@7365admin1/layer-common 1.10.0 → 1.10.1

package/composables/useWebUsb.ts

@@ -0,0 +1,389 @@
+import QRCode from "qrcode";
+
+// Web USB type definitions
+interface USBDevice {
+  vendorId: number;
+  productId: number;
+  manufacturerName?: string;
+  productName?: string;
+  serialNumber?: string;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  selectConfiguration(configurationValue: number): Promise<void>;
+  claimInterface(interfaceNumber: number): Promise<void>;
+  releaseInterface(interfaceNumber: number): Promise<void>;
+  transferOut(
+    endpointNumber: number,
+    data: BufferSource,
+  ): Promise<USBOutTransferResult>;
+  configuration: {
+    interfaces: Array<{
+      interfaceNumber: number;
+      alternates: Array<{
+        endpoints: Array<{
+          endpointNumber: number;
+          direction: "in" | "out";
+        }>;
+      }>;
+    }>;
+  };
+}
+
+interface USBOutTransferResult {
+  status: "ok" | "stall" | "babble";
+  bytesWritten: number;
+}
+
+declare global {
+  interface Navigator {
+    usb: {
+      getDevices(): Promise<USBDevice[]>;
+      requestDevice(options: {
+        filters: Array<{ vendorId?: number; productId?: number }>;
+      }): Promise<USBDevice>;
+    };
+  }
+}
+
+export default function useWebUsb() {
+  const isWebUsbSupported = computed(() => {
+    return typeof navigator !== "undefined" && "usb" in navigator;
+  });
+
+  const getAvailableDevices = async () => {
+    if (!isWebUsbSupported.value) {
+      throw new Error("Web USB is not supported in this browser");
+    }
+    try {
+      const devices = await navigator.usb.getDevices();
+      return devices.map((device: USBDevice) => ({
+        vendorId: device.vendorId,
+        productId: device.productId,
+        manufacturerName: device.manufacturerName || "Unknown",
+        productName: device.productName || "Unknown",
+        serialNumber: device.serialNumber || "Unknown",
+        deviceId: `${device.vendorId}:${device.productId}`,
+      }));
+    } catch (error) {
+      console.error("Error getting USB devices:", error);
+      throw new Error("Failed to get USB devices");
+    }
+  };
+
+  const requestDevice = async () => {
+    if (!isWebUsbSupported.value) {
+      throw new Error("Web USB is not supported in this browser");
+    }
+    try {
+      const device = await navigator.usb.requestDevice({ filters: [] });
+      return {
+        vendorId: device.vendorId,
+        productId: device.productId,
+        manufacturerName: device.manufacturerName || "Unknown",
+        productName: device.productName || "Unknown",
+        serialNumber: device.serialNumber || "Unknown",
+        deviceId: `${device.vendorId}:${device.productId}`,
+      };
+    } catch (error: any) {
+      if (error.name === "NotFoundError") {
+        throw new Error("No device selected");
+      }
+      console.error("Error requesting USB device:", error);
+      throw new Error("Failed to access USB device");
+    }
+  };
+
+  const connectToDevice = async (vendorId: number, productId: number) => {
+    if (!isWebUsbSupported.value) {
+      throw new Error("Web USB is not supported in this browser");
+    }
+    try {
+      let devices = await navigator.usb.getDevices();
+      let device = devices.find(
+        (d: USBDevice) => d.vendorId === vendorId && d.productId === productId,
+      );
+      if (!device) {
+        device = await navigator.usb.requestDevice({
+          filters: [{ vendorId, productId }],
+        });
+      }
+      await device.open();
+      await device.selectConfiguration(1);
+      await device.claimInterface(0);
+      return device;
+    } catch (error) {
+      console.error("Error connecting to USB device:", error);
+      throw new Error("Failed to connect to USB device");
+    }
+  };
+
+  const testConnection = async (
+    vendorId: number,
+    productId: number,
+    forQr?: boolean,
+    urlImage?: string,
+    doorLevel?: number | string | null,
+    liftLevel?: number | string | null,
+    companyName?: string,
+    address?: string,
+    qrHeader?: string,
+    qrSubText?: string,
+  ) => {
+    if (!isWebUsbSupported.value) {
+      throw new Error("Web USB is not supported in this browser");
+    }
+
+    let device: USBDevice | null = null;
+    try {
+      device = await connectToDevice(vendorId, productId);
+
+      const deviceInfo = {
+        vendorId: device.vendorId,
+        productId: device.productId,
+        manufacturerName: device.manufacturerName || "Unknown",
+        productName: device.productName || "Unknown",
+        serialNumber: device.serialNumber || "Unknown",
+      };
+
+      let printTestResult;
+      if (forQr && urlImage) {
+        printTestResult = await printQrCode(
+          device,
+          urlImage,
+          doorLevel ?? null,
+          liftLevel ?? null,
+          companyName,
+          address,
+          qrHeader,
+          qrSubText,
+        );
+      } else {
+        printTestResult = await testPrint(device);
+      }
+
+      return {
+        success: true,
+        deviceInfo,
+        printTest: printTestResult,
+        message: printTestResult.success
+          ? "Connection and print test successful"
+          : "Connection successful but print test failed",
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+        message: "Connection failed",
+      };
+    } finally {
+      if (device) {
+        try {
+          await device.close();
+        } catch (closeError) {
+          console.error("Error closing device:", closeError);
+        }
+      }
+    }
+  };
+
+  const testPrint = async (device: USBDevice) => {
+    try {
+      const testCommands = [
+        0x1b, 0x40,
+        0x1b, 0x61, 0x01,
+        0x1b, 0x21, 0x30,
+        ...new TextEncoder().encode("TEST PRINT\n"),
+        0x1b, 0x21, 0x00,
+        ...new TextEncoder().encode("Printer connection test successful!\n"),
+        ...new TextEncoder().encode("Date: " + new Date().toLocaleString() + "\n"),
+        0x1d, 0x56, 0x00,
+        0x0a, 0x0a, 0x0a, 0x0a,
+      ];
+
+      const testData = new Uint8Array(testCommands);
+      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: any) {
+      console.error("Test print error:", error);
+      return { success: false, error: error.message, message: "Test print failed" };
+    }
+  };
+
+  async function createReceiptLayout(
+    qrUrlImage: string,
+    doorLevel: number | string | null,
+    liftLevel: number | string | null,
+    companyName?: string,
+    address?: string,
+    qrHeader?: string,
+    qrSubText?: string,
+  ): Promise<HTMLCanvasElement> {
+    const canvas = document.createElement("canvas");
+    canvas.width = 576;
+    canvas.height = 620;
+    const ctx = canvas.getContext("2d")!;
+    ctx.fillStyle = "#fff";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = "#000";
+    ctx.textAlign = "center";
+
+    ctx.font = "bold 30px Arial";
+    ctx.fillText(qrHeader || "Welcome", canvas.width / 2, 40);
+
+    ctx.font = "20px Arial";
+    ctx.fillText(
+      qrSubText || "Proceed to Security Desk to check-out after visit",
+      canvas.width / 2,
+      70,
+    );
+
+    const qrSmall = 140;
+    const qrCenter = 250;
+    const margin = 20;
+    const qrCanvas = await QRCode.toCanvas(qrUrlImage, { width: qrCenter });
+
+    ctx.drawImage(qrCanvas, margin, 90, qrSmall, qrSmall);
+    ctx.drawImage(qrCanvas, canvas.width - qrSmall - margin, 90, qrSmall, qrSmall);
+    ctx.drawImage(qrCanvas, (canvas.width - qrCenter) / 2, 110, qrCenter, qrCenter);
+    ctx.drawImage(qrCanvas, margin, 300, qrSmall, qrSmall);
+    ctx.drawImage(qrCanvas, canvas.width - qrSmall - margin, 300, qrSmall, qrSmall);
+
+    ctx.font = "25px Arial";
+    ctx.fillText(companyName || "", canvas.width / 2, 470);
+
+    ctx.font = "25px Arial";
+    ctx.fillText(address || "", canvas.width / 2, 505);
+
+    const now = new Date();
+    const pad = (n: number) => n.toString().padStart(2, "0");
+    const dateStr = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const timeStr = `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+
+    ctx.font = "20px Arial";
+    ctx.fillText(`Date: ${dateStr} ${timeStr}`, canvas.width / 2, 540);
+
+    let accessText = "Access: ";
+    if (doorLevel && liftLevel) {
+      accessText += "Door / Elevator";
+    } else if (doorLevel) {
+      accessText += "Door";
+    } else if (liftLevel) {
+      accessText += "Elevator";
+    } else {
+      accessText += "N/A";
+    }
+    ctx.fillText(accessText, canvas.width / 2, 570);
+
+    ctx.font = "italic 20px Arial";
+    let instructionText = "";
+    if (doorLevel && liftLevel) {
+      instructionText = `Scan ${doorLevel}. Scan and press Level ${liftLevel}. One time use.`;
+    } else if (doorLevel) {
+      instructionText = `Scan ${doorLevel}. One time use.`;
+    } else if (liftLevel) {
+      instructionText = `Scan and press Level ${liftLevel}. One time use.`;
+    } else {
+      instructionText = "One time use.";
+    }
+    ctx.fillText(instructionText, canvas.width / 2, 600);
+
+    return canvas;
+  }
+
+  function canvasToRaster(canvas: HTMLCanvasElement): Uint8Array {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Canvas 2D context not available");
+
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const pixels = imageData.data;
+    const width = canvas.width;
+    const height = canvas.height;
+    const rowBytes = Math.ceil(width / 8);
+    const bytes: number[] = [];
+
+    bytes.push(0x1d, 0x76, 0x30, 0x00);
+    bytes.push(rowBytes & 0xff, (rowBytes >> 8) & 0xff);
+    bytes.push(height & 0xff, (height >> 8) & 0xff);
+
+    for (let y = 0; y < height; y++) {
+      for (let xByte = 0; xByte < rowBytes; xByte++) {
+        let byte = 0;
+        for (let bit = 0; bit < 8; bit++) {
+          const x = xByte * 8 + bit;
+          const idx = (y * width + x) * 4;
+          if (x < width) {
+            const r = pixels[idx];
+            const g = pixels[idx + 1];
+            const b = pixels[idx + 2];
+            const avg = (r + g + b) / 3;
+            if (avg < 128) {
+              byte |= 0x80 >> bit;
+            }
+          }
+        }
+        bytes.push(byte);
+      }
+    }
+
+    return new Uint8Array(bytes);
+  }
+
+  const printQrCode = async (
+    device: USBDevice,
+    urlImage: string,
+    doorLevel: number | string | null,
+    liftLevel: number | string | null,
+    companyName?: string,
+    address?: string,
+    qrHeader?: string,
+    qrSubText?: string,
+  ) => {
+    try {
+      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");
+
+      const canvas = await createReceiptLayout(
+        urlImage,
+        doorLevel,
+        liftLevel,
+        companyName,
+        address,
+        qrHeader,
+        qrSubText,
+      );
+      const rasterData = canvasToRaster(canvas);
+
+      await device.transferOut(outputEndpoint.endpointNumber, rasterData.buffer);
+
+      const CUT = new Uint8Array([0x1d, 0x56, 0x41, 0x10]);
+      await device.transferOut(outputEndpoint.endpointNumber, CUT.buffer);
+
+      return { success: true, message: "QR print sent successfully" };
+    } catch (error: any) {
+      console.error("Print QR code error:", error);
+      return { success: false, error: error.message };
+    }
+  };
+
+  return {
+    isWebUsbSupported,
+    getAvailableDevices,
+    requestDevice,
+    connectToDevice,
+    testConnection,
+  };
+}

package/composables/useWorkOrder.ts

@@ -73,7 +73,7 @@ export default function useWorkOrder() {
 
   function deleteWorkOrder(id: string) {
     return useNuxtApp().$api<Record<string, any>>(`/api/work-orders/deleted/work-order`, {
-      method: "DELETE",
+      method: "PUT",
       query: { id },
     });
   }

package/nuxt.config.ts

@@ -32,6 +32,9 @@ export default defineNuxtConfig({
       APP_PEST_CONTROL: (process.env.APP_PEST_CONTROL as string) ?? "",
       APP_LANDSCAPING: (process.env.APP_LANDSCAPING as string) ?? "",
       APP_POOL_MAINTENANCE: (process.env.APP_POOL_MAINTENANCE as string) ?? "",
+      ENTRYPASS_ACM_URL:
+        (process.env.ENTRYPASS_ACM_URL as string) ??
+        "https://entrypass-xsocket.iservice365.app/",
     },
   },
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "publishConfig": {
@@ -30,8 +30,11 @@
   "dependencies": {
     "@ckeditor/ckeditor5-vue": "^7.3.0",
     "@iconify/vue": "^5.0.0",
+    "qrcode.vue": "^3.4.1",
     "@mdi/font": "^7.4.47",
+    "@types/qrcode": "^1.5.6",
     "ckeditor5": "^47.2.0",
+    "qrcode": "^1.5.4",
     "sass": "^1.80.6",
     "vue3-signature": "^0.2.4",
     "zod": "^3.24.2"

package/types/area.d.ts

@@ -0,0 +1,22 @@
+declare type TArea = {
+  _id: string;
+  name: string;
+  checklist: TAreaChecklist[];
+  createdAt: string;
+  updatedAt: string;
+};
+
+declare type TAreaChecklist = {
+  _id: string;
+  name: string;
+};
+
+declare type TAreaCreate = {
+  name: string;
+  set: number;
+  type: string;
+  units: Array<{
+    unit: string;
+    name: string;
+  }>;
+};

package/types/attendance.d.ts

@@ -0,0 +1,38 @@
+declare type TAttendance = {
+  _id: string;
+  teamMember: string;
+  checkIn?: string;
+  checkOut?: string;
+  totalHours?: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+declare type TAttendanceCheckIn = {
+  checkIn: {
+    timestamp: string;
+    location: TAttendanceLocation;
+    img?: string;
+  };
+};
+
+declare type TAttendanceCheckOut = {
+  checkOut: {
+    timestamp: string;
+    location: TAttendanceLocation;
+    img?: string;
+  };
+};
+
+declare type TAttendanceLocation = {
+  latitude: number;
+  longitude: number;
+};
+
+declare type TAttendanceSettings = {
+  site: string;
+  isLocationEnabled: boolean;
+  location?: TAttendanceLocation;
+  isGeofencingEnabled?: boolean;
+  mile?: number;
+};

package/types/checkout-item.d.ts

@@ -0,0 +1,27 @@
+declare type TCheckoutItemApi = {
+  _id: string;
+  createdAt: string;
+  name: string;
+  status: string;
+  supply: string;
+  qty: number;
+  unitOfMeasurement: string;
+  remarks?: string;
+  attachment?: string[];
+};
+
+declare type TCheckoutItemCreate = {
+  items: Array<{
+    supply: string;
+    qty: number;
+    attachment?: string[];
+  }>;
+};
+
+declare type TCheckoutItem = {
+  supply: string;
+  supplyName: string;
+  qty: number;
+  photos: string[];
+  photoIds: string[];
+};

package/types/cleaner-schedule.d.ts

@@ -0,0 +1,54 @@
+declare type TCleanerChecklist = {
+  _id: string;
+  date: string;
+  status: TCleanerChecklistStatus[];
+  createdAt: string;
+  updatedAt: string;
+  attachments: string[];
+};
+
+declare type TCleanerChecklistStatus = {
+  type: string;
+  site: string;
+  status: string;
+  completedAt: string;
+  createdByName: string;
+};
+
+declare type TAreaRejectChecklist = {
+  attachments: string[];
+  remarks: string;
+};
+
+declare type TAreaChecklistHistory = {
+  _id: string;
+  name: string;
+  status: string;
+  createdAt: string;
+  endedAt: string;
+  acceptedByName: string;
+};
+
+declare type TUnitChecklistItem = {
+  unit: string;
+  name: string;
+  status: string;
+  remarks: string;
+  completedByName?: string;
+  timestamp?: string;
+};
+
+declare type TChecklistSet = {
+  units: TUnitChecklistItem[];
+  set: number;
+  remarks?: string;
+  attachments?: string[];
+  completedByName?: string;
+};
+
+declare type TFlattenedUnitItem = TUnitChecklistItem & {
+  set: number;
+};
+
+declare type TScheduleAreaStatus = "All" | "Ready" | "Ongoing" | "Completed";
+declare type TAreaType = "all" | "common" | "toilet";

package/types/location.d.ts

@@ -0,0 +1,42 @@
+declare type TLocationData = {
+  latitude: number;
+  longitude: number;
+  address?: string;
+  city?: string;
+  country?: string;
+  postalCode?: string;
+};
+
+declare type TLocationFormData = {
+  country: string;
+  postalCode: string;
+  city: string;
+  address: string;
+};
+
+declare type TLocationFieldState = {
+  country: boolean;
+  city: boolean;
+  address: boolean;
+};
+
+declare type TNominatimResult = {
+  lat: string;
+  lon: string;
+  display_name: string;
+  address?: {
+    city?: string;
+    town?: string;
+    village?: string;
+    state?: string;
+    country?: string;
+    postcode?: string;
+  };
+};
+
+declare type TLocationSearchParams = {
+  postalCode: string;
+  city?: string;
+  address?: string;
+  country?: string;
+};

package/types/schedule-task.d.ts

@@ -0,0 +1,18 @@
+declare type TScheduleTask = {
+  _id: string;
+  title: string;
+  // replaced frequency-based recurrence with explicit date range
+  startDate?: string; // YYYY-MM-DD
+  endDate?: string; // YYYY-MM-DD
+  time?: string;
+  description?: string;
+  areas: { name: string; value: string }[];
+  site: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+declare type TScheduleTaskForm = Pick<
+  TScheduleTask,
+  "title" | "startDate" | "endDate" | "time" | "description" | "areas"
+>;

package/types/stock.d.ts

@@ -0,0 +1,16 @@
+declare type TStock = {
+  _id?: string;
+  site: string;
+  supply: string;
+  in?: number;
+  out?: number;
+  balance: number;
+  qty: number;
+  remarks?: string;
+  status?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  deletedAt?: string;
+};
+
+declare type TStockCreate = Pick<TStock, "qty" | "remarks">;

package/types/supply.d.ts

@@ -0,0 +1,11 @@
+declare type TSupply = {
+  _id: string;
+  name: string;
+  qty: number;
+  status: string;
+  unitOfMeasurement: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+declare type TSupplyCreate = Pick<TSupply, "name" | "unitOfMeasurement">;

package/utils/acm-crypto.ts

@@ -0,0 +1,30 @@
+import crypto from "crypto";
+
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 12;
+const SECRET_KEY = crypto.createSecretKey(
+  new Uint8Array(crypto.createHash("sha256").update("acm-secret-key").digest())
+);
+
+// encrypting entrypass url for security purpose
+export function encryptAcmUrl(entrypassUrl: string) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(
+    ALGORITHM,
+    SECRET_KEY,
+    new Uint8Array(iv)
+  );
+
+  const encrypted = Buffer.concat([
+    cipher.update(entrypassUrl, "utf8"),
+    cipher.final() as any,
+  ]);
+
+  const authTag = cipher.getAuthTag();
+
+  return [
+    iv.toString("base64"),
+    authTag.toString("base64"),
+    encrypted.toString("base64"),
+  ].join(":");
+}