node-hp-scan-to 1.2.2 → 1.3.1

package/src/HPApi.ts

@@ -1,54 +1,53 @@
 "use strict";
 
-import WalkupScanDestination, {
-  WalkupScanDestinationData,
-} from "./WalkupScanDestination";
-import WalkupScanToCompDestination, {
-  WalkupScanToCompDestinationData,
-} from "./WalkupScanToCompDestination";
 import { promisify } from "util";
 import fs from "fs";
 import axios, {
   AxiosError,
   AxiosRequestConfig,
-  AxiosRequestHeaders,
   AxiosResponse,
+  RawAxiosRequestHeaders,
 } from "axios";
 import { URL } from "url";
-import { Parser } from "xml2js";
-import * as stream from 'stream/promises';
-import EventTable, { EventTableData } from "./EventTable";
-import Job, { JobData } from "./Job";
-import ScanStatus, { ScanStatusData } from "./ScanStatus";
-import WalkupScanDestinations, {
-  WalkupScanDestinationsData,
-} from "./WalkupScanDestinations";
-import WalkupScanToCompDestinations, {
-  WalkupScanToCompDestinationsData,
-} from "./WalkupScanToCompDestinations";
+import * as stream from "stream";
+import { Stream } from "stream";
+import EventTable, { EtagEventTable } from "./EventTable";
+import Job from "./Job";
+import ScanStatus from "./ScanStatus";
+import WalkupScanDestination from "./WalkupScanDestination";
+import WalkupScanToCompDestination from "./WalkupScanToCompDestination";
+import WalkupScanDestinations from "./WalkupScanDestinations";
+import WalkupScanToCompDestinations from "./WalkupScanToCompDestinations";
 import ScanJobSettings from "./ScanJobSettings";
 import Destination from "./Destination";
-import { Stream } from "stream";
-import WalkupScanToCompEvent, {
-  WalkupScanToCompEventData,
-} from "./WalkupScanToCompEvent";
+import WalkupScanToCompEvent from "./WalkupScanToCompEvent";
+import DiscoveryTree from "./DiscoveryTree";
+import WalkupScanToCompManifest from "./WalkupScanToCompManifest";
+import WalkupScanToCompCaps from "./WalkupScanToCompCaps";
+import WalkupScanManifest from "./WalkupScanManifest";
+import ScanJobManifest from "./ScanJobManifest";
+import ScanCaps from "./ScanCaps";
+import { delay } from "./delay";
+import * as net from "net";
 
-const parser = new Parser();
-const parseString = promisify<string, any>(parser.parseString);
 let printerIP = "192.168.1.11";
 let debug = false;
 let callCount = 0;
 
 export default class HPApi {
-  static setPrinterIP(ip: string) {
+  static setDeviceIP(ip: string): void {
     printerIP = ip;
   }
 
-  static setDebug(dbg: boolean) {
+  static setDebug(dbg: boolean): void {
     debug = dbg;
   }
 
-  private static logDebug(callId: number, isRequest: boolean, msg: any) {
+  private static logDebug(
+    callId: number,
+    isRequest: boolean,
+    msg: object | string
+  ): void {
     if (debug) {
       const id = String(callId).padStart(4, "0");
       const content = typeof msg === "string" ? msg : JSON.stringify(msg);
@@ -56,11 +55,16 @@ export default class HPApi {
     }
   }
 
-  private static async callAxios(request: AxiosRequestConfig) {
+  private static async callAxios(
+    request: AxiosRequestConfig
+  ): Promise<AxiosResponse<string>> {
     callCount++;
+    if (request.timeout === 0) {
+      request.timeout = 100_000;
+    }
     HPApi.logDebug(callCount, true, request);
     try {
-      const response = (await axios(request)) as AxiosResponse<string>;
+      const response = await axios(request);
       HPApi.logDebug(callCount, false, {
         status: response.status,
         data: response.data,
@@ -83,10 +87,47 @@ export default class HPApi {
     }
   }
 
-  static async getWalkupScanDestinations(): Promise<WalkupScanDestinations> {
+  static async isAlive(timeout: number | null = null): Promise<boolean> {
+    const definedTimeout = timeout || 10000; // default of 10 seconds
+    return new Promise((resolve) => {
+      const socket = net.createConnection(80, printerIP, () => {
+        clearTimeout(timer);
+        resolve(true);
+        socket.end();
+      });
+      const timer = setTimeout(() => {
+        resolve(false);
+        socket.end();
+      }, definedTimeout);
+      socket.on("error", () => {
+        clearTimeout(timer);
+        resolve(false);
+      });
+    });
+  }
+
+  static async waitDeviceUp(deviceUpPollingInterval: number): Promise<void> {
+    let first = true;
+    while (!(await HPApi.isAlive())) {
+      if (first) {
+        console.log(
+          `Device ip: ${printerIP} is down! [${new Date().toISOString()}]`
+        );
+      }
+      first = false;
+      await delay(deviceUpPollingInterval);
+    }
+    if (!first) {
+      console.log(
+        `Device ip: ${printerIP} is up again! [${new Date().toISOString()}]`
+      );
+    }
+  }
+
+  static async getDiscoveryTree(): Promise<DiscoveryTree> {
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
-      url: "/WalkupScan/WalkupScanDestinations",
+      url: "/DevMgmt/DiscoveryTree.xml",
       method: "GET",
       responseType: "text",
     });
@@ -94,10 +135,24 @@ export default class HPApi {
     if (response.status !== 200) {
       throw new Error(response.statusText);
     } else {
-      const parsed = (await parseString(
-        response.data
-      )) as WalkupScanDestinationsData;
-      return new WalkupScanDestinations(parsed);
+      return DiscoveryTree.createDiscoveryTree(response.data);
+    }
+  }
+
+  static async getWalkupScanDestinations(
+    uri: string = "/WalkupScan/WalkupScanDestinations"
+  ): Promise<WalkupScanDestinations> {
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: uri,
+      method: "GET",
+      responseType: "text",
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return WalkupScanDestinations.createWalkupScanDestinations(response.data);
     }
   }
 
@@ -112,26 +167,95 @@ export default class HPApi {
     if (response.status !== 200) {
       throw new Error(response.statusText);
     } else {
-      const parsed = (await parseString(
+      return WalkupScanToCompDestinations.createWalkupScanToCompDestinations(
         response.data
-      )) as WalkupScanToCompDestinationsData;
-      return new WalkupScanToCompDestinations(parsed);
+      );
     }
   }
 
-  static async getWalkupScanToCompCaps(): Promise<boolean> {
-    return HPApi.callAxios({
+  static async getWalkupScanManifest(uri: string): Promise<WalkupScanManifest> {
+    const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
-      url: "/WalkupScanToComp/WalkupScanToCompCaps",
+      url: uri,
       method: "GET",
       responseType: "text",
-    }).then(
-      (response) => response.status == 200,
-      () => false
-    );
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return WalkupScanManifest.createWalkupScanManifest(response.data);
+    }
+  }
+  static async getWalkupScanToCompManifest(
+    uri: string
+  ): Promise<WalkupScanToCompManifest> {
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: uri,
+      method: "GET",
+      responseType: "text",
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return WalkupScanToCompManifest.createWalkupScanToCompManifest(
+        response.data
+      );
+    }
   }
 
-  static async getWalkupScanToCompEvent(compEventURI: string): Promise<WalkupScanToCompEvent> {
+  static async getScanJobManifest(uri: string): Promise<ScanJobManifest> {
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: uri,
+      method: "GET",
+      responseType: "text",
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return ScanJobManifest.createScanJobManifest(response.data);
+    }
+  }
+
+  static async getScanCaps(uri: string): Promise<ScanCaps> {
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: uri,
+      method: "GET",
+      responseType: "text",
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return ScanCaps.createScanCaps(response.data);
+    }
+  }
+
+  static async getWalkupScanToCompCaps(
+    uri: string
+  ): Promise<WalkupScanToCompCaps> {
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: uri,
+      method: "GET",
+      responseType: "text",
+    });
+
+    if (response.status !== 200) {
+      throw new Error(response.statusText);
+    } else {
+      return WalkupScanToCompCaps.createWalkupScanToCompCaps(response.data);
+    }
+  }
+
+  static async getWalkupScanToCompEvent(
+    compEventURI: string
+  ): Promise<WalkupScanToCompEvent> {
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
       url: compEventURI,
@@ -142,38 +266,65 @@ export default class HPApi {
     if (response.status !== 200) {
       throw response;
     } else {
-      return HPApi.createWalkupScanToCompEvent(response.data);
+      return WalkupScanToCompEvent.createWalkupScanToCompEvent(response.data);
     }
   }
 
-  static async removeDestination(walkupScanDestination: WalkupScanDestination) {
-    let urlInfo = new URL(walkupScanDestination.resourceURI);
-
-    if (urlInfo.pathname === null) {
-      throw new Error(
-        `invalid walkupScanDestination.resourceURI: ${walkupScanDestination.resourceURI}`
-      );
+  static async removeDestination(
+    walkupScanDestination: WalkupScanDestination | WalkupScanToCompDestination
+  ): Promise<boolean> {
+    let path: string;
+
+    if (walkupScanDestination.resourceURI.startsWith("http")) {
+      let urlInfo = new URL(walkupScanDestination.resourceURI);
+      if (urlInfo.pathname === null) {
+        throw new Error(
+          `invalid walkupScanDestination.resourceURI: ${walkupScanDestination.resourceURI}`
+        );
+      }
+      path = urlInfo.pathname;
+    } else {
+      path = walkupScanDestination.resourceURI;
     }
 
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
-      url: urlInfo.pathname,
+      url: path,
       method: "DELETE",
       responseType: "text",
     });
-    if (response.status === 204) {
+    if (response.status === 204 || response.status == 200) {
       return true;
     } else {
       throw response;
     }
   }
 
-  static async registerDestination(destination: Destination, toComp: boolean) {
-    let xml = await destination.toXML();
-    let url = "/WalkupScan/WalkupScanDestinations";
-    if (toComp) {
-      url = "/WalkupScanToComp/WalkupScanToCompDestinations";
+  static async registerWalkupScanDestination(
+    destination: Destination
+  ): Promise<string> {
+    const xml = await destination.toXML();
+    const url = "/WalkupScan/WalkupScanDestinations";
+    const response = await HPApi.callAxios({
+      baseURL: `http://${printerIP}`,
+      url: url,
+      method: "POST",
+      headers: { "Content-Type": "text/xml" },
+      data: xml,
+      responseType: "text",
+    });
+
+    if (response.status === 201 && response.headers.location != null) {
+      return new URL(response.headers.location).pathname;
+    } else {
+      throw response;
     }
+  }
+  static async registerWalkupScanToCompDestination(
+    destination: Destination
+  ): Promise<string> {
+    const xml = await destination.toXML();
+    const url = "/WalkupScanToComp/WalkupScanToCompDestinations";
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
       url: url,
@@ -183,7 +334,7 @@ export default class HPApi {
       responseType: "text",
     });
 
-    if (response.status === 201) {
+    if (response.status === 201 && response.headers.location != null) {
       return new URL(response.headers.location).pathname;
     } else {
       throw response;
@@ -192,9 +343,9 @@ export default class HPApi {
 
   static async getEvents(
     etag = "",
-    timeout = 0
-  ): Promise<{ etag: string; eventTable: EventTable }> {
-    let url = this.appendTimeout("/EventMgmt/EventTable", timeout);
+    decisecondTimeout = 0
+  ): Promise<EtagEventTable> {
+    let url = this.appendTimeout("/EventMgmt/EventTable", decisecondTimeout);
 
     let headers = this.placeETagHeader(etag, {});
 
@@ -206,6 +357,7 @@ export default class HPApi {
         method: "GET",
         responseType: "text",
         headers: headers,
+        timeout: decisecondTimeout * 100 * 1.1,
       });
     } catch (error) {
       const axiosError = error as AxiosError;
@@ -221,18 +373,21 @@ export default class HPApi {
       throw error;
     }
 
-    const parsed = await parseString(response.data);
-    return {
-      etag: response.headers["etag"],
-      eventTable: new EventTable(parsed as EventTableData),
-    };
+    const etagReceived = response.headers["etag"];
+    if (etagReceived == null) {
+      throw response;
+    }
+
+    const content = response.data;
+    return EventTable.createEtagEventTable(content, etagReceived);
   }
 
-  static placeETagHeader(etag: string, headers: AxiosRequestHeaders) {
+  static placeETagHeader(
+    etag: string,
+    headers: RawAxiosRequestHeaders
+  ): RawAxiosRequestHeaders {
     if (etag !== "") {
-      headers = {
-        "If-None-Match": etag,
-      };
+      headers["If-None-Match"] = etag;
     }
     return headers;
   }
@@ -247,7 +402,9 @@ export default class HPApi {
     return url;
   }
 
-  static async getDestination(destinationURL: string) {
+  static async getDestination(
+    destinationURL: string
+  ): Promise<WalkupScanDestination | WalkupScanToCompDestination> {
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
       url: destinationURL,
@@ -260,31 +417,16 @@ export default class HPApi {
     } else {
       const content = response.data;
       if (destinationURL.includes("WalkupScanToComp")) {
-        return this.createWalkupScanToCompDestination(content);
+        return WalkupScanToCompDestination.createWalkupScanToCompDestination(
+          content
+        );
       } else {
-        return this.createWalkupScanDestination(content);
+        return WalkupScanDestination.createWalkupScanDestination(content);
       }
     }
   }
 
-  static async createWalkupScanDestination(content: string) {
-    const parsed = (await parseString(content)) as WalkupScanDestinationData;
-    return new WalkupScanDestination(parsed);
-  }
-
-  static async createWalkupScanToCompDestination(content: string) {
-    const parsed = (await parseString(
-      content
-    )) as WalkupScanToCompDestinationData;
-    return new WalkupScanToCompDestination(parsed);
-  }
-
-  static async createWalkupScanToCompEvent(content: string) {
-    const parsed = (await parseString(content)) as WalkupScanToCompEventData;
-    return new WalkupScanToCompEvent(parsed);
-  }
-
-  static async getScanStatus() {
+  static async getScanStatus(): Promise<ScanStatus> {
     const response = await HPApi.callAxios({
       baseURL: `http://${printerIP}`,
       url: "/Scan/Status",
@@ -295,18 +437,18 @@ export default class HPApi {
     if (response.status !== 200) {
       throw response;
     } else {
-      const parsed = (await parseString(response.data)) as ScanStatusData;
-      return new ScanStatus(parsed);
+      let content = response.data;
+      return ScanStatus.createScanStatus(content);
     }
   }
 
-  static delay(t: number) {
+  static delay(t: number): Promise<void> {
     return new Promise(function (resolve) {
       setTimeout(resolve, t);
     });
   }
 
-  static async postJob(job: ScanJobSettings) {
+  static async postJob(job: ScanJobSettings): Promise<string> {
     await HPApi.delay(500);
     const xml = await job.toXML();
     const response = await HPApi.callAxios({
@@ -318,7 +460,7 @@ export default class HPApi {
       responseType: "text",
     });
 
-    if (response.status === 201) {
+    if (response.status === 201 && response.headers.location != null) {
       return response.headers.location;
     } else {
       throw response;
@@ -339,8 +481,8 @@ export default class HPApi {
     if (response.status !== 200) {
       throw response;
     } else {
-      const parsed = (await parseString(response.data)) as JobData;
-      return new Job(parsed);
+      const content = response.data;
+      return Job.createJob(content);
     }
   }
 
@@ -358,7 +500,7 @@ export default class HPApi {
     const destinationFileStream = fs.createWriteStream(destination);
     data.pipe(destinationFileStream);
 
-    await stream.finished(destinationFileStream);
+    await promisify(stream.finished)(destinationFileStream);
 
     return destination;
   }

package/src/Job.ts

@@ -1,4 +1,8 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, JobData>(parser.parseString);
 
 export interface JobData {
   "j:Job": {
@@ -16,7 +20,7 @@ export interface JobData {
           }[];
         }[];
       }[];
-      PostScanPage: {
+      PostScanPage?: {
         PageNumber: string[];
       }[];
     }[];
@@ -30,6 +34,11 @@ export default class Job {
     this.data = data;
   }
 
+  static async createJob(content: string): Promise<Job> {
+    const parsed = await parseString(content);
+    return new Job(parsed);
+  }
+
   get currentPageNumber(): string | null {
     let preScanPage = this.data["j:Job"].ScanJob[0].PreScanPage;
     if (preScanPage) {
@@ -39,11 +48,14 @@ export default class Job {
     }
   }
 
-  get totalPageNumber(): number {
-    return parseInt(
-      this.data["j:Job"].ScanJob[0].PostScanPage[0].PageNumber[0],
-      10
-    );
+  get totalPageNumber(): number | null {
+    if (this.data["j:Job"].ScanJob[0].PostScanPage) {
+      return parseInt(
+        this.data["j:Job"].ScanJob[0].PostScanPage[0].PageNumber[0],
+        10
+      );
+    }
+    return null;
   }
 
   get jobState():
@@ -55,46 +67,56 @@ export default class Job {
     return this.data["j:Job"]["j:JobState"][0];
   }
 
-  get pageState(): string {
+  get pageState(): string | null {
     let preScanPage = this.data["j:Job"].ScanJob[0].PreScanPage;
     if (preScanPage) {
       return preScanPage[0].PageState[0];
     } else {
-      return "";
+      return null;
     }
   }
 
   get binaryURL(): string | null {
-    let preScanPage = this.data["j:Job"].ScanJob[0].PreScanPage;
-    if (preScanPage) {
-      return preScanPage[0].BinaryURL[0];
-    } else {
-      return null;
+    if (this.data["j:Job"].ScanJob[0].PreScanPage) {
+      return this.data["j:Job"].ScanJob[0].PreScanPage[0].BinaryURL[0];
     }
+    return null;
   }
 
-  get imageWidth(): number {
+  get imageWidth(): number | null {
+    if (!this.data["j:Job"].ScanJob[0].hasOwnProperty("PreScanPage")) {
+      return null;
+    }
     return parseInt(
       this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
         ?.ImageWidth[0] ?? ""
     );
   }
-  get imageHeight(): number {
-    return parseInt(
-      this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
-        ?.ImageHeight[0] ?? ""
-    );
+  get imageHeight(): number | null {
+    if (this.data["j:Job"].ScanJob[0].PreScanPage) {
+      return parseInt(
+        this.data["j:Job"].ScanJob[0].PreScanPage[0].BufferInfo[0]
+          .ImageHeight[0]
+      );
+    }
+    return null;
   }
-  get xResolution(): number {
-    return parseInt(
-      this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
-        ?.ScanSettings?.[0]?.XResolution[0] ?? ""
-    );
+  get xResolution(): number | null {
+    if (this.data["j:Job"].ScanJob[0].PreScanPage) {
+      return parseInt(
+        this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
+          ?.ScanSettings?.[0]?.XResolution[0] ?? ""
+      );
+    }
+    return null;
   }
-  get yResolution(): number {
-    return parseInt(
-      this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
-        ?.ScanSettings?.[0]?.YResolution[0] ?? ""
-    );
+  get yResolution(): number | null {
+    if (this.data["j:Job"].ScanJob[0].hasOwnProperty("PreScanPage")) {
+      return parseInt(
+        this.data["j:Job"].ScanJob[0].PreScanPage?.[0]?.BufferInfo?.[0]
+          ?.ScanSettings?.[0]?.YResolution[0] ?? ""
+      );
+    }
+    return null;
   }
 }

package/src/JpegUtil.ts

@@ -8,7 +8,7 @@ export default class JpegUtil {
     debug = dbg;
   }
 
-  private static logDebug(msg: any) {
+  private static logDebug(msg: string | object) {
     if (debug) {
       console.log(msg);
     }
@@ -145,7 +145,7 @@ export default class JpegUtil {
     startOfStartOfFrame: number,
     lengthOfStartOfFrame: number,
     numberOfLine: number
-  ) : boolean {
+  ): boolean {
     // write the picture height
     if (6 < lengthOfStartOfFrame) {
       const heightBuffer = Buffer.from([0x00, 0x00]);
@@ -267,7 +267,11 @@ export default class JpegUtil {
     return null;
   }
 
-  private static parseMarker(buffer: Buffer, i: number, markerHandler: { [key: string]: (start: number, length: number) => boolean }) : boolean {
+  private static parseMarker(
+    buffer: Buffer,
+    i: number,
+    markerHandler: { [key: string]: (start: number, length: number) => boolean }
+  ): boolean {
     let marker = "";
 
     //Retrieve the block length of the first block since the first block will not contain the size of file
@@ -279,7 +283,7 @@ export default class JpegUtil {
       if (buffer[i] != 0xff) {
         this.logDebug(
           "We should be at the begining of the next block, but got: " +
-          buffer[i]
+            buffer[i]
         );
         return false;
       }