@7365admin1/layer-common 1.10.10 → 1.11.1

package/components/SlideCardGroup.vue

@@ -0,0 +1,194 @@
+<template>
+  <v-sheet class="mx-auto">
+    <v-slide-group
+      class="pa-1"
+      show-arrows
+      :style="{ backgroundColor: '#FFFF' }"
+    >
+      <v-slide-group-item
+        v-for="(data, idx) in localDataFiles"
+        :key="idx"
+        v-slot="{ isSelected }"
+      >
+        <v-card
+          :class="['ma-1', isSelected && 'selected']"
+          width="150"
+          height="100"
+          @click="clickable && emit('onClickCarousel', data.path)"
+          class="rounded-lg border-thin"
+          border=" opacity-50 thin "
+        >
+          <v-btn
+            icon
+            variant="text"
+            size="x-small"
+            class="remove-btn pa-0 ma-0"
+            @click.stop="removeFile(data)"
+          >
+            <v-icon color="red" class="pa-0 ma-0" size="x-large"
+              >mdi-close-circle</v-icon
+            >
+          </v-btn>
+          <!-- File Icons -->
+
+          <v-img :src="data.url" cover height="200">
+            <template #placeholder>
+              <v-skeleton-loader height="100%" width="100%" />
+            </template>
+          </v-img>
+          <!-- <template v-if="url.type !== 'image'">
+            <div
+              class="d-flex fill-height align-center justify-center flex-column"
+            >
+              <v-icon
+                :icon="getFileIcon(url.type)"
+                size="64"
+                :color="getFileColor(url.type)"
+              ></v-icon>
+            </div>
+          </template>
+
+
+
+          <template v-else>
+            <v-img :src="url.path" cover height="200">
+              <template #placeholder>
+                <v-skeleton-loader height="100%" width="100%" />
+              </template>
+            </v-img>
+          </template> -->
+
+          <!-- Edit Button -->
+          <!-- <div v-if="imgEditable" class="edit-btn">
+            <v-btn
+              color="primary"
+              size="small"
+              @click.stop="onImageEdit(url.path, idx)"
+            >
+              <v-icon start>mdi-pencil</v-icon>
+              Edit
+            </v-btn>
+          </div>  -->
+        </v-card>
+      </v-slide-group-item>
+    </v-slide-group>
+  </v-sheet>
+
+  <DrawImage
+    v-if="isShowImageEdit"
+    :is-show-dialog="isShowImageEdit"
+    :image-url="imageUrl"
+    :image-idx="imageIdx"
+    @on-submit="onImageSubmitEdit"
+    @on-close-dialog="isShowImageEdit = false"
+  />
+</template>
+
+<script setup lang="ts">
+const { getImage } = useUtils();
+const { attachedFiles } = useUploadFiles();
+
+const emit = defineEmits<{
+  (event: "onClickCarousel", url: string): void;
+  (event: "onImageEdit", url: string, idx: number): void;
+  (event: "onFileRemove"): void;
+}>();
+
+const props = defineProps<{
+  clickable?: boolean;
+  imgEditable?: boolean;
+  dataFiles?: File[];
+}>();
+const localDataFiles = ref([...props.dataFiles]);
+const isShowImageEdit = ref(false);
+const imageUrl = ref("");
+const imageIdx = ref(0);
+
+const getFileType = (url: string) => {
+  const extension = url.split(".").pop()?.toLowerCase() || "";
+  if (["jpg", "jpeg", "png", "gif", "webp"].includes(extension)) return "image";
+  if (["pdf"].includes(extension)) return "pdf";
+  if (["doc", "docx"].includes(extension)) return "word";
+  return "other";
+};
+
+const getFileIcon = (type: string) => {
+  switch (type) {
+    case "pdf":
+      return "mdi-file-pdf-box";
+    case "word":
+      return "mdi-file-word-box";
+    default:
+      return "mdi-file-outline";
+  }
+};
+
+const getFileColor = (type: string) => {
+  switch (type) {
+    case "pdf":
+      return "red";
+    case "word":
+      return "blue";
+    default:
+      return "grey";
+  }
+};
+
+const onImageEdit = (url: string, idx: number) => {
+  isShowImageEdit.value = true;
+  imageUrl.value = url;
+  imageIdx.value = idx;
+};
+
+const onImageSubmitEdit = async (url: string, idx: number) => {
+  const response = await getImage(url);
+  if (!response) return;
+  attachedFiles.value[idx].data = new File(
+    [response],
+    attachedFiles.value[idx].data?.name
+  );
+  attachedFiles.value[idx].url = url;
+  isShowImageEdit.value = false;
+};
+
+const isImageFile = (type: string) => {
+  return type?.startsWith("image/");
+};
+
+watch(
+  () => props.dataFiles,
+  (newDataFiles) => {
+    localDataFiles.value = [...newDataFiles];
+  }
+);
+
+const removeFile = (file) => {
+  const index = localDataFiles.value.findIndex(
+    (dataFile) => dataFile.id === file.id
+  );
+
+  if (index !== -1) {
+    localDataFiles.value.splice(index, 1);
+    emit("onFileRemove", file);
+  }
+};
+</script>
+
+<style scoped>
+.edit-btn {
+  position: absolute;
+  bottom: 8px;
+  right: 8px;
+}
+
+.selected {
+  border: 2px solid var(--v-theme-primary);
+}
+
+.remove-btn {
+  position: absolute;
+  top: 0px;
+  right: 0px;
+  z-index: 2;
+}
+</style>

package/components/VisitorForm.vue

@@ -322,6 +322,7 @@ const { requiredRule, debounce, UTCToLocalTIme } = useUtils();
 const { getSiteById, getSiteLevels, getSiteUnits } = useSiteSettings();
 const { createVisitor, typeFieldMap, contractorTypes, getVisitors, updateVisitor } = useVisitor();
 const { getBySiteId: getEntryPassSettingsBySiteId } = useSiteEntryPassSettings();
+const { createVisitorPass } = useAccessManagement();
 const { findPersonByNRIC, findPersonByContact, searchCompanyList, findUsersByPlateNumber } = usePeople()
 const { getById: getUnitDataById } = useBuildingUnit()
 
@@ -354,7 +355,7 @@ const visitor = reactive<Partial<TVisitorPayload>>({
 
 const passType = ref("");
 const passQuantity = ref<number | null>(1);
-const passCards = ref<string[]>([]);
+const passCards = ref<{ _id: string; cardNo: string }[]>([]);
 
 const registeredUnitCompanyName = ref('N/A')
 
@@ -906,6 +907,21 @@ async function submit() {
   try {
     const res = await createVisitor(payload);
     if (res) {
+      if (prop.type === "contractor" && passType.value) {
+        const visitorId = res?._id;
+        const acmUrl = entryPassSettings.value?.data?.settings?.acm_url;
+        if (visitorId && acmUrl) {
+          await createVisitorPass({
+            site: prop.site,
+            unitId: visitor.unit!,
+            quantity: passQuantity.value ?? 1,
+            type: passType.value === "QR" ? "QRCODE" : passType.value,
+            nfcCards: passCards.value,
+            acm_url: acmUrl,
+            visitorId,
+          });
+        }
+      }
       if (createMore.value) {
         emit("done:more");
       } else emit("done");

package/composables/useAccessManagement.ts

@@ -111,8 +111,8 @@ export default function useAccessManagement() {
     site: string;
     userType: string;
     type: string;
-    accessLevel: string;
-    liftAccessLevel: string;
+    accessLevel: string | null;
+    liftAccessLevel: string | null;
   }) {
     return useNuxtApp().$api<Record<string, any>>(
       `/api/access-management/access-and-lift-cards`,
@@ -122,8 +122,8 @@ export default function useAccessManagement() {
           site: params.site,
           userType: params.userType,
           type: params.type,
-          accessLevel: params.accessLevel,
-          liftAccessLevel: params.liftAccessLevel,
+          ...(params.accessLevel != null ? { accessLevel: params.accessLevel } : {}),
+          ...(params.liftAccessLevel != null ? { liftAccessLevel: params.liftAccessLevel } : {}),
         },
       }
     );
@@ -135,8 +135,8 @@ export default function useAccessManagement() {
     type: string;
     site: string;
     userType: string;
-    accessLevel: string;
-    liftAccessLevel: string;
+    accessLevel: string | null;
+    liftAccessLevel: string | null;
   }) {
     return useNuxtApp().$api<Record<string, any>>(
       `/api/access-management/assign-access-card`,
@@ -261,6 +261,24 @@ export default function useAccessManagement() {
     );
   }
 
+  function createVisitorPass(payload: {
+    site: string;
+    unitId: string;
+    quantity: number;
+    type: string;
+    nfcCards: { _id: string; cardNo: string }[];
+    acm_url: string;
+    visitorId: string;
+  }) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/access-management/visitor`,
+      {
+        method: "POST",
+        body: payload,
+      }
+    );
+  }
+
   return {
     getDoorAccessLevels,
     getLiftAccessLevels,
@@ -280,5 +298,6 @@ export default function useAccessManagement() {
     getAllVisitorAccessCardsQrTags,
     getAvailableContractorCards,
     generateQrVms,
+    createVisitorPass,
   };
 }

package/composables/useComment.ts

@@ -0,0 +1,147 @@
+const { currentUser } = useLocalAuth();
+export default function useComment() {
+  class MComment implements TCommentChat {
+    _id?: string;
+    comment: string;
+    attachments?: TAttachment[];
+    createdBy: string;
+    workOrder: string;
+    createdAt?: string;
+    updatedAt?: string;
+    createdByName?: string;
+    createdByType?: string;
+    feedback?: string;
+    justify?: string | undefined;
+    seenByNames: string;
+
+    constructor(comment: Partial<TCommentChat> = {}) {
+      this._id = comment._id || "";
+      this.comment = comment.comment || "";
+      this.attachments = comment.attachments || [];
+      this.workOrder = comment.workOrder || "";
+      this.createdAt = comment.createdAt
+        ? comment.createdAt.toString()
+        : undefined;
+      this.updatedAt = comment.updatedAt || "";
+      this.createdBy = comment.createdBy || "";
+      this.createdByName = comment.createdByName || "";
+      this.createdByType = comment.createdByType || "";
+      this.justify = comment.justify || "";
+      this.feedback = comment.feedback || "";
+      this.seenByNames = comment.seenByNames ?? "";
+    }
+  }
+
+  const comment = useState("comment", () => new MComment());
+  const comments = useState("comments", (): TCommentChat[] => []);
+  const page = useState("commentPage", () => 1);
+  const itemsPerPage = useState("itemsPerPage", () => 2);
+  const search = useState("commentSearch", () => "");
+  const pageRange = useState("commentPageRange", () => "-- - -- of --");
+  const isCommentsLoaded = useState("isCommentsLoaded", () => false);
+
+  function addComment(payload: TCommentChat) {
+    delete payload._id;
+    return useNuxtApp().$api<{ value?: { message: string } }>(
+      "/api/comments/v1",
+      {
+        method: "POST",
+        body: payload,
+      }
+    );
+  }
+
+  function getCommentById(id: string) {
+    return useNuxtApp().$api(`/api/auth/comments/id/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function setComment(data?: TCommentChat) {
+    comment.value = new MComment(data);
+  }
+
+  const isInviteValid = useState("isInviteValid", () => false);
+
+  function getCommentsByWorkOrder(id: string) {
+    return useNuxtApp().$api(`/api/comments/v1/work-order/${id}`);
+  }
+
+  function getCommentsByWorkOrderId(id: string) {
+    return useNuxtApp().$api(`/api/comments/v1/work-order/${id}`);
+  }
+
+  function getCommentsByFeedBackId(id: string, type?: string) {
+    const commentFeedbackOrWOD =
+      type === "workOrder" ? "work-order" : "feedback";
+    return useNuxtApp().$api(`/api/comments/v1/${commentFeedbackOrWOD}/${id}`);
+  }
+
+  async function setComments(id: string, type?: string) {
+    try {
+      isCommentsLoaded.value = true;
+      const _comments = (await getCommentsByFeedBackId(
+        id,
+        type
+      )) as TCommentPaginated;
+
+      let updateSeenIds: any = [];
+
+      comments.value = _comments.items
+        .map((comment: any) => {
+          if (comment.createdBy === currentUser.value._id) {
+            comment.justify = "end";
+          } else {
+            comment.justify = "start";
+            if (
+              ((Array.isArray(comment.seenBy) &&
+                !comment.seenBy.includes(currentUser.value._id)) ||
+                !comment?.seenBy) &&
+              comment?._id
+            ) {
+              updateSeenIds.push(comment._id);
+            }
+          }
+          return comment;
+        })
+        .sort(
+          (firstComment: any, secondComment: any) =>
+            new Date(firstComment.createdAt).getTime() -
+            new Date(secondComment.createdAt).getTime()
+        );
+
+      if (Array.isArray(updateSeenIds) && updateSeenIds.length > 0) {
+        const seenBy = await updateSeenBy(updateSeenIds, currentUser.value._id);
+      }
+    } catch (error) {
+      console.log("error :", error);
+    } finally {
+      isCommentsLoaded.value = false;
+    }
+  }
+
+  function updateSeenBy(ids: string[], seenById: string) {
+    return useNuxtApp().$api(`/api/comments/v1/seen-by`, {
+      method: "PUT",
+      body: { seenById, ids },
+    });
+  }
+
+  return {
+    comment,
+    comments,
+    page,
+    itemsPerPage,
+    pageRange,
+    addComment,
+    setComment,
+    search,
+    isCommentsLoaded,
+    isInviteValid,
+    setComments,
+    getCommentById,
+    getCommentsByWorkOrderId,
+    updateSeenBy,
+    getCommentsByFeedBackId,
+  };
+}

package/composables/useFeedback.ts

@@ -1,36 +1,63 @@
 export default function useFeedback() {
-  const feedbacks = useState<Array<TFeedback>>("feedbacks", () => []);
+  class MFeedback implements TFeedback {
+    _id?: string;
+    description?: string;
+    subject?: string;
+    service?: string;
+    provider?: string | null;
+    location: string;
+    status?: string;
+    createdBy?: any;
+    createdByName?: string;
+    createdByEmail?: string;
+    attachments?: TAttachment[];
+    workOrders?: object[];
+    workOrder?: Record<string, any>;
+    organization: string;
+    site: string;
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    app: string;
+    assignee?: string;
+    assigneeName?: string;
+    assigneeInfo?: Record<string, any>;
+    statusUpdates?: any[];
+    attachedIR?: Array<Record<string, any>>;
+
+    constructor(feedback: Partial<TFeedback> = {}) {
+      this._id = feedback._id || "";
+      this.description = feedback.description || "";
+      this.subject = feedback.subject || "";
+      this.service = feedback.service || "";
+      this.status = feedback.status || "";
+      this.createdBy = feedback.createdBy || {};
+      this.provider = feedback.provider || null;
+      this.location = feedback.location || "";
+      this.attachments = feedback.attachments || [];
+      this.workOrders = feedback.workOrders || [];
+      this.workOrder = feedback.workOrder ?? {};
+      this.organization = feedback.organization || "";
+      this.site = feedback.site || "";
+      this.createdAt = "";
+      this.updatedAt = "";
+      this.app = feedback.app || "";
+      this.assignee = feedback.assignee || "";
+      this.assigneeName = feedback.assigneeName || "";
+      this.assigneeInfo = feedback.assigneeInfo ?? {};
+      this.statusUpdates = feedback.statusUpdates ?? [];
+      this.attachedIR = feedback.attachedIR ?? [];
+    }
+  }
+
+  const feedback = useState("feedback", () => new MFeedback());
+  const feedbacks = useState("feedbacks", (): TFeedback[] => []);
   const page = useState("page", () => 1);
   const pages = useState("pages", () => 0);
   const pageRange = useState("pageRange", () => "-- - -- of --");
 
-  const feedback = useState(
-    "feedback",
-    (): TFeedback => ({
-      _id: "",
-      attachments: [],
-      category: "",
-      categoryInfo: "",
-      subject: "",
-      location: "",
-      description: "",
-      createdBy: "",
-      createdAt: "",
-      updatedAt: "",
-      status: "pending",
-      metadata: {
-        serviceProvider: "",
-        assignee: "",
-        organization: "",
-        site: "",
-        name: "",
-        signature: "",
-        attachments: "",
-        completedAt: "",
-      },
-      workOrderNo: "",
-    })
-  );
+  function setFeedback(data?: TFeedback) {
+    feedback.value = data || new MFeedback();
+  }
 
   const { currentUser } = useLocalAuth();
 
@@ -89,7 +116,7 @@ export default function useFeedback() {
     });
   }
 
-  function createFeedback(payload: TFeedbackCreate) {
+  function createFeedback(payload: TFeedback) {
     return useNuxtApp().$api<Record<string, any>>("/api/feedbacks2", {
       method: "POST",
       body: payload,
@@ -135,8 +162,29 @@ export default function useFeedback() {
     );
   }
 
+  function addFeedBackWorkOrder(payload: any) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/feedbacks2/create-work-order",
+      {
+        method: "POST",
+        body: payload,
+      }
+    );
+  }
+
+  function updateStatusFeedback(payload: any) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/feedbacks2/status-update",
+      {
+        method: "POST",
+        body: payload,
+      }
+    );
+  }
+
   return {
     feedbacks,
+    setFeedback,
     feedback,
     page,
     pages,
@@ -148,5 +196,7 @@ export default function useFeedback() {
     deleteFeedback,
     updateFeedbackServiceProvider,
     updateStatusComplete,
+    addFeedBackWorkOrder,
+    updateStatusFeedback,
   };
 }

package/composables/usePDFDownload.ts

@@ -11,7 +11,7 @@ export default function(){
     const downloadUrl = window.URL.createObjectURL(res);
     const a = document.createElement("a");
     a.href = downloadUrl;
-    a.download = `SOA DOWNLOAD.pdf`; // Specify the file name
+    a.download = title; // Specify the file name
     document.body.appendChild(a);
     a.click(); // Trigger the download
     window.URL.revokeObjectURL(downloadUrl); // Clean up

package/composables/useWorkOrder.ts

@@ -1,34 +1,68 @@
 export default function useWorkOrder() {
+  class MWorkOrder implements TWorkOrder {
+    _id?: string;
+    description: string;
+    service: string;
+    subject: string | null;
+    provider: string | null;
+    providerName?: string;
+    status?: string;
+    assignee?: string | TUser;
+    assigneeName?: string;
+    attachments?: string[];
+    createdBy?: string | TUser;
+    createdByName?: string;
+    site: string;
+    organization: string;
+    location?: string;
+    comments?: TComment[];
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    feedback?: string;
+    statusUpdates?: any[];
+    prefix?: string;
+    noOfDigits?: any;
+    number?: number;
+    version?: number;
+    isHighPriority?: boolean;
+
+    constructor(workOrder: Partial<TWorkOrder> = {}) {
+      this._id = workOrder._id || "";
+      this.description = workOrder.description || "";
+      this.service = workOrder.service || "";
+      this.subject = workOrder.subject || null;
+      this.provider = workOrder.provider || null;
+      this.providerName = workOrder.providerName || "";
+      this.status = workOrder.status || "";
+      this.assignee = workOrder.assignee;
+      this.attachments = workOrder.attachments || [];
+      this.createdBy = workOrder.createdBy || "";
+      this.createdByName = workOrder.createdByName;
+      this.site = workOrder.site || "";
+      this.organization = workOrder.organization || "";
+      this.location = workOrder.location || "";
+      this.assigneeName = workOrder.assigneeName || "";
+      this.comments = workOrder.comments || [];
+      this.createdAt = "";
+      this.updatedAt = "";
+      this.feedback = workOrder.feedback || "";
+      this.prefix = workOrder.prefix || "";
+      this.noOfDigits = workOrder.noOfDigits || 1;
+      this.number = workOrder.number || 1;
+      this.version = workOrder.version || 0;
+      this.isHighPriority = workOrder.isHighPriority || false;
+    }
+  }
+
+  const workOrder = useState("workOrder", () => new MWorkOrder());
   const workOrders = useState<Array<TWorkOrder>>("workOrders", () => []);
   const page = useState("page", () => 1);
   const pages = useState("pages", () => 0);
   const pageRange = useState("pageRange", () => "-- - -- of --");
-  const workOrder = useState<TWorkOrder>("workOrder", () => ({
-    _id: "",
-    category: "",
-    categoryInfo: "",
-    subject: "",
-    description: "",
-    createdBy: "",
-    service: "",
-    provider: "",
-    organization: "",
-    site: "",
-    createdByName: "",
-    assignee: "",
-    location: "",
-    attachments: [],
-    feedback: "",
-    status: "",
-    createdAt: "",
-    updatedAt: "",
-    deletedAt: "",
-    highPriority: false,
-    block: "",
-    level: "",
-    unit: "",
-    serviceProvider: "",
-  }));
+
+  function setWorkOrder(data?: TWorkOrder) {
+    workOrder.value = data || new MWorkOrder();
+  }
 
   async function getWorkOrders({
     page = 1,
@@ -100,6 +134,7 @@ export default function useWorkOrder() {
 
   return {
     workOrders,
+    setWorkOrder,
     workOrder,
     page,
     pages,