ff-admin-server/src/command/newsletterRecipientsCommandHandler.ts

import { DeleteResult, EntityManager, InsertResult, UpdateResult } from "typeorm";
import { dataSource } from "../data-source";
import InternalException from "../exceptions/internalException";
import NewsletterRecipientsService from "../service/newsletterRecipientsService";
import { SynchronizeNewsletterRecipientsCommand } from "./newsletterRecipientsCommand";
import { newsletterRecipients } from "../entity/newsletterRecipients";

export default abstract class NewsletterRecipientsCommandHandler {
  /**
   * @description sync newsletterRecipients
   * @param {SynchronizeNewsletterRecipientsCommand} syncNewsletterRecipients
   * @returns {Promise<void>}
   */
  static async sync(syncNewsletterRecipients: SynchronizeNewsletterRecipientsCommand): Promise<void> {
    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).includes(r)
        );
        let removeRecipients = currentRecipients.filter(
          (r) => !syncNewsletterRecipients.recipients.map((np) => np).includes(r)
        );

        if (newRecipients.length != 0) {
          await this.syncPresenceAdd(manager, syncNewsletterRecipients.newsletterId, newRecipients);
        }

        if (removeRecipients.length != 0) {
          await this.syncPresenceRemove(manager, syncNewsletterRecipients.newsletterId, removeRecipients);
        }
      })
      .then(() => {})
      .catch((err) => {
        throw new InternalException("Failed syncing newsletter recipients", err);
      });
  }

  private static async syncPresenceAdd(
    manager: EntityManager,
    newsletterId: number,
    recipients: Array<number>
  ): Promise<InsertResult> {
    return await manager
      .createQueryBuilder()
      .insert()
      .into(newsletterRecipients)
      .values(
        recipients.map((r) => ({
          memberId: r,
          newsletterId: newsletterId,
        }))
      )
      .execute();
  }

  private static async syncPresenceRemove(
    manager: EntityManager,
    newsletterId: number,
    recipients: Array<number>
  ): Promise<DeleteResult> {
    return await manager
      .createQueryBuilder()
      .delete()
      .from(newsletterRecipients)
      .where("memberId IN (:...ids)", { ids: recipients })
      .andWhere("newsletterId = :newsletterId", { newsletterId })
      .execute();
  }
}