law-common 10.27.0 → 10.28.0

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermittedActions = getPermittedActions;
+/**
+ * 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 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
+ */
+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) || {};
+    // 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/dist/src/utils/helper.fn.util.d.ts

@@ -1,4 +1,4 @@
-import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData } from "../entities";
+import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData, IEntityServiceResponse } from "../entities";
 import { Modify } from "../misc";
 export declare function groupByFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T[]>;
 export declare function groupByOneToOneFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T>;
@@ -176,6 +176,42 @@ export declare function transformDate<T extends {
 export declare function capitalizeFirstWord(str: string): string;
 export declare function getEntitiesFromSearchV2Response<E extends EntityEnum, // Enum key like EntityEnum.USER, EntityEnum.PROJECT, etc.
 T extends EnumEntityType<E>>(searchResponseV2: IBaseEntityServiceResponse<EnumEntityType<EntityEnum>>, entityEnumKey: E, EntityClass: new () => T): T[];
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+export declare function findEntitiesFromSearchV2RelatedEntities<E extends EntityEnum, T extends EnumEntityType<E>>(relatedEntities: IEntityServiceResponse | undefined, targetKey: EntityEnum, EntityClass: new () => T): T[];
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/dist/src/utils/helper.fn.util.js

@@ -33,6 +33,7 @@ exports.createKeyLabelMap = createKeyLabelMap;
 exports.transformDate = transformDate;
 exports.capitalizeFirstWord = capitalizeFirstWord;
 exports.getEntitiesFromSearchV2Response = getEntitiesFromSearchV2Response;
+exports.findEntitiesFromSearchV2RelatedEntities = findEntitiesFromSearchV2RelatedEntities;
 exports.areDecimalNumbersEqual = areDecimalNumbersEqual;
 exports.formatIndianNumber = formatIndianNumber;
 exports.findDuplicateIds = findDuplicateIds;
@@ -403,6 +404,58 @@ function getEntitiesFromSearchV2Response(searchResponseV2, entityEnumKey, Entity
     }
     return (((_a = searchResponseV2.relatedEntities[entityEnumKey]) === null || _a === void 0 ? void 0 : _a.baseEntities) || []).map((entity) => Object.assign(new EntityClass(), entity));
 }
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+function findEntitiesFromSearchV2RelatedEntities(relatedEntities, targetKey, EntityClass) {
+    if (!relatedEntities)
+        return [];
+    let result = [];
+    for (const key of Object.keys(relatedEntities)) {
+        const value = relatedEntities[key];
+        // If this key is the target and has baseEntities
+        if (key === targetKey && (value === null || value === void 0 ? void 0 : value.baseEntities)) {
+            result.push(...value.baseEntities.map((entity) => Object.assign(new EntityClass(), entity)));
+        }
+        // If value has relatedEntities, recurse
+        if (value === null || value === void 0 ? void 0 : value.relatedEntities) {
+            result.push(...findEntitiesFromSearchV2RelatedEntities(value.relatedEntities, targetKey, EntityClass));
+        }
+    }
+    return result;
+}
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/dist/src/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./date.util";
 export * from "./helper.fn.util";
 export * from "./models/date-code.model.util";
+export * from "./string.util";
+export * from "./entity.flow.util";

package/dist/src/utils/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./date.util"), exports);
 __exportStar(require("./helper.fn.util"), exports);
 __exportStar(require("./models/date-code.model.util"), exports);
+__exportStar(require("./string.util"), exports);
+__exportStar(require("./entity.flow.util"), exports);

package/dist/src/utils/string.util.d.ts

@@ -0,0 +1 @@
+export declare function formatString(input: string): string;

package/dist/src/utils/string.util.js

@@ -1 +1,15 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatString = formatString;
+function formatString(input) {
+    if (input.includes('_')) {
+        return input
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+    }
+    else {
+        // For single-word strings, capitalize the first letter
+        return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
+    }
+}

package/package.json

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

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

@@ -1,15 +0,0 @@
-import { Modify } from "../../misc/interface/modify.interface";
-export declare function ConvertToCommonEntity<T extends {
-    createdOn: Date;
-    updatedOn: Date;
-}, R extends Modify<T, {
-    createdOn: string;
-    updatedOn: string;
-}>>(obj: T): R;
-export declare function ConvertApiToEntity<T extends {
-    createdOn: string;
-    updatedOn: string;
-}, R extends Modify<T, {
-    createdOn: Date;
-    updatedOn: Date;
-}>>(obj: T): R;

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

@@ -1,24 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-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);
-}
-function ConvertApiToEntity(obj) {
-    const { createdOn: _, updatedOn: __ } = obj, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);
-    return Object.assign({ createdOn: new Date(obj.createdOn), updatedOn: new Date(obj.updatedOn) }, objectToAssign);
-}