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

package/src/data/foundation/workschedule.ts

@@ -0,0 +1,688 @@
+/**
+ * @hidden
+ * Interface para os parâmetros do construtor do Workschedule.
+ */
+export interface WorkscheduleParams {
+    /**
+     * Identificador do horário.
+     */
+    id: string;
+
+    /**
+     * Código do horário.
+     */
+    code: number;
+
+    /**
+     * Carga horária do horário.
+     */
+    workload: number;
+
+    /**
+     * Tipo do horário.
+     */
+    type: WorkscheduleType;
+
+    /**
+     * Tipo de definição do horário.
+     */
+    definitionType: WorkscheduleDefinitionType;
+
+    /**
+     * Lista de marcações do horário.
+     */
+    clockingRegisters: WorkscheduleClockingRegister[];
+
+    /**
+     * Definição da aba ponto no cadastro do horário.
+     */
+    clockingEvent: WorkscheduleClockingEvent;
+}
+
+/**
+ * @hidden
+ * Interface para os parâmetros do construtor das marcações do horário.
+ */
+export interface WorkscheduleClockingRegisterParams {
+    /**
+     * Sequência do registro de marcação.
+     */
+    sequence: number;
+
+    /**
+     * Hora da marcação.
+     */
+    clockingEvent: number;
+
+    /**
+     * Tolerância antes da marcação.
+     */
+    toleranceBefore: number;
+
+    /**
+     * Tolerância após a marcação.
+     */
+    toleranceAfter: number;
+
+    /**
+     * Mobilidade antes da marcação.
+     */
+    mobilityBefore: number;
+
+    /**
+     * Mobilidade após a marcação.
+     */
+    mobilityAfter: number;
+
+    /**
+     * Tipo de intervalo se existir.
+     */
+    intervalType: IntervalType | null;
+
+    /**
+     * Tipo da marcação.
+     */
+    clockingEventScheduleType: ClockingEventScheduleType;
+
+    /**
+     * Tipo de uso da marcação.
+     */
+    usingType: UsingType;
+}
+
+/**
+ * @hidden
+ * Interface para os parâmetros do construtor da aba ponto no cadastro do horário.
+ */
+export interface WorkscheduleClockingEventParams {
+    /**
+     * Tolerância de horas extras no início e fim do expediente.
+     */
+    workStartEndOvertimeTolerance: number;
+
+    /**
+     * Tolerância de horas extras para refeições.
+     */
+    mealOvertimeTolerance: number;
+
+    /**
+     * Tolerância total diária de horas extras.
+     */
+    overtimeDailyTotalTolerance: number;
+
+    /**
+     * Tolerância total diária de ausências.
+     */
+    absenceDailyTotalTolerance: number;
+
+    /**
+     * Tolerância de ausência no início e fim do expediente.
+     */
+    workStartEndAbsenceTolerance: number;
+
+    /**
+     * Tolerância de ausência para refeições.
+     */
+    mealAbsenceTolerance: number;
+}
+
+/**
+ * Representa um horário.
+ * 
+ * @example
+ * ```typescript
+ *  workschedule.code; // Retorna o código do horário.
+ *  workschedule.type; // Retorna o tipo do horário.
+ *  workschedule.workload; // Retorna a carga horária do horário.
+ *  workschedule.clockingRegisters; // Retorna a lista de marcações do horário.
+ *  workschedule.clockingEvent; // Retorna as definições da aba ponto do horário.
+ * ```
+ * @see {@link WorkscheduleType}
+ * @see {@link WorkscheduleDefinitionType}
+ * @see {@link WorkscheduleClockingRegister}
+ * @see {@link WorkscheduleClockingEvent}
+ * @see {@link IntervalType}
+ * @see {@link ClockingEventScheduleType}
+ * @see {@link UsingType}
+ * 
+ */
+export class Workschedule {
+    private readonly _id: string;
+    private readonly _code: number;
+    private readonly _type: WorkscheduleType;
+    private readonly _definitionType: WorkscheduleDefinitionType;
+    private readonly _workload: number;
+    private readonly _clockingRegisters: WorkscheduleClockingRegister[];
+    private readonly _clockingEvent: WorkscheduleClockingEvent;
+
+    /**
+     * @hidden
+     * Construtor da classe Workschedule.
+     * @param params Parâmetros para inicializar o Workschedule.
+     */
+    constructor(params: WorkscheduleParams) {
+        this._id = params.id;
+        this._code = params.code;
+        this._type = params.type;
+        this._definitionType = params.definitionType;
+        this._workload = params.workload;
+        this._clockingRegisters = params.clockingRegisters || [];
+        this._clockingEvent = params.clockingEvent;
+    }
+
+
+    /**
+     * @hidden
+     * Retorna o ID do horário.
+     */
+    get id(): string {
+        return this._id;
+    }
+
+    /**
+     * Retorna o código do horário.
+     * @example
+     * ```typescript
+     * workschedule.code; // Retorna o código do horário.
+     * ```
+     * @returns Código do horário.
+     */
+    get code(): number {
+        return this._code;
+    }
+
+    /**
+     * Retorna o tipo do do horário.
+     * 
+     * @example
+     * ```typescript
+     * workschedule.type; // Retorna o tipo do horário.
+     * ```
+     * @returns Tipo do horário.
+     */
+    get type(): WorkscheduleType {
+        return this._type;
+    }
+
+    /**
+     * Retorna o tipo de definição do horário.
+     * @example
+     * ```typescript
+     * const def = workschedule.definitionType; // Retorna o tipo de definição do horário.
+     * ```
+     * @returns Tipo de definição do horário.
+     */
+    get definitionType(): WorkscheduleDefinitionType {
+        return this._definitionType;
+    }
+
+    /**
+     * Retorna a carga horária do horário.
+     * @example
+     * ```typescript
+     * workschedule.workload; // Retorna a carga horária do horário.
+     * ```
+     * @returns Carga horária do horário.
+     */
+    get workload(): number {
+        return this._workload;
+    }
+
+    /**
+     * Retorna a lista de marcações do horário.
+     * 
+     * @example
+     * ```typescript
+     * const registers = workschedule.clockingRegisters; // Retorna a lista de marcações do horário.
+     * registers.forEach(register => {
+     *     console.log(register.clockingEvent); // Exibe o evento de marcação de cada registro.
+     * });
+     * ```
+     * @return Lista de marcações do horário.
+     * @see {@link WorkscheduleClockingRegister}
+     */
+    get clockingRegisters(): WorkscheduleClockingRegister[] {
+        return this._clockingRegisters;
+    }
+
+    /**
+     * Retorna as definições da aba ponto do horário.
+     * 
+     * @example
+     * ```typescript
+     * const clockingEvent = workschedule.clockingEvent; // Retorna as definiçõesda aba ponto do horário.
+     * console.log(clockingEvent.workStartEndOvertimeTolerance); // Exibe a tolerância de horas extras no início e fim do expediente.
+     * ```
+     * @return Definições da aba ponto do horário.
+     * @see {@link WorkscheduleClockingEvent}
+     */
+    get clockingEvent(): WorkscheduleClockingEvent {
+        return this._clockingEvent;
+    }
+
+    /**
+     * Retorna a quantidade de registros de marcação do horário.
+     * @example
+     * ```typescript
+     * const count = workschedule.clockingRegistersCount; // Retorna a quantidade de registros de marcação do horário.
+     * console.log(`Total de registros de marcação: ${count}`);
+     * ```
+     * @returns Quantidade de registros de marcação do horário.
+     */
+    get clockingRegistersCount(): number {
+        return this._clockingRegisters.length;
+    }
+}
+
+/**
+ * Representa um registro de marcação do horário.
+ */
+export class WorkscheduleClockingRegister {
+    private readonly _sequence: number;
+    private readonly _clockingEvent: number;
+    private readonly _toleranceBefore: number;
+    private readonly _toleranceAfter: number;
+    private readonly _mobilityBefore: number;
+    private readonly _mobilityAfter: number;
+    private readonly _intervalType: IntervalType | null;
+    private readonly _clockingEventScheduleType: ClockingEventScheduleType;
+    private readonly _usingType: UsingType;
+
+    /**
+     * @hidden
+     * Construtor da classe WorkscheduleClockingRegister.
+     * @param params Parâmetros para inicializar o WorkscheduleClockingRegister.
+     */
+    constructor(params: WorkscheduleClockingRegisterParams) {
+        this._sequence = params.sequence;
+        this._clockingEvent = params.clockingEvent;
+        this._toleranceBefore = params.toleranceBefore;
+        this._toleranceAfter = params.toleranceAfter;
+        this._mobilityBefore = params.mobilityBefore;
+        this._mobilityAfter = params.mobilityAfter;
+        this._intervalType = params.intervalType ?? null;
+        this._clockingEventScheduleType = params.clockingEventScheduleType;
+        this._usingType = params.usingType;
+    }
+
+    /**
+     * Retorna a sequência do registro de marcação.
+     * 
+     * @example
+     * ```typescript
+     * const sequence = clockingRegister.sequence; // Retorna a sequência do registro de marcação.
+     * console.log(`Sequência: ${sequence}`);
+     * ```
+     * @returns Sequência do registro de marcação.
+     * 
+     */
+    get sequence(): number {
+        return this._sequence;
+    }
+
+    /**
+     * Retorna a marcação.
+     * 
+     * @example
+     * ```typescript
+     * const clockingEvent = clockingRegister.clockingEvent; // Retorna a marcação em minutos
+     * console.log(`Marcação: ${clockingEvent} minutos`);
+     * ```
+     * @returns Marcação em minutos.
+     */
+    get clockingEvent(): number {
+        return this._clockingEvent;
+    }
+
+    /**
+     * Retorna a tolerância antes do horário de marcação.
+     * 
+     * @example
+     * ```typescript
+     * const toleranceBefore = clockingRegister.toleranceBefore; // Retorna a tolerância antes do horário de marcação em minutos.
+     * console.log(`Tolerância antes: ${toleranceBefore} minutos`);
+     * ```
+     * @return Tolerância antes do horário de marcação em minutos.
+     */
+    get toleranceBefore(): number {
+        return this._toleranceBefore;
+    }
+
+    /**
+     * Retorna a tolerância após o horário de marcação.
+     * 
+     * @example
+     * ```typescript
+     * const toleranceAfter = clockingRegister.toleranceAfter; // Retorna a tolerância após o horário de marcação em minutos.
+     * console.log(`Tolerância após: ${toleranceAfter} minutos`);
+     * ```
+     * @return Tolerância após o horário de marcação em minutos.
+     */
+    get toleranceAfter(): number {
+        return this._toleranceAfter;
+    }
+
+    /**
+     * Retorna a mobilidade antes do horário de marcação.
+     * 
+     * @example
+     * ```typescript
+     * const mobilityBefore = clockingRegister.mobilityBefore; // Retorna a mobilidade antes do horário de marcação em minutos.
+     * console.log(`Mobilidade antes: ${mobilityBefore} minutos`);
+     * ```
+     * @return Mobilidade antes do horário de marcação em minutos.
+     */
+    get mobilityBefore(): number {
+        return this._mobilityBefore;
+    }
+
+    /**
+     * Retorna a mobilidade após o horário de marcação.
+     * @example
+     * ```typescript
+     * const mobilityAfter = clockingRegister.mobilityAfter; // Retorna a mobilidade após o horário de marcação em minutos.
+     * console.log(`Mobilidade após: ${mobilityAfter} minutos`);
+     * ```
+     * @return Mobilidade após o horário de marcação em minutos.
+     */
+    get mobilityAfter(): number {
+        return this._mobilityAfter;
+    }
+
+    /**
+     * Retorna o tipo de intervalo.
+     * 
+     * @example
+     * ```typescript
+     * const intervalType = clockingRegister.intervalType; // Retorna o tipo de intervalo.
+     * console.log(`Tipo de intervalo: ${intervalType}`);
+     * ```
+     * @returns Tipo de intervalo ou null se não existir.
+     * 
+     */
+    get intervalType(): IntervalType | null {
+        return this._intervalType;
+    }
+
+    /**
+     * Retorna o tipo de evento de marcação.
+     * @example
+     * ```typescript
+     * const clockingEventType = clockingRegister.clockingEventScheduleType; // Retorna o tipo de evento de marcação.
+     * console.log(`Tipo de evento de marcação: ${clockingEventType}`);
+     * ```
+     * @return Tipo de evento de marcação.
+     * @see {@link ClockingEventScheduleType}
+     */
+    get clockingEventScheduleType(): ClockingEventScheduleType {
+        return this._clockingEventScheduleType;
+    }
+
+    /**
+     * Retorna o tipo de uso.
+     * 
+     * @example
+     * ```typescript
+     * const usingType = clockingRegister.usingType; // Retorna o tipo de uso.
+     * console.log(`Tipo de uso: ${usingType}`);
+     * ```
+     * @returns Tipo de uso.
+     */
+    get usingType(): UsingType {
+        return this._usingType;
+    }
+}
+
+/**
+ * Representa um evento da aba ponto no cadastro do horário.
+ */
+export class WorkscheduleClockingEvent {
+    private readonly _workStartEndOvertimeTolerance: number;
+    private readonly _mealOvertimeTolerance: number;
+    private readonly _overtimeDailyTotalTolerance: number;
+    private readonly _absenceDailyTotalTolerance: number;
+    private readonly _workStartEndAbsenceTolerance: number;
+    private readonly _mealAbsenceTolerance: number;
+
+    /**
+     * @hidden
+     * Construtor da classe WorkscheduleClockingEvent.
+     * @param params Parâmetros para inicializar a WorkscheduleClockingEvent.
+     */
+    constructor(params: WorkscheduleClockingEventParams) {
+        this._workStartEndOvertimeTolerance = params.workStartEndOvertimeTolerance;
+        this._mealOvertimeTolerance = params.mealOvertimeTolerance;
+        this._overtimeDailyTotalTolerance = params.overtimeDailyTotalTolerance;
+        this._absenceDailyTotalTolerance = params.absenceDailyTotalTolerance;
+        this._workStartEndAbsenceTolerance = params.workStartEndAbsenceTolerance;
+        this._mealAbsenceTolerance = params.mealAbsenceTolerance;
+    }
+
+    /**
+     * Retorna a tolerância de horas extras no início e fim do expediente.
+     * @example
+     * ```typescript
+     * const overtimeTolerance = workschedule.clockingEvent.workStartEndOvertimeTolerance; // Retorna a tolerância de horas extras no início e fim do expediente em minutos.
+     * console.log(`Tolerância de horas extras no início e fim do expediente: ${overtimeTolerance} minutos`);
+     * ```
+     * @return Tolerância de horas extras no início e fim do expediente em minutos.
+     */
+    get workStartEndOvertimeTolerance(): number {
+        return this._workStartEndOvertimeTolerance;
+    }
+
+    /**
+     * Retorna a tolerância de horas extras para refeições.
+     * @example
+     * ```typescript
+     * const mealOvertimeTolerance = workschedule.clockingEvent.mealOvertimeTolerance; // Retorna a tolerância de horas extras para refeições em minutos.
+     * console.log(`Tolerância de horas extras para refeições: ${mealOvertimeTolerance } minutos`);
+     * ```
+     * @return Tolerância de horas extras para refeições em minutos.
+     */
+    get mealOvertimeTolerance(): number {
+        return this._mealOvertimeTolerance;
+    }
+
+    /**
+     * Retorna a tolerância total diária de horas extras.
+     * @example
+     * ```typescript
+     * const overtimeDailyTotalTolerance = workschedule.clockingEvent.overtimeDailyTotalTolerance; // Retorna a tolerância total diária de horas extras em minutos.
+     * console.log(`Tolerância total diária de horas extras: ${overtimeDailyTotalTolerance} minutos`);
+     * ```
+     * @return Tolerância total diária de horas extras em minutos.
+     */
+    get overtimeDailyTotalTolerance(): number {
+        return this._overtimeDailyTotalTolerance;
+    }
+
+    /**
+     * Retorna a tolerância total diária de ausências.
+     * 
+     * @example
+     * ```typescript
+     * const absenceDailyTotalTolerance = workschedule.clockingEvent.absenceDailyTotalTolerance; // Retorna a tolerância total diária de ausências em minutos.
+     * console.log(`Tolerância total diária de ausências: ${absenceDailyTotalTolerance} minutos`);
+     * ```
+     * @return Tolerância total diária de ausências em minutos.
+     */
+    get absenceDailyTotalTolerance(): number {
+        return this._absenceDailyTotalTolerance;
+    }
+
+    /**
+     * Retorna a tolerância de ausência no início e fim do expediente.
+     * 
+     * @example
+     * ```typescript
+     * const workStartEndAbsenceTolerance = workschedule.clockingEvent.workStartEndAbsenceTolerance; // Retorna a tolerância de ausência no início e fim do expediente em minutos.
+     * console.log(`Tolerância de ausência no início e fim do expediente: ${workStartEndAbsenceTolerance} minutos`);
+     * ```
+     * @return Tolerância de ausência no início e fim do expediente em minutos.
+     */
+    get workStartEndAbsenceTolerance(): number {
+        return this._workStartEndAbsenceTolerance;
+    }
+
+    /**
+     * Retorna a tolerância de ausência para refeições.
+     * 
+     * @example
+     * ```typescript
+     * const mealAbsenceTolerance = workschedule.clockingEvent.mealAbsenceTolerance; // Retorna a tolerância de ausência para refeições em minutos.
+     * console.log(`Tolerância de ausência para refeições: ${mealAbsenceTolerance} minutos`);
+     * ```
+     * @return Tolerância de ausência para refeições em minutos.
+     */
+    get mealAbsenceTolerance(): number {
+        return this._mealAbsenceTolerance;
+    }
+}
+
+/**
+ * Enumeração para os tipos de definição do horário.
+ * @enum
+ */
+export enum WorkscheduleDefinitionType {
+    /**
+     * Normal.
+     */
+    NORMAL = "NORMAL",
+    /**
+     * Folga.
+     */
+    DAYOFF = "DAYOFF",
+    /**
+     * Feriado.
+     */
+    HOLIDAY = "HOLIDAY",
+    /**
+     * Compensação.
+     */
+    OFFSET = "OFFSET",
+    /**
+     * Descanso semanal remunerado.
+     */
+    DSR = "DSR"
+}
+
+/**
+ * Enumeração para os tipos de horário.
+ * @enum
+ */
+export enum WorkscheduleType {
+    /**
+     * Horário rígido.
+     */
+    RIGID = "RIGID",
+    /**
+     * Horário móvel.
+     */
+    MOBILE = "MOBILE",
+    /**
+     * Horário flexível.
+     */
+    FLEXIBLE = "FLEXIBLE",
+    /**
+     * Horário móvel na entrada e saída.
+     */
+    MOBILE_ENTRANCE_EXIT = "MOBILE_ENTRANCE_EXIT",
+    /**
+     * Horário móvel na refeição.
+     */
+    MOBILE_MEAL = "MOBILE_MEAL",
+    /**
+     * Horário flexível nos intervalos.
+     */
+    FLEXIBLE_AT_INTERVALS = "FLEXIBLE_AT_INTERVALS"
+}
+
+/**
+ * Enumeração para os tipos de uso.
+ * @enum
+ */
+export enum UsingType {
+    /**
+     * Entrada e saída obrigatórias.
+     */
+    MANDATORY_ENTRY_OR_EXIT = "MANDATORY_ENTRY_OR_EXIT",
+    /**
+     * Entrada e saída não obrigatórias.
+     */
+    NON_MANDATORY_ENTRY_OR_EXIT = "NON_MANDATORY_ENTRY_OR_EXIT",
+    /**
+     * Entrada e saída geradas.
+     */
+    GENERATED_ENTRY_OR_EXIT = "GENERATED_ENTRY_OR_EXIT",
+    /**
+     * Refeição obrigatória.
+     */
+    MANDATORY_MEAL = "MANDATORY_MEAL",
+    /**
+     * Refeição não obrigatória.
+     */
+    NON_MANDATORY_PRE_ASSIGNED_MEAL = "NON_MANDATORY_PRE_ASSIGNED_MEAL",
+    /**
+     * Refeição obrigatória extra.
+     */
+    MANDATORY_EXTRA_MEAL = "MANDATORY_EXTRA_MEAL",
+    /**
+     * Refeição gerada.
+     */
+    GENERATED_PRE_ASSIGNED_MEAL = "GENERATED_PRE_ASSIGNED_MEAL",
+    /**
+     * Lanche obrigatório.
+     */
+    MANDATORY_SNACK = "MANDATORY_SNACK",
+    /**
+     * Lanche não obrigatório.
+     */
+    NON_MANDATORY_SNACK = "NON_MANDATORY_SNACK",
+    /**
+     * Lanche obrigatório extra.
+     */
+    EXTRA_MANDATORY_SNACK = "EXTRA_MANDATORY_SNACK",
+}
+
+/**
+ * Enumeração para os tipos de intervalos de cálculo de marcações do horário.
+ * @enum
+ */
+export enum IntervalType {
+    /**
+     * Intervalo rígido.
+     */
+    RIGID = "RIGID",
+    /**
+     * Intervalo móvel.
+     */
+    MOBILE = "MOBILE",
+    /**
+     * Intervalo flexível.
+     */
+    FLEXIBLE = "FLEXIBLE",
+    /**
+     * Intervalo núcleo.
+     */
+    CORE = "CORE",
+}
+
+/**
+ * Enumeração para os tipos de evento de marcação.
+ * @enum
+ */
+export enum ClockingEventScheduleType {
+    /**
+     * Evento de marcação obrigatório.
+     */
+    MANDATORY = "MANDATORY",
+    /**
+     * Evento de marcação não obrigatório.
+     */
+    NON_MANDATORY = "NON_MANDATORY",
+    /**
+     * Evento de marcação gerado.
+     */
+    GENERATED = "GENERATED",
+}