law-common 10.18.1-beta.2 → 10.18.1-beta.20

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingEntityModel = exports.BillingStatusCategoryEnumForUI = void 0;
+const enums_1 = require("../../enums");
+const billing_type_enum_1 = require("../enums/billing-type.enum");
+const billing_status_enum_1 = require("../enums/billing.status.enum");
+const billing_invoice_type_enum_1 = require("../enums/billing_invoice_type.enum");
+const payment_status_enum_1 = require("../enums/payment_status.enum");
+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");
+var BillingStatusCategoryEnumForUI;
+(function (BillingStatusCategoryEnumForUI) {
+    BillingStatusCategoryEnumForUI["INTERNAL_REVIEW_STATUS"] = "INTERNAL_REVIEW_STATUS";
+    BillingStatusCategoryEnumForUI["CLIENT_REVIEW_STATUS"] = "CLIENT_REVIEW_STATUS";
+    BillingStatusCategoryEnumForUI["PAYMENT_STATUS"] = "PAYMENT_STATUS";
+})(BillingStatusCategoryEnumForUI || (exports.BillingStatusCategoryEnumForUI = BillingStatusCategoryEnumForUI = {}));
+class BillingEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.startDate = "";
+        this.endDate = "";
+        this.projectId = 0;
+        this.totalAmount = 0;
+        this.totalMinutes = 0;
+        this.invoiceNumber = "";
+        this.paymentStatus = payment_status_enum_1.PaymentStatusEnum.PENDING;
+        this.status = billing_status_enum_1.BillingStatusEnum.PENDING_APPROVAL;
+        this.writeoffAmount = 0;
+        this.totalAmountPaid = 0;
+        this.tdsAmount = 0;
+        this.creditNoteAmount = 0;
+        this.invoiceEntityId = 0;
+        this.invoiceEntityType = billing_invoice_type_enum_1.BillingInvoiceTypeEnum.CLIENT;
+        this.invoiceContactName = "";
+        this.bankId = 0;
+        this.particulars = "";
+        this.currency = enums_1.CurrencyEnum.INR;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.type = billing_type_enum_1.BillingTypeEnum.INVOICE;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new BillingEntityModel(entity_utils_interface_1.EntityEnum.BILLING);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getStatusCategory() {
+        return this.mapStatusCategory(this.status);
+    }
+    getStatusLabel() {
+        return this.mapStatusLabel(this.status);
+    }
+    getTotalAmountInINR() {
+        return Number(this.conversionRate) > 0
+            ? Number(this.totalAmount) * Number(this.conversionRate)
+            : Number(this.totalAmount);
+    }
+    getDateRange() {
+        return `${this.formatDate(this.startDate)} - ${this.formatDate(this.endDate, true)}`;
+    }
+    getBillDate() {
+        return new Date(this.createdOn);
+    }
+    mapOverdue(configValue) {
+        var _a, _b, _c, _d;
+        let overdue = false;
+        if (configValue !== undefined &&
+            this.mapStatusCategory(this.status) ===
+                BillingStatusCategoryEnumForUI.PAYMENT_STATUS &&
+            this.status !== billing_status_enum_1.BillingStatusEnum.SETTLED) {
+            const overdueDays = (_d = (_b = (_a = this.project) === null || _a === void 0 ? void 0 : _a.billingOverdueDays) !== null && _b !== void 0 ? _b : (_c = this.client) === null || _c === void 0 ? void 0 : _c.billingOverdueDays) !== null && _d !== void 0 ? _d : Number(configValue);
+            const dueDate = new Date(this.createdOn);
+            dueDate.setDate(dueDate.getDate() + overdueDays);
+            overdue = dueDate < new Date();
+        }
+        this.billOverdue = overdue;
+    }
+    mapStatusCategory(status) {
+        // Define mapping sets
+        const categories = {
+            [BillingStatusCategoryEnumForUI.INTERNAL_REVIEW_STATUS]: [
+                billing_status_enum_1.BillingStatusEnum.INTERNAL_APPROVED,
+                billing_status_enum_1.BillingStatusEnum.PENDING_APPROVAL,
+                billing_status_enum_1.BillingStatusEnum.REQUEST_CHANGES,
+                billing_status_enum_1.BillingStatusEnum.CANCELLED,
+            ],
+            [BillingStatusCategoryEnumForUI.CLIENT_REVIEW_STATUS]: [
+                billing_status_enum_1.BillingStatusEnum.PENDING_CLIENT_REVIEW,
+                billing_status_enum_1.BillingStatusEnum.CLIENT_REVISION_APPROVAL,
+                billing_status_enum_1.BillingStatusEnum.REJECT_CLIENT_REVISION,
+            ],
+            [BillingStatusCategoryEnumForUI.PAYMENT_STATUS]: [
+                billing_status_enum_1.BillingStatusEnum.INVOICE_SENT,
+                billing_status_enum_1.BillingStatusEnum.PENDING_PAYMENT,
+                billing_status_enum_1.BillingStatusEnum.SETTLED,
+            ],
+        };
+        // Validation: check if any status exists in more than one category
+        const statusMap = new Map();
+        for (const [category, statuses] of Object.entries(categories)) {
+            for (const s of statuses) {
+                const existing = statusMap.get(s) || [];
+                existing.push(category);
+                statusMap.set(s, existing);
+            }
+        }
+        for (const [s, cats] of statusMap) {
+            if (cats.length > 1) {
+                console.error(`Duplicate mapping: ${s} exists in categories ${cats.join(", ")}`);
+            }
+        }
+        // Now do actual mapping
+        for (const [category, statuses] of Object.entries(categories)) {
+            if (statuses.includes(status)) {
+                return category;
+            }
+        }
+        throw new Error(`Unhandled Billing Status: ${status}`);
+    }
+    mapStatusLabel(status) {
+        switch (status) {
+            case billing_status_enum_1.BillingStatusEnum.PENDING_APPROVAL:
+                return "Pending Internal Approval";
+            case billing_status_enum_1.BillingStatusEnum.REQUEST_CHANGES:
+                return "Requested Changes";
+            case billing_status_enum_1.BillingStatusEnum.CANCELLED:
+                return "Cancelled";
+            case billing_status_enum_1.BillingStatusEnum.INTERNAL_APPROVED:
+                return "Approved Internally";
+            case billing_status_enum_1.BillingStatusEnum.PENDING_CLIENT_REVIEW:
+                return "Pending Client Review";
+            case billing_status_enum_1.BillingStatusEnum.CLIENT_REVISION_APPROVAL:
+                return "Client Approved Revision";
+            case billing_status_enum_1.BillingStatusEnum.REJECT_CLIENT_REVISION:
+                return "Client Rejected Revision";
+            case billing_status_enum_1.BillingStatusEnum.INVOICE_SENT:
+                return "Invoice Sent";
+            case billing_status_enum_1.BillingStatusEnum.PENDING_PAYMENT:
+                return "Pending Payment";
+            case billing_status_enum_1.BillingStatusEnum.SETTLED:
+                return "Settled";
+            default:
+                return status;
+        }
+    }
+    formatDate(dateStr, includeYear = false) {
+        const year = dateStr.slice(0, 4);
+        const month = parseInt(dateStr.slice(4, 6), 10) - 1;
+        const day = dateStr.slice(6, 8);
+        return new Date(+year, month, +day).toLocaleDateString("en-IN", Object.assign({ day: "numeric", month: "short" }, (includeYear && { year: "numeric" })));
+    }
+    getAvailableAction(currentUserPermissions, billingConfigFlow, getUpdateActionVisibility) {
+        const currentBillingStatusActionConfig = billingConfigFlow[this.status];
+        if (currentBillingStatusActionConfig) {
+            const actionVisibilityConfig = getUpdateActionVisibility(this);
+            return Object.entries(currentBillingStatusActionConfig.actions)
+                .filter(([_, actionConfig]) => {
+                const actionPermissions = actionConfig.permissions.filter((item) => item != "BILLING_VIEW_PDF") || [];
+                const commonPermissions = actionPermissions.filter((actionPermission) => currentUserPermissions.includes(actionPermission));
+                if (commonPermissions.length === 0) {
+                    return false;
+                }
+                if (commonPermissions.length > 1) {
+                    throw new Error("Multiple permissions found for an action");
+                }
+                if (!actionVisibilityConfig[commonPermissions[0]]) {
+                    return true;
+                }
+                return commonPermissions.some((permission) => actionVisibilityConfig[permission] &&
+                    actionVisibilityConfig[permission]());
+            })
+                .map(([actionKey, actionConfig]) => actionKey);
+        }
+        return [];
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs || [];
+    }
+}
+exports.BillingEntityModel = BillingEntityModel;
+BillingEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "project",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "projectId",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.CLIENT,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "client",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "project.clientId",
+        },
+    },
+    {
+        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.REIMBURSEMENT_EXPENSE,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "reimbursementExpense",
+        mapKeyConfig: { relationKey: "projectId", key: "projectId" },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "billingIdReimbursementExpense",
+        mapKeyConfig: {
+            relationKey: "billingId",
+            key: "id",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.BILLING_TIMESHEET,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "billingTimesheets",
+        mapKeyConfig: {
+            relationKey: "billingId",
+            key: "id",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.BANK,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "bank",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "bankId",
+        },
+    },
+];

package/dist/src/entities/model/client-affiliate.entity.model.d.ts

@@ -0,0 +1,19 @@
+import { IClientAffiliateApiEntity } from "../../api";
+import { EntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
+export declare class ClientAffiliateEntityModel extends BaseEntityModel<EntityEnum.CLIENT_AFFILIATE> implements IClientAffiliateApiEntity {
+    id: number;
+    name: string;
+    address: string;
+    details?: string;
+    clientId: number;
+    organizationId: number;
+    zipCode: string;
+    country: string;
+    createdOn: string;
+    updatedOn: string;
+    createdBy: number;
+    updatedBy: number;
+    getRelationConfigs(): any;
+    static fromApiEntity(apiEntity: IClientAffiliateApiEntity): ClientAffiliateEntityModel;
+}

package/dist/src/entities/model/client-affiliate.entity.model.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAffiliateEntityModel = void 0;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class ClientAffiliateEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.name = "";
+        this.address = "";
+        this.clientId = 0;
+        this.organizationId = 0;
+        this.zipCode = "";
+        this.country = "";
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.createdBy = 0;
+        this.updatedBy = 0;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ClientAffiliateEntityModel(entity_utils_interface_1.EntityEnum.CLIENT_AFFILIATE);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+}
+exports.ClientAffiliateEntityModel = ClientAffiliateEntityModel;

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

@@ -0,0 +1,35 @@
+import { IClientApiEntity } from "../../api";
+import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { RelationConfigs } from "../interface/relation-config.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ProjectEntityModel } from "./project.entity.model";
+export declare class ClientEntityModel extends BaseEntityModel<EntityEnum.CLIENT> implements IClientApiEntity {
+    createdOn: string;
+    updatedOn: string;
+    id: number;
+    name: string;
+    description?: string;
+    primaryContactName: string;
+    primaryContact: string;
+    primaryEmail: string;
+    secondaryContactName?: string;
+    secondaryEmail?: string;
+    address?: string;
+    secondaryContact?: string;
+    country?: string;
+    industry?: string;
+    zipCode?: string;
+    organizationId: number;
+    reference?: string;
+    createdBy: number;
+    updatedBy: number;
+    projectIds?: number[];
+    billingOverdueDays: number;
+    projects: ProjectEntityModel[];
+    getRelationConfigs(): any;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.PROJECT
+    ], EnumEntityType<EntityEnum.CLIENT>>;
+    static fromApiEntity(apiEntity: IClientApiEntity): ClientEntityModel;
+    populateProjectIds(projects: ProjectEntityModel[]): ClientEntityModel;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEntityModel = void 0;
+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 ClientEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.id = 0;
+        this.name = "";
+        this.primaryContactName = "";
+        this.primaryContact = "";
+        this.primaryEmail = "";
+        this.organizationId = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.billingOverdueDays = 0;
+        this.projects = [];
+    }
+    getRelationConfigs() {
+        // return this.constructor.prototype.relationConfigs || [];
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ClientEntityModel(entity_utils_interface_1.EntityEnum.CLIENT);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    populateProjectIds(projects) {
+        this.projectIds = projects
+            .filter((project) => project.clientId === this.id)
+            .map((project) => project.id);
+        return this;
+    }
+}
+exports.ClientEntityModel = ClientEntityModel;
+ClientEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "projects",
+        mapKeyConfig: {
+            relationKey: "clientId",
+            key: "id",
+        },
+    },
+];

package/dist/src/entities/model/configuration.model.d.ts

@@ -1,20 +1,19 @@
-import { ConfigurationKeyEnum, ConfigurationTypeEnum, IConfigurationEntity } from "..";
-export interface IConfigurationsModel extends IConfigurationEntity {
-    isCronJobKey(): boolean;
-}
-export declare class ConfigurationsModel implements IConfigurationsModel {
+import { ConfigurationKeyEnum, ConfigurationTypeEnum } from "..";
+import { IConfigurationApiEntity } from "../../api";
+export declare class ConfigurationEntityModel implements IConfigurationApiEntity {
     id: number;
     key: ConfigurationKeyEnum;
     value: string;
     description: string;
     label: string;
     type: ConfigurationTypeEnum;
-    createdOn: Date;
-    updatedOn: Date;
+    createdOn: string;
+    updatedOn: string;
     createdBy: number;
     updatedBy: number;
     organizationId: number;
-    constructor(data: IConfigurationEntity);
+    constructor(data: IConfigurationApiEntity);
     isCronJobKey(): boolean;
-    static findByKey(configurationEntities: IConfigurationEntity[], key: ConfigurationKeyEnum): IConfigurationEntity | undefined;
+    static findByKey(configurationEntities: IConfigurationApiEntity[], key: ConfigurationKeyEnum): IConfigurationApiEntity | undefined;
+    static fromApiEntity(apiEntity: IConfigurationApiEntity): ConfigurationEntityModel;
 }

package/dist/src/entities/model/configuration.model.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationsModel = void 0;
+exports.ConfigurationEntityModel = void 0;
 const __1 = require("..");
-class ConfigurationsModel {
+class ConfigurationEntityModel {
     constructor(data) {
         this.id = 0;
         this.key = __1.ConfigurationKeyEnum.PENDING_APPROVAL_TIMESHEET_REMINDER;
@@ -10,8 +10,8 @@ class ConfigurationsModel {
         this.description = "";
         this.label = "";
         this.type = __1.ConfigurationTypeEnum.CRONJOB_EXPRESSION;
-        this.createdOn = new Date();
-        this.updatedOn = new Date();
+        this.createdOn = "";
+        this.updatedOn = "";
         this.createdBy = 0;
         this.updatedBy = 0;
         this.organizationId = 0;
@@ -23,5 +23,11 @@ class ConfigurationsModel {
     static findByKey(configurationEntities, key) {
         return configurationEntities.find((configurationEntity) => configurationEntity.key === key);
     }
+    static fromApiEntity(apiEntity) {
+        console.log("apiEntity", apiEntity);
+        const entity = new ConfigurationEntityModel(apiEntity);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
 }
-exports.ConfigurationsModel = ConfigurationsModel;
+exports.ConfigurationEntityModel = ConfigurationEntityModel;

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

@@ -1,11 +1,14 @@
-import { IDesignationEntity } from "../interface/designation.entity.interface";
-export declare class DesignationEntityModel implements IDesignationEntity {
+import { IDesignationApiEntity } from "../interface/designation.entity.interface";
+import { EntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
+export declare class DesignationEntityModel extends BaseEntityModel<EntityEnum.DESIGNATION> implements IDesignationApiEntity {
     id: number;
     name: string;
     description?: string;
     createdBy: number;
-    createdOn: Date;
+    createdOn: string;
     updatedBy: number;
-    updatedOn: Date;
-    constructor(data: IDesignationEntity);
+    updatedOn: string;
+    static fromApiEntity(apiEntity: IDesignationApiEntity): DesignationEntityModel;
+    getRelationConfigs(): any[];
 }

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

@@ -1,15 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DesignationEntityModel = void 0;
-class DesignationEntityModel {
-    constructor(data) {
-        this.id = data.id;
-        this.name = data.name;
-        this.description = data.description;
-        this.createdBy = data.createdBy;
-        this.createdOn = data.createdOn;
-        this.updatedBy = data.updatedBy;
-        this.updatedOn = data.updatedOn;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class DesignationEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.name = "";
+        this.createdBy = 0;
+        this.createdOn = "";
+        this.updatedBy = 0;
+        this.updatedOn = "";
+    }
+    //   constructor(data: IDesignationApiEntity) {
+    // this.id = data.id;
+    // this.name = data.name;
+    // this.description = data.description;
+    // this.createdBy = data.createdBy;
+    // this.createdOn = data.createdOn;
+    // this.updatedBy = data.updatedBy;
+    // this.updatedOn = data.updatedOn;
+    //   }
+    static fromApiEntity(apiEntity) {
+        const entity = new DesignationEntityModel(entity_utils_interface_1.EntityEnum.DESIGNATION);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs || [];
     }
 }
 exports.DesignationEntityModel = DesignationEntityModel;

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

@@ -0,0 +1,8 @@
+import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, IBaseEntityApiResponse } 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;
+    enumEntities: EntityEnum[];
+}): 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;

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToIndex = mapToIndex;
+exports.getEntityIndexMap = getEntityIndexMap;
+exports.populateRelationsFor = populateRelationsFor;
+exports.parseEntities = parseEntities;
+const timesheet_model_1 = require("../../model/entities/timesheet.model");
+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_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 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");
+const reimbursement_entity_model_1 = require("./reimbursement.entity.model");
+const task_entity_model_1 = require("./task.entity.model");
+const user_entity_model_1 = require("./user.entity.model");
+function mapToIndex(entityMap) {
+    return Object.keys(entityMap).reduce((acc, key) => {
+        // @ts-ignore
+        acc[key] = entityMap[key].reduce((innerAcc, entity) => {
+            innerAcc[entity.id] = entity;
+            return innerAcc;
+        }, {});
+        return acc;
+    }, {});
+}
+function getEntityIndexMap(data, baseEntity, reusedConfig) {
+    const entityMap = {};
+    parseEntities(data, baseEntity, entityMap);
+    const entityIndexMap = mapToIndex(entityMap);
+    if (reusedConfig) {
+        for (const entity of reusedConfig.enumEntities) {
+            // @ts-ignore
+            entityIndexMap[entity] = reusedConfig.existingEntityIndexMap[entity];
+        }
+    }
+    return entityIndexMap;
+}
+function populateRelationsFor(entityIndexMap, enumEntities) {
+    enumEntities.forEach((entity) => {
+        base_entity_model_1.BaseEntityModel.populateRelationsForEntities(entityIndexMap, entity);
+    });
+}
+function parseEntities(json, baseEntity, entityMap) {
+    var _a;
+    console.log("baseEntity", baseEntity);
+    const entityFromJsonMappings = {
+        [entity_utils_interface_1.EntityEnum.PROJECT]: project_entity_model_1.ProjectEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.CLIENT]: client_entity_model_1.ClientEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING]: billing_entity_model_1.BillingEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.USER]: user_entity_model_1.UserEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING]: project_user_mapping_entity_model_1.ProjectUserMappingEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT]: reimbursement_entity_model_1.ReimbursementEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE]: reimbursement_expense_entity_model_1.ReimbursementExpenseEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.CLIENT_AFFILIATE]: client_affiliate_entity_model_1.ClientAffiliateEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BANK]: bank_entity_model_1.BankEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.CONFIGURATION]: configuration_model_1.ConfigurationEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.TASK]: task_entity_model_1.TaskEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_TIMESHEET]: billing_timesheet_entity_model_1.BillingTimesheetEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.TIMESHEET]: timesheet_model_1.TimesheetEntityModel.fromApiEntity,
+    };
+    if (!(baseEntity in entityFromJsonMappings)) {
+        console.log("entityFromJsonMappings", entityFromJsonMappings);
+        throw new Error(`Unknown entity: ${baseEntity}`);
+    }
+    entityMap[baseEntity] = ((_a = json["baseEntities"]) !== null && _a !== void 0 ? _a : []).map((e) => entityFromJsonMappings[baseEntity](e));
+    console.log("entityMap", entityMap[entity_utils_interface_1.EntityEnum.CONFIGURATION]);
+    if (json["relatedEntities"]) {
+        const relatedEntities = json["relatedEntities"];
+        for (const entityName in relatedEntities) {
+            parseEntities(
+            // @ts-ignore
+            relatedEntities[entityName], entityName, entityMap);
+        }
+    }
+    return entityMap;
+}

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

@@ -1,19 +1 @@
-import { DateCodeModel } from "../../utils";
-import { IAuditColumnEntity } from "../interface/audit-column.entity.interface";
-import { IHolidayEntity } from "../interface/holiday.entity.interface";
-export declare class BaseEntityModel<T extends IAuditColumnEntity> {
-    createdOn: Date;
-    updatedOn: Date;
-    createdBy: number;
-    updatedBy: number;
-    constructor(data: T);
-}
-export declare class HolidayEntityModel extends BaseEntityModel<IHolidayEntity> implements IHolidayEntity {
-    id: number;
-    holidayListId: number;
-    dateCode: string;
-    private constructor();
-    getDateCodeModel(): DateCodeModel;
-    static fromEntity(data: IHolidayEntity): HolidayEntityModel;
-    static getDateCodeModelFromDate(models: HolidayEntityModel[]): DateCodeModel[];
-}
+export declare const toBeDeleted = "holiday";