- Catalogo: qualità di stampa, margini. ora è 300 DPI.

2024-12-05 14:12:51 +01:00
parent c914555a5f
commit 8803190313
12 changed files with 296804 additions and 1450 deletions
--- a/src/server/router/admin_router.js
+++ b/src/server/router/admin_router.js
@@ -30,8 +30,286 @@ const { ImageDownloader } = require('../tools/general.js');

 const path = require('path');

+const gs = require('ghostscript4js');
+
+const { PDFDocument, rgb } = require('pdf-lib');
+
+const pdf = require('pdf-parse');
+
+
 var { authenticate } = require('../middleware/authenticate');

+const multer = require('multer');
+
+const DIR_PDF_IN = __dirname + '/upload/files_input/';
+const DIR_PDF_OUT = __dirname + '/upload/files_output/';
+
+const upload = multer({ dest: DIR_PDF_IN });
+
+const util = require('util');
+const cwd = process.cwd();
+
+const { exec } = require('child_process');
+
+const execPromise = util.promisify(exec);
+
+
+async function compressPdf(inputFile, outputFile, compressione) {
+  try {
+    const tempFolder = path.join(cwd, "temp");
+    const hasTempFolder = tools.isFileExists(tempFolder);
+
+    if (!hasTempFolder) {
+      await fs.mkdir(tempFolder); // Usa la versione promessa di mkdir
+    }
+
+    /*
+  Quando utilizzi Ghostscript per comprimere un PDF e desideri controllare la qualità di stampa, puoi modificare i parametri dell'opzione -dPDFSETTINGS per ottenere risultati migliori per scopi di stampa. 
+  Le seguenti opzioni sono disponibili per -dPDFSETTINGS:
+
+  Opzioni di -dPDFSETTINGS
+  /screen: Buona per la visualizzazione su schermo; bassa qualità e dimensione del file ridotta.
+  /ebook: Ottimizza il PDF per la lettura su ebook; qualità media e dimensione media.
+  /printer: Ottimizza il PDF per la stampa di qualità; migliora la risoluzione rispetto a /ebook.
+  /prepress: Ottimizza per la stampa di alta qualità; ideale per progetti di stampa professionali.
+  /default: Usa impostazioni predefinite; generalmente fornisce un buon equilibrio tra qualità e dimensione.
+  */
+
+    // Comprime il PDF utilizzando Ghostscript
+    const gsCommand = `gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/${compressione} -dNOPAUSE -dQUIET -dBATCH -sOutputFile="${outputFile}" "${inputFile}"`;
+
+    console.log('gsCommand', gsCommand);
+
+    // Esegui il comando per la compressione
+    await execPromise(gsCommand);
+
+    console.log(`PDF compresso e salvato come '${outputFile}'`);
+
+  } catch (error) {
+    console.error('Errore durante la compressione:', error);
+    throw error; // Propaga l'errore
+  }
+}
+
+async function convertPDF_GS(inputFile, outputFile, width, height) {
+  // Verifica che il file di input esista
+  if (!tools.isFileExists(inputFile)) {
+    throw new Error(`Il file di input non esiste: ${inputFile}`);
+  }
+
+  // Converti cm in punti (1 cm = 28.34646 punti)
+  const widthPt = width * 28.34646;
+  const heightPt = height * 28.34646;
+
+  // Arrotonda i valori
+  const widthPx = Math.round(widthPt);
+  const heightPx = Math.round(heightPt);
+
+  // Comando Ghostscript
+  const gsCommand = [
+    '-sDEVICE=pdfwrite',
+    '-dCompatibilityLevel=1.4',
+    '-dPDFSETTINGS=/prepress',
+    '-dNOPAUSE',
+    '-dQUIET',
+    '-dBATCH',
+    `-dDEVICEWIDTHPOINTS=${widthPx}`,
+    `-dDEVICEHEIGHTPOINTS=${heightPx}`,
+    '-dDPIx=300',
+    '-dDPIy=300',
+    `-sOutputFile=${outputFile}`,
+    inputFile
+  ].join(' ');
+
+  try {
+    console.log(gsCommand);
+    await gs.executeSync(gsCommand); // Assicurati che executeSync restituisca una promessa o usa la funzione corretta se è sincrona.
+    console.log('Conversione completata con successo!');
+
+    // Verifica che il file di output sia stato generato
+    if (tools.isFileExists(outputFile)) {
+      console.log('File di output generato:', outputFile);
+    } else {
+      console.error('Il File di output NON è stato generato! :', outputFile);
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Il file di input non esiste: ${inputFile}`);
+    } else if (error instanceof gs.GhostscriptError) {
+      throw new Error(`Errore Ghostscript: ${error.message}`);
+    } else {
+      throw new Error(`Errore durante la conversione: ${error.message}`);
+    }
+  }
+}
+
+async function extractPdfInfo(inputFile) {
+  // Estrai le dimensioni delle pagine utilizzando pdf-lib
+  const existingPdfBytes = fs.readFileSync(inputFile);
+  const pdfDoc = await PDFDocument.load(existingPdfBytes);
+
+  // Ottieni informazioni sulle dimensioni delle pagine
+  const pages = pdfDoc.getPages();
+  const pageInfo = pages.map(page => {
+    const { width, height } = page.getSize();
+    return {
+      width: width, // in punti
+      height: height // in punti
+    };
+  });
+
+  // Estrai informazioni testuali e numero di pagine utilizzando pdf-parse
+  const dataBuffer = fs.readFileSync(inputFile);
+  const data = await pdf(dataBuffer);
+
+  const dpiInfo = {
+    numPages: data.numpages,
+    pageInfo: pageInfo
+  };
+
+  console.log("DPI info might require image extraction (not available directly):");
+  console.log("Number of Pages:", dpiInfo.numPages);
+  console.log("Page Dimensions (in points):", dpiInfo.pageInfo);
+}
+
+
+async function convertPDF_PdfLib(inputFile, outputFile, width, height, compressione) {
+  if (!tools.isFileExists(inputFile)) {
+    throw new Error(`Il file di input non esiste: ${inputFile}`);
+  }
+
+  try {
+    // Carica il PDF esistente
+    const existingPdfBytes = fs.readFileSync(inputFile);
+    const pdfDoc = await PDFDocument.load(existingPdfBytes);
+
+    // Crea un nuovo PDF
+    const newPdfDoc = await PDFDocument.create();
+
+    // Itera attraverso le pagine esistenti
+    const pages = pdfDoc.getPages();
+    for (const page of pages) {
+      const { width: originalWidth, height: originalHeight } = page.getSize();
+
+      // Calcola la larghezza e l'altezza in punti
+      const newWidth = width * 72; // Convertito in punti
+      const newHeight = height * 72; // Convertito in punti
+
+      // Crea una nuova pagina con le dimensioni specificate
+      const newPage = newPdfDoc.addPage([newWidth, newHeight]);
+
+      // Calcola lo scaling per mantenere le proporzioni
+      const scaleWidth = newWidth / originalWidth;
+      const scaleHeight = newHeight / originalHeight;
+      const scale = Math.min(scaleWidth, scaleHeight); // Usa il min per mantenere il rapporto
+
+      // Incorpora la pagina esistente nel nuovo PDF
+      const embeddedPage = await newPdfDoc.embedPage(page);
+
+      // Disegna la pagina incorporata nel nuovo PDF
+      newPage.drawPage(embeddedPage, {
+        x: (newWidth - originalWidth * scale) / 2, // Centrato orizzontalmente
+        y: (newHeight - originalHeight * scale) / 2, // Centrato verticalmente
+        width: originalWidth * scale,
+        height: originalHeight * scale,
+      });
+    }
+
+    // Salva il nuovo PDF
+    const pdfBytes = await newPdfDoc.save();
+    fs.writeFileSync(outputFile, pdfBytes);
+    console.log(`PDF convertito e salvato come '${outputFile}'`);
+
+    const comprimi = false;
+
+    let fileout = outputFile;
+
+    if (compressione) {
+      const compressed = tools.removeFileExtension(outputFile) + '-compressed.pdf';
+
+      await compressPdf(outputFile, compressed, compressione);
+
+      extractPdfInfo(compressed);
+      fileout = compressed;
+    }
+
+    return fileout;
+
+  } catch (e) {
+    console.error(e);
+    return '';
+  }
+}
+
+
+// Endpoint POST per la conversione del PDF
+router.post('/convert-pdf', upload.single('pdf'), async (req, res) => {
+  if (!req.file) {
+    return res.status(400).send('No file uploaded.');
+  }
+
+  const inputFile = req.file.path;
+  const { width, height, compressione } = req.body;
+
+  if (!width) {
+    fs.unlinkSync(inputFile);
+    return res.status(400).send('Width parameter is required');
+  }
+
+  let outputFile = path.join(DIR_PDF_OUT, `${tools.removeFileExtension(req.file.originalname)}-converted.pdf`);
+
+  try {
+    await fs.promises.mkdir(DIR_PDF_IN, { recursive: true });
+    await fs.promises.mkdir(DIR_PDF_OUT, { recursive: true });
+
+    // console.log('File:', req.file);
+    // console.log('Width:', width);
+    // console.log('Height:', height);
+
+    // Converti il PDF
+    // await convertPDF_GS(inputFile, outputFile, width, height);
+    const fileout = await convertPDF_PdfLib(inputFile, outputFile, width, height, compressione);
+
+    if (fileout) {
+      // Invia il file convertito
+      res.download(fileout, 'output-converted.pdf', (err) => {
+        if (err) {
+          console.error('Errore durante l\'invio del file:', err);
+          if (!res.headersSent) {
+            res.status(500).send('Errore durante l\'invio del file convertito');
+          }
+        } else {
+          // Rimuovi i file temporanei
+          cleanupFiles(inputFile, outputFile);
+        }
+      });
+    }
+
+  } catch (error) {
+    console.error('Errore durante la conversione:', error);
+    cleanupFiles(inputFile, outputFile);
+    if (!res.headersSent) {
+      res.status(500).send(`Errore durante la conversione del PDF: ${error.message}`);
+    }
+  }
+});
+
+function cleanupFiles(inputFile, outputFile) {
+  if (inputFile) {
+    tools.deleteFile(inputFile)
+      .catch((err) => {
+        console.error('Errore durante la rimozione del file di INPUT:', err);
+      })
+  };
+  if (outputFile) {
+    tools.deleteFile(outputFile)
+      .catch((err) => {
+        console.error('Errore durante la rimozione del file di output:', err);
+      })
+  };
+
+};
+
 router.post('/updateval', authenticate, async (req, res) => {
  console.log('/updateval', req.body.pairval);
  idapp = req.body.idapp;
@@ -575,7 +853,7 @@ router.post('/import', authenticate, async (req, res) => {
            rank1Y: product.rank1Y,
          }

-          if (product.DataPubblicazione) { 
+          if (product.DataPubblicazione) {
            productInfo.date_publishing = new Date(product.DataPubblicazione);
            // convert data to timestamp
            productInfo.date_publishing_ts = productInfo.date_publishing.getTime();
@@ -640,7 +918,7 @@ router.post('/import', authenticate, async (req, res) => {
              }
              if ((!recmacro.Pagine || recmacro.Pagine === 0) && recrankingisbn.Pagine)
                recmacro.Pagine = recrankingisbn.Pagine;
-              
+
              if (!recmacro.misure && recrankingisbn.misure) {
                recmacro.misure = recrankingisbn.misure;
              }
--- a/src/server/tools/general.js
+++ b/src/server/tools/general.js
@@ -4011,6 +4011,16 @@ module.exports = {
    return path.dirname(filename);
  },

+  async deleteFile(filePath) {
+    try {
+      await fs.promises.unlink(filePath);
+      console.log(`File eliminato con successo: ${filePath}`);
+    } catch (err) {
+      console.error(`Errore durante l'eliminazione del file: ${filePath}`, err);
+      throw err;
+    }
+  },
+
  delete(mypath, alsothumb, callback) {

    fs.unlink(mypath, function (err) {
@@ -4097,7 +4107,11 @@ module.exports = {
  },

  isFileExists(filename) {
-    return fs.existsSync(filename);
+    try {
+      return fs.existsSync(filename);
+    } catch (e) {
+      return false
+    }
  },

  getiPAddressUser(req) {
@@ -4400,7 +4414,7 @@ module.exports = {
    // Controlla se il valore è un numero valido
    return !isNaN(value) && value !== null && value !== '';
  },
-  
+
  invertescapeslash(mystr) {
    return mystr.replace(/Ç/g, '/');
  },
@@ -4783,6 +4797,20 @@ module.exports = {
    }
  },

+  removeFileExtension(filename) {
+    // Trova l'ultima occorrenza del punto nel nome del file
+    const lastDotIndex = filename.lastIndexOf('.');
+
+    // Se non c'è un punto o il punto è all'inizio del nome file,
+    // restituisci il nome file originale
+    if (lastDotIndex === -1 || lastDotIndex === 0) {
+      return filename;
+    }
+
+    // Altrimenti, restituisci la parte del nome file prima dell'ultimo punto
+    return filename.substring(0, lastDotIndex);
+  },
+
  removeSpanAndDivTags(text) {
    // Rimozione dei tag <span> e </span> dalla stringa di testo
    const spanRegex = /<span[^>]*>|<\/span>/gi;