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

package/src/data/schedules/readiness.ts

@@ -0,0 +1,150 @@
+import { ObjectUtils } from "src/utils/object.utils";
+import { Situation } from "../foundation/situation";
+import { ContextReference } from '../context/contextReference';
+
+/**
+ * @hidden
+ * Parâmetros para criar uma programação de Readiness.
+ * @param originDate Data de origem do sobreaviso.
+ * @param destinationDate Data de destino do sobreaviso.
+ * @typedef {Object} ReadinessParams
+ */
+export interface ReadinessParams {
+    /** Data inicial do sobreaviso. */
+    startDate: Date;
+    /** Data final do sobreaviso. */
+    endDate: Date;
+    /** Hora inicial do sobreaviso. */
+    startTime: number;
+    /** Hora final do sobreaviso. */
+    endTime: number;
+    /** Indica se o sobreaviso é contínuo. */
+    continuous: boolean;
+    /** Identificador da situação do sobreaviso. */
+    situationId: string;
+}
+
+/**
+ * Representa uma programação de sobreaviso.
+ * A programação de sobreaviso é utilizada para informar o período no qual o colaborador estará de sobreaviso ou prontidão a serviço da empresa.
+ */
+export class Readiness {
+
+    /**
+     * Data inicial do sobreaviso.
+     * @param startDate Data inicial do sobreaviso.
+     */
+    private readonly _startDate: Date;
+
+    /**
+     * Data final do sobreaviso.
+     * @param endDate Data final do sobreaviso.
+     */
+    private readonly _endDate: Date;
+
+    /**
+     * Hora inicial do sobreaviso.
+     * @param startTime Hora inicial do sobreaviso.
+     */
+    private readonly _startTime: number;
+
+    /**
+     * Hora final do sobreaviso.
+     * @param endTime Hora final do sobreaviso.
+     */
+    private readonly _endTime: number;
+
+    /**
+     * Indica se o sobreaviso é contínuo.
+     * @param continuous Indica se o sobreaviso é contínuo.
+     */
+    private readonly _continuous: boolean;
+
+    /**
+     * Identificador da situação do sobreaviso.
+     * @param situationId Identificador da situação do sobreaviso.
+     */
+    private readonly _situationId: string;
+
+    constructor(params: ReadinessParams) {
+        this._startDate = ObjectUtils.toDateOrThrow(params.startDate, "readiness.startDate");
+        this._endDate = ObjectUtils.toDateOrThrow(params.endDate, "readiness.endDate");
+        this._startTime = params.startTime;
+        this._endTime = params.endTime;
+        this._continuous = params.continuous;
+        this._situationId = params.situationId;
+    }
+
+    /**
+     * Data inicial do sobreaviso.
+     * @returns Data inicial do sobreaviso.
+     */
+    get startDate(): Date {
+        return this._startDate;
+    }
+
+    /**
+     * Data final do sobreaviso.
+     * @returns Data final do sobreaviso.
+     */
+    get endDate(): Date {
+        return this._endDate;
+    }
+
+    /**
+     * Hora inicial do sobreaviso.
+     * @returns Hora inicial do sobreaviso.
+     */
+    get startTime(): number {
+        return this._startTime;
+    }
+
+    /**
+     * Hora final do sobreaviso.
+     * @returns Hora final do sobreaviso.
+     */
+    get endTime(): number {
+        return this._endTime;
+    }
+
+    /**
+     * Indica se o sobreaviso é contínuo.
+     * @returns Indica se o sobreaviso é contínuo.
+     */
+    get continuous(): boolean {
+        return this._continuous;
+    }
+
+    /**
+     * Identificador da situação do sobreaviso.
+     * @returns Identificador da situação do sobreaviso.
+     */
+    private get situationId(): string {
+        return this._situationId;
+    }
+
+    /**
+     * Obtém a situação associada ao sobreaviso.
+     * @returns Situação associada ao sobreaviso.
+     * @throws Se a situação não for encontrada no contexto.
+     */
+    get situation(): Situation {
+        const situation = ContextReference.getGlobalInstance().getSituationById(this._situationId);
+        if (!situation) {
+            throw new Error(`Situação com ID ${this._situationId} não encontrada no contexto.`);
+        }
+        return situation;
+    }
+
+    public static clone(readiness: Readiness): Readiness {
+        return new Readiness({
+            startDate: readiness.startDate,
+            endDate: readiness.endDate,
+            startTime: readiness.startTime,
+            endTime: readiness.endTime,
+            continuous: readiness.continuous,
+            situationId: readiness.situationId
+        });
+    }
+
+}

package/src/data/schedules/schedules.ts

@@ -0,0 +1,398 @@
+import { DateUtils } from "../../utils/dateUtils";
+import { Bridge } from "./bridge";
+import { Readiness } from "./readiness";
+import { Compensation } from "./compensation";
+import { WorkscheduleChange } from "./workscheduleChange";
+import { WorkshiftChange } from "./workshiftChange";
+import { OvertimeAuthorization } from "./overtimeAuthorization";
+import { TimeEvaluation } from "../timeEvaluation/timeEvaluation";
+
+/**
+ * @hidden
+ * Parâmetros para a classe Schedules.
+ * @param bridges Lista de pontes.
+ * @param workscheduleChanges Lista de trocas de horário de trabalho.
+ * @param workshiftChanges Lista de trocas de escala.
+ * @param readinesses Lista de sobreavisos.
+ * @param overtimeAuthorizations Lista de autorizações de horas extras.
+ * @param compensations Lista de compensações.
+ *
+ */
+export interface SchedulesParams {
+    bridges: Bridge[];
+    workscheduleChanges: WorkscheduleChange[];
+    workshiftChanges: WorkshiftChange[];
+    readinesses: Readiness[];
+    overtimeAuthorizations: OvertimeAuthorization[];
+    compensations: Compensation[];
+}
+
+/**
+ * Representa as programações do colaborador no período calculado, como: autorização de horas extras, compensação, sobreaviso/prontidão, ponte e trocas de horário e escala.
+ * Aqui serão apresentadas todas as programações do perído calculado, no objeto apuração ({@link TimeEvaluation}), as programações já estão no contexto do dia, exibindo apenas as programações do dia.
+ * 
+ * - O período calculado considera, no mínimo, o período de apuração do cálculo da competência mais 5 dias anteriores e 4 dias posteriores conforme configurado em "Retornar dias" na definição de apuração.
+ * 
+ * ```
+ * Demontração do período calculado
+ * 
+ * Período de apuração do cálculo = 24/03/2025 a 23/04/2025
+ * Data inicial = data início do cálculo - 4 dias extras - valor parametrizado em `Retornar dias` (se for nulo assume 1 dia)
+ * Data final = data fim do cálculo + 4 dias extras
+ * Período calculado = 19/03/2025 a 27/04/2025
+ * ```
+ * @example
+ * ```typescript
+ * schedules.bridges; // Retorna as pontes do colaborador no período calculado.
+ * schedules.workscheduleChanges; // Retorna as trocas de horário de trabalho do colaborador no período calculado.
+ * schedules.workshiftChanges; // Retorna as trocas de escala do colaborador no período calculado.
+ * schedules.compensations; // Retorna as compensações de horas do colaborador no período calculado.
+ * schedules.overtimeAuthorizations; // Retorna as autorizações de horas extras do colaborador no período calculado.
+ * schedules.readinesses; // Retorna os sobreavisos/prontidão do colaborador no período calculado.
+ * ```
+ * @see {@link bridges}
+ * @see {@link workshiftChanges}
+ * @see {@link workscheduleChanges}
+ * @see {@link compensations}
+ * @see {@link overtimeAuthorizations}
+ * @see {@link readinesses}
+ * ```
+ * 
+ */
+export class Schedules {
+    private readonly _bridges: Bridge[];
+    private readonly _worksheduleChanges: WorkscheduleChange[];
+    private readonly _workshiftChanges: WorkshiftChange[];
+    private readonly _readinesses: Readiness[];
+    private readonly _overtimeAuthorizations: OvertimeAuthorization[];
+    private readonly _compensations: Compensation[];
+
+    /**
+     * @hidden
+     * @param params Parâmetros necessários para criar uma instância de Schedules.
+     */
+    constructor(params: SchedulesParams) {
+        this._bridges = [];
+        this._worksheduleChanges = [];
+        this._workshiftChanges = [];
+        this._readinesses = [];
+        this._overtimeAuthorizations = [];
+        this._compensations = [];
+
+        this.mapBridges(params);
+        this.mapWorkscheduleChanges(params);
+        this.mapWorkshiftChange(params);
+        this.mapReadiness(params);
+        this.mapOvertimeAuthorizations(params);
+        this.mapCompensation(params);
+    }
+
+    private mapWorkscheduleChanges(params: SchedulesParams) {
+        if (Array.isArray(params.workscheduleChanges)) {
+            for (const workshiftChange of params.workscheduleChanges) {
+                this._worksheduleChanges.push(WorkscheduleChange.clone(workshiftChange));
+            }
+        }
+    }
+
+    private mapBridges(params: SchedulesParams) {
+        if (Array.isArray(params.bridges)) {
+            for (const bridge of params.bridges) {
+                this._bridges.push(Bridge.clone(bridge));
+            }
+        }
+    }
+
+    private mapWorkshiftChange(params: SchedulesParams) {
+        if (Array.isArray(params.workshiftChanges)) {
+            for (const workshiftChange of params.workshiftChanges) {
+                this._workshiftChanges.push(WorkshiftChange.clone(workshiftChange));
+            }
+        }
+    }
+
+    private mapReadiness(params: SchedulesParams) {
+        if (Array.isArray(params.readinesses)) {
+            for (const readiness of params.readinesses) {
+                this._readinesses.push(Readiness.clone(readiness));
+            }
+        }
+    }
+
+    private mapOvertimeAuthorizations(params: SchedulesParams) {
+        if (Array.isArray(params.overtimeAuthorizations)) {
+            for (const overtimeAuthorization of params.overtimeAuthorizations) {
+                this._overtimeAuthorizations.push(OvertimeAuthorization.clone(overtimeAuthorization));
+            }
+        }
+    }
+
+    private mapCompensation(params: SchedulesParams) {
+        if (Array.isArray(params.compensations)) {
+            for (const compensation of params.compensations) {
+                this._compensations.push(Compensation.clone(compensation));
+            }
+        }
+    }
+
+    /**
+     * @hidden
+     * Cria uma nova instância de Schedules vazia.
+     */
+    static default(): Schedules {
+        return new Schedules({ bridges: [], workscheduleChanges: [], workshiftChanges: [], readinesses: [], overtimeAuthorizations: [], compensations: [] });
+    }
+
+    /**
+     * Retorna as pontes do colaborador no período calculado.
+     * Usa o método {@link findBridgeByDate} para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const bridges = schedules.bridges; // Retorna todas as pontes do colaborador no período calculado.
+     * bridges.forEach(bridge => {
+     *   console.log(`Ponte de ${bridge.originDate} até ${bridge.destinationDate
+     * }`);
+     * ```
+     * 
+     * @returns Lista de pontes do colaborador no período calculado.
+     *
+     * @see {@link Bridge}
+     */
+    get bridges(): Bridge[] {
+        return this._bridges;
+    }
+
+    /**
+     * Retorna as trocas de horário de trabalho do colaborador no período calculado.
+     * Usa o método {@link findWorkscheduleChangeByDate}  para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const workscheduleChanges = schedules.workscheduleChanges; // Retorna todas as trocas de horário de trabalho do colaborador no período calculado.
+     * workscheduleChanges.forEach(change => {
+     *  console.log(`Troca de horário em ${change.date}: ${change.workschedule.code}`);
+     * });
+     * ```
+     * 
+     * @returns Lista de trocas de horário de trabalho do colaborador no período calculado.
+     * 
+     * @see {@link WorkscheduleChange}
+     * @see {@link Workschedule}
+     */
+    get workscheduleChanges(): WorkscheduleChange[] {
+        return this._worksheduleChanges;
+    }
+
+    /**
+     * Retorna as trocas de escala do colaborador no período calculado.
+     * Usa o método {@link findWorkshiftChangeByDate}  para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const workshiftChanges = schedules.workshiftChanges; // Retorna todas as trocas de escala do colaborador no período calculado.
+     * workshiftChanges.forEach(change => {
+     *  console.log(`Troca de escala de ${change.startDate} até ${change.endDate}: ${change.workshift.code}`);
+     * });
+     * ```
+     * 
+     * @returns Lista de trocas de escala do colaborador no período calculado.
+     * 
+     * @see {@link WorkshiftChange}
+     * @see {@link Workshift}
+     */
+    get workshiftChanges(): WorkshiftChange[] {
+        return this._workshiftChanges;
+    }
+
+    /**
+     * Retorna os sobreavisos do colaborador no período calculado.
+     * Usa o método {@link findReadinessByDate}  para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const readinesses = schedules.readinesses; // Retorna os sobreavisos do colaborador no período calculado.
+     * readinesses.forEach(readiness => {
+     *  console.log(`Programação de sobreaviso de ${readiness.startDate} até ${readiness.endDate}`);
+     * });
+     * ```
+     * 
+     * @returns Lista de sobreavisos do colaborador no período calculado.
+     * 
+     * @see {@link Readiness}
+     */
+    get readinesses(): Readiness[] {
+        return this._readinesses;
+    }
+
+    /**
+     * Retorna as autorizações de horas extras do colaborador no período calculado.
+     * Usa o método {@link findOvertimeAuthorizationByDate}  para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const overtimeAuthorizations = schedules.overtimeAuthorizations; // Retorna as autorizações de horas extras do colaborador no período calculado.
+     * overtimeAuthorizations.forEach(auth => {
+     *  console.log(`Autorização de horas extras de ${auth.startDate} até ${auth.endDate}`);
+     * });
+     * ```
+     * 
+     * @returns Lista de autorizações de horas extras do colaborador no período calculado.
+     * 
+     * @see {@link OvertimeAuthorization}
+     */
+    get overtimeAuthorizations(): OvertimeAuthorization[] {
+        return this._overtimeAuthorizations;
+    }
+
+    /**
+     * Retorna as compensações de horas do colaborador no período calculado.
+     * Usa o método {@link findCompensationByDate}  para buscar de um dia específico.
+     * 
+     * @example
+     * ```typescript
+     * const compensations = schedules.compensation; // Retorna as compensações de horas do colaborador no período calculado.
+     * compensations.forEach(compensation => {
+     *  console.log(`Compensação de ${compensation.startDate} até ${compensation.endDate}: ${compensation.numberOfHours} horas`);
+     * });
+     * ```
+     * 
+     * @returns Lista de compensações de horas do colaborador no período calculado.
+     * 
+     * @see {@link Compensation}
+     */
+    get compensations(): Compensation[] {
+        return this._compensations;
+    }
+
+    /**
+     * Busca a ponte de um dia específico verificando se a data é igual a originDate ou destinationDate.
+     * @example
+     * ```typescript
+     * const bridge = findBridgeByDate(new Date("2024-02-02"));
+     * if(bridge) {
+     *   ...
+     * }
+     * ```
+     * 
+     * @param date Data a ser usada no filtro.
+     * @returns A ponte que corresponde ao critério ou undefined se não encontrar.
+     */
+    findBridgeByDate(date: Date): Bridge | undefined {
+        return this._bridges.find((bridge) => {
+            return DateUtils.equals(bridge.originDate, date) || DateUtils.equals(bridge.destinationDate, date);
+        });
+    }
+
+    /**
+     * Busca a troca de horário de um dia específico verificando se a data é igual a date.
+     * @example
+     * ```typescript
+     * const workscheduleChange = findWorkscheduleByDate(new Date("2024-02-02"));
+     * if(workscheduleChange) {
+     *   ...
+     * }
+     * ```
+     * @param date Data a ser usada no filtro
+     * @returns A troca de horário que corresponde ao critério ou undefined se não encontrar.
+     */
+    findWorkscheduleChangeByDate(date: Date): WorkscheduleChange | undefined {
+        return this._worksheduleChanges.find((workscheduleChange) => {
+            return DateUtils.equals(workscheduleChange.date, date);
+        });
+    }
+
+    /**
+     * Busca a troca de escala de um dia específico verificando se a data está entre startDate e endDate.
+     * @example
+     * ```typescript
+     * const workshiftChange = findWorkshiftChangeByDate(new Date("2024-02-02"));
+     * if(workshiftChange) {
+     *   ...
+     * }
+     * ```
+     * 
+     * @param date Data a ser usada no filtro.
+     * @returns A troca de escala que corresponde ao critério ou undefined se não encontrar.
+     */
+    findWorkshiftChangeByDate(date: Date): WorkshiftChange | undefined {
+        return this._workshiftChanges.find((workshiftChange) => {
+            return DateUtils.between(date, workshiftChange.startDate, workshiftChange.endDate);
+        });
+    }
+
+    /**
+     * Busca o sobreaviso de um dia específico verificando se a data está entre startDate e endDate.
+     * @example
+     * ```typescript
+     * const readiness = findReadinessByDate(new Date("2024-02-02"));
+     * if(readiness) {
+     *   ...
+     * }
+     * ```
+     * 
+     * @param date Data a ser usada no filtro.
+     * @returns O sobreaviso que corresponde ao critério ou undefined se não encontrar.
+     */
+    findReadinessByDate(date: Date): Readiness[] {
+        return this._readinesses.filter((readiness) => {
+            return DateUtils.between(date, readiness.startDate, readiness.endDate);
+        });
+    }
+
+    /**
+     * Busca a autorização de horas extras de um dia específico verificando se a data está entre startDate e endDate.
+     * @example
+     * ```typescript
+     * const overtimeAuthorization = findOvertimeAuthorizationByDate(new Date("2024-02-02"));
+     * if(overtimeAuthorization) {
+     *   ...
+     * }
+     * ```
+     * 
+     * @param date Data a ser usada no filtro.
+     * @returns A autorização de horas extras que corresponde ao critério ou undefined se não encontrar.
+     */
+    findOvertimeAuthorizationByDate(date: Date): OvertimeAuthorization[] {
+        return this._overtimeAuthorizations.filter((overtimeAuthorization) => {
+            return DateUtils.between(date, overtimeAuthorization.startDate, overtimeAuthorization.endDate);
+        });
+    }
+
+    /**
+     * Busca a compensação de um dia específico verificando se a data está entre startDate e endDate.
+     * @example
+     * ```typescript
+     * const compensations = findCompensationByDate(new Date("2024-02-02"));
+     * if(compensations.length > 0) {
+     *   ...
+     * }
+     * ```
+     * 
+     * @param date Data a ser usada no filtro.
+     * @returns A compensação que corresponde ao critério ou uma lista vazia se não encontrar.
+    */
+   findCompensationByDate(date: Date): Compensation[] {
+       return this._compensations.filter((compensation) => {
+           return DateUtils.between(date, compensation.startDate, compensation.endDate);
+        });
+    }
+
+    /**
+     * Clona a instância de Schedules.
+     * 
+     * @returns Uma nova instância de Schedules com os mesmos parâmetros.
+     */
+    public static clone(schedules: Schedules): Schedules {
+        return new Schedules({
+            bridges: schedules.bridges?.map(bridge => Bridge.clone(bridge)) || [],
+            workscheduleChanges: schedules.workscheduleChanges?.map(change => WorkscheduleChange.clone(change)) || [],
+            workshiftChanges: schedules.workshiftChanges?.map(change => WorkshiftChange.clone(change)) || [],
+            readinesses: schedules.readinesses?.map(readiness => Readiness.clone(readiness)) || [],
+            overtimeAuthorizations: schedules.overtimeAuthorizations?.map(auth => OvertimeAuthorization.clone(auth)) || [],
+            compensations: schedules.compensations?.map(compensation => Compensation.clone(compensation)) || []
+        });
+    }
+
+
+}

package/src/data/schedules/workscheduleChange.ts

@@ -0,0 +1,91 @@
+import { ObjectUtils } from "src/utils/object.utils";
+import { ContextReference } from "../context/contextReference";
+import { Workschedule } from "../foundation/workschedule";
+
+/**
+ * Parâmetros para criar uma troca de horário.
+ * @param date Data da troca do horário.
+ * @param workscheduleId Identificador do horário de trabalho.
+ * @param contextRef Referência do contexto onde a troca de horário está inserida.
+ */
+export interface WorkscheduleParams {
+    date: Date;
+    workscheduleId: string;
+}
+
+/**
+ * Representa uma programação de troca de horário de trabalho.
+ * Uma troca de horário é uma alteração no horário de trabalho de um colaborador em uma data específica.
+ * A troca de horário é utilizada para registrar alterações no horário de trabalho, como trocas de turnos ou ajustes de horários.
+ */
+export class WorkscheduleChange {
+    /**
+     * Data da troca do horário.
+     */
+    private readonly _date: Date;
+    /**
+     * Identificador do horário de trabalho.
+     */
+    private readonly _workscheduleId: string;
+
+    /**
+     * @hidden
+     * @param params Parâmetros necessários para criar uma instância de WorkscheduleChange.
+     */
+    constructor(params: WorkscheduleParams) {
+        this._date = ObjectUtils.toDateOrThrow(params.date, "WorkscheduleChange.date");
+        this._workscheduleId = params.workscheduleId;
+    }
+
+    /**
+     * Data da troca do horário.
+     * @example
+     * ```typescript
+     * let date = workscheduleChange.date; // Retorna a data da troca do horário.
+     * ```
+     * @returns Data da troca do horário.
+     */
+    get date(): Date {
+        return this._date;
+    }
+
+    /**
+     * @hidden
+     * Identificador do horário de trabalho.
+     */
+    private get workscheduleId(): string {
+        return this._workscheduleId;
+    }
+
+    /**
+     * Horário de trabalho associado a esta troca.
+     * @example
+     * ```typescript
+     * let workschedule = workscheduleChange.workschedule; // Retorna o Horário de trabalho associado a esta troca.
+     * workschedule.code; // Retorna o código do Horário de trabalho associado a esta troca.
+     * ```
+     * @returns O Horário de trabalho associado a esta troca de horário.
+     * 
+     */
+    get workschedule(): Workschedule {
+        const workschedule = ContextReference.getGlobalInstance().getWorkschedule(this._workscheduleId);
+        if (!workschedule) {
+            throw new Error(`Workschedule with id ${this._workscheduleId} not found in context.`);
+        }
+
+        return workschedule;
+    }
+
+    /**
+     * Clona a instância de WorkscheduleChange.
+     * @returns Uma nova instância de WorkscheduleChange com os mesmos valores.
+     */
+    public static clone(object: WorkscheduleChange): WorkscheduleChange {
+        return new WorkscheduleChange({
+            date: object.date,
+            workscheduleId: object.workscheduleId,
+        });
+    }
+
+}
+