Ehrenamt/ff-admin-server
2
0
Fork 0
Code Issues 16 Pull requests Projects Releases 35 Packages Wiki Activity Actions

update newsletter syncing commands and controller

Browse source
This commit is contained in:
Julian Krauser 2024-12-26 12:34:31 +01:00
parent 4180da5749
commit 6dcd650cad
9 changed files with 16 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/command/newsletterRecipientsCommand.ts
View file

@ -1,9 +1,4 @@
export interface SynchronizeNewsletterRecipientsCommand {
newsletterId: number;
recipients: Array<NewsletterRecipientCommand>;
}
export interface NewsletterRecipientCommand {
memberId: number;
addedManually: boolean;
recipients: Array<number>;
}

43
src/command/newsletterRecipientsCommandHandler.ts
View file

@ -2,7 +2,7 @@ import { DeleteResult, EntityManager, InsertResult, UpdateResult } from "typeorm
import { dataSource } from "../data-source";
import InternalException from "../exceptions/internalException";
import NewsletterRecipientsService from "../service/newsletterRecipientsService";
import { NewsletterRecipientCommand, SynchronizeNewsletterRecipientsCommand } from "./newsletterRecipientsCommand";
import { SynchronizeNewsletterRecipientsCommand } from "./newsletterRecipientsCommand";
import { newsletterRecipients } from "../entity/newsletterRecipients";
export default abstract class NewsletterRecipientsCommandHandler {
@ -12,18 +12,17 @@ export default abstract class NewsletterRecipientsCommandHandler {
* @returns {Promise<void>}
*/
static async sync(syncNewsletterRecipients: SynchronizeNewsletterRecipientsCommand): Promise<void> {
let currentRecipients = await NewsletterRecipientsService.getAll(syncNewsletterRecipients.newsletterId);
let currentRecipients = (await NewsletterRecipientsService.getAll(syncNewsletterRecipients.newsletterId)).map(
(r) => r.memberId
);
return await dataSource.manager
.transaction(async (manager) => {
let newRecipients = syncNewsletterRecipients.recipients.filter(
(r) => !currentRecipients.map((np) => np.memberId).includes(r.memberId)
(r) => !currentRecipients.map((np) => np).includes(r)
);
let removeRecipients = currentRecipients.filter(
(r) => !syncNewsletterRecipients.recipients.map((np) => np.memberId).includes(r.memberId)
);
let keptRecipients = currentRecipients.filter((r) =>
syncNewsletterRecipients.recipients.map((np) => np.memberId).includes(r.memberId)
(r) => !syncNewsletterRecipients.recipients.map((np) => np).includes(r)
);
if (newRecipients.length != 0) {
@ -33,10 +32,6 @@ export default abstract class NewsletterRecipientsCommandHandler {
if (removeRecipients.length != 0) {
await this.syncPresenceRemove(manager, syncNewsletterRecipients.newsletterId, removeRecipients);
}
for (const recipient of keptRecipients) {
await this.syncPresenceUpdate(manager, syncNewsletterRecipients.newsletterId, recipient);
}
})
.then(() => {})
.catch((err) => {
@ -47,47 +42,31 @@ export default abstract class NewsletterRecipientsCommandHandler {
private static async syncPresenceAdd(
manager: EntityManager,
newsletterId: number,
recipients: Array<NewsletterRecipientCommand>
recipients: Array<number>
): Promise<InsertResult> {
return await manager
.createQueryBuilder()
.insert()
.into(newsletterRecipients)
.values(
recipients.map((d) => ({
...d,
recipients.map((r) => ({
memberId: r,
newsletterId: newsletterId,
}))
)
.execute();
}
private static async syncPresenceUpdate(
manager: EntityManager,
newsletterId: number,
recipient: NewsletterRecipientCommand
): Promise<UpdateResult> {
return await manager
.createQueryBuilder()
.update(newsletterRecipients)
.set({
addedManually: recipient.addedManually,
})
.where("memberId = :memberId", { memberId: recipient.memberId })
.andWhere("newsletterId = :newsletterId", { newsletterId })
.execute();
}
private static async syncPresenceRemove(
manager: EntityManager,
newsletterId: number,
recipients: Array<NewsletterRecipientCommand>
recipients: Array<number>
): Promise<DeleteResult> {
return await manager
.createQueryBuilder()
.delete()
.from(newsletterRecipients)
.where("memberId IN (:...ids)", { ids: recipients.map((d) => d.memberId) })
.where("memberId IN (:...ids)", { ids: recipients })
.andWhere("newsletterId = :newsletterId", { newsletterId })
.execute();
}