law-common 10.21.1-beta.1 → 10.21.1-beta.3

package/dist/src/entities/func/convert-to-common-entity.func.js

@@ -14,9 +14,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConvertToCommonEntity = ConvertToCommonEntity;
 exports.ConvertApiToEntity = ConvertApiToEntity;
 function ConvertToCommonEntity(obj) {
-    var _a, _b;
     const { createdOn: _, updatedOn: __ } = obj, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);
-    return Object.assign({ createdOn: (_a = obj.createdOn) === null || _a === void 0 ? void 0 : _a.toISOString(), updatedOn: (_b = obj.updatedOn) === null || _b === void 0 ? void 0 : _b.toISOString() }, objectToAssign);
+    const dateTransformerObj = {};
+    if (obj.createdOn) {
+        dateTransformerObj["createdOn"] = obj.createdOn.toISOString();
+    }
+    if (obj.updatedOn) {
+        dateTransformerObj["updatedOn"] = obj.updatedOn.toISOString();
+    }
+    return Object.assign(Object.assign({}, dateTransformerObj), objectToAssign);
 }
 function ConvertApiToEntity(obj) {
     const { createdOn: _, updatedOn: __ } = obj, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);

package/dist/src/entities/model/entity.model.interface.d.ts

@@ -11,3 +11,8 @@ export declare const entityEnumToEntityModel: {
 export declare function entityMapToModels(entityMap: EntityMap): void;
 export declare function parseEntities<T extends EnumEntityType<EntityEnum | VirtualEntityEnum>>(json: IBaseEntityApiResponse<T>, baseEntity: EntityEnum | VirtualEntityEnum, entityMap: EntityMap): EntityMap;
 export declare function entityMapToEntityIndexMap(entityMap: EntityMap, entityRelationsFor: EntityEnum[]): EntityIndexMap;
+export declare function parseEntitiesWithoutModels<T extends EnumEntityType<EntityEnum | VirtualEntityEnum>>(json: IBaseEntityApiResponse<T>, baseEntity: EntityEnum | VirtualEntityEnum, entityMap?: {
+    [E in EntityEnum | VirtualEntityEnum]?: IApiEntity<EnumEntityType<E>>[];
+}): {
+    [E in EntityEnum | VirtualEntityEnum]?: IApiEntity<EnumEntityType<E>>[];
+};

package/dist/src/entities/model/entity.model.interface.js

@@ -7,6 +7,7 @@ exports.populateRelationsFor = populateRelationsFor;
 exports.entityMapToModels = entityMapToModels;
 exports.parseEntities = parseEntities;
 exports.entityMapToEntityIndexMap = entityMapToEntityIndexMap;
+exports.parseEntitiesWithoutModels = parseEntitiesWithoutModels;
 const entity_utils_interface_1 = require("../interface/entity.utils.interface");
 const bank_entity_model_1 = require("./bank.entity.model");
 const base_entity_model_1 = require("./base.entity.model");
@@ -103,3 +104,19 @@ function entityMapToEntityIndexMap(entityMap, entityRelationsFor) {
     populateRelationsFor(entityIndexMap, entityRelationsFor);
     return entityIndexMap;
 }
+function parseEntitiesWithoutModels(json, baseEntity, entityMap = {}) {
+    var _a;
+    if (!(baseEntity in exports.entityEnumToEntityModel)) {
+        throw new Error(`Unknown entity: ${baseEntity}`);
+    }
+    entityMap[baseEntity] = ((_a = json["baseEntities"]) !== null && _a !== void 0 ? _a : []);
+    if (json["relatedEntities"]) {
+        const relatedEntities = json["relatedEntities"];
+        for (const entityName in relatedEntities) {
+            parseEntitiesWithoutModels(
+            // @ts-ignore
+            relatedEntities[entityName], entityName, entityMap);
+        }
+    }
+    return entityMap;
+}

package/dist/src/utils/entity.flow.util.d.ts

@@ -9,22 +9,24 @@ export type LeaveStatusActionPair = {
  * @param currentStatus - The current status of the leave
  * @param userPermissions - Array of permissions the user has
  * @param combineActions - Array of action values to combine into a single action
- * @param data - Optional function to provide additional visibility conditions based on the entity data
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
  * @returns Array of available actions with labels and values
- * @throws Error if user has multiple permissions for a single action
  */
 export declare function getPermittedActions<T extends LeaveStatusActionPair, E>(entityFlowConfig: {
-    [key in T['status']]?: {
+    [key in T["status"]]?: {
         actions: {
-            [key in T['action']]?: {
+            [key in T["action"]]?: {
                 permissions: string[];
-                next: () => T['status'];
+                next: () => T["status"];
             };
         };
     };
-}, currentStatus: T['status'] | null, userPermissions: string[], combineActions?: T['action'][], data?: (a: E) => {
+}, currentStatus: T["status"] | null, userPermissions: string[], combineActions?: T["action"][], actionLabels?: {
+    [key in T["action"]]?: string;
+}, data?: (a: E) => {
     [key: string]: () => boolean;
 }): {
     label: string;
-    value: T['action'] | string;
+    value: T["action"] | string;
 }[];

package/dist/src/utils/entity.flow.util.js

@@ -1,54 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPermittedActions = getPermittedActions;
-const entities_1 = require("../entities");
+/**
+ * Converts an action or combined action to a value-label pair
+ * @param action - The action or combined action key
+ * @param actionLabels - Object mapping actions to custom labels
+ * @returns Object with label and value
+ */
+function convertToValueLabel(action, actionLabels) {
+    return {
+        label: actionLabels[action] || action,
+        value: action,
+    };
+}
+/**
+ * Filters actions based on user permissions and visibility conditions
+ * @param actionConfig - The actions configuration for the current status
+ * @param userPermissions - Array of permissions the user has
+ * @param data - Optional function to provide additional visibility conditions
+ * @returns Array of permitted action keys
+ * @throws Error if multiple permissions are found for a single action
+ */
+function _getPermittedActions(actionConfig, userPermissions, data) {
+    return Object.entries(actionConfig)
+        .filter(([actionKey, config]) => {
+        var _a;
+        const actionRequiredPermissions = (_a = config === null || config === void 0 ? void 0 : config.permissions) !== null && _a !== void 0 ? _a : [];
+        const matchingPermissions = actionRequiredPermissions.filter((permission) => userPermissions.includes(permission));
+        if (matchingPermissions.length > 1) {
+            throw new Error(`Multiple permissions found for action ${actionKey}: ${matchingPermissions.join(", ")}`);
+        }
+        return (matchingPermissions.length > 0 &&
+            (!data ||
+                !data({})[matchingPermissions[0]] ||
+                data({})[matchingPermissions[0]]()));
+    })
+        .map(([actionKey, _]) => actionKey);
+}
+/**
+ * Combines specified actions into a single action if all are present
+ * @param permittedActions - Array of permitted action keys
+ * @param combineActions - Array of actions to combine
+ * @returns Array of action keys, with combined action if applicable
+ */
+function combinePermittedActions(permittedActions, combineActions) {
+    if (combineActions.length === 0) {
+        return permittedActions;
+    }
+    const isCombinedActionPresent = combineActions.every((action) => permittedActions.includes(action));
+    if (isCombinedActionPresent) {
+        const combinedValue = combineActions.join("_");
+        return [
+            ...permittedActions.filter((action) => !combineActions.includes(action)),
+            combinedValue,
+        ];
+    }
+    return permittedActions;
+}
 /**
  * Gets available actions for a leave based on current status and user permissions
  * @param entityFlowConfig - The flow configuration for the entity
  * @param currentStatus - The current status of the leave
  * @param userPermissions - Array of permissions the user has
  * @param combineActions - Array of action values to combine into a single action
- * @param data - Optional function to provide additional visibility conditions based on the entity data
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
  * @returns Array of available actions with labels and values
- * @throws Error if user has multiple permissions for a single action
  */
-function getPermittedActions(entityFlowConfig, currentStatus, userPermissions, combineActions = [], data = (_) => ({})) {
+function getPermittedActions(entityFlowConfig, currentStatus, userPermissions, combineActions = [], actionLabels = {}, data = (_) => ({})) {
     var _a;
     // Handle invalid inputs
     if (!currentStatus || !entityFlowConfig[currentStatus]) {
         return [];
     }
     const actionConfig = ((_a = entityFlowConfig[currentStatus]) === null || _a === void 0 ? void 0 : _a.actions) || {};
-    // Filter actions based on user permissions
-    const permittedActions = Object.entries(actionConfig)
-        .filter(([actionKey, config]) => {
-        var _a;
-        const actionRequiredPermissions = (_a = config.permissions) !== null && _a !== void 0 ? _a : [];
-        const matchingPermissions = actionRequiredPermissions.filter((permission) => userPermissions.includes(permission));
-        // Check for multiple permissions
-        if (matchingPermissions.length > 1) {
-            throw new Error(`Multiple permissions found for action ${actionKey}: ${matchingPermissions.join(', ')}`);
-        }
-        return matchingPermissions.length > 0 && (!data || !data({})[matchingPermissions[0]] || data({})[matchingPermissions[0]]());
-    })
-        .map(([actionKey, _]) => ({
-        label: entities_1.LeaveActionEnum.getLabel(actionKey) || '',
-        value: actionKey,
-    }));
-    // // Combine specified actions if all are present and combineActions is not empty
-    if (combineActions.length > 0) {
-        const isCombinedActionPresent = combineActions.every((action) => permittedActions.some((a) => a.value === action));
-        if (isCombinedActionPresent) {
-            return [
-                ...permittedActions.filter((action) => !combineActions.includes(action.value)),
-                {
-                    label: combineActions
-                        .map((a) => entities_1.LeaveActionEnum.getLabel(a) || '')
-                        .join('/'),
-                    value: combineActions.join('_'),
-                },
-            ];
-        }
-    }
-    return permittedActions;
+    // Get permitted actions
+    const permittedActions = _getPermittedActions(actionConfig, userPermissions, data);
+    // Combine actions if specified
+    const finalActions = combinePermittedActions(permittedActions, combineActions);
+    // Convert to value-label pairs
+    return finalActions.map((action) => convertToValueLabel(action, actionLabels));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "law-common",
- "version": "10.21.1-beta.1",
+ "version": "10.21.1-beta.3",
  "description": "",
  "main": "dist/index.js",
  "files": [