@7365admin1/core 3.72.1-staging.327 → 3.72.1-staging.328

package/dist/index.d.ts

@@ -13237,6 +13237,8 @@ declare function useHidAmicoRepo(): {
     findIdentitiesByHidUserIds: (reader: string | ObjectId, hidUserIds: Array<string | number>) => Promise<mongodb.WithId<bson.Document>[]>;
     acquireEnrollmentLock: (reader: string | ObjectId, owner: string, ttlSeconds: number) => Promise<boolean>;
     releaseEnrollmentLock: (reader: string | ObjectId, owner?: string) => Promise<boolean>;
+    setEnrollmentSession: (reader: string | ObjectId, owner: string, session: string) => Promise<boolean>;
+    getEnrollmentSession: (reader: string | ObjectId) => Promise<string>;
     assertOrganizationSiteAccess: (site: string | ObjectId, org: string | ObjectId) => Promise<{
         siteId: ObjectId;
         orgId: ObjectId;

package/dist/index.js

@@ -45129,6 +45129,20 @@ function useHidAmicoRepo() {
       throw error;
     }
   }
+  async function setEnrollmentSession(reader, owner, session) {
+    const result = await enrollmentLocks().updateOne(
+      { _id: toId3(reader, "reader ID"), owner },
+      { $set: { session, sessionAt: /* @__PURE__ */ new Date() } }
+    );
+    return result.matchedCount > 0;
+  }
+  async function getEnrollmentSession(reader) {
+    const lock = await enrollmentLocks().findOne({
+      _id: toId3(reader, "reader ID"),
+      expiresAt: { $gt: /* @__PURE__ */ new Date() }
+    });
+    return String(lock?.session ?? "");
+  }
   async function releaseEnrollmentLock(reader, owner) {
     const result = await enrollmentLocks().deleteOne({
       _id: toId3(reader, "reader ID"),
@@ -45687,6 +45701,8 @@ function useHidAmicoRepo() {
     findIdentitiesByHidUserIds,
     acquireEnrollmentLock,
     releaseEnrollmentLock,
+    setEnrollmentSession,
+    getEnrollmentSession,
     assertOrganizationSiteAccess,
     getSitePermissions,
     listSitePermissionDocuments,
@@ -46935,6 +46951,8 @@ var HidAmicoClient = class {
   constructor(reader) {
     this.reader = reader;
     this.session = "";
+    /** True while `session` belongs to another request. See `adoptSession`. */
+    this.borrowedSession = false;
     const relayAuth = getRelayAuth();
     this.http = import_axios.default.create({
       baseURL: normalizeHidReaderBaseUrl(reader.baseUrl),
@@ -46994,6 +47012,7 @@ var HidAmicoClient = class {
       throw new import_node_server_utils141.BadRequestError("HID Amico login failed: missing session.");
     }
     this.session = res.data.session;
+    this.borrowedSession = false;
     return this.session;
   }
   async sessionIsValid() {
@@ -47146,10 +47165,34 @@ var HidAmicoClient = class {
       verified: true
     };
   }
+  /**
+   * Take over a session somebody else opened, without logging in.
+   *
+   * For the cancel path only. While an enrolment is listening the reader will
+   * not serve a second `hidlogin.fcgi` inside the client's 15 second timeout, so
+   * the cancel has to ride the enrolment's session or it never reaches the
+   * device at all.
+   *
+   * A borrowed session is NOT this client's to close - see `logout`.
+   */
+  adoptSession(session) {
+    this.session = String(session ?? "");
+    this.borrowedSession = Boolean(this.session);
+    return this.session;
+  }
+  /** Whether this client may end the session it is holding. */
+  get ownsSession() {
+    return Boolean(this.session) && !this.borrowedSession;
+  }
   async logout() {
     if (!this.session) {
       return;
     }
+    if (this.borrowedSession) {
+      this.session = "";
+      this.borrowedSession = false;
+      return;
+    }
     const logoutUrl = this.url("/logout.fcgi");
     try {
       this.session = "";
@@ -49866,7 +49909,8 @@ function useHidAmicoService() {
       throw new import_node_server_utils141.BadRequestError("Another physical HID card enrollment is already running on this reader.");
     }
     try {
-      await client.login();
+      const session = await client.login();
+      await repo.setEnrollmentSession(readerId, lockOwner, session);
       await assertHidUserExists(client, hidUserId);
       await ensurePhysicalCardIdentification(client);
       const beforeRows = await loadPhysicalCardRows(client, hidUserId);
@@ -49947,15 +49991,20 @@ function useHidAmicoService() {
   async function cancelUserCardEnrollment(readerId) {
     const reader = await getActiveReader(readerId);
     const client = new HidAmicoClient(reader);
+    const runningSession = await repo.getEnrollmentSession(readerId);
     try {
-      await client.login();
+      if (runningSession) {
+        client.adoptSession(runningSession);
+      } else {
+        await client.login();
+      }
       await client.cancelRemoteEnrollment();
       const enrollmentWasRunning = await repo.releaseEnrollmentLock(readerId);
       await repo.addEvent({
         reader: readerId,
         site: reader.site,
         type: "user_card_enrollment_cancelled",
-        payload: { enrollmentWasRunning }
+        payload: { enrollmentWasRunning, borrowedSession: Boolean(runningSession) }
       });
       return { readerId, cancelled: true };
     } finally {