node-hp-scan-to 1.4.3 → 1.5.0

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}`,
+    ),
+  );
+}

package/src/scanProcessing.ts

@@ -7,12 +7,14 @@ import JpegUtil from "./JpegUtil";
 import { DeviceCapabilities } from "./DeviceCapabilities";
 import { waitForScanEvent, waitScanRequest } from "./listening";
 import ScanJobSettings from "./ScanJobSettings";
-import { createPdfFrom, ScanContent, ScanPage } from "./ScanContent";
+import { ScanContent, ScanPage } from "./ScanContent";
 import Job from "./Job";
 import { delay } from "./delay";
 import PathHelper from "./PathHelper";
 import ScanStatus from "./ScanStatus";
 import { InputSource } from "./InputSource";
+import { PaperlessConfig } from "./paperless/PaperlessConfig";
+import { postProcessing } from "./postProcessing";
 
 async function waitDeviceUntilItIsReadyToUploadOrCompleted(
   jobUrl: string,
@@ -38,7 +40,7 @@ async function waitDeviceUntilItIsReadyToUploadOrCompleted(
   return job;
 }
 
-async function TryGetDestination(
+async function tryGetDestination(
   event: Event,
 ): Promise<WalkupScanDestination | WalkupScanToCompDestination | null> {
   //this code can in some cases be executed before the user actually chooses between Document or Photo
@@ -71,7 +73,7 @@ async function TryGetDestination(
 async function scanProcessing(filePath: string): Promise<number | null> {
   const buffer: Buffer = await fs.readFile(filePath);
 
-  let height = JpegUtil.fixSizeWithDNL(buffer);
+  const height = JpegUtil.fixSizeWithDNL(buffer);
   if (height != null) {
     // rewrite the fixed file
     await fs.writeFile(filePath, buffer);
@@ -86,7 +88,7 @@ function createScanPage(
   filePath: string,
   sizeFixed: number | null,
 ): ScanPage {
-  let height = sizeFixed ?? job.imageHeight;
+  const height = sizeFixed ?? job.imageHeight;
   return {
     path: filePath,
     pageNumber: currentPageNumber,
@@ -97,7 +99,7 @@ function createScanPage(
   };
 }
 
-async function handleProcessingState(
+async function handleScanProcessingState(
   job: Job,
   inputSource: InputSource,
   folder: string,
@@ -168,7 +170,7 @@ async function executeScanJob(
     }
 
     if (job.jobState === "Processing") {
-      const page = await handleProcessingState(
+      const page = await handleScanProcessingState(
         job,
         inputSource,
         folder,
@@ -201,9 +203,9 @@ async function waitScanNewPageRequest(compEventURI: string): Promise<boolean> {
   while (wait) {
     await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
 
-    let walkupScanToCompEvent =
+    const walkupScanToCompEvent =
       await HPApi.getWalkupScanToCompEvent(compEventURI);
-    let message = walkupScanToCompEvent.eventType;
+    const message = walkupScanToCompEvent.eventType;
 
     if (message === "ScanNewPageRequested") {
       startNewScanJob = true;
@@ -281,59 +283,6 @@ async function executeScanJobs(
   }
 }
 
-async function mergeToPdf(
-  folder: string,
-  scanCount: number,
-  scanJobContent: ScanContent,
-  filePattern: string | undefined,
-  date: Date,
-): Promise<string | null> {
-  if (scanJobContent.elements.length > 0) {
-    const pdfFilePath: string = PathHelper.getFileForScan(
-      folder,
-      scanCount,
-      filePattern,
-      "pdf",
-      date,
-    );
-    await createPdfFrom(scanJobContent, pdfFilePath);
-    scanJobContent.elements.forEach((e) => fs.unlink(e.path));
-    return pdfFilePath;
-  }
-  console.log(`No page available to build a pdf file`);
-  return null;
-}
-
-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}`,
-    ),
-  );
-}
-
 function isPdf(
   destination: WalkupScanDestination | WalkupScanToCompDestination,
 ) {
@@ -360,7 +309,7 @@ export function getScanWidth(
   scanConfig: ScanConfig,
   inputSource: InputSource,
   deviceCapabilities: DeviceCapabilities,
-) {
+): number | null {
   if (scanConfig.width && scanConfig.width > 0) {
     const maxWidth =
       inputSource === InputSource.Adf
@@ -373,7 +322,9 @@ export function getScanWidth(
       return scanConfig.width;
     }
   } else {
-    return null;
+    return inputSource === InputSource.Adf
+      ? deviceCapabilities.adfMaxWidth
+      : deviceCapabilities.platenMaxWidth;
   }
 }
 
@@ -381,7 +332,7 @@ export function getScanHeight(
   scanConfig: ScanConfig,
   inputSource: InputSource,
   deviceCapabilities: DeviceCapabilities,
-) {
+): number | null {
   if (scanConfig.height && scanConfig.height > 0) {
     const maxHeight =
       inputSource === InputSource.Adf
@@ -394,11 +345,13 @@ export function getScanHeight(
       return scanConfig.height;
     }
   } else {
-    return null;
+    return inputSource === InputSource.Adf
+      ? deviceCapabilities.adfMaxHeight
+      : deviceCapabilities.platenMaxHeight;
   }
 }
 
-export async function saveScan(
+export async function saveScanFromEvent(
   event: Event,
   folder: string,
   tempFolder: string,
@@ -413,7 +366,7 @@ export async function saveScan(
     }
   }
 
-  const destination = await TryGetDestination(event);
+  const destination = await tryGetDestination(event);
   if (!destination) {
     console.log("No shortcut selected!");
     return;
@@ -443,7 +396,7 @@ export async function saveScan(
   const scanStatus = await HPApi.getScanStatus();
 
   if (scanStatus.scannerState !== "Idle") {
-    console.log("Scanner state is not Idle, aborting scan attempt...!")
+    console.log("Scanner state is not Idle, aborting scan attempt...!");
   }
 
   console.log("Afd is : " + scanStatus.adfState);
@@ -479,19 +432,15 @@ export async function saveScan(
   console.log(
     `Scan of page(s) completed totalPages: ${scanJobContent.elements.length}:`,
   );
-
-  if (toPdf) {
-    const pdfFilePath = await mergeToPdf(
-      folder,
-      scanCount,
-      scanJobContent,
-      scanConfig.directoryConfig.filePattern,
-      scanDate,
-    );
-    displayPdfScan(pdfFilePath, scanJobContent);
-  } else {
-    displayJpegScan(scanJobContent);
-  }
+  await postProcessing(
+    scanConfig,
+    folder,
+    tempFolder,
+    scanCount,
+    scanJobContent,
+    scanDate,
+    toPdf,
+  );
 }
 
 export type DirectoryConfig = {
@@ -499,11 +448,13 @@ export type DirectoryConfig = {
   tempDirectory: string | undefined;
   filePattern: string | undefined;
 };
+
 export type ScanConfig = {
   resolution: number;
   width: number | null;
   height: number | null;
   directoryConfig: DirectoryConfig;
+  paperlessConfig: PaperlessConfig | undefined;
 };
 export type AdfAutoScanConfig = ScanConfig & {
   isDuplex: boolean;
@@ -512,6 +463,11 @@ export type AdfAutoScanConfig = ScanConfig & {
   startScanDelay: number;
 };
 
+export type SingleScanConfig = ScanConfig & {
+  isDuplex: boolean;
+  generatePdf: boolean;
+};
+
 export async function scanFromAdf(
   scanCount: number,
   folder: string,
@@ -568,18 +524,15 @@ export async function scanFromAdf(
     `Scan of page(s) completed, total pages: ${scanJobContent.elements.length}:`,
   );
 
-  if (adfAutoScanConfig.generatePdf) {
-    const pdfFilePath = await mergeToPdf(
-      folder,
-      scanCount,
-      scanJobContent,
-      adfAutoScanConfig.directoryConfig.filePattern,
-      date,
-    );
-    displayPdfScan(pdfFilePath, scanJobContent);
-  } else {
-    displayJpegScan(scanJobContent);
-  }
+  await postProcessing(
+    adfAutoScanConfig,
+    folder,
+    tempFolder,
+    scanCount,
+    scanJobContent,
+    date,
+    adfAutoScanConfig.generatePdf,
+  );
 }
 
 export async function waitAdfLoaded(