ff-admin-server/src/controller/admin/newsletterController.ts

import { Request, Response } from "express";
import NewsletterService from "../../service/newsletterService";
import NewsletterFactory from "../../factory/admin/newsletter";
import NewsletterDatesService from "../../service/newsletterDatesService";
import NewsletterDatesFactory from "../../factory/admin/newsletterDates";
import NewsletterRecipientsService from "../../service/newsletterRecipientsService";
import NewsletterRecipientsFactory from "../../factory/admin/newsletterRecipients";
import { FileSystemHelper } from "../../helpers/fileSystemHelper";
import { CreateNewsletterCommand, SynchronizeNewsletterCommand } from "../../command/newsletterCommand";
import NewsletterCommandHandler from "../../command/newsletterCommandHandler";
import { SynchronizeNewsletterDatesCommand } from "../../command/newsletterDatesCommand";
import NewsletterDatesCommandHandler from "../../command/newsletterDatesCommandHandler";
import { SynchronizeNewsletterRecipientsCommand } from "../../command/newsletterRecipientsCommand";
import NewsletterRecipientsCommandHandler from "../../command/newsletterRecipientsCommandHandler";
import { NewsletterDatesViewModel } from "../../viewmodel/admin/newsletterDates.models";
import { NewsletterRecipientsViewModel } from "../../viewmodel/admin/newsletterRecipients.models";

/**
 * @description get all newsletters
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getAllNewsletters(req: Request, res: Response): Promise<any> {
  let offset = parseInt((req.query.offset as string) ?? "0");
  let count = parseInt((req.query.count as string) ?? "25");
  let [newsletters, total] = await NewsletterService.getAll(offset, count);

  res.json({
    newsletters: NewsletterFactory.mapToBase(newsletters),
    total: total,
    offset: offset,
    count: count,
  });
}

/**
 * @description get newsletter by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getNewsletterById(req: Request, res: Response): Promise<any> {
  let id = parseInt(req.params.id);
  let newsletter = await NewsletterService.getById(id);

  res.json(NewsletterFactory.mapToSingle(newsletter));
}

/**
 * @description get newsletter dates by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getNewsletterDatesById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);

  let dates = await NewsletterDatesService.getAll(newsletterId);

  res.json(NewsletterDatesFactory.mapToBase(dates));
}

/**
 * @description get newsletter recipientss by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getNewsletterRecipientsById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);

  let recipientss = await NewsletterRecipientsService.getAll(newsletterId);

  res.json(NewsletterRecipientsFactory.mapToBase(recipientss));
}

/**
 * @description get newsletter printouts by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getNewsletterPrintoutsById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);

  let newsletter = await NewsletterService.getById(newsletterId);

  let folderPath = FileSystemHelper.formatPath("export", "newsletter", `${newsletter.id}_${newsletter.title}`);
  let filesInFolder = FileSystemHelper.getFilesInDirectory(folderPath);

  res.json(filesInFolder);
}

/**
 * @description get newsletter printout by id and print
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function getNewsletterPrintoutByIdAndPrint(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);
  let filename = req.params.filename;

  let newsletter = await NewsletterService.getById(newsletterId);

  let filepath = FileSystemHelper.formatPath("export", "newsletter", `${newsletter.id}_${newsletter.title}`, filename);

  res.sendFile(process.cwd() + filepath, {
    headers: {
      "Content-Type": "application/pdf",
    },
  });
}

/**
 * @description create newsletter
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function createNewsletter(req: Request, res: Response): Promise<any> {
  let title = req.body.title;

  let createNewsletter: CreateNewsletterCommand = {
    title,
  };
  let id = await NewsletterCommandHandler.create(createNewsletter);

  res.send(id);
}

/**
 * @description create newsletter printout by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function createNewsletterPrintoutById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);
  let newsletter = await NewsletterService.getById(newsletterId);
  let dates = await NewsletterDatesService.getAll(newsletterId);
  let recipients = await NewsletterRecipientsService.getAll(newsletterId);

  // print newsletter pdf for every member having newsletter type configured to print or if all members get printout
  // check if all users have mail or adress
  // squash all files to single for printing
  // use Helper for Newsletter printing and mail sending

  res.sendStatus(204);
}

/**
 * @description synchronize newsletter by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function synchronizeNewsletterById(req: Request, res: Response): Promise<any> {
  let id = parseInt(req.params.id);
  let title = req.body.title;
  let description = req.body.description;
  let newsletterTitle = req.body.newsletterTitle;
  let newsletterText = req.body.newsletterText;
  let newsletterSignatur = req.body.newsletterSignatur;
  let recipientsByQueryId = req.body.recipientsByQueryId ?? null;

  let syncNewsletter: SynchronizeNewsletterCommand = {
    id,
    title,
    description,
    newsletterTitle,
    newsletterText,
    newsletterSignatur,
    recipientsByQueryId,
  };
  await NewsletterCommandHandler.sync(syncNewsletter);

  if (recipientsByQueryId) {
    // TODO! set all recipients to query selection
  }

  res.sendStatus(204);
}

/**
 * @description synchronize newsletter dates by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function synchronizeNewsletterDatesById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);
  let dates = req.body.dates as Array<NewsletterDatesViewModel>;

  let syncDates: SynchronizeNewsletterDatesCommand = {
    newsletterId,
    dates: dates.map((d) => ({
      calendarId: d.calendarId,
      diffTitle: d.diffTitle,
      diffDescription: d.diffDescription,
    })),
  };
  await NewsletterDatesCommandHandler.sync(syncDates);

  res.sendStatus(204);
}

/**
 * @description synchronize newsletter recipients by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function synchronizeNewsletterRecipientsById(req: Request, res: Response): Promise<any> {
  let newsletterId = parseInt(req.params.newsletterId);
  let recipients = req.body.recipients as Array<NewsletterRecipientsViewModel>;

  let syncRecipients: SynchronizeNewsletterRecipientsCommand = {
    newsletterId,
    recipients: recipients.map((r) => ({
      memberId: r.memberId,
      addedManually: r.addedManually,
    })),
  };
  await NewsletterRecipientsCommandHandler.sync(syncRecipients);

  res.sendStatus(204);
}