node-hp-scan-to 1.2.2 → 1.3.1

package/src/listening.ts

@@ -0,0 +1,145 @@
+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++) {
+    let walkupScanToCompEvent = await HPApi.getWalkupScanToCompEvent(
+      compEventURI
+    );
+    let 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/readDeviceCapabilities.ts

@@ -0,0 +1,46 @@
+import { DeviceCapabilities } from "./DeviceCapabilities";
+import HPApi from "./HPApi";
+import WalkupScanToCompCaps from "./WalkupScanToCompCaps";
+
+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!");
+  }
+
+  if (discoveryTree.ScanJobManifestURI != null) {
+    const scanJobManifest = await HPApi.getScanJobManifest(
+      discoveryTree.ScanJobManifestURI
+    );
+    if (scanJobManifest.ScanCapsURI != null) {
+      await HPApi.getScanCaps(scanJobManifest.ScanCapsURI);
+    }
+  }
+
+  return {
+    supportsMultiItemScanFromPlaten,
+    useWalkupScanToComp: walkupScanToCompCaps != null,
+  };
+}