law-common 10.27.0 → 10.28.0

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

@@ -1,4 +1,4 @@
-import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, IBaseEntityApiResponse } from "../interface/entity.utils.interface";
+import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, EnumToModel, IApiEntity, IBaseEntityApiResponse, VirtualEntityEnum } from "../interface/entity.utils.interface";
 export declare function mapToIndex(entityMap: EntityMap): EntityIndexMap;
 export declare function getEntityIndexMap<T extends EntityEnum>(data: IBaseEntityApiResponse<EnumEntityType<T>>, baseEntity: T, reusedConfig?: {
     existingEntityIndexMap: EntityIndexMap;
@@ -6,3 +6,14 @@ export declare function getEntityIndexMap<T extends EntityEnum>(data: IBaseEntit
 }): EntityIndexMap;
 export declare function populateRelationsFor(entityIndexMap: EntityIndexMap, enumEntities: EntityEnum[]): void;
 export declare function parseEntities<T extends EnumEntityType<EntityEnum>>(json: IBaseEntityApiResponse<T>, baseEntity: EntityEnum, entityMap: EntityMap): EntityMap;
+export declare const entityEnumToEntityModel: {
+    [E in EntityEnum | VirtualEntityEnum]?: (json: IApiEntity<EnumEntityType<E>> & {
+        createdOn: number;
+        updatedOn: number;
+    }) => EnumToModel<E>;
+};
+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

@@ -1,18 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityEnumToEntityModel = void 0;
 exports.mapToIndex = mapToIndex;
 exports.getEntityIndexMap = getEntityIndexMap;
 exports.populateRelationsFor = populateRelationsFor;
 exports.parseEntities = parseEntities;
+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");
 const billing_reimbursement_expense_entity_model_1 = require("./billing-reimbursement-expense.entity.model");
 const billing_timesheet_entity_model_1 = require("./billing-timesheet.entity.model");
+const billing_transaction_model_1 = require("./billing-transaction.model");
 const billing_entity_model_1 = require("./billing.entity.model");
 const client_affiliate_entity_model_1 = require("./client-affiliate.entity.model");
 const client_entity_model_1 = require("./client.entity.model");
 const configuration_model_1 = require("./configuration.model");
+const holiday_entity_model_1 = require("./holiday.entity.model");
+const leave_entity_model_1 = require("./leave.entity.model");
+const leave_count_entity_model_1 = require("./leave_count.entity.model");
 const project_user_mapping_entity_model_1 = require("./project-user-mapping.entity.model");
 const project_entity_model_1 = require("./project.entity.model");
 const reimbursement_expense_entity_model_1 = require("./reimbursement-expense.entity.model");
@@ -57,13 +63,14 @@ function parseEntities(json, baseEntity, entityMap) {
         [entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING]: project_user_mapping_entity_model_1.ProjectUserMappingEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.REIMBURSEMENT]: reimbursement_entity_model_1.ReimbursementEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE]: reimbursement_expense_entity_model_1.ReimbursementExpenseEntityModel.fromEntity,
-        [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.CLIENT_AFFILIATE]: client_affiliate_entity_model_1.ClientAffiliateEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.BANK]: bank_entity_model_1.BankEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.CONFIGURATION]: configuration_model_1.ConfigurationEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.TASK]: task_entity_model_1.TaskEntityModel.fromEntity,
-        [entity_utils_interface_1.EntityEnum.BILLING_TIMESHEET]: billing_timesheet_entity_model_1.BillingTimesheetEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_TIMESHEET]: billing_timesheet_entity_model_1.BillingTimesheetEntityModel.fromEntity,
         [entity_utils_interface_1.EntityEnum.TIMESHEET]: timesheet_entity_model_1.TimesheetEntityModel.fromEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_TRANSACTION]: billing_transaction_model_1.BillingTransactionEntityModel.fromEntity,
     };
     if (!(baseEntity in entityFromJsonMappings)) {
         throw new Error(`Unknown entity: ${baseEntity}`);
@@ -81,3 +88,40 @@ function parseEntities(json, baseEntity, entityMap) {
     }
     return entityMap;
 }
+exports.entityEnumToEntityModel = {
+    [entity_utils_interface_1.EntityEnum.PROJECT]: project_entity_model_1.ProjectEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.CLIENT]: client_entity_model_1.ClientEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.BILLING]: billing_entity_model_1.BillingEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.USER]: user_entity_model_1.UserEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING]: project_user_mapping_entity_model_1.ProjectUserMappingEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.REIMBURSEMENT]: reimbursement_entity_model_1.ReimbursementEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE]: reimbursement_expense_entity_model_1.ReimbursementExpenseEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.HOLIDAY]: holiday_entity_model_1.HolidayEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.LEAVE]: leave_entity_model_1.LeaveEntityModel.fromEntity,
+    [entity_utils_interface_1.VirtualEntityEnum.LEAVE_COUNT]: leave_count_entity_model_1.LeaveCountVirtualEntityModel.fromEntity,
+    // Add other entities here as needed
+    [entity_utils_interface_1.EntityEnum.CLIENT_AFFILIATE]: client_affiliate_entity_model_1.ClientAffiliateEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.BANK]: bank_entity_model_1.BankEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.CONFIGURATION]: configuration_model_1.ConfigurationEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.TASK]: task_entity_model_1.TaskEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.BILLING_TIMESHEET]: billing_timesheet_entity_model_1.BillingTimesheetEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.TIMESHEET]: timesheet_entity_model_1.TimesheetEntityModel.fromEntity,
+    [entity_utils_interface_1.EntityEnum.BILLING_TRANSACTION]: billing_transaction_model_1.BillingTransactionEntityModel.fromEntity,
+};
+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/entities/model/holiday.entity.model.d.ts

@@ -1 +1,14 @@
-export declare const toBeDeleted = "holiday";
+import { EntityEnum } from "../interface/entity.utils.interface";
+import { IHolidayEntity } from "../interface/holiday.entity.interface";
+import { BaseEntityModel } from "./base.entity.model";
+export declare class HolidayEntityModel extends BaseEntityModel<EntityEnum.HOLIDAY> implements IHolidayEntity {
+    id: number;
+    holidayListId: number;
+    dateCode: string;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: number;
+    updatedOn: number;
+    getRelationConfigs(): never[];
+    static fromEntity(entity: IHolidayEntity): HolidayEntityModel;
+}

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

@@ -1,44 +1,28 @@
 "use strict";
-// import { DateCodeModel } from "../../utils";
-// import { IAuditColumnEntity } from "../interface/audit-column.entity.interface";
-// import { IHolidayEntity } from "../interface/holiday.entity.interface";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDeleted = void 0;
-// export class BaseEntityModelV1<T extends IAuditColumnEntity> {
-//   createdOn: Date;
-//   updatedOn: Date;
-//   createdBy: number;
-//   updatedBy: number;
-//   constructor(data: T) {
-//     this.createdOn = data.createdOn;
-//     this.updatedOn = data.updatedOn;
-//     this.createdBy = data.createdBy;
-//     this.updatedBy = data.updatedBy;
-//   }
-// }
-// export class HolidayEntityModel
-//   extends BaseEntityModelV1<IHolidayEntity>
-//   implements IHolidayEntity
-// {
-//   id: number;
-//   holidayListId: number;
-//   dateCode: string;
-//   private constructor(data: IHolidayEntity) {
-//     super(data);
-//     this.id = data.id;
-//     this.holidayListId = data.holidayListId;
-//     this.dateCode = data.dateCode;
-//   }
-//   getDateCodeModel(): DateCodeModel {
-//     return new DateCodeModel(this.dateCode);
-//   }
-//   static fromEntity(data: IHolidayEntity): HolidayEntityModel {
-//     return new HolidayEntityModel(data);
-//   }
-//   static getDateCodeModelFromDate(
-//     models: HolidayEntityModel[]
-//   ): DateCodeModel[] {
-//     return models.map((model) => model.getDateCodeModel());
-//   }
-// }
-exports.toBeDeleted = "holiday";
+exports.HolidayEntityModel = void 0;
+// import { EntityEnum, IHolidayEntity } from "law-common/dist/src/entities";
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+// import { IHolidayApiEntity } from "law-common/dist/src/api";
+class HolidayEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.holidayListId = 0;
+        this.dateCode = "";
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = 0;
+        this.updatedOn = 0;
+    }
+    getRelationConfigs() {
+        return [];
+    }
+    static fromEntity(entity) {
+        const result = new HolidayEntityModel(entity_utils_interface_1.EntityEnum.HOLIDAY);
+        Object.assign(result, entity);
+        return result;
+    }
+}
+exports.HolidayEntityModel = HolidayEntityModel;

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

@@ -2,8 +2,13 @@ import { DateCodeModel, Weekday } from "../../utils";
 import { DurationTypeEnum } from "../enums/duration-type.enum";
 import { LeaveTypeEnum } from "../enums/leave-type.enum";
 import { LeaveStatusEnum } from "../enums/leave.status.enum";
+import { RelationType } from "../enums/relation-type.enum";
+import { EntityEnum, VirtualEntityEnum } from "../interface/entity.utils.interface";
 import { ILeaveEntity } from "../interface/leave.entity.interface";
-export declare class LeaveEntityModel implements ILeaveEntity {
+import { BaseEntityModel } from "./base.entity.model";
+import { LeaveCountVirtualEntityModel } from "./leave_count.entity.model";
+import { UserEntityModel } from "./user.entity.model";
+export declare class LeaveEntityModel extends BaseEntityModel<EntityEnum.LEAVE> implements ILeaveEntity {
     id: number;
     employeeId: number;
     fromDate: string;
@@ -17,13 +22,55 @@ export declare class LeaveEntityModel implements ILeaveEntity {
     updatedOn: number;
     createdBy: number;
     updatedBy: number;
-    private constructor();
+    leaveCount?: LeaveCountVirtualEntityModel;
+    createdByUser?: UserEntityModel;
+    updatedByUser?: UserEntityModel;
+    user?: UserEntityModel;
     static fromEntity(data: ILeaveEntity): LeaveEntityModel;
-    isMoreThanOneDayLeave(): boolean;
     getLeaveDuration(excludeWeekdays?: Weekday[], excludeDates?: DateCodeModel[]): number;
     static getLeaveDuration(leaves: LeaveEntityModel[], excludeWeekdays?: Weekday[], excludeDates?: DateCodeModel[], leaveStatusEnum?: LeaveStatusEnum[]): number;
     getDateCodeModels(dateCodeIncludePredicates?: ((dateModel: DateCodeModel) => boolean)[], dateCodeExcludePredicates?: ((dateModel: DateCodeModel) => boolean)[]): DateCodeModel[];
     static getLeaveApprovePredicate(): (leave: LeaveEntityModel) => boolean;
     static getLeavePendingPredicate(): (leave: LeaveEntityModel) => boolean;
     static getLeavesByPredicates(leaves: LeaveEntityModel[], includePredicates?: ((leave: LeaveEntityModel) => boolean)[], excludePredicates?: ((leave: LeaveEntityModel) => boolean)[]): LeaveEntityModel[];
+    static orderByFromDateAsc(leaves: LeaveEntityModel[]): LeaveEntityModel[];
+    isWeekendSucceeds(): boolean;
+    isWeekendPrecedes(): boolean;
+    isHolidaySucceeds(holidays: DateCodeModel[]): boolean;
+    isHolidayPrecedes(holidays: DateCodeModel[]): boolean;
+    getRelationConfigs(): any[];
+    static relationConfigs: ({
+        name: VirtualEntityEnum;
+        relation: RelationType;
+        key: string;
+        mapKeyConfig: {
+            relationKey: string;
+            key: string;
+        };
+    } | {
+        name: EntityEnum;
+        relation: RelationType;
+        key: string;
+        mapKeyConfig: {
+            relationKey: string;
+            key: string;
+        };
+    })[];
+    static fromApiEntity(apiEntity: ILeaveEntity): LeaveEntityModel;
+    static getPendingApprovalStatuses(): LeaveStatusEnum[];
+    getStatusLabel(): string;
+    getTypeLabel(): string;
+    getLeaveCount(): number;
+    static getLeaveCount(leaveEntities: LeaveEntityModel[]): number;
+    isMoreThanOneDayLeave(): boolean;
+    getFromDateLabel(): string;
+    getToDateLabel(): string;
+    getDateDurationLabel(): string;
+    static getLeaveStatusPriority(): {
+        pending_approval: number;
+        edit_approval: number;
+        delete_approval: number;
+        approved: number;
+        rejected: number;
+    };
 }

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

@@ -2,33 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LeaveEntityModel = void 0;
 const utils_1 = require("../../utils");
+const string_util_1 = require("../../utils/string.util");
 const duration_type_enum_1 = require("../enums/duration-type.enum");
+const leave_type_enum_1 = require("../enums/leave-type.enum");
 const leave_status_enum_1 = require("../enums/leave.status.enum");
-class LeaveEntityModel {
-    constructor(data) {
+const relation_type_enum_1 = require("../enums/relation-type.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class LeaveEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.employeeId = 0;
+        this.fromDate = "";
+        this.toDate = "";
+        this.reason = "";
+        this.durationType = duration_type_enum_1.DurationTypeEnum.FULL;
+        this.status = leave_status_enum_1.LeaveStatusEnum.DELETED;
+        this.type = leave_type_enum_1.LeaveTypeEnum.SICK;
         this.createdOn = 0;
         this.updatedOn = 0;
-        this.id = data.id;
-        this.employeeId = data.employeeId;
-        this.fromDate = data.fromDate;
-        this.toDate = data.toDate;
-        this.reason = data.reason;
-        this.durationType = data.durationType;
-        this.status = data.status;
-        this.remark = data.remark;
-        this.type = data.type;
-        this.createdOn = data.createdOn;
-        this.updatedOn = data.updatedOn;
-        this.createdBy = data.createdBy;
-        this.updatedBy = data.updatedBy;
+        this.createdBy = 0;
+        this.updatedBy = 0;
     }
     static fromEntity(data) {
-        return new LeaveEntityModel(data);
-    }
-    isMoreThanOneDayLeave() {
-        const fromDate = new utils_1.DateCodeModel(this.fromDate);
-        const toDate = new utils_1.DateCodeModel(this.toDate);
-        return fromDate.diffInDays(toDate) > 1;
+        const entity = new LeaveEntityModel(entity_utils_interface_1.EntityEnum.LEAVE);
+        Object.assign(entity, data);
+        return entity;
     }
     getLeaveDuration(excludeWeekdays = [], excludeDates = []) {
         if (!this.isMoreThanOneDayLeave()) {
@@ -80,5 +80,153 @@ class LeaveEntityModel {
         return leaves.filter((leave) => includePredicates.every((predicate) => predicate(leave)) &&
             excludePredicates.every((predicate) => !predicate(leave)));
     }
+    static orderByFromDateAsc(leaves) {
+        return leaves.sort((a, b) => {
+            const dateA = new Date(a.fromDate);
+            const dateB = new Date(b.fromDate);
+            return dateA.getTime() - dateB.getTime();
+        });
+    }
+    isWeekendSucceeds() {
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        const nextDate = toDate.getByOffset(1);
+        return nextDate.isDayPresent([utils_1.Weekday.Saturday, utils_1.Weekday.Sunday]);
+    }
+    isWeekendPrecedes() {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const prevDate = fromDate.getByOffset(-1);
+        return prevDate.isDayPresent([utils_1.Weekday.Saturday, utils_1.Weekday.Sunday]);
+    }
+    isHolidaySucceeds(holidays) {
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        const nextDate = toDate.getByOffset(1);
+        return holidays.some((holiday) => holiday.isSame(nextDate));
+    }
+    isHolidayPrecedes(holidays) {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const prevDate = fromDate.getByOffset(-1);
+        return holidays.some((holiday) => holiday.isSame(prevDate));
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromApiEntity(apiEntity) {
+        return LeaveEntityModel.fromEntity(apiEntity);
+    }
+    static getPendingApprovalStatuses() {
+        return [
+            leave_status_enum_1.LeaveStatusEnum.PENDING_APPROVAL,
+            leave_status_enum_1.LeaveStatusEnum.DELETE_APPROVAL,
+            leave_status_enum_1.LeaveStatusEnum.EDIT_APPROVAL,
+        ];
+    }
+    getStatusLabel() {
+        const pendingStatuses = LeaveEntityModel.getPendingApprovalStatuses();
+        let statusLabel = "";
+        if (pendingStatuses.includes(this.status)) {
+            statusLabel = "PENDING_APPROVAL";
+        }
+        else if (this.status === leave_status_enum_1.LeaveStatusEnum.RESOLVE_REJECTED) {
+            statusLabel = "CHANGES_REJECTED";
+        }
+        else {
+            statusLabel = this.status.toString();
+        }
+        return (0, string_util_1.formatString)(statusLabel);
+    }
+    getTypeLabel() {
+        return (0, string_util_1.formatString)(this.type.toString());
+    }
+    getLeaveCount() {
+        var _a;
+        return ((_a = this.leaveCount) === null || _a === void 0 ? void 0 : _a.count) || 0;
+    }
+    static getLeaveCount(leaveEntities) {
+        return leaveEntities.reduce((acc, leave) => acc + leave.getLeaveCount(), 0);
+    }
+    isMoreThanOneDayLeave() {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        return fromDate.diffInDays(toDate) > 1;
+    }
+    getFromDateLabel() {
+        const statues = [
+            duration_type_enum_1.DurationTypeEnum.SECOND,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FULL,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FIRST,
+        ];
+        if (statues.includes(this.durationType)) {
+            return "Second Half";
+        }
+        return "Full Day";
+    }
+    getToDateLabel() {
+        const statues = [
+            duration_type_enum_1.DurationTypeEnum.FIRST,
+            duration_type_enum_1.DurationTypeEnum.FULL_FIRST,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FIRST,
+        ];
+        if (statues.includes(this.durationType)) {
+            return "First Half";
+        }
+        return "Full Day";
+    }
+    getDateDurationLabel() {
+        if (!this.isMoreThanOneDayLeave()) {
+            return `${new utils_1.DateCodeModel(this.fromDate).getFormattedDateWithMonthName()} ${this.durationType === duration_type_enum_1.DurationTypeEnum.FULL
+                ? "(Full Day)"
+                : this.durationType === duration_type_enum_1.DurationTypeEnum.FIRST
+                    ? "(First Half)"
+                    : "(Second Half)"}`;
+        }
+        return `${new utils_1.DateCodeModel(this.fromDate).getFormattedDateWithMonthName()} (${this.getFromDateLabel()}) - ${new utils_1.DateCodeModel(this.toDate).getFormattedDateWithMonthName()} (${this.getToDateLabel()})`;
+    }
+    static getLeaveStatusPriority() {
+        return {
+            [leave_status_enum_1.LeaveStatusEnum.PENDING_APPROVAL]: 1,
+            [leave_status_enum_1.LeaveStatusEnum.EDIT_APPROVAL]: 2,
+            [leave_status_enum_1.LeaveStatusEnum.DELETE_APPROVAL]: 3,
+            [leave_status_enum_1.LeaveStatusEnum.APPROVED]: 4,
+            [leave_status_enum_1.LeaveStatusEnum.REJECTED]: 5,
+        };
+    }
 }
 exports.LeaveEntityModel = LeaveEntityModel;
+LeaveEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.VirtualEntityEnum.LEAVE_COUNT,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "leaveCount",
+        mapKeyConfig: {
+            relationKey: "leaveId",
+            key: "id",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "createdByUser",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "createdBy",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "updatedByUser",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "updatedBy",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "user",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "employeeId",
+        },
+    },
+];

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

@@ -0,0 +1,19 @@
+import { DateCodeModel } from "../../utils";
+import { VirtualEntityEnum } from "../interface/entity.utils.interface";
+import { ILeaveCountVirtualEntity } from "../interface/leave.entity.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { LeaveEntityModel } from "./leave.entity.model";
+export declare class LeaveCountVirtualEntityModel extends BaseEntityModel<VirtualEntityEnum.LEAVE_COUNT> implements ILeaveCountVirtualEntity {
+    id: number;
+    period: string;
+    leaveId?: number;
+    count: number;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: number;
+    updatedOn: number;
+    static fromEntity(entity: ILeaveCountVirtualEntity): LeaveCountVirtualEntityModel;
+    getRelationConfigs(): any[];
+    static relationConfigs: never[];
+    static fromLeaveHoliday(leaveModel: LeaveEntityModel, holidayDateCodes: DateCodeModel[]): LeaveCountVirtualEntityModel;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveCountVirtualEntityModel = void 0;
+const utils_1 = require("../../utils");
+const leave_type_enum_1 = require("../enums/leave-type.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class LeaveCountVirtualEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.period = "";
+        this.count = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = 0;
+        this.updatedOn = 0;
+    }
+    static fromEntity(entity) {
+        const result = new LeaveCountVirtualEntityModel(entity_utils_interface_1.VirtualEntityEnum.LEAVE_COUNT);
+        Object.assign(result, entity);
+        return result;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromLeaveHoliday(leaveModel, holidayDateCodes) {
+        const leaveCountVirtualEntity = {
+            leaveId: leaveModel.id,
+            count: leaveModel.getLeaveDuration([utils_1.Weekday.Sunday, utils_1.Weekday.Saturday], holidayDateCodes) +
+                (leaveModel.type === leave_type_enum_1.LeaveTypeEnum.SICK &&
+                    (leaveModel.isWeekendPrecedes() ||
+                        leaveModel.isWeekendSucceeds() ||
+                        leaveModel.isHolidayPrecedes(holidayDateCodes) ||
+                        leaveModel.isHolidaySucceeds(holidayDateCodes))
+                    ? 2
+                    : 0),
+            createdBy: leaveModel.createdBy,
+            updatedBy: leaveModel.updatedBy,
+            createdOn: leaveModel.createdOn,
+            updatedOn: leaveModel.updatedOn,
+            id: leaveModel.id,
+            period: leaveModel.fromDate + leaveModel.toDate + leaveModel.durationType,
+        };
+        return LeaveCountVirtualEntityModel.fromEntity(leaveCountVirtualEntity);
+    }
+}
+exports.LeaveCountVirtualEntityModel = LeaveCountVirtualEntityModel;
+// static relationConfigs = [
+//             {
+//                 name: EntityEnum.LEAVE,
+//                 relation: RelationType.ONE,
+//                 key: 'leaveCount',
+//                 mapKeyConfig: {
+//                     relationKey: 'id',
+//                     key: 'leaveId',
+//                 },
+//             },
+//         ];
+LeaveCountVirtualEntityModel.relationConfigs = [];

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

@@ -0,0 +1,32 @@
+import { LeaveActionEnum, LeaveStatusEnum } from "../entities";
+export type LeaveStatusActionPair = {
+    status: LeaveStatusEnum;
+    action: LeaveActionEnum;
+};
+/**
+ * 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
+ */
+export declare function getPermittedActions<T extends LeaveStatusActionPair, E>(entityFlowConfig: {
+    [key in T["status"]]?: {
+        actions: {
+            [key in T["action"]]?: {
+                permissions: string[];
+                next: () => T["status"];
+            };
+        };
+    };
+}, 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;
+}[];