src/helpers/newsletterHelper.ts

@@ -61,41 +61,39 @@ export abstract class NewsletterHelper {
       newsletterTitle: newsletter.newsletterTitle,
       newsletterText: newsletter.newsletterText,
       newsletterSignatur: newsletter.newsletterSignatur,
-      dates: dates
+      dates: dates.map((d) => ({
-        .map((d) => ({
+        title: d.diffTitle || d.calendar.title,
-          title: d.diffTitle || d.calendar.title,
+        content: d.diffDescription || d.calendar.content,
-          content: d.diffDescription || d.calendar.content,
+        starttime: d.calendar.starttime,
-          starttime: d.calendar.starttime,
+        formattedStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
-          formattedStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
+          weekday: "long",
-            weekday: "long",
+          day: "2-digit",
-            day: "2-digit",
+          month: "long",
-            month: "long",
+        }),
-          }),
+        formattedFullStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
-          formattedFullStarttime: new Date(d.calendar.starttime).toLocaleDateString("de-DE", {
+          weekday: "long",
-            weekday: "long",
+          day: "2-digit",
-            day: "2-digit",
+          month: "long",
-            month: "long",
+          year: "numeric",
-            year: "numeric",
+          hour: "2-digit",
-            hour: "2-digit",
+          minute: "2-digit",
-            minute: "2-digit",
+        }),
-          }),
+        endtime: d.calendar.endtime,
-          endtime: d.calendar.endtime,
+        formattedEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
-          formattedEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
+          weekday: "long",
-            weekday: "long",
+          day: "2-digit",
-            day: "2-digit",
+          month: "long",
-            month: "long",
+        }),
-          }),
+        formattedFullEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
-          formattedFullEndtime: new Date(d.calendar.endtime).toLocaleDateString("de-DE", {
+          weekday: "long",
-            weekday: "long",
+          day: "2-digit",
-            day: "2-digit",
+          month: "long",
-            month: "long",
+          year: "numeric",
-            year: "numeric",
+          hour: "2-digit",
-            hour: "2-digit",
+          minute: "2-digit",
-            minute: "2-digit",
+        }),
-          }),
+        location: d.calendar.location,
-          location: d.calendar.location,
+      })),
-        }))
-        .sort((a, b) => a.starttime.getTime() - b.starttime.getTime()),
       ...(recipient
         ? {
             recipient: {
@@ -282,7 +280,7 @@ export abstract class NewsletterHelper {
 
     const pdfRecipients = await this.getPrintRecipients(newsletterId);
 
-    this.formatJobEmit("progress", "pdf", "info", newsletterId, pdfRecipients.length, 0, "starting printing");
+    this.formatJobEmit("progress", "pdf", "info", newsletterId, pdfRecipients.length, 0, "starting sending");
 
     for (const [index, rec] of pdfRecipients.entries()) {
       let data = this.buildData(newsletter, dates, rec, printWithAdress.includes(rec.sendNewsletter?.type?.id));

src/helpers/pdfExport.ts

@@ -1,47 +1,10 @@
-import puppeteer, { Browser } from "puppeteer";
+import puppeteer 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",
@@ -65,25 +28,33 @@ 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);
 
-    const renderedTemplate = await this.renderTemplate(template, title, data, customTemplate);
+    let header: string, footer: string, body: string, headerMargin: number, footerMargin: number;
-    let { header, footer, body, headerMargin, footerMargin } = renderedTemplate;
+    if (!customTemplate) {
-
+      ({ header, footer, body, headerMargin, footerMargin } = await TemplateHelper.renderFileForModule({
-    if (!this.browserInstance || !this.browserInstance.connected) {
+        module: template,
-      this.browserInstance = await puppeteer.launch({
+        headerData: data,
-        headless: true,
+        bodyData: data,
-        args: ["--no-sandbox", "--disable-gpu", "--disable-setuid-sandbox"],
+        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 page = await this.browserInstance.newPage();
+    const browser = await puppeteer.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-gpu", "--disable-setuid-sandbox"],
+    });
+    const page = await browser.newPage();
     await page.setContent(body, { waitUntil: "domcontentloaded" });
 
     const exportPath = FileSystemHelper.formatPath(folder, `${filename}.pdf`);
@@ -103,16 +74,7 @@ export abstract class PdfExport {
       footerTemplate: footer,
     });
 
-    await page.close();
+    await browser.close();
-
-    this.printing.delete(id);
-
-    if (this.printing.size == 0) {
-      this.timeout = setTimeout(() => {
-        this.browserInstance.close();
-        this.browserInstance = undefined;
-      }, 5000);
-    }
 
     return pdf;
   }

src/helpers/templateHelper.ts

@@ -11,9 +11,7 @@ export abstract class TemplateHelper {
     try {
       tmpFile = FileSystemHelper.readTemplateFile(`/src/templates/${template}.template.html`);
     } catch (err) {
-      tmpFile = FileSystemHelper.readTemplateFile(
+      tmpFile = FileSystemHelper.readTemplateFile(`/src/templates/${template.split(".")[1]}.template.html`);
-        `/src/templates/${template.split(".")[template.split(".").length - 1]}.template.html`
-      );
     }
     return tmpFile;
   }