node-hp-scan-to 1.6.1 → 1.7.1

package/src/listening.ts

@@ -1,144 +0,0 @@
-import HPApi from "./HPApi";
-import Event from "./Event";
-import Destination from "./Destination";
-import { DeviceCapabilities } from "./DeviceCapabilities";
-
-export async function waitScanRequest(compEventURI: string): Promise<boolean> {
-  const waitMax = 50;
-  for (let i = 0; i < waitMax; i++) {
-    const walkupScanToCompEvent =
-      await HPApi.getWalkupScanToCompEvent(compEventURI);
-    const message = walkupScanToCompEvent.eventType;
-    if (message === "HostSelected") {
-      // this ok to wait
-    } else if (message === "ScanRequested") {
-      break;
-    } else if (message === "ScanNewPageRequested") {
-      break;
-    } else if (message === "ScanPagesComplete") {
-      console.log("no more page to scan, scan is finished");
-      return false;
-    } else {
-      console.log(`Unknown eventType: ${message}`);
-      return false;
-    }
-
-    console.log(`Waiting user input: ${i + 1}/${waitMax}`);
-    await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
-  }
-  return true;
-}
-
-export async function waitForScanEvent(
-  resourceURI: string,
-  afterEtag: string | null = null,
-): Promise<Event> {
-  console.log("Start listening for new ScanEvent");
-
-  let eventTable = await HPApi.getEvents(afterEtag ?? "");
-  let acceptedScanEvent = null;
-  let currentEtag = eventTable.etag;
-  while (acceptedScanEvent == null) {
-    eventTable = await HPApi.getEvents(currentEtag, 1200);
-    currentEtag = eventTable.etag;
-
-    acceptedScanEvent = eventTable.eventTable.events.find(
-      (ev) =>
-        ev.isScanEvent &&
-        ev.destinationURI &&
-        ev.destinationURI.indexOf(resourceURI) >= 0,
-    );
-  }
-  return acceptedScanEvent;
-}
-
-async function registerWalkupScanToCompDestination(
-  registrationConfig: RegistrationConfig,
-): Promise<string> {
-  const walkupScanDestinations = await HPApi.getWalkupScanToCompDestinations();
-  const destinations = walkupScanDestinations.destinations;
-
-  console.log(
-    "Host destinations fetched:",
-    destinations.map((d) => d.name).join(", "),
-  );
-
-  const hostname = registrationConfig.label;
-  const destination = destinations.find((x) => x.name === hostname);
-
-  let resourceURI;
-  if (destination) {
-    console.log(
-      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`,
-    );
-    resourceURI = destination.resourceURI;
-  } else {
-    resourceURI = await HPApi.registerWalkupScanToCompDestination(
-      new Destination(hostname, hostname, true),
-    );
-    console.log(`New Destination registered: ${hostname} - ${resourceURI}`);
-  }
-
-  console.log(`Using: ${hostname}`);
-
-  return resourceURI;
-}
-
-async function registerWalkupScanDestination(
-  registrationConfig: RegistrationConfig,
-): Promise<string> {
-  const walkupScanDestinations = await HPApi.getWalkupScanDestinations();
-  const destinations = walkupScanDestinations.destinations;
-
-  console.log(
-    "Host destinations fetched:",
-    destinations.map((d) => d.name).join(", "),
-  );
-
-  const hostname = registrationConfig.label;
-  const destination = destinations.find((x) => x.name === hostname);
-
-  let resourceURI;
-  if (destination) {
-    console.log(
-      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`,
-    );
-    resourceURI = destination.resourceURI;
-  } else {
-    resourceURI = await HPApi.registerWalkupScanDestination(
-      new Destination(hostname, hostname, false),
-    );
-    console.log(`New Destination registered: ${hostname} - ${resourceURI}`);
-  }
-
-  console.log(`Using: ${hostname}`);
-
-  return resourceURI;
-}
-
-export type RegistrationConfig = {
-  label: string;
-};
-
-export async function waitScanEvent(
-  deviceCapabilities: DeviceCapabilities,
-  registrationConfig: RegistrationConfig,
-): Promise<Event> {
-  let resourceURI: string;
-  if (deviceCapabilities.useWalkupScanToComp) {
-    resourceURI = await registerWalkupScanToCompDestination(registrationConfig);
-  } else {
-    resourceURI = await registerWalkupScanDestination(registrationConfig);
-  }
-
-  console.log("Waiting scan event for:", resourceURI);
-  return await waitForScanEvent(resourceURI);
-}
-
-export async function clearRegistrations() {
-  const dests = await HPApi.getWalkupScanToCompDestinations();
-  for (let i = 0; i < dests.destinations.length; i++) {
-    console.log(`Removing: ${dests.destinations[i].name}`);
-    await HPApi.removeDestination(dests.destinations[i]);
-  }
-}

package/src/nextcloud/NextcloudConfig.ts

@@ -1,7 +0,0 @@
-export type NextcloudConfig = {
-  baseUrl: string;
-  username: string;
-  password: string;
-  uploadFolder: string;
-  keepFiles: boolean;
-};

package/src/nextcloud/nextcloud.ts

@@ -1,146 +0,0 @@
-import axios, { AxiosError } from "axios";
-import { ScanContent } from "../ScanContent";
-import { NextcloudConfig } from "./NextcloudConfig";
-import fs from "fs/promises";
-import path from "path";
-
-export async function uploadImagesToNextcloud(
-  scanJobContent: ScanContent,
-  nextcloudConfig: NextcloudConfig,
-) {
-  await checkFolderAndUpload(nextcloudConfig, async () => {
-    for (const element of scanJobContent.elements) {
-      const { path: filePath } = element;
-      await uploadToNextcloud(filePath, nextcloudConfig);
-    }
-  });
-}
-
-export async function uploadPdfToNextcloud(
-  pdfFilePath: string | null,
-  nextcloudConfig: NextcloudConfig,
-) {
-  await checkFolderAndUpload(nextcloudConfig, async () => {
-    if (pdfFilePath) {
-      await uploadToNextcloud(pdfFilePath, nextcloudConfig);
-    } else {
-      console.log(
-        "Pdf generation has failed, nothing is going to be uploaded to Nextcloud",
-      );
-    }
-  });
-}
-
-async function uploadToNextcloud(
-  filePath: string,
-  nextcloudConfig: NextcloudConfig,
-): Promise<void> {
-  const { baseUrl, username, password, uploadFolder } = nextcloudConfig;
-  const fileName = path.basename(filePath);
-
-  const folderUrl = buildFolderUrl(baseUrl, username, uploadFolder);
-  const uploadUrl = buildUrl(folderUrl, [fileName]);
-
-  let fileBuffer: Buffer;
-  try {
-    fileBuffer = await fs.readFile(filePath);
-  } catch (e) {
-    console.error("Fail to read file:", e);
-    return;
-  }
-  const auth = { username, password };
-
-  console.log(`Start uploading to Nextcloud: ${fileName}`);
-  try {
-    const response = await axios({
-      method: "PUT",
-      url: uploadUrl,
-      auth,
-      data: fileBuffer,
-    });
-
-    let action: string;
-    if (response.status === 201) {
-      action = "created";
-    } else {
-      action = "updated";
-    }
-    console.log(
-      `Document successfully ${action} file at Nextcloud. (Folder: ${uploadFolder}, File: ${fileName})`,
-    );
-  } catch (error) {
-    console.error("Fail to upload document:", error);
-  }
-}
-
-async function checkFolderAndUpload(
-  nextcloudConfig: NextcloudConfig,
-  uploadFunction: () => Promise<void>,
-) {
-  const folderExists = await checkNextcloudFolderExists(nextcloudConfig);
-  if (!folderExists) {
-    console.log(
-      "Upload folder does not exist or user has no permission; skipping upload",
-    );
-    return;
-  }
-
-  await uploadFunction();
-}
-
-async function checkNextcloudFolderExists(
-  nextcloudConfig: NextcloudConfig,
-): Promise<boolean> {
-  const { baseUrl, username, password, uploadFolder } = nextcloudConfig;
-  const folderUrl = buildFolderUrl(baseUrl, username, uploadFolder);
-  const auth = { username, password };
-
-  console.log("Check if upload folder exists");
-  try {
-    // Check if the upload folder exists
-    await axios({
-      method: "PROPFIND",
-      url: folderUrl,
-      auth,
-      headers: { Depth: 0 },
-    });
-    console.log(`Found upload folder '${uploadFolder}' in Nextcloud`);
-  } catch (error) {
-    const axiosError = error as AxiosError;
-    if (axiosError.response?.status === 404) {
-      console.warn(`Upload folder '${uploadFolder}' not found in Nextcloud`);
-    } else if (axiosError.response?.status === 401) {
-      console.warn(
-        `User has no permission to access upload folder '${uploadFolder}' in Nextcloud`,
-      );
-    } else {
-      console.error("Fail to check upload folder exists:", axiosError.toJSON());
-    }
-    console.trace("Error response:", axiosError.response);
-    return false;
-  }
-  return true;
-}
-
-function buildFolderUrl(
-  baseUrl: string,
-  username: string,
-  uploadFolder: string,
-) {
-  return buildUrl(baseUrl, [
-    "remote.php",
-    "dav",
-    "files",
-    username,
-    uploadFolder,
-  ]);
-}
-
-function buildUrl(baseUrl: string, path: string[]): string {
-  const url = new URL(baseUrl);
-  const search = /^\/+|\/+$/g;
-  path.forEach((part) => {
-    url.pathname = `${url.pathname.replace(search, "")}/${encodeURIComponent(part.replace(search, ""))}`;
-  });
-  return url.toString();
-}

package/src/paperless/PaperlessConfig.ts

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

package/src/paperless/paperless.ts

@@ -1,110 +0,0 @@
-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);
-  }
-}
-
-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);
-  } 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

@@ -1,67 +0,0 @@
-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

@@ -1,165 +0,0 @@
-import { ScanContent } from "./ScanContent";
-import { mergeToPdf } from "./pdfProcessing";
-import {
-  convertImagesToPdfAndUploadAsSeparateDocumentsToPaperless,
-  mergeToPdfAndUploadAsSingleDocumentToPaperless,
-  uploadImagesAsSeparateDocumentsToPaperless,
-  uploadPdfToPaperless,
-} from "./paperless/paperless";
-import {
-  uploadPdfToNextcloud,
-  uploadImagesToNextcloud,
-} from "./nextcloud/nextcloud";
-import { ScanConfig } from "./scanProcessing";
-import fs from "fs/promises";
-import { PaperlessConfig } from "./paperless/PaperlessConfig";
-import { NextcloudConfig } from "./nextcloud/NextcloudConfig";
-
-export async function postProcessing(
-  scanConfig: ScanConfig,
-  folder: string,
-  tempFolder: string,
-  scanCount: number,
-  scanJobContent: ScanContent,
-  scanDate: Date,
-  toPdf: boolean,
-) {
-  if (toPdf) {
-    await handlePdfPostProcessing(
-      folder,
-      tempFolder,
-      scanCount,
-      scanJobContent,
-      scanDate,
-      scanConfig,
-    );
-  } else {
-    await handleImagePostProcessing(
-      folder,
-      scanCount,
-      scanJobContent,
-      scanDate,
-      scanConfig,
-    );
-  }
-}
-
-async function handlePdfPostProcessing(
-  folder: string,
-  tempFolder: string,
-  scanCount: number,
-  scanJobContent: ScanContent,
-  scanDate: Date,
-  scanConfig: ScanConfig,
-) {
-  const paperlessConfig = scanConfig.paperlessConfig;
-  const nextcloudConfig = scanConfig.nextcloudConfig;
-
-  const pdfFilePath = await mergeToPdf(
-    paperlessConfig ? tempFolder : folder,
-    scanCount,
-    scanJobContent,
-    scanConfig.directoryConfig.filePattern,
-    scanDate,
-    true,
-  );
-  if (pdfFilePath != null) {
-    displayPdfScan(pdfFilePath, scanJobContent);
-    if (paperlessConfig) {
-      await uploadPdfToPaperless(pdfFilePath, paperlessConfig);
-    }
-    if (nextcloudConfig) {
-      await uploadPdfToNextcloud(pdfFilePath, nextcloudConfig);
-    }
-    await cleanUpFilesIfNeeded([pdfFilePath], paperlessConfig, nextcloudConfig);
-  }
-}
-
-async function handleImagePostProcessing(
-  folder: string,
-  scanCount: number,
-  scanJobContent: ScanContent,
-  scanDate: Date,
-  scanConfig: ScanConfig,
-) {
-  const paperlessConfig = scanConfig.paperlessConfig;
-  const nextcloudConfig = scanConfig.nextcloudConfig;
-
-  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,
-        );
-      }
-    }
-  }
-  if (nextcloudConfig) {
-    await uploadImagesToNextcloud(scanJobContent, nextcloudConfig);
-  }
-  const filePaths = scanJobContent.elements.map((element) => element.path);
-  await cleanUpFilesIfNeeded(filePaths, paperlessConfig, nextcloudConfig);
-}
-
-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}`,
-    ),
-  );
-}
-
-async function cleanUpFilesIfNeeded(
-  filePaths: string[],
-  paperlessConfig: PaperlessConfig | undefined,
-  nextcloudConfig: NextcloudConfig | undefined,
-) {
-  let keepFiles: boolean =
-    paperlessConfig?.keepFiles ?? nextcloudConfig?.keepFiles ?? true;
-  if (!keepFiles) {
-    await Promise.all(
-      filePaths.map(async (filePath) => {
-        await fs.unlink(filePath);
-        console.log(`File ${filePath} has been removed from the filesystem`);
-      }),
-    );
-  }
-}

package/src/readDeviceCapabilities.ts

@@ -1,52 +0,0 @@
-import { DeviceCapabilities } from "./DeviceCapabilities";
-import HPApi from "./HPApi";
-import WalkupScanToCompCaps from "./WalkupScanToCompCaps";
-import ScanCaps from "./ScanCaps";
-
-export async function readDeviceCapabilities(): Promise<DeviceCapabilities> {
-  let supportsMultiItemScanFromPlaten = true;
-  const discoveryTree = await HPApi.getDiscoveryTree();
-  let walkupScanToCompCaps: WalkupScanToCompCaps | null = null;
-  if (discoveryTree.WalkupScanToCompManifestURI != null) {
-    const walkupScanToCompManifest = await HPApi.getWalkupScanToCompManifest(
-      discoveryTree.WalkupScanToCompManifestURI,
-    );
-    if (walkupScanToCompManifest.WalkupScanToCompCapsURI != null) {
-      walkupScanToCompCaps = await HPApi.getWalkupScanToCompCaps(
-        walkupScanToCompManifest.WalkupScanToCompCapsURI,
-      );
-      supportsMultiItemScanFromPlaten =
-        walkupScanToCompCaps.supportsMultiItemScanFromPlaten;
-    }
-  } else if (discoveryTree.WalkupScanManifestURI != null) {
-    const walkupScanManifest = await HPApi.getWalkupScanManifest(
-      discoveryTree.WalkupScanManifestURI,
-    );
-    if (walkupScanManifest.walkupScanDestinationsURI != null) {
-      await HPApi.getWalkupScanDestinations(
-        walkupScanManifest.walkupScanDestinationsURI,
-      );
-    }
-  } else {
-    console.log("Unknown device!");
-  }
-
-  let scanCaps: ScanCaps | null = null;
-  if (discoveryTree.ScanJobManifestURI != null) {
-    const scanJobManifest = await HPApi.getScanJobManifest(
-      discoveryTree.ScanJobManifestURI,
-    );
-    if (scanJobManifest.ScanCapsURI != null) {
-      scanCaps = await HPApi.getScanCaps(scanJobManifest.ScanCapsURI);
-    }
-  }
-
-  return {
-    supportsMultiItemScanFromPlaten,
-    useWalkupScanToComp: walkupScanToCompCaps != null,
-    platenMaxWidth: scanCaps?.platenMaxWidth || null,
-    platenMaxHeight: scanCaps?.platenMaxHeight || null,
-    adfMaxWidth: scanCaps?.adfMaxWidth || null,
-    adfMaxHeight: scanCaps?.adfMaxHeight || null,
-  };
-}