From 160d82459d0b25aa521a7ee9b107d400cdb8345d Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Sun, 22 Dec 2024 10:29:42 +0100
Subject: [PATCH 01/16] template storing

---
 src/command/templateCommand.ts             | 18 ++++
 src/command/templateCommandHandler.ts      | 72 ++++++++++++++++
 src/controller/admin/templateController.ts | 95 ++++++++++++++++++++++
 src/data-source.ts                         |  4 +
 src/entity/template.ts                     | 36 ++++++++
 src/factory/admin/template.ts              | 30 +++++++
 src/migrations/1734854680201-template.ts   | 30 +++++++
 src/routes/admin/index.ts                  |  2 +
 src/routes/admin/template.ts               | 45 ++++++++++
 src/service/templateService.ts             | 41 ++++++++++
 src/type/permissionTypes.ts                |  5 +-
 src/viewmodel/admin/template.models.ts     |  9 ++
 12 files changed, 386 insertions(+), 1 deletion(-)
 create mode 100644 src/command/templateCommand.ts
 create mode 100644 src/command/templateCommandHandler.ts
 create mode 100644 src/controller/admin/templateController.ts
 create mode 100644 src/entity/template.ts
 create mode 100644 src/factory/admin/template.ts
 create mode 100644 src/migrations/1734854680201-template.ts
 create mode 100644 src/routes/admin/template.ts
 create mode 100644 src/service/templateService.ts
 create mode 100644 src/viewmodel/admin/template.models.ts

diff --git a/src/command/templateCommand.ts b/src/command/templateCommand.ts
new file mode 100644
index 0000000..9823d20
--- /dev/null
+++ b/src/command/templateCommand.ts
@@ -0,0 +1,18 @@
+export interface CreateTemplateCommand {
+  template: string;
+  description: string | null;
+}
+
+export interface UpdateTemplateCommand {
+  id: number;
+  template: string;
+  description: string | null;
+  design: object;
+  headerHTML: string;
+  bodyHTML: string;
+  footerHTML: string;
+}
+
+export interface DeleteTemplateCommand {
+  id: number;
+}
diff --git a/src/command/templateCommandHandler.ts b/src/command/templateCommandHandler.ts
new file mode 100644
index 0000000..3cf9871
--- /dev/null
+++ b/src/command/templateCommandHandler.ts
@@ -0,0 +1,72 @@
+import { dataSource } from "../data-source";
+import { template } from "../entity/template";
+import InternalException from "../exceptions/internalException";
+import { CreateTemplateCommand, DeleteTemplateCommand, UpdateTemplateCommand } from "./templateCommand";
+
+export default abstract class TemplateCommandHandler {
+  /**
+   * @description create template
+   * @param CreateTemplateCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createTemplate: CreateTemplateCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(template)
+      .values({
+        template: createTemplate.template,
+        description: createTemplate.description,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating template", err);
+      });
+  }
+
+  /**
+   * @description update template
+   * @param UpdateTemplateCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateTemplate: UpdateTemplateCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(template)
+      .set({
+        template: updateTemplate.template,
+        description: updateTemplate.description,
+        design: updateTemplate.design,
+        headerHTML: updateTemplate.headerHTML,
+        bodyHTML: updateTemplate.bodyHTML,
+        footerHTML: updateTemplate.footerHTML,
+      })
+      .where("id = :id", { id: updateTemplate.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating template", err);
+      });
+  }
+
+  /**
+   * @description delete template
+   * @param DeleteTemplateCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletTemplate: DeleteTemplateCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(template)
+      .where("id = :id", { id: deletTemplate.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting template", err);
+      });
+  }
+}
diff --git a/src/controller/admin/templateController.ts b/src/controller/admin/templateController.ts
new file mode 100644
index 0000000..6f46ae6
--- /dev/null
+++ b/src/controller/admin/templateController.ts
@@ -0,0 +1,95 @@
+import { Request, Response } from "express";
+import TemplateService from "../../service/templateService";
+import TemplateFactory from "../../factory/admin/template";
+import { CreateTemplateCommand, DeleteTemplateCommand, UpdateTemplateCommand } from "../../command/templateCommand";
+import TemplateCommandHandler from "../../command/templateCommandHandler";
+
+/**
+ * @description get all templates
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllTemplates(req: Request, res: Response): Promise<any> {
+  let templates = await TemplateService.getAll();
+
+  res.json(TemplateFactory.mapToBase(templates));
+}
+
+/**
+ * @description get template by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getTemplateById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let template = await TemplateService.getById(id);
+
+  res.json(TemplateFactory.mapToSingle(template));
+}
+
+/**
+ * @description create new template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createTemplate(req: Request, res: Response): Promise<any> {
+  const template = req.body.template;
+  const description = req.body.description;
+
+  let createTemplate: CreateTemplateCommand = {
+    template: template,
+    description: description,
+  };
+  let id = await TemplateCommandHandler.create(createTemplate);
+
+  res.status(200).send(id);
+}
+
+/**
+ * @description update template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateTemplate(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const template = req.body.template;
+  const description = req.body.description;
+  const design = req.body.design;
+  const headerHTML = req.body.headerHTML;
+  const bodyHTML = req.body.bodyHTML;
+  const footerHTML = req.body.footerHTML;
+
+  let updateTemplate: UpdateTemplateCommand = {
+    id: id,
+    template: template,
+    description: description,
+    design: design,
+    headerHTML: headerHTML,
+    bodyHTML: bodyHTML,
+    footerHTML: footerHTML,
+  };
+  await TemplateCommandHandler.update(updateTemplate);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteTemplate(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteTemplate: DeleteTemplateCommand = {
+    id: id,
+  };
+  await TemplateCommandHandler.delete(deleteTemplate);
+
+  res.sendStatus(204);
+}
diff --git a/src/data-source.ts b/src/data-source.ts
index 685d05c..0b29b2c 100644
--- a/src/data-source.ts
+++ b/src/data-source.ts
@@ -51,6 +51,8 @@ import { memberExecutivePositionsView } from "./views/memberExecutivePositionVie
 import { memberQualificationsView } from "./views/memberQualificationsView";
 import { membershipView } from "./views/membershipsView";
 import { MemberDataViews1734520998539 } from "./migrations/1734520998539-memberDataViews";
+import { template } from "./entity/template";
+import { Template1734854680201 } from "./migrations/1734854680201-template";
 
 const dataSource = new DataSource({
   type: DB_TYPE as any,
@@ -90,6 +92,7 @@ const dataSource = new DataSource({
     calendar,
     calendarType,
     query,
+    template,
     memberView,
     memberExecutivePositionsView,
     memberQualificationsView,
@@ -112,6 +115,7 @@ const dataSource = new DataSource({
     SecuringCalendarType1733249553766,
     QueryStore1734187754677,
     MemberDataViews1734520998539,
+    Template1734854680201,
   ],
   migrationsRun: true,
   migrationsTransactionMode: "each",
diff --git a/src/entity/template.ts b/src/entity/template.ts
new file mode 100644
index 0000000..2b5d366
--- /dev/null
+++ b/src/entity/template.ts
@@ -0,0 +1,36 @@
+import { Column, Entity, PrimaryColumn } from "typeorm";
+
+@Entity()
+export class template {
+  @PrimaryColumn({ generated: "increment", type: "int" })
+  id: number;
+
+  @Column({ type: "varchar", length: 255 })
+  template: string;
+
+  @Column({ type: "varchar", length: 255, nullable: true })
+  description?: string;
+
+  @Column({
+    type: "text",
+    default: "{}",
+    transformer: {
+      to(value: object) {
+        return JSON.stringify(value);
+      },
+      from(value: string) {
+        return JSON.parse(value);
+      },
+    },
+  })
+  design: object;
+
+  @Column({ type: "text", default: "" })
+  headerHTML: string;
+
+  @Column({ type: "text", default: "" })
+  bodyHTML: string;
+
+  @Column({ type: "text", default: "" })
+  footerHTML: string;
+}
diff --git a/src/factory/admin/template.ts b/src/factory/admin/template.ts
new file mode 100644
index 0000000..c1d721d
--- /dev/null
+++ b/src/factory/admin/template.ts
@@ -0,0 +1,30 @@
+import { template } from "../../entity/template";
+import { TemplateViewModel } from "../../viewmodel/admin/template.models";
+
+export default abstract class TemplateFactory {
+  /**
+   * @description map record to template
+   * @param {template} record
+   * @returns {TemplateViewModel}
+   */
+  public static mapToSingle(record: template): TemplateViewModel {
+    return {
+      id: record.id,
+      template: record.template,
+      description: record.description,
+      design: record.design,
+      headerHTML: record.headerHTML,
+      bodyHTML: record.bodyHTML,
+      footerHTML: record.footerHTML,
+    };
+  }
+
+  /**
+   * @description map records to template
+   * @param {Array<template>} records
+   * @returns {Array<TemplateViewModel>}
+   */
+  public static mapToBase(records: Array<template>): Array<TemplateViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/migrations/1734854680201-template.ts b/src/migrations/1734854680201-template.ts
new file mode 100644
index 0000000..df30687
--- /dev/null
+++ b/src/migrations/1734854680201-template.ts
@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner, Table } from "typeorm";
+import { DB_TYPE } from "../env.defaults";
+
+export class Template1734854680201 implements MigrationInterface {
+  name = "Template1734854680201";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
+
+    await queryRunner.createTable(
+      new Table({
+        name: "template",
+        columns: [
+          { name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
+          { name: "template", type: "varchar", length: "255", isNullable: false },
+          { name: "description", type: "varchar", length: "255", isNullable: true },
+          { name: "design", type: "text", isNullable: false, default: "'{}'" },
+          { name: "headerHTML", type: "text", isNullable: false, default: "''" },
+          { name: "bodyHTML", type: "text", isNullable: false, default: "''" },
+          { name: "footerHTML", type: "text", isNullable: false, default: "''" },
+        ],
+      }),
+      true
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable("template");
+  }
+}
diff --git a/src/routes/admin/index.ts b/src/routes/admin/index.ts
index 193213e..c51f08c 100644
--- a/src/routes/admin/index.ts
+++ b/src/routes/admin/index.ts
@@ -8,6 +8,7 @@ import membershipStatus from "./membershipStatus";
 import qualification from "./qualification";
 import calendarType from "./calendarType";
 import queryStore from "./queryStore";
+import template from "./template";
 
 import member from "./member";
 import protocol from "./protocol";
@@ -39,6 +40,7 @@ router.use(
 router.use("/qualification", PermissionHelper.passCheckMiddleware("read", "settings", "qualification"), qualification);
 router.use("/calendartype", PermissionHelper.passCheckMiddleware("read", "settings", "calendar_type"), calendarType);
 router.use("/querystore", PermissionHelper.passCheckMiddleware("read", "settings", "query_store"), queryStore);
+router.use("/template", PermissionHelper.passCheckMiddleware("read", "settings", "template"), template);
 
 router.use("/member", PermissionHelper.passCheckMiddleware("read", "club", "member"), member);
 router.use("/protocol", PermissionHelper.passCheckMiddleware("read", "club", "protocol"), protocol);
diff --git a/src/routes/admin/template.ts b/src/routes/admin/template.ts
new file mode 100644
index 0000000..1653956
--- /dev/null
+++ b/src/routes/admin/template.ts
@@ -0,0 +1,45 @@
+import express, { Request, Response } from "express";
+import {
+  createTemplate,
+  deleteTemplate,
+  getAllTemplates,
+  getTemplateById,
+  updateTemplate,
+} from "../../controller/admin/templateController";
+import PermissionHelper from "../../helpers/permissionHelper";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllTemplates(req, res);
+});
+
+router.get("/:id", async (req: Request, res: Response) => {
+  await getTemplateById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "settings", "template"),
+  async (req: Request, res: Response) => {
+    await createTemplate(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "settings", "template"),
+  async (req: Request, res: Response) => {
+    await updateTemplate(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "settings", "template"),
+  async (req: Request, res: Response) => {
+    await deleteTemplate(req, res);
+  }
+);
+
+export default router;
diff --git a/src/service/templateService.ts b/src/service/templateService.ts
new file mode 100644
index 0000000..52517bc
--- /dev/null
+++ b/src/service/templateService.ts
@@ -0,0 +1,41 @@
+import { dataSource } from "../data-source";
+import { template } from "../entity/template";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class TemplateService {
+  /**
+   * @description get all templates
+   * @returns {Promise<Array<template>>}
+   */
+  static async getAll(): Promise<Array<template>> {
+    return await dataSource
+      .getRepository(template)
+      .createQueryBuilder("template")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("templates not found", err);
+      });
+  }
+
+  /**
+   * @description get template by id
+   * @returns {Promise<template>}
+   */
+  static async getById(id: number): Promise<template> {
+    return await dataSource
+      .getRepository(template)
+      .createQueryBuilder("template")
+      .where("template.id = :id", { id: id })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("template not found by id", err);
+      });
+  }
+}
diff --git a/src/type/permissionTypes.ts b/src/type/permissionTypes.ts
index d5bb35e..62fbc51 100644
--- a/src/type/permissionTypes.ts
+++ b/src/type/permissionTypes.ts
@@ -14,7 +14,8 @@ export type PermissionModule =
   | "user"
   | "role"
   | "query"
-  | "query_store";
+  | "query_store"
+  | "template";
 
 export type PermissionType = "read" | "create" | "update" | "delete";
 
@@ -53,6 +54,7 @@ export const permissionModules: Array<PermissionModule> = [
   "role",
   "query",
   "query_store",
+  "template",
 ];
 export const permissionTypes: Array<PermissionType> = ["read", "create", "update", "delete"];
 export const sectionsAndModules: SectionsAndModulesObject = {
@@ -65,6 +67,7 @@ export const sectionsAndModules: SectionsAndModulesObject = {
     "membership_status",
     "calendar_type",
     "query_store",
+    "template",
   ],
   user: ["user", "role"],
 };
diff --git a/src/viewmodel/admin/template.models.ts b/src/viewmodel/admin/template.models.ts
new file mode 100644
index 0000000..264a1bb
--- /dev/null
+++ b/src/viewmodel/admin/template.models.ts
@@ -0,0 +1,9 @@
+export interface TemplateViewModel {
+  id: number;
+  template: string;
+  description: string | null;
+  design: object;
+  headerHTML: string;
+  bodyHTML: string;
+  footerHTML: string;
+}

From 5f18e614be64937c774e9e3da73739074feaa24d Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Sun, 22 Dec 2024 17:29:11 +0100
Subject: [PATCH 02/16] changed data structure to single html

---
 src/command/templateCommand.ts             | 4 +---
 src/command/templateCommandHandler.ts      | 4 +---
 src/controller/admin/templateController.ts | 8 ++------
 src/entity/template.ts                     | 8 +-------
 src/factory/admin/template.ts              | 4 +---
 src/migrations/1734854680201-template.ts   | 4 +---
 src/viewmodel/admin/template.models.ts     | 4 +---
 7 files changed, 8 insertions(+), 28 deletions(-)

diff --git a/src/command/templateCommand.ts b/src/command/templateCommand.ts
index 9823d20..55a5f44 100644
--- a/src/command/templateCommand.ts
+++ b/src/command/templateCommand.ts
@@ -8,9 +8,7 @@ export interface UpdateTemplateCommand {
   template: string;
   description: string | null;
   design: object;
-  headerHTML: string;
-  bodyHTML: string;
-  footerHTML: string;
+  html: string;
 }
 
 export interface DeleteTemplateCommand {
diff --git a/src/command/templateCommandHandler.ts b/src/command/templateCommandHandler.ts
index 3cf9871..1f9b4ce 100644
--- a/src/command/templateCommandHandler.ts
+++ b/src/command/templateCommandHandler.ts
@@ -40,9 +40,7 @@ export default abstract class TemplateCommandHandler {
         template: updateTemplate.template,
         description: updateTemplate.description,
         design: updateTemplate.design,
-        headerHTML: updateTemplate.headerHTML,
-        bodyHTML: updateTemplate.bodyHTML,
-        footerHTML: updateTemplate.footerHTML,
+        html: updateTemplate.html,
       })
       .where("id = :id", { id: updateTemplate.id })
       .execute()
diff --git a/src/controller/admin/templateController.ts b/src/controller/admin/templateController.ts
index 6f46ae6..9c8a2a0 100644
--- a/src/controller/admin/templateController.ts
+++ b/src/controller/admin/templateController.ts
@@ -59,18 +59,14 @@ export async function updateTemplate(req: Request, res: Response): Promise<any>
   const template = req.body.template;
   const description = req.body.description;
   const design = req.body.design;
-  const headerHTML = req.body.headerHTML;
-  const bodyHTML = req.body.bodyHTML;
-  const footerHTML = req.body.footerHTML;
+  const html = req.body.html;
 
   let updateTemplate: UpdateTemplateCommand = {
     id: id,
     template: template,
     description: description,
     design: design,
-    headerHTML: headerHTML,
-    bodyHTML: bodyHTML,
-    footerHTML: footerHTML,
+    html: html,
   };
   await TemplateCommandHandler.update(updateTemplate);
 
diff --git a/src/entity/template.ts b/src/entity/template.ts
index 2b5d366..6a25724 100644
--- a/src/entity/template.ts
+++ b/src/entity/template.ts
@@ -26,11 +26,5 @@ export class template {
   design: object;
 
   @Column({ type: "text", default: "" })
-  headerHTML: string;
-
-  @Column({ type: "text", default: "" })
-  bodyHTML: string;
-
-  @Column({ type: "text", default: "" })
-  footerHTML: string;
+  html: string;
 }
diff --git a/src/factory/admin/template.ts b/src/factory/admin/template.ts
index c1d721d..7da05e0 100644
--- a/src/factory/admin/template.ts
+++ b/src/factory/admin/template.ts
@@ -13,9 +13,7 @@ export default abstract class TemplateFactory {
       template: record.template,
       description: record.description,
       design: record.design,
-      headerHTML: record.headerHTML,
-      bodyHTML: record.bodyHTML,
-      footerHTML: record.footerHTML,
+      html: record.html,
     };
   }
 
diff --git a/src/migrations/1734854680201-template.ts b/src/migrations/1734854680201-template.ts
index df30687..7ccd1e9 100644
--- a/src/migrations/1734854680201-template.ts
+++ b/src/migrations/1734854680201-template.ts
@@ -15,9 +15,7 @@ export class Template1734854680201 implements MigrationInterface {
           { name: "template", type: "varchar", length: "255", isNullable: false },
           { name: "description", type: "varchar", length: "255", isNullable: true },
           { name: "design", type: "text", isNullable: false, default: "'{}'" },
-          { name: "headerHTML", type: "text", isNullable: false, default: "''" },
-          { name: "bodyHTML", type: "text", isNullable: false, default: "''" },
-          { name: "footerHTML", type: "text", isNullable: false, default: "''" },
+          { name: "html", type: "text", isNullable: false, default: "''" },
         ],
       }),
       true
diff --git a/src/viewmodel/admin/template.models.ts b/src/viewmodel/admin/template.models.ts
index 264a1bb..eb1ceaa 100644
--- a/src/viewmodel/admin/template.models.ts
+++ b/src/viewmodel/admin/template.models.ts
@@ -3,7 +3,5 @@ export interface TemplateViewModel {
   template: string;
   description: string | null;
   design: object;
-  headerHTML: string;
-  bodyHTML: string;
-  footerHTML: string;
+  html: string;
 }

From 6cb8ca0a125b2412c2a431b219e221a4fb66df1c Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Mon, 23 Dec 2024 14:00:50 +0100
Subject: [PATCH 03/16] template preparation

---
 src/command/templateUsageCommand.ts           |  6 ++
 src/command/templateUsageCommandHandler.ts    | 28 +++++++
 src/controller/admin/protocolController.ts    |  2 +-
 .../admin/templateUsageController.ts          | 64 ++++++++++++++++
 src/data-source.ts                            |  4 +
 src/entity/member.ts                          |  2 +-
 src/entity/templateUsage.ts                   | 39 ++++++++++
 src/factory/admin/templateUsage.ts            | 27 +++++++
 src/helpers/pdfExport.ts                      | 30 +++-----
 src/helpers/templateHelper.ts                 | 76 +++++++++++++++++++
 src/migrations/1734949173739-templateUsage.ts | 75 ++++++++++++++++++
 src/routes/admin/index.ts                     |  2 +
 src/routes/admin/templateUsage.ts             | 21 +++++
 src/service/templateUsageService.ts           | 46 +++++++++++
 src/type/permissionTypes.ts                   |  5 +-
 src/viewmodel/admin/templateUsage.models.ts   |  8 ++
 16 files changed, 414 insertions(+), 21 deletions(-)
 create mode 100644 src/command/templateUsageCommand.ts
 create mode 100644 src/command/templateUsageCommandHandler.ts
 create mode 100644 src/controller/admin/templateUsageController.ts
 create mode 100644 src/entity/templateUsage.ts
 create mode 100644 src/factory/admin/templateUsage.ts
 create mode 100644 src/helpers/templateHelper.ts
 create mode 100644 src/migrations/1734949173739-templateUsage.ts
 create mode 100644 src/routes/admin/templateUsage.ts
 create mode 100644 src/service/templateUsageService.ts
 create mode 100644 src/viewmodel/admin/templateUsage.models.ts

diff --git a/src/command/templateUsageCommand.ts b/src/command/templateUsageCommand.ts
new file mode 100644
index 0000000..b9218a9
--- /dev/null
+++ b/src/command/templateUsageCommand.ts
@@ -0,0 +1,6 @@
+export interface UpdateTemplateUsageCommand {
+  scope: string;
+  headerId: number | null;
+  bodyId: number | null;
+  footerId: number | null;
+}
diff --git a/src/command/templateUsageCommandHandler.ts b/src/command/templateUsageCommandHandler.ts
new file mode 100644
index 0000000..54626ba
--- /dev/null
+++ b/src/command/templateUsageCommandHandler.ts
@@ -0,0 +1,28 @@
+import { dataSource } from "../data-source";
+import { templateUsage } from "../entity/templateUsage";
+import InternalException from "../exceptions/internalException";
+import { UpdateTemplateUsageCommand } from "./templateUsageCommand";
+
+export default abstract class TemplateUsageCommandHandler {
+  /**
+   * @description update templateUsage
+   * @param UpdateTemplateUsageCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateTemplateUsage: UpdateTemplateUsageCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(templateUsage)
+      .set({
+        headerId: updateTemplateUsage.headerId,
+        bodyId: updateTemplateUsage.bodyId,
+        footerId: updateTemplateUsage.footerId,
+      })
+      .where("scope = :scope", { scope: updateTemplateUsage.scope })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating templateUsage", err);
+      });
+  }
+}
diff --git a/src/controller/admin/protocolController.ts b/src/controller/admin/protocolController.ts
index 12a5b22..ef5ca3d 100644
--- a/src/controller/admin/protocolController.ts
+++ b/src/controller/admin/protocolController.ts
@@ -237,7 +237,7 @@ export async function createProtocolPrintoutById(req: Request, res: Response): P
   )}`;
 
   await PdfExport.renderFile({
-    template: "protocol.template.html",
+    template: "protocol",
     title,
     filename,
     data: {
diff --git a/src/controller/admin/templateUsageController.ts b/src/controller/admin/templateUsageController.ts
new file mode 100644
index 0000000..0d146d7
--- /dev/null
+++ b/src/controller/admin/templateUsageController.ts
@@ -0,0 +1,64 @@
+import { Request, Response } from "express";
+import TemplateUsageService from "../../service/templateUsageService";
+import TemplateUsageFactory from "../../factory/admin/templateUsage";
+import { UpdateTemplateUsageCommand } from "../../command/templateUsageCommand";
+import TemplateUsageCommandHandler from "../../command/templateUsageCommandHandler";
+import PermissionHelper from "../../helpers/permissionHelper";
+import ForbiddenRequestException from "../../exceptions/forbiddenRequestException";
+import { PermissionModule } from "../../type/permissionTypes";
+
+/**
+ * @description get all templateUsages
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllTemplateUsages(req: Request, res: Response): Promise<any> {
+  let templateUsages = await TemplateUsageService.getAll();
+
+  if (!req.isOwner) {
+    templateUsages = templateUsages.filter((tu) => {
+      return (
+        PermissionHelper.can(req.permissions, "update", "settings", tu.scope) ||
+        PermissionHelper.can(req.permissions, "update", "club", tu.scope)
+      );
+    });
+  }
+
+  res.json(TemplateUsageFactory.mapToBase(templateUsages));
+}
+
+/**
+ * @description update templateUsage
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateTemplateUsage(req: Request, res: Response): Promise<any> {
+  const scope = req.params.scope;
+  let allowedSettings = PermissionHelper.can(
+    req.permissions,
+    "update",
+    "settings",
+    req.params.scope as PermissionModule
+  );
+  let allowedClub = PermissionHelper.can(req.permissions, "update", "club", req.params.scope as PermissionModule);
+
+  if (!(req.isOwner || allowedSettings || allowedClub)) {
+    throw new ForbiddenRequestException(`missing permission for editing scope ${req.params.scope}`);
+  }
+
+  const headerId = req.body.headerId ?? null;
+  const bodyId = req.body.bodyId ?? null;
+  const footerId = req.body.footerId ?? null;
+
+  let updateTemplateUsage: UpdateTemplateUsageCommand = {
+    scope: scope,
+    headerId: headerId,
+    bodyId: bodyId,
+    footerId: footerId,
+  };
+  await TemplateUsageCommandHandler.update(updateTemplateUsage);
+
+  res.sendStatus(204);
+}
diff --git a/src/data-source.ts b/src/data-source.ts
index 0b29b2c..d9567fd 100644
--- a/src/data-source.ts
+++ b/src/data-source.ts
@@ -53,6 +53,8 @@ import { membershipView } from "./views/membershipsView";
 import { MemberDataViews1734520998539 } from "./migrations/1734520998539-memberDataViews";
 import { template } from "./entity/template";
 import { Template1734854680201 } from "./migrations/1734854680201-template";
+import { templateUsage } from "./entity/templateUsage";
+import { TemplateUsage1734949173739 } from "./migrations/1734949173739-templateUsage";
 
 const dataSource = new DataSource({
   type: DB_TYPE as any,
@@ -93,6 +95,7 @@ const dataSource = new DataSource({
     calendarType,
     query,
     template,
+    templateUsage,
     memberView,
     memberExecutivePositionsView,
     memberQualificationsView,
@@ -116,6 +119,7 @@ const dataSource = new DataSource({
     QueryStore1734187754677,
     MemberDataViews1734520998539,
     Template1734854680201,
+    TemplateUsage1734949173739,
   ],
   migrationsRun: true,
   migrationsTransactionMode: "each",
diff --git a/src/entity/member.ts b/src/entity/member.ts
index 7bb0d78..de7f612 100644
--- a/src/entity/member.ts
+++ b/src/entity/member.ts
@@ -40,7 +40,7 @@ export class member {
   birthdate: Date;
 
   @OneToMany(() => communication, (communications) => communications.member)
-  communications: communication;
+  communications: communication[];
 
   @OneToOne(() => communication, {
     nullable: true,
diff --git a/src/entity/templateUsage.ts b/src/entity/templateUsage.ts
new file mode 100644
index 0000000..8aefd11
--- /dev/null
+++ b/src/entity/templateUsage.ts
@@ -0,0 +1,39 @@
+import { Column, Entity, ManyToOne, PrimaryColumn } from "typeorm";
+import { template } from "./template";
+import { PermissionModule } from "../type/permissionTypes";
+
+@Entity()
+export class templateUsage {
+  @PrimaryColumn({ type: "varchar", length: 255 })
+  scope: PermissionModule;
+
+  @Column({ type: "number", nullable: true })
+  headerId: number | null;
+
+  @Column({ type: "number", nullable: true })
+  bodyId: number | null;
+
+  @Column({ type: "number", nullable: true })
+  footerId: number | null;
+
+  @ManyToOne(() => template, {
+    nullable: true,
+    onDelete: "RESTRICT",
+    onUpdate: "RESTRICT",
+  })
+  header: template | null;
+
+  @ManyToOne(() => template, {
+    nullable: true,
+    onDelete: "RESTRICT",
+    onUpdate: "RESTRICT",
+  })
+  body: template | null;
+
+  @ManyToOne(() => template, {
+    nullable: true,
+    onDelete: "RESTRICT",
+    onUpdate: "RESTRICT",
+  })
+  footer: template | null;
+}
diff --git a/src/factory/admin/templateUsage.ts b/src/factory/admin/templateUsage.ts
new file mode 100644
index 0000000..e2a5acb
--- /dev/null
+++ b/src/factory/admin/templateUsage.ts
@@ -0,0 +1,27 @@
+import { templateUsage } from "../../entity/templateUsage";
+import { TemplateUsageViewModel } from "../../viewmodel/admin/templateUsage.models";
+
+export default abstract class TemplateUsageFactory {
+  /**
+   * @description map record to templateUsage
+   * @param {templateUsage} record
+   * @returns {TemplateUsageViewModel}
+   */
+  public static mapToSingle(record: templateUsage): TemplateUsageViewModel {
+    return {
+      scope: record.scope,
+      header: record.header ? { id: record.header.id, template: record.header.template } : null,
+      body: record.body ? { id: record.body.id, template: record.body.template } : null,
+      footer: record.footer ? { id: record.footer.id, template: record.footer.template } : null,
+    };
+  }
+
+  /**
+   * @description map records to templateUsage
+   * @param {Array<templateUsage>} records
+   * @returns {Array<TemplateUsageViewModel>}
+   */
+  public static mapToBase(records: Array<templateUsage>): Array<TemplateUsageViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/helpers/pdfExport.ts b/src/helpers/pdfExport.ts
index c42b185..ff15fad 100644
--- a/src/helpers/pdfExport.ts
+++ b/src/helpers/pdfExport.ts
@@ -1,36 +1,34 @@
-import { readFileSync } from "fs";
-import Handlebars from "handlebars";
 import puppeteer from "puppeteer";
+import { TemplateHelper } from "./templateHelper";
+import { PermissionModule } from "../type/permissionTypes";
 
 export abstract class PdfExport {
-  static getTemplate(template: string) {
-    return readFileSync(process.cwd() + "/src/templates/" + template, "utf8");
-  }
-
   static async renderFile({
     template,
     title = "pdf-export Mitgliederverwaltung",
     filename,
     data,
   }: {
-    template: string;
+    template: PermissionModule;
     title: string;
     filename: string;
     data: any;
   }) {
-    const templateHtml = this.getTemplate(template);
-    const templateCompiled = Handlebars.compile(templateHtml);
-    const html = templateCompiled(data);
+    const { header, footer, body } = await TemplateHelper.renderFileForModule({
+      module: template,
+      bodyData: data,
+      title: title,
+    });
 
     const browser = await puppeteer.launch({
       headless: true,
       args: ["--no-sandbox", "--disable-gpu", "--disable-setuid-sandbox"],
     });
     const page = await browser.newPage();
-    await page.setContent(html, { waitUntil: "domcontentloaded" });
+    await page.setContent(body, { waitUntil: "domcontentloaded" });
 
     await page.pdf({
-      path: process.cwd() + `/export/${filename}.pdf`, // Name der PDF-Datei
+      path: process.cwd() + `/export/${filename}.pdf`,
       format: "A4",
       printBackground: false,
       margin: {
@@ -40,12 +38,8 @@ export abstract class PdfExport {
         right: "10mm",
       },
       displayHeaderFooter: true,
-      headerTemplate: `<h1 style="font-size:10px; text-align:center; width:100%;">${title}</h1>`,
-      footerTemplate: `
-        <div style="font-size:10px; text-align:center; width:100%; color:#888;">
-          Seite <span class="pageNumber"></span> von <span class="totalPages"></span>
-        </div>
-      `,
+      headerTemplate: header,
+      footerTemplate: footer,
     });
 
     await browser.close();
diff --git a/src/helpers/templateHelper.ts b/src/helpers/templateHelper.ts
new file mode 100644
index 0000000..a8c4dc0
--- /dev/null
+++ b/src/helpers/templateHelper.ts
@@ -0,0 +1,76 @@
+import { readFileSync } from "fs";
+import TemplateService from "../service/templateService";
+import { PermissionModule } from "../type/permissionTypes";
+import TemplateUsageService from "../service/templateUsageService";
+import Handlebars from "handlebars";
+
+export abstract class TemplateHelper {
+  static getTemplateFromFile(template: string) {
+    return readFileSync(`${process.cwd()}/src/templates/${template}.template.html`, "utf8");
+  }
+
+  static async getTemplateFromStore(templateId: number): Promise<string> {
+    return (await TemplateService.getById(templateId)).html;
+  }
+
+  static applyDataToTemplate(template: string, data: any): string {
+    const normalizedTemplate = this.normalizeTemplate(template);
+    const templateCompiled = Handlebars.compile(normalizedTemplate);
+    return templateCompiled(data);
+  }
+
+  static normalizeTemplate(template: string): string {
+    template = template.replace(/<listend>.*?<\/listend>/g, "{{/each}}");
+    template = template.replace(/<liststart\b[^>]*>(WDH Start: )?/g, "{{#each ");
+    template = template.replace(/<\/liststart>/g, "}}");
+
+    return template;
+  }
+
+  static async renderFileForModule({
+    module,
+    title = "pdf-export Mitgliederverwaltung",
+    headerData = {},
+    bodyData = {},
+    footerData = {},
+  }: {
+    module: PermissionModule;
+    title?: string;
+    headerData?: any;
+    bodyData?: any;
+    footerData?: any;
+  }): Promise<{ header: string; body: string; footer: string }> {
+    const moduleTemplates = await TemplateUsageService.getByScope(module);
+
+    let header = `<h1 style="font-size:10px; text-align:center; width:100%;">${title}</h1>`;
+    let footer = `
+      <div style="font-size:10px; text-align:center; width:100%; color:#888;">
+        Seite <span class="pageNumber"></span> von <span class="totalPages"></span>
+      </div>
+    `;
+    let body = "";
+
+    if (moduleTemplates.headerId) {
+      header = await this.getTemplateFromStore(moduleTemplates.headerId);
+      header = this.applyDataToTemplate(header, headerData);
+    }
+
+    if (moduleTemplates.footerId) {
+      footer = await this.getTemplateFromStore(moduleTemplates.footerId);
+      footer = this.applyDataToTemplate(footer, footerData);
+    }
+
+    if (moduleTemplates.bodyId) {
+      body = await this.getTemplateFromStore(moduleTemplates.bodyId);
+    } else {
+      body = this.getTemplateFromFile(module);
+    }
+    body = this.applyDataToTemplate(body, bodyData);
+
+    return {
+      header,
+      footer,
+      body,
+    };
+  }
+}
diff --git a/src/migrations/1734949173739-templateUsage.ts b/src/migrations/1734949173739-templateUsage.ts
new file mode 100644
index 0000000..2f419d4
--- /dev/null
+++ b/src/migrations/1734949173739-templateUsage.ts
@@ -0,0 +1,75 @@
+import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
+import { DB_TYPE } from "../env.defaults";
+import { templateUsage } from "../entity/templateUsage";
+
+export class TemplateUsage1734949173739 implements MigrationInterface {
+  name = "TemplateUsage1734949173739";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
+
+    await queryRunner.createTable(
+      new Table({
+        name: "template_usage",
+        columns: [
+          { name: "scope", type: "varchar", length: "255", isPrimary: true },
+          { name: "headerId", type: variableType_int, isNullable: true },
+          { name: "bodyId", type: variableType_int, isNullable: true },
+          { name: "footerId", type: variableType_int, isNullable: true },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.manager
+      .createQueryBuilder()
+      .insert()
+      .into(templateUsage)
+      .values({ scope: "protocol" })
+      .orIgnore()
+      .execute();
+
+    await queryRunner.createForeignKey(
+      "template_usage",
+      new TableForeignKey({
+        columnNames: ["headerId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "template",
+        onDelete: "RESTRICT",
+        onUpdate: "RESTRICT",
+      })
+    );
+    await queryRunner.createForeignKey(
+      "template_usage",
+      new TableForeignKey({
+        columnNames: ["bodyId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "template",
+        onDelete: "RESTRICT",
+        onUpdate: "RESTRICT",
+      })
+    );
+    await queryRunner.createForeignKey(
+      "template_usage",
+      new TableForeignKey({
+        columnNames: ["footerId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "template",
+        onDelete: "RESTRICT",
+        onUpdate: "RESTRICT",
+      })
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const template_usage = await queryRunner.getTable("template_usage");
+    let foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("headerId") !== -1);
+    await queryRunner.dropForeignKey("template_usage", foreignKey);
+    foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("bodyId") !== -1);
+    await queryRunner.dropForeignKey("template_usage", foreignKey);
+    foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("footerId") !== -1);
+    await queryRunner.dropForeignKey("template_usage", foreignKey);
+
+    await queryRunner.dropTable("template_usage");
+  }
+}
diff --git a/src/routes/admin/index.ts b/src/routes/admin/index.ts
index c51f08c..f1c6982 100644
--- a/src/routes/admin/index.ts
+++ b/src/routes/admin/index.ts
@@ -9,6 +9,7 @@ import qualification from "./qualification";
 import calendarType from "./calendarType";
 import queryStore from "./queryStore";
 import template from "./template";
+import templateUsage from "./templateUsage";
 
 import member from "./member";
 import protocol from "./protocol";
@@ -41,6 +42,7 @@ router.use("/qualification", PermissionHelper.passCheckMiddleware("read", "setti
 router.use("/calendartype", PermissionHelper.passCheckMiddleware("read", "settings", "calendar_type"), calendarType);
 router.use("/querystore", PermissionHelper.passCheckMiddleware("read", "settings", "query_store"), queryStore);
 router.use("/template", PermissionHelper.passCheckMiddleware("read", "settings", "template"), template);
+router.use("/templateusage", PermissionHelper.passCheckMiddleware("read", "settings", "template_usage"), templateUsage);
 
 router.use("/member", PermissionHelper.passCheckMiddleware("read", "club", "member"), member);
 router.use("/protocol", PermissionHelper.passCheckMiddleware("read", "club", "protocol"), protocol);
diff --git a/src/routes/admin/templateUsage.ts b/src/routes/admin/templateUsage.ts
new file mode 100644
index 0000000..ca4da5b
--- /dev/null
+++ b/src/routes/admin/templateUsage.ts
@@ -0,0 +1,21 @@
+import express, { Request, Response } from "express";
+import PermissionHelper from "../../helpers/permissionHelper";
+import { getAllTemplateUsages, updateTemplateUsage } from "../../controller/admin/templateUsageController";
+import { PermissionModule } from "../../type/permissionTypes";
+import ForbiddenRequestException from "../../exceptions/forbiddenRequestException";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllTemplateUsages(req, res);
+});
+
+router.patch(
+  "/:scope",
+  PermissionHelper.passCheckMiddleware("update", "settings", "template_usage"),
+  async (req: Request, res: Response) => {
+    await updateTemplateUsage(req, res);
+  }
+);
+
+export default router;
diff --git a/src/service/templateUsageService.ts b/src/service/templateUsageService.ts
new file mode 100644
index 0000000..25b61ee
--- /dev/null
+++ b/src/service/templateUsageService.ts
@@ -0,0 +1,46 @@
+import { dataSource } from "../data-source";
+import { templateUsage } from "../entity/templateUsage";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class TemplateUsageService {
+  /**
+   * @description get all templateUsages
+   * @returns {Promise<Array<templateUsage>>}
+   */
+  static async getAll(): Promise<Array<templateUsage>> {
+    return await dataSource
+      .getRepository(templateUsage)
+      .createQueryBuilder("templateUsage")
+      .leftJoinAndSelect("templateUsage.header", "headerTemplate")
+      .leftJoinAndSelect("templateUsage.body", "bodyTemplate")
+      .leftJoinAndSelect("templateUsage.footer", "footerTemplate")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("templates not found", err);
+      });
+  }
+
+  /**
+   * @description get template by scope
+   * @returns {Promise<templateUsage>}
+   */
+  static async getByScope(scope: string): Promise<templateUsage | null> {
+    return await dataSource
+      .getRepository(templateUsage)
+      .createQueryBuilder("templateUsage")
+      .leftJoinAndSelect("templateUsage.header", "headerTemplate")
+      .leftJoinAndSelect("templateUsage.body", "bodyTemplate")
+      .leftJoinAndSelect("templateUsage.footer", "footerTemplate")
+      .where("templateUsage.scope = :scope", { scope: scope })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err): null => {
+        return null;
+      });
+  }
+}
diff --git a/src/type/permissionTypes.ts b/src/type/permissionTypes.ts
index 62fbc51..34e2be9 100644
--- a/src/type/permissionTypes.ts
+++ b/src/type/permissionTypes.ts
@@ -15,7 +15,8 @@ export type PermissionModule =
   | "role"
   | "query"
   | "query_store"
-  | "template";
+  | "template"
+  | "template_usage";
 
 export type PermissionType = "read" | "create" | "update" | "delete";
 
@@ -55,6 +56,7 @@ export const permissionModules: Array<PermissionModule> = [
   "query",
   "query_store",
   "template",
+  "template_usage",
 ];
 export const permissionTypes: Array<PermissionType> = ["read", "create", "update", "delete"];
 export const sectionsAndModules: SectionsAndModulesObject = {
@@ -68,6 +70,7 @@ export const sectionsAndModules: SectionsAndModulesObject = {
     "calendar_type",
     "query_store",
     "template",
+    "template_usage",
   ],
   user: ["user", "role"],
 };
diff --git a/src/viewmodel/admin/templateUsage.models.ts b/src/viewmodel/admin/templateUsage.models.ts
new file mode 100644
index 0000000..3f9aa00
--- /dev/null
+++ b/src/viewmodel/admin/templateUsage.models.ts
@@ -0,0 +1,8 @@
+import { PermissionModule } from "../../type/permissionTypes";
+
+export interface TemplateUsageViewModel {
+  scope: PermissionModule;
+  header: { id: number; template: string } | null;
+  body: { id: number; template: string } | null;
+  footer: { id: number; template: string } | null;
+}

From 71480ecc97a43e27e92daff9e6bcb67e76274724 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Tue, 24 Dec 2024 10:24:46 +0100
Subject: [PATCH 04/16] template duplication

---
 src/controller/admin/templateController.ts | 29 ++++++++++++++++++++++
 src/routes/admin/template.ts               |  9 +++++++
 2 files changed, 38 insertions(+)

diff --git a/src/controller/admin/templateController.ts b/src/controller/admin/templateController.ts
index 9c8a2a0..9f867f9 100644
--- a/src/controller/admin/templateController.ts
+++ b/src/controller/admin/templateController.ts
@@ -48,6 +48,35 @@ export async function createTemplate(req: Request, res: Response): Promise<any>
   res.status(200).send(id);
 }
 
+/**
+ * @description clone template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function cloneTemplate(req: Request, res: Response): Promise<any> {
+  const cloneId = req.body.cloneId;
+
+  const { template, description, design, html } = await TemplateService.getById(cloneId);
+
+  let createTemplate: CreateTemplateCommand = {
+    template: "",
+    description: "",
+  };
+  let id = await TemplateCommandHandler.create(createTemplate);
+
+  let updateTemplate: UpdateTemplateCommand = {
+    id: id,
+    template: template + " - Kopie",
+    description: description,
+    design: design,
+    html: html,
+  };
+  await TemplateCommandHandler.update(updateTemplate);
+
+  res.status(200).send(id);
+}
+
 /**
  * @description update template
  * @param req {Request} Express req object
diff --git a/src/routes/admin/template.ts b/src/routes/admin/template.ts
index 1653956..492837e 100644
--- a/src/routes/admin/template.ts
+++ b/src/routes/admin/template.ts
@@ -1,5 +1,6 @@
 import express, { Request, Response } from "express";
 import {
+  cloneTemplate,
   createTemplate,
   deleteTemplate,
   getAllTemplates,
@@ -26,6 +27,14 @@ router.post(
   }
 );
 
+router.post(
+  "/clone",
+  PermissionHelper.passCheckMiddleware("create", "settings", "template"),
+  async (req: Request, res: Response) => {
+    await cloneTemplate(req, res);
+  }
+);
+
 router.patch(
   "/:id",
   PermissionHelper.passCheckMiddleware("update", "settings", "template"),

From 020ae4a939f64fe7a47e63283c21b6cdc40fd7de Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Tue, 24 Dec 2024 13:52:56 +0100
Subject: [PATCH 05/16] preview template usage

---
 .../admin/templateUsageController.ts          | 23 ++++++++
 src/demodata/protocol.data.ts                 | 56 +++++++++++++++++++
 src/helpers/demoDataHelper.ts                 | 13 +++++
 src/helpers/pdfExport.ts                      | 24 +++++---
 src/helpers/templateHelper.ts                 | 12 ++--
 src/routes/admin/templateUsage.ts             | 10 +++-
 ...plate.html => protocol.body.template.html} |  0
 src/templates/protocol.footer.template.html   |  3 +
 8 files changed, 124 insertions(+), 17 deletions(-)
 create mode 100644 src/demodata/protocol.data.ts
 create mode 100644 src/helpers/demoDataHelper.ts
 rename src/templates/{protocol.template.html => protocol.body.template.html} (100%)
 create mode 100644 src/templates/protocol.footer.template.html

diff --git a/src/controller/admin/templateUsageController.ts b/src/controller/admin/templateUsageController.ts
index 0d146d7..e121215 100644
--- a/src/controller/admin/templateUsageController.ts
+++ b/src/controller/admin/templateUsageController.ts
@@ -6,6 +6,8 @@ import TemplateUsageCommandHandler from "../../command/templateUsageCommandHandl
 import PermissionHelper from "../../helpers/permissionHelper";
 import ForbiddenRequestException from "../../exceptions/forbiddenRequestException";
 import { PermissionModule } from "../../type/permissionTypes";
+import { PdfExport } from "../../helpers/pdfExport";
+import { DemoDataHelper } from "../../helpers/demoDataHelper";
 
 /**
  * @description get all templateUsages
@@ -28,6 +30,27 @@ export async function getAllTemplateUsages(req: Request, res: Response): Promise
   res.json(TemplateUsageFactory.mapToBase(templateUsages));
 }
 
+/**
+ * @description print demo of templateUsage
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function printTemplateUsageDemo(req: Request, res: Response): Promise<any> {
+  const scope = req.params.scope as PermissionModule;
+
+  let demoData = DemoDataHelper.getData(scope);
+  let pdf = await PdfExport.renderFile({ template: scope, saveToDisk: false, data: demoData });
+
+  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 update templateUsage
  * @param req {Request} Express req object
diff --git a/src/demodata/protocol.data.ts b/src/demodata/protocol.data.ts
new file mode 100644
index 0000000..1feeace
--- /dev/null
+++ b/src/demodata/protocol.data.ts
@@ -0,0 +1,56 @@
+import { member } from "../entity/member";
+import { protocolAgenda } from "../entity/protocolAgenda";
+import { protocolDecision } from "../entity/protocolDecision";
+import { protocolVoting } from "../entity/protocolVoting";
+
+export const protocolDemoData: {
+  title: string;
+  summary: string;
+  iteration: number;
+  date: string;
+  start: string;
+  end: string;
+  agenda: Array<Partial<protocolAgenda>>;
+  decisions: Array<Partial<protocolDecision>>;
+  presence: Array<Partial<member>>;
+  votings: Array<Partial<protocolVoting>>;
+} = {
+  title: "Beispiel Protokoll Daten",
+  summary: "Zusammenfassung der Demodaten.",
+  iteration: 1,
+  date: new Date().toLocaleDateString("de-DE", {
+    weekday: "long",
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+  }),
+  start: "19:00:00",
+  end: "21:00:00",
+  agenda: [
+    {
+      topic: "Protokoll-TOP",
+      context: "Inhalt des Punktes",
+    },
+  ],
+  decisions: [
+    {
+      topic: "Entscheidung yz",
+      context: "Inhalt der Entscheidung",
+    },
+  ],
+  presence: [
+    {
+      firstname: "Julian",
+      lastname: "Krauser",
+    },
+  ],
+  votings: [
+    {
+      topic: "Abstimmung xy",
+      context: "Inhalt der Abstimmung",
+      favour: 1,
+      abstain: 2,
+      against: 3,
+    },
+  ],
+};
diff --git a/src/helpers/demoDataHelper.ts b/src/helpers/demoDataHelper.ts
new file mode 100644
index 0000000..158f17b
--- /dev/null
+++ b/src/helpers/demoDataHelper.ts
@@ -0,0 +1,13 @@
+import { protocolDemoData } from "../demodata/protocol.data";
+import { PermissionModule } from "../type/permissionTypes";
+
+export abstract class DemoDataHelper {
+  static getData(scope: PermissionModule) {
+    switch (scope) {
+      case "protocol":
+        return protocolDemoData;
+      default:
+        return {};
+    }
+  }
+}
diff --git a/src/helpers/pdfExport.ts b/src/helpers/pdfExport.ts
index ff15fad..827f3db 100644
--- a/src/helpers/pdfExport.ts
+++ b/src/helpers/pdfExport.ts
@@ -6,13 +6,17 @@ export abstract class PdfExport {
   static async renderFile({
     template,
     title = "pdf-export Mitgliederverwaltung",
-    filename,
-    data,
+    filename = null,
+    data = {},
+    saveToDisk = true,
+    margins = { top: "15mm", bottom: "15mm" },
   }: {
     template: PermissionModule;
-    title: string;
-    filename: string;
-    data: any;
+    title?: string;
+    filename?: string;
+    data?: any;
+    saveToDisk?: boolean;
+    margins?: { top: string; bottom: string };
   }) {
     const { header, footer, body } = await TemplateHelper.renderFileForModule({
       module: template,
@@ -27,13 +31,13 @@ export abstract class PdfExport {
     const page = await browser.newPage();
     await page.setContent(body, { waitUntil: "domcontentloaded" });
 
-    await page.pdf({
-      path: process.cwd() + `/export/${filename}.pdf`,
+    let pdf = await page.pdf({
+      ...(saveToDisk ? { path: process.cwd() + `/export/${filename}.pdf` } : {}),
       format: "A4",
       printBackground: false,
       margin: {
-        top: "15mm",
-        bottom: "15mm",
+        top: margins.top,
+        bottom: margins.bottom,
         left: "10mm",
         right: "10mm",
       },
@@ -43,5 +47,7 @@ export abstract class PdfExport {
     });
 
     await browser.close();
+
+    return pdf;
   }
 }
diff --git a/src/helpers/templateHelper.ts b/src/helpers/templateHelper.ts
index a8c4dc0..04a0874 100644
--- a/src/helpers/templateHelper.ts
+++ b/src/helpers/templateHelper.ts
@@ -39,15 +39,11 @@ export abstract class TemplateHelper {
     headerData?: any;
     bodyData?: any;
     footerData?: any;
-  }): Promise<{ header: string; body: string; footer: string }> {
+  }): Promise<{ header: string; body: string; footer: string; margins?: { top: string; bottom: string } }> {
     const moduleTemplates = await TemplateUsageService.getByScope(module);
 
     let header = `<h1 style="font-size:10px; text-align:center; width:100%;">${title}</h1>`;
-    let footer = `
-      <div style="font-size:10px; text-align:center; width:100%; color:#888;">
-        Seite <span class="pageNumber"></span> von <span class="totalPages"></span>
-      </div>
-    `;
+    let footer = "";
     let body = "";
 
     if (moduleTemplates.headerId) {
@@ -58,12 +54,14 @@ export abstract class TemplateHelper {
     if (moduleTemplates.footerId) {
       footer = await this.getTemplateFromStore(moduleTemplates.footerId);
       footer = this.applyDataToTemplate(footer, footerData);
+    } else {
+      footer = this.getTemplateFromFile(module + ".footer");
     }
 
     if (moduleTemplates.bodyId) {
       body = await this.getTemplateFromStore(moduleTemplates.bodyId);
     } else {
-      body = this.getTemplateFromFile(module);
+      body = this.getTemplateFromFile(module + ".body");
     }
     body = this.applyDataToTemplate(body, bodyData);
 
diff --git a/src/routes/admin/templateUsage.ts b/src/routes/admin/templateUsage.ts
index ca4da5b..d25b321 100644
--- a/src/routes/admin/templateUsage.ts
+++ b/src/routes/admin/templateUsage.ts
@@ -1,6 +1,10 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../helpers/permissionHelper";
-import { getAllTemplateUsages, updateTemplateUsage } from "../../controller/admin/templateUsageController";
+import {
+  getAllTemplateUsages,
+  printTemplateUsageDemo,
+  updateTemplateUsage,
+} from "../../controller/admin/templateUsageController";
 import { PermissionModule } from "../../type/permissionTypes";
 import ForbiddenRequestException from "../../exceptions/forbiddenRequestException";
 
@@ -10,6 +14,10 @@ router.get("/", async (req: Request, res: Response) => {
   await getAllTemplateUsages(req, res);
 });
 
+router.get("/:scope", async (req: Request, res: Response) => {
+  await printTemplateUsageDemo(req, res);
+});
+
 router.patch(
   "/:scope",
   PermissionHelper.passCheckMiddleware("update", "settings", "template_usage"),
diff --git a/src/templates/protocol.template.html b/src/templates/protocol.body.template.html
similarity index 100%
rename from src/templates/protocol.template.html
rename to src/templates/protocol.body.template.html
diff --git a/src/templates/protocol.footer.template.html b/src/templates/protocol.footer.template.html
new file mode 100644
index 0000000..7a3190b
--- /dev/null
+++ b/src/templates/protocol.footer.template.html
@@ -0,0 +1,3 @@
+<div style="font-size: 10px; text-align: center; width: 100%; color: #888">
+  Seite <span class="pageNumber"></span> von <span class="totalPages"></span>
+</div>

From e9b29f8acf594c17bcab5c81bbf308dddf1972c8 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Tue, 24 Dec 2024 14:06:48 +0100
Subject: [PATCH 06/16] extend calendar link

---
 src/controller/publicController.ts |  6 +++++-
 src/service/calendarService.ts     | 12 +++++++++---
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/controller/publicController.ts b/src/controller/publicController.ts
index 8c627fc..15c5d73 100644
--- a/src/controller/publicController.ts
+++ b/src/controller/publicController.ts
@@ -16,6 +16,7 @@ import CalendarFactory from "../factory/admin/calendar";
  */
 export async function getCalendarItemsByTypes(req: Request, res: Response): Promise<any> {
   let types = Array.isArray(req.query.types) ? req.query.types : [req.query.types];
+  let nscdr = req.query.nscdr == "true";
   let output = (req.query.output as "ics" | "json") ?? "ics";
 
   if (output != "ics" && output != "json") {
@@ -33,7 +34,10 @@ export async function getCalendarItemsByTypes(req: Request, res: Response): Prom
         ti.passphrase == "" ||
         ti.passphrase == (types as Array<string>).find((t) => t.includes(ti.type)).split(":")[1]
     );
-    items = await CalendarService.getByTypes(typeIds.map((t) => t.id));
+    items = await CalendarService.getByTypes(
+      typeIds.map((t) => t.id),
+      nscdr
+    );
   } else {
     items = await CalendarService.getByTypeNSCDR();
   }
diff --git a/src/service/calendarService.ts b/src/service/calendarService.ts
index 48c771d..5bbf4f4 100644
--- a/src/service/calendarService.ts
+++ b/src/service/calendarService.ts
@@ -44,12 +44,18 @@ export default abstract class CalendarService {
    * @description get calendar by types
    * @returns {Promise<Array<calendar>>}
    */
-  static async getByTypes(types: Array<number>): Promise<Array<calendar>> {
-    return await dataSource
+  static async getByTypes(types: Array<number>, addNscdr: boolean = false): Promise<Array<calendar>> {
+    const query = dataSource
       .getRepository(calendar)
       .createQueryBuilder("calendar")
       .leftJoinAndSelect("calendar.type", "type")
-      .where("type.id IN (:...types)", { types: types })
+      .where("type.id IN (:...types)", { types: types });
+
+    if (addNscdr) {
+      query.orWhere("type.nscdr = :nscdr", { nscdr: true });
+    }
+
+    return await query
       .getMany()
       .then((res) => {
         return res;

From 01ce3fdd396b9ed8ebb24da3abedaa28affdd480 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Wed, 25 Dec 2024 12:22:28 +0100
Subject: [PATCH 07/16] newsletter CRUD & pdf

---
 package-lock.json                             |  43 ++++
 package.json                                  |   1 +
 src/command/newsletterCommand.ts              |  18 ++
 src/command/newsletterCommandHandler.ts       |  73 ++++++
 src/command/newsletterDatesCommand.ts         |  10 +
 src/command/newsletterDatesCommandHandler.ts  |  95 ++++++++
 src/command/newsletterRecipientsCommand.ts    |   9 +
 .../newsletterRecipientsCommandHandler.ts     |  94 +++++++
 src/controller/admin/newsletterController.ts  | 229 ++++++++++++++++++
 src/controller/admin/protocolController.ts    |   4 +-
 src/data-source.ts                            |   8 +
 src/entity/newsletter.ts                      |  42 ++++
 src/entity/newsletterDates.ts                 |  32 +++
 src/entity/newsletterRecipients.ts            |  29 +++
 src/factory/admin/newsletter.ts               |  32 +++
 src/factory/admin/newsletterDates.ts          |  30 +++
 src/factory/admin/newsletterRecipients.ts     |  28 +++
 src/helpers/fileSystemHelper.ts               |  31 +++
 src/helpers/pdfExport.ts                      |  31 ++-
 src/helpers/templateHelper.ts                 |   4 +-
 src/migrations/1735118780511-newsletter.ts    | 129 ++++++++++
 src/routes/admin/index.ts                     |   2 +
 src/routes/admin/newsletter.ts                |  85 +++++++
 src/service/newsletterDatesService.ts         |  26 ++
 src/service/newsletterRecipientsService.ts    |  28 +++
 src/service/newsletterService.ts              |  44 ++++
 src/service/protocolPrecenseService.ts        |  19 --
 src/type/permissionTypes.ts                   |   3 +
 src/viewmodel/admin/newsletter.models.ts      |  12 +
 src/viewmodel/admin/newsletterDates.models.ts |   9 +
 .../admin/newsletterRecipients.models.ts      |   8 +
 31 files changed, 1185 insertions(+), 23 deletions(-)
 create mode 100644 src/command/newsletterCommand.ts
 create mode 100644 src/command/newsletterCommandHandler.ts
 create mode 100644 src/command/newsletterDatesCommand.ts
 create mode 100644 src/command/newsletterDatesCommandHandler.ts
 create mode 100644 src/command/newsletterRecipientsCommand.ts
 create mode 100644 src/command/newsletterRecipientsCommandHandler.ts
 create mode 100644 src/controller/admin/newsletterController.ts
 create mode 100644 src/entity/newsletter.ts
 create mode 100644 src/entity/newsletterDates.ts
 create mode 100644 src/entity/newsletterRecipients.ts
 create mode 100644 src/factory/admin/newsletter.ts
 create mode 100644 src/factory/admin/newsletterDates.ts
 create mode 100644 src/factory/admin/newsletterRecipients.ts
 create mode 100644 src/helpers/fileSystemHelper.ts
 create mode 100644 src/migrations/1735118780511-newsletter.ts
 create mode 100644 src/routes/admin/newsletter.ts
 create mode 100644 src/service/newsletterDatesService.ts
 create mode 100644 src/service/newsletterRecipientsService.ts
 create mode 100644 src/service/newsletterService.ts
 create mode 100644 src/viewmodel/admin/newsletter.models.ts
 create mode 100644 src/viewmodel/admin/newsletterDates.models.ts
 create mode 100644 src/viewmodel/admin/newsletterRecipients.models.ts

diff --git a/package-lock.json b/package-lock.json
index d359826..4946c5b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -20,6 +20,7 @@
         "mysql": "^2.18.1",
         "node-schedule": "^2.1.1",
         "nodemailer": "^6.9.14",
+        "pdf-lib": "^1.17.1",
         "puppeteer": "^23.11.1",
         "qrcode": "^1.5.4",
         "reflect-metadata": "^0.2.2",
@@ -177,6 +178,24 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
+    "node_modules/@pdf-lib/standard-fonts": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/standard-fonts/-/standard-fonts-1.0.0.tgz",
+      "integrity": "sha512-hU30BK9IUN/su0Mn9VdlVKsWBS6GyhVfqjwl1FjZN4TxP6cCw0jP2w7V3Hf5uX7M0AZJ16vey9yE0ny7Sa59ZA==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.6"
+      }
+    },
+    "node_modules/@pdf-lib/upng": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/upng/-/upng-1.0.1.tgz",
+      "integrity": "sha512-dQK2FUMQtowVP00mtIksrlZhdFXQZPC+taih1q4CvPZ5vqdxR/LKBaFg0oAfzd1GlHZXXSPdQfzQnt+ViGvEIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.10"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -2666,6 +2685,12 @@
       "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.0.tgz",
       "integrity": "sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw=="
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -2766,6 +2791,24 @@
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-3.2.0.tgz",
       "integrity": "sha512-jczvQbCUS7XmS7o+y1aEO9OBVFeZBQ1MDSEqmO7xSoPgOPoowY/SxLpZ6Vh97/8qHZOteiCKb7gkG9gA2ZUxJA=="
     },
+    "node_modules/pdf-lib": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/pdf-lib/-/pdf-lib-1.17.1.tgz",
+      "integrity": "sha512-V/mpyJAoTsN4cnP31vc0wfNA1+p20evqqnap0KLoRUN0Yk/p3wN52DOEsL4oBFcLdb76hlpKPtzJIgo67j/XLw==",
+      "license": "MIT",
+      "dependencies": {
+        "@pdf-lib/standard-fonts": "^1.0.0",
+        "@pdf-lib/upng": "^1.0.1",
+        "pako": "^1.0.11",
+        "tslib": "^1.11.1"
+      }
+    },
+    "node_modules/pdf-lib/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/pend": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
diff --git a/package.json b/package.json
index 621f201..555db79 100644
--- a/package.json
+++ b/package.json
@@ -35,6 +35,7 @@
     "mysql": "^2.18.1",
     "node-schedule": "^2.1.1",
     "nodemailer": "^6.9.14",
+    "pdf-lib": "^1.17.1",
     "puppeteer": "^23.11.1",
     "qrcode": "^1.5.4",
     "reflect-metadata": "^0.2.2",
diff --git a/src/command/newsletterCommand.ts b/src/command/newsletterCommand.ts
new file mode 100644
index 0000000..354ae62
--- /dev/null
+++ b/src/command/newsletterCommand.ts
@@ -0,0 +1,18 @@
+export interface CreateNewsletterCommand {
+  title: string;
+}
+
+export interface SynchronizeNewsletterCommand {
+  id: number;
+  title: string;
+  description: string;
+  newsletterTitle: string;
+  newsletterText: string;
+  newsletterSignatur: string;
+  recipientsByQueryId?: number;
+}
+
+export interface SendNewsletterCommand {
+  id: number;
+  isSent: boolean;
+}
diff --git a/src/command/newsletterCommandHandler.ts b/src/command/newsletterCommandHandler.ts
new file mode 100644
index 0000000..6667a74
--- /dev/null
+++ b/src/command/newsletterCommandHandler.ts
@@ -0,0 +1,73 @@
+import { dataSource } from "../data-source";
+import { newsletter } from "../entity/newsletter";
+import InternalException from "../exceptions/internalException";
+import { CreateNewsletterCommand, SendNewsletterCommand, SynchronizeNewsletterCommand } from "./newsletterCommand";
+
+export default abstract class NewsletterCommandHandler {
+  /**
+   * @description create newsletter
+   * @param CreateNewsletterCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createNewsletter: CreateNewsletterCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(newsletter)
+      .values({
+        title: createNewsletter.title,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating newsletter", err);
+      });
+  }
+
+  /**
+   * @description sync newsletter
+   * @param SynchronizeNewsletterCommand
+   * @returns {Promise<void>}
+   */
+  static async sync(syncNewsletter: SynchronizeNewsletterCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(newsletter)
+      .set({
+        title: syncNewsletter.title,
+        description: syncNewsletter.description,
+        newsletterTitle: syncNewsletter.newsletterTitle,
+        newsletterText: syncNewsletter.newsletterText,
+        newsletterSignatur: syncNewsletter.newsletterSignatur,
+        recipientsByQueryId: syncNewsletter.recipientsByQueryId,
+      })
+      .where("id = :id", { id: syncNewsletter.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed synching newsletter", err);
+      });
+  }
+
+  /**
+   * @description send newsletter
+   * @param SendNewsletterCommand
+   * @returns {Promise<void>}
+   */
+  static async send(syncNewsletter: SendNewsletterCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(newsletter)
+      .set({
+        isSent: syncNewsletter.isSent,
+      })
+      .where("id = :id", { id: syncNewsletter.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed setting newsletter send state", err);
+      });
+  }
+}
diff --git a/src/command/newsletterDatesCommand.ts b/src/command/newsletterDatesCommand.ts
new file mode 100644
index 0000000..70d789f
--- /dev/null
+++ b/src/command/newsletterDatesCommand.ts
@@ -0,0 +1,10 @@
+export interface SynchronizeNewsletterDatesCommand {
+  newsletterId: number;
+  dates: Array<NewsletterDateCommand>;
+}
+
+export interface NewsletterDateCommand {
+  calendarId: number;
+  diffTitle?: string;
+  diffDescription?: string;
+}
diff --git a/src/command/newsletterDatesCommandHandler.ts b/src/command/newsletterDatesCommandHandler.ts
new file mode 100644
index 0000000..f1ec22b
--- /dev/null
+++ b/src/command/newsletterDatesCommandHandler.ts
@@ -0,0 +1,95 @@
+import { DeleteResult, EntityManager, InsertResult, UpdateResult } from "typeorm";
+import { dataSource } from "../data-source";
+import InternalException from "../exceptions/internalException";
+import NewsletterDatesService from "../service/newsletterDatesService";
+import { NewsletterDateCommand, SynchronizeNewsletterDatesCommand } from "./newsletterDatesCommand";
+import { newsletterDates } from "../entity/newsletterDates";
+
+export default abstract class NewsletterDatesCommandHandler {
+  /**
+   * @description sync newsletter dates
+   * @param {SynchronizeNewsletterDatesCommand} syncNewsletterDates
+   * @returns {Promise<void>}
+   */
+  static async sync(syncNewsletterDates: SynchronizeNewsletterDatesCommand): Promise<void> {
+    let currentDates = await NewsletterDatesService.getAll(syncNewsletterDates.newsletterId);
+
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newDates = syncNewsletterDates.dates.filter(
+          (r) => !currentDates.map((np) => np.calendarId).includes(r.calendarId)
+        );
+        let removeDates = currentDates.filter(
+          (r) => !syncNewsletterDates.dates.map((np) => np.calendarId).includes(r.calendarId)
+        );
+        let keptDates = currentDates.filter((r) =>
+          syncNewsletterDates.dates.map((np) => np.calendarId).includes(r.calendarId)
+        );
+
+        if (newDates.length != 0) {
+          await this.syncPresenceAdd(manager, syncNewsletterDates.newsletterId, newDates);
+        }
+
+        if (removeDates.length != 0) {
+          await this.syncPresenceRemove(manager, syncNewsletterDates.newsletterId, removeDates);
+        }
+
+        for (const date of keptDates) {
+          await this.syncPresenceUpdate(manager, syncNewsletterDates.newsletterId, date);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed syncing newsletter dates", err);
+      });
+  }
+
+  private static async syncPresenceAdd(
+    manager: EntityManager,
+    newsletterId: number,
+    dates: Array<NewsletterDateCommand>
+  ): Promise<InsertResult> {
+    return await manager
+      .createQueryBuilder()
+      .insert()
+      .into(newsletterDates)
+      .values(
+        dates.map((d) => ({
+          ...d,
+          newsletterId: newsletterId,
+        }))
+      )
+      .execute();
+  }
+
+  private static async syncPresenceUpdate(
+    manager: EntityManager,
+    newsletterId: number,
+    date: NewsletterDateCommand
+  ): Promise<UpdateResult> {
+    return await manager
+      .createQueryBuilder()
+      .update(newsletterDates)
+      .set({
+        diffTitle: date.diffTitle,
+        diffDescription: date.diffDescription,
+      })
+      .where("calendarId = :calendarId", { calendarId: date.calendarId })
+      .andWhere("newsletterId = :newsletterId", { newsletterId })
+      .execute();
+  }
+
+  private static async syncPresenceRemove(
+    manager: EntityManager,
+    newsletterId: number,
+    dates: Array<NewsletterDateCommand>
+  ): Promise<DeleteResult> {
+    return await manager
+      .createQueryBuilder()
+      .delete()
+      .from(newsletterDates)
+      .where("calendarId IN (:...ids)", { ids: dates.map((d) => d.calendarId) })
+      .andWhere("newsletterId = :newsletterId", { newsletterId })
+      .execute();
+  }
+}
diff --git a/src/command/newsletterRecipientsCommand.ts b/src/command/newsletterRecipientsCommand.ts
new file mode 100644
index 0000000..fdd8928
--- /dev/null
+++ b/src/command/newsletterRecipientsCommand.ts
@@ -0,0 +1,9 @@
+export interface SynchronizeNewsletterRecipientsCommand {
+  newsletterId: number;
+  recipients: Array<NewsletterRecipientCommand>;
+}
+
+export interface NewsletterRecipientCommand {
+  memberId: number;
+  addedManually: boolean;
+}
diff --git a/src/command/newsletterRecipientsCommandHandler.ts b/src/command/newsletterRecipientsCommandHandler.ts
new file mode 100644
index 0000000..0421c41
--- /dev/null
+++ b/src/command/newsletterRecipientsCommandHandler.ts
@@ -0,0 +1,94 @@
+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 { 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);
+
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newRecipients = syncNewsletterRecipients.recipients.filter(
+          (r) => !currentRecipients.map((np) => np.memberId).includes(r.memberId)
+        );
+        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)
+        );
+
+        if (newRecipients.length != 0) {
+          await this.syncPresenceAdd(manager, syncNewsletterRecipients.newsletterId, newRecipients);
+        }
+
+        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) => {
+        throw new InternalException("Failed syncing newsletter recipients", err);
+      });
+  }
+
+  private static async syncPresenceAdd(
+    manager: EntityManager,
+    newsletterId: number,
+    recipients: Array<NewsletterRecipientCommand>
+  ): Promise<InsertResult> {
+    return await manager
+      .createQueryBuilder()
+      .insert()
+      .into(newsletterRecipients)
+      .values(
+        recipients.map((d) => ({
+          ...d,
+          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>
+  ): Promise<DeleteResult> {
+    return await manager
+      .createQueryBuilder()
+      .delete()
+      .from(newsletterRecipients)
+      .where("memberId IN (:...ids)", { ids: recipients.map((d) => d.memberId) })
+      .andWhere("newsletterId = :newsletterId", { newsletterId })
+      .execute();
+  }
+}
diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
new file mode 100644
index 0000000..1d4efb0
--- /dev/null
+++ b/src/controller/admin/newsletterController.ts
@@ -0,0 +1,229 @@
+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);
+}
diff --git a/src/controller/admin/protocolController.ts b/src/controller/admin/protocolController.ts
index ef5ca3d..345a42b 100644
--- a/src/controller/admin/protocolController.ts
+++ b/src/controller/admin/protocolController.ts
@@ -27,6 +27,7 @@ import ProtocolPrintoutService from "../../service/protocolPrintoutService";
 import ProtocolPrintoutFactory from "../../factory/admin/protocolPrintout";
 import { CreateProtocolPrintoutCommand } from "../../command/protocolPrintoutCommand";
 import ProtocolPrintoutCommandHandler from "../../command/protocolPrintoutCommandHandler";
+import { FileSystemHelper } from "../../helpers/fileSystemHelper";
 
 /**
  * @description get all protocols
@@ -240,6 +241,7 @@ export async function createProtocolPrintoutById(req: Request, res: Response): P
     template: "protocol",
     title,
     filename,
+    folder: "protocol",
     data: {
       title: protocol.title,
       summary: protocol.summary,
@@ -262,7 +264,7 @@ export async function createProtocolPrintoutById(req: Request, res: Response): P
   let printout: CreateProtocolPrintoutCommand = {
     title,
     iteration: iteration + 1,
-    filename,
+    filename: FileSystemHelper.formatPath("protocol", filename),
     protocolId,
   };
   await ProtocolPrintoutCommandHandler.create(printout);
diff --git a/src/data-source.ts b/src/data-source.ts
index d9567fd..7b97e03 100644
--- a/src/data-source.ts
+++ b/src/data-source.ts
@@ -55,6 +55,10 @@ import { template } from "./entity/template";
 import { Template1734854680201 } from "./migrations/1734854680201-template";
 import { templateUsage } from "./entity/templateUsage";
 import { TemplateUsage1734949173739 } from "./migrations/1734949173739-templateUsage";
+import { newsletter } from "./entity/newsletter";
+import { newsletterDates } from "./entity/newsletterDates";
+import { newsletterRecipients } from "./entity/newsletterRecipients";
+import { Newsletter1735118780511 } from "./migrations/1735118780511-newsletter";
 
 const dataSource = new DataSource({
   type: DB_TYPE as any,
@@ -96,6 +100,9 @@ const dataSource = new DataSource({
     query,
     template,
     templateUsage,
+    newsletter,
+    newsletterDates,
+    newsletterRecipients,
     memberView,
     memberExecutivePositionsView,
     memberQualificationsView,
@@ -120,6 +127,7 @@ const dataSource = new DataSource({
     MemberDataViews1734520998539,
     Template1734854680201,
     TemplateUsage1734949173739,
+    Newsletter1735118780511,
   ],
   migrationsRun: true,
   migrationsTransactionMode: "each",
diff --git a/src/entity/newsletter.ts b/src/entity/newsletter.ts
new file mode 100644
index 0000000..0694d88
--- /dev/null
+++ b/src/entity/newsletter.ts
@@ -0,0 +1,42 @@
+import { Column, Entity, ManyToOne, OneToMany, PrimaryColumn } from "typeorm";
+import { newsletterDates } from "./newsletterDates";
+import { member } from "./member";
+import { newsletterRecipients } from "./newsletterRecipients";
+import { query } from "./query";
+
+@Entity()
+export class newsletter {
+  @PrimaryColumn({ generated: "increment", type: "int" })
+  id: number;
+
+  @Column({ type: "varchar", length: 255 })
+  title: string;
+
+  @Column({ type: "varchar", length: 255, default: "" })
+  description: string;
+
+  @Column({ type: "varchar", length: 255, default: "" })
+  newsletterTitle: string;
+
+  @Column({ type: "text", default: "" })
+  newsletterText: string;
+
+  @Column({ type: "varchar", length: 255, default: "" })
+  newsletterSignatur: string;
+
+  @Column({ type: "boolean", default: false })
+  isSent: boolean;
+
+  @OneToMany(() => newsletterDates, (dates) => dates.newsletter)
+  dates: newsletterDates[];
+
+  @OneToMany(() => newsletterRecipients, (recipient) => recipient.newsletter)
+  recipients: newsletterRecipients[];
+
+  @ManyToOne(() => query, {
+    nullable: true,
+    onDelete: "CASCADE",
+    onUpdate: "RESTRICT",
+  })
+  recipientsByQuery?: query;
+}
diff --git a/src/entity/newsletterDates.ts b/src/entity/newsletterDates.ts
new file mode 100644
index 0000000..5ef80ba
--- /dev/null
+++ b/src/entity/newsletterDates.ts
@@ -0,0 +1,32 @@
+import { Column, Entity, ManyToOne, PrimaryColumn } from "typeorm";
+import { newsletter } from "./newsletter";
+import { calendar } from "./calendar";
+
+@Entity()
+export class newsletterDates {
+  @PrimaryColumn({ type: "int" })
+  newsletterId: number;
+
+  @PrimaryColumn({ type: "int" })
+  calendarId: number;
+
+  @Column({ type: "varchar", length: 255, nullable: true })
+  diffTitle: string | null;
+
+  @Column({ type: "text", nullable: true })
+  diffDescription: string | null;
+
+  @ManyToOne(() => newsletter, (newsletter) => newsletter.dates, {
+    nullable: false,
+    onDelete: "CASCADE",
+    onUpdate: "RESTRICT",
+  })
+  newsletter: newsletter;
+
+  @ManyToOne(() => calendar, {
+    nullable: false,
+    onDelete: "RESTRICT",
+    onUpdate: "RESTRICT",
+  })
+  calendar: calendar;
+}
diff --git a/src/entity/newsletterRecipients.ts b/src/entity/newsletterRecipients.ts
new file mode 100644
index 0000000..1f62a5a
--- /dev/null
+++ b/src/entity/newsletterRecipients.ts
@@ -0,0 +1,29 @@
+import { Column, Entity, ManyToOne, PrimaryColumn } from "typeorm";
+import { newsletter } from "./newsletter";
+import { member } from "./member";
+
+@Entity()
+export class newsletterRecipients {
+  @PrimaryColumn({ type: "int" })
+  newsletterId: number;
+
+  @PrimaryColumn({ type: "int" })
+  memberId: number;
+
+  @Column({ type: "boolean", default: false })
+  addedManually: boolean;
+
+  @ManyToOne(() => newsletter, (newsletter) => newsletter.recipients, {
+    nullable: false,
+    onDelete: "CASCADE",
+    onUpdate: "RESTRICT",
+  })
+  newsletter: newsletter;
+
+  @ManyToOne(() => member, {
+    nullable: false,
+    onDelete: "CASCADE",
+    onUpdate: "RESTRICT",
+  })
+  member: member;
+}
diff --git a/src/factory/admin/newsletter.ts b/src/factory/admin/newsletter.ts
new file mode 100644
index 0000000..3dca651
--- /dev/null
+++ b/src/factory/admin/newsletter.ts
@@ -0,0 +1,32 @@
+import { newsletter } from "../../entity/newsletter";
+import { NewsletterViewModel } from "../../viewmodel/admin/newsletter.models";
+import QueryStoreFactory from "./queryStore";
+
+export default abstract class NewsletterFactory {
+  /**
+   * @description map record to newsletter
+   * @param {newsletter} record
+   * @returns {NewsletterViewModel}
+   */
+  public static mapToSingle(record: newsletter): NewsletterViewModel {
+    return {
+      id: record.id,
+      title: record.title,
+      description: record.description,
+      newsletterTitle: record.newsletterTitle,
+      newsletterText: record.newsletterText,
+      newsletterSignatur: record.newsletterSignatur,
+      isSent: record.isSent,
+      recipientsByQuery: record?.recipientsByQuery ? QueryStoreFactory.mapToSingle(record.recipientsByQuery) : null,
+    };
+  }
+
+  /**
+   * @description map records to newsletter
+   * @param {Array<newsletter>} records
+   * @returns {Array<NewsletterViewModel>}
+   */
+  public static mapToBase(records: Array<newsletter>): Array<NewsletterViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/factory/admin/newsletterDates.ts b/src/factory/admin/newsletterDates.ts
new file mode 100644
index 0000000..232e7ac
--- /dev/null
+++ b/src/factory/admin/newsletterDates.ts
@@ -0,0 +1,30 @@
+import { newsletterDates } from "../../entity/newsletterDates";
+import { NewsletterDatesViewModel } from "../../viewmodel/admin/newsletterDates.models";
+import CalendarFactory from "./calendar";
+import MemberFactory from "./member";
+
+export default abstract class NewsletterDatesFactory {
+  /**
+   * @description map record to newsletterDates
+   * @param {newsletterDates} record
+   * @returns {NewsletterDatesViewModel}
+   */
+  public static mapToSingle(record: newsletterDates): NewsletterDatesViewModel {
+    return {
+      newsletterId: record.newsletterId,
+      calendarId: record.calendarId,
+      diffTitle: record.diffTitle,
+      diffDescription: record.diffDescription,
+      calendar: CalendarFactory.mapToSingle(record.calendar),
+    };
+  }
+
+  /**
+   * @description map records to newsletterDates
+   * @param {Array<newsletterDates>} records
+   * @returns {Array<NewsletterDatesViewModel>}
+   */
+  public static mapToBase(records: Array<newsletterDates>): Array<NewsletterDatesViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/factory/admin/newsletterRecipients.ts b/src/factory/admin/newsletterRecipients.ts
new file mode 100644
index 0000000..f9373ef
--- /dev/null
+++ b/src/factory/admin/newsletterRecipients.ts
@@ -0,0 +1,28 @@
+import { newsletterRecipients } from "../../entity/newsletterRecipients";
+import { NewsletterRecipientsViewModel } from "../../viewmodel/admin/newsletterRecipients.models";
+import MemberFactory from "./member";
+
+export default abstract class NewsletterRecipientsFactory {
+  /**
+   * @description map record to newsletterRecipients
+   * @param {newsletterRecipients} record
+   * @returns {NewsletterRecipientsViewModel}
+   */
+  public static mapToSingle(record: newsletterRecipients): NewsletterRecipientsViewModel {
+    return {
+      newsletterId: record.newsletterId,
+      memberId: record.memberId,
+      addedManually: record.addedManually,
+      member: MemberFactory.mapToSingle(record.member),
+    };
+  }
+
+  /**
+   * @description map records to newsletterRecipients
+   * @param {Array<newsletterRecipients>} records
+   * @returns {Array<NewsletterRecipientsViewModel>}
+   */
+  public static mapToBase(records: Array<newsletterRecipients>): Array<NewsletterRecipientsViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/helpers/fileSystemHelper.ts b/src/helpers/fileSystemHelper.ts
new file mode 100644
index 0000000..fc6423e
--- /dev/null
+++ b/src/helpers/fileSystemHelper.ts
@@ -0,0 +1,31 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { readdirSync } from "fs";
+
+export abstract class FileSystemHelper {
+  static createFolder(newFolder: string) {
+    const exportPath = join(process.cwd(), "export", newFolder);
+    if (!existsSync(exportPath)) {
+      mkdirSync(exportPath, { recursive: true });
+    }
+  }
+
+  static readFile(filePath: string) {
+    return readFileSync(join(process.cwd(), filePath), "utf8");
+  }
+
+  static writeFile(filePath: string, file: any) {
+    writeFileSync(filePath, file);
+  }
+
+  static formatPath(...args: string[]) {
+    return join(...args);
+  }
+
+  static getFilesInDirectory(directoryPath: string, filetype?: string): string[] {
+    const fullPath = join(process.cwd(), directoryPath);
+    return readdirSync(fullPath, { withFileTypes: true })
+      .filter((dirent) => !dirent.isDirectory() && (!filetype || dirent.name.endsWith(filetype)))
+      .map((dirent) => dirent.name);
+  }
+}
diff --git a/src/helpers/pdfExport.ts b/src/helpers/pdfExport.ts
index 827f3db..519cc84 100644
--- a/src/helpers/pdfExport.ts
+++ b/src/helpers/pdfExport.ts
@@ -1,6 +1,8 @@
 import puppeteer from "puppeteer";
 import { TemplateHelper } from "./templateHelper";
 import { PermissionModule } from "../type/permissionTypes";
+import { FileSystemHelper } from "./fileSystemHelper";
+import { PDFDocument } from "pdf-lib";
 
 export abstract class PdfExport {
   static async renderFile({
@@ -10,6 +12,7 @@ export abstract class PdfExport {
     data = {},
     saveToDisk = true,
     margins = { top: "15mm", bottom: "15mm" },
+    folder = "",
   }: {
     template: PermissionModule;
     title?: string;
@@ -17,7 +20,10 @@ export abstract class PdfExport {
     data?: any;
     saveToDisk?: boolean;
     margins?: { top: string; bottom: string };
+    folder?: string;
   }) {
+    if (folder != "") FileSystemHelper.createFolder(folder);
+
     const { header, footer, body } = await TemplateHelper.renderFileForModule({
       module: template,
       bodyData: data,
@@ -31,8 +37,10 @@ export abstract class PdfExport {
     const page = await browser.newPage();
     await page.setContent(body, { waitUntil: "domcontentloaded" });
 
+    const exportPath = FileSystemHelper.formatPath(process.cwd(), "export", folder, `${filename}.pdf`);
+
     let pdf = await page.pdf({
-      ...(saveToDisk ? { path: process.cwd() + `/export/${filename}.pdf` } : {}),
+      ...(saveToDisk ? { path: exportPath } : {}),
       format: "A4",
       printBackground: false,
       margin: {
@@ -50,4 +58,25 @@ export abstract class PdfExport {
 
     return pdf;
   }
+
+  static async sqashToSingleFile(inputFolder: string, outputFile: string, outputFolder: string = "") {
+    if (outputFolder != "") FileSystemHelper.createFolder(outputFolder);
+
+    let pdfFilePaths = FileSystemHelper.getFilesInDirectory(inputFolder, ".pdf");
+
+    const mergedPdf = await PDFDocument.create();
+
+    for (const pdfPath of pdfFilePaths) {
+      const pdfBytes = FileSystemHelper.readFile(pdfPath);
+      const pdf = await PDFDocument.load(pdfBytes);
+      const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+      copiedPages.forEach((page) => mergedPdf.addPage(page));
+    }
+
+    const mergedPdfBytes = await mergedPdf.save();
+
+    const exportPath = FileSystemHelper.formatPath(process.cwd(), "export", outputFolder, `${outputFile}.pdf`);
+
+    FileSystemHelper.writeFile(exportPath, mergedPdfBytes);
+  }
 }
diff --git a/src/helpers/templateHelper.ts b/src/helpers/templateHelper.ts
index 04a0874..c6cf289 100644
--- a/src/helpers/templateHelper.ts
+++ b/src/helpers/templateHelper.ts
@@ -1,12 +1,12 @@
-import { readFileSync } from "fs";
 import TemplateService from "../service/templateService";
 import { PermissionModule } from "../type/permissionTypes";
 import TemplateUsageService from "../service/templateUsageService";
 import Handlebars from "handlebars";
+import { FileSystemHelper } from "./fileSystemHelper";
 
 export abstract class TemplateHelper {
   static getTemplateFromFile(template: string) {
-    return readFileSync(`${process.cwd()}/src/templates/${template}.template.html`, "utf8");
+    return FileSystemHelper.readFile(`/src/templates/${template}.template.html`);
   }
 
   static async getTemplateFromStore(templateId: number): Promise<string> {
diff --git a/src/migrations/1735118780511-newsletter.ts b/src/migrations/1735118780511-newsletter.ts
new file mode 100644
index 0000000..6308425
--- /dev/null
+++ b/src/migrations/1735118780511-newsletter.ts
@@ -0,0 +1,129 @@
+import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
+import { DB_TYPE } from "../env.defaults";
+
+export class Newsletter1735118780511 implements MigrationInterface {
+  name = "Newsletter1735118780511";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
+
+    await queryRunner.createTable(
+      new Table({
+        name: "newsletter_dates",
+        columns: [
+          { name: "newsletterId", type: variableType_int, isPrimary: true },
+          { name: "calendarId", type: "varchar", length: "255", isPrimary: true },
+          { name: "diffTitle", type: "varchar", length: "255", isNullable: true },
+          { name: "diffDescription", type: "text", isNullable: true },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        name: "newsletter_recipients",
+        columns: [
+          { name: "newsletterId", type: variableType_int, isPrimary: true },
+          { name: "memberId", type: variableType_int, isPrimary: true },
+          { name: "addedManually", type: "tinyint", default: "0" },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        name: "newsletter",
+        columns: [
+          { name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
+          { name: "title", type: "varchar", length: "255" },
+          { name: "description", type: "varchar", length: "255", default: "''" },
+          { name: "newsletterTitle", type: "varchar", length: "255", default: "''" },
+          { name: "newsletterText", type: "text", default: "''" },
+          { name: "newsletterSignatur", type: "varchar", length: "255", default: "''" },
+          { name: "isSent", type: "tinyint", default: "0" },
+          { name: "recipientsByQueryId", type: variableType_int, isNullable: true },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter_dates",
+      new TableForeignKey({
+        columnNames: ["newsletterId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "newsletter",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter_dates",
+      new TableForeignKey({
+        columnNames: ["calendarId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "calendar",
+        onDelete: "RESTRICT",
+        onUpdate: "RESTRICT",
+      })
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter_recipients",
+      new TableForeignKey({
+        columnNames: ["newsletterId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "newsletter",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter_recipients",
+      new TableForeignKey({
+        columnNames: ["memberId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "member",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter",
+      new TableForeignKey({
+        columnNames: ["recipientsByQueryId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "query",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const tableN = await queryRunner.getTable("newsletter");
+    const tableNR = await queryRunner.getTable("newsletter_recipients");
+    const tableND = await queryRunner.getTable("newsletter_dates");
+
+    const foreignKeyN = tableN.foreignKeys.find((fk) => fk.columnNames.indexOf("recipientsByQueryId") !== -1);
+    const foreignKeyNR = tableNR.foreignKeys.find((fk) => fk.columnNames.indexOf("newsletterId") !== -1);
+    const foreignKeyNR2 = tableNR.foreignKeys.find((fk) => fk.columnNames.indexOf("memberId") !== -1);
+    const foreignKeyND1 = tableND.foreignKeys.find((fk) => fk.columnNames.indexOf("newsletterId") !== -1);
+    const foreignKeyND2 = tableND.foreignKeys.find((fk) => fk.columnNames.indexOf("calendarId") !== -1);
+
+    await queryRunner.dropForeignKey("newsletter", foreignKeyN);
+    await queryRunner.dropForeignKey("newsletter_recipients", foreignKeyNR);
+    await queryRunner.dropForeignKey("newsletter_recipients", foreignKeyNR2);
+    await queryRunner.dropForeignKey("newsletter_dates", foreignKeyND1);
+    await queryRunner.dropForeignKey("newsletter_dates", foreignKeyND2);
+
+    await queryRunner.dropTable("newsletter");
+    await queryRunner.dropTable("newsletter_recipients");
+    await queryRunner.dropTable("newsletter_dates");
+  }
+}
diff --git a/src/routes/admin/index.ts b/src/routes/admin/index.ts
index f1c6982..4da8c12 100644
--- a/src/routes/admin/index.ts
+++ b/src/routes/admin/index.ts
@@ -15,6 +15,7 @@ import member from "./member";
 import protocol from "./protocol";
 import calendar from "./calendar";
 import queryBuilder from "./queryBuilder";
+import newsletter from "./newsletter";
 
 import role from "./role";
 import user from "./user";
@@ -48,6 +49,7 @@ router.use("/member", PermissionHelper.passCheckMiddleware("read", "club", "memb
 router.use("/protocol", PermissionHelper.passCheckMiddleware("read", "club", "protocol"), protocol);
 router.use("/calendar", PermissionHelper.passCheckMiddleware("read", "club", "calendar"), calendar);
 router.use("/querybuilder", PermissionHelper.passCheckMiddleware("read", "club", "query"), queryBuilder);
+router.use("/newsletter", PermissionHelper.passCheckMiddleware("read", "club", "newsletter"), newsletter);
 
 router.use("/role", PermissionHelper.passCheckMiddleware("read", "user", "role"), role);
 router.use("/user", PermissionHelper.passCheckMiddleware("read", "user", "user"), user);
diff --git a/src/routes/admin/newsletter.ts b/src/routes/admin/newsletter.ts
new file mode 100644
index 0000000..c721810
--- /dev/null
+++ b/src/routes/admin/newsletter.ts
@@ -0,0 +1,85 @@
+import express, { Request, Response } from "express";
+import {
+  createNewsletter,
+  createNewsletterPrintoutById,
+  getAllNewsletters,
+  getNewsletterDatesById,
+  getNewsletterById,
+  getNewsletterRecipientsById,
+  getNewsletterPrintoutByIdAndPrint,
+  getNewsletterPrintoutsById,
+  synchronizeNewsletterDatesById,
+  synchronizeNewsletterById,
+  synchronizeNewsletterRecipientsById,
+} from "../../controller/admin/newsletterController";
+import PermissionHelper from "../../helpers/permissionHelper";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllNewsletters(req, res);
+});
+
+router.get("/:id", async (req: Request, res: Response) => {
+  await getNewsletterById(req, res);
+});
+
+router.get("/:protocolId/dates", async (req: Request, res: Response) => {
+  await getNewsletterDatesById(req, res);
+});
+
+router.get("/:protocolId/recipients", async (req: Request, res: Response) => {
+  await getNewsletterRecipientsById(req, res);
+});
+
+router.get("/:protocolId/printouts", async (req: Request, res: Response) => {
+  await getNewsletterPrintoutsById(req, res);
+});
+
+router.get("/:protocolId/printout/:filename", async (req: Request, res: Response) => {
+  await getNewsletterPrintoutByIdAndPrint(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await createNewsletter(req, res);
+  }
+);
+
+router.post(
+  "/:protocolId/printout",
+  PermissionHelper.passCheckMiddleware("create", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await createNewsletterPrintoutById(req, res);
+  }
+);
+
+router.patch(
+  "/:id/synchronize",
+  PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await synchronizeNewsletterById(req, res);
+  }
+);
+
+router.patch(
+  "/:protocolId/synchronize/dates",
+  PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await synchronizeNewsletterDatesById(req, res);
+  }
+);
+
+router.patch(
+  "/:protocolId/synchronize/recipients",
+  PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await synchronizeNewsletterRecipientsById(req, res);
+  }
+);
+
+// TODO: send mails | send mail preview | render preview before print job
+
+export default router;
diff --git a/src/service/newsletterDatesService.ts b/src/service/newsletterDatesService.ts
new file mode 100644
index 0000000..5152de0
--- /dev/null
+++ b/src/service/newsletterDatesService.ts
@@ -0,0 +1,26 @@
+import { dataSource } from "../data-source";
+import { newsletterDates } from "../entity/newsletterDates";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterDatesService {
+  /**
+   * @description get all newsletterDates
+   * @returns {Promise<Array<newsletterDates>>}
+   */
+  static async getAll(newsletterId: number): Promise<Array<newsletterDates>> {
+    return await dataSource
+      .getRepository(newsletterDates)
+      .createQueryBuilder("newsletterDates")
+      .leftJoinAndSelect("newsletterDates.calendar", "calendar")
+      .leftJoinAndSelect("newsletterDates.newsletter", "newsletter")
+      .where("newsletterDates.newsletterId = :id", { id: newsletterId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterDatess not found", err);
+      });
+  }
+}
diff --git a/src/service/newsletterRecipientsService.ts b/src/service/newsletterRecipientsService.ts
new file mode 100644
index 0000000..923ad0d
--- /dev/null
+++ b/src/service/newsletterRecipientsService.ts
@@ -0,0 +1,28 @@
+import { dataSource } from "../data-source";
+import { newsletterRecipients } from "../entity/newsletterRecipients";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterRecipientsService {
+  /**
+   * @description get all newsletterRecipients
+   * @returns {Promise<Array<newsletterRecipients>>}
+   */
+  static async getAll(newsletterId: number): Promise<Array<newsletterRecipients>> {
+    return await dataSource
+      .getRepository(newsletterRecipients)
+      .createQueryBuilder("newsletterRecipients")
+      .leftJoinAndSelect("newsletterRecipients.member", "member")
+      .leftJoinAndSelect("member.sendNewsletter", "sendNewsletter")
+      .leftJoinAndSelect("sendNewsletter.type", "communicationtype")
+      .leftJoinAndSelect("newsletterRecipients.newsletter", "newsletter")
+      .where("newsletterDates.newsletterId = :id", { id: newsletterId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterRecipientss not found", err);
+      });
+  }
+}
diff --git a/src/service/newsletterService.ts b/src/service/newsletterService.ts
new file mode 100644
index 0000000..cd05747
--- /dev/null
+++ b/src/service/newsletterService.ts
@@ -0,0 +1,44 @@
+import { dataSource } from "../data-source";
+import { newsletter } from "../entity/newsletter";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterService {
+  /**
+   * @description get all newsletters
+   * @returns {Promise<[Array<newsletter>, number]>}
+   */
+  static async getAll(offset: number = 0, count: number = 25): Promise<[Array<newsletter>, number]> {
+    return await dataSource
+      .getRepository(newsletter)
+      .createQueryBuilder("newsletter")
+      .offset(offset)
+      .limit(count)
+      .getManyAndCount()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletters not found", err);
+      });
+  }
+
+  /**
+   * @description get newsletter by id
+   * @returns {Promise<newsletter>}
+   */
+  static async getById(id: number): Promise<newsletter> {
+    return await dataSource
+      .getRepository(newsletter)
+      .createQueryBuilder("newsletter")
+      .leftJoinAndSelect("newsletter.recipientsByQuery", "query")
+      .where("newsletter.id = :id", { id: id })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletter not found by id", err);
+      });
+  }
+}
diff --git a/src/service/protocolPrecenseService.ts b/src/service/protocolPrecenseService.ts
index c8840c3..2fc9c94 100644
--- a/src/service/protocolPrecenseService.ts
+++ b/src/service/protocolPrecenseService.ts
@@ -21,23 +21,4 @@ export default abstract class ProtocolPresenceService {
         throw new InternalException("protocolPresence not found", err);
       });
   }
-
-  /**
-   * @description get protocolDecision by id
-   * @returns {Promise<protocolPresence>}
-   */
-  static async getById(id: number): Promise<protocolPresence> {
-    return await dataSource
-      .getRepository(protocolPresence)
-      .createQueryBuilder("protocolPresence")
-      .leftJoinAndSelect("protocolPresence.member", "member")
-      .where("protocolPresence.id = :id", { id: id })
-      .getOneOrFail()
-      .then((res) => {
-        return res;
-      })
-      .catch((err) => {
-        throw new InternalException("protocolDecision not found by id", err);
-      });
-  }
 }
diff --git a/src/type/permissionTypes.ts b/src/type/permissionTypes.ts
index 34e2be9..95ea543 100644
--- a/src/type/permissionTypes.ts
+++ b/src/type/permissionTypes.ts
@@ -4,6 +4,7 @@ export type PermissionModule =
   | "member"
   | "calendar"
   | "newsletter"
+  | "newsletter_config"
   | "protocol"
   | "qualification"
   | "award"
@@ -44,6 +45,7 @@ export const permissionModules: Array<PermissionModule> = [
   "member",
   "calendar",
   "newsletter",
+  "newsletter_config",
   "protocol",
   "qualification",
   "award",
@@ -71,6 +73,7 @@ export const sectionsAndModules: SectionsAndModulesObject = {
     "query_store",
     "template",
     "template_usage",
+    "newsletter_config",
   ],
   user: ["user", "role"],
 };
diff --git a/src/viewmodel/admin/newsletter.models.ts b/src/viewmodel/admin/newsletter.models.ts
new file mode 100644
index 0000000..b68814f
--- /dev/null
+++ b/src/viewmodel/admin/newsletter.models.ts
@@ -0,0 +1,12 @@
+import { QueryStoreViewModel } from "./queryStore.models";
+
+export interface NewsletterViewModel {
+  id: number;
+  title: string;
+  description: string;
+  newsletterTitle: string;
+  newsletterText: string;
+  newsletterSignatur: string;
+  isSent: boolean;
+  recipientsByQuery?: QueryStoreViewModel;
+}
diff --git a/src/viewmodel/admin/newsletterDates.models.ts b/src/viewmodel/admin/newsletterDates.models.ts
new file mode 100644
index 0000000..a1bf0cc
--- /dev/null
+++ b/src/viewmodel/admin/newsletterDates.models.ts
@@ -0,0 +1,9 @@
+import { CalendarViewModel } from "./calendar.models";
+
+export interface NewsletterDatesViewModel {
+  newsletterId: number;
+  calendarId: number;
+  diffTitle: string | null;
+  diffDescription: string | null;
+  calendar: CalendarViewModel;
+}
diff --git a/src/viewmodel/admin/newsletterRecipients.models.ts b/src/viewmodel/admin/newsletterRecipients.models.ts
new file mode 100644
index 0000000..55160f9
--- /dev/null
+++ b/src/viewmodel/admin/newsletterRecipients.models.ts
@@ -0,0 +1,8 @@
+import { MemberViewModel } from "./member.models";
+
+export interface NewsletterRecipientsViewModel {
+  newsletterId: number;
+  memberId: number;
+  addedManually: boolean;
+  member: MemberViewModel;
+}

From 7d36ed3121152b9a8af2f08e118d943af143dce3 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Thu, 26 Dec 2024 11:08:48 +0100
Subject: [PATCH 08/16] newsletter config CRUD

---
 src/command/newsletterConfigCommand.ts        |  6 +++
 src/command/newsletterConfigCommandHandler.ts | 30 ++++++++++++
 .../admin/newsletterConfigController.ts       | 49 +++++++++++++++++++
 src/controller/admin/newsletterController.ts  |  1 +
 src/data-source.ts                            |  4 ++
 src/entity/newsletterConfig.ts                | 30 ++++++++++++
 src/enums/newsletterConfigType.ts             |  4 ++
 src/factory/admin/newsletterConfig.ts         | 27 ++++++++++
 .../1735207446910-newsletterConfig.ts         | 39 +++++++++++++++
 src/routes/admin/index.ts                     |  6 +++
 src/routes/admin/newsletterConfig.ts          | 27 ++++++++++
 src/service/newsletterConfigService.ts        | 43 ++++++++++++++++
 src/service/newsletterService.ts              |  1 -
 .../admin/newsletterConfig.models.ts          |  8 +++
 14 files changed, 274 insertions(+), 1 deletion(-)
 create mode 100644 src/command/newsletterConfigCommand.ts
 create mode 100644 src/command/newsletterConfigCommandHandler.ts
 create mode 100644 src/controller/admin/newsletterConfigController.ts
 create mode 100644 src/entity/newsletterConfig.ts
 create mode 100644 src/enums/newsletterConfigType.ts
 create mode 100644 src/factory/admin/newsletterConfig.ts
 create mode 100644 src/migrations/1735207446910-newsletterConfig.ts
 create mode 100644 src/routes/admin/newsletterConfig.ts
 create mode 100644 src/service/newsletterConfigService.ts
 create mode 100644 src/viewmodel/admin/newsletterConfig.models.ts

diff --git a/src/command/newsletterConfigCommand.ts b/src/command/newsletterConfigCommand.ts
new file mode 100644
index 0000000..861e3e3
--- /dev/null
+++ b/src/command/newsletterConfigCommand.ts
@@ -0,0 +1,6 @@
+import { NewsletterConfigType } from "../enums/newsletterConfigType";
+
+export interface SetNewsletterConfigCommand {
+  comTypeId: number;
+  config: NewsletterConfigType;
+}
diff --git a/src/command/newsletterConfigCommandHandler.ts b/src/command/newsletterConfigCommandHandler.ts
new file mode 100644
index 0000000..d054c38
--- /dev/null
+++ b/src/command/newsletterConfigCommandHandler.ts
@@ -0,0 +1,30 @@
+import { dataSource } from "../data-source";
+import { newsletterConfig } from "../entity/newsletterConfig";
+import InternalException from "../exceptions/internalException";
+import { SetNewsletterConfigCommand } from "./newsletterConfigCommand";
+
+export default abstract class NewsletterConfigCommandHandler {
+  /**
+   * @description set newsletterConfig
+   * @param SetNewsletterConfigCommand
+   * @returns {Promise<number>}
+   */
+  static async setConfig(setNewsletterConfig: SetNewsletterConfigCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(newsletterConfig)
+      .values({
+        comTypeId: setNewsletterConfig.comTypeId,
+        config: setNewsletterConfig.config,
+      })
+      .orUpdate(["config"], "comTypeId")
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed setting newsletterConfig", err);
+      });
+  }
+}
diff --git a/src/controller/admin/newsletterConfigController.ts b/src/controller/admin/newsletterConfigController.ts
new file mode 100644
index 0000000..790d093
--- /dev/null
+++ b/src/controller/admin/newsletterConfigController.ts
@@ -0,0 +1,49 @@
+import { Request, Response } from "express";
+import NewsletterConfigService from "../../service/newsletterConfigService";
+import NewsletterConfigFactory from "../../factory/admin/newsletterConfig";
+import NewsletterConfigCommandHandler from "../../command/newsletterConfigCommandHandler";
+import { SetNewsletterConfigCommand } from "../../command/newsletterConfigCommand";
+
+/**
+ * @description get all newsletterConfigs
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllNewsletterConfigs(req: Request, res: Response): Promise<any> {
+  let newsletterConfigs = await NewsletterConfigService.getAll();
+
+  res.json(NewsletterConfigFactory.mapToBase(newsletterConfigs));
+}
+
+/**
+ * @description get newsletterConfig by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterConfigById(req: Request, res: Response): Promise<any> {
+  let comId = parseInt(req.params.comId);
+  let newsletterConfig = await NewsletterConfigService.getByComId(comId);
+
+  res.json(NewsletterConfigFactory.mapToSingle(newsletterConfig));
+}
+
+/**
+ * @description set newsletterConfig
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function setNewsletterConfig(req: Request, res: Response): Promise<any> {
+  let comTypeId = req.body.comTypeId;
+  let config = req.body.config;
+
+  let createNewsletterConfig: SetNewsletterConfigCommand = {
+    comTypeId,
+    config,
+  };
+  let id = await NewsletterConfigCommandHandler.setConfig(createNewsletterConfig);
+
+  res.send(id);
+}
diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index 1d4efb0..11bf8c2 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -146,6 +146,7 @@ export async function createNewsletterPrintoutById(req: Request, res: Response):
   // 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);
 }
diff --git a/src/data-source.ts b/src/data-source.ts
index 7b97e03..7e8321f 100644
--- a/src/data-source.ts
+++ b/src/data-source.ts
@@ -59,6 +59,8 @@ import { newsletter } from "./entity/newsletter";
 import { newsletterDates } from "./entity/newsletterDates";
 import { newsletterRecipients } from "./entity/newsletterRecipients";
 import { Newsletter1735118780511 } from "./migrations/1735118780511-newsletter";
+import { newsletterConfig } from "./entity/newsletterConfig";
+import { NewsletterConfig1735207446910 } from "./migrations/1735207446910-newsletterConfig";
 
 const dataSource = new DataSource({
   type: DB_TYPE as any,
@@ -103,6 +105,7 @@ const dataSource = new DataSource({
     newsletter,
     newsletterDates,
     newsletterRecipients,
+    newsletterConfig,
     memberView,
     memberExecutivePositionsView,
     memberQualificationsView,
@@ -128,6 +131,7 @@ const dataSource = new DataSource({
     Template1734854680201,
     TemplateUsage1734949173739,
     Newsletter1735118780511,
+    NewsletterConfig1735207446910,
   ],
   migrationsRun: true,
   migrationsTransactionMode: "each",
diff --git a/src/entity/newsletterConfig.ts b/src/entity/newsletterConfig.ts
new file mode 100644
index 0000000..6ad74ab
--- /dev/null
+++ b/src/entity/newsletterConfig.ts
@@ -0,0 +1,30 @@
+import { Column, Entity, ManyToOne, PrimaryColumn } from "typeorm";
+import { NewsletterConfigType } from "../enums/newsletterConfigType";
+import { communicationType } from "./communicationType";
+
+@Entity()
+export class newsletterConfig {
+  @PrimaryColumn({ type: "int" })
+  comTypeId: number;
+
+  @Column({
+    type: "varchar",
+    length: "255",
+    transformer: {
+      to(value: NewsletterConfigType) {
+        return value.toString();
+      },
+      from(value: string) {
+        return NewsletterConfigType[value as keyof typeof NewsletterConfigType];
+      },
+    },
+  })
+  config: NewsletterConfigType;
+
+  @ManyToOne(() => communicationType, {
+    nullable: false,
+    onDelete: "CASCADE",
+    onUpdate: "RESTRICT",
+  })
+  comType: communicationType;
+}
diff --git a/src/enums/newsletterConfigType.ts b/src/enums/newsletterConfigType.ts
new file mode 100644
index 0000000..4703494
--- /dev/null
+++ b/src/enums/newsletterConfigType.ts
@@ -0,0 +1,4 @@
+export enum NewsletterConfigType {
+  pdf = "pdf",
+  mail = "mail",
+}
diff --git a/src/factory/admin/newsletterConfig.ts b/src/factory/admin/newsletterConfig.ts
new file mode 100644
index 0000000..854bd83
--- /dev/null
+++ b/src/factory/admin/newsletterConfig.ts
@@ -0,0 +1,27 @@
+import { newsletterConfig } from "../../entity/newsletterConfig";
+import { NewsletterConfigViewModel } from "../../viewmodel/admin/newsletterConfig.models";
+import CommunicationTypeFactory from "./communicationType";
+
+export default abstract class NewsletterConfigFactory {
+  /**
+   * @description map record to newsletterConfig
+   * @param {newsletterConfig} record
+   * @returns {NewsletterConfigViewModel}
+   */
+  public static mapToSingle(record: newsletterConfig): NewsletterConfigViewModel {
+    return {
+      comTypeId: record.comTypeId,
+      config: record.config,
+      comType: record?.comType ? CommunicationTypeFactory.mapToSingle(record.comType) : null,
+    };
+  }
+
+  /**
+   * @description map records to newsletterConfig
+   * @param {Array<newsletterConfig>} records
+   * @returns {Array<NewsletterConfigViewModel>}
+   */
+  public static mapToBase(records: Array<newsletterConfig>): Array<NewsletterConfigViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}
diff --git a/src/migrations/1735207446910-newsletterConfig.ts b/src/migrations/1735207446910-newsletterConfig.ts
new file mode 100644
index 0000000..8f893d9
--- /dev/null
+++ b/src/migrations/1735207446910-newsletterConfig.ts
@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
+import { DB_TYPE } from "../env.defaults";
+
+export class NewsletterConfig1735207446910 implements MigrationInterface {
+  name = "NewsletterConfig1735207446910";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
+
+    await queryRunner.createTable(
+      new Table({
+        name: "newsletter_config",
+        columns: [
+          { name: "comTypeId", type: variableType_int, isPrimary: true, isNullable: false },
+          { name: "config", type: "varchar", length: "255", isNullable: false },
+        ],
+      }),
+      true
+    );
+
+    await queryRunner.createForeignKey(
+      "newsletter_config",
+      new TableForeignKey({
+        columnNames: ["comTypeId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "communication_type",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable("newsletter_config");
+    const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("comTypeId") !== -1);
+    await queryRunner.dropForeignKey("newsletter_config", foreignKey);
+    await queryRunner.dropTable("newsletter_config");
+  }
+}
diff --git a/src/routes/admin/index.ts b/src/routes/admin/index.ts
index 4da8c12..8d627af 100644
--- a/src/routes/admin/index.ts
+++ b/src/routes/admin/index.ts
@@ -10,6 +10,7 @@ import calendarType from "./calendarType";
 import queryStore from "./queryStore";
 import template from "./template";
 import templateUsage from "./templateUsage";
+import newsletterConfig from "./newsletterConfig";
 
 import member from "./member";
 import protocol from "./protocol";
@@ -44,6 +45,11 @@ router.use("/calendartype", PermissionHelper.passCheckMiddleware("read", "settin
 router.use("/querystore", PermissionHelper.passCheckMiddleware("read", "settings", "query_store"), queryStore);
 router.use("/template", PermissionHelper.passCheckMiddleware("read", "settings", "template"), template);
 router.use("/templateusage", PermissionHelper.passCheckMiddleware("read", "settings", "template_usage"), templateUsage);
+router.use(
+  "/newsletterconfig",
+  PermissionHelper.passCheckMiddleware("read", "settings", "newsletter_config"),
+  newsletterConfig
+);
 
 router.use("/member", PermissionHelper.passCheckMiddleware("read", "club", "member"), member);
 router.use("/protocol", PermissionHelper.passCheckMiddleware("read", "club", "protocol"), protocol);
diff --git a/src/routes/admin/newsletterConfig.ts b/src/routes/admin/newsletterConfig.ts
new file mode 100644
index 0000000..c1be19d
--- /dev/null
+++ b/src/routes/admin/newsletterConfig.ts
@@ -0,0 +1,27 @@
+import express, { Request, Response } from "express";
+import {
+  getAllNewsletterConfigs,
+  getNewsletterConfigById,
+  setNewsletterConfig,
+} from "../../controller/admin/newsletterConfigController";
+import PermissionHelper from "../../helpers/permissionHelper";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllNewsletterConfigs(req, res);
+});
+
+router.get("/:id", async (req: Request, res: Response) => {
+  await getNewsletterConfigById(req, res);
+});
+
+router.put(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "settings", "newsletter_config"),
+  async (req: Request, res: Response) => {
+    await setNewsletterConfig(req, res);
+  }
+);
+
+export default router;
diff --git a/src/service/newsletterConfigService.ts b/src/service/newsletterConfigService.ts
new file mode 100644
index 0000000..f85970d
--- /dev/null
+++ b/src/service/newsletterConfigService.ts
@@ -0,0 +1,43 @@
+import { dataSource } from "../data-source";
+import { newsletterConfig } from "../entity/newsletterConfig";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterConfigService {
+  /**
+   * @description get all newsletterConfigs
+   * @returns {Promise<Array<newsletterConfig>>}
+   */
+  static async getAll(): Promise<Array<newsletterConfig>> {
+    return await dataSource
+      .getRepository(newsletterConfig)
+      .createQueryBuilder("newsletterConfig")
+      .leftJoinAndSelect("newsletterConfig.comType", "comType")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterConfigs not found", err);
+      });
+  }
+
+  /**
+   * @description get newsletterConfig by id
+   * @returns {Promise<newsletterConfig>}
+   */
+  static async getByComId(comId: number): Promise<newsletterConfig> {
+    return await dataSource
+      .getRepository(newsletterConfig)
+      .createQueryBuilder("newsletterConfig")
+      .leftJoinAndSelect("newsletterConfig.comType", "comType")
+      .where("newsletterConfig.comTypId = :comTypId", { icomTypId: comId })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterConfig not found by cmId", err);
+      });
+  }
+}
diff --git a/src/service/newsletterService.ts b/src/service/newsletterService.ts
index cd05747..f522233 100644
--- a/src/service/newsletterService.ts
+++ b/src/service/newsletterService.ts
@@ -1,6 +1,5 @@
 import { dataSource } from "../data-source";
 import { newsletter } from "../entity/newsletter";
-import { member } from "../entity/member";
 import InternalException from "../exceptions/internalException";
 
 export default abstract class NewsletterService {
diff --git a/src/viewmodel/admin/newsletterConfig.models.ts b/src/viewmodel/admin/newsletterConfig.models.ts
new file mode 100644
index 0000000..d21e4bf
--- /dev/null
+++ b/src/viewmodel/admin/newsletterConfig.models.ts
@@ -0,0 +1,8 @@
+import { NewsletterConfigType } from "../../enums/newsletterConfigType";
+import { CommunicationTypeViewModel } from "./communicationType.models";
+
+export interface NewsletterConfigViewModel {
+  comTypeId: number;
+  config: NewsletterConfigType;
+  comType: CommunicationTypeViewModel;
+}

From 4180da5749c441734fe93b498fd3088bf6fe1474 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Thu, 26 Dec 2024 12:04:12 +0100
Subject: [PATCH 09/16] extend newstellter config

---
 src/command/newsletterConfigCommand.ts        |  4 ++++
 src/command/newsletterConfigCommandHandler.ts | 21 +++++++++++++++++--
 .../admin/newsletterConfigController.ts       | 21 +++++++++++++++++--
 src/routes/admin/newsletterConfig.ts          |  9 ++++++++
 4 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/src/command/newsletterConfigCommand.ts b/src/command/newsletterConfigCommand.ts
index 861e3e3..011bc11 100644
--- a/src/command/newsletterConfigCommand.ts
+++ b/src/command/newsletterConfigCommand.ts
@@ -4,3 +4,7 @@ export interface SetNewsletterConfigCommand {
   comTypeId: number;
   config: NewsletterConfigType;
 }
+
+export interface DeleteNewsletterConfigCommand {
+  comTypeId: number;
+}
diff --git a/src/command/newsletterConfigCommandHandler.ts b/src/command/newsletterConfigCommandHandler.ts
index d054c38..6f6b948 100644
--- a/src/command/newsletterConfigCommandHandler.ts
+++ b/src/command/newsletterConfigCommandHandler.ts
@@ -1,7 +1,7 @@
 import { dataSource } from "../data-source";
 import { newsletterConfig } from "../entity/newsletterConfig";
 import InternalException from "../exceptions/internalException";
-import { SetNewsletterConfigCommand } from "./newsletterConfigCommand";
+import { DeleteNewsletterConfigCommand, SetNewsletterConfigCommand } from "./newsletterConfigCommand";
 
 export default abstract class NewsletterConfigCommandHandler {
   /**
@@ -9,7 +9,7 @@ export default abstract class NewsletterConfigCommandHandler {
    * @param SetNewsletterConfigCommand
    * @returns {Promise<number>}
    */
-  static async setConfig(setNewsletterConfig: SetNewsletterConfigCommand): Promise<number> {
+  static async set(setNewsletterConfig: SetNewsletterConfigCommand): Promise<number> {
     return await dataSource
       .createQueryBuilder()
       .insert()
@@ -27,4 +27,21 @@ export default abstract class NewsletterConfigCommandHandler {
         throw new InternalException("Failed setting newsletterConfig", err);
       });
   }
+  /**
+   * @description delete newsletterConfig
+   * @param number
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteNewsletterConfig: DeleteNewsletterConfigCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(newsletterConfig)
+      .where("comTypeId = :comTypeId", { comTypeId: deleteNewsletterConfig.comTypeId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed setting newsletterConfig", err);
+      });
+  }
 }
diff --git a/src/controller/admin/newsletterConfigController.ts b/src/controller/admin/newsletterConfigController.ts
index 790d093..3abe4b5 100644
--- a/src/controller/admin/newsletterConfigController.ts
+++ b/src/controller/admin/newsletterConfigController.ts
@@ -2,7 +2,7 @@ import { Request, Response } from "express";
 import NewsletterConfigService from "../../service/newsletterConfigService";
 import NewsletterConfigFactory from "../../factory/admin/newsletterConfig";
 import NewsletterConfigCommandHandler from "../../command/newsletterConfigCommandHandler";
-import { SetNewsletterConfigCommand } from "../../command/newsletterConfigCommand";
+import { DeleteNewsletterConfigCommand, SetNewsletterConfigCommand } from "../../command/newsletterConfigCommand";
 
 /**
  * @description get all newsletterConfigs
@@ -43,7 +43,24 @@ export async function setNewsletterConfig(req: Request, res: Response): Promise<
     comTypeId,
     config,
   };
-  let id = await NewsletterConfigCommandHandler.setConfig(createNewsletterConfig);
+  let id = await NewsletterConfigCommandHandler.set(createNewsletterConfig);
 
   res.send(id);
 }
+
+/**
+ * @description delete award
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteNewsletterConfig(req: Request, res: Response): Promise<any> {
+  const comTypeId = parseInt(req.params.comTypeId);
+
+  let deleteNewsletterConfig: DeleteNewsletterConfigCommand = {
+    comTypeId: comTypeId,
+  };
+  await NewsletterConfigCommandHandler.delete(deleteNewsletterConfig);
+
+  res.sendStatus(204);
+}
diff --git a/src/routes/admin/newsletterConfig.ts b/src/routes/admin/newsletterConfig.ts
index c1be19d..05cb0e9 100644
--- a/src/routes/admin/newsletterConfig.ts
+++ b/src/routes/admin/newsletterConfig.ts
@@ -1,5 +1,6 @@
 import express, { Request, Response } from "express";
 import {
+  deleteNewsletterConfig,
   getAllNewsletterConfigs,
   getNewsletterConfigById,
   setNewsletterConfig,
@@ -24,4 +25,12 @@ router.put(
   }
 );
 
+router.delete(
+  "/:comTypeId",
+  PermissionHelper.passCheckMiddleware("create", "settings", "newsletter_config"),
+  async (req: Request, res: Response) => {
+    await deleteNewsletterConfig(req, res);
+  }
+);
+
 export default router;

From 6dcd650cade61c97e49617dba213cba5bf809802 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Thu, 26 Dec 2024 12:34:31 +0100
Subject: [PATCH 10/16] update newsletter syncing commands and controller

---
 src/command/newsletterRecipientsCommand.ts    |  7 +--
 .../newsletterRecipientsCommandHandler.ts     | 43 +++++--------------
 src/controller/admin/newsletterController.ts  |  7 +--
 src/entity/newsletterRecipients.ts            |  3 --
 src/factory/admin/newsletter.ts               |  1 +
 src/factory/admin/newsletterRecipients.ts     |  1 -
 src/migrations/1735118780511-newsletter.ts    |  1 -
 src/viewmodel/admin/newsletter.models.ts      |  1 +
 .../admin/newsletterRecipients.models.ts      |  1 -
 9 files changed, 16 insertions(+), 49 deletions(-)

diff --git a/src/command/newsletterRecipientsCommand.ts b/src/command/newsletterRecipientsCommand.ts
index fdd8928..ec69c35 100644
--- a/src/command/newsletterRecipientsCommand.ts
+++ b/src/command/newsletterRecipientsCommand.ts
@@ -1,9 +1,4 @@
 export interface SynchronizeNewsletterRecipientsCommand {
   newsletterId: number;
-  recipients: Array<NewsletterRecipientCommand>;
-}
-
-export interface NewsletterRecipientCommand {
-  memberId: number;
-  addedManually: boolean;
+  recipients: Array<number>;
 }
diff --git a/src/command/newsletterRecipientsCommandHandler.ts b/src/command/newsletterRecipientsCommandHandler.ts
index 0421c41..b321c71 100644
--- a/src/command/newsletterRecipientsCommandHandler.ts
+++ b/src/command/newsletterRecipientsCommandHandler.ts
@@ -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();
   }
diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index 11bf8c2..fa9f481 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -215,14 +215,11 @@ export async function synchronizeNewsletterDatesById(req: Request, res: Response
  */
 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 recipients = req.body.recipients as Array<number>;
 
   let syncRecipients: SynchronizeNewsletterRecipientsCommand = {
     newsletterId,
-    recipients: recipients.map((r) => ({
-      memberId: r.memberId,
-      addedManually: r.addedManually,
-    })),
+    recipients: recipients,
   };
   await NewsletterRecipientsCommandHandler.sync(syncRecipients);
 
diff --git a/src/entity/newsletterRecipients.ts b/src/entity/newsletterRecipients.ts
index 1f62a5a..b57bce4 100644
--- a/src/entity/newsletterRecipients.ts
+++ b/src/entity/newsletterRecipients.ts
@@ -10,9 +10,6 @@ export class newsletterRecipients {
   @PrimaryColumn({ type: "int" })
   memberId: number;
 
-  @Column({ type: "boolean", default: false })
-  addedManually: boolean;
-
   @ManyToOne(() => newsletter, (newsletter) => newsletter.recipients, {
     nullable: false,
     onDelete: "CASCADE",
diff --git a/src/factory/admin/newsletter.ts b/src/factory/admin/newsletter.ts
index 3dca651..d734564 100644
--- a/src/factory/admin/newsletter.ts
+++ b/src/factory/admin/newsletter.ts
@@ -17,6 +17,7 @@ export default abstract class NewsletterFactory {
       newsletterText: record.newsletterText,
       newsletterSignatur: record.newsletterSignatur,
       isSent: record.isSent,
+      recipientsByQueryId: record?.recipientsByQuery ? record.recipientsByQuery.id : null,
       recipientsByQuery: record?.recipientsByQuery ? QueryStoreFactory.mapToSingle(record.recipientsByQuery) : null,
     };
   }
diff --git a/src/factory/admin/newsletterRecipients.ts b/src/factory/admin/newsletterRecipients.ts
index f9373ef..9a1e332 100644
--- a/src/factory/admin/newsletterRecipients.ts
+++ b/src/factory/admin/newsletterRecipients.ts
@@ -12,7 +12,6 @@ export default abstract class NewsletterRecipientsFactory {
     return {
       newsletterId: record.newsletterId,
       memberId: record.memberId,
-      addedManually: record.addedManually,
       member: MemberFactory.mapToSingle(record.member),
     };
   }
diff --git a/src/migrations/1735118780511-newsletter.ts b/src/migrations/1735118780511-newsletter.ts
index 6308425..e9f79ea 100644
--- a/src/migrations/1735118780511-newsletter.ts
+++ b/src/migrations/1735118780511-newsletter.ts
@@ -26,7 +26,6 @@ export class Newsletter1735118780511 implements MigrationInterface {
         columns: [
           { name: "newsletterId", type: variableType_int, isPrimary: true },
           { name: "memberId", type: variableType_int, isPrimary: true },
-          { name: "addedManually", type: "tinyint", default: "0" },
         ],
       }),
       true
diff --git a/src/viewmodel/admin/newsletter.models.ts b/src/viewmodel/admin/newsletter.models.ts
index b68814f..cfd8b42 100644
--- a/src/viewmodel/admin/newsletter.models.ts
+++ b/src/viewmodel/admin/newsletter.models.ts
@@ -8,5 +8,6 @@ export interface NewsletterViewModel {
   newsletterText: string;
   newsletterSignatur: string;
   isSent: boolean;
+  recipientsByQueryId?: number;
   recipientsByQuery?: QueryStoreViewModel;
 }
diff --git a/src/viewmodel/admin/newsletterRecipients.models.ts b/src/viewmodel/admin/newsletterRecipients.models.ts
index 55160f9..a1030a7 100644
--- a/src/viewmodel/admin/newsletterRecipients.models.ts
+++ b/src/viewmodel/admin/newsletterRecipients.models.ts
@@ -3,6 +3,5 @@ import { MemberViewModel } from "./member.models";
 export interface NewsletterRecipientsViewModel {
   newsletterId: number;
   memberId: number;
-  addedManually: boolean;
   member: MemberViewModel;
 }

From dad54c97edca861b52a40ba0d7de6641328a2267 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Thu, 26 Dec 2024 13:57:31 +0100
Subject: [PATCH 11/16] fix newsletter routing and service

---
 src/controller/admin/newsletterController.ts |  4 ----
 src/entity/newsletter.ts                     |  3 +++
 src/routes/admin/newsletter.ts               | 14 +++++++-------
 src/service/newsletterRecipientsService.ts   |  4 ++--
 4 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index fa9f481..620687f 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -177,10 +177,6 @@ export async function synchronizeNewsletterById(req: Request, res: Response): Pr
   };
   await NewsletterCommandHandler.sync(syncNewsletter);
 
-  if (recipientsByQueryId) {
-    // TODO! set all recipients to query selection
-  }
-
   res.sendStatus(204);
 }
 
diff --git a/src/entity/newsletter.ts b/src/entity/newsletter.ts
index 0694d88..9393e53 100644
--- a/src/entity/newsletter.ts
+++ b/src/entity/newsletter.ts
@@ -27,6 +27,9 @@ export class newsletter {
   @Column({ type: "boolean", default: false })
   isSent: boolean;
 
+  @Column({ type: "int", nullable: true })
+  recipientsByQueryId?: number;
+
   @OneToMany(() => newsletterDates, (dates) => dates.newsletter)
   dates: newsletterDates[];
 
diff --git a/src/routes/admin/newsletter.ts b/src/routes/admin/newsletter.ts
index c721810..93bde92 100644
--- a/src/routes/admin/newsletter.ts
+++ b/src/routes/admin/newsletter.ts
@@ -24,19 +24,19 @@ router.get("/:id", async (req: Request, res: Response) => {
   await getNewsletterById(req, res);
 });
 
-router.get("/:protocolId/dates", async (req: Request, res: Response) => {
+router.get("/:newsletterId/dates", async (req: Request, res: Response) => {
   await getNewsletterDatesById(req, res);
 });
 
-router.get("/:protocolId/recipients", async (req: Request, res: Response) => {
+router.get("/:newsletterId/recipients", async (req: Request, res: Response) => {
   await getNewsletterRecipientsById(req, res);
 });
 
-router.get("/:protocolId/printouts", async (req: Request, res: Response) => {
+router.get("/:newsletterId/printouts", async (req: Request, res: Response) => {
   await getNewsletterPrintoutsById(req, res);
 });
 
-router.get("/:protocolId/printout/:filename", async (req: Request, res: Response) => {
+router.get("/:newsletterId/printout/:filename", async (req: Request, res: Response) => {
   await getNewsletterPrintoutByIdAndPrint(req, res);
 });
 
@@ -49,7 +49,7 @@ router.post(
 );
 
 router.post(
-  "/:protocolId/printout",
+  "/:newsletterId/printout",
   PermissionHelper.passCheckMiddleware("create", "club", "protocol"),
   async (req: Request, res: Response) => {
     await createNewsletterPrintoutById(req, res);
@@ -65,7 +65,7 @@ router.patch(
 );
 
 router.patch(
-  "/:protocolId/synchronize/dates",
+  "/:newsletterId/synchronize/dates",
   PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
   async (req: Request, res: Response) => {
     await synchronizeNewsletterDatesById(req, res);
@@ -73,7 +73,7 @@ router.patch(
 );
 
 router.patch(
-  "/:protocolId/synchronize/recipients",
+  "/:newsletterId/synchronize/recipients",
   PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
   async (req: Request, res: Response) => {
     await synchronizeNewsletterRecipientsById(req, res);
diff --git a/src/service/newsletterRecipientsService.ts b/src/service/newsletterRecipientsService.ts
index 923ad0d..8e0f9a5 100644
--- a/src/service/newsletterRecipientsService.ts
+++ b/src/service/newsletterRecipientsService.ts
@@ -16,13 +16,13 @@ export default abstract class NewsletterRecipientsService {
       .leftJoinAndSelect("member.sendNewsletter", "sendNewsletter")
       .leftJoinAndSelect("sendNewsletter.type", "communicationtype")
       .leftJoinAndSelect("newsletterRecipients.newsletter", "newsletter")
-      .where("newsletterDates.newsletterId = :id", { id: newsletterId })
+      .where("newsletterRecipients.newsletterId = :id", { id: newsletterId })
       .getMany()
       .then((res) => {
         return res;
       })
       .catch((err) => {
-        throw new InternalException("newsletterRecipientss not found", err);
+        throw new InternalException("newsletterRecipients not found", err);
       });
   }
 }

From d7b92aedc1549cd8923a0ced375b5a2357e4fb37 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Thu, 26 Dec 2024 19:35:29 +0100
Subject: [PATCH 12/16] typing and comparison

---
 src/command/newsletterDatesCommand.ts         |  2 +-
 src/command/newsletterDatesCommandHandler.ts  | 10 ++++++----
 src/controller/admin/newsletterController.ts  |  6 +++---
 src/entity/newsletterDates.ts                 |  4 ++--
 src/service/newsletterDatesService.ts         |  1 +
 src/viewmodel/admin/newsletterDates.models.ts |  2 +-
 6 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/command/newsletterDatesCommand.ts b/src/command/newsletterDatesCommand.ts
index 70d789f..5b92ba6 100644
--- a/src/command/newsletterDatesCommand.ts
+++ b/src/command/newsletterDatesCommand.ts
@@ -4,7 +4,7 @@ export interface SynchronizeNewsletterDatesCommand {
 }
 
 export interface NewsletterDateCommand {
-  calendarId: number;
+  calendarId: string;
   diffTitle?: string;
   diffDescription?: string;
 }
diff --git a/src/command/newsletterDatesCommandHandler.ts b/src/command/newsletterDatesCommandHandler.ts
index f1ec22b..99ee1ad 100644
--- a/src/command/newsletterDatesCommandHandler.ts
+++ b/src/command/newsletterDatesCommandHandler.ts
@@ -17,13 +17,15 @@ export default abstract class NewsletterDatesCommandHandler {
     return await dataSource.manager
       .transaction(async (manager) => {
         let newDates = syncNewsletterDates.dates.filter(
-          (r) => !currentDates.map((np) => np.calendarId).includes(r.calendarId)
+          (r) => !currentDates.some((cd) => cd.calendarId == r.calendarId)
         );
         let removeDates = currentDates.filter(
-          (r) => !syncNewsletterDates.dates.map((np) => np.calendarId).includes(r.calendarId)
+          (r) => !syncNewsletterDates.dates.some((cd) => cd.calendarId == r.calendarId)
         );
-        let keptDates = currentDates.filter((r) =>
-          syncNewsletterDates.dates.map((np) => np.calendarId).includes(r.calendarId)
+        let keptDates = syncNewsletterDates.dates.filter(
+          (r) =>
+            currentDates.some((cd) => cd.calendarId == r.calendarId) &&
+            !removeDates.some((cd) => cd.calendarId == r.calendarId)
         );
 
         if (newDates.length != 0) {
diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index 620687f..0e141f5 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -62,7 +62,7 @@ export async function getNewsletterDatesById(req: Request, res: Response): Promi
 }
 
 /**
- * @description get newsletter recipientss by id
+ * @description get newsletter recipients by id
  * @param req {Request} Express req object
  * @param res {Response} Express res object
  * @returns {Promise<*>}
@@ -70,9 +70,9 @@ export async function getNewsletterDatesById(req: Request, res: Response): Promi
 export async function getNewsletterRecipientsById(req: Request, res: Response): Promise<any> {
   let newsletterId = parseInt(req.params.newsletterId);
 
-  let recipientss = await NewsletterRecipientsService.getAll(newsletterId);
+  let recipients = await NewsletterRecipientsService.getAll(newsletterId);
 
-  res.json(NewsletterRecipientsFactory.mapToBase(recipientss));
+  res.json(NewsletterRecipientsFactory.mapToBase(recipients));
 }
 
 /**
diff --git a/src/entity/newsletterDates.ts b/src/entity/newsletterDates.ts
index 5ef80ba..aefb8ee 100644
--- a/src/entity/newsletterDates.ts
+++ b/src/entity/newsletterDates.ts
@@ -7,8 +7,8 @@ export class newsletterDates {
   @PrimaryColumn({ type: "int" })
   newsletterId: number;
 
-  @PrimaryColumn({ type: "int" })
-  calendarId: number;
+  @PrimaryColumn({ type: "varchar" })
+  calendarId: string;
 
   @Column({ type: "varchar", length: 255, nullable: true })
   diffTitle: string | null;
diff --git a/src/service/newsletterDatesService.ts b/src/service/newsletterDatesService.ts
index 5152de0..08c4b0e 100644
--- a/src/service/newsletterDatesService.ts
+++ b/src/service/newsletterDatesService.ts
@@ -13,6 +13,7 @@ export default abstract class NewsletterDatesService {
       .getRepository(newsletterDates)
       .createQueryBuilder("newsletterDates")
       .leftJoinAndSelect("newsletterDates.calendar", "calendar")
+      .leftJoinAndSelect("calendar.type", "type")
       .leftJoinAndSelect("newsletterDates.newsletter", "newsletter")
       .where("newsletterDates.newsletterId = :id", { id: newsletterId })
       .getMany()
diff --git a/src/viewmodel/admin/newsletterDates.models.ts b/src/viewmodel/admin/newsletterDates.models.ts
index a1bf0cc..074056d 100644
--- a/src/viewmodel/admin/newsletterDates.models.ts
+++ b/src/viewmodel/admin/newsletterDates.models.ts
@@ -2,7 +2,7 @@ import { CalendarViewModel } from "./calendar.models";
 
 export interface NewsletterDatesViewModel {
   newsletterId: number;
-  calendarId: number;
+  calendarId: string;
   diffTitle: string | null;
   diffDescription: string | null;
   calendar: CalendarViewModel;

From 5a59a63e4a110272e41d9034432d890dc3cd648a Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Fri, 27 Dec 2024 13:17:23 +0100
Subject: [PATCH 13/16] query result formatter

---
 .../admin/queryBuilderController.ts           |  2 +-
 src/helpers/dynamicQueryBuilder.ts            | 52 ++++++++++++++++++-
 src/type/dynamicQueries.ts                    |  4 ++
 3 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/src/controller/admin/queryBuilderController.ts b/src/controller/admin/queryBuilderController.ts
index be4a68e..e6bb519 100644
--- a/src/controller/admin/queryBuilderController.ts
+++ b/src/controller/admin/queryBuilderController.ts
@@ -91,7 +91,7 @@ export async function executeQuery(req: Request, res: Response): Promise<any> {
 
       res.json({
         stats: "success",
-        rows: rows,
+        rows: DynamicQueryBuilder.flattenQueryResult(rows),
         total: total,
         offset: offset,
         count: count,
diff --git a/src/helpers/dynamicQueryBuilder.ts b/src/helpers/dynamicQueryBuilder.ts
index ee6ce4c..1dc1b94 100644
--- a/src/helpers/dynamicQueryBuilder.ts
+++ b/src/helpers/dynamicQueryBuilder.ts
@@ -1,6 +1,6 @@
 import { Brackets, DataSource, NotBrackets, ObjectLiteral, SelectQueryBuilder, WhereExpressionBuilder } from "typeorm";
 import { dataSource } from "../data-source";
-import { ConditionStructure, DynamicQueryStructure } from "../type/dynamicQueries";
+import { ConditionStructure, DynamicQueryStructure, FieldType, QueryResult } from "../type/dynamicQueries";
 import { TableMeta } from "../type/tableMeta";
 
 export default abstract class DynamicQueryBuilder {
@@ -229,4 +229,54 @@ export default abstract class DynamicQueryBuilder {
 
     return { query, parameters };
   }
+
+  public static flattenQueryResult(result: Array<QueryResult>): Array<{ [key: string]: FieldType }> {
+    function flatten(row: QueryResult, prefix: string = ""): Array<{ [key: string]: FieldType }> {
+      let results: Array<{ [key: string]: FieldType }> = [{}];
+
+      for (const key in row) {
+        const value = row[key];
+        const newKey = prefix ? `${prefix}_${key}` : key;
+
+        if (Array.isArray(value) && value.every((item) => typeof item === "object" && item !== null)) {
+          const arrayResults: Array<{ [key: string]: FieldType }> = [];
+          value.forEach((item) => {
+            const flattenedItems = flatten(item, newKey);
+            arrayResults.push(...flattenedItems);
+          });
+
+          const tempResults: Array<{ [key: string]: FieldType }> = [];
+          results.forEach((res) => {
+            arrayResults.forEach((arrRes) => {
+              tempResults.push({ ...res, ...arrRes });
+            });
+          });
+          results = tempResults;
+        } else if (value && typeof value === "object" && !Array.isArray(value)) {
+          const objResults = flatten(value as QueryResult, newKey);
+          const tempResults: Array<{ [key: string]: FieldType }> = [];
+          results.forEach((res) => {
+            objResults.forEach((objRes) => {
+              tempResults.push({ ...res, ...objRes });
+            });
+          });
+          results = tempResults;
+        } else {
+          results.forEach((res) => {
+            res[newKey] = String(value);
+          });
+        }
+      }
+      return results;
+    }
+
+    const flattenedResults: Array<{ [key: string]: FieldType }> = [];
+
+    result.forEach((item) => {
+      const flattenedItems = flatten(item);
+      flattenedResults.push(...flattenedItems);
+    });
+
+    return flattenedResults;
+  }
 }
diff --git a/src/type/dynamicQueries.ts b/src/type/dynamicQueries.ts
index 9e1f046..7ae4a79 100644
--- a/src/type/dynamicQueries.ts
+++ b/src/type/dynamicQueries.ts
@@ -54,6 +54,10 @@ export type OrderByStructure = {
 
 export type OrderByType = "ASC" | "DESC";
 
+export type QueryResult = {
+  [key: string]: FieldType | QueryResult | Array<QueryResult>;
+};
+
 export const exampleQuery: DynamicQueryStructure = {
   select: ["firstname", "lastname"],
   table: "member",

From 5f827fb177b96f5acb84b3b70c035de79906c176 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Sat, 28 Dec 2024 18:03:33 +0100
Subject: [PATCH 14/16] send or print newsletter preview

---
 src/controller/admin/newsletterController.ts  | 175 +++++++++++++++++-
 .../admin/templateUsageController.ts          |   6 +-
 src/controller/admin/userController.ts        |   3 +-
 src/controller/inviteController.ts            |   3 +-
 src/controller/resetController.ts             |   3 +-
 src/demodata/newsletter.data.ts               |  72 +++++++
 src/helpers/demoDataHelper.ts                 |   3 +
 src/helpers/fileSystemHelper.ts               |   3 +
 src/helpers/mailHelper.ts                     |  27 ++-
 src/helpers/pdfExport.ts                      |   2 +
 src/helpers/templateHelper.ts                 |   4 +-
 src/migrations/1735118780511-newsletter.ts    |  16 ++
 src/routes/admin/newsletter.ts                |  21 ++-
 src/templates/newsletter.body.template.html   |  41 ++++
 src/templates/newsletter.footer.template.html |   4 +
 15 files changed, 355 insertions(+), 28 deletions(-)
 create mode 100644 src/demodata/newsletter.data.ts
 create mode 100644 src/templates/newsletter.body.template.html
 create mode 100644 src/templates/newsletter.footer.template.html

diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index 0e141f5..6a19524 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -13,7 +13,10 @@ import NewsletterDatesCommandHandler from "../../command/newsletterDatesCommandH
 import { SynchronizeNewsletterRecipientsCommand } from "../../command/newsletterRecipientsCommand";
 import NewsletterRecipientsCommandHandler from "../../command/newsletterRecipientsCommandHandler";
 import { NewsletterDatesViewModel } from "../../viewmodel/admin/newsletterDates.models";
-import { NewsletterRecipientsViewModel } from "../../viewmodel/admin/newsletterRecipients.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
@@ -113,6 +116,84 @@ export async function getNewsletterPrintoutByIdAndPrint(req: Request, res: Respo
   });
 }
 
+/**
+ * @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
@@ -131,7 +212,7 @@ export async function createNewsletter(req: Request, res: Response): Promise<any
 }
 
 /**
- * @description create newsletter printout by id
+ * @description create newsletter printouts for each member by id
  * @param req {Request} Express req object
  * @param res {Response} Express res object
  * @returns {Promise<*>}
@@ -151,6 +232,96 @@ export async function createNewsletterPrintoutById(req: Request, res: Response):
   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
diff --git a/src/controller/admin/templateUsageController.ts b/src/controller/admin/templateUsageController.ts
index e121215..ac1e74a 100644
--- a/src/controller/admin/templateUsageController.ts
+++ b/src/controller/admin/templateUsageController.ts
@@ -40,7 +40,11 @@ export async function printTemplateUsageDemo(req: Request, res: Response): Promi
   const scope = req.params.scope as PermissionModule;
 
   let demoData = DemoDataHelper.getData(scope);
-  let pdf = await PdfExport.renderFile({ template: scope, saveToDisk: false, data: demoData });
+  let pdf = await PdfExport.renderFile({
+    template: scope,
+    saveToDisk: false,
+    data: demoData,
+  });
 
   let pdfbuffer = Buffer.from(pdf);
 
diff --git a/src/controller/admin/userController.ts b/src/controller/admin/userController.ts
index 6596c0a..0177fec 100644
--- a/src/controller/admin/userController.ts
+++ b/src/controller/admin/userController.ts
@@ -146,8 +146,7 @@ export async function deleteUser(req: Request, res: Response): Promise<any> {
 
   try {
     // sendmail
-    let mailhelper = new MailHelper();
-    await mailhelper.sendMail(
+    await MailHelper.sendMail(
       user.mail,
       `Email Bestätigung für Mitglieder Admin-Portal von ${CLUB_NAME}`,
       `Ihr Nutzerkonto des Adminportals wurde erfolgreich gelöscht.`
diff --git a/src/controller/inviteController.ts b/src/controller/inviteController.ts
index 8fa2f34..bb08cd6 100644
--- a/src/controller/inviteController.ts
+++ b/src/controller/inviteController.ts
@@ -71,8 +71,7 @@ export async function inviteUser(req: Request, res: Response, isInvite: boolean
   let token = await InviteCommandHandler.create(createInvite);
 
   // sendmail
-  let mailhelper = new MailHelper();
-  await mailhelper.sendMail(
+  await MailHelper.sendMail(
     mail,
     `Email Bestätigung für Mitglieder Admin-Portal von ${CLUB_NAME}`,
     `Öffne folgenden Link: ${origin}/${isInvite ? "invite" : "setup"}/verify?mail=${mail}&token=${token}`
diff --git a/src/controller/resetController.ts b/src/controller/resetController.ts
index 32f2004..fe0554c 100644
--- a/src/controller/resetController.ts
+++ b/src/controller/resetController.ts
@@ -41,8 +41,7 @@ export async function startReset(req: Request, res: Response): Promise<any> {
   let token = await ResetCommandHandler.create(createReset);
 
   // sendmail
-  let mailhelper = new MailHelper();
-  await mailhelper.sendMail(
+  await MailHelper.sendMail(
     mail,
     `Email Bestätigung für Mitglieder Admin-Portal von ${CLUB_NAME}`,
     `Öffne folgenden Link: ${origin}/reset/reset?mail=${mail}&token=${token}`
diff --git a/src/demodata/newsletter.data.ts b/src/demodata/newsletter.data.ts
new file mode 100644
index 0000000..41a81f4
--- /dev/null
+++ b/src/demodata/newsletter.data.ts
@@ -0,0 +1,72 @@
+import { calendar } from "../entity/calendar";
+import { member } from "../entity/member";
+import { Salutation } from "../enums/salutation";
+
+export const newsletterDemoData: {
+  title: string;
+  description: string;
+  newsletterTitle: string;
+  newsletterText: string;
+  newsletterSignatur: string;
+  dates: Array<
+    Partial<
+      calendar & {
+        formattedStarttime: string;
+        formattedFullStarttime: string;
+        formattedEndtime: string;
+        formattedFullEndtime: string;
+      }
+    >
+  >;
+  recipient: Partial<member & { street: string; streetNumber: string; streetNumberAdd: string }>;
+} = {
+  title: "Beispiel Newsletter Daten",
+  description: "Zusammenfassung der Demodaten.",
+  newsletterTitle: "<h1>Sehr geehrtes Feuerwehrmitglied</h1>",
+  newsletterText: "<p>zu folgenden Terminen möchten wir recht herzlich zur Teilnahme einladen:</p>",
+  newsletterSignatur: "<p>Mit freundlichen Grüßen</p><p>...</p>",
+  dates: [
+    {
+      title: "Termin 1",
+      content: "<p>Beschreibung eines Termins</p>",
+      starttime: new Date(),
+      formattedStarttime: new Date().toLocaleDateString("de-DE", {
+        weekday: "long",
+        day: "2-digit",
+        month: "long",
+      }),
+      formattedFullStarttime: new Date().toLocaleDateString("de-DE", {
+        weekday: "long",
+        day: "2-digit",
+        month: "long",
+        year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+      }),
+      endtime: new Date(),
+      formattedEndtime: new Date().toLocaleDateString("de-DE", {
+        weekday: "long",
+        day: "2-digit",
+        month: "long",
+      }),
+      formattedFullEndtime: new Date().toLocaleDateString("de-DE", {
+        weekday: "long",
+        day: "2-digit",
+        month: "long",
+        year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+      }),
+      location: "Feuerwehrhaus",
+    },
+  ],
+  recipient: {
+    firstname: "Julian",
+    lastname: "Krauser",
+    salutation: Salutation.sir,
+    nameaffix: "",
+    street: "Straße",
+    streetNumber: "Hausnummer",
+    streetNumberAdd: "Adresszusatz",
+  },
+};
diff --git a/src/helpers/demoDataHelper.ts b/src/helpers/demoDataHelper.ts
index 158f17b..e02e5b5 100644
--- a/src/helpers/demoDataHelper.ts
+++ b/src/helpers/demoDataHelper.ts
@@ -1,3 +1,4 @@
+import { newsletterDemoData } from "../demodata/newsletter.data";
 import { protocolDemoData } from "../demodata/protocol.data";
 import { PermissionModule } from "../type/permissionTypes";
 
@@ -6,6 +7,8 @@ export abstract class DemoDataHelper {
     switch (scope) {
       case "protocol":
         return protocolDemoData;
+      case "newsletter":
+        return newsletterDemoData;
       default:
         return {};
     }
diff --git a/src/helpers/fileSystemHelper.ts b/src/helpers/fileSystemHelper.ts
index fc6423e..ad7f33f 100644
--- a/src/helpers/fileSystemHelper.ts
+++ b/src/helpers/fileSystemHelper.ts
@@ -24,6 +24,9 @@ export abstract class FileSystemHelper {
 
   static getFilesInDirectory(directoryPath: string, filetype?: string): string[] {
     const fullPath = join(process.cwd(), directoryPath);
+    if (!existsSync(fullPath)) {
+      return [];
+    }
     return readdirSync(fullPath, { withFileTypes: true })
       .filter((dirent) => !dirent.isDirectory() && (!filetype || dirent.name.endsWith(filetype)))
       .map((dirent) => dirent.name);
diff --git a/src/helpers/mailHelper.ts b/src/helpers/mailHelper.ts
index b4c2dd9..5414673 100644
--- a/src/helpers/mailHelper.ts
+++ b/src/helpers/mailHelper.ts
@@ -1,20 +1,16 @@
 import { Transporter, createTransport, TransportOptions } from "nodemailer";
 import { CLUB_NAME, MAIL_HOST, MAIL_PASSWORD, MAIL_PORT, MAIL_SECURE, MAIL_USERNAME } from "../env.defaults";
 
-export default class MailHelper {
-  private readonly transporter: Transporter;
-
-  constructor() {
-    this.transporter = createTransport({
-      host: MAIL_HOST,
-      port: MAIL_PORT,
-      secure: (MAIL_SECURE as "true" | "false") == "true",
-      auth: {
-        user: MAIL_USERNAME,
-        pass: MAIL_PASSWORD,
-      },
-    } as TransportOptions);
-  }
+export default abstract class MailHelper {
+  private static readonly transporter: Transporter = createTransport({
+    host: MAIL_HOST,
+    port: MAIL_PORT,
+    secure: (MAIL_SECURE as "true" | "false") == "true",
+    auth: {
+      user: MAIL_USERNAME,
+      pass: MAIL_PASSWORD,
+    },
+  } as TransportOptions);
 
   /**
    * @description send mail
@@ -23,7 +19,7 @@ export default class MailHelper {
    * @param {string} content
    * @returns {Prmose<*>}
    */
-  async sendMail(target: string, subject: string, content: string): Promise<any> {
+  static async sendMail(target: string, subject: string, content: string): Promise<any> {
     return new Promise((resolve, reject) => {
       this.transporter
         .sendMail({
@@ -31,6 +27,7 @@ export default class MailHelper {
           to: target,
           subject,
           text: content,
+          html: content,
         })
         .then((info) => resolve(info.messageId))
         .catch((e) => reject(e));
diff --git a/src/helpers/pdfExport.ts b/src/helpers/pdfExport.ts
index 519cc84..fa0875e 100644
--- a/src/helpers/pdfExport.ts
+++ b/src/helpers/pdfExport.ts
@@ -26,7 +26,9 @@ export abstract class PdfExport {
 
     const { header, footer, body } = await TemplateHelper.renderFileForModule({
       module: template,
+      headerData: data,
       bodyData: data,
+      footerData: data,
       title: title,
     });
 
diff --git a/src/helpers/templateHelper.ts b/src/helpers/templateHelper.ts
index c6cf289..3f49961 100644
--- a/src/helpers/templateHelper.ts
+++ b/src/helpers/templateHelper.ts
@@ -48,15 +48,15 @@ export abstract class TemplateHelper {
 
     if (moduleTemplates.headerId) {
       header = await this.getTemplateFromStore(moduleTemplates.headerId);
-      header = this.applyDataToTemplate(header, headerData);
+      header = this.applyDataToTemplate(header, { title, ...headerData });
     }
 
     if (moduleTemplates.footerId) {
       footer = await this.getTemplateFromStore(moduleTemplates.footerId);
-      footer = this.applyDataToTemplate(footer, footerData);
     } else {
       footer = this.getTemplateFromFile(module + ".footer");
     }
+    footer = this.applyDataToTemplate(footer, footerData);
 
     if (moduleTemplates.bodyId) {
       body = await this.getTemplateFromStore(moduleTemplates.bodyId);
diff --git a/src/migrations/1735118780511-newsletter.ts b/src/migrations/1735118780511-newsletter.ts
index e9f79ea..a6294d0 100644
--- a/src/migrations/1735118780511-newsletter.ts
+++ b/src/migrations/1735118780511-newsletter.ts
@@ -1,5 +1,6 @@
 import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
 import { DB_TYPE } from "../env.defaults";
+import { templateUsage } from "../entity/templateUsage";
 
 export class Newsletter1735118780511 implements MigrationInterface {
   name = "Newsletter1735118780511";
@@ -102,9 +103,24 @@ export class Newsletter1735118780511 implements MigrationInterface {
         onUpdate: "RESTRICT",
       })
     );
+
+    await queryRunner.manager
+      .createQueryBuilder()
+      .insert()
+      .into(templateUsage)
+      .values({ scope: "newsletter" })
+      .orIgnore()
+      .execute();
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.manager
+      .createQueryBuilder()
+      .delete()
+      .from(templateUsage)
+      .where({ scope: "newsletter" })
+      .execute();
+
     const tableN = await queryRunner.getTable("newsletter");
     const tableNR = await queryRunner.getTable("newsletter_recipients");
     const tableND = await queryRunner.getTable("newsletter_dates");
diff --git a/src/routes/admin/newsletter.ts b/src/routes/admin/newsletter.ts
index 93bde92..63d149c 100644
--- a/src/routes/admin/newsletter.ts
+++ b/src/routes/admin/newsletter.ts
@@ -11,6 +11,9 @@ import {
   synchronizeNewsletterDatesById,
   synchronizeNewsletterById,
   synchronizeNewsletterRecipientsById,
+  sendNewsletterById,
+  createNewsletterMailPreviewById,
+  createNewsletterPrintoutPreviewById,
 } from "../../controller/admin/newsletterController";
 import PermissionHelper from "../../helpers/permissionHelper";
 
@@ -40,6 +43,10 @@ router.get("/:newsletterId/printout/:filename", async (req: Request, res: Respon
   await getNewsletterPrintoutByIdAndPrint(req, res);
 });
 
+router.get("/:newsletterId/printoutpreview", async (req: Request, res: Response) => {
+  await createNewsletterPrintoutPreviewById(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "club", "protocol"),
@@ -56,6 +63,18 @@ router.post(
   }
 );
 
+router.post("/:newsletterId/mailpreview", async (req: Request, res: Response) => {
+  await createNewsletterMailPreviewById(req, res);
+});
+
+router.post(
+  "/:newsletterId/send",
+  PermissionHelper.passCheckMiddleware("create", "club", "protocol"),
+  async (req: Request, res: Response) => {
+    await sendNewsletterById(req, res);
+  }
+);
+
 router.patch(
   "/:id/synchronize",
   PermissionHelper.passCheckMiddleware("update", "club", "protocol"),
@@ -80,6 +99,4 @@ router.patch(
   }
 );
 
-// TODO: send mails | send mail preview | render preview before print job
-
 export default router;
diff --git a/src/templates/newsletter.body.template.html b/src/templates/newsletter.body.template.html
new file mode 100644
index 0000000..941d89e
--- /dev/null
+++ b/src/templates/newsletter.body.template.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Newsletter</title>
+  </head>
+  <body>
+    <h1>{{{newsletterTitle}}}</h1>
+    <p>{{{newsletterText}}}</p>
+    <br />
+    {{#each dates}}
+    <div>
+      <h2><b>{{this.formattedStarttime}}: {{this.title}}</b></h2>
+      <span>{{{this.content}}}</span>
+    </div>
+    {{/each}}
+    <br />
+    <br />
+    <p>{{{newsletterSignatur}}}</p>
+  </body>
+  <style>
+    h2,
+    h3,
+    p,
+    span,
+    ul,
+    li {
+      padding: 0;
+      margin: 0;
+    }
+
+    h1,
+    h2 {
+      color: #990b00;
+    }
+
+    h2 {
+      margin-bottom: 5px;
+    }
+  </style>
+</html>
diff --git a/src/templates/newsletter.footer.template.html b/src/templates/newsletter.footer.template.html
new file mode 100644
index 0000000..68f9f47
--- /dev/null
+++ b/src/templates/newsletter.footer.template.html
@@ -0,0 +1,4 @@
+<div style="font-size: 10pt; width: 100%; margin: 0 20px; padding-top: 5px; color: #888; border-top: 0.5px solid black">
+  {{recipient.lastname}}, {{recipient.firstname}}, {{recipient.street}} {{recipient.streetNumber}}
+  {{recipient.streetNumberAdd}}
+</div>

From 728c4e05fa0d82ed491ea6de60bd62baaf692ae7 Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Mon, 30 Dec 2024 14:47:00 +0100
Subject: [PATCH 15/16] print pdfs and send mails with ics file

---
 src/controller/admin/newsletterController.ts  | 143 +++---------
 src/controller/admin/protocolController.ts    |   2 +-
 src/controller/publicController.ts            |  56 +----
 src/env.defaults.ts                           |   8 +
 src/helpers/calendarHelper.ts                 |  62 +++++
 src/helpers/dynamicQueryBuilder.ts            |  87 +++++++
 src/helpers/fileSystemHelper.ts               |  43 +++-
 src/helpers/mailHelper.ts                     |   9 +-
 src/helpers/newsletterHelper.ts               | 218 ++++++++++++++++++
 src/helpers/pdfExport.ts                      |  10 +-
 src/helpers/templateHelper.ts                 |   2 +-
 src/templates/newsletter.footer.template.html |   4 +-
 12 files changed, 461 insertions(+), 183 deletions(-)
 create mode 100644 src/helpers/calendarHelper.ts
 create mode 100644 src/helpers/newsletterHelper.ts

diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index 6a19524..f8d0fb5 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -17,6 +17,8 @@ import { PdfExport } from "../../helpers/pdfExport";
 import UserService from "../../service/userService";
 import { TemplateHelper } from "../../helpers/templateHelper";
 import MailHelper from "../../helpers/mailHelper";
+import { NewsletterHelper } from "../../helpers/newsletterHelper";
+import { Salutation } from "../../enums/salutation";
 
 /**
  * @description get all newsletters
@@ -89,8 +91,9 @@ export async function getNewsletterPrintoutsById(req: Request, res: Response): P
 
   let newsletter = await NewsletterService.getById(newsletterId);
 
-  let folderPath = FileSystemHelper.formatPath("export", "newsletter", `${newsletter.id}_${newsletter.title}`);
-  let filesInFolder = FileSystemHelper.getFilesInDirectory(folderPath);
+  let filesInFolder = FileSystemHelper.getFilesInDirectory(
+    `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
+  );
 
   res.json(filesInFolder);
 }
@@ -107,9 +110,13 @@ export async function getNewsletterPrintoutByIdAndPrint(req: Request, res: Respo
 
   let newsletter = await NewsletterService.getById(newsletterId);
 
-  let filepath = FileSystemHelper.formatPath("export", "newsletter", `${newsletter.id}_${newsletter.title}`, filename);
+  let filepath = FileSystemHelper.formatPath(
+    "newsletter",
+    `${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+    filename
+  );
 
-  res.sendFile(process.cwd() + filepath, {
+  res.sendFile(filepath, {
     headers: {
       "Content-Type": "application/pdf",
     },
@@ -128,54 +135,15 @@ export async function createNewsletterPrintoutPreviewById(req: Request, res: Res
   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 data = NewsletterHelper.buildData(newsletter, dates);
+  data.recipient = {
+    firstname: recipient.firstname,
+    lastname: recipient.lastname,
+    salutation: Salutation.none,
+    nameaffix: "",
+    street: "Straße",
+    streetNumber: "Hausnummer",
+    streetNumberAdd: "Adresszusatz",
   };
 
   let pdf = await PdfExport.renderFile({
@@ -219,15 +187,8 @@ export async function createNewsletter(req: Request, res: Response): Promise<any
  */
 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
+  await NewsletterHelper.printPdfs(newsletterId);
 
   res.sendStatus(204);
 }
@@ -244,54 +205,15 @@ export async function createNewsletterMailPreviewById(req: Request, res: Respons
   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 data = NewsletterHelper.buildData(newsletter, dates);
+  data.recipient = {
+    firstname: recipient.firstname,
+    lastname: recipient.lastname,
+    salutation: Salutation.none,
+    nameaffix: "",
+    street: "Straße",
+    streetNumber: "Hausnummer",
+    streetNumberAdd: "Adresszusatz",
   };
 
   const { body } = await TemplateHelper.renderFileForModule({
@@ -313,11 +235,8 @@ export async function createNewsletterMailPreviewById(req: Request, res: Respons
  */
 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
+  await NewsletterHelper.sendMails(newsletterId);
 
   res.sendStatus(204);
 }
diff --git a/src/controller/admin/protocolController.ts b/src/controller/admin/protocolController.ts
index 345a42b..a82608f 100644
--- a/src/controller/admin/protocolController.ts
+++ b/src/controller/admin/protocolController.ts
@@ -264,7 +264,7 @@ export async function createProtocolPrintoutById(req: Request, res: Response): P
   let printout: CreateProtocolPrintoutCommand = {
     title,
     iteration: iteration + 1,
-    filename: FileSystemHelper.formatPath("protocol", filename),
+    filename: FileSystemHelper.normalizePath("protocol", filename),
     protocolId,
   };
   await ProtocolPrintoutCommandHandler.create(printout);
diff --git a/src/controller/publicController.ts b/src/controller/publicController.ts
index 15c5d73..d933522 100644
--- a/src/controller/publicController.ts
+++ b/src/controller/publicController.ts
@@ -6,6 +6,7 @@ import { createEvents } from "ics";
 import moment from "moment";
 import InternalException from "../exceptions/internalException";
 import CalendarFactory from "../factory/admin/calendar";
+import { CalendarHelper } from "../helpers/calendarHelper";
 
 /**
  * @description get all calendar items by types or nscdr
@@ -45,59 +46,8 @@ export async function getCalendarItemsByTypes(req: Request, res: Response): Prom
   if (output == "json") {
     res.json(CalendarFactory.mapToBase(items));
   } else {
-    let events = createEvents(
-      items.map((i) => ({
-        calName: process.env.CLUB_NAME,
-        uid: i.id,
-        sequence: 1,
-        ...(i.allDay
-          ? {
-              start: moment(i.starttime)
-                .format("YYYY-M-D")
-                .split("-")
-                .map((a) => parseInt(a)) as [number, number, number],
-              end: moment(i.endtime)
-                .format("YYYY-M-D")
-                .split("-")
-                .map((a) => parseInt(a)) as [number, number, number],
-            }
-          : {
-              start: moment(i.starttime)
-                .format("YYYY-M-D-H-m")
-                .split("-")
-                .map((a) => parseInt(a)) as [number, number, number, number, number],
-              end: moment(i.endtime)
-                .format("YYYY-M-D-H-m")
-                .split("-")
-                .map((a) => parseInt(a)) as [number, number, number, number, number],
-            }),
-        title: i.title,
-        description: i.content,
-        location: i.location,
-        categories: [i.type.type],
-        created: moment(i.createdAt)
-          .format("YYYY-M-D-H-m")
-          .split("-")
-          .map((a) => parseInt(a)) as [number, number, number, number, number],
-        lastModified: moment(i.updatedAt)
-          .format("YYYY-M-D-H-m")
-          .split("-")
-          .map((a) => parseInt(a)) as [number, number, number, number, number],
-        transp: "OPAQUE" as "OPAQUE",
-        url: "https://www.ff-merching.de",
-        alarms: [
-          {
-            action: "display",
-            description: "Erinnerung",
-            trigger: {
-              minutes: 30,
-              before: true,
-            },
-          },
-        ],
-      }))
-    );
+    let { error, value } = CalendarHelper.buildICS(items);
 
-    res.type("ics").send(events.value);
+    res.type("ics").send(value);
   }
 }
diff --git a/src/env.defaults.ts b/src/env.defaults.ts
index 2ad0925..21c9430 100644
--- a/src/env.defaults.ts
+++ b/src/env.defaults.ts
@@ -20,6 +20,7 @@ export const MAIL_PORT = Number(process.env.MAIL_PORT ?? "587");
 export const MAIL_SECURE = process.env.MAIL_SECURE ?? "false";
 
 export const CLUB_NAME = process.env.CLUB_NAME ?? "";
+export const CLUB_WEBSITE = process.env.CLUB_WEBSITE ?? "";
 
 export function configCheck() {
   if (DB_TYPE != "mysql" && DB_TYPE != "sqlite") throw new Error("set valid value to DB_TYPE (mysql|sqlite)");
@@ -39,6 +40,13 @@ export function configCheck() {
   if (MAIL_HOST == "" || typeof MAIL_HOST != "string") throw new Error("set valid value to MAIL_HOST");
   if (typeof MAIL_PORT != "number") throw new Error("set valid numeric value to MAIL_PORT");
   if (MAIL_SECURE != "true" && MAIL_SECURE != "false") throw new Error("set 'true' or 'false' to MAIL_SECURE");
+
+  console.log(CLUB_WEBSITE);
+  if (
+    CLUB_WEBSITE != "" &&
+    !/^(http(s):\/\/.)[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)$/.test(CLUB_WEBSITE)
+  )
+    throw new Error("CLUB_WEBSITE is not valid url");
 }
 
 function checkMS(input: string, origin: string) {
diff --git a/src/helpers/calendarHelper.ts b/src/helpers/calendarHelper.ts
new file mode 100644
index 0000000..86409be
--- /dev/null
+++ b/src/helpers/calendarHelper.ts
@@ -0,0 +1,62 @@
+import { createEvents } from "ics";
+import { calendar } from "../entity/calendar";
+import moment from "moment";
+import { CLUB_NAME, CLUB_WEBSITE, MAIL_USERNAME } from "../env.defaults";
+
+export abstract class CalendarHelper {
+  public static buildICS(entries: Array<calendar>): { error?: Error; value?: string } {
+    return createEvents(
+      entries.map((i) => ({
+        calName: process.env.CLUB_NAME,
+        uid: i.id,
+        sequence: i.sequence,
+        ...(i.allDay
+          ? {
+              start: moment(i.starttime)
+                .format("YYYY-M-D")
+                .split("-")
+                .map((a) => parseInt(a)) as [number, number, number],
+              end: moment(i.endtime)
+                .format("YYYY-M-D")
+                .split("-")
+                .map((a) => parseInt(a)) as [number, number, number],
+            }
+          : {
+              start: moment(i.starttime)
+                .format("YYYY-M-D-H-m")
+                .split("-")
+                .map((a) => parseInt(a)) as [number, number, number, number, number],
+              end: moment(i.endtime)
+                .format("YYYY-M-D-H-m")
+                .split("-")
+                .map((a) => parseInt(a)) as [number, number, number, number, number],
+            }),
+        title: i.title,
+        description: i.content,
+        location: i.location,
+        categories: [i.type.type],
+        organizer: { name: CLUB_NAME, email: MAIL_USERNAME },
+        created: moment(i.createdAt)
+          .format("YYYY-M-D-H-m")
+          .split("-")
+          .map((a) => parseInt(a)) as [number, number, number, number, number],
+        lastModified: moment(i.updatedAt)
+          .format("YYYY-M-D-H-m")
+          .split("-")
+          .map((a) => parseInt(a)) as [number, number, number, number, number],
+        transp: "OPAQUE" as "OPAQUE",
+        ...(CLUB_WEBSITE != "" ? { url: CLUB_WEBSITE } : {}),
+        alarms: [
+          {
+            action: "display",
+            description: "Erinnerung",
+            trigger: {
+              minutes: 30,
+              before: true,
+            },
+          },
+        ],
+      }))
+    );
+  }
+}
diff --git a/src/helpers/dynamicQueryBuilder.ts b/src/helpers/dynamicQueryBuilder.ts
index 1dc1b94..79930fd 100644
--- a/src/helpers/dynamicQueryBuilder.ts
+++ b/src/helpers/dynamicQueryBuilder.ts
@@ -279,4 +279,91 @@ export default abstract class DynamicQueryBuilder {
 
     return flattenedResults;
   }
+
+  public static async executeQuery(
+    query: string | DynamicQueryStructure,
+    offset: number,
+    count: number
+  ): Promise<
+    | {
+        stats: "error";
+        sql: string;
+        code: string;
+        msg: string;
+      }
+    | {
+        stats: "success";
+        rows: Array<{ [key: string]: FieldType }>;
+        total: number;
+        offset: number;
+        count: number;
+      }
+  > {
+    if (typeof query == "string") {
+      const upperQuery = query.trim().toUpperCase();
+      if (!upperQuery.startsWith("SELECT") || /INSERT|UPDATE|DELETE|ALTER|DROP|CREATE|TRUNCATE/.test(upperQuery)) {
+        return {
+          stats: "error",
+          sql: query,
+          code: "UNALLOWED",
+          msg: "Not allowed to change rows",
+        };
+      }
+
+      try {
+        let data: Array<any> = [];
+
+        return await dataSource
+          .transaction(async (manager) => {
+            data = await manager.query(query);
+
+            throw new Error("AllwaysRollbackQuery");
+          })
+          .catch((error) => {
+            if (error.message === "AllwaysRollbackQuery") {
+              return {
+                stats: "success",
+                rows: data,
+                total: data.length,
+                offset: offset,
+                count: count,
+              };
+            } else {
+              return {
+                stats: "error",
+                sql: error.sql,
+                code: error.code,
+                msg: error.sqlMessage,
+              };
+            }
+          });
+      } catch (error) {
+        return {
+          stats: "error",
+          sql: error.sql,
+          code: error.code,
+          msg: error.sqlMessage,
+        };
+      }
+    } else {
+      try {
+        let [rows, total] = await this.buildQuery(query, offset, count).getManyAndCount();
+
+        return {
+          stats: "success",
+          rows: this.flattenQueryResult(rows),
+          total: total,
+          offset: offset,
+          count: count,
+        };
+      } catch (error) {
+        return {
+          stats: "error",
+          sql: error.sql,
+          code: error.code,
+          msg: error.sqlMessage,
+        };
+      }
+    }
+  }
 }
diff --git a/src/helpers/fileSystemHelper.ts b/src/helpers/fileSystemHelper.ts
index ad7f33f..5813f6a 100644
--- a/src/helpers/fileSystemHelper.ts
+++ b/src/helpers/fileSystemHelper.ts
@@ -1,29 +1,43 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join } from "path";
 import { readdirSync } from "fs";
 
 export abstract class FileSystemHelper {
-  static createFolder(newFolder: string) {
-    const exportPath = join(process.cwd(), "export", newFolder);
+  static createFolder(...args: string[]) {
+    const exportPath = this.formatPath(...args);
     if (!existsSync(exportPath)) {
       mkdirSync(exportPath, { recursive: true });
     }
   }
 
-  static readFile(filePath: string) {
-    return readFileSync(join(process.cwd(), filePath), "utf8");
+  static readFile(...filePath: string[]) {
+    return readFileSync(this.formatPath(...filePath), "utf8");
   }
 
-  static writeFile(filePath: string, file: any) {
-    writeFileSync(filePath, file);
+  static readFileasBase64(...filePath: string[]) {
+    return readFileSync(this.formatPath(...filePath), "base64");
+  }
+
+  static readTemplateFile(filePath: string) {
+    return readFileSync(process.cwd() + filePath, "utf8");
+  }
+
+  static writeFile(filePath: string, filename: string, file: any) {
+    this.createFolder(filePath);
+    let path = this.formatPath(filePath, filename);
+    writeFileSync(path, file);
   }
 
   static formatPath(...args: string[]) {
+    return join(process.cwd(), "export", ...args);
+  }
+
+  static normalizePath(...args: string[]) {
     return join(...args);
   }
 
   static getFilesInDirectory(directoryPath: string, filetype?: string): string[] {
-    const fullPath = join(process.cwd(), directoryPath);
+    const fullPath = this.formatPath(directoryPath);
     if (!existsSync(fullPath)) {
       return [];
     }
@@ -31,4 +45,17 @@ export abstract class FileSystemHelper {
       .filter((dirent) => !dirent.isDirectory() && (!filetype || dirent.name.endsWith(filetype)))
       .map((dirent) => dirent.name);
   }
+
+  static clearDirectoryByFiletype(directoryPath: string, filetype: string) {
+    const fullPath = this.formatPath(directoryPath);
+    if (!existsSync(fullPath)) {
+      return;
+    }
+    readdirSync(fullPath, { withFileTypes: true })
+      .filter((dirent) => !dirent.isDirectory() && dirent.name.endsWith(filetype))
+      .forEach((dirent) => {
+        const filePath = join(fullPath, dirent.name);
+        unlinkSync(filePath);
+      });
+  }
 }
diff --git a/src/helpers/mailHelper.ts b/src/helpers/mailHelper.ts
index 5414673..ab44a26 100644
--- a/src/helpers/mailHelper.ts
+++ b/src/helpers/mailHelper.ts
@@ -1,5 +1,6 @@
 import { Transporter, createTransport, TransportOptions } from "nodemailer";
 import { CLUB_NAME, MAIL_HOST, MAIL_PASSWORD, MAIL_PORT, MAIL_SECURE, MAIL_USERNAME } from "../env.defaults";
+import { Attachment } from "nodemailer/lib/mailer";
 
 export default abstract class MailHelper {
   private static readonly transporter: Transporter = createTransport({
@@ -19,7 +20,12 @@ export default abstract class MailHelper {
    * @param {string} content
    * @returns {Prmose<*>}
    */
-  static async sendMail(target: string, subject: string, content: string): Promise<any> {
+  static async sendMail(
+    target: string,
+    subject: string,
+    content: string,
+    attach: Array<Attachment> = []
+  ): Promise<any> {
     return new Promise((resolve, reject) => {
       this.transporter
         .sendMail({
@@ -28,6 +34,7 @@ export default abstract class MailHelper {
           subject,
           text: content,
           html: content,
+          attachments: attach,
         })
         .then((info) => resolve(info.messageId))
         .catch((e) => reject(e));
diff --git a/src/helpers/newsletterHelper.ts b/src/helpers/newsletterHelper.ts
new file mode 100644
index 0000000..8ed7450
--- /dev/null
+++ b/src/helpers/newsletterHelper.ts
@@ -0,0 +1,218 @@
+import Mail from "nodemailer/lib/mailer";
+import { member } from "../entity/member";
+import { newsletter } from "../entity/newsletter";
+import { newsletterDates } from "../entity/newsletterDates";
+import { newsletterRecipients } from "../entity/newsletterRecipients";
+import MemberService from "../service/memberService";
+import NewsletterDatesService from "../service/newsletterDatesService";
+import NewsletterRecipientsService from "../service/newsletterRecipientsService";
+import NewsletterService from "../service/newsletterService";
+import { CalendarHelper } from "./calendarHelper";
+import DynamicQueryBuilder from "./dynamicQueryBuilder";
+import { FileSystemHelper } from "./fileSystemHelper";
+import MailHelper from "./mailHelper";
+import { CLUB_NAME } from "../env.defaults";
+import { TemplateHelper } from "./templateHelper";
+import { PdfExport } from "./pdfExport";
+import NewsletterConfigService from "../service/newsletterConfigService";
+import { NewsletterConfigType } from "../enums/newsletterConfigType";
+import InternalException from "../exceptions/internalException";
+
+export abstract class NewsletterHelper {
+  public static buildData(
+    newsletter: newsletter,
+    dates: Array<newsletterDates>,
+    recipient?: member,
+    showAdress: boolean = false
+  ) {
+    return {
+      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
+        ? {
+            recipient: {
+              firstname: recipient.firstname,
+              lastname: recipient.lastname,
+              salutation: recipient.salutation,
+              nameaffix: recipient.nameaffix,
+              ...(showAdress
+                ? {
+                    street: recipient.sendNewsletter.street ?? "",
+                    streetNumber: recipient.sendNewsletter.streetNumber ?? "",
+                    streetNumberAdd: recipient.sendNewsletter.streetNumberAddition ?? "",
+                  }
+                : {}),
+            },
+          }
+        : {}),
+    };
+  }
+
+  public static async transformRecipientsToMembers(
+    newsletter: newsletter,
+    recipients: Array<newsletterRecipients>
+  ): Promise<Array<member>> {
+    let useQuery = newsletter.recipientsByQuery?.query;
+
+    let queryMemberIds: Array<number> = [];
+    if (useQuery) {
+      let result = await DynamicQueryBuilder.executeQuery(
+        useQuery.startsWith("{") ? JSON.parse(useQuery) : useQuery,
+        0,
+        1000
+      );
+      if (result.stats == "success") {
+        let keys = Object.keys(result.rows?.[0] ?? {});
+        let memberKey = keys.find((k) => k.includes("member_id"));
+        queryMemberIds = result.rows.map((t) => parseInt((t[memberKey] ?? t.id) as string));
+      }
+    }
+
+    for (let recipient of recipients) {
+      if (!queryMemberIds.includes(recipient.memberId)) {
+        queryMemberIds.push(recipient.memberId);
+      }
+    }
+
+    console.log(queryMemberIds);
+
+    let members = await MemberService.getAll(0, 1000);
+
+    return members[0].filter((m) => queryMemberIds.includes(m.id));
+  }
+
+  public static getICSFilePath(newsletter: newsletter) {
+    return FileSystemHelper.formatPath(
+      "newsletter",
+      `${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+      `events.ics`
+    );
+  }
+
+  public static saveIcsToFile(newsletter: newsletter, ics: string) {
+    FileSystemHelper.writeFile(`newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`, "events.ics", ics);
+  }
+
+  public static async sendMails(newsletterId: number) {
+    let newsletter = await NewsletterService.getById(newsletterId);
+    let dates = await NewsletterDatesService.getAll(newsletterId);
+    let recipients = await NewsletterRecipientsService.getAll(newsletterId);
+    let config = await NewsletterConfigService.getAll();
+
+    const { value, error } = CalendarHelper.buildICS(dates.map((r) => r.calendar));
+    if (error) throw new InternalException("Failed Building ICS form Mail", error);
+    this.saveIcsToFile(newsletter, value);
+
+    let allowedForMail = config.filter((c) => c.config == NewsletterConfigType.mail).map((c) => c.comTypeId);
+
+    const members = await this.transformRecipientsToMembers(newsletter, recipients);
+    const mailRecipients = members.filter(
+      (m) =>
+        m.sendNewsletter != null &&
+        m.sendNewsletter?.email != null &&
+        allowedForMail.includes(m.sendNewsletter?.type?.id)
+    );
+
+    for (const rec of mailRecipients) {
+      let data = this.buildData(newsletter, dates, rec);
+      const { body } = await TemplateHelper.renderFileForModule({
+        module: "newsletter",
+        bodyData: data,
+        title: `Newsletter von ${CLUB_NAME}`,
+      });
+      await MailHelper.sendMail(rec.sendNewsletter.email, `Newsletter von ${CLUB_NAME}`, body, [
+        { filename: "events.ics", path: this.getICSFilePath(newsletter) },
+      ])
+        .then(() => {})
+        .catch((err) => {
+          console.log("mail send", err);
+        });
+    }
+  }
+
+  public static async printPdfs(newsletterId: number) {
+    let newsletter = await NewsletterService.getById(newsletterId);
+    let dates = await NewsletterDatesService.getAll(newsletterId);
+    let recipients = await NewsletterRecipientsService.getAll(newsletterId);
+    let config = await NewsletterConfigService.getAll();
+
+    FileSystemHelper.clearDirectoryByFiletype(
+      `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+      ".pdf"
+    );
+
+    const { value, error } = CalendarHelper.buildICS(dates.map((r) => r.calendar));
+    if (error) throw new InternalException("Failed Building ICS form Pdf", error);
+    this.saveIcsToFile(newsletter, value);
+
+    let notAllowedForPdf = config.filter((c) => c.config == NewsletterConfigType.mail).map((c) => c.comTypeId);
+    let printWithAdress = config.filter((c) => c.config == NewsletterConfigType.pdf).map((c) => c.comTypeId);
+
+    const members = await this.transformRecipientsToMembers(newsletter, recipients);
+    const pdfRecipients = members.filter(
+      (m) => !notAllowedForPdf.includes(m.sendNewsletter?.type?.id) || m.sendNewsletter == null
+    );
+
+    for (const rec of pdfRecipients) {
+      let data = this.buildData(newsletter, dates, rec, printWithAdress.includes(rec.sendNewsletter?.type?.id));
+
+      await PdfExport.renderFile({
+        template: "newsletter",
+        title: `Newsletter von ${CLUB_NAME}`,
+        filename: `${rec.lastname}_${rec.firstname}_${rec.id}`,
+        folder: `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+        data: data,
+      })
+        .then(() => {})
+        .catch((err) => {
+          console.log("pdf print", err);
+        });
+    }
+
+    await PdfExport.sqashToSingleFile(
+      `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+      "allPdfsTogether",
+      `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
+    )
+      .then(() => {})
+      .catch((err) => {
+        console.log("pdf squash", err);
+      });
+  }
+}
diff --git a/src/helpers/pdfExport.ts b/src/helpers/pdfExport.ts
index fa0875e..26a32c2 100644
--- a/src/helpers/pdfExport.ts
+++ b/src/helpers/pdfExport.ts
@@ -39,7 +39,7 @@ export abstract class PdfExport {
     const page = await browser.newPage();
     await page.setContent(body, { waitUntil: "domcontentloaded" });
 
-    const exportPath = FileSystemHelper.formatPath(process.cwd(), "export", folder, `${filename}.pdf`);
+    const exportPath = FileSystemHelper.formatPath(folder, `${filename}.pdf`);
 
     let pdf = await page.pdf({
       ...(saveToDisk ? { path: exportPath } : {}),
@@ -66,10 +66,12 @@ export abstract class PdfExport {
 
     let pdfFilePaths = FileSystemHelper.getFilesInDirectory(inputFolder, ".pdf");
 
+    if (pdfFilePaths.length == 0) return;
+
     const mergedPdf = await PDFDocument.create();
 
     for (const pdfPath of pdfFilePaths) {
-      const pdfBytes = FileSystemHelper.readFile(pdfPath);
+      const pdfBytes = FileSystemHelper.readFileasBase64(inputFolder, pdfPath);
       const pdf = await PDFDocument.load(pdfBytes);
       const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
       copiedPages.forEach((page) => mergedPdf.addPage(page));
@@ -77,8 +79,6 @@ export abstract class PdfExport {
 
     const mergedPdfBytes = await mergedPdf.save();
 
-    const exportPath = FileSystemHelper.formatPath(process.cwd(), "export", outputFolder, `${outputFile}.pdf`);
-
-    FileSystemHelper.writeFile(exportPath, mergedPdfBytes);
+    FileSystemHelper.writeFile(outputFolder, `${outputFile}.pdf`, mergedPdfBytes);
   }
 }
diff --git a/src/helpers/templateHelper.ts b/src/helpers/templateHelper.ts
index 3f49961..cc1567b 100644
--- a/src/helpers/templateHelper.ts
+++ b/src/helpers/templateHelper.ts
@@ -6,7 +6,7 @@ import { FileSystemHelper } from "./fileSystemHelper";
 
 export abstract class TemplateHelper {
   static getTemplateFromFile(template: string) {
-    return FileSystemHelper.readFile(`/src/templates/${template}.template.html`);
+    return FileSystemHelper.readTemplateFile(`/src/templates/${template}.template.html`);
   }
 
   static async getTemplateFromStore(templateId: number): Promise<string> {
diff --git a/src/templates/newsletter.footer.template.html b/src/templates/newsletter.footer.template.html
index 68f9f47..0c4baa8 100644
--- a/src/templates/newsletter.footer.template.html
+++ b/src/templates/newsletter.footer.template.html
@@ -1,4 +1,4 @@
 <div style="font-size: 10pt; width: 100%; margin: 0 20px; padding-top: 5px; color: #888; border-top: 0.5px solid black">
-  {{recipient.lastname}}, {{recipient.firstname}}, {{recipient.street}} {{recipient.streetNumber}}
-  {{recipient.streetNumberAdd}}
+  {{recipient.lastname}}, {{recipient.firstname}}{{#if recipient.street}},{{/if}} {{recipient.street}}
+  {{recipient.streetNumber}} {{recipient.streetNumberAdd}}
 </div>

From e693bd9aa355a9c43fd06c565984c52410b0965f Mon Sep 17 00:00:00 2001
From: Julian Krauser <jkrauser209@gmail.com>
Date: Tue, 31 Dec 2024 14:23:14 +0100
Subject: [PATCH 16/16] http sse for progress

---
 src/controller/admin/newsletterController.ts |  76 ++++++++++-
 src/helpers/newsletterHelper.ts              | 133 ++++++++++++++++++-
 src/routes/admin/newsletter.ts               |  10 ++
 3 files changed, 213 insertions(+), 6 deletions(-)

diff --git a/src/controller/admin/newsletterController.ts b/src/controller/admin/newsletterController.ts
index f8d0fb5..87e62ca 100644
--- a/src/controller/admin/newsletterController.ts
+++ b/src/controller/admin/newsletterController.ts
@@ -17,7 +17,7 @@ import { PdfExport } from "../../helpers/pdfExport";
 import UserService from "../../service/userService";
 import { TemplateHelper } from "../../helpers/templateHelper";
 import MailHelper from "../../helpers/mailHelper";
-import { NewsletterHelper } from "../../helpers/newsletterHelper";
+import { NewsletterEventType, NewsletterHelper } from "../../helpers/newsletterHelper";
 import { Salutation } from "../../enums/salutation";
 
 /**
@@ -179,6 +179,43 @@ export async function createNewsletter(req: Request, res: Response): Promise<any
   res.send(id);
 }
 
+/**
+ * @description get newsletter printout progress by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterPrintoutProgressById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+
+  res.flushHeaders();
+
+  const progressHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "pdf") {
+      res.write(JSON.stringify(data));
+    }
+  };
+
+  const completeHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "pdf") {
+      res.write(JSON.stringify(data));
+      res.end();
+    }
+  };
+
+  NewsletterHelper.jobStatus.on("progress", progressHandler);
+  NewsletterHelper.jobStatus.on("complete", completeHandler);
+
+  req.on("close", () => {
+    NewsletterHelper.jobStatus.off("progress", progressHandler);
+    NewsletterHelper.jobStatus.off("complete", completeHandler);
+  });
+}
+
 /**
  * @description create newsletter printouts for each member by id
  * @param req {Request} Express req object
@@ -241,6 +278,43 @@ export async function sendNewsletterById(req: Request, res: Response): Promise<a
   res.sendStatus(204);
 }
 
+/**
+ * @description get newsletter sending progress by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterSendingProgressById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+
+  res.flushHeaders();
+
+  const progressHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "mail") {
+      res.write(JSON.stringify(data));
+    }
+  };
+
+  const completeHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "mail") {
+      res.write(JSON.stringify(data));
+      res.end();
+    }
+  };
+
+  NewsletterHelper.jobStatus.on("progress", progressHandler);
+  NewsletterHelper.jobStatus.on("complete", completeHandler);
+
+  req.on("close", () => {
+    NewsletterHelper.jobStatus.off("progress", progressHandler);
+    NewsletterHelper.jobStatus.off("complete", completeHandler);
+  });
+}
+
 /**
  * @description synchronize newsletter by id
  * @param req {Request} Express req object
diff --git a/src/helpers/newsletterHelper.ts b/src/helpers/newsletterHelper.ts
index 8ed7450..70d71c9 100644
--- a/src/helpers/newsletterHelper.ts
+++ b/src/helpers/newsletterHelper.ts
@@ -17,8 +17,30 @@ import { PdfExport } from "./pdfExport";
 import NewsletterConfigService from "../service/newsletterConfigService";
 import { NewsletterConfigType } from "../enums/newsletterConfigType";
 import InternalException from "../exceptions/internalException";
+import EventEmitter from "events";
+
+export interface NewsletterEventType {
+  kind: "pdf" | "mail";
+  newsletterId: number;
+  total: number;
+  iteration: number;
+  msg: string;
+}
 
 export abstract class NewsletterHelper {
+  public static jobStatus = new EventEmitter();
+
+  private static formatJobEmit(
+    event: "progress" | "complete",
+    kind: "pdf" | "mail",
+    newsletterId: number,
+    total: number,
+    iteration: number,
+    msg: string
+  ) {
+    this.jobStatus.emit<NewsletterEventType>(event, { kind, newsletterId, total, iteration, msg, date: new Date() });
+  }
+
   public static buildData(
     newsletter: newsletter,
     dates: Array<newsletterDates>,
@@ -149,8 +171,20 @@ export abstract class NewsletterHelper {
         allowedForMail.includes(m.sendNewsletter?.type?.id)
     );
 
-    for (const rec of mailRecipients) {
+    this.formatJobEmit("progress", "mail", newsletterId, mailRecipients.length, 0, "starting sending");
+
+    for (const [index, rec] of mailRecipients.entries()) {
+      this.formatJobEmit(
+        "progress",
+        "mail",
+        newsletterId,
+        mailRecipients.length,
+        index,
+        `start sending to ${rec.sendNewsletter.email}`
+      );
+
       let data = this.buildData(newsletter, dates, rec);
+
       const { body } = await TemplateHelper.renderFileForModule({
         module: "newsletter",
         bodyData: data,
@@ -159,11 +193,37 @@ export abstract class NewsletterHelper {
       await MailHelper.sendMail(rec.sendNewsletter.email, `Newsletter von ${CLUB_NAME}`, body, [
         { filename: "events.ics", path: this.getICSFilePath(newsletter) },
       ])
-        .then(() => {})
+        .then(() => {
+          this.formatJobEmit(
+            "progress",
+            "mail",
+            newsletterId,
+            mailRecipients.length,
+            index,
+            `successfully sent to ${rec.sendNewsletter.email}`
+          );
+        })
         .catch((err) => {
+          this.formatJobEmit(
+            "progress",
+            "mail",
+            newsletterId,
+            mailRecipients.length,
+            index,
+            `failed to send to ${rec.sendNewsletter.email}`
+          );
           console.log("mail send", err);
         });
     }
+
+    this.formatJobEmit(
+      "complete",
+      "mail",
+      newsletterId,
+      mailRecipients.length,
+      mailRecipients.length,
+      `completed sending process`
+    );
   }
 
   public static async printPdfs(newsletterId: number) {
@@ -189,7 +249,18 @@ export abstract class NewsletterHelper {
       (m) => !notAllowedForPdf.includes(m.sendNewsletter?.type?.id) || m.sendNewsletter == null
     );
 
-    for (const rec of pdfRecipients) {
+    this.formatJobEmit("progress", "pdf", newsletterId, pdfRecipients.length, 0, "starting sending");
+
+    for (const [index, rec] of pdfRecipients.entries()) {
+      this.formatJobEmit(
+        "progress",
+        "pdf",
+        newsletterId,
+        pdfRecipients.length,
+        index,
+        `start print for ${rec.lastname}, ${rec.firstname}`
+      );
+
       let data = this.buildData(newsletter, dates, rec, printWithAdress.includes(rec.sendNewsletter?.type?.id));
 
       await PdfExport.renderFile({
@@ -199,20 +270,72 @@ export abstract class NewsletterHelper {
         folder: `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
         data: data,
       })
-        .then(() => {})
+        .then(() => {
+          this.formatJobEmit(
+            "progress",
+            "pdf",
+            newsletterId,
+            pdfRecipients.length,
+            index,
+            `successfully printed for ${rec.lastname}, ${rec.firstname}`
+          );
+        })
         .catch((err) => {
+          this.formatJobEmit(
+            "progress",
+            "pdf",
+            newsletterId,
+            pdfRecipients.length,
+            index,
+            `failed print for ${rec.lastname}, ${rec.firstname}`
+          );
           console.log("pdf print", err);
         });
     }
 
+    this.formatJobEmit(
+      "progress",
+      "pdf",
+      newsletterId,
+      pdfRecipients.length,
+      pdfRecipients.length,
+      "starting pdf combine"
+    );
+
     await PdfExport.sqashToSingleFile(
       `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
       "allPdfsTogether",
       `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
     )
-      .then(() => {})
+      .then(() => {
+        this.formatJobEmit(
+          "progress",
+          "pdf",
+          newsletterId,
+          pdfRecipients.length,
+          pdfRecipients.length,
+          "sucessfully combined pdf"
+        );
+      })
       .catch((err) => {
+        this.formatJobEmit(
+          "progress",
+          "pdf",
+          newsletterId,
+          pdfRecipients.length,
+          pdfRecipients.length,
+          "failed combining pdf"
+        );
         console.log("pdf squash", err);
       });
+
+    this.formatJobEmit(
+      "complete",
+      "pdf",
+      newsletterId,
+      pdfRecipients.length,
+      pdfRecipients.length,
+      `completed printing process`
+    );
   }
 }
diff --git a/src/routes/admin/newsletter.ts b/src/routes/admin/newsletter.ts
index 63d149c..d7b6edb 100644
--- a/src/routes/admin/newsletter.ts
+++ b/src/routes/admin/newsletter.ts
@@ -14,6 +14,8 @@ import {
   sendNewsletterById,
   createNewsletterMailPreviewById,
   createNewsletterPrintoutPreviewById,
+  getNewsletterPrintoutProgressById,
+  getNewsletterSendingProgressById,
 } from "../../controller/admin/newsletterController";
 import PermissionHelper from "../../helpers/permissionHelper";
 
@@ -47,6 +49,14 @@ router.get("/:newsletterId/printoutpreview", async (req: Request, res: Response)
   await createNewsletterPrintoutPreviewById(req, res);
 });
 
+router.get("/:newsletterId/printoutprogress", async (req: Request, res: Response) => {
+  await getNewsletterPrintoutProgressById(req, res);
+});
+
+router.get("/:newsletterId/sendprogress", async (req: Request, res: Response) => {
+  await getNewsletterSendingProgressById(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "club", "protocol"),