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

package/src/data/timeEvaluation/timeEvaluationSituation.ts

@@ -0,0 +1,154 @@
+import { ContextReference } from "../context/contextReference";
+import { Situation } from "../foundation/situation";
+
+/**
+ * @hidden
+ */
+export interface TimeEvaluationSituationParams {
+    situationId: string | undefined;
+    situationCode: number;
+    numberOfHours: number;
+}
+
+/**
+ * Representa uma situação de apuração de horas de um dia.
+ * Uma situação de apuração é utilizada para registrar a quantidade de horas apuradas em uma situação específica, como horas extras, faltas, atrasos, etc.
+ * 
+ * Exemplo de uso:
+ * ```typescript
+ * timeEvalSituation.situation.code; // Retorna o código da situação.
+ * timeEvalSituation.numberOfHours; // Retorna a quantidade de horas apuradas.
+ * timeEvalSituation.addNumberOfHours(2); // Adiciona 2 horas à situação apurada.
+ * ```
+ * @see {@link Situation}
+ */
+export class TimeEvaluationSituation {
+    /**
+     * @hidden
+     * Identificador
+     */
+    id: string;
+    /**
+     * Situação.
+     */
+    private readonly _situationId: string | undefined;
+    /**
+     * Número de horas.
+     */
+    private _numberOfHours: number;
+    private readonly _situationCode: number;
+    private _changed: boolean;
+
+    /**
+     * @hidden
+     * Construtor da classe TimeEvaluationSituation.
+     */
+    constructor(params: TimeEvaluationSituationParams) {
+        this._situationId = params.situationId;
+        this._numberOfHours = params.numberOfHours;
+        this._changed = false;
+        this._situationCode = params.situationCode;
+    }
+
+    /**
+     * Retorna a quantidade de horas da situação em minutos.
+     * @example
+     * ```typescript
+     * timeEvalSituation.numberOfHours; // Retorna a quantidade de horas em minutos.
+     * ```
+     * @returns Quantidade de horas em minutos.
+     * 
+     */
+    get numberOfHours(): number {
+        return this._numberOfHours;
+    }
+
+    /**
+     * Atualiza a quantidade de horas da situação em minutos.
+     * @example
+     * ```typescript
+     * timeEvalSituation.numberOfHours = 120; // Define a quantidade de horas para 120 minutos.
+     * ```
+     * @param value Quantidade de horas em minutos.
+     */
+    set numberOfHours(value: number) {
+        this._changed = true;
+        this._numberOfHours = value;
+    }
+
+    /**
+     * Retorna a situação associada a esta apuração de horas.
+     * Se o código da situação tiver sido carregado no contexto, retorna a situação correspondente com todos os dados.
+     * Caso contrário, constrói uma nova situação com base no código da situação e no contexto.
+     * @example
+     * ```typescript
+     * timeEvalSituation.situation.code; // Retorna o código da situação.
+     * ```
+     * 
+     * @returns Situação associada à apuração.
+     */
+    get situation(): Situation {
+        if (this._situationId) {
+            const situation = ContextReference.getGlobalInstance().getSituationById(this._situationId);
+            if (situation) {
+                return situation;
+            }
+        }
+
+        return Situation.build(this._situationCode);
+    }
+
+    /**
+     * Retorna o código da situação associada a esta apuração de horas.
+     * Vai sempre retornar um valor, mesmo que a situação não esteja carregada no contexto.
+     * 
+     * @example
+     * ```typescript
+     * timeEvalSituation.situationCode; // Retorna o código da situação.
+     * ```
+     */
+    get situationCode(): number {
+        return this._situationCode;
+    }
+
+    /**
+     * @hidden
+     */
+    get changed(): boolean {
+        return this._changed;
+    }
+
+    /**
+     * Soma uma quantidade de horas a uma situação apurada em minutos.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluationSituation.numberOfHours; // Retorna a quantidade de horas apuradas, exemplo: 120 minutos (2 horas).
+     * timeEvalSituation.addNumberOfHours(120); // Adiciona 2 horas à situação apurada, exemplo: 240 minutos (4 horas).
+     * // Após a adição, a quantidade de horas apuradas será 240 minutos (4 horas).
+     * ```
+     * 
+     * @param numberOfHours Quantidade de horas a ser adicionada.
+     */
+    public addNumberOfHours(numberOfHours: number) {
+        this._changed = true;
+        this._numberOfHours += numberOfHours;
+    }
+
+    /**
+     * @hidden
+     * Retorna o id da situação.
+     * Somente retorna caso exista referência para a situação.
+     */
+    private get situationId(): string | undefined {
+        return this._situationId;
+    }
+
+    public static clone(object: TimeEvaluationSituation): TimeEvaluationSituation {
+        return new TimeEvaluationSituation({
+            situationId: object.situationId,
+            situationCode: object.situationCode,
+            numberOfHours: object.numberOfHours,
+        });
+    }
+}

package/src/data/user/user.ts

@@ -0,0 +1,44 @@
+/**
+ * @hidden
+ * Interface para os parâmetros do construtor do User.
+ */
+export interface UserParams {
+    userName: string;
+}
+
+/**
+ * Representa o usuário corrente.
+ * 
+ * @example
+ * ```typescript
+ * console.log(user.userName); // Retorna o usuário corrente. Exemplo: "admin@senior.com.br"
+ * ```
+ */
+export class User {
+    
+    /**
+     *  Usuário corrente.
+     */
+    private readonly _userName: string;
+
+    /**
+     * @hidden
+     * @param params Parâmetros necessários para criar uma instância de User.
+     */
+    constructor(params: UserParams) {
+        this._userName = params.userName;
+    }
+
+    /**
+     * Retorna o usuário corrente.
+     * 
+     * @example
+     * ```typescript
+     * let userName = user.userName; // Retorna o usuário corrente.
+     * ```
+     * @return Usuário corrente.
+     */
+    get userName(): string {
+        return this._userName;
+    }
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+export { Context } from './data/context/context';
+export { Changes, ChangesItems, ChangesType } from './data/changes/changes';
+export { ClockingEvent, ClockingEventOriginType, ClockingUseType } from './data/timeEvaluation/clockingEvent';
+export { Contract, ContractType } from './data/contract/contract';
+export { DateUtils, WeekDay } from './utils/dateUtils';
+export { ObjectUtils } from './utils/object.utils';
+export { Employee } from './data/employee/employee';
+export { Employer } from './data/foundation/employer';
+export { EmploymentRelationship } from './data/foundation/employmentRelationship';
+export { Log, LogType } from './data/log/log';
+export { Histories } from './data/histories/histories';
+export { Holiday } from './data/foundation/holiday';
+export { HolidayGroup } from './data/foundation/holidayGroup';
+export { Interval, IntervalSubTypes, IntervalTypes, PositionWorkHours } from './data/timeEvaluation/interval';
+export { Person } from './data/foundation/person';
+export { Dataset as RuleParams } from './data/dataset/dataset';
+export { Schedules } from './data/schedules/schedules';
+export { Bridge } from './data/schedules/bridge';
+export { WorkscheduleChange } from './data/schedules/workscheduleChange';
+export { WorkshiftChange } from './data/schedules/workshiftChange';
+export { LeaveHistory } from './data/histories/leaveHistory';
+export { SeparatedHours } from './data/timeEvaluation/separatedHours';
+export { Situation, SituationType } from './data/foundation/situation';
+export { Syndicate } from './data/foundation/syndicate';
+export { TimeEvaluation } from './data/timeEvaluation/timeEvaluation';
+export { TimeEvaluationSituation } from './data/timeEvaluation/timeEvaluationSituation';
+export {
+    Workschedule,
+    WorkscheduleClockingRegister,
+    WorkscheduleClockingEvent,
+    WorkscheduleParams,
+    WorkscheduleType,
+    ClockingEventScheduleType,
+    WorkscheduleDefinitionType,
+    UsingType,
+    IntervalType
+} from './data/foundation/workschedule';
+export { Workshift, WorkshiftParams, WorkshiftType, AutoSearchType, TimeShiftType, WorkshiftGroup, WorkshiftDetail, HolidayGroupParams, HolidayType } from './data/foundation/workshift';
+export { TimeEvaluationSituationDefinitionHistory } from './data/definition/timeEvaluationSituationDefinitionHistory';
+export { JobPositionHistory } from './data/histories/jobPositionHistory';
+export { WorkshiftHistory } from './data/histories/workshiftHistory';
+export { JobPosition } from './data/foundation/jobPosition';
+export { CompanyBranchHistory } from './data/histories/companyBranchHistory';
+export { CompanyBranch } from './data/foundation/companyBranch';
+export { DateInterval, DateIntervalUtils } from './utils/dateIntervalUtils';
+export { ContextReference } from './data/context/contextReference';
+export { User } from './data/user/user';
+export { HourBankAccount } from './data/hourBank/hourBankAccount';
+export { EmploymentRelationshipHistory } from "./data/histories/employmentRelationshipHistory";
+export { TimeEvaluationHistory, TimeEvaluationType } from './data/histories/timeEvaluationHistory';
+export { EstimatedHours } from "./data/timeEvaluation/estimatedHours";
+export { HourBank } from "./data/hourBank/hourBank";
+export { Readiness } from './data/schedules/readiness';
+export { OvertimeAuthorization } from "./data/schedules/overtimeAuthorization";
+export { Compensation, CompensationType, PeriodType } from './data/schedules/compensation';
+export { CostCenter } from "./data/foundation/costCenter";
+export { Database } from "./data/dataset/database";
+export { Dataset } from "./data/dataset/dataset";
+export { CostCenterHistory } from "./data/histories/costCenterHistory";
+export { AdjustmentReason, AdjustmentReasonParams } from './data/timeEvaluation/adjustmentReason';

package/src/test/builder/bridgeBuilder.builder.ts

@@ -0,0 +1,28 @@
+import { Bridge, BridgeParams } from "../../data/schedules/bridge";
+
+export class BridgeBuilder {
+    private originDate: Date = new Date();
+    private destinationDate: Date = new Date();
+
+    static builder(): BridgeBuilder {
+        return new BridgeBuilder();
+    }
+
+    withOriginDate(originDate: Date): BridgeBuilder {
+        this.originDate = originDate;
+        return this;
+    }
+
+    withDestinationDate(destinationDate: Date): BridgeBuilder {
+        this.destinationDate = destinationDate;
+        return this;
+    }
+
+    build(): Bridge {
+        const params: BridgeParams = {
+            originDate: this.originDate,
+            destinationDate: this.destinationDate,
+        };
+        return new Bridge(params);
+    }
+}

package/src/test/builder/clockingEvent.builder.ts

@@ -0,0 +1,49 @@
+import { ObjectUtils } from "../../../src/utils/object.utils";
+import { ClockingEventOriginType, ClockingUseType, ClockingEvent, ClockingEventParams } from "../../../src/data/timeEvaluation/clockingEvent";
+
+export class ClockingEventBuilder {
+ 
+  private clockingEventDate = new Date("2025-01-01");
+  private clockingEventTime = 429;
+  private functionCode = 0;
+  private originType = ClockingEventOriginType.TYPED;
+  private useType = ClockingUseType.CLOCKING;
+
+  public withClockingEventDate(clockingEventDate: Date): ClockingEventBuilder {
+    this.clockingEventDate = clockingEventDate;
+    return this;
+  }
+
+  public withClockingEventTime(clockingEventTime: number): ClockingEventBuilder {
+    this.clockingEventTime = clockingEventTime;
+    return this;
+  }
+
+  public withFunctionCode(functionCode: number): ClockingEventBuilder {
+    this.functionCode = functionCode;
+    return this;
+  }
+
+  public withOriginType(originType: ClockingEventOriginType): ClockingEventBuilder {
+    this.originType = originType;
+    return this;
+  }
+
+  public withUseType(useType: ClockingUseType): ClockingEventBuilder {
+    this.useType = useType;
+    return this;
+  }
+  
+
+  public build(): ClockingEvent {
+    const params: ClockingEventParams = {
+      clockingEventDate: ObjectUtils.toDateOrThrow(this.clockingEventDate, "clockingEvent.clockingEventDate"),
+      clockingEventTime: this.clockingEventTime,
+      functionCode: this.functionCode,
+      originType: this.originType,
+      useType: this.useType,
+    };
+
+    return new ClockingEvent(params);
+  }
+}

package/src/test/builder/companyBranchHistoryBuilder.ts

@@ -0,0 +1,29 @@
+import { CompanyBranchHistory, CompanyBranchHistoryParams } from "../../data/histories/companyBranchHistory";
+
+export class CompanyBranchHistoryBuilder {
+    static defaultParams(): CompanyBranchHistoryParams {
+        return {
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-12-31"),
+            companyBranchKey: "CB1"
+        };
+    }
+
+    static default(): { build: () => CompanyBranchHistory } {
+        return {
+            build: (): CompanyBranchHistory => {
+                return new CompanyBranchHistory(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<CompanyBranchHistoryParams>): { build: () => CompanyBranchHistory } {
+        return {
+            build: (): CompanyBranchHistory => {
+                const def = this.defaultParams();
+                const merged: CompanyBranchHistoryParams = { ...def, ...params };
+                return new CompanyBranchHistory(merged);
+            }
+        };
+    }
+}

package/src/test/builder/compensation.builder.ts

@@ -0,0 +1,84 @@
+import { Compensation, CompensationParams, CompensationType, PeriodType } from "../../data/schedules/compensation";
+
+export class CompensationBuilder {
+    private params: CompensationParams;
+
+    private constructor() {
+        this.params = CompensationBuilder.defaultParams();
+    }
+
+    static defaultParams(): CompensationParams {
+        return {
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-01-31"),
+            intervalStart: 480, // 08:00
+            intervalEnd: 1020, // 17:00
+            compensationType: CompensationType.ABSENCE_FOR_COMPENSATION,
+            periodType: PeriodType.ANY_PART_OF_WORKDAY,
+            numberOfHours: 8,
+            situationId: "situation-123",
+            workscheduleId: "workschedule-456",
+        };
+    }
+
+    static default(): CompensationBuilder {
+        return new CompensationBuilder();
+    }
+
+    withParams(params: Partial<CompensationParams>): CompensationBuilder {
+        this.params = {
+            ...this.params,
+            ...params
+        };
+        return this;
+    }
+
+    withStartDate(startDate: Date): CompensationBuilder {
+        this.params.startDate = startDate;
+        return this;
+    }
+
+    withEndDate(endDate: Date): CompensationBuilder {
+        this.params.endDate = endDate;
+        return this;
+    }
+
+    withIntervalStart(intervalStart: number): CompensationBuilder {
+        this.params.intervalStart = intervalStart;
+        return this;
+    }
+
+    withIntervalEnd(intervalEnd: number): CompensationBuilder {
+        this.params.intervalEnd = intervalEnd;
+        return this;
+    }
+
+    withCompensationType(compensationType: CompensationType): CompensationBuilder {
+        this.params.compensationType = compensationType;
+        return this;
+    }
+
+    withPeriodType(periodType: PeriodType): CompensationBuilder {
+        this.params.periodType = periodType;
+        return this;
+    }
+
+    withNumberOfHours(numberOfHours: number): CompensationBuilder {
+        this.params.numberOfHours = numberOfHours;
+        return this;
+    }
+
+    withSituationId(situationId: string): CompensationBuilder {
+        this.params.situationId = situationId;
+        return this;
+    }
+
+    withWorkscheduleId(workscheduleId: string): CompensationBuilder {
+        this.params.workscheduleId = workscheduleId;
+        return this;
+    }
+
+    build(): Compensation {
+        return new Compensation(this.params);
+    }
+}

package/src/test/builder/contextReference.builder.ts

@@ -0,0 +1,69 @@
+import { ContextReference } from "../../../src/data/context/contextReference";
+import { Situation } from "../../../src/data/foundation/situation";
+import { SituationBuilder } from "./situation.builder";
+import { HolidayBuilder } from "./holiday.builder";
+import { TimeEvaluationSituationDefinitionHistory } from "../../data/definition/timeEvaluationSituationDefinitionHistory";
+import { Holiday } from "../../data/foundation/holiday";
+
+export class ContextReferenceBuilder {
+    private situations: Situation[] = [
+        new SituationBuilder().build()
+    ];
+
+    private holidays: Holiday[] = [
+        new HolidayBuilder().build()
+    ];
+
+    static builder(): ContextReferenceBuilder {
+        return new ContextReferenceBuilder();
+    }
+    static default(): ContextReferenceBuilder { 
+        return new ContextReferenceBuilder();
+    }
+
+    private timeEvaluationSituationDefinitionHistories: TimeEvaluationSituationDefinitionHistory[] = [];
+
+    public withSituations(situations: Situation[]): ContextReferenceBuilder {
+        this.situations = situations;
+        return this;
+    }
+
+    public withHolidays(holidays: Holiday[]): ContextReferenceBuilder {
+        this.holidays = holidays;
+        return this;
+    }
+
+    static empty(): ContextReference {
+        return new ContextReference({
+            situations: [],
+            holidays: [],
+            timeEvaluationSituationDefinitions: [],
+            jobPositions: [],
+            companyBranches: [],
+            workschedules: [],
+            workshifts: [],
+            workshiftGroups: [],
+            workshiftDetails: [],
+            syndicates: [],
+            employmentRelationships: [],
+            costCenters: []
+        });
+    }
+
+    public build(): ContextReference {
+        return new ContextReference({
+            situations: this.situations,
+            holidays: this.holidays,
+            timeEvaluationSituationDefinitions: this.timeEvaluationSituationDefinitionHistories,
+            jobPositions: [],
+            workschedules: [],
+            workshifts: [],
+            workshiftGroups: [],
+            workshiftDetails: [],
+            companyBranches: [],
+            syndicates: [],
+            employmentRelationships: [],
+            costCenters: []
+        });
+    }
+}

package/src/test/builder/costCenterHistoryBuilder.ts

@@ -0,0 +1,29 @@
+import { CostCenterHistory, CostCenterHistoryParams } from "../../data/histories/costCenterHistory";
+
+export class CostCenterHistoryBuilder {
+    static defaultParams(): CostCenterHistoryParams {
+        return {
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-12-31"),
+            costCenterKey: "CC1"
+        };
+    }
+
+    static default(): { build: () => CostCenterHistory } {
+        return {
+            build: (): CostCenterHistory => {
+                return new CostCenterHistory(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<CostCenterHistoryParams>): { build: () => CostCenterHistory } {
+        return {
+            build: (): CostCenterHistory => {
+                const def = this.defaultParams();
+                const merged: CostCenterHistoryParams = { ...def, ...params };
+                return new CostCenterHistory(merged);
+            }
+        };
+    }
+}

package/src/test/builder/database.builder.ts

@@ -0,0 +1,21 @@
+import { Database } from "../../data/dataset/database";
+
+export class DatabaseBuilder {
+    
+    static empty(): Database {
+        return new Database({
+            situations: [],
+            holidays: [],
+            jobPositions: [],
+            companyBranches: [],
+            timeEvaluationSituationDefinitions: [],
+            syndicates: [],
+            workschedules: [],
+            workshifts: [],
+            workshiftGroups: [],
+            workshiftDetails: [],
+            employmentRelationships: [],
+            costCenters: []
+        });
+    }
+}

package/src/test/builder/datasetBuilder.ts

@@ -0,0 +1,111 @@
+import { Dataset, DatasetParams } from "../../data/dataset/dataset";
+import { Contract } from "../../data/contract/contract";
+import { TimeEvaluation } from "../../data/timeEvaluation/timeEvaluation";
+import { TimeEvaluationSituation } from "../../data/timeEvaluation/timeEvaluationSituation";
+import { SchedulesBuilder } from "./schedules.builder";
+import { HistoriesBuilder } from "./historiesBuilder";
+import { TimeEvaluationBuilder } from "./timeEvaluation.builder";
+import { EstimatedHours } from "../../data/timeEvaluation/estimatedHours";
+import { DatabaseBuilder } from "./database.builder";
+import { User } from "../../data/user/user";
+
+export class DatasetBuilder {
+    static default() {
+        return {
+            build: (): Dataset => {
+                const params: DatasetParams = {
+                    batchId: "batch-1",
+                    startDate: new Date(),
+                    endDate: new Date(),
+                    contracts: [],
+                    database: DatabaseBuilder.empty(),
+                    currentUser: new User({ userName: "test-user" })
+                };
+                return new Dataset(params);
+            }
+        };
+    }
+
+    static withContractWithError() {
+        return {
+            build: (): Dataset => {
+
+                const timeEvaluation = TimeEvaluationBuilder.default();
+                timeEvaluation.invalidate("Error message");
+
+                const contract = this.newContract(timeEvaluation);
+                const params: DatasetParams = DatasetBuilder.newDatasetParams(contract);
+
+                return new Dataset(params);
+            }
+        };
+    }
+
+    static newDatasetParams(contract: Contract): DatasetParams {
+        return {
+            batchId: "batch-err",
+            startDate: new Date(),
+            endDate: new Date(),
+            contracts: [contract],
+            database: DatabaseBuilder.empty(),
+            currentUser: new User({ userName: "test-user" })
+        };
+    }
+
+    static newContract(timeEvaluation: TimeEvaluation) {
+        return {
+            id: "c1",
+            holidays: [],
+            timeEvaluation: [timeEvaluation],
+            employee: null,
+            histories: [],
+            schedules: [],
+            hourBankAccounts: [],
+        } as unknown as Contract;
+    }
+
+    static withContractWithSituationChanged() {
+
+        return {
+            build: (): Dataset => {
+                const situation = new TimeEvaluationSituation({
+                    situationId: "",
+                    situationCode: 1,
+                    numberOfHours: 8
+                });
+                const timeEvaluation = new TimeEvaluation({
+                    date: new Date(),
+                    workscheduleId: "string",
+                    workscheduleWorkshiftId: "string",
+                    workshiftId: "string",
+                    timeEvaluationSituations: [situation],
+                    clockingEvents: [],
+                    intervals: [],
+                    schedules: SchedulesBuilder.default().build(),
+                    histories: HistoriesBuilder.default().build(),
+                    hourBankAccounts: [],
+                    situationDefinitionKey: "string",
+                    estimatedHours: new EstimatedHours({
+                        meal: [
+                            { dailyHours: 90, nightlyHours: 0 },
+                            { dailyHours: 30, nightlyHours: 10 }
+                        ],
+                        snack: [
+                            { dailyHours: 15, nightlyHours: 5 }
+                        ],
+                        work: [
+                            { dailyHours: 120, nightlyHours: 30 },
+                            { dailyHours: 60, nightlyHours: 0 }
+                        ]
+                    }),
+                    syndicateKey: "string",
+                    missingClockingEvent: false,
+                    costCenterKey: "costCenterKey",
+                });
+                const contract = this.newContract(timeEvaluation);
+                const params = DatasetBuilder.newDatasetParams(contract);
+                return new Dataset(params);
+            }
+        };
+    }
+}