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

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToIndex = mapToIndex;
+exports.getEntityIndexMap = getEntityIndexMap;
+exports.populateRelationsFor = populateRelationsFor;
+exports.parseEntities = parseEntities;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+const billing_reimbursement_expense_entity_model_1 = require("./billing-reimbursement-expense.entity.model");
+const billing_entity_model_1 = require("./billing.entity.model");
+const client_entity_model_1 = require("./client.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");
+const reimbursement_entity_model_1 = require("./reimbursement.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;
+    const entityFromJsonMappings = {
+        [entity_utils_interface_1.EntityEnum.PROJECT]: project_entity_model_1.ProjectEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.CLIENT]: client_entity_model_1.ClientEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING]: billing_entity_model_1.BillingEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.USER]: user_entity_model_1.UserEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING]: project_user_mapping_entity_model_1.ProjectUserMappingEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT]: reimbursement_entity_model_1.ReimbursementEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE]: reimbursement_expense_entity_model_1.ReimbursementExpenseEntity.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntity.fromApiEntity,
+    };
+    if (!(baseEntity in entityFromJsonMappings)) {
+        throw new Error(`Unknown entity: ${baseEntity}`);
+    }
+    entityMap[baseEntity] = ((_a = json["baseEntities"]) !== null && _a !== void 0 ? _a : []).map((e) => entityFromJsonMappings[baseEntity](e));
+    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";

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

@@ -1,31 +1,44 @@
 "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.HolidayEntityModel = exports.BaseEntityModel = void 0;
-const utils_1 = require("../../utils");
-class BaseEntityModel {
-    constructor(data) {
-        this.createdOn = data.createdOn;
-        this.updatedOn = data.updatedOn;
-        this.createdBy = data.createdBy;
-        this.updatedBy = data.updatedBy;
-    }
-}
-exports.BaseEntityModel = BaseEntityModel;
-class HolidayEntityModel extends BaseEntityModel {
-    constructor(data) {
-        super(data);
-        this.id = data.id;
-        this.holidayListId = data.holidayListId;
-        this.dateCode = data.dateCode;
-    }
-    getDateCodeModel() {
-        return new utils_1.DateCodeModel(this.dateCode);
-    }
-    static fromEntity(data) {
-        return new HolidayEntityModel(data);
-    }
-    static getDateCodeModelFromDate(models) {
-        return models.map((model) => model.getDateCodeModel());
-    }
-}
-exports.HolidayEntityModel = HolidayEntityModel;
+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";

package/dist/src/entities/model/project-user-mapping.entity.model.d.ts

@@ -0,0 +1,25 @@
+import { ProjectUserStatusEnum } from "../enums/project_user_status.enum";
+import { EntityEnum, EnumEntityType, IEntityApiResponse } from "../interface/entity.utils.interface";
+import { IProjectUserMappingEntity } from "../interface/project.entity.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { RelationConfigs } from "./client.entity.model";
+import { ProjectEntity } from "./project.entity.model";
+import { UserEntity } from "./user.entity.model";
+export declare class ProjectUserMappingEntity extends BaseEntityModel<EntityEnum.PROJECT_USER_MAPPING> implements IEntityApiResponse<IProjectUserMappingEntity> {
+    id: number;
+    projectId: number;
+    userId: number;
+    status: ProjectUserStatusEnum;
+    createdOn: string;
+    updatedOn: string;
+    createdBy: number;
+    updatedBy: number;
+    user?: UserEntity;
+    project?: ProjectEntity;
+    static fromApiEntity(apiEntity: IEntityApiResponse<IProjectUserMappingEntity>): ProjectUserMappingEntity;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.USER,
+        EntityEnum.PROJECT
+    ], EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>;
+    getRelationConfigs(): [import("./client.entity.model").IRelationConfig<EntityEnum.USER, EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>, import("./client.entity.model").IRelationConfig<EntityEnum.PROJECT, EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>];
+}

package/dist/src/entities/model/project-user-mapping.entity.model.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectUserMappingEntity = void 0;
+const project_user_status_enum_1 = require("../enums/project_user_status.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class ProjectUserMappingEntity extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.projectId = 0;
+        this.userId = 0;
+        this.status = project_user_status_enum_1.ProjectUserStatusEnum.ACTIVE;
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.createdBy = 0;
+        this.updatedBy = 0;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ProjectUserMappingEntity(entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getRelationConfigs() {
+        return ProjectUserMappingEntity.relationConfigs;
+    }
+}
+exports.ProjectUserMappingEntity = ProjectUserMappingEntity;
+ProjectUserMappingEntity.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: base_entity_model_1.RelationType.ONE,
+        key: "user",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "userId",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT,
+        relation: base_entity_model_1.RelationType.ONE,
+        key: "project",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "projectId",
+        },
+    },
+];

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

@@ -0,0 +1,39 @@
+import { IProjectApiEntity } from "../../api";
+import { CurrencyEnum } from "../../enums";
+import { ProjectBillingTypeEnum, ProjectStatusEnum } from "../enums/project.entity.enum";
+import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { IProjectUserDto } from "../interface/project.entity.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ClientEntity, RelationConfigs } from "./client.entity.model";
+import { ProjectUserMappingEntity } from "./project-user-mapping.entity.model";
+import { UserEntity } from "./user.entity.model";
+export declare class ProjectEntity extends BaseEntityModel<EntityEnum.PROJECT> implements IProjectApiEntity {
+    id: number;
+    name: string;
+    clientId: number;
+    startDate: string;
+    currency: CurrencyEnum;
+    billingType: ProjectBillingTypeEnum;
+    billingRate: string;
+    status: ProjectStatusEnum;
+    organizationId: number;
+    description?: string;
+    expectedEndDate?: string;
+    actualEndDate?: string;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    users?: IProjectUserDto[];
+    billingOverdueDays?: number;
+    userMappings?: (UserEntity & ProjectUserMappingEntity)[];
+    projectUserMappings?: ProjectUserMappingEntity[];
+    client: ClientEntity;
+    static fromApiEntity(apiEntity: IProjectApiEntity): ProjectEntity;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.PROJECT_USER_MAPPING,
+        EntityEnum.CLIENT
+    ], EnumEntityType<EntityEnum.PROJECT>>;
+    populateUsers(users: UserEntity[], projectUserMapping: ProjectUserMappingEntity[]): void;
+    getRelationConfigs(): [import("./client.entity.model").IRelationConfig<EntityEnum.PROJECT_USER_MAPPING, EnumEntityType<EntityEnum.PROJECT>>, import("./client.entity.model").IRelationConfig<EntityEnum.CLIENT, EnumEntityType<EntityEnum.PROJECT>>];
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectEntity = void 0;
+const enums_1 = require("../../enums");
+const project_entity_enum_1 = require("../enums/project.entity.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class ProjectEntity extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.name = "";
+        this.clientId = 0;
+        this.startDate = "";
+        this.currency = enums_1.CurrencyEnum.INR;
+        this.billingType = project_entity_enum_1.ProjectBillingTypeEnum.HOURLY;
+        this.billingRate = "";
+        this.status = project_entity_enum_1.ProjectStatusEnum.ACTIVE;
+        this.organizationId = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.users = [];
+        this.client = {};
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ProjectEntity(entity_utils_interface_1.EntityEnum.PROJECT);
+        entity.id = apiEntity.id;
+        entity.name = apiEntity.name;
+        entity.clientId = apiEntity.clientId;
+        entity.startDate = apiEntity.startDate;
+        entity.currency = apiEntity.currency;
+        entity.billingType = apiEntity.billingType;
+        entity.billingRate = apiEntity.billingRate;
+        entity.status = apiEntity.status;
+        entity.organizationId = apiEntity.organizationId;
+        entity.description = apiEntity.description;
+        entity.expectedEndDate = apiEntity.expectedEndDate;
+        entity.actualEndDate = apiEntity.actualEndDate;
+        entity.createdBy = apiEntity.createdBy;
+        entity.updatedBy = apiEntity.updatedBy;
+        entity.createdOn = apiEntity.createdOn;
+        entity.updatedOn = apiEntity.updatedOn;
+        entity.billingOverdueDays = apiEntity.billingOverdueDays;
+        return entity;
+    }
+    populateUsers(users, projectUserMapping) {
+        // const projectUserDto = projectUserMapping
+        //   .filter((mapping) => mapping.projectId === this.id)
+        //   .map((mapping) => {
+        //     const user = users.find((u) => u.id === mapping.userId);
+        //     if (user) {
+        //       return {
+        //         id: user.id,
+        //         role: user.role,
+        //         projectUserStatus: mapping.status,
+        //       };
+        //     } else {
+        //       continue;
+        //     }
+        //   });
+        // this.users = projectUserDto;
+        const projectUserDto = projectUserMapping
+            .filter((mapping) => mapping.projectId === this.id)
+            .flatMap((mapping) => {
+            const user = users.find((u) => u.id === mapping.userId);
+            return user
+                ? [
+                    {
+                        id: user.id,
+                        role: user.role,
+                        projectUserStatus: mapping.status,
+                    },
+                ]
+                : [];
+        });
+        this.users = projectUserDto;
+    }
+    getRelationConfigs() {
+        return ProjectEntity.relationConfigs;
+    }
+}
+exports.ProjectEntity = ProjectEntity;
+ProjectEntity.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING,
+        relation: base_entity_model_1.RelationType.MANY,
+        key: "projectUserMappings",
+        mapKeyConfig: {
+            relationKey: "projectId",
+            key: "id",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.CLIENT,
+        relation: base_entity_model_1.RelationType.ONE,
+        key: "client",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "clientId",
+        },
+    },
+];

package/dist/src/entities/model/reimbursement-expense.entity.model.d.ts

@@ -0,0 +1,27 @@
+import { ReimbursementEntity } from "./reimbursement.entity.model";
+import { RelationConfigs } from "./client.entity.model";
+import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ReimbursementExpenseState } from "../enums/reimbursement.entity.enum";
+import { IReimbursementExpenseApiEntity } from "../../api";
+export declare class ReimbursementExpenseEntity extends BaseEntityModel<EntityEnum.REIMBURSEMENT_EXPENSE> implements IReimbursementExpenseApiEntity {
+    id: number;
+    reimbursementId: number;
+    userId: number;
+    projectId: number;
+    expenseType: string;
+    amount: number;
+    state: ReimbursementExpenseState;
+    remark?: string;
+    sanctionedBy?: number;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    reimbursement?: ReimbursementEntity;
+    static fromApiEntity(apiEntity: IReimbursementExpenseApiEntity): ReimbursementExpenseEntity;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.REIMBURSEMENT
+    ], EnumEntityType<EntityEnum.REIMBURSEMENT_EXPENSE>>;
+    getRelationConfigs(): any;
+}

package/dist/src/entities/model/reimbursement-expense.entity.model.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReimbursementExpenseEntity = void 0;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+const reimbursement_entity_enum_1 = require("../enums/reimbursement.entity.enum");
+class ReimbursementExpenseEntity extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.reimbursementId = 0;
+        this.userId = 0;
+        this.projectId = 0;
+        this.expenseType = "";
+        this.amount = 0;
+        this.state = reimbursement_entity_enum_1.ReimbursementExpenseState.PENDING;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ReimbursementExpenseEntity(entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs || [];
+    }
+}
+exports.ReimbursementExpenseEntity = ReimbursementExpenseEntity;
+ReimbursementExpenseEntity.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.REIMBURSEMENT,
+        key: "reimbursement",
+        relation: base_entity_model_1.RelationType.ONE,
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "reimbursementId",
+        },
+    },
+];

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

@@ -0,0 +1,32 @@
+import { IReimbursementApiEntity } from "../../api";
+import { ReimbursementBillingPresentEnum, ReimbursementBillingTypeEnum, ReimbursementIncurredByEnum, ReimbursementPaymentStatusEnum, ReimbursementStatusEnum } from "../enums/reimbursement.entity.enum";
+import { EntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
+export declare class ReimbursementEntity extends BaseEntityModel<EntityEnum.REIMBURSEMENT> implements IReimbursementApiEntity {
+    id: number;
+    billingType: ReimbursementBillingTypeEnum;
+    billDate: string;
+    amount: number;
+    billNo?: string;
+    expenseIncurredBy: ReimbursementIncurredByEnum;
+    billPresent: ReimbursementBillingPresentEnum;
+    description: string;
+    attachmentUrlsCsv?: string;
+    status: ReimbursementStatusEnum;
+    paymentStatus: ReimbursementPaymentStatusEnum;
+    amountReimbursed?: number;
+    processedBy?: number;
+    processedDate?: string;
+    paymentDetails?: string;
+    remark?: string;
+    disbursementDate?: string;
+    referenceNo?: string;
+    bankId?: number;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    static relationConfigs: never[];
+    getRelationConfigs(): any[];
+    static fromApiEntity(apiEntity: IReimbursementApiEntity): ReimbursementEntity;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReimbursementEntity = void 0;
+const reimbursement_entity_enum_1 = require("../enums/reimbursement.entity.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class ReimbursementEntity extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.billingType = reimbursement_entity_enum_1.ReimbursementBillingTypeEnum.BILLABLE;
+        this.billDate = "";
+        this.amount = 0;
+        this.expenseIncurredBy = reimbursement_entity_enum_1.ReimbursementIncurredByEnum.SELF;
+        this.billPresent = reimbursement_entity_enum_1.ReimbursementBillingPresentEnum.NO;
+        this.description = "";
+        this.status = reimbursement_entity_enum_1.ReimbursementStatusEnum.APPROVAL_PENDING;
+        this.paymentStatus = reimbursement_entity_enum_1.ReimbursementPaymentStatusEnum.UNPAID;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs || [];
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ReimbursementEntity(entity_utils_interface_1.EntityEnum.REIMBURSEMENT);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+}
+exports.ReimbursementEntity = ReimbursementEntity;
+ReimbursementEntity.relationConfigs = [];

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

@@ -0,0 +1,14 @@
+import { ITaskApiEntity } from "../../api";
+import { TaskStatusEnum, TaskTypeEnum } from "../enums/task.entity.enum";
+export declare class TaskEntity implements ITaskApiEntity {
+    id: number;
+    name: string;
+    description: string;
+    status: TaskStatusEnum;
+    type: TaskTypeEnum;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    static fromApiEntity(apiEntity: ITaskApiEntity): TaskEntity;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskEntity = void 0;
+const task_entity_enum_1 = require("../enums/task.entity.enum");
+class TaskEntity {
+    constructor() {
+        this.id = 0;
+        this.name = "";
+        this.description = "";
+        this.status = task_entity_enum_1.TaskStatusEnum.active;
+        this.type = task_entity_enum_1.TaskTypeEnum.billable;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new TaskEntity();
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+}
+exports.TaskEntity = TaskEntity;

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

@@ -0,0 +1,18 @@
+import { ITimesheetApiEntity } from "../../api";
+import { TimesheetStatusEnum } from "../enums/timesheet.status.enum";
+export declare class TimesheetEntity implements ITimesheetApiEntity {
+    id: number;
+    userId: number;
+    projectId: number;
+    task: string;
+    description?: string;
+    dateCode: string;
+    totalDuration: number;
+    status: TimesheetStatusEnum;
+    remark?: string;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    static fromApiEntity(apiEntity: ITimesheetApiEntity): TimesheetEntity;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimesheetEntity = void 0;
+const timesheet_status_enum_1 = require("../enums/timesheet.status.enum");
+class TimesheetEntity {
+    constructor() {
+        this.id = 0;
+        this.userId = 0;
+        this.projectId = 0;
+        this.task = "";
+        this.dateCode = "";
+        this.totalDuration = 0;
+        this.status = timesheet_status_enum_1.TimesheetStatusEnum.CREATE_APPROVAL;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = "";
+        this.updatedOn = "";
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new TimesheetEntity();
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+}
+exports.TimesheetEntity = TimesheetEntity;

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

@@ -0,0 +1,43 @@
+import { IUserApiEntity } from "../../api";
+import { UserRoleEnum, UserStatusEnum } from "../enums/user.entity.enum";
+export declare class UserEntity implements IUserApiEntity {
+    id: number;
+    name: string;
+    email: string;
+    contactNo: string;
+    secondaryContactNo?: string;
+    password?: string;
+    userCode?: string;
+    joiningDate?: string;
+    endDate?: string;
+    address?: string;
+    zipCode?: number;
+    country?: string;
+    designation: string;
+    panNo?: string;
+    panDocumentUrl?: string;
+    aadharNo?: string;
+    aadharDocumentUrl?: string;
+    role: UserRoleEnum;
+    status?: UserStatusEnum;
+    organizationId: number;
+    passportDocumentUrl?: string;
+    academicQualificationDocumentUrl?: string;
+    officeAllocation: number;
+    tempAddress?: string;
+    tempZipCode?: number;
+    tempCountry?: string;
+    tempAddressSameAsPrimary: boolean;
+    emergencyContactName: string;
+    emergencyContactNo: string;
+    emergencyContactRelation: string;
+    secondEmergencyContactName?: string;
+    secondaryEmergencyContactNo?: string;
+    secondaryEmergencyContactRelation?: string;
+    permissions?: string[];
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    static fromApiEntity(apiEntity: IUserApiEntity): UserEntity;
+}