@seniorsistemas/hcm-clocking-event-rule-nodejs 0.35.0

package/src/data/context/contextReference.ts

@@ -0,0 +1,376 @@
+import { DateUtils } from "src/utils/dateUtils";
+import { TimeEvaluationSituationDefinitionHistory } from "../definition/timeEvaluationSituationDefinitionHistory";
+import { Holiday } from "./../foundation/holiday";
+import { Situation } from "./../foundation/situation";
+import { JobPosition } from "../foundation/jobPosition";
+import { CompanyBranch } from "../foundation/companyBranch";
+import { Workshift, WorkshiftGroup, WorkshiftDetail } from "../foundation/workshift";
+import { Workschedule } from "../foundation/workschedule";
+import { Syndicate } from "../foundation/syndicate";
+import { EmploymentRelationship } from "../foundation/employmentRelationship";
+import { CostCenter } from "../foundation/costCenter";
+
+/**
+ * @hidden
+ * Parâmetros para criar um ContextReference.
+ */
+export interface ContextReferenceParams {
+    situations: Situation[];
+    holidays: Holiday[];
+    timeEvaluationSituationDefinitions: TimeEvaluationSituationDefinitionHistory[];
+    jobPositions: JobPosition[];
+    companyBranches: CompanyBranch[];
+    workshifts: Workshift[];
+    workshiftGroups: WorkshiftGroup[];
+    workshiftDetails: WorkshiftDetail[];
+    workschedules: Workschedule[];
+    syndicates: Syndicate[];
+    employmentRelationships: EmploymentRelationship[];
+    costCenters: CostCenter[];
+}
+
+/**
+ * @hidden
+ * Parâmetros para criar uma referência de contexto.
+ */
+export class ContextReference {
+    private readonly _situations: Map<string, Situation>;
+    private readonly _situationsByCode: Map<number, Situation>;
+    private readonly _jobPositions: Map<string, JobPosition>;
+    private readonly _workshifts: Map<string, Workshift>;
+    private readonly _workshiftGroups: Map<string, WorkshiftGroup>;
+    private readonly _workshiftDetails: Map<string, WorkshiftDetail>;
+    private readonly _workschedules: Map<string, Workschedule>;
+    private readonly _companyBranches: Map<string, CompanyBranch>;
+    private readonly _holidays: Map<string, Holiday>;
+    private readonly _timeEvaluationSituationDefinitions: Map<string, TimeEvaluationSituationDefinitionHistory>;
+    private readonly _syndicates: Map<string, Syndicate>;
+    private readonly _employmentRelationships: Map<string, EmploymentRelationship>;
+    private readonly _costCenters: Map<string, CostCenter>;
+
+    // Instância global da ContextReference
+    private static _globalInstance: ContextReference | null = null;
+
+    constructor(params: ContextReferenceParams) {
+        this._holidays = new Map<string, Holiday>();
+        this._situations = new Map<string, Situation>();
+        this._situationsByCode = new Map<number, Situation>();
+        this._jobPositions = new Map<string, JobPosition>();
+        this._timeEvaluationSituationDefinitions = new Map<string, TimeEvaluationSituationDefinitionHistory>();
+        this._companyBranches = new Map<string, CompanyBranch>();
+        this._workshifts = new Map<string, Workshift>();
+        this._workshiftGroups = new Map<string, WorkshiftGroup>();
+        this._workshiftDetails = new Map<string, WorkshiftDetail>();
+        this._workschedules = new Map<string, Workschedule>();
+        this._syndicates = new Map<string, Syndicate>();
+        this._employmentRelationships = new Map<string, EmploymentRelationship>();
+        this._costCenters = new Map<string, CostCenter>();
+
+        this.mapSituation(params);
+        this.mapHoliday(params);
+        this.mapTimeEvaluationDefinition(params);
+        this.jobPosition(params);
+        this.companyBranch(params);
+        this.mapWorkshift(params);
+        this.mapWorkshiftGroups(params);
+        this.mapWorkshiftDetails(params);
+        this.mapWorkschedule(params);
+        this.mapSyndicate(params);
+        this.mapEmploymentRelationship(params);
+        this.mapCostCenter(params);
+
+    }
+
+
+    private mapTimeEvaluationDefinition(params: ContextReferenceParams) {
+        if (Array.isArray(params.timeEvaluationSituationDefinitions)) {
+            for (const timeEvaluationSituationDefinitionHistory of params.timeEvaluationSituationDefinitions) {
+
+                const newTimeEvaluationSituationDefinitionHistory = TimeEvaluationSituationDefinitionHistory.clone(timeEvaluationSituationDefinitionHistory);
+
+                const key = this.generateKeySituationDefinition(
+                    newTimeEvaluationSituationDefinitionHistory.code,
+                    newTimeEvaluationSituationDefinitionHistory.startDate,
+                    newTimeEvaluationSituationDefinitionHistory.endDate
+                );
+
+                this._timeEvaluationSituationDefinitions.set(key, newTimeEvaluationSituationDefinitionHistory);
+            }
+        }
+    }
+
+    private mapHoliday(params: ContextReferenceParams) {
+        if (Array.isArray(params.holidays)) {
+            for (const holiday of params.holidays) {
+                this._holidays.set(holiday.key, Holiday.clone(holiday));
+            }
+        }
+    }
+
+    private mapSituation(params: ContextReferenceParams) {
+        if (Array.isArray(params.situations)) {
+            for (const situation of params.situations) {
+                const newSituation = Situation.clone(situation);
+                this._situationsByCode.set(situation.code, newSituation);
+                this._situations.set(newSituation.id, newSituation);
+            }
+        }
+    }
+
+    private jobPosition(params: ContextReferenceParams) {
+        if (Array.isArray(params.jobPositions)) {
+            for (const jobPosition of params.jobPositions) {
+                const newJobPosition = new JobPosition({
+                    structureCode: jobPosition.structureCode,
+                    code: jobPosition.code
+                });
+
+                const key = this.generateKeyJobPosition(jobPosition.structureCode, jobPosition.code);
+                this._jobPositions.set(key, newJobPosition);
+            }
+        }
+    }
+
+
+    private mapWorkshift(params: ContextReferenceParams) {
+        if (Array.isArray(params.workshifts)) {
+            for (const workshift of params.workshifts) {
+                const newWorkshift = Workshift.clone(workshift);
+                this._workshifts.set(Workshift.getKey(newWorkshift), newWorkshift);
+            }
+        }
+    }
+
+    private mapWorkshiftGroups(params: ContextReferenceParams) {
+        if (Array.isArray(params.workshiftGroups)) {
+            for (const workshiftGroup of params.workshiftGroups) {
+                const newWorkshiftGroup = WorkshiftGroup.clone(workshiftGroup);
+                this._workshiftGroups.set(WorkshiftGroup.getKey(newWorkshiftGroup), newWorkshiftGroup);
+            }
+        }
+    }
+
+    private mapWorkshiftDetails(params: ContextReferenceParams) {
+        if (Array.isArray(params.workshiftDetails)) {
+            for (const workshiftDetail of params.workshiftDetails) {
+                const newWorkshiftDetail = WorkshiftDetail.clone(workshiftDetail);
+                this._workshiftDetails.set(WorkshiftDetail.getKey(newWorkshiftDetail), newWorkshiftDetail);
+            }
+        }
+    }
+
+    private mapWorkschedule(params: ContextReferenceParams) {
+        if (Array.isArray(params.workschedules)) {
+            for (const workschedule of params.workschedules) {
+                const newWorkschedule = new Workschedule({
+                    id: workschedule.id,
+                    code: workschedule.code,
+                    workload: workschedule.workload,
+                    type: workschedule.type,
+                    definitionType: workschedule.definitionType,
+                    clockingRegisters: workschedule.clockingRegisters,
+                    clockingEvent: workschedule.clockingEvent
+                });
+
+                this._workschedules.set(workschedule.id, newWorkschedule);
+            }
+        }
+    }
+
+
+    private companyBranch(params: ContextReferenceParams) {
+        if (Array.isArray(params.companyBranches)) {
+            for (const companyBrach of params.companyBranches) {
+                const newCompanyBranch = CompanyBranch.clone(companyBrach);
+                this._companyBranches.set(CompanyBranch.getKey(newCompanyBranch), newCompanyBranch);
+            }
+        }
+    }
+
+    private mapSyndicate(params: ContextReferenceParams) {
+        if (Array.isArray(params.syndicates)) {
+            for (const syndicate of params.syndicates) {
+                const newSyndicate = Syndicate.clone(syndicate);
+                this._syndicates.set(Syndicate.getKey(syndicate), newSyndicate);
+            }
+        }
+    }
+
+    private mapEmploymentRelationship(params: ContextReferenceParams) {
+        if (Array.isArray(params.employmentRelationships)) {
+            for (const employmentRelationship of params.employmentRelationships) {
+                const newEmploymentRelationship = new EmploymentRelationship({
+                    id: employmentRelationship.id,
+                    code: employmentRelationship.code,
+                    contractType: employmentRelationship.contractType
+                });
+
+                this._employmentRelationships.set(employmentRelationship.id, newEmploymentRelationship);
+            }
+        }
+    }
+
+    private mapCostCenter(params: ContextReferenceParams) {
+        if (Array.isArray(params.costCenters)) {
+            for (const costCenter of params.costCenters) {
+                const newCostCenter = new CostCenter({
+                    code: costCenter.code
+                });
+
+                this._costCenters.set(costCenter.code, newCostCenter);
+            }
+        }
+    }
+
+    private generateKeyJobPosition(structureCode: number, code: number): string {
+        return `${structureCode}_${code}`;
+    }
+
+    private generateKeySituationDefinition(code: number, startDate: Date, endDate: Date | null): string {
+        const endDateStr = endDate ? DateUtils.dateToIsoDateStr(endDate) : "null";
+        return `${code}_${DateUtils.dateToIsoDateStr(startDate)}_${endDateStr}`;
+    }
+
+    getSituationById(id: string): Situation | undefined {
+        return this._situations.get(id);
+    }
+
+    getSituationByCode(code: number): Situation | undefined {
+        return this._situationsByCode.get(code);
+    }
+
+    getHolidayByKey(key: string): Holiday {
+        const holiday = this._holidays.get(key);
+        if (!holiday) {
+            throw new Error(`Holiday with key ${key} not found`);
+        }
+        return holiday;
+    }
+
+    /**
+     * Buscar uma definição de situação
+     * @param code codigo da situação
+     * @param startDate data inicial
+     * @param endDate data final
+     * @returns Definição de situação
+     */
+    getTimeEvaluationSituationDefinitionHistory(key: string): TimeEvaluationSituationDefinitionHistory {
+        const timeEvaluationSituationDefinitionHistory = this._timeEvaluationSituationDefinitions.get(key);
+        if (!timeEvaluationSituationDefinitionHistory) {
+            throw new Error(`Time evaluation situation definition history with ${key} not found`);
+        }
+        return timeEvaluationSituationDefinitionHistory;
+    }
+
+    /**
+     * Busca o cargo de um colaborador com base no código do cargo e na estrutura do cargo.
+     * @param code código do cargo
+     * @param structureCode estrutura do cargo
+     * @returns cargo
+     */
+    getJobPosition(key: string): JobPosition | undefined {
+        return this._jobPositions.get(key);
+    }
+
+    /**
+     * Busca o centro de custo com base no código do centro de custo.
+     * @param code código do centro de custo
+     * @returns centro de custo
+     */
+    getCostCenter(code: string): CostCenter {
+        const costCenter = this._costCenters.get(code);
+        if (!costCenter) {
+            throw new Error(`Cost center with code ${code} not found`);
+        }
+        return costCenter;
+    }
+
+    /**
+     * Busca a filial de uma empresa com base na chave da filial.
+     * @param key chave da filial
+     * @returns filial da empresa
+     */
+    getCompanyBranch(key: string): CompanyBranch | undefined {
+        return this._companyBranches.get(key);
+    }
+
+    /**
+     * Busca a escala de trabalho com base no id da escala.
+     * @param id id da escala
+     * @returns escala de trabalho
+     */
+    getWorkshift(id: string): Workshift | undefined {
+        return this._workshifts.get(id);
+    }
+
+    /**
+     * Busca  turma de uma escala com base no id da turma.
+     * 
+     * @param id id da turma da escala.
+     * @returns workshiftGroup ou undefined se não encontrado
+     */
+    getWorkshiftGroup(id: string): WorkshiftGroup | undefined {
+        return this._workshiftGroups.get(id);
+    }
+
+    /**
+     * Busca as configurações de feriado de uma escala com base na chave do detalhe.
+     * 
+     * @param key chave de identificação das configurações da escala.
+     * @returns workshiftDetail ou undefined se não encontrado
+     */
+    getWorkshiftDetail(key: string): WorkshiftDetail | undefined {
+        return this._workshiftDetails.get(key);
+    }
+
+    /**
+     * Busca o horário de trabalho com base no id da escala.
+     * @param id id da escala
+     * @returns escala de trabalho
+     */
+    getWorkschedule(id: string): Workschedule | undefined {
+        return this._workschedules.get(id);
+    }
+
+    /**
+     * Busca o sindicato do histórico vigente na data de apuração com base no código.
+     * @param code código do sindicato
+     * @returns Objeto Syndicate
+     */
+    getSyndicate(code: string): Syndicate | undefined {
+        return this._syndicates.get(code);
+    }
+
+    /**
+     * Busca o vínculo do histórico vigente na data de apuração com base no ID do vínculo.
+     * @param id ID do vínculo
+     * @returns Objeto EmploymentRelationship
+     */
+    getEmploymentRelationship(id: string): EmploymentRelationship {
+        const employmentRelationship = this._employmentRelationships.get(id);
+        if (!employmentRelationship) {
+            throw new Error(`Employment relationship with id ${id} not found`);
+        }
+        return employmentRelationship;
+    }
+
+    /**
+     * Define a instância global de ContextReference
+     * @param instance Instância a ser definida globalmente
+     */
+    public static setGlobalInstance(instance: ContextReference | null) {
+        ContextReference._globalInstance = instance;
+    }
+
+    /**
+     * Obtém a instância global de ContextReference
+     * @returns Instância global
+     * @throws Se a instância global não foi definida
+     */
+    public static getGlobalInstance(): ContextReference {
+        if (!ContextReference._globalInstance) {
+            throw new Error("ContextReference global instance not set. Use setGlobalInstance().");
+        }
+        return ContextReference._globalInstance;
+    }
+}

package/src/data/contract/contract.ts

@@ -0,0 +1,272 @@
+import { ContextReference } from "../context/contextReference";
+import { Employee } from "../employee/employee";
+import { Histories } from "../histories/histories";
+import { Holiday } from "../foundation/holiday";
+import { HourBankAccount } from "../hourBank/hourBankAccount";
+import { Schedules } from "../schedules/schedules";
+import { TimeEvaluation } from "../timeEvaluation/timeEvaluation";
+
+/**
+ * Interface para os parâmetros do construtor de Contract.
+ * @hidden
+ */
+export interface ContractParams {
+    id: string;
+    holidaysKeys: string[];
+    timeEvaluation: TimeEvaluation[];
+    employee: Employee;
+    histories: Histories;
+    schedules: Schedules;
+    hourBankAccounts: HourBankAccount[];
+}
+
+/**
+ * O contrato é a unidade de trabalho do colaborador, onde são armazenadas as informações de apuração, colaborador, históricos, programações, banco de horas e feriados.
+ * 
+ * O contrato é composto por:
+ * - Apurações de cada dia, deve ser feito uma iteração para cada dia do contrato, onde são apuradas as situações do colaborador.
+ * - Colaborador, informações do colaborador.
+ * - Contas nos bancos de horas: código do banco de horas, data de criação e, se existir, data de extinção.
+ * - Históricos: históricos do colaborador, como sindicato, afastamento, escala, etc.
+ * - Programações: programações do colaborador, como escala, horário de trabalho, etc.
+ * - Feriados: feriados dos dias apurados.
+ * 
+ * @example
+ * ```javascript
+ * context.contracts.forEach(contract => {
+ *     context.logInfo(`Colaborador: ${contract.employee.person.name}`);
+ * });
+ * ```
+ */
+
+export class Contract {
+    private readonly _id: string;
+    private readonly _holidaysKeys: string[];
+    private readonly _timeEvaluation: TimeEvaluation[];
+    private readonly _employee: Employee;
+    private readonly _histories: Histories;
+    private readonly _schedules: Schedules;
+    private readonly _hourBankAccounts: HourBankAccount[];
+
+    /**
+     * @hidden
+     */
+    constructor(params: ContractParams) {
+
+        this._id = params.id;
+
+        if (params.employee) {
+            this._employee = Employee.clone(params.employee);
+        }
+
+        this._histories = new Histories({
+            jobPositionHistories: params.histories.jobPositionHistories,
+            companyBranchHistories: params.histories.companyBranchHistories,
+            employmentRelationshipHistories: params.histories.employmentRelationshipHistories,
+            timeEvaluationHistories: params.histories.timeEvaluationHistories,
+            workshiftHistories: params.histories.workshiftHistories,
+            costCenterHistories: params.histories.costCenterHistories,
+            leaveHistories: params.histories.leaveHistories,
+        });
+
+
+        if (params.schedules) {
+            this._schedules = Schedules.clone(params.schedules);
+            
+        } else {
+            this._schedules = Schedules.default();
+        }
+
+        this._hourBankAccounts = [];
+        if (params.hourBankAccounts && Array.isArray(params.hourBankAccounts)) {
+            for (const account of params.hourBankAccounts) {
+                const newAccount = new HourBankAccount({
+                    hourBank: account.hourBank,
+                    creationDate: account.creationDate,
+                    extinctionDate: account.extinctionDate,
+                });
+                this._hourBankAccounts.push(newAccount);
+            }
+        }
+
+        if (params.holidaysKeys && Array.isArray(params.holidaysKeys)) {
+            this._holidaysKeys = params.holidaysKeys;
+        } else {
+            this._holidaysKeys = [];
+        }
+
+
+
+        this._timeEvaluation = [];
+        for (const timeEvaluationItem of params.timeEvaluation) {
+            const timeEvaluation = TimeEvaluation.clone(timeEvaluationItem, this);
+            this._timeEvaluation.push(timeEvaluation);
+        }
+
+
+    }
+
+    /**
+     * @hidden
+     * Id do contrato.
+     * @return Id do contrato.
+     */
+    get id(): string {
+        return this._id;
+    }
+
+    /**
+     * Colaborador do contrato de apuração, dentro do colaborador pode ser encontrado:
+     * - Informações pessoais do colaborador, como nome.
+     * - Informação da empresa do colaborador.
+     * - Informações sobre históricos atuais como: centro de custo, filial, cargo, vínculo empregatício, etc.
+     *  
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * console.log(`Colaborador: ${contract.employee.person.name}`);
+     * ```
+     * 
+     * @return Colaborador do contrato.
+     * @see {@link Employee}
+     */
+    get employee(): Employee {
+        return this._employee;
+    }
+
+    /**
+     * Lista das apurações do contrato do colaborador, somente os dias apurados serão listados.
+     * Cada apuração representa um dia de trabalho do colaborador, onde são apuradas as situações do colaborador, como faltas, atrasos, horas extras, etc.
+     * 
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * for (const timeEvaluation of contract.timeEvaluation) {
+     *     console.log(`Data: ${timeEvaluation.date}`);
+     * }
+     * ```
+     * @return Lista de apurações do contrato do colaborador.
+     * @see {@link TimeEvaluation}
+     */
+    get timeEvaluation(): TimeEvaluation[] {
+        return this._timeEvaluation;
+    }
+
+    /**
+     * @hidden
+     * Chaves dos feriados do contrato.
+     */
+    get holidaysKeys(): string[] {
+        return this._holidaysKeys;
+    }
+
+    /**
+     * Busca os feriados do contrato do colaborador no período apurado.
+     * Caso não encontre feriados, retorna undefined.
+     * Atenção: o sistema carrega os feriados do contrato do colaborador no período apurado mais 3 dias antes e 3 dias depois.
+     * 
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * // Parâmetro date deve ser uma data no período de apuração do contrato.
+     * let holiday = contract.getHolidayByDate(new Date("2023-01-01"));
+     * if (holiday) {
+     *     console.log(`Feriado encontrado na data: ${DateUtils.format(holiday.date)}`);
+     * } else {
+     *    console.log("Feriado não encontrado nesta data.");
+     * }
+     * ```
+     * 
+     * @param date Data do feriado.
+     * @return Feriado ou undefined.
+     * @see {@link Holiday}
+     */
+    public getHolidayByDate(date: Date): Holiday | undefined {
+
+        for (const key of this._holidaysKeys) {
+            const holiday = ContextReference.getGlobalInstance().getHolidayByKey(key);
+            if (holiday && holiday.date.getTime() === date.getTime()) {
+                return holiday;
+            }
+        }
+
+        return undefined;
+    }
+
+
+    /**
+     * Retorna informações sobre os históricos do colaborador no período da apuração.
+     * Os históricos podem incluir informações como: centro de custo, filial, cargo, vínculo empregatício, etc. 
+     * 
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * context.logInfo(`Existem ${contract.histories.jobPositionHistories.length} históricos de cargo no período.`);}`);
+     * ```
+     */
+    get histories(): Histories {
+        return this._histories;
+    }
+
+    /**
+     * Programações do colaborador no período da apuração.
+     * As programações podem incluir informações como: pontes, troca de escala, troca de horário, etc.
+     * 
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * context.logInfo(`Existem ${contract.schedules.bridges.length} pontes no período.`);}`);
+     * ```
+     * @return Programações do colaborador no período da apuração.
+     * @see {@link Schedules}
+     */
+    get schedules(): Schedules {
+        return this._schedules;
+    }
+
+    /**
+     * Conta de banco de horas do colaborador no período da apuração.
+     * 
+     * @example
+     * ```javascript
+     * let contract = context.contracts[0];
+     * for (const account of contract.hourBankAccounts) {
+     *    context.logInfo(`Conta de banco de horas criada na data ${DateUtils.format(account.creationDate)}`);
+     *    context.logInfo(`Banco de horas: ${account.hourBank.code}`);
+     * }
+     * ```
+     * @return Contas dos bancos de horas do colaborador no período da apuração.
+     * @see {@link HourBankAccount}
+     */
+    get hourBankAccounts(): HourBankAccount[] {
+        return this._hourBankAccounts;
+    }
+}
+
+/**
+ * Enumeração para os tipos de contrato de trabalho.
+ * @enum
+ */
+export enum ContractType {
+    /**
+     * Contrato de trabalho de um empregado.
+     */
+    EMPLOYEE = "EMPLOYEE",
+    /**
+     * Contrato de trabalho de um diretor.
+     */
+    DIRECTOR = "DIRECTOR",
+    /**
+     * Contrato de trabalho de um estagiário.
+     */
+    TRAINEE = "TRAINEE",
+    /**
+     * Contrato de trabalho de um aprendiz.
+     */
+    APRENTICE = "APPRENTICE",
+    /**
+     * Contrato de trabalho de um terceiro.
+     */
+    THIRD_PARTY = "THIRD_PARTY",
+}
+