- Generazione della Raccolta dei Cataloghi (web e Stampa), e creazione del PDF Online.

- Lista Raccolta Cataloghi, aggiungi/togli catalogo.

src/server/router/admin_router.js

@@ -28,6 +28,7 @@ const Gasordine = require('../models/gasordine');
 const { User } = require('../models/user');
 
 const { Catalog } = require('../models/catalog');
+const { RaccoltaCataloghi } = require('../models/raccoltacataloghi');
 
 const server_constants = require('../tools/server_constants');
 
@@ -420,41 +421,47 @@ router.post('/online-pdf', authenticate, async (req, res) => {
 
   idapp = req.body.idapp;
   id_catalog = req.body.id_catalog;
+  id_raccolta = req.body.id_raccolta;
   stampa = req.body.stampa;
   let mydir = '';
   let risout = {};
 
   try {
+    let myrec = null;
     // Aggiorna il PDF OnLine, copiando il file da Generato a OnLine
-    let catalog = await Catalog.findOne({ _id: id_catalog });
+    if (id_catalog) {
+      myrec = await Catalog.findOne({ _id: id_catalog });
+    } else if (id_raccolta) {
+      myrec = await RaccoltaCataloghi.findOne({ _id: id_raccolta });
+    }
 
-    if (catalog) {
+    if (myrec) {
       mydir = tools.getdirByIdApp(idapp);
       // const baseurl = this.getHostByIdApp(idapp);
 
       if (stampa) {
-        catalog.pdf_online_stampa = catalog.pdf_generato_stampa.replace('_generato', '');
+        myrec.pdf_online_stampa = myrec.pdf_generato_stampa.replace('_generato', '');
       } else {
-        catalog.pdf_online = catalog.pdf_generato.replace('_generato', '');
+        myrec.pdf_online = myrec.pdf_generato.replace('_generato', '');
       }
 
       // Aggiorna il PDF OnLine, copiando il file da Generato a OnLine
-      const fileOrigin = mydir + (stampa ? catalog.pdf_generato_stampa : catalog.pdf_generato);
-      const fileDest = mydir + (stampa ? catalog.pdf_online_stampa : catalog.pdf_online);
-      const fileDestNoDir = (stampa ? catalog.pdf_online_stampa : catalog.pdf_online);
+      const fileOrigin = mydir + (stampa ? myrec.pdf_generato_stampa : myrec.pdf_generato);
+      const fileDest = mydir + (stampa ? myrec.pdf_online_stampa : myrec.pdf_online);
+      const fileDestNoDir = stampa ? myrec.pdf_online_stampa : myrec.pdf_online;
       // copia il file
       await fs.promises.copyFile(fileOrigin, fileDest);
 
       if (stampa) {
-        catalog.data_online_stampa = catalog.data_generato_stampa;
+        myrec.data_online_stampa = myrec.data_generato_stampa;
       } else {
-        catalog.data_online = catalog.data_generato;
+        myrec.data_online = myrec.data_generato;
       }
 
       // Aggiorna il record
-      await catalog.save();
+      await myrec.save();
 
-      risout = {catalog: catalog._doc};
+      risout = { record: myrec._doc };
     }
 
     // risout
@@ -465,6 +472,114 @@ router.post('/online-pdf', authenticate, async (req, res) => {
   }
 });
 
+async function JoinPDFCatalogs(cataloghi, options, outputFile, stampa) {
+  try {
+    // Per ogni catalogo prendi il suo PDF Generato
+
+    const pdfDoc = await PDFDocument.create();
+
+    for (let id_catalog of cataloghi) {
+      let catalog = await Catalog.findOne({ _id: id_catalog });
+      if (catalog) {
+        let filename = stampa ? catalog.pdf_generato_stampa : catalog.pdf_generato;
+        if (filename) {
+          const pdfBytes = await fs.promises.readFile(options.mydir + filename);
+          const pdf = await PDFDocument.load(pdfBytes);
+          const pages = pdf.getPages();
+          const copiedPages = await pdfDoc.copyPages(
+            pdf,
+            pages.map((p, i) => i)
+          );
+          for (let page of copiedPages) {
+            pdfDoc.addPage(page);
+          }
+        } else {
+          console.log('ATTENZIONE! Catalogo non ancora Generato ! ', catalog.title);
+        }
+      }
+    }
+
+    // Raccolta salvata !
+    const pdfBytes = await pdfDoc.save();
+    await fs.promises.writeFile(outputFile, pdfBytes);
+    // scrivi il percorso relativo e nomefile sul DB
+
+    const outputFilename = path.basename(outputFile);
+    const outputPath = path.join(options.dir_out, outputFilename);
+
+    const ris = {
+      outputPath,
+    };
+
+    return ris;
+  } catch (e) {
+    console.error('Error: ', e);
+  }
+
+  return {};
+}
+
+router.post('/join-pdf', authenticate, async (req, res) => {
+  console.log('/join-pdf');
+
+  idapp = req.body.idapp;
+  options = req.body.options;
+  options.idapp = idapp;
+  options.mydir = tools.getdirByIdApp(idapp);
+
+  try {
+    const full_dir_out = tools.getdirByIdApp(options.idapp) + '/' + options.dir_out;
+    await fs.promises.mkdir(full_dir_out, { recursive: true });
+
+    // Aggiorna il PDF OnLine, copiando il file da Generato a OnLine
+    let raccolta = await RaccoltaCataloghi.findOne({ _id: options.id_raccolta });
+
+    if (raccolta) {
+      cataloghi = raccolta.lista_cataloghi;
+
+      let outputFile = path.join(
+        full_dir_out,
+        tools.removeFileExtension(raccolta.nomefile_da_generare) + '_generato.pdf'
+      );
+
+      if (options.stampa) {
+        outputFileStampa = path.join(full_dir_out, path.basename(tools.removeFileExtension(outputFile))) + '-stampabile.pdf';
+        // Creazione file per STAMPA
+        const ris_stampa = await JoinPDFCatalogs(cataloghi, options, outputFileStampa, true);
+        if (ris_stampa) {
+          raccolta.pdf_generato_stampa = ris_stampa.outputPath;
+        }
+      } else {
+        // Creazione file per WEB
+        const ris = await JoinPDFCatalogs(cataloghi, options, outputFile, false);
+        if (ris) {
+          raccolta.pdf_generato = ris.outputPath;
+        }
+      }
+
+      if (options.metti_online) {
+        if (options.stampa) {
+          raccolta.pdf_online_stampa = raccolta.pdf_generato_stampa.replace('_generato', '');
+        } else {
+          raccolta.pdf_online = raccolta.pdf_generato.replace('_generato', '');
+        }
+        const fileDest = options.mydir + raccolta.pdf_online;
+        await fs.promises.writeFile(fileDest, pdfBytes);
+      }
+
+      raccolta.save();
+
+      risout = { raccolta: raccolta._doc };
+    }
+
+    // risout
+
+    return res.status(200).send(risout);
+  } catch (e) {
+    console.error('Err join-pdf', e.message);
+  }
+});
+
 // Endpoint POST per la conversione del PDF
 router.post('/convert-pdf', upload.single('pdf'), async (req, res) => {
   if (!req.file) {