@feedmepos/mf-hrm-portal 1.1.0-dev → 1.1.2-dev

package/dist/employee-jH7EJnhi.js

@@ -0,0 +1,172 @@
+import { d as v } from "./dayjs.min-DVb8OkTL.js";
+import { defineStore as T, storeToRefs as _ } from "pinia";
+import { ref as h } from "vue";
+import { useCoreStore as U } from "@feedmepos/mf-common";
+import { b as o, g as n, t as $, k as b, s as I } from "./index-CicR1-Jp.js";
+import { u as S } from "./useAppStore-RzLLN5d9.js";
+const c = {
+  async readEmployees() {
+    return n(await o().get("/pos-users"));
+  },
+  async createEmployee(e) {
+    return n(await o().post("/pos-users", e));
+  },
+  async createMasterEmployee(e) {
+    return n(await o().post("/pos-users/master-user", e));
+  },
+  async migrateToMasterEmployee(e, s) {
+    return n(await o().put(`/pos-users/migrate/${e}`, s));
+  },
+  async updateEmployee(e, s) {
+    return n(await o().put(`/pos-users/${e}`, s));
+  },
+  async updateMasterEmployee(e, s) {
+    return n(await o().put(`/pos-users/master-user/${e}`, s));
+  },
+  async deleteEmployee(e) {
+    return n(
+      await o().put(`/pos-users/${e._id}`, {
+        user: e,
+        roles: []
+      })
+    );
+  },
+  async deleteMasterEmployee(e) {
+    return n(
+      await o().put(`/pos-users/master-user/${e._id}`, {
+        user: e,
+        roles: []
+      })
+    );
+  },
+  async generateEmployeePasscode() {
+    return `${n(await o().get("/pos-users/generate-passcode"))}`;
+  },
+  async syncUsersMeta() {
+    await o().post("/pos-users/create-users-meta");
+  }
+};
+async function i(e) {
+  const s = S().roles.value, { restaurants: d } = U(), w = e.reduce((l, m) => {
+    var f;
+    const { _id: E, restaurantId: y } = m, p = l.findIndex((r) => r._id === E), M = ((f = d.value.find((r) => r._id === y)) == null ? void 0 : f.profile.name) || "", u = s.find((r) => r._id === m.role), g = {
+      restaurantId: y,
+      restaurantName: M,
+      roleId: (u == null ? void 0 : u._id) || "",
+      roleName: (u == null ? void 0 : u.name) || ""
+    };
+    return p < 0 ? l.push({
+      ...m,
+      since: v(b(E)).format("DD/MM/YYYY"),
+      restaurants: [g]
+    }) : l[p].restaurants.some((r) => r.restaurantId === y) || (l[p].restaurants = I([...l[p].restaurants, g], {
+      selector: "restaurantName"
+    })), l;
+  }, []);
+  return I(w, { selector: "name" });
+}
+const x = T("employee", () => {
+  const e = h([]), s = h(!1), d = h([]);
+  async function w() {
+    try {
+      s.value = !0;
+      const r = await c.readEmployees();
+      e.value = await i(r);
+    } catch (r) {
+      console.log("Error reading employees:", r);
+    } finally {
+      s.value = !1;
+    }
+  }
+  async function l(r) {
+    try {
+      const t = await c.createEmployee(r);
+      e.value = await i(t);
+    } catch (t) {
+      console.log("Error creating employee:", t);
+    }
+  }
+  async function m(r, t) {
+    try {
+      const a = await c.updateEmployee(r, t);
+      e.value = await i(a);
+    } catch (a) {
+      console.log("Error updating employee:", a);
+    }
+  }
+  async function E(r) {
+    try {
+      const t = await c.deleteEmployee(r);
+      e.value = await i(t);
+    } catch (t) {
+      console.log("Error deleting employee:", t);
+    }
+  }
+  async function y(r) {
+    try {
+      const t = await c.deleteMasterEmployee(r);
+      e.value = await i(t);
+    } catch (t) {
+      console.log("Error deleting master employee:", t);
+    }
+  }
+  async function p(r) {
+    try {
+      const t = await c.createMasterEmployee(r);
+      e.value = await i(t);
+    } catch (t) {
+      console.log("Error creating master employee:", t);
+    }
+  }
+  async function M(r, t) {
+    try {
+      const a = await c.updateMasterEmployee(r, t);
+      e.value = await i(a);
+    } catch (a) {
+      console.log("Error updating master employee:", a);
+    }
+  }
+  async function u(r, t) {
+    try {
+      const a = await c.migrateToMasterEmployee(r, t);
+      e.value = await i(a);
+    } catch (a) {
+      console.log("Error migrating to master employee:", a);
+    }
+  }
+  async function g() {
+    try {
+      d.value = await $.readTeamMemberPosUserIds();
+    } catch (r) {
+      console.log("Error reading team member pos user ids:", r);
+    }
+  }
+  async function f() {
+    await c.syncUsersMeta();
+  }
+  return {
+    employees: e,
+    restrictEmployeeIds: d,
+    isLoading: s,
+    readEmployees: w,
+    createEmployee: l,
+    updateEmployee: m,
+    deleteEmployee: E,
+    createMasterEmployee: p,
+    updateMasterEmployee: M,
+    deleteMasterEmployee: y,
+    migrateToMasterUser: u,
+    readTeamMemberPosUserIds: g,
+    syncUsersMeta: f
+  };
+}), R = () => {
+  const e = x();
+  return {
+    ...e,
+    ..._(e)
+  };
+};
+export {
+  c as E,
+  R as u
+};

package/dist/helpers/permission-set.d.ts

@@ -0,0 +1,32 @@
+import type { InheritedPermission, IFdtoPermissionSet } from '@/types/permission-set';
+import type { FdoPermissionRule } from '@feedmepos/core/entity';
+/**
+ * Transform permission sets by grouping role names by collection IDs for a specific field
+ * @param permissionSets - Array of permission sets with their permissions
+ * @param field - The field name to extract collection IDs from (e.g., 'restaurantId', 'warehouseId')
+ * @param resource - The collection of resource (e.g., list of restaurants, warehouses)
+ * @returns Array of objects containing collection ID and associated role names
+ */
+export declare function transformByCollection(permissionSets: IFdtoPermissionSet[], field: string, resourceIds: string[]): InheritedPermission[];
+/**
+ * Combine base permissions (permissions set) with user permissions
+ * @param basePermissions - Base permissions
+ * @param overridePermissions - User permissions
+ * @returns Combined permissions
+ * Return combined result with below criteria:
+ * - If base has it and user doesn't, return base permission with { inverted: true }
+ * - If user has it and base doesn't, return user permission
+ * - If base and user has it, nothing return
+ * For permission with conditions (collection: warehouses, roles, restaurants)
+ * - If base conditions different from user conditions, return rule with { inverted: true } and conditions on collection ids to be denied
+ * - If base has conditions and user doesn't, return base with { inverted: true } without conditions, essentially denied all access
+ * - If user has conditions and base doesn't, return user's rule (user added)
+ */
+export declare function getOverridePermissions(basePermissions: FdoPermissionRule[], overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];
+/**
+ * Combine base permissions with override permissions to get effective permissions
+ * @param basePermissions - Base permissions from permission sets
+ * @param overridePermissions - Override permissions from permission user
+ * @returns - Combined effective permissions
+ */
+export declare function getEffectivePermissions(basePermissions: FdoPermissionRule[], overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];

package/dist/helpers/portal-user.d.ts

@@ -0,0 +1,8 @@
+import type { FTeamMember, IFdtoPortalUser } from '@/types/team';
+/**
+ * Combine portal user data with permission assignment and return as team member data
+ * @param doc
+ * @param options
+ * @returns
+ */
+export declare function portalUserToTeamMember(doc: IFdtoPortalUser): FTeamMember;

package/dist/helpers/rule.d.ts

@@ -14,15 +14,16 @@ export declare function ruleExtension(rule: FdoPermissionRule): {
     fields?: string[] | null | undefined;
     inverted?: boolean | null | undefined;
     subject: string;
-    actions: ("delete" | "update" | "create" | "read" | "manage")[];
+    actions: ("update" | "create" | "read" | "delete" | "manage")[];
 };
 export declare function getMaxDiscount(rules: FdoPermissionRule[]): number;
-export declare function getManagableRestaurantIds(rules: RawRule[]): string[] | null;
+export declare function getManagableRestaurantIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function hasAdminRule(rules: FdoPermissionRule[]): boolean;
-export declare function usableRoleIds(rules: RawRule[]): string[] | null;
+export declare function usableRoleIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function fromValue(values: string[], maxDiscountPercentage: number): {
     subject: string;
     actions: ("delete" | "update" | "create" | "read" | "manage")[];
     conditions: object;
 }[];
 export declare function toRule(v: string): Rule;
+export declare function mapAndSortPermissions(permissions: Array<FdoPermissionRule | RawRule>): string[];