node-hp-scan-to 1.4.3 → 1.5.1

package/src/index.ts

@@ -5,7 +5,7 @@
 
 import os from "os";
 import { Command, Option, OptionValues, program } from "commander";
-import Bonjour from "bonjour";
+import { Bonjour } from "bonjour-service";
 import config from "config";
 import HPApi from "./HPApi";
 import PathHelper from "./PathHelper";
@@ -19,11 +19,15 @@ import {
 import {
   AdfAutoScanConfig,
   DirectoryConfig,
-  saveScan,
+  saveScanFromEvent,
   ScanConfig,
   scanFromAdf,
   waitAdfLoaded,
 } from "./scanProcessing";
+import * as commitInfo from "./commitInfo.json";
+import { PaperlessConfig } from "./paperless/PaperlessConfig";
+import { startHealthCheckServer } from "./healthcheck";
+
 
 let iteration = 0;
 
@@ -52,6 +56,7 @@ async function listenCmd(
   let keepActive = true;
   let errorCount = 0;
   while (keepActive) {
+    iteration++;
     console.log(`Running iteration: ${iteration} - errorCount: ${errorCount}`);
     try {
       const event = await waitScanEvent(deviceCapabilities, registrationConfig);
@@ -61,7 +66,7 @@ async function listenCmd(
         scanConfig.directoryConfig.filePattern,
       );
       console.log(`Scan event captured, saving scan #${scanCount}`);
-      await saveScan(
+      await saveScanFromEvent(
         event,
         folder,
         tempFolder,
@@ -117,6 +122,7 @@ async function adfAutoscanCmd(
   let keepActive = true;
   let errorCount = 0;
   while (keepActive) {
+    iteration++;
     console.log(`Running iteration: ${iteration} - errorCount: ${errorCount}`);
     try {
       await waitAdfLoaded(
@@ -170,9 +176,9 @@ async function clearRegistrationsCmd(cmd: Command) {
 
 function findOfficejetIp(deviceNamePrefix: string): Promise<string> {
   return new Promise((resolve) => {
-    const bonjour = Bonjour();
+    const bonjour = new Bonjour();
     console.log("Searching device...");
-    let browser = bonjour.find(
+    const browser = bonjour.find(
       {
         type: "http",
       },
@@ -202,15 +208,15 @@ function getConfig<T>(name: string): T | undefined {
 function setupScanParameters(command: Command): Command {
   command.option(
     "-d, --directory <dir>",
-    "Directory where scans are saved (default: /tmp/scan-to-pc<random>)",
+    "Directory where scans are saved (default: /tmp/scan-to-pcRANDOM)",
   );
   command.option(
     "-t, --temp-directory <dir>",
-    "Temp directory used for processing (default: /tmp/scan-to-pc<random>)",
+    "Temp directory used for processing (default: /tmp/scan-to-pcRANDOM)",
   );
   command.option(
     "-p, --pattern <pattern>",
-    'Pattern for filename (i.e. "scan"_dd.mm.yyyy_hh:MM:ss, without this its scanPage<number>)',
+    'Pattern for filename (i.e. "scan"_dd.mm.yyyy_hh:MM:ss, without this its scanPageNUMBER)',
   );
   command.option(
     "-r, --resolution <dpi>",
@@ -224,12 +230,33 @@ function setupScanParameters(command: Command): Command {
     "-h, --height <height>",
     "Height in pixel of the scans (default: 3507)",
   );
+  command.option(
+    "-s, --paperless-post-document-url <paperless_post_document_url>",
+    "The paperless post document url (example: https://domain.tld/api/documents/post_document/)",
+  );
+
+  command.option(
+    "-o, --paperless-token <paperless_token>",
+    "The paperless token",
+  );
+  command.option(
+    "--paperless-group-multi-page-scan-into-a-pdf",
+    "Combine multiple scanned images into a single PDF document",
+  );
+  command.option(
+    "--paperless-always-send-as-pdf-file",
+    "Always convert scan job to pdf before sending to paperless",
+  );
+  command.option(
+    "-k, --paperless-keep-files",
+    "Keep the scan files on the file system (default: false)",
+  );
   return command;
 }
 
 function setupParameterOpts(command: Command): Command {
   command.option(
-    "-ip, --address <ip>",
+    "-a, --address <ip>",
     "IP address of the device (this overrides -p)",
   );
   command.option(
@@ -266,41 +293,93 @@ function getIsDebug(options: OptionValues) {
   return debug;
 }
 
-function getScanConfiguration(parentOption: OptionValues) {
+function getPaperlessConfig(
+  parentOption: OptionValues,
+): PaperlessConfig | undefined {
+  const paperlessPostDocumentUrl: string =
+    parentOption.paperlessPostDocumentUrl ||
+    getConfig("paperless_post_document_url");
+  const configPaperlessToken: string =
+    parentOption.paperlessToken || getConfig("paperless_token");
+  const configPaperlessKeepFiles =
+    parentOption.paperlessKeepFiles ||
+    getConfig("paperless_keep_files") ||
+    false;
+
+  if (paperlessPostDocumentUrl && configPaperlessToken) {
+    const configPaperlessKeepFiles: boolean =
+      parentOption.paperlessKeepFiles ||
+      getConfig("paperless_keep_files") ||
+      false;
+    const groupMultiPageScanIntoAPdf: boolean =
+      parentOption.paperlessGroupMultiPageScanIntoAPdf ||
+      getConfig("paperless_group_multi_page_scan_into_a_pdf") ||
+      false;
+    const alwaysSendAsPdfFile: boolean =
+      parentOption.paperlessAlwaysSendAsPdfFile ||
+      getConfig("paperless_always_send_as_pdf_file") ||
+      false;
+
+    console.log(
+      `Paperless configuration provided, post document url: ${paperlessPostDocumentUrl}, the token length: ${configPaperlessToken.length}, keepFiles: ${configPaperlessKeepFiles}`,
+    );
+    return {
+      postDocumentUrl: paperlessPostDocumentUrl,
+      authToken: configPaperlessToken,
+      keepFiles: configPaperlessKeepFiles,
+      groupMultiPageScanIntoAPdf: groupMultiPageScanIntoAPdf,
+      alwaysSendAsPdfFile: alwaysSendAsPdfFile,
+    };
+  } else {
+    return undefined;
+  }
+}
+
+function getHealthCheckSetting(option: OptionValues) {
+  const healthCheckEnabled: boolean =
+    option.healthCheck || getConfig("enableHealthCheck") === true;
+  let healthCheckPort: number;
+  if (option.healthCheckPort) {
+    healthCheckPort = parseInt(option.healthCheckPort, 10);
+  } else {
+    healthCheckPort = getConfig<number>("healthCheckPort") || 3000;
+  }
+  return {
+    isHealthCheckEnabled: healthCheckEnabled,
+    healthCheckPort: healthCheckPort,
+  };
+}
+
+function getScanConfiguration(option: OptionValues) {
   const directoryConfig: DirectoryConfig = {
-    directory: parentOption.directory || getConfig("directory"),
-    tempDirectory: parentOption.tempDirectory || getConfig("tempDirectory"),
-    filePattern: parentOption.pattern || getConfig("pattern"),
+    directory: option.directory || getConfig("directory"),
+    tempDirectory: option.tempDirectory || getConfig("tempDirectory"),
+    filePattern: option.pattern || getConfig("pattern"),
   };
 
-  const configWidth = (
-    parentOption.width ||
-    getConfig("width") ||
-    0
-  ).toString();
+  const configWidth = (option.width || getConfig("width") || 0).toString();
   const width =
     configWidth.toLowerCase() === "max"
       ? Number.MAX_SAFE_INTEGER
       : parseInt(configWidth, 10);
 
-  const configHeight = (
-    parentOption.width ||
-    getConfig("height") ||
-    "0"
-  ).toString();
+  const configHeight = (option.width || getConfig("height") || "0").toString();
   const height =
     configWidth.toLowerCase() === "max"
       ? Number.MAX_SAFE_INTEGER
       : parseInt(configHeight, 10);
 
+  const paperlessConfig = getPaperlessConfig(option);
+
   const scanConfig: ScanConfig = {
     resolution: parseInt(
-      parentOption.resolution || getConfig("resolution") || "200",
+      option.resolution || getConfig("resolution") || "200",
       10,
     ),
     width: width,
     height: height,
     directoryConfig,
+    paperlessConfig,
   };
   return scanConfig;
 }
@@ -322,6 +401,15 @@ async function main() {
       "-l, --label <label>",
       "The label to display on the device (the default is the hostname)",
     )
+    .addOption(
+      new Option("--health-check", "Start an http health check endpoint"),
+    )
+    .addOption(
+      new Option(
+        "--health-check-port <health-check-port>",
+        "Start an http health check endpoint",
+      ),
+    )
     .action(async (options, cmd) => {
       const parentOption = cmd.parent.opts();
 
@@ -337,6 +425,11 @@ async function main() {
 
       const deviceUpPollingInterval = getDeviceUpPollingInterval(parentOption);
 
+      const healthCheckSetting = getHealthCheckSetting(options);
+      if (healthCheckSetting.isHealthCheckEnabled) {
+        startHealthCheckServer(healthCheckSetting.healthCheckPort);
+      }
+
       const scanConfig = getScanConfiguration(options);
 
       await listenCmd(registrationConfig, scanConfig, deviceUpPollingInterval);
@@ -369,6 +462,15 @@ async function main() {
         "Once document are detected to be in the adf, this specify the wait delay in millisecond before triggering the scan",
       ),
     )
+    .addOption(
+      new Option("--health-check", "Start an http health check endpoint"),
+    )
+    .addOption(
+      new Option(
+        "--health-check-port <port>",
+        "Start an http health check endpoint",
+      ),
+    )
     .description(
       "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)",
     )
@@ -383,6 +485,11 @@ async function main() {
 
       const deviceUpPollingInterval = getDeviceUpPollingInterval(parentOption);
 
+      const healthCheckSetting = getHealthCheckSetting(options);
+      if (healthCheckSetting.isHealthCheckEnabled) {
+        startHealthCheckServer(healthCheckSetting.healthCheckPort);
+      }
+
       const scanConfig = getScanConfiguration(options);
 
       const adfScanConfig: AdfAutoScanConfig = {
@@ -414,4 +521,5 @@ async function main() {
   await program.parseAsync(process.argv);
 }
 
+console.log(`Current commit ID: ${commitInfo.commitId}`);
 main().catch((err) => console.log(err));

package/src/listening.ts

@@ -6,9 +6,9 @@ import { DeviceCapabilities } from "./DeviceCapabilities";
 export async function waitScanRequest(compEventURI: string): Promise<boolean> {
   const waitMax = 50;
   for (let i = 0; i < waitMax; i++) {
-    let walkupScanToCompEvent =
+    const walkupScanToCompEvent =
       await HPApi.getWalkupScanToCompEvent(compEventURI);
-    let message = walkupScanToCompEvent.eventType;
+    const message = walkupScanToCompEvent.eventType;
     if (message === "HostSelected") {
       // this ok to wait
     } else if (message === "ScanRequested") {

package/src/paperless/PaperlessConfig.ts

@@ -0,0 +1,7 @@
+export type PaperlessConfig = {
+  postDocumentUrl: string;
+  authToken: string;
+  keepFiles: boolean;
+  groupMultiPageScanIntoAPdf: boolean;
+  alwaysSendAsPdfFile: boolean;
+};

package/src/paperless/paperless.ts

@@ -0,0 +1,122 @@
+import fsSync from "fs";
+import FormData from "form-data";
+import axios from "axios";
+import { ScanConfig } from "../scanProcessing";
+import { ScanContent } from "../ScanContent";
+import fs from "fs/promises";
+import { convertToPdf, mergeToPdf } from "../pdfProcessing";
+import { PaperlessConfig } from "./PaperlessConfig";
+
+export async function uploadImagesAsSeparateDocumentsToPaperless(
+  scanJobContent: ScanContent,
+  paperlessConfig: PaperlessConfig,
+) {
+  for (let i = 0; i < scanJobContent.elements.length; ++i) {
+    const filePath = scanJobContent.elements[i].path;
+    await uploadToPaperless(filePath, paperlessConfig);
+    if (!paperlessConfig.keepFiles) {
+      await fs.unlink(filePath);
+      console.log(
+        `Image document ${filePath} has been removed from the filesystem`,
+      );
+    }
+  }
+}
+
+export async function convertImagesToPdfAndUploadAsSeparateDocumentsToPaperless(
+  scanJobContent: ScanContent,
+  paperlessConfig: PaperlessConfig,
+) {
+  for (let i = 0; i < scanJobContent.elements.length; ++i) {
+    const pdfFilePath = await convertToPdf(
+      scanJobContent.elements[i],
+      !paperlessConfig.keepFiles,
+    );
+    if (pdfFilePath) {
+      await uploadToPaperless(pdfFilePath, paperlessConfig);
+      await fs.unlink(pdfFilePath);
+    } else {
+      console.log(
+        "Pdf generation has failed, nothing is going to be uploaded to paperless for: " +
+          scanJobContent.elements[i].path,
+      );
+    }
+  }
+}
+
+export async function mergeToPdfAndUploadAsSingleDocumentToPaperless(
+  folder: string,
+  scanCount: number,
+  scanJobContent: ScanContent,
+  scanConfig: ScanConfig,
+  scanDate: Date,
+  paperlessConfig: PaperlessConfig,
+) {
+  const pdfFilePath = await mergeToPdf(
+    folder,
+    scanCount,
+    scanJobContent,
+    scanConfig.directoryConfig.filePattern,
+    scanDate,
+    !paperlessConfig.keepFiles,
+  );
+  if (pdfFilePath) {
+    await uploadToPaperless(pdfFilePath, paperlessConfig);
+    await fs.unlink(pdfFilePath);
+    console.log(
+      `Pdf document ${pdfFilePath} has been removed from the filesystem`,
+    );
+  } else {
+    console.log(
+      "Pdf generation has failed, nothing is going to be uploaded to paperless",
+    );
+  }
+}
+
+export async function uploadPdfToPaperless(
+  pdfFilePath: string | null,
+  paperlessConfig: PaperlessConfig,
+) {
+  if (pdfFilePath) {
+    await uploadToPaperless(pdfFilePath, paperlessConfig);
+    if (!paperlessConfig.keepFiles) {
+      await fs.unlink(pdfFilePath);
+      console.log(
+        `Pdf document ${pdfFilePath} has been removed from the filesystem`,
+      );
+    }
+  } else {
+    console.log(
+      "Pdf generation has failed, nothing is going to be uploaded to paperless",
+    );
+  }
+}
+
+async function uploadToPaperless(
+  filePath: string,
+  paperlessConfig: PaperlessConfig,
+): Promise<void> {
+  const url = paperlessConfig.postDocumentUrl;
+
+  const authToken = paperlessConfig.authToken;
+
+  const fileStream = fsSync.createReadStream(filePath);
+
+  const form = new FormData();
+  form.append("document", fileStream);
+
+  console.log(`Start uploading to paperless: ${filePath}`);
+  try {
+    const response = await axios.post(url, form, {
+      headers: {
+        ...form.getHeaders(),
+        Authorization: `Token ${authToken}`,
+      },
+    });
+
+    console.log("Document successfully uploaded to paperless:", response.data);
+  } catch (error) {
+    console.error("Fail to upload document:", error);
+  }
+  fileStream.close();
+}

package/src/pdfProcessing.ts

@@ -0,0 +1,67 @@
+import { ScanContent, ScanPage } from "./ScanContent";
+import PathHelper from "./PathHelper";
+import fs from "fs/promises";
+import path from "path";
+import { jsPDF } from "jspdf";
+
+export async function mergeToPdf(
+  folder: string,
+  scanCount: number,
+  scanJobContent: ScanContent,
+  filePattern: string | undefined,
+  date: Date,
+  deleteFiles: boolean,
+): Promise<string | null> {
+  if (scanJobContent.elements.length > 0) {
+    const pdfFilePath: string = PathHelper.getFileForScan(
+      folder,
+      scanCount,
+      filePattern,
+      "pdf",
+      date,
+    );
+    await createPdfFrom(scanJobContent, pdfFilePath);
+    if (deleteFiles) {
+      await Promise.all(scanJobContent.elements.map((e) => fs.unlink(e.path)));
+    }
+    return pdfFilePath;
+  }
+  console.log(`No page available to build a pdf file`);
+  return null;
+}
+
+export async function convertToPdf(
+  scanPage: ScanPage,
+  deleteFile: boolean,
+): Promise<string | null> {
+  const fileName = path.basename(scanPage.path, path.extname(scanPage.path));
+  const pdfFilePath = path.join(path.dirname(scanPage.path), `${fileName}.pdf`);
+
+  await createPdfFrom({ elements: [scanPage] }, pdfFilePath);
+  if (deleteFile) {
+    await fs.unlink(scanPage.path);
+  }
+  return pdfFilePath;
+}
+
+export async function createPdfFrom(
+  scanContent: ScanContent,
+  destination: string,
+) {
+  let doc: jsPDF | null = null;
+  for (const element of scanContent.elements) {
+    const widthInInches = element.width / element.xResolution;
+    const heightInInches = element.height / element.yResolution;
+    const format = [widthInInches, heightInInches];
+
+    if (doc == null) {
+      doc = new jsPDF({ unit: "in", floatPrecision: 3, format });
+    } else {
+      doc.addPage(format);
+    }
+
+    const imageByteBuffer = await fs.readFile(element.path);
+    doc.addImage(imageByteBuffer, "JPEG", 0, 0, widthInInches, heightInInches);
+  }
+  doc?.save(destination);
+}

package/src/postProcessing.ts

@@ -0,0 +1,91 @@
+import { ScanContent } from "./ScanContent";
+import { mergeToPdf } from "./pdfProcessing";
+import {
+  convertImagesToPdfAndUploadAsSeparateDocumentsToPaperless,
+  mergeToPdfAndUploadAsSingleDocumentToPaperless,
+  uploadImagesAsSeparateDocumentsToPaperless,
+  uploadPdfToPaperless,
+} from "./paperless/paperless";
+import { ScanConfig } from "./scanProcessing";
+
+export async function postProcessing(
+  scanConfig: ScanConfig,
+  folder: string,
+  tempFolder: string,
+  scanCount: number,
+  scanJobContent: ScanContent,
+  scanDate: Date,
+  toPdf: boolean,
+) {
+  const paperlessConfig = scanConfig.paperlessConfig;
+  if (toPdf) {
+    const pdfFilePath = await mergeToPdf(
+      paperlessConfig ? tempFolder : folder,
+      scanCount,
+      scanJobContent,
+      scanConfig.directoryConfig.filePattern,
+      scanDate,
+      true,
+    );
+    displayPdfScan(pdfFilePath, scanJobContent);
+    if (paperlessConfig) {
+      await uploadPdfToPaperless(pdfFilePath, paperlessConfig);
+    }
+  } else {
+    displayJpegScan(scanJobContent);
+    if (paperlessConfig) {
+      if (paperlessConfig.groupMultiPageScanIntoAPdf) {
+        await mergeToPdfAndUploadAsSingleDocumentToPaperless(
+          folder,
+          scanCount,
+          scanJobContent,
+          scanConfig,
+          scanDate,
+          paperlessConfig,
+        );
+      } else {
+        if (paperlessConfig.alwaysSendAsPdfFile) {
+          await convertImagesToPdfAndUploadAsSeparateDocumentsToPaperless(
+            scanJobContent,
+            paperlessConfig,
+          );
+        } else {
+          await uploadImagesAsSeparateDocumentsToPaperless(
+            scanJobContent,
+            paperlessConfig,
+          );
+        }
+      }
+    }
+  }
+}
+
+function displayPdfScan(
+  pdfFilePath: string | null,
+  scanJobContent: ScanContent,
+) {
+  if (pdfFilePath === null) {
+    console.log(`Pdf generated has not been generated`);
+    return;
+  }
+  console.log(
+    `The following page(s) have been rendered inside '${pdfFilePath}': `,
+  );
+  scanJobContent.elements.forEach((e) =>
+    console.log(
+      `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
+        e.height
+      }`,
+    ),
+  );
+}
+
+function displayJpegScan(scanJobContent: ScanContent) {
+  scanJobContent.elements.forEach((e) =>
+    console.log(
+      `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
+        e.height
+      } - ${e.path}`,
+    ),
+  );
+}