node-hp-scan-to 1.5.1 → 1.6.0

package/src/nextcloud/nextcloud.ts

@@ -0,0 +1,146 @@
+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/paperless.ts

@@ -14,12 +14,6 @@ export async function uploadImagesAsSeparateDocumentsToPaperless(
   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`,
-      );
-    }
   }
 }
 
@@ -79,12 +73,6 @@ export async function uploadPdfToPaperless(
 ) {
   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",

package/src/postProcessing.ts

@@ -6,7 +6,14 @@ import {
   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,
@@ -17,47 +24,95 @@ export async function postProcessing(
   scanDate: Date,
   toPdf: boolean,
 ) {
-  const paperlessConfig = scanConfig.paperlessConfig;
   if (toPdf) {
-    const pdfFilePath = await mergeToPdf(
-      paperlessConfig ? tempFolder : folder,
+    await handlePdfProcessing(
+      folder,
+      tempFolder,
       scanCount,
       scanJobContent,
-      scanConfig.directoryConfig.filePattern,
       scanDate,
-      true,
+      scanConfig,
     );
-    displayPdfScan(pdfFilePath, scanJobContent);
-    if (paperlessConfig) {
-      await uploadPdfToPaperless(pdfFilePath, paperlessConfig);
-    }
   } else {
-    displayJpegScan(scanJobContent);
-    if (paperlessConfig) {
-      if (paperlessConfig.groupMultiPageScanIntoAPdf) {
-        await mergeToPdfAndUploadAsSingleDocumentToPaperless(
-          folder,
-          scanCount,
+    await handleImageProcessing(
+      folder,
+      scanCount,
+      scanJobContent,
+      scanDate,
+      scanConfig,
+    );
+  }
+}
+
+async function handlePdfProcessing(
+  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,
+  );
+  displayPdfScan(pdfFilePath, scanJobContent);
+  if (paperlessConfig) {
+    await uploadPdfToPaperless(pdfFilePath, paperlessConfig);
+  }
+  if (nextcloudConfig) {
+    await uploadPdfToNextcloud(pdfFilePath, nextcloudConfig);
+  }
+  await cleanUpFilesIfNeeded([pdfFilePath], paperlessConfig, nextcloudConfig);
+}
+
+async function handleImageProcessing(
+  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,
-          scanConfig,
-          scanDate,
           paperlessConfig,
         );
       } else {
-        if (paperlessConfig.alwaysSendAsPdfFile) {
-          await convertImagesToPdfAndUploadAsSeparateDocumentsToPaperless(
-            scanJobContent,
-            paperlessConfig,
-          );
-        } else {
-          await uploadImagesAsSeparateDocumentsToPaperless(
-            scanJobContent,
-            paperlessConfig,
-          );
-        }
+        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(
@@ -89,3 +144,20 @@ function displayJpegScan(scanJobContent: ScanContent) {
     ),
   );
 }
+
+async function cleanUpFilesIfNeeded(
+  filePaths: (string | null)[],
+  paperlessConfig: PaperlessConfig | undefined,
+  nextcloudConfig: NextcloudConfig | undefined,
+) {
+  if (!paperlessConfig?.keepFiles && !nextcloudConfig?.keepFiles) {
+    await Promise.all(
+      filePaths.map(async (filePath) => {
+        if (filePath) {
+          await fs.unlink(filePath);
+          console.log(`File ${filePath} has been removed from the filesystem`);
+        }
+      }),
+    );
+  }
+}

package/src/scanProcessing.ts

@@ -14,6 +14,7 @@ import PathHelper from "./PathHelper";
 import ScanStatus from "./ScanStatus";
 import { InputSource } from "./InputSource";
 import { PaperlessConfig } from "./paperless/PaperlessConfig";
+import { NextcloudConfig } from "./nextcloud/NextcloudConfig";
 import { postProcessing } from "./postProcessing";
 
 async function waitDeviceUntilItIsReadyToUploadOrCompleted(
@@ -455,6 +456,7 @@ export type ScanConfig = {
   height: number | null;
   directoryConfig: DirectoryConfig;
   paperlessConfig: PaperlessConfig | undefined;
+  nextcloudConfig: NextcloudConfig | undefined;
 };
 export type AdfAutoScanConfig = ScanConfig & {
   isDuplex: boolean;