@iservice365/layer-common 0.1.0 → 0.2.1

package/composables/useCommonPermission.ts

@@ -0,0 +1,130 @@
+export function useCommonPermissions() {
+  const invitationPermissions: Record<string, TPermission> = {
+    "create-invitation": {
+      check: true,
+      description:
+        "Allows the user to create a new invitation for a invitation to join the organization.",
+    },
+    "view-invitations": {
+      check: true,
+      description:
+        "Allows the user to view the list of all invitation in the organization.",
+    },
+    "cancel-invitation": {
+      check: true,
+      description:
+        "Allows the user to permanently remove a invitation from the organization.",
+    },
+  };
+
+  const memberPermissions: Record<string, TPermission> = {
+    "view-members": {
+      check: true,
+      description:
+        "Allows the user to view the list of all members in the organization.",
+    },
+    "assign-member-role": {
+      check: true,
+      description:
+        "Allows the user to assign a specific role to a member in the organization.",
+    },
+    "suspend-member": {
+      check: true,
+      description: "Allows the user to suspend a member's account temporarily.",
+    },
+    "activate-member": {
+      check: true,
+      description:
+        "Allows the user to reactivate a suspended member's account.",
+    },
+    "delete-member": {
+      check: true,
+      description:
+        "Allows the user to permanently remove a member from the organization.",
+    },
+  };
+
+  const rolePermissions: Record<string, TPermission> = {
+    "add-role": {
+      check: true,
+      description: "Allows the user to add a new role to the system.",
+    },
+    "see-all-roles": {
+      check: true,
+      description: "Allows the user to view the list of all roles.",
+    },
+    "see-role-details": {
+      check: true,
+      description: "Allows the user to view the details of a specific role.",
+    },
+    "delete-role": {
+      check: true,
+      description:
+        "Allows the user to remove a role from the system permanently.",
+    },
+    "update-role": {
+      check: true,
+      description: "Allows the user to update the details of an existing role.",
+    },
+  };
+
+  const feedbackPermissions: Record<string, TPermission> = {
+    "add-feedback": {
+      check: true,
+      description: "Allows the user to create a new feedback.",
+    },
+    "see-all-feedback": {
+      check: true,
+      description: "Allows the user to view the list of all feedback.",
+    },
+    "see-feedback-details": {
+      check: true,
+      description:
+        "Allows the user to view the details of a specific feedback.",
+    },
+    "delete-feedback": {
+      check: true,
+      description:
+        "Allows the user to remove a feedback from the system permanently.",
+    },
+    "update-feedback": {
+      check: true,
+      description:
+        "Allows the user to update the details of an existing feedback.",
+    },
+  };
+
+  const workOrderPermissions: Record<string, TPermission> = {
+    "create-work-order": {
+      check: true,
+      description: "Allows the user to create a new work order.",
+    },
+    "see-all-work-orders": {
+      check: true,
+      description: "Allows the user to view the list of all work orders.",
+    },
+    "see-work-order-details": {
+      check: true,
+      description:
+        "Allows the user to view the details of a specific work order.",
+    },
+    "delete-work-order": {
+      check: true,
+      description:
+        "Allows the user to remove a work order from the system permanently.",
+    },
+    "update-work-order": {
+      check: true,
+      description:
+        "Allows the user to update the details of an existing work order.",
+    },
+  };
+
+  return {
+    invitationPermissions,
+    memberPermissions,
+    rolePermissions,
+    feedbackPermissions,
+    workOrderPermissions,
+  };
+}

package/composables/useCustomer.ts

@@ -0,0 +1,113 @@
+export default function useCustomer() {
+  const customers = ref<Array<TCustomer>>([]);
+  const page = ref(1);
+  const pages = ref(0);
+  const pageRange = ref("-- - -- of --");
+  const search = ref("");
+
+  const customer = useState(
+    "customer",
+    (): TCustomer => ({
+      _id: "",
+      name: "",
+      orgId: "",
+      customerOrgId: "",
+      createdAt: "",
+      updatedAt: "",
+    })
+  );
+
+  async function getCustomers({
+    page = 1,
+    search = "",
+    limit = 10,
+    organization,
+    status = "active",
+    sort = "",
+    order = "asc",
+  }: {
+    page?: number;
+    search?: string;
+    limit?: number;
+    organization?: string;
+    status?: string;
+    sort?: string;
+    order?: string;
+  } = {}) {
+    const { currentUser } = useLocalAuth();
+
+    const orgId = organization || currentUser.value?.defaultOrg;
+
+    try {
+      const response = await useNuxtApp().$api<TCustomerPaginatedResponse>(
+        `/api/customers/organization/${orgId}/status/${status}`,
+        {
+          method: "GET",
+          query: { page, search, limit, sort, order },
+        }
+      );
+
+      customers.value = response.items;
+      pages.value = response.pages;
+      pageRange.value = response.pageRange;
+    } catch (err) {
+      console.error("Error fetching customers:", err);
+    }
+  }
+
+  function createCustomer(payload: TCustomerCreate) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/customers`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function deleteCustomer(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/customers/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  function getCustomerById(id: string) {
+    return useNuxtApp().$api<TCustomer>(`/api/customers/${id}`, {
+      method: "GET",
+    });
+  }
+
+  async function getAll({
+    page = 1,
+    search = "",
+    limit = 10,
+    org = "",
+    status = "active",
+    sort = "",
+    order = "asc",
+  }: {
+    page?: number;
+    search?: string;
+    limit?: number;
+    org?: string;
+    status?: string;
+    sort?: string;
+    order?: string;
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/customers", {
+      method: "GET",
+      query: { page, search, limit, sort, order, status, org },
+    });
+  }
+
+  return {
+    customers,
+    customer,
+    page,
+    pages,
+    pageRange,
+    search,
+    getCustomers,
+    deleteCustomer,
+    createCustomer,
+    getCustomerById,
+    getAll,
+  };
+}

package/composables/useFeedback.ts

@@ -0,0 +1,117 @@
+export default function useFeedback() {
+  const feedbacks = useState<Array<TFeedback>>("feedbacks", () => []);
+  const page = useState("page", () => 1);
+  const pages = useState("pages", () => 0);
+  const pageRange = useState("pageRange", () => "-- - -- of --");
+
+  const feedback = useState(
+    "feedback",
+    (): TFeedback => ({
+      _id: "",
+      attachments: [],
+      category: "",
+      subject: "",
+      location: "",
+      description: "",
+      createdBy: "",
+      createdAt: "",
+      updatedAt: "",
+      status: "pending",
+      metadata: {
+        serviceProvider: "",
+        assignee: "",
+        organization: "",
+        site: "",
+        name: "",
+        signature: "",
+        attachments: "",
+        completedAt: "",
+      },
+    })
+  );
+
+  async function getFeedbacks({
+    page = 1,
+    organization = "",
+    site = "",
+    status = "to-do",
+    search = "",
+    limit = 10,
+    from = "",
+  } = {}) {
+    try {
+      return useNuxtApp().$api<Record<string, any>>(
+        `/api/feedbacks/organization/${organization}/site/${site}/status/${status}`,
+        {
+          method: "GET",
+          query: { page, search, limit, from },
+        }
+      );
+    } catch (err) {
+      console.error("Error fetching feedbacks:", err);
+    }
+  }
+
+  function getFeedbackById(id: string) {
+    return useNuxtApp().$api<TFeedback>(`/api/feedbacks/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function createFeedback(payload: TFeedbackCreate) {
+    return useNuxtApp().$api<Record<string, any>>("/api/feedbacks", {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function updateFeedback(id: string, payload: TFeedbackUpdate) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/feedbacks/${id}`, {
+      method: "PUT",
+      body: payload,
+    });
+  }
+
+  function deleteFeedback(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/feedbacks/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  function updateFeedbackServiceProvider(id: string, serviceProvider: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/feedbacks/${id}/service-provider`,
+      {
+        method: "PATCH",
+        body: {
+          serviceProvider,
+        },
+      }
+    );
+  }
+
+  function updateStatusComplete(id: string, payload: TFeedbackStatusComplete) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/feedbacks/${id}/status-complete`,
+      {
+        method: "PUT",
+        body: payload,
+      }
+    );
+  }
+
+  return {
+    feedbacks,
+    feedback,
+    page,
+    pages,
+    pageRange,
+    getFeedbacks,
+    getFeedbackById,
+    createFeedback,
+    updateFeedback,
+    deleteFeedback,
+    updateFeedbackServiceProvider,
+    updateStatusComplete,
+  };
+}

package/composables/useFile.ts

@@ -0,0 +1,40 @@
+export default function useFile() {
+  const baseUrl =
+    "https://seven365-storage.sgp1.cdn.digitaloceanspaces.com/dev";
+
+  function addFile(file: File | null) {
+    if (!file) {
+      throw new Error("File not found.");
+    }
+
+    const formData = new FormData();
+    formData.append("file", file);
+
+    return $fetch<Record<string, any>>(
+      "https://storage-api-dev-new-wv7cx.ondigitalocean.app/api/files/upload/v2",
+      {
+        method: "POST",
+        body: formData,
+      }
+    );
+  }
+
+  function getFileUrl(id: string) {
+    return `${baseUrl}/${id}`;
+  }
+
+  function deleteFile(attachmentId: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/files/${attachmentId}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  return {
+    addFile,
+    deleteFile,
+    getFileUrl,
+  };
+}

package/composables/useInvoice.ts

@@ -0,0 +1,18 @@
+export default function useInvoice() {
+  function getBySubscriptionId({ search = "", id = "", page = 1 } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/invoices/subscription/${id}`,
+      {
+        method: "GET",
+        params: {
+          search,
+          page,
+        },
+      }
+    );
+  }
+
+  return {
+    getBySubscriptionId,
+  };
+}

package/composables/useLocal.ts

@@ -9,26 +9,46 @@ export default function useLocal() {
 
   const drawer = useState("drawer", () => true);
 
-  const { APP_RECAP } = appConfig;
+  const { APP_ACCOUNT, APP_ORG } = appConfig;
 
   const apps = computed(() => {
     return [
       {
-        title: "RECAP",
+        title: "Account",
         icon: "mdi-account-group",
-        link: APP_RECAP as string,
-        landingPage: "requests/status/draft",
+        link: APP_ACCOUNT as string,
+        landingPage: "home",
+      },
+      {
+        title: "Organization",
+        icon: "mdi-account-group",
+        link: APP_ORG as string,
+        landingPage: "/",
       },
     ];
   });
 
   const headerSearch = useState("headerSearch", () => "");
 
+  const natureOfBusiness = [
+    {
+      title: "Property Management Agency",
+      value: "property_management_agency",
+    },
+    { title: "Security Agency", value: "security_agency" },
+    {
+      title: "Mechanical and Electrical Services",
+      value: "mechanical_electrical_services",
+    },
+    { title: "Cleaning Services", value: "cleaning_services" },
+  ];
+
   return {
     cookieConfig,
     getUserFromCookie,
     drawer,
     apps,
     headerSearch,
+    natureOfBusiness,
   };
 }

package/composables/useLocalAuth.ts

@@ -1,6 +1,38 @@
 export default function useLocalAuth() {
   const { cookieConfig } = useRuntimeConfig().public;
 
+  const currentUser = useState<TUser | null>("currentUser", () => null);
+
+  function authenticate() {
+    // Get access token from cookies
+    const accessToken = useCookie("accessToken", cookieConfig).value;
+
+    if (!accessToken) {
+      // Redirect to login page if no access token
+      navigateTo({ name: "index" });
+    }
+
+    const user = useCookie("user", cookieConfig).value;
+
+    const { data: getCurrentUserReq, error: getCurrentUserErr } =
+      useLazyAsyncData("getCurrentUser", () =>
+        useNuxtApp().$api<TUser>(`/api/users/id/${user}`)
+      );
+
+    watchEffect(() => {
+      if (getCurrentUserReq.value) {
+        currentUser.value = getCurrentUserReq.value;
+      }
+    });
+
+    watchEffect(() => {
+      if (getCurrentUserErr.value) {
+        // Redirect to login page if user authentication fails
+        navigateTo({ name: "index" });
+      }
+    });
+  }
+
   async function login({ email = "", password = "" }) {
     return useNuxtApp().$api<Record<string, any>>("/api/auth", {
       method: "POST",
@@ -8,15 +40,13 @@ export default function useLocalAuth() {
     });
   }
 
-  function setToken({ refreshToken = "", accessToken = "", user = "" }) {
-    useCookie("accessToken", cookieConfig).value = accessToken;
-    useCookie("refreshToken", cookieConfig).value = refreshToken;
+  function setSession({ sid = "", user = "" }) {
+    useCookie("sid", cookieConfig).value = sid;
     useCookie("user", cookieConfig).value = user;
   }
 
   function clearCookies() {
-    useCookie("accessToken", cookieConfig).value = null;
-    useCookie("refreshToken", cookieConfig).value = null;
+    useCookie("sid", cookieConfig).value = null;
     useCookie("user", cookieConfig).value = null;
     useCookie("organization", cookieConfig).value = null;
   }
@@ -36,8 +66,6 @@ export default function useLocalAuth() {
     }
   }
 
-  const currentUser = useState((): TUser | null => null);
-
   async function getCurrentUser() {
     const user = useCookie("user", cookieConfig).value;
     if (!user) return null;
@@ -54,12 +82,14 @@ export default function useLocalAuth() {
     }
 
     try {
-      const response = await useNuxtApp().$api("/api/auth/forget-password", {
-        method: "POST",
-        body: JSON.stringify({ email }),
-        headers: { "Content-Type": "application/json" },
-      });
-      return response;
+      return await useNuxtApp().$api<Record<string, any>>(
+        "/api/auth/forget-password",
+        {
+          method: "POST",
+          body: JSON.stringify({ email }),
+          headers: { "Content-Type": "application/json" },
+        }
+      );
     } catch (error) {
       console.error("Error in password reset request:", error);
       throw error;
@@ -72,11 +102,14 @@ export default function useLocalAuth() {
     passwordConfirmation: string
   ) {
     try {
-      return await useNuxtApp().$api("/api/auth/reset-password", {
-        method: "POST",
-        body: JSON.stringify({ otp, newPassword, passwordConfirmation }),
-        headers: { "Content-Type": "application/json" },
-      });
+      return await useNuxtApp().$api<Record<string, any>>(
+        "/api/auth/reset-password",
+        {
+          method: "POST",
+          body: JSON.stringify({ otp, newPassword, passwordConfirmation }),
+          headers: { "Content-Type": "application/json" },
+        }
+      );
     } catch (error) {
       console.error("Error resetting password:", error);
       throw error;
@@ -84,20 +117,29 @@ export default function useLocalAuth() {
   }
 
   function verify(id: string) {
-    return useNuxtApp().$api<TKeyValuePair>(`/api/auth/verify/${id}`, {
+    return useNuxtApp().$api<Record<string, any>>(`/api/auth/verify/${id}`, {
       method: "GET",
     });
   }
 
+  function signUp(email: string, referral: string) {
+    return useNuxtApp().$api<Record<string, any>>("/api/auth/sign-up", {
+      method: "POST",
+      body: { email, referral },
+    });
+  }
+
   return {
+    authenticate,
     login,
+    setSession,
     logout,
     clearCookies,
     getCurrentUser,
-    setToken,
     forgotPassword,
     resetPassword,
     currentUser,
     verify,
+    signUp,
   };
 }

package/composables/useLocalSetup.ts

@@ -0,0 +1,13 @@
+export function useLocalSetup() {
+  const userAppRole = useState<Record<string, any> | null>(
+    "userAppRole",
+    () => null
+  );
+
+  const id = useState<string | null>("memberShipOrgId", () => null);
+
+  return {
+    userAppRole,
+    id,
+  };
+}