@7365admin1/layer-common 3.1.4-staging.53 → 3.2.0

package/composables/useWebUsb.ts

@@ -11,10 +11,6 @@ interface USBDevice {
   close(): Promise<void>;
   selectConfiguration(configurationValue: number): Promise<void>;
   claimInterface(interfaceNumber: number): Promise<void>;
-  selectAlternateInterface(
-    interfaceNumber: number,
-    alternateSetting: number,
-  ): Promise<void>;
   releaseInterface(interfaceNumber: number): Promise<void>;
   transferOut(
     endpointNumber: number,
@@ -23,27 +19,14 @@ interface USBDevice {
   configuration: {
     interfaces: Array<{
       interfaceNumber: number;
-      alternate: USBAlternateInterface;
       alternates: Array<{
-        alternateSetting: number;
-        interfaceClass: number;
         endpoints: Array<{
           endpointNumber: number;
           direction: "in" | "out";
         }>;
       }>;
     }>;
-  } | null;
-  configurations: Array<{ configurationValue: number }>;
-}
-
-interface USBAlternateInterface {
-  alternateSetting: number;
-  interfaceClass: number;
-  endpoints: Array<{
-    endpointNumber: number;
-    direction: "in" | "out";
-  }>;
+  };
 }
 
 interface USBOutTransferResult {
@@ -56,86 +39,13 @@ declare global {
     usb: {
       getDevices(): Promise<USBDevice[]>;
       requestDevice(options: {
-        filters: Array<{
-          vendorId?: number;
-          productId?: number;
-          classCode?: number;
-        }>;
+        filters: Array<{ vendorId?: number; productId?: number }>;
       }): Promise<USBDevice>;
     };
   }
 }
 
 export default function useWebUsb() {
-  const printerConnections = new WeakMap<
-    USBDevice,
-    { interfaceNumber: number; endpointNumber: number }
-  >();
-
-  const protectedInterfaceClasses = new Set([0x01, 0x03, 0x08, 0x0b, 0x0e, 0x10, 0xe0]);
-
-  function getErrorMessage(error: unknown, fallback: string) {
-    return error instanceof Error && error.message ? error.message : fallback;
-  }
-
-  function findPrinterInterface(device: USBDevice) {
-    const candidates = (device.configuration?.interfaces || []).flatMap((usbInterface) =>
-      usbInterface.alternates.flatMap((alternate) => {
-        const outputEndpoint = alternate.endpoints.find((endpoint) => endpoint.direction === "out");
-        if (!outputEndpoint || protectedInterfaceClasses.has(alternate.interfaceClass)) return [];
-
-        return [{
-          interfaceNumber: usbInterface.interfaceNumber,
-          alternateSetting: alternate.alternateSetting,
-          activeAlternateSetting: usbInterface.alternate.alternateSetting,
-          interfaceClass: alternate.interfaceClass,
-          endpointNumber: outputEndpoint.endpointNumber,
-        }];
-      }),
-    );
-
-    candidates.sort((left, right) => {
-      const priority = (interfaceClass: number) => interfaceClass === 0x07 ? 0 : interfaceClass === 0xff ? 1 : 2;
-      return priority(left.interfaceClass) - priority(right.interfaceClass);
-    });
-
-    return candidates[0] || null;
-  }
-
-  async function preparePrinterDevice(device: USBDevice) {
-    await device.open();
-    if (!device.configuration) {
-      await device.selectConfiguration(device.configurations[0]?.configurationValue || 1);
-    }
-
-    const printerInterface = findPrinterInterface(device);
-    if (!printerInterface) {
-      throw new Error(
-        "The selected USB device is not a compatible printer. Select the receipt printer instead of a Bluetooth, camera, keyboard, or other system device.",
-      );
-    }
-
-    await device.claimInterface(printerInterface.interfaceNumber);
-    if (printerInterface.alternateSetting !== printerInterface.activeAlternateSetting) {
-      await device.selectAlternateInterface(
-        printerInterface.interfaceNumber,
-        printerInterface.alternateSetting,
-      );
-    }
-
-    printerConnections.set(device, {
-      interfaceNumber: printerInterface.interfaceNumber,
-      endpointNumber: printerInterface.endpointNumber,
-    });
-    return device;
-  }
-
-  function getPrinterConnection(device: USBDevice) {
-    const connection = printerConnections.get(device);
-    if (!connection) throw new Error("Printer interface is not connected");
-    return connection;
-  }
-
   const isWebUsbSupported = computed(() => {
     return typeof navigator !== "undefined" && "usb" in navigator;
   });
@@ -165,9 +75,7 @@ export default function useWebUsb() {
       throw new Error("Web USB is not supported in this browser");
     }
     try {
-      const device = await navigator.usb.requestDevice({
-        filters: [{ classCode: 0x07 }, { classCode: 0xff }],
-      });
+      const device = await navigator.usb.requestDevice({ filters: [] });
       return {
         vendorId: device.vendorId,
         productId: device.productId,
@@ -176,12 +84,12 @@ export default function useWebUsb() {
         serialNumber: device.serialNumber || "Unknown",
         deviceId: `${device.vendorId}:${device.productId}`,
       };
-    } catch (error: unknown) {
-      if (error instanceof DOMException && error.name === "NotFoundError") {
+    } catch (error: any) {
+      if (error.name === "NotFoundError") {
         throw new Error("No device selected");
       }
       console.error("Error requesting USB device:", error);
-      throw new Error(getErrorMessage(error, "Failed to access USB printer"));
+      throw new Error("Failed to access USB device");
     }
   };
 
@@ -202,17 +110,14 @@ export default function useWebUsb() {
         });
       }
       console.log("[WebUSB] Opening device:", device.vendorId, device.productId);
-      await preparePrinterDevice(device);
+      await device.open();
+      await device.selectConfiguration(1);
+      await device.claimInterface(0);
       console.log("[WebUSB] Device opened and interface claimed.");
       return device;
-    } catch (error: unknown) {
+    } catch (error) {
       console.error("Error connecting to USB device:", error);
-      try {
-        await device?.close();
-      } catch (closeError) {
-        console.error("Error closing rejected USB device:", closeError);
-      }
-      throw new Error(getErrorMessage(error, "Failed to connect to USB printer"));
+      throw new Error("Failed to connect to USB device");
     }
   };
 
@@ -268,20 +173,15 @@ export default function useWebUsb() {
           ? "Connection and print test successful"
           : "Connection successful but print test failed",
       };
-    } catch (error: unknown) {
+    } catch (error: any) {
       return {
         success: false,
-        error: getErrorMessage(error, "Failed to connect to USB printer"),
+        error: error.message,
         message: "Connection failed",
       };
     } finally {
       if (device) {
         try {
-          const connection = printerConnections.get(device);
-          if (connection) {
-            await device.releaseInterface(connection.interfaceNumber);
-            printerConnections.delete(device);
-          }
           await device.close();
         } catch (closeError) {
           console.error("Error closing device:", closeError);
@@ -305,16 +205,21 @@ export default function useWebUsb() {
       ];
 
       const testData = new Uint8Array(testCommands);
-      const { endpointNumber } = getPrinterConnection(device);
-      await device.transferOut(endpointNumber, testData);
+      const usbInterface = device.configuration.interfaces[0];
+      const alternate = usbInterface.alternates[0];
+      const outputEndpoint = alternate.endpoints.find(
+        (ep: any) => ep.direction === "out",
+      );
+
+      if (!outputEndpoint) {
+        throw new Error("No output endpoint found");
+      }
+
+      await device.transferOut(outputEndpoint.endpointNumber, testData);
       return { success: true, message: "Test print sent successfully" };
-    } catch (error: unknown) {
+    } catch (error: any) {
       console.error("Test print error:", error);
-      return {
-        success: false,
-        error: getErrorMessage(error, "Test print failed"),
-        message: "Test print failed",
-      };
+      return { success: false, error: error.message, message: "Test print failed" };
     }
   };
 
@@ -449,8 +354,13 @@ export default function useWebUsb() {
   ) => {
     try {
       console.log("[WebUSB] printQrCode start — doorLevel:", doorLevel, "liftLevel:", liftLevel, "company:", companyName, "address:", address);
-      const { endpointNumber } = getPrinterConnection(device);
-      console.log("[WebUSB] Using endpoint:", endpointNumber);
+      const usbInterface = device.configuration.interfaces[0];
+      const alternate = usbInterface.alternates[0];
+      const outputEndpoint = alternate.endpoints.find(
+        (ep: any) => ep.direction === "out",
+      );
+      if (!outputEndpoint) throw new Error("No output endpoint found");
+      console.log("[WebUSB] Using endpoint:", outputEndpoint.endpointNumber);
 
       const canvas = await createReceiptLayout(
         urlImage,
@@ -465,17 +375,17 @@ export default function useWebUsb() {
       const rasterData = canvasToRaster(canvas);
       console.log("[WebUSB] Raster data size:", rasterData.byteLength, "bytes");
 
-      await device.transferOut(endpointNumber, rasterData.buffer);
+      await device.transferOut(outputEndpoint.endpointNumber, rasterData.buffer);
       console.log("[WebUSB] Raster data sent.");
 
       const CUT = new Uint8Array([0x1d, 0x56, 0x41, 0x10]);
-      await device.transferOut(endpointNumber, CUT.buffer);
+      await device.transferOut(outputEndpoint.endpointNumber, CUT.buffer);
       console.log("[WebUSB] Cut command sent.");
 
       return { success: true, message: "QR print sent successfully" };
-    } catch (error: unknown) {
+    } catch (error: any) {
       console.error("[WebUSB] printQrCode error:", error);
-      return { success: false, error: getErrorMessage(error, "Unable to print QR code") };
+      return { success: false, error: error.message };
     }
   };
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "3.1.4-staging.53",
+  "version": "3.2.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "publishConfig": {
@@ -40,7 +40,6 @@
     "qrcode": "^1.5.4",
     "qrcode.vue": "^3.4.1",
     "sass": "^1.80.6",
-    "sip.js": "0.21.2",
     "socket.io-client": "^4.8.3",
     "vue-draggable-next": "^2.3.0",
     "vue3-signature": "^0.2.4",

package/pages/[org]/[site]/access-mgmt/identity-mapping/index.vue

@@ -0,0 +1,23 @@
+<template>
+  <v-container fluid>
+    <HidEnabledGate
+      :site="siteId"
+      :org="orgId"
+      message="Enable HID as a service for this site before mapping identities."
+    >
+      <HidIdentityMapping :site="siteId" :org="orgId" />
+    </HidEnabledGate>
+  </v-container>
+</template>
+
+<script setup lang="ts">
+definePageMeta({
+  layout: "default",
+  middleware: ["01-auth", "02-org"],
+  memberOnly: true,
+});
+
+const route = useRoute();
+const siteId = computed(() => String(route.params.site ?? ""));
+const orgId = computed(() => String(route.params.org ?? ""));
+</script>

package/plugins/secure-member.client.ts

@@ -12,40 +12,75 @@ export default defineNuxtPlugin(() => {
 
   const { userAppRole, id, orgNature } = useLocalSetup();
 
-  router.beforeEach(async (to) => {
+  router.afterEach(async (to) => {
     const isMember = to.meta?.memberOnly;
 
     if (!isMember) return;
 
     const APP = useRuntimeConfig().public.APP;
-    const org =
-      (to.params.org as string) || (to.params.organization as string) || "";
+    const org = computed(
+      () =>
+        (to.params.org as string) || (to.params.organization as string) || ""
+    );
 
-    if (!hexSchema.safeParse(org).success) {
-      return { name: "require-organization-membership" };
+    console.log('[secure-member-plugin', 'org', org.value)
+
+    if (!hexSchema.safeParse(org.value).success) {
+      return router.replace({ name: "require-organization-membership" });
     }
 
-    const userId = useCookie("user").value ?? "";
-    if (!userId) return { name: "index" };
+    const userId = computed(() => useCookie("user").value ?? "");
+
+    const { data: userMemberData, error: userMemberError } =
+      await useLazyAsyncData(
+        "plugin-get-member-by-id-" + userId.value + "-" + APP + "-" + org.value,
+        () => getByUserType(userId.value, APP, org.value),
+        { watch: [userId] }
+      );
+
+    watchEffect(() => {
+      if (userMemberError.value) {
+        console.log('running-secure-member-redirect-plugin')
+        navigateTo(
+          {
+            name: "index",
+          },
+          { replace: true }
+        );
+      }
+    });
+
+    const roleId = ref("roleId");
 
-    try {
-      const userMemberData = await getByUserType(userId, APP, org);
-      id.value = userMemberData.org ?? "";
+    watchEffect(() => {
+      if (userMemberData.value) {
+        id.value = userMemberData.value.org ?? "";
+        roleId.value = userMemberData.value.role ?? "roleId";
+      }
+    });
 
-      const [orgResult, roleResult] = await Promise.allSettled([
-        getById(org),
-        userMemberData.role ? getRoleById(userMemberData.role) : null,
-      ]);
+    const { data: getOrgByIdReq } = await useLazyAsyncData(
+      "plugin-get-org-by-id-" + org.value,
+      () => getById(org.value),
+      { watch: [org] }
+    );
 
-      if (orgResult.status === "fulfilled" && orgResult.value) {
-        orgNature.value = orgResult.value.nature ?? "";
+    watchEffect(() => {
+      if (getOrgByIdReq.value) {
+        orgNature.value = getOrgByIdReq.value.nature ?? "";
       }
+    });
 
-      if (roleResult.status === "fulfilled" && roleResult.value) {
-        userAppRole.value = roleResult.value;
+    const { data: getRoleByIdReq } = await useLazyAsyncData(
+      "plugin-get-role-by-id-" + roleId.value,
+      () => getRoleById(roleId.value),
+      { watch: [roleId] }
+    );
+
+    watchEffect(() => {
+      if (getRoleByIdReq.value) {
+        userAppRole.value = getRoleByIdReq.value;
       }
-    } catch (error) {
-      return { name: "index" };
-    }
+    });
   });
 });

package/types/site.d.ts

@@ -1,70 +1,5 @@
 declare type TSiteCreate = Pick<TSite, "name" | "description" | "orgId">;
 
-declare type THidQrCodeFormat = "0" | "1" | "2";
-
-declare type THidPermissionCategory =
-  | "resident"
-  | "property_management"
-  | "service_provider";
-
-declare type THidPermissionAssignment = {
-  subjectId: string;
-  category: THidPermissionCategory;
-  name: string;
-  subtitle?: string;
-  intercom: boolean;
-};
-
-declare type THidSitePermissions = {
-  site: string;
-  assignments: THidPermissionAssignment[];
-  counts: {
-    resident: number;
-    propertyManagement: number;
-    serviceProvider: number;
-    intercom: number;
-  };
-};
-
-declare type THidPermissionCandidate = THidPermissionAssignment & {
-  selected: boolean;
-};
-
-declare type THidQrCodePassConfig = {
-  enabled: boolean;
-  onlineMode?: boolean;
-  readerId: string;
-  qrFormat: THidQrCodeFormat;
-  identificationMethods?: {
-    facial: boolean;
-    card: boolean;
-    qrCode: boolean;
-    idPassword: boolean;
-    pin: boolean;
-    bluetooth: boolean;
-  };
-  printer: {
-    vendorId: string;
-    productId: string;
-  };
-  template: {
-    header: string;
-    subtext: string;
-  };
-  validityMinutes: number | null;
-  updatedAt?: string;
-};
-
-declare type TSiteMetadata = {
-  block?: number;
-  guardPosts?: number;
-  gracePeriod?: number;
-  incidentCounter?: number;
-  incidentLogo?: string;
-  services?: Record<string, unknown>[];
-  hidQrCodePass?: THidQrCodePassConfig;
-};
-
 
 declare type TSite = {
   _id?: string;

package/types/subscription.ts

@@ -0,0 +1,51 @@
+export type PlanStatus = "active" | "deactive";
+
+export type PlanType = "free_bundle" | "paid_bundle" | "custom_apps";
+
+export type BillingCycle = "monthly" | "annually";
+
+export interface AppOption {
+  id: string;
+  name: string;
+  monthlyPrice: number;
+  yearlyPrice: number;
+}
+
+export interface SubscriptionPlan {
+  id: string;
+  name: string;
+  description?: string;
+  maxSeats: number;
+  planType: PlanType;
+  billingCycle: BillingCycle | null;
+  price: number | null;
+  applicationIds: string[];
+  status: PlanStatus;
+}
+
+export interface PlanFormState {
+  name: string;
+  description: string;
+  maxSeats: number;
+  planType: PlanType;
+  billingCycle: BillingCycle | null;
+  bundleApps: string[];
+  bundlePrice: number | null;
+  customApps: string[];
+}
+
+export const PLAN_TYPE_LABEL: Record<PlanType, string> = {
+  free_bundle: "Free (Bundle)",
+  paid_bundle: "Paid (Bundle)",
+  custom_apps: "Paid (Custom Apps)",
+};
+
+// Mock catalogue of applications that can be bundled into a plan.
+// Replace with data fetched from your backend.
+export const AVAILABLE_APPLICATIONS: AppOption[] = [
+  { id: "crm", name: "CRM", monthlyPrice: 49, yearlyPrice: 490 },
+  { id: "hrm", name: "HRM", monthlyPrice: 39, yearlyPrice: 390 },
+  { id: "accounting", name: "Accounting", monthlyPrice: 59, yearlyPrice: 590 },
+  { id: "inventory", name: "Inventory", monthlyPrice: 45, yearlyPrice: 450 },
+  { id: "pos", name: "POS", monthlyPrice: 69, yearlyPrice: 690 },
+];