1.4.2

Reviewed-on: #91

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:18-alpine AS build
+FROM node:22-alpine AS build
 
 RUN apk add --no-cache \
   chromium \
@@ -20,7 +20,7 @@ COPY . /app
 
 RUN npm run build
 
-FROM node:18-alpine AS prod
+FROM node:22-alpine AS prod
 
 RUN apk add --no-cache \
   chromium \

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-admin-server",
-  "version": "1.3.6",
+  "version": "1.4.2",
   "description": "Feuerwehr/Verein Mitgliederverwaltung Server",
   "main": "dist/index.js",
   "scripts": {
@@ -26,7 +26,7 @@
   "dependencies": {
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
-    "express": "^5.0.0-beta.3",
+    "express": "^5.1.0",
     "express-rate-limit": "^7.5.0",
     "express-validator": "^7.2.1",
     "handlebars": "^4.7.8",
@@ -41,10 +41,10 @@
     "multer": "^1.4.5-lts.1",
     "mysql": "^2.18.1",
     "node-schedule": "^2.1.1",
-    "nodemailer": "^6.9.14",
+    "nodemailer": "^6.10.1",
     "pdf-lib": "^1.17.1",
     "pg": "^8.13.1",
-    "puppeteer": "^23.11.1",
+    "puppeteer": "^24.6.1",
     "qrcode": "^1.5.4",
     "reflect-metadata": "^0.2.2",
     "rss-parser": "^3.13.0",
@@ -52,25 +52,26 @@
     "speakeasy": "^2.0.0",
     "sqlite3": "^5.1.7",
     "typeorm": "^0.3.20",
-    "uuid": "^10.0.0"
+    "uuid": "^11.1.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.14",
-    "@types/express": "^4.17.17",
+    "@types/express": "^5.0.1",
     "@types/ip": "^1.1.3",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/lodash.uniqby": "^4.7.9",
     "@types/morgan": "^1.9.9",
-    "@types/ms": "^0.7.34",
+    "@types/ms": "^2.1.0",
     "@types/multer": "^1.4.12",
     "@types/mysql": "^2.15.21",
-    "@types/node": "^16.18.41",
+    "@types/node": "^22.14.1",
     "@types/node-schedule": "^2.1.6",
     "@types/nodemailer": "^6.4.14",
+    "@types/pg": "~8.11.12",
     "@types/qrcode": "~1.5.5",
     "@types/speakeasy": "^2.0.10",
-    "@types/uuid": "^9.0.2",
-    "ts-node": "10.7.0",
-    "typescript": "^4.5.2"
+    "@types/uuid": "^10.0.0",
+    "ts-node": "10.9.2",
+    "typescript": "^5.8.3"
   }
 }

src/command/club/member/communicationCommandHandler.ts

@@ -18,6 +18,17 @@ export default abstract class CommunicationCommandHandler {
     let insertId = -1;
     return await dataSource
       .transaction(async (manager) => {
+        if (createCommunication.isSendNewsletter) {
+          await manager
+            .createQueryBuilder()
+            .update(communication)
+            .set({
+              isSendNewsletter: false,
+            })
+            .where("memberId = :memberId", { memberId: createCommunication.memberId })
+            .execute();
+        }
+
         await manager
           .createQueryBuilder()
           .insert()
@@ -40,16 +51,6 @@ export default abstract class CommunicationCommandHandler {
           .then((result) => {
             insertId = result.identifiers[0].id;
           });
-
-        await manager
-          .createQueryBuilder()
-          .update(communication)
-          .set({
-            isSendNewsletter: false,
-          })
-          .where("memberId = :memberId", { memberId: createCommunication.memberId })
-          .andWhere("id <> :id", { id: insertId })
-          .execute();
       })
       .then(() => {
         return insertId;
@@ -67,6 +68,17 @@ export default abstract class CommunicationCommandHandler {
   static async update(updateCommunication: UpdateCommunicationCommand): Promise<void> {
     return await dataSource
       .transaction(async (manager) => {
+        if (updateCommunication.isSendNewsletter) {
+          await manager
+            .createQueryBuilder()
+            .update(communication)
+            .set({
+              isSendNewsletter: false,
+            })
+            .where("memberId = :memberId", { memberId: updateCommunication.memberId })
+            .execute();
+        }
+
         await manager
           .createQueryBuilder()
           .update(communication)
@@ -85,16 +97,6 @@ export default abstract class CommunicationCommandHandler {
           .where("id = :id", { id: updateCommunication.id })
           .andWhere("memberId = :memberId", { memberId: updateCommunication.memberId })
           .execute();
-
-        await manager
-          .createQueryBuilder()
-          .update(communication)
-          .set({
-            isSendNewsletter: false,
-          })
-          .where("memberId = :memberId", { memberId: updateCommunication.memberId })
-          .andWhere("id <> :id", { id: updateCommunication.id })
-          .execute();
       })
       .then(() => {})
       .catch((err) => {

src/command/club/newsletter/newsletterCommand.ts

@@ -9,7 +9,7 @@ export interface SynchronizeNewsletterCommand {
   newsletterTitle: string;
   newsletterText: string;
   newsletterSignatur: string;
-  recipientsByQueryId?: number;
+  recipientsByQueryId?: string;
 }
 
 export interface SendNewsletterCommand {

src/command/club/protocol/protocolAgendaCommand.ts

@@ -1,7 +1,7 @@
 export interface SynchronizeProtocolAgendaCommand {
-  id?: number;
+  id: number;
   topic: string;
   context: string;
-  sort?: number;
+  sort: number;
   protocolId: number;
 }

src/command/club/protocol/protocolAgendaCommandHandler.ts

@@ -39,13 +39,16 @@ export default abstract class ProtocolAgendaCommandHandler {
    */
   static async sync(syncProtocolAgenda: Array<SynchronizeProtocolAgendaCommand>): Promise<void> {
     return await dataSource
+      .transaction(async (transactionalEntityManager) => {
+        for (const agenda of syncProtocolAgenda) {
+          await transactionalEntityManager
             .createQueryBuilder()
-      .insert()
-      .into(protocolAgenda)
-      .values(syncProtocolAgenda)
-      .orUpdate(["topic", "context", "sort"], ["id"])
-      .execute()
-      .then(() => {})
+            .update(protocolAgenda)
+            .set(agenda)
+            .where({ id: agenda.id })
+            .execute();
+        }
+      })
       .catch((err) => {
         throw new DatabaseActionException("SYNC", "protocolAgenda", err);
       });

src/command/club/protocol/protocolDecisionCommand.ts

@@ -1,7 +1,7 @@
 export interface SynchronizeProtocolDecisionCommand {
-  id?: number;
+  id: number;
   topic: string;
   context: string;
-  sort?: number;
+  sort: number;
   protocolId: number;
 }

src/command/club/protocol/protocolDecisionCommandHandler.ts

@@ -38,12 +38,16 @@ export default abstract class ProtocolDecisionCommandHandler {
    */
   static async sync(syncProtocolDecisions: Array<SynchronizeProtocolDecisionCommand>): Promise<void> {
     return await dataSource
+      .transaction(async (transactionalEntityManager) => {
+        for (const decision of syncProtocolDecisions) {
+          await transactionalEntityManager
             .createQueryBuilder()
-      .insert()
-      .into(protocolDecision)
-      .values(syncProtocolDecisions)
-      .orUpdate(["topic", "context", "sort"], ["id"])
-      .execute()
+            .update(protocolDecision)
+            .set(decision)
+            .where({ id: decision.id })
+            .execute();
+        }
+      })
       .then(() => {})
       .catch((err) => {
         throw new DatabaseActionException("SYNC", "protocolDecision", err);

src/command/club/protocol/protocolVotingCommand.ts

@@ -5,6 +5,6 @@ export interface SynchronizeProtocolVotingCommand {
   favour: number;
   abstain: number;
   against: number;
-  sort?: number;
+  sort: number;
   protocolId: number;
 }

src/command/club/protocol/protocolVotingCommandHandler.ts

@@ -38,12 +38,16 @@ export default abstract class ProtocolVotingCommandHandler {
    */
   static async sync(syncProtocolVotings: Array<SynchronizeProtocolVotingCommand>): Promise<void> {
     return await dataSource
+      .transaction(async (transactionalEntityManager) => {
+        for (const voting of syncProtocolVotings) {
+          await transactionalEntityManager
             .createQueryBuilder()
-      .insert()
-      .into(protocolVoting)
-      .values(syncProtocolVotings)
-      .orUpdate(["topic", "context", "favour", "abstain", "against", "sort"], ["id"])
-      .execute()
+            .update(protocolVoting)
+            .set(voting)
+            .where({ id: voting.id })
+            .execute();
+        }
+      })
       .then(() => {})
       .catch((err) => {
         throw new DatabaseActionException("SYNC", "protocolVoting", err);

src/command/configuration/newsletterConfig/newsletterConfigCommandHandler.ts

@@ -19,7 +19,7 @@ export default abstract class NewsletterConfigCommandHandler {
         comTypeId: setNewsletterConfig.comTypeId,
         config: setNewsletterConfig.config,
       })
-      .orUpdate(["config"], "comTypeId")
+      .orUpdate(["config"], ["comTypeId"])
       .execute()
       .then((result) => {})
       .catch((err) => {

src/command/configuration/queryStore/queryStoreCommand.ts

@@ -6,10 +6,10 @@ export interface CreateQueryStoreCommand {
 }
 
 export interface UpdateQueryStoreCommand {
-  id: number;
+  id: string;
   query: string | DynamicQueryStructure;
 }
 
 export interface DeleteQueryStoreCommand {
-  id: number;
+  id: string;
 }

src/controller/admin/club/newsletterController.ts

@@ -94,7 +94,7 @@ export async function getNewsletterPrintoutsById(req: Request, res: Response): P
   let newsletter = await NewsletterService.getById(newsletterId);
 
   let filesInFolder = FileSystemHelper.getFilesInDirectory(
-    `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
+    `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`
   );
 
   res.json(filesInFolder);
@@ -114,7 +114,7 @@ export async function getNewsletterPrintoutByIdAndPrint(req: Request, res: Respo
 
   let filepath = FileSystemHelper.formatPath(
     "newsletter",
-    `${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+    `${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
     filename
   );
 
@@ -164,6 +164,34 @@ export async function createNewsletterPrintoutPreviewById(req: Request, res: Res
   res.send(pdfbuffer);
 }
 
+/**
+ * @description get all members receiving a newsletter printout by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterPrintReceiversById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  let recipients = await NewsletterHelper.getPrintRecipients(newsletterId);
+
+  res.json(recipients);
+}
+
+/**
+ * @description get all members receiving a newsletter mail by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterMailReceiversById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  let recipients = await NewsletterHelper.getMailRecipients(newsletterId);
+
+  res.json(recipients);
+}
+
 /**
  * @description create newsletter
  * @param req {Request} Express req object
@@ -328,7 +356,7 @@ export async function synchronizeNewsletterById(req: Request, res: Response): Pr
   let newsletterTitle = req.body.newsletterTitle;
   let newsletterText = req.body.newsletterText;
   let newsletterSignatur = req.body.newsletterSignatur;
-  let recipientsByQueryId = req.body.recipientsByQueryId ?? null;
+  let recipientsByQueryId = req.body.recipientsByQueryId || null;
 
   let syncNewsletter: SynchronizeNewsletterCommand = {
     id,

src/controller/admin/club/protocolController.ts

@@ -235,7 +235,7 @@ export async function createProtocolPrintoutById(req: Request, res: Response): P
     year: "numeric",
   })}`;
 
-  let filename = `${new Date().toISOString().split("T")[0]}_${iteration + 1}_Protokoll_${protocol.title.replace(
+  let filename = `${new Date().toISOString().split("T")[0]}_${iteration + 1}_Protokoll_${protocol.title.replaceAll(
     /[^a-zA-Z0-9]/g,
     ""
   )}`;
@@ -317,7 +317,7 @@ export async function synchronizeProtocolAgendaById(req: Request, res: Response)
 
   let syncAgenda: Array<SynchronizeProtocolAgendaCommand> = agenda.map(
     (a: ProtocolAgendaViewModel): SynchronizeProtocolAgendaCommand => ({
-      id: a.id ?? null,
+      id: a.id,
       topic: a.topic,
       context: a.context,
       sort: a.sort,
@@ -341,7 +341,7 @@ export async function synchronizeProtocolDecisonsById(req: Request, res: Respons
 
   let syncDecision: Array<SynchronizeProtocolDecisionCommand> = decisions.map(
     (d: ProtocolDecisionViewModel): SynchronizeProtocolDecisionCommand => ({
-      id: d.id ?? null,
+      id: d.id,
       topic: d.topic,
       context: d.context,
       sort: d.sort,
@@ -365,7 +365,7 @@ export async function synchronizeProtocolVotingsById(req: Request, res: Response
 
   let syncVoting: Array<SynchronizeProtocolVotingCommand> = votings.map(
     (v: ProtocolVotingViewModel): SynchronizeProtocolVotingCommand => ({
-      id: v.id ?? null,
+      id: v.id,
       topic: v.topic,
       context: v.context,
       favour: v.favour,

src/controller/admin/club/queryBuilderController.ts

@@ -1,6 +1,7 @@
 import { Request, Response } from "express";
 import DynamicQueryBuilder from "../../../helpers/dynamicQueryBuilder";
 import { dataSource } from "../../../data-source";
+import QueryStoreService from "../../../service/configuration/queryStoreService";
 
 /**
  * @description get all table metas
@@ -43,3 +44,23 @@ export async function executeQuery(req: Request, res: Response): Promise<any> {
 
   res.json(result);
 }
+
+/**
+ * @description execute Query by StoreId
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function executeQueryByStoreId(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 noLimit = req.query.noLimit === "true";
+  const storeId = req.params.storeId;
+
+  let queryStore = await QueryStoreService.getById(storeId);
+  let query = queryStore.query.startsWith("{") ? JSON.parse(queryStore.query) : queryStore.query;
+
+  let result = await DynamicQueryBuilder.executeQuery({ query, offset, count, noLimit });
+
+  res.json(result);
+}

src/controller/admin/configuration/queryStoreController.ts

@@ -27,7 +27,7 @@ export async function getAllQueryStores(req: Request, res: Response): Promise<an
  * @returns {Promise<*>}
  */
 export async function getQueryStoreById(req: Request, res: Response): Promise<any> {
-  const id = parseInt(req.params.id);
+  const id = req.params.id;
 
   let queryStore = await QueryStoreService.getById(id);
 
@@ -61,7 +61,7 @@ export async function createQueryStore(req: Request, res: Response): Promise<any
  * @returns {Promise<*>}
  */
 export async function updateQueryStore(req: Request, res: Response): Promise<any> {
-  const id = parseInt(req.params.id);
+  const id = req.params.id;
   const query = req.body.query;
 
   let updateQueryStore: UpdateQueryStoreCommand = {
@@ -81,7 +81,7 @@ export async function updateQueryStore(req: Request, res: Response): Promise<any
  * @returns {Promise<*>}
  */
 export async function deleteQueryStore(req: Request, res: Response): Promise<any> {
-  const id = parseInt(req.params.id);
+  const id = req.params.id;
 
   let deleteQueryStore: DeleteQueryStoreCommand = {
     id: id,

src/data-source.ts

@@ -48,6 +48,9 @@ import { salutation } from "./entity/configuration/salutation";
 import { BackupAndResetDatabase1738166124200 } from "./migrations/1738166124200-BackupAndResetDatabase";
 import { CreateSchema1738166167472 } from "./migrations/1738166167472-CreateSchema";
 import { TemplatesAndProtocolSort1742549956787 } from "./migrations/1742549956787-templatesAndProtocolSort";
+import { QueryToUUID1742922178643 } from "./migrations/1742922178643-queryToUUID";
+import { NewsletterColumnType1744351418751 } from "./migrations/1744351418751-newsletterColumnType";
+import { QueryUpdatedAt1744795756230 } from "./migrations/1744795756230-QueryUpdatedAt";
 
 const dataSource = new DataSource({
   type: DB_TYPE as any,
@@ -101,7 +104,14 @@ const dataSource = new DataSource({
     webapi,
     webapiPermission,
   ],
-  migrations: [BackupAndResetDatabase1738166124200, CreateSchema1738166167472, TemplatesAndProtocolSort1742549956787],
+  migrations: [
+    BackupAndResetDatabase1738166124200,
+    CreateSchema1738166167472,
+    TemplatesAndProtocolSort1742549956787,
+    QueryToUUID1742922178643,
+    NewsletterColumnType1744351418751,
+    QueryUpdatedAt1744795756230,
+  ],
   migrationsRun: true,
   migrationsTransactionMode: "each",
   subscribers: [],

src/entity/club/newsletter/newsletter.ts

@@ -1,6 +1,5 @@
 import { Column, Entity, ManyToOne, OneToMany, PrimaryColumn } from "typeorm";
 import { newsletterDates } from "./newsletterDates";
-import { member } from "../member/member";
 import { newsletterRecipients } from "./newsletterRecipients";
 import { query } from "../../configuration/query";
 
@@ -15,20 +14,20 @@ export class newsletter {
   @Column({ type: "varchar", length: 255, default: "" })
   description: string;
 
-  @Column({ type: "varchar", length: 255, default: "" })
+  @Column({ type: "text", default: "" })
   newsletterTitle: string;
 
   @Column({ type: "text", default: "" })
   newsletterText: string;
 
-  @Column({ type: "varchar", length: 255, default: "" })
+  @Column({ type: "text", default: "" })
   newsletterSignatur: string;
 
   @Column({ type: "boolean", default: false })
   isSent: boolean;
 
-  @Column({ type: "int", nullable: true })
-  recipientsByQueryId?: number;
+  @Column({ nullable: true })
+  recipientsByQueryId?: string;
 
   @OneToMany(() => newsletterDates, (dates) => dates.newsletter, { cascade: ["insert"] })
   dates: newsletterDates[];

src/entity/configuration/query.ts

@@ -1,13 +1,16 @@
-import { Column, Entity, PrimaryColumn } from "typeorm";
+import { Column, Entity, PrimaryColumn, UpdateDateColumn } from "typeorm";
 
 @Entity()
 export class query {
-  @PrimaryColumn({ generated: "increment", type: "int" })
-  id: number;
+  @PrimaryColumn({ generated: "uuid", type: "varchar" })
+  id: string;
 
   @Column({ type: "varchar", length: 255, unique: true })
   title: string;
 
   @Column({ type: "text", default: "" })
   query: string;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
 }

src/env.defaults.ts

@@ -12,9 +12,9 @@ export const DB_PASSWORD = process.env.DB_PASSWORD ?? "";
 export const SERVER_PORT = Number(process.env.SERVER_PORT ?? 5000);
 
 export const JWT_SECRET = process.env.JWT_SECRET ?? "my_jwt_secret_string_ilughfnadiuhgq§$IUZGFVRweiouarbt1oub3h5q4a";
-export const JWT_EXPIRATION = process.env.JWT_EXPIRATION ?? "15m";
-export const REFRESH_EXPIRATION = process.env.REFRESH_EXPIRATION ?? "1d";
-export const PWA_REFRESH_EXPIRATION = process.env.PWA_REFRESH_EXPIRATION ?? "5d";
+export const JWT_EXPIRATION = (process.env.JWT_EXPIRATION ?? "15m") as ms.StringValue;
+export const REFRESH_EXPIRATION = (process.env.REFRESH_EXPIRATION ?? "1d") as ms.StringValue;
+export const PWA_REFRESH_EXPIRATION = (process.env.PWA_REFRESH_EXPIRATION ?? "5d") as ms.StringValue;
 
 export const MAIL_USERNAME = process.env.MAIL_USERNAME ?? "";
 export const MAIL_PASSWORD = process.env.MAIL_PASSWORD ?? "";
@@ -30,10 +30,10 @@ export const BACKUP_COPIES = Number(process.env.BACKUP_COPIES ?? "7");
 export const BACKUP_AUTO_RESTORE = process.env.BACKUP_AUTO_RESTORE ?? "true";
 
 export const USE_SECURITY_STRICT_LIMIT = process.env.USE_SECURITY_STRICT_LIMIT ?? "true";
-export const SECURITY_STRICT_LIMIT_WINDOW = process.env.SECURITY_STRICT_LIMIT_WINDOW ?? "15m";
+export const SECURITY_STRICT_LIMIT_WINDOW = (process.env.SECURITY_STRICT_LIMIT_WINDOW ?? "15m") as ms.StringValue;
 export const SECURITY_STRICT_LIMIT_REQUEST_COUNT = Number(process.env.SECURITY_STRICT_LIMIT_REQUEST_COUNT ?? "15");
 export const USE_SECURITY_LIMIT = process.env.USE_SECURITY_LIMIT ?? "true";
-export const SECURITY_LIMIT_WINDOW = process.env.SECURITY_LIMIT_WINDOW ?? "1m";
+export const SECURITY_LIMIT_WINDOW = (process.env.SECURITY_LIMIT_WINDOW ?? "1m") as ms.StringValue;
 export const SECURITY_LIMIT_REQUEST_COUNT = Number(process.env.SECURITY_LIMIT_REQUEST_COUNT ?? "500");
 
 export const TRUST_PROXY = ((): Array<string> | string | boolean | number | null => {
@@ -104,7 +104,7 @@ export function configCheck() {
   }
 }
 
-function checkMS(input: string, origin: string) {
+function checkMS(input: ms.StringValue, origin: string) {
   try {
     const result = ms(input);
     if (result === undefined) {

src/factory/admin/configuration/queryStore.ts

@@ -12,6 +12,7 @@ export default abstract class QueryStoreFactory {
       id: record.id,
       title: record.title,
       query: record.query.startsWith("{") ? JSON.parse(record.query) : record.query,
+      updatedAt: record.updatedAt,
     };
   }
 

src/helpers/backupHelper.ts

@@ -6,6 +6,7 @@ import InternalException from "../exceptions/internalException";
 import UserService from "../service/management/userService";
 import { BACKUP_COPIES, BACKUP_INTERVAL } from "../env.defaults";
 import DatabaseActionException from "../exceptions/databaseActionException";
+import { availableTemplates } from "../type/templateTypes";
 
 export type BackupSection =
   | "member"
@@ -212,7 +213,7 @@ export default abstract class BackupHelper {
       case "calendar":
         return await this.getCalendar();
       case "query":
-        return await this.getQueryStore();
+        return await this.getQueryStore(collectIds);
       case "template":
         return await this.getTemplate();
       case "user":
@@ -348,7 +349,12 @@ export default abstract class BackupHelper {
         "member.birthdate",
         "member.internalId",
       ])
-      .addSelect(["recipientsByQuery.title", "recipientsByQuery.query"])
+      .addSelect([
+        ...(collectIds ? ["recipientsByQuery.id"] : []),
+        "recipientsByQuery.title",
+        "recipientsByQuery.query",
+        "recipientsByQuery.updatedAt",
+      ])
       .getMany()
       .then((res: any) =>
         res.map((n: any) => ({
@@ -393,8 +399,8 @@ export default abstract class BackupHelper {
         .getMany(),
     };
   }
-  private static async getQueryStore(): Promise<Array<any>> {
-    return await dataSource.getRepository("query").find({ select: { title: true, query: true } });
+  private static async getQueryStore(collectIds: boolean): Promise<Array<any>> {
+    return await dataSource.getRepository("query").find({ select: { id: collectIds, title: true, query: true } });
   }
   private static async getTemplate(): Promise<{ [key: string]: Array<any> }> {
     return {
@@ -743,12 +749,31 @@ export default abstract class BackupHelper {
       .values(data?.["template"] ?? [])
       .orIgnore()
       .execute();
+
+    let templates = await this.transactionManager.getRepository("template").find();
+    let dataWithMappedId = (data?.["template_usage"] ?? [])
+      .filter((d) => availableTemplates.includes(d.scope))
+      .map((d) => ({
+        ...d,
+        headerHeightId: templates.find((template) => template.template == d.headerHeight)?.id ?? null,
+        footerHeightId: templates.find((template) => template.template == d.footerHeight)?.id ?? null,
+        headerId: templates.find((template) => template.template == d.header?.template)?.id ?? null,
+        bodyId: templates.find((template) => template.template == d.body?.template)?.id ?? null,
+        footerId: templates.find((template) => template.template == d.footer?.template)?.id ?? null,
+      }));
+    availableTemplates.forEach((at) => {
+      if (!dataWithMappedId.some((d) => d.scope == at)) {
+        dataWithMappedId.push({
+          scope: at,
+        });
+      }
+    });
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("template_usage")
-      .values(data?.["template_usage"] ?? [])
-      .orUpdate(["headerId", "bodyId", "footerId", "headerHeight", "footerHeight"], ["scope"])
+      .values(dataWithMappedId)
+      .orIgnore()
       .execute();
   }
   private static async setUser(data: { [key: string]: Array<any> }): Promise<void> {

src/helpers/dynamicQueryBuilder.ts

@@ -2,6 +2,7 @@ import { Brackets, DataSource, NotBrackets, ObjectLiteral, SelectQueryBuilder, W
 import { dataSource } from "../data-source";
 import { ConditionStructure, DynamicQueryStructure, FieldType, QueryResult } from "../type/dynamicQueries";
 import { TableMeta } from "../type/tableMeta";
+import { StringHelper } from "./stringHelper";
 
 export default abstract class DynamicQueryBuilder {
   public static allowedTables: Array<string> = [
@@ -62,11 +63,18 @@ export default abstract class DynamicQueryBuilder {
     count?: number;
     noLimit?: boolean;
   }): SelectQueryBuilder<ObjectLiteral> {
-    let affix = Math.random().toString(36).substring(2);
-    let query = dataSource.getRepository(queryObj.table).createQueryBuilder(`${queryObj.table}_${affix}`);
+    let affix = queryObj.id ?? StringHelper.random(10);
+    let query = dataSource.getRepository(queryObj.table).createQueryBuilder(`${affix}_${queryObj.table}`);
 
     this.buildDynamicQuery(query, queryObj, affix);
 
+    if (queryObj.orderBy) {
+      queryObj.orderBy.forEach((order) => {
+        // compatability layer for none id (old) queries
+        if (order.id) query.addOrderBy(`${order.id}_${order.table}.${order.column}`, order.order);
+      });
+    }
+
     if (!noLimit) {
       query.offset(offset);
       query.limit(count);
@@ -78,10 +86,10 @@ export default abstract class DynamicQueryBuilder {
   private static buildDynamicQuery(
     query: SelectQueryBuilder<ObjectLiteral>,
     queryObject: DynamicQueryStructure,
-    affix: string = "",
+    affix: string = "", // table id
     depth: number = 0
   ): void {
-    const alias = queryObject.table + "_" + affix;
+    const alias = `${affix}_${queryObject.table}`;
     let firstSelect = true;
     let selects: Array<string> = [];
 
@@ -108,18 +116,21 @@ export default abstract class DynamicQueryBuilder {
 
     if (queryObject.join) {
       for (const join of queryObject.join) {
-        let subaffix = Math.random().toString(36).substring(2);
-        query.leftJoin(`${alias}.${join.foreignColumn}`, join.table + "_" + subaffix);
+        let subaffix = join.id ?? StringHelper.random(10);
+        if (join.type == undefined) join.type = "defined";
+        if (join.type == "defined") {
+          query.innerJoin(`${alias}.${join.foreignColumn}`, `${subaffix}_${join.table}`);
+        } else {
+          let condition = join.condition
+            .replaceAll(`${join.table}.`, `${subaffix}_${join.table}.`)
+            .replaceAll(`${queryObject.table}.`, `${alias}.`);
+
+          query.innerJoin(join.table, `${subaffix}_${join.table}`, condition);
+        }
 
         this.buildDynamicQuery(query, join, subaffix, depth + 1);
       }
     }
-
-    if (queryObject.orderBy) {
-      queryObject.orderBy.forEach((order) => {
-        query.addOrderBy(`${alias}.${order.column}`, order.order);
-      });
-    }
   }
 
   public static applyWhere(
@@ -166,7 +177,7 @@ export default abstract class DynamicQueryBuilder {
     condition: ConditionStructure & { structureType: "condition" },
     alias: string
   ): { query: string; parameters: Record<string, unknown> } {
-    const parameterKey = `${alias}_${condition.column}_${Math.random().toString(36).substring(2)}`;
+    const parameterKey = `${condition.column}_${Math.random().toString(36).substring(2)}`;
     let query = `${alias}.${condition.column}`;
     let parameters: Record<string, unknown> = {};
 
@@ -379,6 +390,7 @@ export default abstract class DynamicQueryBuilder {
           count: noLimit ? total : count,
         };
       } catch (error) {
+        console.log(error);
         return {
           stats: "error",
           sql: error.sql,
@@ -391,27 +403,31 @@ export default abstract class DynamicQueryBuilder {
 }
 
 const memberQuery: DynamicQueryStructure = {
+  id: "memberId",
   select: "*",
   table: "member",
   orderBy: [
-    { column: "lastname", order: "ASC" },
-    { column: "firstname", order: "ASC" },
+    { id: "memberId", depth: 0, table: "member", column: "lastname", order: "ASC" },
+    { id: "memberId", depth: 0, table: "member", column: "firstname", order: "ASC" },
   ],
 };
 
 const memberByRunningMembershipQuery: DynamicQueryStructure = {
+  id: "memberId",
   select: "*",
   table: "member",
   join: [
     {
+      id: "membershipId",
       select: "*",
       table: "membership",
       where: [{ structureType: "condition", concat: "_", operation: "null", column: "end", value: "" }],
       foreignColumn: "memberships",
+      type: "defined",
     },
   ],
   orderBy: [
-    { column: "lastname", order: "ASC" },
-    { column: "firstname", order: "ASC" },
+    { id: "memberId", depth: 0, table: "member", column: "lastname", order: "ASC" },
+    { id: "memberId", depth: 0, table: "member", column: "firstname", order: "ASC" },
   ],
 };

src/helpers/jwtHelper.ts

@@ -58,7 +58,10 @@ export abstract class JWTHelper {
     let rolePermissions =
       userRoles.length != 0 ? await RolePermissionService.getByRoles(userRoles.map((e) => e.id)) : [];
     let rolePermissionStrings = rolePermissions.map((e) => e.permission);
-    let permissionObject = PermissionHelper.convertToObject([...userPermissionStrings, ...rolePermissionStrings]);
+    let permissionObject = PermissionHelper.convertToObject(
+      [...userPermissionStrings, ...rolePermissionStrings],
+      isOwner
+    );
 
     let jwtData: JWTToken = {
       userId: id,

src/helpers/newsletterHelper.ts

@@ -1,4 +1,3 @@
-import Mail from "nodemailer/lib/mailer";
 import { member } from "../entity/club/member/member";
 import { newsletter } from "../entity/club/newsletter/newsletter";
 import { newsletterDates } from "../entity/club/newsletter/newsletterDates";
@@ -62,9 +61,10 @@ export abstract class NewsletterHelper {
       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,
+      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",
@@ -94,7 +94,8 @@ export abstract class NewsletterHelper {
             minute: "2-digit",
           }),
           location: d.calendar.location,
-      })),
+        }))
+        .sort((a, b) => a.starttime.getTime() - b.starttime.getTime()),
       ...(recipient
         ? {
             recipient: {
@@ -104,9 +105,9 @@ export abstract class NewsletterHelper {
               nameaffix: recipient.nameaffix,
               ...(showAdress
                 ? {
-                    street: recipient.sendNewsletter.street ?? "",
-                    streetNumber: recipient.sendNewsletter.streetNumber ?? "",
-                    streetNumberAdd: recipient.sendNewsletter.streetNumberAddition ?? "",
+                    street: recipient.sendNewsletter.street || "",
+                    streetNumber: recipient.sendNewsletter.streetNumber || "",
+                    streetNumberAdd: recipient.sendNewsletter.streetNumberAddition || "",
                   }
                 : {}),
             },
@@ -140,33 +141,19 @@ export abstract class NewsletterHelper {
       }
     }
 
+    if (queryMemberIds.length == 0) {
+      return [];
+    } else {
       let members = await MemberService.getAll({ noLimit: true, ids: queryMemberIds });
-
       return members[0];
     }
-
-  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) {
+  public static async getMailRecipients(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);
@@ -177,6 +164,58 @@ export abstract class NewsletterHelper {
         allowedForMail.includes(m.sendNewsletter?.type?.id)
     );
 
+    return mailRecipients;
+  }
+
+  public static async getPrintRecipients(newsletterId: number) {
+    let newsletter = await NewsletterService.getById(newsletterId);
+    let recipients = await NewsletterRecipientsService.getAll(newsletterId);
+    let config = await NewsletterConfigService.getAll();
+
+    let notAllowedForPdf = config.filter((c) => c.config == NewsletterConfigType.mail).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
+    );
+
+    pdfRecipients.unshift({
+      id: "0",
+      firstname: "Alle Mitglieder",
+      lastname: CLUB_NAME,
+      nameaffix: "",
+      salutation: { salutation: "" },
+    } as member);
+
+    return pdfRecipients;
+  }
+
+  public static getICSFilePath(newsletter: newsletter) {
+    return FileSystemHelper.formatPath(
+      "newsletter",
+      `${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
+      `events.ics`
+    );
+  }
+
+  public static saveIcsToFile(newsletter: newsletter, ics: string) {
+    FileSystemHelper.writeFile(
+      `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
+      "events.ics",
+      ics
+    );
+  }
+
+  public static async sendMails(newsletterId: number) {
+    let newsletter = await NewsletterService.getById(newsletterId);
+    let dates = await NewsletterDatesService.getAll(newsletterId);
+
+    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);
+
+    const mailRecipients = await this.getMailRecipients(newsletterId);
+
     this.formatJobEmit("progress", "mail", "info", newsletterId, mailRecipients.length, 0, "starting sending");
 
     for (const [index, rec] of mailRecipients.entries()) {
@@ -228,11 +267,10 @@ export abstract class NewsletterHelper {
   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(" ", "")}`,
+      `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
       ".pdf"
     );
 
@@ -240,33 +278,20 @@ export abstract class NewsletterHelper {
     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
-    );
+    const pdfRecipients = await this.getPrintRecipients(newsletterId);
 
-    this.formatJobEmit("progress", "pdf", "info", newsletterId, pdfRecipients.length + 1, 0, "starting sending");
+    this.formatJobEmit("progress", "pdf", "info", newsletterId, pdfRecipients.length, 0, "starting printing");
 
-    for (const [index, rec] of [
-      ...pdfRecipients,
-      {
-        id: "0",
-        firstname: "Alle Mitglieder",
-        lastname: CLUB_NAME,
-        nameaffix: "",
-        salutation: { salutation: "" },
-      } as member,
-    ].entries()) {
+    for (const [index, rec] of pdfRecipients.entries()) {
       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(" ", "")}`,
+        filename: `${rec.lastname}_${rec.firstname}_${rec.id}`.replaceAll(" ", "-"),
+        folder: `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
         data: data,
       })
         .then(() => {
@@ -294,9 +319,9 @@ export abstract class NewsletterHelper {
     }
 
     await PdfExport.sqashToSingleFile(
-      `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+      `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`,
       "allPdfsTogether",
-      `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
+      `newsletter/${newsletter.id}_${newsletter.title.replaceAll(" ", "")}`
     )
       .then(() => {
         this.formatJobEmit(

src/helpers/pdfExport.ts

@@ -1,10 +1,47 @@
-import puppeteer from "puppeteer";
+import puppeteer, { Browser } from "puppeteer";
 import { TemplateHelper } from "./templateHelper";
 import { PermissionModule } from "../type/permissionTypes";
 import { FileSystemHelper } from "./fileSystemHelper";
 import { PDFDocument } from "pdf-lib";
+import { StringHelper } from "./stringHelper";
 
 export abstract class PdfExport {
+  private static browserInstance: undefined | Browser = undefined;
+  private static timeout: undefined | NodeJS.Timeout = undefined;
+  private static printing = new Map<string, string>();
+
+  private static async renderTemplate(
+    template: `${PermissionModule}` | `${PermissionModule}.${string}`,
+    title: string,
+    data: any,
+    customTemplate?: {
+      headerId?: number;
+      footerId?: number;
+      bodyId?: string | number;
+      headerHeight: number;
+      footerHeight: number;
+    }
+  ): Promise<{ header: string; footer: string; body: string; headerMargin?: number; footerMargin?: number }> {
+    if (!customTemplate) {
+      return await TemplateHelper.renderFileForModule({
+        module: template,
+        headerData: data,
+        bodyData: data,
+        footerData: data,
+        title: title,
+      });
+    } else {
+      return await TemplateHelper.renderFileForCustom({
+        module: template,
+        customTemplate,
+        headerData: data,
+        bodyData: data,
+        footerData: data,
+        title: title,
+      });
+    }
+  }
+
   static async renderFile({
     template,
     title = "pdf-export FF Admin",
@@ -28,33 +65,25 @@ export abstract class PdfExport {
       footerHeight: number;
     };
   }) {
+    try {
+      clearTimeout(this.timeout);
+    } catch (err) {}
+    let id = StringHelper.random(32);
+    this.printing.set(id, "printing");
+
     if (folder != "") FileSystemHelper.createFolder(folder);
 
-    let header: string, footer: string, body: string, headerMargin: number, footerMargin: number;
-    if (!customTemplate) {
-      ({ header, footer, body, headerMargin, footerMargin } = await TemplateHelper.renderFileForModule({
-        module: template,
-        headerData: data,
-        bodyData: data,
-        footerData: data,
-        title: title,
-      }));
-    } else {
-      ({ header, footer, body, headerMargin, footerMargin } = await TemplateHelper.renderFileForCustom({
-        module: template,
-        customTemplate,
-        headerData: data,
-        bodyData: data,
-        footerData: data,
-        title: title,
-      }));
-    }
+    const renderedTemplate = await this.renderTemplate(template, title, data, customTemplate);
+    let { header, footer, body, headerMargin, footerMargin } = renderedTemplate;
 
-    const browser = await puppeteer.launch({
+    if (!this.browserInstance || !this.browserInstance.connected) {
+      this.browserInstance = await puppeteer.launch({
         headless: true,
         args: ["--no-sandbox", "--disable-gpu", "--disable-setuid-sandbox"],
       });
-    const page = await browser.newPage();
+    }
+
+    const page = await this.browserInstance.newPage();
     await page.setContent(body, { waitUntil: "domcontentloaded" });
 
     const exportPath = FileSystemHelper.formatPath(folder, `${filename}.pdf`);
@@ -74,7 +103,16 @@ export abstract class PdfExport {
       footerTemplate: footer,
     });
 
-    await browser.close();
+    await page.close();
+
+    this.printing.delete(id);
+
+    if (this.printing.size == 0) {
+      this.timeout = setTimeout(() => {
+        this.browserInstance.close();
+        this.browserInstance = undefined;
+      }, 5000);
+    }
 
     return pdf;
   }

src/helpers/permissionHelper.ts

@@ -4,9 +4,11 @@ import {
   permissionModules,
   PermissionObject,
   PermissionSection,
+  permissionSections,
   PermissionString,
   PermissionType,
   permissionTypes,
+  sectionsAndModules,
 } from "../type/permissionTypes";
 import ForbiddenRequestException from "../exceptions/forbiddenRequestException";
 
@@ -17,8 +19,8 @@ export default class PermissionHelper {
     section: PermissionSection,
     module?: PermissionModule
   ) {
-    if (type == "admin") return permissions?.admin ?? false;
-    if (permissions?.admin) return true;
+    if (type == "admin") return permissions?.admin ?? permissions?.adminByOwner ?? false;
+    if (permissions?.admin || permissions?.adminByOwner) return true;
     if (
       (!module &&
         permissions[section] != undefined &&
@@ -50,8 +52,8 @@ export default class PermissionHelper {
     type: PermissionType | "admin",
     section: PermissionSection
   ): boolean {
-    if (type == "admin") return permissions?.admin ?? false;
-    if (permissions?.admin) return true;
+    if (type == "admin") return permissions?.admin ?? permissions?.adminByOwner ?? false;
+    if (permissions?.admin || permissions?.adminByOwner) return true;
     if (
       permissions[section]?.all == "*" ||
       permissions[section]?.all?.includes(type) ||
@@ -73,6 +75,11 @@ export default class PermissionHelper {
     }, false);
   }
 
+  static canValue(permissions: PermissionObject, key: string, emptyIfAdmin: boolean = false): string {
+    if (emptyIfAdmin && (permissions.admin || permissions.adminByOwner)) return "";
+    return permissions?.additional?.[key] ?? "";
+  }
+
   static passCheckMiddleware(
     requiredPermissions: PermissionType | "admin",
     section: PermissionSection,
@@ -159,14 +166,28 @@ export default class PermissionHelper {
     };
   }
 
-  static convertToObject(permissions: Array<PermissionString>): PermissionObject {
-    if (permissions.includes("*")) {
+  static convertToObject(permissions: Array<PermissionString>, isOwner: boolean = false): PermissionObject {
+    let isAdmin = permissions.includes("*");
+
+    let additional: { [key: string]: string } = {};
+    let additionalPermissions = permissions.map((e) => e.split(".")).filter((e) => e[0] == "additional") as Array<
+      ["additional", string, string]
+    >;
+    for (let split of additionalPermissions) {
+      let module = sectionsAndModules.additional.find((a) => a.key == split[1]);
+      if (!isAdmin || (isAdmin && !module.emptyIfAdmin)) additional[split[1]] = split[2];
+    }
+
+    if (isAdmin) {
       return {
         admin: true,
+        adminByOwner: isOwner,
+        ...(Object.keys(additional).length > 0 && { additional }),
       };
     }
+
     let output: PermissionObject = {};
-    let splitPermissions = permissions.map((e) => e.split(".")) as Array<
+    let splitPermissions = permissions.map((e) => e.split(".")).filter((e) => e[0] != "additional") as Array<
       [PermissionSection, PermissionModule | PermissionType | "*", PermissionType | "*"]
     >;
     for (let split of splitPermissions) {
@@ -208,15 +229,31 @@ export default class PermissionHelper {
         }
       }
     }
-    return output;
+
+    return {
+      adminByOwner: isOwner,
+      ...output,
+      ...(Object.keys(additional).length > 0 && { additional }),
+    };
   }
 
   static convertToStringArray(permissions: PermissionObject): Array<PermissionString> {
-    if (permissions?.admin) {
-      return ["*"];
+    let isAdmin = permissions?.admin;
+
+    let additional: Array<PermissionString> = [];
+    let additionalPermissions = Object.entries(permissions?.additional ?? {});
+    for (let add of additionalPermissions) {
+      additional.push(`additional.${add[0]}.${add[1]}`);
     }
+
+    if (isAdmin) {
+      return ["*", ...additional];
+    }
+
     let output: Array<PermissionString> = [];
-    let sections = Object.keys(permissions) as Array<PermissionSection>;
+    let sections = Object.keys(permissions).filter((m: PermissionSection) =>
+      permissionSections.includes(m)
+    ) as Array<PermissionSection>;
     for (let section of sections) {
       if (permissions[section].all) {
         let types = permissions[section].all;
@@ -242,7 +279,8 @@ export default class PermissionHelper {
         }
       }
     }
-    return output;
+
+    return [...output, ...additional];
   }
 
   static getWhatToAdd(before: Array<PermissionString>, after: Array<PermissionString>): Array<PermissionString> {

src/helpers/templateHelper.ts

@@ -3,6 +3,7 @@ import { PermissionModule } from "../type/permissionTypes";
 import TemplateUsageService from "../service/configuration/templateUsageService";
 import Handlebars, { template } from "handlebars";
 import { FileSystemHelper } from "./fileSystemHelper";
+import { TemplateFormat } from "../type/templateTypes";
 
 export abstract class TemplateHelper {
   static getTemplateFromFile(template: string) {
@@ -10,7 +11,9 @@ export abstract class TemplateHelper {
     try {
       tmpFile = FileSystemHelper.readTemplateFile(`/src/templates/${template}.template.html`);
     } catch (err) {
-      tmpFile = FileSystemHelper.readTemplateFile(`/src/templates/${template.split(".")[1]}.template.html`);
+      tmpFile = FileSystemHelper.readTemplateFile(
+        `/src/templates/${template.split(".")[template.split(".").length - 1]}.template.html`
+      );
     }
     return tmpFile;
   }
@@ -26,9 +29,9 @@ export abstract class TemplateHelper {
   }
 
   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, "}}");
+    template = template.replaceAll(/<listend>.*?<\/listend>/g, "{{/each}}");
+    template = template.replaceAll(/<liststart\b[^>]*>(WDH Start: )?/g, "{{#each ");
+    template = template.replaceAll(/<\/liststart>/g, "}}");
 
     return template;
   }
@@ -40,7 +43,7 @@ export abstract class TemplateHelper {
     bodyData = {},
     footerData = {},
   }: {
-    module: `${PermissionModule}` | `${PermissionModule}.${string}`;
+    module: TemplateFormat;
     title?: string;
     headerData?: any;
     bodyData?: any;
@@ -88,7 +91,7 @@ export abstract class TemplateHelper {
     footerData = {},
     customTemplate,
   }: {
-    module: `${PermissionModule}` | `${PermissionModule}.${string}`;
+    module: TemplateFormat;
     title?: string;
     headerData?: any;
     bodyData?: any;

src/migrations/1738166167472-CreateSchema.ts

@@ -106,7 +106,7 @@ export class CreateSchema1738166167472 implements MigrationInterface {
       .insert()
       .into(templateUsage)
       .values([{ scope: "newsletter" }, { scope: "protocol" }, { scope: "member.list" }])
-      .orUpdate(["headerId", "bodyId", "footerId", "headerHeight", "footerHeight"], ["scope"])
+      .orIgnore()
       .execute();
 
     await queryRunner.createTable(protocol_table, true, true, true);

src/migrations/1742549956787-templatesAndProtocolSort.ts

@@ -11,7 +11,7 @@ export class TemplatesAndProtocolSort1742549956787 implements MigrationInterface
       .insert()
       .into(templateUsage)
       .values([{ scope: "member" }])
-      .orUpdate(["headerId", "bodyId", "footerId", "headerHeight", "footerHeight"], ["scope"])
+      .orIgnore()
       .execute();
 
     await queryRunner.manager
@@ -47,7 +47,7 @@ export class TemplatesAndProtocolSort1742549956787 implements MigrationInterface
       .insert()
       .into(templateUsage)
       .values([{ scope: "member.list" }])
-      .orUpdate(["headerId", "bodyId", "footerId", "headerHeight", "footerHeight"], ["scope"])
+      .orIgnore()
       .execute();
 
     await queryRunner.manager.createQueryBuilder().delete().from(templateUsage).where({ scope: "member" }).execute();

src/migrations/1742922178643-queryToUUID.ts

@@ -0,0 +1,94 @@
+import { MigrationInterface, QueryRunner, TableColumn, TableForeignKey } from "typeorm";
+import { getTypeByORM, isIncrementPrimary, isUUIDPrimary } from "./ormHelper";
+import { query } from "../entity/configuration/query";
+
+export class QueryToUUID1742922178643 implements MigrationInterface {
+  name = "QueryToUUID1742922178643";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable("newsletter");
+    const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("recipientsByQueryId") !== -1);
+    await queryRunner.dropForeignKey("newsletter", foreignKey);
+
+    const entries = await queryRunner.manager.getRepository(query).find({ select: { title: true, query: true } });
+    await queryRunner.clearTable("query");
+
+    await queryRunner.dropColumn("newsletter", "recipientsByQueryId");
+    await queryRunner.dropColumn("query", "id");
+
+    await queryRunner.addColumn(
+      "query",
+      new TableColumn({
+        name: "id",
+        ...getTypeByORM("uuid"),
+        ...isUUIDPrimary,
+      })
+    );
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({
+        name: "recipientsByQueryId",
+        ...getTypeByORM("uuid", true),
+      })
+    );
+
+    await queryRunner.manager.createQueryBuilder().insert().into("query").values(entries).execute();
+
+    await queryRunner.createForeignKey(
+      "newsletter",
+      new TableForeignKey({
+        columnNames: ["recipientsByQueryId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "query",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable("newsletter");
+    const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("recipientsByQueryId") !== -1);
+    await queryRunner.dropForeignKey("newsletter", foreignKey);
+
+    const entries = await queryRunner.manager.getRepository(query).find({ select: { title: true, query: true } });
+    await queryRunner.clearTable("query");
+
+    await queryRunner.dropColumn("newsletter", "recipientsByQueryId");
+    await queryRunner.dropColumn("query", "id");
+
+    await queryRunner.addColumn(
+      "query",
+      new TableColumn({
+        name: "id",
+        ...getTypeByORM("int"),
+        ...isIncrementPrimary,
+      })
+    );
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({
+        name: "recipientsByQueryId",
+        ...getTypeByORM("int", true),
+      })
+    );
+
+    await queryRunner.manager
+      .createQueryBuilder()
+      .insert()
+      .into("query")
+      .values(entries.map((e, i) => ({ ...e, id: i + 1 })))
+      .execute();
+
+    await queryRunner.createForeignKey(
+      "newsletter",
+      new TableForeignKey({
+        columnNames: ["recipientsByQueryId"],
+        referencedColumnNames: ["id"],
+        referencedTableName: "query",
+        onDelete: "CASCADE",
+        onUpdate: "RESTRICT",
+      })
+    );
+  }
+}

src/migrations/1744351418751-newsletterColumnType.ts

@@ -0,0 +1,43 @@
+import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
+import { getDefaultByORM, getTypeByORM } from "./ormHelper";
+import { newsletter } from "../entity/club/newsletter/newsletter";
+
+export class NewsletterColumnType1744351418751 implements MigrationInterface {
+  name = "NewsletterColumnType1744351418751";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    let newsletters = await queryRunner.manager.getRepository("newsletter").find();
+
+    await queryRunner.dropColumn("newsletter", "newsletterTitle");
+    await queryRunner.dropColumn("newsletter", "newsletterSignatur");
+
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({ name: "newsletterTitle", ...getTypeByORM("text"), default: getDefaultByORM("string") })
+    );
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({ name: "newsletterSignatur", ...getTypeByORM("text"), default: getDefaultByORM("string") })
+    );
+
+    await queryRunner.manager.getRepository("newsletter").save(newsletters);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    let newsletters = await queryRunner.manager.getRepository("newsletter").find();
+
+    await queryRunner.dropColumn("newsletter", "newsletterTitle");
+    await queryRunner.dropColumn("newsletter", "newsletterSignatur");
+
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({ name: "newsletterTitle", ...getTypeByORM("varchar"), default: getDefaultByORM("string") })
+    );
+    await queryRunner.addColumn(
+      "newsletter",
+      new TableColumn({ name: "newsletterSignatur", ...getTypeByORM("varchar"), default: getDefaultByORM("string") })
+    );
+
+    await queryRunner.manager.getRepository("newsletter").save(newsletters);
+  }
+}

src/migrations/1744795756230-QueryUpdatedAt.ts

@@ -0,0 +1,22 @@
+import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
+import { getTypeByORM, getDefaultByORM } from "./ormHelper";
+
+export class QueryUpdatedAt1744795756230 implements MigrationInterface {
+  name = "QueryUpdatedAt1744795756230";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.addColumn(
+      "query",
+      new TableColumn({
+        name: "updatedAt",
+        ...getTypeByORM("datetime", false, 6),
+        default: getDefaultByORM("currentTimestamp", 6),
+        onUpdate: getDefaultByORM<string>("currentTimestamp", 6),
+      })
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropColumn("query", "updatedAt");
+  }
+}

src/routes/admin/club/newsletter.ts

@@ -16,6 +16,8 @@ import {
   createNewsletterPrintoutPreviewById,
   getNewsletterPrintoutProgressById,
   getNewsletterSendingProgressById,
+  getNewsletterMailReceiversById,
+  getNewsletterPrintReceiversById,
 } from "../../../controller/admin/club/newsletterController";
 import PermissionHelper from "../../../helpers/permissionHelper";
 
@@ -57,6 +59,14 @@ router.get("/:newsletterId/sendprogress", async (req: Request, res: Response) =>
   await getNewsletterSendingProgressById(req, res);
 });
 
+router.get("/:newsletterId/printrecipients", async (req: Request, res: Response) => {
+  await getNewsletterPrintReceiversById(req, res);
+});
+
+router.get("/:newsletterId/mailrecipients", async (req: Request, res: Response) => {
+  await getNewsletterMailReceiversById(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "club", "protocol"),

src/routes/admin/club/queryBuilder.ts

@@ -1,5 +1,10 @@
 import express, { Request, Response } from "express";
-import { executeQuery, getAllTableMeta, getTableMetaByTablename } from "../../../controller/admin/club/queryBuilderController";
+import {
+  executeQuery,
+  executeQueryByStoreId,
+  getAllTableMeta,
+  getTableMetaByTablename,
+} from "../../../controller/admin/club/queryBuilderController";
 
 var router = express.Router({ mergeParams: true });
 
@@ -15,4 +20,8 @@ router.post("/query", async (req: Request, res: Response) => {
   await executeQuery(req, res);
 });
 
+router.post("/query/:storeId", async (req: Request, res: Response) => {
+  await executeQueryByStoreId(req, res);
+});
+
 export default router;

src/routes/index.ts

@@ -68,7 +68,7 @@ export default (app: Express) => {
   }
   app.set("query parser", "extended");
   app.use(cors());
-  app.options("*", cors());
+  app.options("*splat", cors());
   app.use(helmet());
   app.use(morgan("short"));
   app.use(express.json());

src/service/club/member/memberService.ts

@@ -1,4 +1,4 @@
-import { SelectQueryBuilder } from "typeorm";
+import { Brackets, Like, SelectQueryBuilder } from "typeorm";
 import { dataSource } from "../../../data-source";
 import { member } from "../../../entity/club/member/member";
 import { membership } from "../../../entity/club/member/membership";
@@ -28,19 +28,29 @@ export default abstract class MemberService {
     let query = this.applyMemberBaseJoins();
 
     if (search != "") {
-      search.split(" ").forEach((term, index) => {
-        const searchQuery = `%${term}%`;
-        const dynamic = "searchQuery" + Math.random().toString(36).substring(2);
-        if (index == 0) {
-          query = query.where(`member.firstname LIKE :${dynamic} OR member.lastname LIKE :${dynamic}`, {
-            [dynamic]: searchQuery,
+      let searchBits = search.split(" ");
+
+      if (searchBits.length < 2) {
+        query = query.where(`member.firstname LIKE :searchQuery OR member.lastname LIKE :searchQuery`, {
+          searchQuery: `%${searchBits[0]}%`,
         });
       } else {
-          query = query.orWhere(`member.firstname LIKE :${dynamic} OR member.lastname LIKE :${dynamic}`, {
-            [dynamic]: searchQuery,
+        searchBits
+          .flatMap((v, i) => searchBits.slice(i + 1).map((w) => [v, w]))
+          .forEach((term) => {
+            query = query
+              .orWhere(
+                new Brackets((qb) =>
+                  qb.where({ firstname: Like(`%${term[0]}%`) }).andWhere({ lastname: Like(`%${term[1]}%`) })
+                )
+              )
+              .orWhere(
+                new Brackets((qb) =>
+                  qb.where({ firstname: Like(`%${term[1]}%`) }).andWhere({ lastname: Like(`%${term[0]}%`) })
+                )
+              );
           });
       }
-      });
     }
 
     if (ids.length != 0) {

src/service/configuration/queryStoreService.ts

@@ -26,7 +26,7 @@ export default abstract class QueryStoreService {
    * @description get queryStore by id
    * @returns {Promise<query>}
    */
-  static async getById(id: number): Promise<query> {
+  static async getById(id: string): Promise<query> {
     return await dataSource
       .getRepository(query)
       .createQueryBuilder("queryStore")

src/type/dynamicQueries.ts

@@ -1,9 +1,10 @@
 export interface DynamicQueryStructure {
+  id: string;
   select: string[] | "*";
   table: string;
   where?: Array<ConditionStructure>;
-  join?: Array<DynamicQueryStructure & { foreignColumn: string }>;
-  orderBy?: Array<OrderByStructure>;
+  join?: Array<DynamicQueryStructure & JoinStructure>;
+  orderBy?: Array<OrderByStructure>; // only at top level
 }
 
 export type ConditionStructure = (
@@ -47,7 +48,12 @@ export type WhereOperation =
   | "timespanEq"; // Date before x years (YYYY-01-01 <bis> YYYY-12-31)
 // TODO: age between | age equals | age greater | age smaller
 
+export type JoinStructure = { foreignColumn: string; type: "defined" } | { condition: string; type: "custom" };
+
 export type OrderByStructure = {
+  id: string;
+  depth: number;
+  table: string;
   column: string;
   order: OrderByType;
 };
@@ -59,6 +65,7 @@ export type QueryResult = {
 };
 
 export const exampleQuery: DynamicQueryStructure = {
+  id: "1234",
   select: ["firstname", "lastname"],
   table: "member",
   where: [
@@ -92,19 +99,25 @@ export const exampleQuery: DynamicQueryStructure = {
   ],
   join: [
     {
+      id: "5678",
       select: "*",
       table: "communication",
       foreignColumn: "sendNewsletter",
+      type: "defined",
     },
     {
+      id: "91011",
       select: "*",
       table: "membership",
       foreignColumn: "memberships",
+      type: "defined",
       join: [
         {
+          id: "121314",
           select: "*",
           table: "membership_status",
           foreignColumn: "status",
+          type: "defined",
           where: [
             {
               structureType: "condition",
@@ -120,10 +133,16 @@ export const exampleQuery: DynamicQueryStructure = {
   ],
   orderBy: [
     {
+      id: "1234",
+      depth: 0,
+      table: "member",
       column: "firstname",
       order: "ASC",
     },
     {
+      id: "1234",
+      depth: 0,
+      table: "member",
       column: "lastname",
       order: "ASC",
     },

src/type/permissionTypes.ts

@@ -30,6 +30,7 @@ export type PermissionString =
   | `${PermissionSection}.${PermissionModule}.*` // für alle Berechtigungen in einem Modul
   | `${PermissionSection}.${PermissionType}` // für spezifische Berechtigungen in einem Abschnitt
   | `${PermissionSection}.*` // für alle Berechtigungen in einem Abschnitt
+  | `additional.${string}.${string}` // additional
   | "*"; // für Admin
 
 export type PermissionObject = {
@@ -38,10 +39,20 @@ export type PermissionObject = {
   } & { all?: Array<PermissionType> | "*" };
 } & {
   admin?: boolean;
+  adminByOwner?: boolean;
+} & {
+  additional?: { [key: string]: string };
 };
 
 export type SectionsAndModulesObject = {
   [section in PermissionSection]: Array<PermissionModule>;
+} & {
+  additional?: Array<{
+    key: string;
+    name: string;
+    type: "number" | "string";
+    emptyIfAdmin: boolean;
+  }>;
 };
 
 export const permissionSections: Array<PermissionSection> = ["club", "configuration", "management"];
@@ -85,4 +96,5 @@ export const sectionsAndModules: SectionsAndModulesObject = {
     "newsletter_config",
   ],
   management: ["user", "role", "webapi", "backup"],
+  additional: [],
 };

src/type/templateTypes.ts

@@ -0,0 +1,11 @@
+import { PermissionModule } from "./permissionTypes";
+
+export type TemplateFormat = `${PermissionModule}` | `${PermissionModule}.${string}`;
+
+export const availableTemplates: Array<TemplateFormat> = [
+  "member",
+  "listprint",
+  "listprint.member",
+  "newsletter",
+  "protocol",
+];

src/viewmodel/admin/club/newsletter/newsletter.models.ts

@@ -8,6 +8,6 @@ export interface NewsletterViewModel {
   newsletterText: string;
   newsletterSignatur: string;
   isSent: boolean;
-  recipientsByQueryId?: number;
+  recipientsByQueryId?: string;
   recipientsByQuery?: QueryStoreViewModel;
 }

src/viewmodel/admin/configuration/queryStore.models.ts

@@ -1,7 +1,8 @@
 import { DynamicQueryStructure } from "../../../type/dynamicQueries";
 
 export interface QueryStoreViewModel {
-  id: number;
+  id: string;
   title: string;
   query: string | DynamicQueryStructure;
+  updatedAt: Date;
 }