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 { PdfExport } from "../../helpers/pdfExport";
import UserService from "../../service/userService";
import { TemplateHelper } from "../../helpers/templateHelper";
import MailHelper from "../../helpers/mailHelper";

/**
 * @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 recipients 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 recipients = await NewsletterRecipientsService.getAll(newsletterId);

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

/**
 * @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 printout preview by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function createNewsletterPrintoutPreviewById(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 recipient = await UserService.getById(parseInt(req.userId));

  let data = {
    title: newsletter.title,
    description: newsletter.description,
    newsletterTitle: newsletter.newsletterTitle,
    newsletterText: newsletter.newsletterText,
    newsletterSignatur: newsletter.newsletterSignatur,
    dates: dates.map((d) => ({
      title: d.diffTitle ?? d.calendar.title,
      content: d.diffDescription ?? d.calendar.content,
      starttime: d.calendar.starttime,
      formattedStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
      }),
      formattedFullStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
        year: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      }),
      endtime: d.calendar.endtime,
      formattedEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
      }),
      formattedFullEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
        year: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      }),
      location: d.calendar.location,
    })),
    recipient: {
      firstname: recipient.firstname,
      lastname: recipient.lastname,
      salutation: "none",
      nameaffix: "",
      street: "Straße",
      streetNumber: "Hausnummer",
      streetNumberAdd: "Adresszusatz",
    },
  };

  let pdf = await PdfExport.renderFile({
    title: "Probedruck Newsletter",
    template: "newsletter",
    saveToDisk: false,
    data: data,
  });

  let pdfbuffer = Buffer.from(pdf);

  res.setHeader("Content-Type", "application/pdf");
  res.setHeader("Content-Length", pdfbuffer.byteLength);
  res.setHeader("Content-Disposition", "inline; filename=preview.pdf");

  res.send(pdfbuffer);
}

/**
 * @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 printouts for each member 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
  // default template

  res.sendStatus(204);
}

/**
 * @description create newsletter mail preview by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function createNewsletterMailPreviewById(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 recipient = await UserService.getById(parseInt(req.userId));

  let data = {
    title: newsletter.title,
    description: newsletter.description,
    newsletterTitle: newsletter.newsletterTitle,
    newsletterText: newsletter.newsletterText,
    newsletterSignatur: newsletter.newsletterSignatur,
    dates: dates.map((d) => ({
      title: d.diffTitle ?? d.calendar.title,
      content: d.diffDescription ?? d.calendar.content,
      starttime: d.calendar.starttime,
      formattedStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
      }),
      formattedFullStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
        year: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      }),
      endtime: d.calendar.endtime,
      formattedEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
      }),
      formattedFullEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
        weekday: "long",
        day: "2-digit",
        month: "long",
        year: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      }),
      location: d.calendar.location,
    })),
    recipient: {
      firstname: recipient.firstname,
      lastname: recipient.lastname,
      salutation: "none",
      nameaffix: "",
      street: "Straße",
      streetNumber: "Hausnummer",
      streetNumberAdd: "Adresszusatz",
    },
  };

  const { body } = await TemplateHelper.renderFileForModule({
    module: "newsletter",
    bodyData: data,
    title: "Probeversand Newsletter",
  });

  await MailHelper.sendMail(recipient.mail, "Probeversand Newsletter", body);

  res.sendStatus(204);
}

/**
 * @description send newsletter mail and create printouts by id
 * @param req {Request} Express req object
 * @param res {Response} Express res object
 * @returns {Promise<*>}
 */
export async function sendNewsletterById(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);

  // attach ics files for date entries to mail

  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);

  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<number>;

  let syncRecipients: SynchronizeNewsletterRecipientsCommand = {
    newsletterId,
    recipients: recipients,
  };
  await NewsletterRecipientsCommandHandler.sync(syncRecipients);

  res.sendStatus(204);
}