@7365admin1/layer-common 1.11.7 → 1.11.8

package/components/StockCard.vue

@@ -165,7 +165,7 @@ const {
   pending: loading,
 } = await useLazyAsyncData(
   `get-stock-by-supply-id-${supplyId}-page-${page}`,
-  () => getStockBySupply(props.site, supplyId),
+  () => getStockBySupply(props.site, supplyId, page.value, "", 10, props.serviceType),
   {
     watch: [page, () => props.site, () => supplyId],
   }

package/components/TiptapEditorQr.vue

@@ -0,0 +1,73 @@
+<template>
+  <div>
+    <VCard class="mx-auto">
+      <VuetifyTiptap
+        v-model="content"
+        markdown-theme="github"
+        :maxHeight="maxHeight"
+        :minHeight="editorMinHeight"
+        :maxWidth="maxWidth"
+        :disabled="isViewMode"
+      />
+    </VCard>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({
+  initialContent: String,
+  maxHeight: String,
+  minHeight: String,
+  maxWidth: String,
+  storageKey: String,
+  clearOnLoad: Boolean,
+});
+
+const route = useRoute();
+
+const editorMinHeight = computed(() => {
+  const type = route.query?.type;
+  const isAddPage =
+    route.name?.toString().includes("add") || route.path?.includes("/add");
+  return ["edit", "add", "view"].includes(type as string) || isAddPage
+    ? props.minHeight
+    : "100px";
+});
+
+const isViewMode = computed(() => route.query?.type === "view");
+
+const content = ref(localStorage.getItem(props.storageKey) || "");
+
+onMounted(() => {
+  if (props.clearOnLoad) {
+    content.value = "";
+    localStorage.removeItem(props.storageKey);
+  }
+  if (props.initialContent !== undefined) {
+    content.value = props.initialContent;
+  }
+});
+
+watch(
+  () => props.initialContent,
+  (newVal) => {
+    content.value = newVal;
+  },
+);
+
+watch(
+  () => content.value,
+  (newVal) => {
+    updateContent();
+    localStorage.setItem(props.storageKey, newVal);
+  },
+);
+
+const emit = defineEmits(["content-updated"]);
+
+const updateContent = () => {
+  emit("content-updated", content.value);
+};
+</script>
+
+<style scoped></style>

package/composables/useKey.ts

@@ -0,0 +1,381 @@
+export interface ISearch {
+  name?: string;
+  passType: string;
+}
+
+export default function useKey() {
+  class MKeyLog implements TKeyLog {
+    _id?: string;
+    name: string;
+    codes?: string[];
+    code?: string;
+    site?: string;
+    organization?: string;
+    serviceProvider?: string;
+    passType?: string; // Visitor Pass || Pass Key
+    passId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    location?: string;
+    description?: string;
+    qty?: number;
+    nextNumber?: number;
+    prefix?: string;
+    keyNo?: number;
+    userType?: string;
+    updatedBy?: string;
+    constructor(
+      {
+        _id = "",
+        name = "",
+        codes = [],
+        code = "",
+        site = "",
+        organization = "",
+        serviceProvider = "",
+        passType = "",
+        passId = "",
+        createdAt,
+        updatedAt,
+        location = "",
+        description = "",
+        qty = 0,
+        nextNumber = "",
+        prefix = "",
+        keyNo,
+        userType,
+        updatedBy,
+      } = {} as TKeyLog
+    ) {
+      this._id = _id;
+      this.name = name;
+      this.codes = codes;
+      this.passType = passType;
+      this.passId = passId;
+      this.codes = codes;
+      this.codes = codes;
+      this.site = site;
+      this.organization = organization;
+      this.serviceProvider = serviceProvider;
+      this.createdAt = createdAt;
+      this.updatedAt = updatedAt;
+      this.location = location;
+      this.description = description;
+      this.qty = qty;
+      this.nextNumber = Number(nextNumber);
+      this.prefix = prefix;
+      this.keyNo = keyNo;
+      this.userType = userType;
+      this.updatedBy = updatedBy;
+    }
+  }
+
+  const keyLogApiUrl = "/api/keys/v1";
+  const passApiUrl = "/api/keys/v1/pass";
+  const keyApiUrl = "/api/keys/v1/keys";
+
+  const keyLog = useState("keyLog", (): TKeyLog => new MKeyLog());
+  const keyLogs = useState("keyLogs", (): TKeyLog[] => []);
+  const page = useState("keyPage", () => 1);
+  const pages = useState("keyPages", () => 1);
+  const pageLimit = useState("keyLimit", () => 10);
+  const pageRange = useState("keyPageRange", () => "-- - -- of --");
+  const search = useState("keySearch", () => "");
+  const isAdding = useState("isAdding", () => false);
+  const isTableLoading = useState("isTableLoading", () => false);
+  const isKeyLogValid = useState("isKeyLogValid", () => false);
+
+  const passList = useState("passList", (): TKeyLog[] => []);
+  const keyList = useState("keyList", (): TKeyLog[] => []);
+  const passTypes = useState(
+    "passTypes",
+    () =>
+      <any>[
+        { title: "Visitor Pass", value: "visitor-pass" },
+        { title: "Contractor Pass", value: "contractor-pass" },
+        { title: "Agent Pass", value: "agent-pass" },
+      ]
+  );
+  const passTypesStatus = useState("passTypesStatus", () => [
+    { title: "Available", value: "Available" },
+    { title: "In Use", value: "In Use" },
+    { title: "Damaged", value: "Damaged" },
+    { title: "Lost", value: "Lost" },
+    { title: "Deleted", value: "Deleted" },
+  ]);
+
+  async function onSearchKey(term: string) {
+    isTableLoading.value = true;
+    const data = useNuxtApp().$api<string | undefined>(keyLogApiUrl, {
+      method: "GET",
+      query: {
+        name: term,
+      },
+    });
+    isTableLoading.value = false;
+    return data;
+  }
+
+  function onFilterKeyByType(value: string) {
+    isTableLoading.value = true;
+    const data = useNuxtApp().$api<string | undefined>(keyLogApiUrl, {
+      method: "GET",
+      query: {
+        passType: value,
+      },
+    });
+    isTableLoading.value = false;
+    return data;
+  }
+
+  function setKey(data?: TKeyLog) {
+    console.log("data", data);
+    keyLog.value = data || new MKeyLog();
+  }
+
+  function addKeyLog(_keyLog: TKeyLog) {
+    isAdding.value = true;
+    delete _keyLog._id;
+    const data = useNuxtApp().$api<{
+      message: string | undefined;
+    }>(keyLogApiUrl, {
+      method: "POST",
+      body: JSON.stringify(_keyLog),
+    });
+    isAdding.value = false;
+    return data.message;
+  }
+
+  function getKeyById(id: string) {
+    const data = useNuxtApp().$api<TKeyLog | undefined>(
+      `${keyLogApiUrl}/${id}`,
+      {
+        method: "GET",
+      }
+    );
+    if (data && typeof data === "object") {
+      setKey(data);
+    }
+    return data;
+  }
+
+  function updateKeyById(id: string, payload: TKeyLog) {
+    payload.codes =
+      payload.codes instanceof Array && payload.codes.length > 0
+        ? payload.codes
+        : [];
+    const data = useNuxtApp().$api<{
+      message: { acknowledged: boolean };
+    }>(`${keyLogApiUrl}/${id}`, {
+      method: "PUT",
+      body: payload,
+    });
+    return data.message;
+  }
+
+  function deleteKeyById(id: string) {
+    const data = useNuxtApp().$api<{ message: TKeyLog }>(
+      `${keyLogApiUrl}/${id}`,
+      {
+        method: "DELETE",
+        query: {
+          _id: id,
+        },
+      }
+    );
+    return data;
+  }
+
+  function getKeysByKeyPageSearch({
+    page = 1,
+    search = "",
+    limit = 10,
+    site,
+    serviceProvider,
+    organization,
+    startDateTime,
+    endDateTime,
+  }: {
+    page?: number;
+    search?: string | ISearch;
+    limit?: number;
+    site?: string;
+    serviceProvider?: string;
+    organization?: string;
+    startDateTime?: string;
+    endDateTime?: string;
+  } = {}) {
+    /*
+      search here should accept
+      empty string or ISearch
+    */
+    return useNuxtApp().$api<TKeyLogResponse>(keyLogApiUrl, {
+      method: "GET",
+      query: {
+        page,
+        search,
+        limit,
+        site,
+        serviceProvider,
+        organization,
+        startDateTime,
+        endDateTime,
+      },
+    });
+  }
+
+  function setKeyLogs(
+    site?: string,
+    serviceProvider?: string,
+    organization?: string,
+    startDate?: string,
+    endDate?: string
+  ) {
+    try {
+      isTableLoading.value = true;
+      const _keyLogs = getKeysByKeyPageSearch({
+        page: page.value,
+        search: search.value,
+        limit: pageLimit.value,
+        site: site,
+        serviceProvider: serviceProvider,
+        organization: organization,
+      });
+      keyLogs.value = _keyLogs.items;
+      pageRange.value = _keyLogs.pageRange;
+      pages.value = _keyLogs.pages;
+      isTableLoading.value = false;
+    } catch (error) {
+      keyLogs.value = [];
+      pageRange.value = "-- - -- of --";
+      isTableLoading.value = false;
+    }
+  }
+
+  const canNextPage = computed(() => pages.value > page.value);
+  function nextPage(
+    { site, serviceProvider, startDate, endDate } = {} as {
+      site?: string;
+      serviceProvider?: string;
+      startDate?: string;
+      endDate?: string;
+    }
+  ) {
+    page.value++;
+    setKeyLogs(site, serviceProvider, undefined, startDate, endDate);
+  }
+
+  const canPrevPage = computed(() => page.value <= 1);
+  function prevPage(
+    { site, serviceProvider, startDate, endDate } = {} as {
+      site?: string;
+      serviceProvider?: string;
+      startDate?: string;
+      endDate?: string;
+    }
+  ) {
+    page.value--;
+    setKeyLogs(site, serviceProvider, undefined, startDate, endDate);
+  }
+
+  function getPassList(
+    { site, serviceProvider, passType } = {} as {
+      site?: string;
+      serviceProvider?: string;
+      passType?: string;
+    }
+  ) {
+    const response = useNuxtApp().$api<TKeyLog[]>(passApiUrl, {
+      method: "GET",
+      query: {
+        site,
+        serviceProvider,
+        passType,
+      },
+    });
+    passList.value = response;
+  }
+
+  function getKeyList(
+    { site, serviceProvider } = {} as {
+      site?: string;
+      serviceProvider?: string;
+    }
+  ) {
+    const response = useNuxtApp().$api<TKeyLog[]>(keyApiUrl, {
+      method: "GET",
+      query: {
+        site,
+        serviceProvider,
+      },
+    });
+    keyList.value = response;
+  }
+
+  function getCountTotalKeys(
+    { site, userType } = {} as {
+      site?: string;
+      userType?: string;
+    }
+  ) {
+    const response = useNuxtApp().$api<TKeyLog[]>(keyLogApiUrl, {
+      method: "PATCH",
+      body: {
+        site,
+        userType,
+      },
+    });
+    keyList.value = response;
+    console.log("keyList", keyList.value);
+    return response;
+  }
+
+  async function getKeyWithSequence(
+    { site, _id } = {} as {
+      site?: string;
+      _id?: string;
+    }
+  ) {
+    const response = useNuxtApp().$api<TKeyLog[]>(keyLogApiUrl, {
+      method: "PUT",
+      query: {
+        site,
+        _id,
+      },
+    });
+    keyList.value = response;
+    console.log("keyList", keyList.value);
+    return response;
+  }
+  return {
+    onSearchKey,
+    onFilterKeyByType,
+    deleteKeyById,
+    updateKeyById,
+    getKeyById,
+    addKeyLog,
+    setKeyLogs,
+    setKey,
+    nextPage,
+    prevPage,
+    page,
+    pages,
+    pageRange,
+    pageLimit,
+    canNextPage,
+    canPrevPage,
+    keyLogs,
+    keyLog,
+    isTableLoading,
+    isAdding,
+    isKeyLogValid,
+    getPassList,
+    getKeyList,
+    passList,
+    keyList,
+    passTypes,
+    passTypesStatus,
+    getCountTotalKeys,
+    getKeyWithSequence,
+  };
+}