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

package/src/data/timeEvaluation/interval.ts

@@ -0,0 +1,568 @@
+import { ObjectUtils } from "../../utils/object.utils";
+import { DateUtils } from "../../utils/dateUtils";
+import { Situation } from "./../foundation/situation";
+import { ContextReference } from "../context/contextReference";
+import { AdjustmentReason } from "./adjustmentReason";
+
+/**
+ * @hidden
+ */
+export interface IntervalParams {
+    clockingEventStart: Date;
+    clockingEventEnd: Date;
+    type: IntervalTypes;
+    subType: IntervalSubTypes;
+    typeIntervalTolerance: IntervalTypes;
+    subTypeIntervalTolerance: IntervalSubTypes;
+    situationId: string;
+    adjustmentReason: AdjustmentReason | undefined;
+    justifiedDays: number;
+    positionWorkingPart: PositionWorkHours;
+    isNightly: boolean;
+    isOvertimeAuthorized: boolean;
+    isTolerancePeriod: boolean;
+    inClockingEventTolerance: boolean;
+}
+
+/**
+ * Representa um intervalo do espelho de cálculo de apuração.
+ * O intervalo é o nucleo da apuração, nele está detalhado como cada hora do dia é considerada em cada intervalo de tempo.
+ * Cenário: Qual é o intervalo de falta do dia, qual é o intervalo de refeição do dia, qual é o intervalo de horas extras do dia, etc.
+ * 
+ * @example
+ * ```typescript
+ *  interval.clockingEventStart; // Retorna a data e hora inicial do intervalo.
+ *  interval.clockingEventEnd; // Retorna a data e hora final do intervalo.
+ *  interval.type; // Retorna o tipo do intervalo.
+ *  interval.subType; // Retorna o subtipo do intervalo.
+ * ```
+ */
+export class Interval {
+    private readonly _clockingEventStart: Date;
+    private readonly _clockingEventEnd: Date;
+    private readonly _type: IntervalTypes;
+    private readonly _subType: IntervalSubTypes;
+    private readonly _typeIntervalTolerance: IntervalTypes;
+    private readonly _subTypeIntervalTolerance: IntervalSubTypes;
+    private readonly _situationId: string;
+    private readonly _adjustmentReason: AdjustmentReason | undefined;
+    private readonly _justifiedDays: number;
+    private readonly _positionWorkingPart: PositionWorkHours;
+    private readonly _isNightly: boolean;
+    private readonly _isOvertimeAuthorized: boolean;
+    private readonly _isTolerancePeriod: boolean;
+    private readonly _inClockingEventTolerance: boolean;
+
+    /**
+     * @hidden
+     */
+    constructor(params: IntervalParams) {
+        this._clockingEventStart = ObjectUtils.toDateOrThrow(params.clockingEventStart, "Interval.clockingEventStart");
+        this._clockingEventEnd = ObjectUtils.toDateOrThrow(params.clockingEventEnd, "Interval.clockingEventEnd");
+        this._type = params.type;
+        this._subType = params.subType;
+        this._typeIntervalTolerance = params.typeIntervalTolerance;
+        this._subTypeIntervalTolerance = params.subTypeIntervalTolerance;
+        this._situationId = params.situationId;
+        this._adjustmentReason = params.adjustmentReason;
+        this._justifiedDays = params.justifiedDays;
+        this._positionWorkingPart = params.positionWorkingPart;
+        this._isNightly = params.isNightly;
+        this._isOvertimeAuthorized = params.isOvertimeAuthorized;
+        this._isTolerancePeriod = params.isTolerancePeriod;
+        this._inClockingEventTolerance = params.inClockingEventTolerance;
+    }
+
+    /**
+     * Retorna a data e hora inicial do intervalo.
+     * @example
+     * ```typescript
+     * let start = interval.clockingEventStart; // Retorna a data e hora inicial do intervalo.
+     * ```
+     * @return A data e hora inicial do intervalo.
+     */
+    get clockingEventStart(): Date {
+        return this._clockingEventStart;
+    }
+
+    /**
+     * Retorna a data e hora final do intervalo.
+     * @example
+     * ```typescript
+     * let end = interval.clockingEventEnd; // Retorna a data e hora final do intervalo.
+     * ```
+     * @return A data e hora final do intervalo.
+     * 
+     */
+    get clockingEventEnd(): Date {
+        return this._clockingEventEnd;
+    }
+
+    /**
+     * Retorna o tipo do intervalo.
+     * @example
+     * ```typescript
+     * let type = interval.type; // Retorna o tipo do intervalo.
+     * ```
+     * @return O tipo do intervalo.
+     */
+    get type(): IntervalTypes {
+        return this._type;
+    }
+
+    /**
+     * Retorna o subtipo do intervalo, exemplo: type OVERTIME (extra) e subType BEFORE_WORKING (antes do expediente).
+     * 
+     * @example
+     * ```typescript
+     * let subType = interval.subType; // Retorna o subtipo do intervalo.
+     * ```
+     * @return O subtipo do intervalo.
+     * @see  {@link IntervalSubTypes}
+     */
+    get subType(): IntervalSubTypes {
+        return this._subType;
+    }
+
+    /**
+     * Retorna o tipo do intervalo de tolerância.
+     * 
+     * @example
+     * ```typescript
+     * let typeIntervalTolerance = interval.typeIntervalTolerance; // Retorna o tipo do intervalo de tolerância.
+     * ```
+     * @return O tipo do intervalo de tolerância.
+     * @see {@link IntervalTypes}
+     * 
+     */
+    get typeIntervalTolerance(): IntervalTypes {
+        return this._typeIntervalTolerance;
+    }
+
+    /**
+     * Retorna o subtipo do intervalo de tolerância.
+     * @example
+     * ```typescript
+     * let subTypeIntervalTolerance = interval.subTypeIntervalTolerance; // Retorna o subtipo do intervalo de tolerância.
+     * ```
+     * @return O subtipo do intervalo de tolerância.
+     * @see {@link IntervalSubTypes}
+     */
+    get subTypeIntervalTolerance(): IntervalSubTypes {
+        return this._subTypeIntervalTolerance;
+    }
+
+    /**
+     * @hidden
+     * Identificador da situação caso o tipo do intervalo for JUSTIFIED_ENTRY, JUSTIFIED_EXIT ou SCHEDULED.
+     * @returns Identificador da situação do intervalo.
+     */
+    private get situationId(): string {
+        return this._situationId;
+    }
+
+    /**
+     * Situação do intervalo caso o tipo do intervalo for JUSTIFIED_ENTRY, JUSTIFIED_EXIT ou SCHEDULED.
+     * 
+     * @example
+     * ```typescript
+     * let situation = interval.situation; // Retorna a situação do intervalo.
+     * sitation.code; // Retorna o código da situação.
+     * ```
+     * @returns Situação do afastamento.
+     */
+    get situation(): Situation | undefined {
+        const situation = ContextReference.getGlobalInstance().getSituationById(this._situationId);
+        if (!situation && !!situation) {
+            throw new Error(`Situation with ID ${this._situationId} not found in context.`);
+        }
+        return situation;
+    }
+
+    /**
+     * Retorna o código do motivo de acerto do intervalo.
+     * 
+     * @example
+     * ```typescript
+     * let adjustmentReason = interval.adjustmentReason; // Retorna o motivo de acerto do intervalo.
+     * adjustmentReason.code; // Retorna o código do motivo de acerto.
+     * ```
+     * @returns Motivo de acerto do intervalo.
+     * @see {@link AdjustmentReason}
+     */
+    get adjustmentReason(): AdjustmentReason | undefined {
+        return this._adjustmentReason;
+    }
+
+    /**
+     * Retorna os dias justificados.
+     * 
+     * @example
+     * ```typescript
+     * let justifiedDays = interval.justifiedDays; // Retorna a quantidade de dias justificados.
+     * ```  
+     * @return A quantidade de dias justificados.
+     */
+    get justifiedDays(): number {
+        return this._justifiedDays;
+    }
+
+    /**
+     * Retorna a posição das horas trabalhadas no intervalo.
+     * 
+     * @example
+     * ```typescript
+     * let positionWorkingPart = interval.positionWorkingPart; // Retorna a posição das horas trabalhadas no intervalo.
+     * ```
+     * @return A posição das horas trabalhadas no intervalo.
+     * @see {@link PositionWorkHours}
+     */
+    get positionWorkingPart(): PositionWorkHours {
+        return this._positionWorkingPart;
+    }
+
+    /**
+     * Retorna se o intervalo é noturno.
+     * 
+     * @example
+     * ```typescript
+     * let isNightly = interval.isNightly; // Retorna se o intervalo é noturno.
+     * ```
+     * @return Verdadeiro se o intervalo é noturno, falso caso contrário.
+     * 
+     */
+    get isNightly(): boolean {
+        return this._isNightly;
+    }
+
+    /**
+     * Retorna se o intervalo tem horas extras autorizadas.
+     * 
+     * @example
+     * ```typescript
+     * let isOvertimeAuthorized = interval.isOvertimeAuthorized; // Retorna se o intervalo tem horas extras autorizadas.
+     * ```
+     * @return Verdadeiro se o intervalo tem horas extras autorizadas, falso caso contrário.
+     * 
+     */
+    get isOvertimeAuthorized(): boolean {
+        return this._isOvertimeAuthorized;
+    }
+
+    /**
+     * Retorna se o intervalo está dentro da tolerância de alguma marcação do horário e se é afetado por ela.
+     * 
+     * @example
+     * ```typescript
+     * let isTolerancePeriod = interval.isTolerancePeriod; // Retorna se o intervalo está dentro da tolerância de evento de marcação.
+     * ```
+     * @return Verdadeiro se o intervalo está dentro da tolerância de evento de marcação, falso caso contrário.
+     * 
+     */
+    get isTolerancePeriod(): boolean {
+        return this._isTolerancePeriod;
+    }
+
+    /**
+     * Retorna se o intervalo está dentro da tolerância de evento de marcação.
+     * 
+     * @example
+     * ```typescript
+     * let inClockingEventTolerance = interval.inClockingEventTolerance; // Retorna se o intervalo está dentro da tolerância de evento de marcação.
+     * ```
+     * @return Verdadeiro se o intervalo está dentro da tolerância de evento de marcação, falso caso contrário.
+     * 
+     */
+    get inClockingEventTolerance(): boolean {
+        return this._inClockingEventTolerance;
+    }
+
+    /**
+     * Retorna a quantidade de minutos do intervalo.
+     * @example
+     * ```typescript
+     * let intervalInMinutes = interval.getIntervalInMinutes(); // Retorna a quantidade de minutos do intervalo.
+     * ```
+     * @return A quantidade de minutos do intervalo.
+     */
+    public getIntervalInMinutes(): number {
+        return DateUtils.getDateInMinutes(this._clockingEventEnd, this._clockingEventStart);
+    }
+
+    public static clone(interval: Interval): Interval {
+        return new Interval({
+            clockingEventStart: interval.clockingEventStart,
+            clockingEventEnd: interval.clockingEventEnd,
+            type: interval.type,
+            subType: interval.subType,
+            typeIntervalTolerance: interval.typeIntervalTolerance,
+            subTypeIntervalTolerance: interval.subTypeIntervalTolerance,
+            situationId: interval.situationId,
+            adjustmentReason: interval.adjustmentReason,
+            justifiedDays: interval.justifiedDays,
+            positionWorkingPart: interval.positionWorkingPart,
+            isNightly: interval.isNightly,
+            isOvertimeAuthorized: interval.isOvertimeAuthorized,
+            isTolerancePeriod: interval.isTolerancePeriod,
+            inClockingEventTolerance: interval.inClockingEventTolerance
+        });
+    }
+}
+
+/**
+ * Enumeração para os tipos de intervalo.
+ * @enum
+ */
+export enum IntervalTypes {
+    /**
+     * Trabalho.
+     */
+    WORKING = "WORKING",
+    /**
+     * Extras.
+     */
+    OVERTIME = "OVERTIME",
+    /**
+     * Faltas.
+     */
+    ABSENCE = "ABSENCE",
+    /**
+     * Refeição.
+     */
+    MEAL = "MEAL",
+    /**
+     * Lanche.
+     */
+    SNACK = "SNACK",
+    /**
+     * Entrada justificada.
+     */
+    JUSTIFIED_ENTRY = "JUSTIFIED_ENTRY",
+    /**
+     * Saída justificada.
+     */
+    JUSTIFIED_EXIT = "JUSTIFIED_EXIT",
+    /**
+     * Entrada indicada.
+     */
+    INDICATED_ENTRY = "INDICATED_ENTRY",
+    /**
+     * Saída indicada.
+     */
+    INDICATED_EXIT = "INDICATED_EXIT",
+    /**
+     * Programado.
+     */
+    SCHEDULED = "SCHEDULED",
+    /**
+     * Simulado.
+     */
+    SIMULATED = "SIMULATED",
+    /**
+     * Descanso mulher.
+     */
+    WOMENS_REST = "WOMENS_REST",
+    /**
+     * Compensado.
+     */
+    COMPENSATED = "COMPENSATED",
+    /**
+     * Espera.
+     */
+    WAITING = "WAITING",
+    /**
+     * Parada obrigatória.
+     */
+    MANDATORY_STOP = "MANDATORY_STOP",
+    /**
+     * Parada obrigatória com refeição.
+     */
+    MEAL_WITH_MANDATORY_STOP = "MEAL_WITH_MANDATORY_STOP",
+    /**
+     * Direção.
+     */
+    DIRECTION = "DIRECTION",
+    /**
+     * Tolerância.
+     */
+    TOLERANCE = "TOLERANCE",
+    /**
+     * Refeição programada/prevista.
+     */
+    SCHEDULED_MEAL = "SCHEDULED_MEAL"
+}
+
+/**
+ * Enumeração para os subtipos de intervalo.
+ * @enum
+ */
+export enum IntervalSubTypes {
+    /**
+     * Antes do expediente.
+     */
+    BEFORE_WORKING = "BEFORE_WORKING",
+
+    /**
+     * Após o expediente.
+     */
+    AFTER_WORKING = "AFTER_WORKING",
+
+    /**
+     * Entrada do expediente.
+     */
+    ENTER = "ENTER",
+
+    /**
+     * Saída do expediente.
+     */
+    CHECKOUT = "CHECKOUT",
+
+    /**
+     * Intervalo para lanche.
+     */
+    SNACK = "SNACK",
+
+    /**
+     * Intervalo para refeição.
+     */
+    MEAL = "MEAL",
+
+    /**
+     * Dia de folga.
+     */
+    DAY_OFF = "DAY_OFF",
+
+    /**
+     * Feriado.
+     */
+    HOLIDAY = "HOLIDAY",
+
+    /**
+     * Dia compensado.
+     */
+    COMPENSATED = "COMPENSATED",
+
+    /**
+     * Dia para descanso.
+     */
+    REST = "REST",
+
+    /**
+     * Atraso.
+     */
+    DELAY = "DELAY",
+
+    /**
+     * Saída intermediária.
+     */
+    INTERMEDIATE_EXIT = "INTERMEDIATE_EXIT",
+
+    /**
+     * Saída antecipada.
+     */
+    EARLY_EXIT = "EARLY_EXIT",
+
+    /**
+     * Jornada integral.
+     */
+    FULL_PART = "FULL_PART",
+
+    /**
+     * Afastamento.
+     */
+    LEAVE = "LEAVE",
+
+    /**
+     * Autorização para saída.
+     */
+    EXIT_AUTHORIZATION = "EXIT_AUTHORIZATION",
+
+    /**
+     * Compensação de ausência.
+     */
+    ABSENSION_COMPENSATION = "ABSENSION_COMPENSATION",
+
+    /**
+     * Compensação extra.
+     */
+    EXTRA_COMPENSATION = "EXTRA_COMPENSATION",
+
+    /**
+     * Sobreaviso/Prontidão.
+     */
+    PRECAUTION = "PRECAUTION",
+
+    /**
+     * Parada.
+     */
+    STOP = "STOP",
+
+    /**
+     * Dia facultativo.
+     */
+    OPTIONAL_DAY = "OPTIONAL_DAY"
+}
+
+/**
+ * @hidden
+ */
+export interface PositionWorkHoursParams {
+    workingHours: number;
+    part: number;
+}
+/**
+ * Representa as horas trabalhadas em uma parte do expediente. 
+ * A divisão do expediente em partes acontece na hora final dos intervalos do tipo meal (refeição).
+ * 
+ * ```
+ * Representação das partes do expediente 
+ * 
+ *   |----------------------------------------expedient-----------------------------------------|
+ *   |----------------------part(1)----------------------|---------------part(2)----------------|
+ * 08:00        10:00        10:15        12:00        13:30        16:30        16:45        18:00
+ *   |------------|------------|------------|------------|------------|------------|------------|
+ *   |   work(1)  |  snack(1)  |   work(2)  |   meal(1)  |   work(3)  |  snack(2)  |   work(4)  |
+ * ```
+ * 
+ * @example
+ * ```typescript
+ * positionWorkHours.workingHours; // Retorna as horas trabalhadas na parte.
+ * positionWorkHours.part; // Retorna a parte do expediente.
+ * ```
+ * 
+ */
+export class PositionWorkHours {
+    private readonly _workingHours: number;
+    private readonly _part: number;
+
+    constructor(params: PositionWorkHoursParams) {
+        this._workingHours = params.workingHours;
+        this._part = params.part;
+    }
+
+    /**
+     * Retorna as horas trabalhadas na parte do expediente.
+     * 
+     * @example
+     * ```typescript
+     * let workingHours = positionWorkHours.workingHours; // Retorna as horas trabalhadas na parte do expediente.
+     * ```
+     * @return As horas trabalhadas na parte do expediente.
+     */
+    get workingHours(): number {
+        return this._workingHours;
+    }
+
+    /**
+     * Retorna a parte do expediente.
+     * 
+     * @example
+     * ```typescript
+     * let part = positionWorkHours.part; // Retorna a parte do expediente.
+     * ```
+     * @return A parte do expediente.
+     */
+    get part(): number {
+        return this._part;
+    }
+}

package/src/data/timeEvaluation/separatedHours.ts

@@ -0,0 +1,134 @@
+/**
+ * @hidden
+ */
+export interface SeparatedHoursParams {
+    dailyHours: number;
+    nightlyHours: number;
+}
+
+/**
+ * Representa um conjunto de horas separadas em diurnas e noturnas.
+ * 
+ * @example
+ * ```typescript
+ * separatedHours.dailyHours; // Retorna a quantidade de horas diurnas.
+ * separatedHours.nightlyHours; // Retorna a quantidade de horas noturnas.
+ * separatedHours.total; // Retorna a quantidade total de horas.
+ * ```
+ */
+export class SeparatedHours {
+    private _dailyHours: number;
+    private _nightlyHours: number;
+
+    /**
+     * @hidden
+     */
+    constructor(params: SeparatedHoursParams) {
+        this._dailyHours = params.dailyHours;
+        this._nightlyHours = params.nightlyHours;
+    }
+
+    /**
+     * Retorna a quantidade de horas diurnas.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * console.log(separatedHours.getDailyHours()); // Saída: 5
+     * ```
+     * 
+     * @returns {number} Horas diurnas.   
+     */
+    get dailyHours(): number {
+        return this._dailyHours;
+    }
+
+    /**
+     * Retorna a quantidade de horas noturnas.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * console.log(separatedHours.getNightlyHours()); // Saída: 3
+     * ```
+     * 
+     * @returns {number} Horas noturnas.   
+     */
+    get nightlyHours(): number {
+        return this._nightlyHours;
+    }
+
+    /**
+     * Retorna a quantidade total de horas somando as horas diurnas e noturnas.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * console.log(separatedHours.total); // Saída: 8
+     * ```
+     * 
+     * @returns {number} Total de horas.   
+     */
+    get total(): number {
+        return this.dailyHours + this.nightlyHours;
+    }
+
+    /**
+     * Retorna a quantidade total de horas separadas.
+     * @returns {string} - Daytime: ${this.dailyHours}, Nighttime: ${this.nightlyHours}.   
+     */
+    public toString(): string {
+        return `Daytime: ${this.dailyHours}, Nighttime: ${this.nightlyHours}`;
+    }
+
+    /**
+     * Soma a quantidade de horas noturnas.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * separatedHours.sumNightlyHours(2);
+     * console.log(separatedHours.toString()); // Saída: Daytime: 5, Nighttime: 5
+     * ```
+     * 
+     * @param {number} nightlyHours Horas noturnas a serem adicionadas.   
+     */
+    public sumNightlyHours(nightlyHours: number): void {
+        this._nightlyHours += nightlyHours;
+    }
+
+    /**
+     * Soma a quantidade de horas diurnas.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * separatedHours.sumDailyHours(2);
+     * console.log(separatedHours.toString()); // Saída: Daytime: 7, Nighttime: 3
+     * ```
+     * 
+     * @param {number} dailyHours Horas diurnas a serem adicionadas.   
+     */
+    public sumDailyHours(dailyHours: number): void {
+        this._dailyHours += dailyHours;
+    }
+
+    /**
+     * Soma duas separação de horas, adicionando as horas diurnas e noturnas, separadamente.
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours1 = new SeparatedHours({ dailyHours: 5, nightlyHours: 3 });
+     * let separatedHours2 = new SeparatedHours({ dailyHours: 2, nightlyHours: 4 });
+     * separatedHours1.sumSeparatedHours(separatedHours2);
+     * console.log(separatedHours1.toString()); // Saída: Daytime: 7, Nighttime: 7
+     * ```
+     * 
+     * @param {SeparatedHours} separatedHours Horas separadas a serem adicionadas.   
+     */
+    public sumSeparatedHours(separatedHours: SeparatedHours): void {
+        this.sumDailyHours(separatedHours.dailyHours);
+        this.sumNightlyHours(separatedHours.nightlyHours);
+    }
+}
+