@7365admin1/layer-common 1.10.0 → 1.10.2

package/composables/useLocation.ts

@@ -0,0 +1,78 @@
+export default function useLocation() {
+  function getCountries() {
+    return useNuxtApp()
+      .$api<Record<string, any>>("/json/country.json", {
+        method: "GET",
+      })
+      .then((countries) =>
+        countries
+          .map((c: any) => c.name)
+          .sort((a: string, b: string) => a.localeCompare(b)),
+      );
+  }
+
+  function getAddressByPostalCode(postalCode: string, country?: string) {
+    const countryISOMap: Record<string, string> = {
+      Singapore: "sg",
+      Malaysia: "my",
+      "United States": "us",
+      "United Kingdom": "gb",
+    };
+
+    const isoCode = country
+      ? countryISOMap[country] || country.toLowerCase()
+      : undefined;
+
+    return useNuxtApp()
+      .$api<Record<string, any>[]>(
+        "https://nominatim.openstreetmap.org/search",
+        {
+          method: "GET",
+          query: {
+            postalcode: postalCode,
+            country: isoCode,
+            format: "json",
+            limit: 1,
+            addressdetails: 1,
+          },
+          headers: {
+            "User-Agent": "iService365-Hygiene-App",
+          },
+        },
+      )
+      .then((data) => (data?.length ? data[0] : null));
+  }
+
+  function searchLocationByAddress({
+    postalCode,
+    city,
+    address,
+    country,
+  }: TLocationSearchParams) {
+    const searchParts = [postalCode, city, address, country].filter(Boolean);
+
+    return useNuxtApp()
+      .$api<Record<string, any>[]>(
+        "https://nominatim.openstreetmap.org/search",
+        {
+          method: "GET",
+          query: {
+            q: searchParts.join(", "),
+            format: "json",
+            limit: 1,
+            addressdetails: 1,
+          },
+          headers: {
+            "User-Agent": "iService365-Hygiene-App",
+          },
+        },
+      )
+      .then((data) => (data?.length ? data[0] : null));
+  }
+
+  return {
+    getCountries,
+    getAddressByPostalCode,
+    searchLocationByAddress,
+  };
+}

package/composables/useOnlineForm.ts

@@ -24,19 +24,26 @@ export default function useOnlineForm() {
     });
   }
   function getOnlineFormById(id: string) {
-    return useNuxtApp().$api<Record<string, any>>(`/api/online-forms/id/${id}`, {
-      method: "GET",
-    });
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/online-forms/id/${id}`,
+      {
+        method: "GET",
+      }
+    );
   }
   function updateOnlineFormById(id: string, value: any) {
-    return useNuxtApp().$api<Record<string, any>>(`/api/online-forms/id/${id}`, {
-      method: "PUT",
-      body: value,
-    });
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/online-forms/id/${id}`,
+      {
+        method: "PUT",
+        body: value,
+      }
+    );
   }
   function deleteOnlineFormById(id: string) {
-    return useNuxtApp().$api(`/api/online-forms/id/${id}`, {
-      method: "DELETE",
+    return useNuxtApp().$api(`/api/online-forms/deleted/online-form`, {
+      method: "PUT",
+      query: { id },
     });
   }
   function getAllBySiteId(

package/composables/usePeople.ts

@@ -1,88 +1,103 @@
-export default function(){
-
-
-    async function getAll({
-      page = 1,
-      limit = 10,
-      sort = "asc",
-      search = "",
-      org = "",
-      site = "",
-      dateTo = "",
-      dateFrom = "",
-      type="",
-      displayNoCheckOut=false
-      } = {}) {
-      return await useNuxtApp().$api<Record<string, any>>("/api/people", {
-        method: "GET",
-        query: { page, limit, sort, search, org, site, dateTo, dateFrom, type }
-      });
+export default function () {
+  async function getAll({
+    page = 1,
+    limit = 10,
+    sort = "asc",
+    search = "",
+    org = "",
+    site = "",
+    dateTo = "",
+    dateFrom = "",
+    type = "",
+    displayNoCheckOut = false,
+  } = {}) {
+    return await useNuxtApp().$api<Record<string, any>>("/api/people", {
+      method: "GET",
+      query: { page, limit, sort, search, org, site, dateTo, dateFrom, type },
+    });
   }
 
-  async function findPersonByNRIC(nric: string): Promise<null | Partial<TPeople>> {
-      return await $fetch<Record<string, any>>(`/api/people/nric/${nric}`, {
-        method: "GET",
-      });
+  async function findPersonByNRIC(
+    nric: string
+  ): Promise<null | Partial<TPeople>> {
+    return await $fetch<Record<string, any>>(`/api/people/nric/${nric}`, {
+      method: "GET",
+    });
   }
 
-  async function findPersonByContact(contact: string): Promise<null | Partial<TPeople>> {
-      return await $fetch<Record<string, any>>(`/api/people/contact/${contact}`, {
-        method: "GET",
-      });
+  async function findPersonByContact(
+    contact: string
+  ): Promise<null | Partial<TPeople>> {
+    return await $fetch<Record<string, any>>(`/api/people/contact/${contact}`, {
+      method: "GET",
+    });
   }
-  async function findUsersByPlateNumber(plateNumber: string): Promise<null | Partial<TPeople>> {
-      return await $fetch<Record<string, any>>(`/api/people/plateNumber/${plateNumber}`, {
+  async function findUsersByPlateNumber(
+    plateNumber: string
+  ): Promise<null | Partial<TPeople>> {
+    return await $fetch<Record<string, any>>(
+      `/api/people/plateNumber/${plateNumber}`,
+      {
         method: "GET",
-        query: { limit: 20 }
-      });
+        query: { limit: 20 },
+      }
+    );
   }
 
-  async function searchCompanyList(company: string): Promise<null | Partial<TPeople>> {
-      return await $fetch<Record<string, any>>('/api/people/company', {
-        method: "GET",
-        query: { search: company}
-      });
+  async function searchCompanyList(
+    company: string
+  ): Promise<null | Partial<TPeople>> {
+    return await $fetch<Record<string, any>>("/api/people/company", {
+      method: "GET",
+      query: { search: company },
+    });
   }
 
-    async function create(payload: Partial<TPeoplePayload>){
-      return await useNuxtApp().$api<Record<string, any>>("/api/people", {
-        method: "POST",
-        body: payload,
-      });
-    }
+  async function create(payload: Partial<TPeoplePayload>) {
+    return await useNuxtApp().$api<Record<string, any>>("/api/people", {
+      method: "POST",
+      body: payload,
+    });
+  }
 
-    async function updateById(_id: string, payload: Partial<TPeoplePayload>){
-      return await useNuxtApp().$api<Record<string, any>>(`/api/people/id/${_id}`, {
+  async function updateById(_id: string, payload: Partial<TPeoplePayload>) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/people/id/${_id}`,
+      {
         method: "PUT",
         body: payload,
-      }); 
-    }
+      }
+    );
+  }
 
-    async function deleteById(_id: string){
-      return await useNuxtApp().$api<Record<string, any>>(`/api/people/id/${_id}`, {
-        method: "PUT",
-      }); 
-    }
+  async function deleteById(_id: string) {
+    return await useNuxtApp().$api<Record<string, any>>(`/api/people/${_id}`, {
+      method: "PUT",
+    });
+  }
 
-    async function getPeopleByUnit( _id: string,{
-      status = "active",
-      type = "resident",
-      } = {}){
-      return await useNuxtApp().$api<Record<string, any>>(`/api/people/unit/${_id}`, {
-         method: "GET",
-         query: { status, type }
-      }); 
-    }
+  async function getPeopleByUnit(
+    _id: string,
+    { status = "active", type = "resident" } = {}
+  ) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/people/unit/${_id}`,
+      {
+        method: "GET",
+        query: { status, type },
+      }
+    );
+  }
 
-    return {
-        create,
-        getAll,
-        updateById,
-        deleteById,
-        findPersonByNRIC,
-        findPersonByContact,
-        getPeopleByUnit,
-        searchCompanyList,
-        findUsersByPlateNumber
-    }
-}
+  return {
+    create,
+    getAll,
+    updateById,
+    deleteById,
+    findPersonByNRIC,
+    findPersonByContact,
+    getPeopleByUnit,
+    searchCompanyList,
+    findUsersByPlateNumber,
+  };
+}

package/composables/useQR.ts

@@ -0,0 +1,29 @@
+export default function useQR() {
+  async function downloadQR(url: string, filename: string = "qrcode") {
+    const res = await useNuxtApp().$api<Blob | MediaSource>(
+      `/api/hygiene-qr/generate`,
+      {
+        method: "GET",
+        query: {
+          url,
+          filename,
+        },
+      }
+    );
+
+    if (!res) throw new Error("Error downloading QR code");
+
+    const downloadUrl = window.URL.createObjectURL(res);
+    const a = document.createElement("a");
+    a.href = downloadUrl;
+    a.download = `${filename}.png`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(downloadUrl);
+  }
+
+  return {
+    downloadQR,
+  };
+}

package/composables/useScheduleTask.ts

@@ -0,0 +1,89 @@
+export default function useScheduleTask() {
+  async function getScheduleTasks({
+    site = "",
+    search = "",
+    page = 1,
+    limit = 10,
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-tasks/site/${site}`,
+      {
+        method: "GET",
+        query: {
+          site,
+          search,
+          page,
+          limit,
+        },
+      },
+    );
+  }
+
+  function getScheduleTaskById(id: string) {
+    return useNuxtApp().$api<TScheduleTask>(
+      `/api/hygiene-schedule-tasks/id/${id}`,
+      {
+        method: "GET",
+      },
+    );
+  }
+
+  function createScheduleTask(payload: {
+    title: string;
+    time: string;
+    startDate?: string;
+    endDate?: string;
+    description?: string;
+    areas: { name: string; value: string }[];
+    site: string;
+  }) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-tasks/site/${payload.site}`,
+      {
+        method: "POST",
+        body: {
+          title: payload.title,
+          time: payload.time,
+          startDate: payload.startDate,
+          endDate: payload.endDate,
+          description: payload.description,
+          areas: payload.areas,
+        },
+      },
+    );
+  }
+
+  function updateScheduleTask(
+    id: string,
+    payload: {
+      title: string;
+      time: string;
+      startDate?: string;
+      endDate?: string;
+      description?: string;
+      areas: { name: string; value: string }[];
+    },
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-tasks/id/${id}`,
+      {
+        method: "PATCH",
+        body: {
+          title: payload.title,
+          time: payload.time,
+          startDate: payload.startDate,
+          endDate: payload.endDate,
+          description: payload.description,
+          areas: payload.areas,
+        },
+      },
+    );
+  }
+
+  return {
+    getScheduleTasks,
+    createScheduleTask,
+    updateScheduleTask,
+    getScheduleTaskById,
+  };
+}

package/composables/useScheduleTaskArea.ts

@@ -0,0 +1,85 @@
+export default function useScheduleTaskArea() {
+  async function getAreas({
+    site = "",
+    search = "",
+    page = 1,
+    limit = 10,
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/hygiene-schedule-task-area",
+      {
+        method: "GET",
+        query: {
+          site,
+          search,
+          page,
+          limit,
+        },
+      }
+    );
+  }
+
+  function createArea(name: string, site: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/hygiene-schedule-task-area",
+      {
+        method: "POST",
+        body: {
+          name,
+          site,
+        },
+      }
+    );
+  }
+
+  function updateArea(id: string, name: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-task-area/id/${id}`,
+      {
+        method: "PATCH",
+        body: { name },
+      }
+    );
+  }
+
+  function deleteArea(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-task-area/id/${id}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  function getAreaById(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-schedule-task-area/id/${id}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function uploadAreas(file: File, site: string) {
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("site", site);
+
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/hygiene-schedule-task-area/upload",
+      {
+        method: "POST",
+        body: formData,
+      }
+    );
+  }
+
+  return {
+    getAreas,
+    createArea,
+    updateArea,
+    deleteArea,
+    getAreaById,
+    uploadAreas,
+  };
+}

package/composables/useScheduleTaskPermission.ts

@@ -0,0 +1,68 @@
+export default function useScheduleTaskPermission() {
+  const { hasPermission } = usePermission();
+  const { permissions } = useCleaningPermission();
+  const { userAppRole } = useLocalSetup();
+
+  const canViewScheduleTasks = computed(() => {
+    if (!userAppRole.value) return true;
+    if (userAppRole.value.permissions.includes("*")) return true;
+    return hasPermission(
+      userAppRole.value,
+      permissions,
+      "schedule-task-mgmt",
+      "see-all-schedule-tasks"
+    );
+  });
+
+  const canCreateScheduleTask = computed(() => {
+    if (!userAppRole.value) return true;
+    if (userAppRole.value.permissions.includes("*")) return true;
+    return hasPermission(
+      userAppRole.value,
+      permissions,
+      "schedule-task-mgmt",
+      "add-schedule-task"
+    );
+  });
+
+  const canUpdateScheduleTask = computed(() => {
+    if (!userAppRole.value) return true;
+    if (userAppRole.value.permissions.includes("*")) return true;
+    return hasPermission(
+      userAppRole.value,
+      permissions,
+      "schedule-task-mgmt",
+      "update-schedule-task"
+    );
+  });
+
+  const canDeleteScheduleTask = computed(() => {
+    if (!userAppRole.value) return true;
+    if (userAppRole.value.permissions.includes("*")) return true;
+    return hasPermission(
+      userAppRole.value,
+      permissions,
+      "schedule-task-mgmt",
+      "delete-schedule-task"
+    );
+  });
+
+  const canViewScheduleTaskDetails = computed(() => {
+    if (!userAppRole.value) return true;
+    if (userAppRole.value.permissions.includes("*")) return true;
+    return hasPermission(
+      userAppRole.value,
+      permissions,
+      "schedule-task-mgmt",
+      "see-schedule-task-details"
+    );
+  });
+
+  return {
+    canViewScheduleTasks,
+    canCreateScheduleTask,
+    canUpdateScheduleTask,
+    canDeleteScheduleTask,
+    canViewScheduleTaskDetails,
+  };
+}

package/composables/useSiteEntryPassSettings.ts

@@ -1,7 +1,7 @@
 export default function useSiteEntryPassSettings() {
   function getBySiteId(siteId: string) {
     return useNuxtApp().$api<Record<string, any>>(
-      `/api/site-entrypass-settings/site/${siteId}`,
+      `/api/access-management/settings/${siteId}`,
       {
         method: "GET",
       }
@@ -17,9 +17,9 @@ export default function useSiteEntryPassSettings() {
     );
   }
 
-  function add(value: any) {
+  function save(value: any) {
     return useNuxtApp().$api<Record<string, any>>(
-      "/api/site-entrypass-settings",
+      "/api/access-management/settings",
       {
         method: "POST",
         body: value,
@@ -27,20 +27,9 @@ export default function useSiteEntryPassSettings() {
     );
   }
 
-  function updateBySiteId(value: any, siteId: string) {
-    return useNuxtApp().$api<Record<string, any>>(
-      "/api/site-entrypass-settings/site/" + siteId,
-      {
-        method: "PUT",
-        body: value,
-      }
-    );
-  }
-
   return {
     getBySiteId,
     getById,
-    add,
-    updateBySiteId,
+    save,
   };
 }

package/composables/useStock.ts

@@ -0,0 +1,45 @@
+export default function useStock() {
+  function getStockBySupply(
+    site: string,
+    supply: string,
+    page = 1,
+    search = "",
+    limit = 10
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-stocks/site/${site}/supply/${supply}`,
+      { method: "GET", query: { page, search, limit } }
+    );
+  }
+
+  function createStock(site: string, id: string, payload: TStockCreate) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-stocks/site/${site}/supply/${id}`,
+      {
+        method: "POST",
+        body: {
+          qty: payload.qty,
+          remarks: payload.remarks,
+        },
+      }
+    );
+  }
+
+  function requestItem(site: string, id: string, payload: TStockCreate) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/hygiene-request-items/site/${site}/supply/${id}`,
+      {
+        method: "POST",
+        body: {
+          qty: payload.qty,
+        },
+      }
+    );
+  }
+
+  return {
+    createStock,
+    getStockBySupply,
+    requestItem,
+  };
+}