@feedmepos/mf-hrm-portal 1.1.6-dev → 2.0.0

package/dist/employee-B3jBmvNJ.js

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

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

@@ -0,0 +1,69 @@
+import type { InheritedPermission, IFdtoPermissionSet } from '@/types/permission-set';
+import type { FdoPermissionRule } from '@feedmepos/core/entity';
+/**
+ * Recursively collect all permission sets following permissionSetIds links.
+ * Returns a flat, deduplicated list in depth-first order (parent before children).
+ * Cycle-safe via the visited set.
+ */
+export declare function collectAllPermissionSets(setIds: string[], allSets: IFdtoPermissionSet[], visited?: Set<string>): IFdtoPermissionSet[];
+/**
+ * Compute the effective permissions from a list of permission sets.
+ *
+ * Unlike a raw `mergePermissionSet().map(...)`, this correctly handles sets that store
+ * override diffs (inverted rules): it first merges all grants and denials from the sets,
+ * then applies the denials on top of the grants via `getEffectivePermissions`, producing a
+ * clean list of effective grants only. This ensures that subjects removed by a child set's
+ * inversion are not incorrectly shown as granted.
+ */
+export declare function mergeToEffectivePermissions(sets: IFdtoPermissionSet[]): FdoPermissionRule[];
+/**
+ * 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[];
+export declare function materializeSystemPermissionSetOverrides(overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];
+/**
+ * Strip positive rules whose subject would be re-injected by system permission set expansion.
+ * These need not be persisted to DB — expansion re-adds them at runtime.
+ * Inverted rules (explicit user denials) are always preserved.
+ */
+export declare function stripSystemExpandedPositives(permissions: 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[];
+/**
+ * Compute the initial permissions for the permission editor.
+ *
+ * Like `getEffectivePermissions`, but also preserves "orphaned" inverted rules — denials whose
+ * subject is NOT present in any base permission set (i.e. they target system-expanded subjects,
+ * not permission-set-inherited subjects). These denials seed `visitedSetIds` in
+ * `expandWithSystemPermissionSets` to block runtime re-expansion of system sets that the user
+ * explicitly unchecked. Without them the editor would initialise without the denial guard and
+ * those subjects would reappear as checked the next time the form opens.
+ *
+ * Inverted rules whose subject IS in base are handled correctly by `getEffectivePermissions`
+ * already (they cancel the inherited grant) and do not need special treatment here.
+ */
+export declare function getEditorPermissions(basePermissions: FdoPermissionRule[], customPermissions: 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

@@ -1,7 +1,7 @@
 import type { RawRule } from '@casl/ability';
 import { F_RULE_SUBJECT, type FdoPermissionRule } from '@feedmepos/core/entity';
 import type { Rule } from '../types/role';
-export declare function filterPermissions(permissions: FdoPermissionRule[], subject: F_RULE_SUBJECT): string;
+export declare function filterPermissions(permissions: FdoPermissionRule[], subject: F_RULE_SUBJECT, availablePermissions?: FdoPermissionRule[]): string;
 export declare function ruleExtension(rule: FdoPermissionRule): {
     conditions: any;
     isDiscountOperation: boolean;
@@ -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[];