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

package/src/test/builder/dateIntervalBuilder.ts

@@ -0,0 +1,25 @@
+import { DateInterval } from "../../utils/dateIntervalUtils";
+
+/**
+ * Builder estático para DateInterval, com valores padrão e métodos de customização.
+ */
+export class DateIntervalBuilder {
+    public static readonly defaultStart: Date = new Date("2023-01-01T00:00:00.000Z");
+    public static readonly defaultEnd: Date = new Date("2023-01-02T00:00:00.000Z");
+
+    static build(start: Date = DateIntervalBuilder.defaultStart, end: Date = DateIntervalBuilder.defaultEnd): DateInterval {
+        return new DateInterval(start, end);
+    }
+
+    static withStart(start: Date): DateInterval {
+        return new DateInterval(start, DateIntervalBuilder.defaultEnd);
+    }
+
+    static withEnd(end: Date): DateInterval {
+        return new DateInterval(DateIntervalBuilder.defaultStart, end);
+    }
+
+    static withRange(start: Date, end: Date): DateInterval {
+        return new DateInterval(start, end);
+    }
+}

package/src/test/builder/employee.builder.ts

@@ -0,0 +1,91 @@
+import { Employee } from "../../data/employee/employee";
+import { Employer } from "../../data/foundation/employer";
+import { Person } from "../../data/foundation/person";
+
+export class EmployeeBuilder {
+
+  private id = "id";
+  private code = 33;
+  private person: Person = new Person({ name: "Lionel Messi" });
+  private hireDate = new Date("2023-03-23");
+  private dismissalDate: Date | null = null;
+  private employmentRelationshipId = "775ee7d1-5d7f-4a1b-b50b-b659a66014b2";
+  private employer: Employer = new Employer({ code: 1 });
+  private costCenterKey = "02";
+  private companyBranchKey = "1_1";
+  private jobPositionKey = "1_1";
+  private workshiftId = "47971e5f-3d1a-4494-8cf6-328c7dfa5394";
+  private workshiftGroupId = "137fa797-595f-45e7-8365-f256e3148016";
+
+  public withId(id: string): EmployeeBuilder {
+    this.id = id;
+    return this;
+  }
+
+  public withCode(code: number): EmployeeBuilder {
+    this.code = code;
+    return this;
+  }
+
+  public withPerson(person: Person): EmployeeBuilder {
+    this.person = person;
+    return this;
+  }
+
+  public withHireDate(hireDate: Date): EmployeeBuilder {
+    this.hireDate = hireDate;
+    return this;
+  }
+
+  public withDismissalDate(dismissalDate: Date | null): EmployeeBuilder {
+    this.dismissalDate = dismissalDate;
+    return this;
+  }
+
+  public withEmploymentRelationshipId(employmentRelationshipId: string): EmployeeBuilder {
+    this.employmentRelationshipId = employmentRelationshipId;
+    return this;
+  }
+
+  public withEmployer(employer: Employer): EmployeeBuilder {
+    this.employer = employer;
+    return this;
+  }
+
+  public withCompanyBranchKey(companyBranchKey: string): EmployeeBuilder {
+    this.companyBranchKey = companyBranchKey;
+    return this;
+  }
+
+  public withJobPositionKey(jobPositionKey: string): EmployeeBuilder {
+    this.jobPositionKey = jobPositionKey;
+    return this;
+  }
+
+  public withWorkshiftId(workshiftId: string): EmployeeBuilder {
+    this.workshiftId = workshiftId;
+    return this;
+  }
+
+  public withWorkshiftGroupId(workshiftGroupId: string): EmployeeBuilder {
+    this.workshiftGroupId = workshiftGroupId;
+    return this;
+  }
+
+  public build(): Employee {
+    return new Employee({
+      id: this.id,
+      code: this.code,
+      person: this.person,
+      hireDate: this.hireDate,
+      dismissalDate: this.dismissalDate,
+      employmentRelationshipId: this.employmentRelationshipId,
+      employer: this.employer,
+      costCenterKey: this.costCenterKey,
+      companyBranchKey: this.companyBranchKey,
+      jobPositionKey: this.jobPositionKey,
+      workshiftId: this.workshiftId,
+      workshiftGroupId: this.workshiftGroupId
+    });
+  }
+}

package/src/test/builder/employmentRelationshipBuilder.ts

@@ -0,0 +1,35 @@
+import { EmploymentRelationship } from "../../data/foundation/employmentRelationship";
+import { ContractType } from "../../data/contract/contract";
+
+export class EmploymentRelationshipBuilder {
+    private _id = "123";
+    private _code = "1";
+    private _contractType = ContractType.EMPLOYEE;
+
+    static builder(): EmploymentRelationshipBuilder {
+        return new EmploymentRelationshipBuilder();
+    }
+
+    withId(id: string): EmploymentRelationshipBuilder {
+        this._id = id;
+        return this;
+    }
+
+    withCode(code: string): EmploymentRelationshipBuilder {
+        this._code = code;
+        return this;
+    }
+
+    withContractType(contractType: ContractType): EmploymentRelationshipBuilder {
+        this._contractType = contractType;
+        return this;
+    }
+
+    build(): EmploymentRelationship {
+        return new EmploymentRelationship({
+            id: this._id,
+            code: this._code,
+            contractType: this._contractType
+        });
+    }
+}

package/src/test/builder/employmentRelationshipHistoryBuilder.ts

@@ -0,0 +1,29 @@
+import { EmploymentRelationshipHistory, EmploymentRelationshipHistoryParams } from "../../data/histories/employmentRelationshipHistory";
+
+export class EmploymentRelationshipHistoryBuilder {
+    static defaultParams(): EmploymentRelationshipHistoryParams {
+        return {
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-12-31"),
+            employmentRelationshipId: "123"
+        };
+    }
+
+    static default(): { build: () => EmploymentRelationshipHistory } {
+        return {
+            build: (): EmploymentRelationshipHistory => {
+                return new EmploymentRelationshipHistory(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<EmploymentRelationshipHistoryParams>): { build: () => EmploymentRelationshipHistory } {
+        return {
+            build: (): EmploymentRelationshipHistory => {
+                const def = this.defaultParams();
+                const merged: EmploymentRelationshipHistoryParams = { ...def, ...params };
+                return new EmploymentRelationshipHistory(merged);
+            }
+        };
+    }
+}

package/src/test/builder/historiesBuilder.ts

@@ -0,0 +1,56 @@
+import { Histories, HistoriesParams } from "../../data/histories/histories";
+import { CompanyBranchHistoryBuilder } from "./companyBranchHistoryBuilder";
+import { JobPositionHistoryBuilder } from "./jobPositionHistoryBuilder";
+import { EmploymentRelationshipHistoryBuilder } from "./employmentRelationshipHistoryBuilder";
+import { CostCenterHistoryBuilder } from "./costCenterHistoryBuilder";
+
+export class HistoriesBuilder {
+    static defaultParams(): HistoriesParams {
+        return {
+            jobPositionHistories: [
+                JobPositionHistoryBuilder.default().build()
+            ],
+            companyBranchHistories: [
+                CompanyBranchHistoryBuilder.default().build()
+            ],
+            employmentRelationshipHistories: [
+                EmploymentRelationshipHistoryBuilder.default().build()],
+            timeEvaluationHistories: [],
+            workshiftHistories: [],
+            leaveHistories: [],            
+            costCenterHistories: [
+                CostCenterHistoryBuilder.default().build()
+            ]
+        };
+    }
+
+    static default(): { build: () => Histories } {
+        return {
+            build: (): Histories => {
+                return new Histories(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<HistoriesParams>): { build: () => Histories } {
+        return {
+            build: (): Histories => {
+                const def = this.defaultParams();
+                const merged: HistoriesParams = { ...def, ...params };
+                if (params.jobPositionHistories){
+                    merged.jobPositionHistories = params.jobPositionHistories;
+                } 
+                if (params.companyBranchHistories){
+                    merged.companyBranchHistories = params.companyBranchHistories;
+                } 
+                if (params.employmentRelationshipHistories) {
+                    merged.employmentRelationshipHistories = params.employmentRelationshipHistories;
+                }
+                if (params.costCenterHistories) {
+                    merged.costCenterHistories = params.costCenterHistories;
+                }
+                return new Histories(merged);
+            }
+        };
+    }
+}

package/src/test/builder/holiday.builder.ts

@@ -0,0 +1,44 @@
+import { Holiday, HolidayParams } from "../../data/foundation/holiday";
+import { HolidayGroup } from "../../data/foundation/holidayGroup";
+
+export class HolidayBuilder {
+  private key = "holiday-1";
+  private date = new Date("2025-01-01");
+  private group = new HolidayGroup({
+    code: 1
+  });
+
+
+  public static builder(): HolidayBuilder {
+    return new HolidayBuilder();
+  }
+
+  public static default(): HolidayBuilder {
+    return new HolidayBuilder();
+  }
+
+  public withKey(key: string): HolidayBuilder {
+    this.key = key;
+    return this;
+  }
+
+  public withGroup(group: HolidayGroup): HolidayBuilder {
+    this.group = group;
+    return this;
+  }
+
+  public withDate(date: Date): HolidayBuilder {
+    this.date = date;
+    return this;
+  }
+
+  public build(): Holiday {
+    const params: HolidayParams = {
+      key: this.key,
+      date: this.date,
+      holidayGroup: this.group
+    };
+    
+    return new Holiday(params);
+  }
+}

package/src/test/builder/hourBankAccountBuilder.ts

@@ -0,0 +1,77 @@
+import { HourBankAccount } from "../../data/hourBank/hourBankAccount";
+import { HourBank } from "../../data/hourBank/hourBank";
+
+export class HourBankAccountBuilder {
+    private _hourBank: HourBank;
+    private _creationDate: Date;
+    private _extinctionDate: Date | null;
+
+    private constructor() {
+        // Valores padrão
+        this._hourBank = new HourBank({ code: 1 });
+        this._creationDate = new Date("2025-01-01");
+        this._extinctionDate = null;
+    }
+
+    /**
+     * Cria uma nova instância do builder com valores padrão.
+     */
+    static builder(): HourBankAccountBuilder {
+        return new HourBankAccountBuilder();
+    }
+
+    /**
+     * Define o HourBank para o HourBankAccount.
+     * @param hourBank Instância de HourBank.
+     */
+    public withHourBank(hourBank: HourBank): HourBankAccountBuilder {
+        this._hourBank = hourBank;
+        return this;
+    }
+
+    /**
+     * Define a data de criação para o HourBankAccount.
+     * @param creationDate Data de criação.
+     */
+    public withCreationDate(creationDate: Date): HourBankAccountBuilder {
+        this._creationDate = creationDate;
+        return this;
+    }
+
+    /**
+     * Define a data de extinção para o HourBankAccount.
+     * @param extinctionDate Data de extinção.
+     */
+    public withExtinctionDate(extinctionDate: Date | null): HourBankAccountBuilder {
+        this._extinctionDate = extinctionDate;
+        return this;
+    }
+
+    /**
+     * Define múltiplos parâmetros para o HourBankAccount.
+     * @param params Parâmetros personalizados.
+     */
+    public withParams(params: Partial<{ hourBank: HourBank; creationDate: Date; extinctionDate: Date | null }>): HourBankAccountBuilder {
+        if (params.hourBank) {
+            this._hourBank = params.hourBank;
+        }
+        if (params.creationDate) {
+            this._creationDate = params.creationDate;
+        }
+        if (params.extinctionDate !== undefined) {
+            this._extinctionDate = params.extinctionDate;
+        }
+        return this;
+    }
+
+    /**
+     * Constrói uma instância de HourBankAccount com os valores configurados.
+     */
+    public build(): HourBankAccount {
+        return new HourBankAccount({
+            hourBank: this._hourBank,
+            creationDate: this._creationDate,
+            extinctionDate: this._extinctionDate,
+        });
+    }
+}

package/src/test/builder/hourBankBuilder.ts

@@ -0,0 +1,32 @@
+import { HourBank, HourBankParams } from "../../data/hourBank/hourBank";
+
+export class HourBankBuilder {
+    /**
+     * Cria uma instância padrão de HourBank.
+     */
+    static default(): HourBank {
+        return new HourBank({
+            code: 1, // Valor padrão para o código
+        });
+    }
+
+    /**
+     * Cria uma instância personalizada de HourBank com código específico.
+     * @param code Código personalizado para HourBank.
+     */
+    static withCode(code: number): HourBank {
+        return new HourBank({
+            code
+        });
+    }
+
+    /**
+     * Cria uma instância personalizada de HourBank.
+     * @param params Parâmetros personalizados para HourBank.
+     */
+    static withParams(params: Partial<HourBankParams>): HourBank {
+        return new HourBank({
+            code: params.code ?? 1, // Usa o valor padrão se não for fornecido
+        });
+    }
+}

package/src/test/builder/interval.builder.ts

@@ -0,0 +1,113 @@
+import { Interval, IntervalSubTypes, IntervalTypes, IntervalParams, PositionWorkHours } from "../../../src/data/timeEvaluation/interval";
+import { AdjustmentReason } from '../../data/timeEvaluation/adjustmentReason';
+
+export class IntervalBuilder {
+  private clockingEventStart = new Date("2024-04-02T08:00:00Z");
+  private clockingEventEnd = new Date("2024-04-02T12:00:00Z");
+  private type = IntervalTypes.WORKING;
+  private subType = IntervalSubTypes.ENTER;
+  private typeIntervalTolerance = IntervalTypes.TOLERANCE;
+  private subTypeIntervalTolerance = IntervalSubTypes.DELAY;
+  private situationId = "1";
+  private adjustmentReason = new AdjustmentReason({ code: 1001 });
+  private justifiedDays = 1;
+  private positionWorkingPart = new PositionWorkHours({
+    workingHours: 4,
+    part: 1,
+  });
+  private isNightly = false;
+  private isOvertimeAuthorized = false;
+  private isTolerancePeriod = false;
+  private inClockingEventTolerance = false;
+
+  public withClockingEventStart(date: Date): IntervalBuilder {
+    this.clockingEventStart = date;
+    return this;
+  }
+
+  public withClockingEventEnd(date: Date): IntervalBuilder {
+    this.clockingEventEnd = date;
+    return this;
+  }
+
+  public withType(type: IntervalTypes): IntervalBuilder {
+    this.type = type;
+    return this;
+  }
+
+  public withSubType(subType: IntervalSubTypes): IntervalBuilder {
+    this.subType = subType;
+    return this;
+  }
+
+  public withTypeIntervalTolerance(type: IntervalTypes): IntervalBuilder {
+    this.typeIntervalTolerance = type;
+    return this;
+  }
+
+  public withSubTypeIntervalTolerance(subType: IntervalSubTypes): IntervalBuilder {
+    this.subTypeIntervalTolerance = subType;
+    return this;
+  }
+
+  public withSituationId(id: string): IntervalBuilder {
+    this.situationId = id;
+    return this;
+  }
+
+  public withAdjustmentReason(adjustmentReason: AdjustmentReason): IntervalBuilder {
+    this.adjustmentReason = adjustmentReason;
+    return this;
+  }
+
+  public withJustifiedDays(days: number): IntervalBuilder {
+    this.justifiedDays = days;
+    return this;
+  }
+
+  public withpositionWorkingPart(position: PositionWorkHours): IntervalBuilder {
+    this.positionWorkingPart = position;
+    return this;
+  }
+
+  public withIsNightly(value: boolean): IntervalBuilder {
+    this.isNightly = value;
+    return this;
+  }
+
+  public withIsOvertimeAuthorized(value: boolean): IntervalBuilder {
+    this.isOvertimeAuthorized = value;
+    return this;
+  }
+
+  public withIsTolerancePeriod(value: boolean): IntervalBuilder {
+    this.isTolerancePeriod = value;
+    return this;
+  }
+
+  public withInClockingEventTolerance(value: boolean): IntervalBuilder {
+    this.inClockingEventTolerance = value;
+    return this;
+  }
+
+  public build(): Interval {
+    const params: IntervalParams = {
+      clockingEventStart: this.clockingEventStart,
+      clockingEventEnd: this.clockingEventEnd,
+      type: this.type,
+      subType: this.subType,
+      typeIntervalTolerance: this.typeIntervalTolerance,
+      subTypeIntervalTolerance: this.subTypeIntervalTolerance,
+      situationId: this.situationId,
+      adjustmentReason: this.adjustmentReason,
+      justifiedDays: this.justifiedDays,
+      positionWorkingPart: this.positionWorkingPart,
+      isNightly: this.isNightly,
+      isOvertimeAuthorized: this.isOvertimeAuthorized,
+      isTolerancePeriod: this.isTolerancePeriod,
+      inClockingEventTolerance: this.inClockingEventTolerance
+    }
+
+    return new Interval(params);
+  }
+}

package/src/test/builder/jobPositionHistoryBuilder.ts

@@ -0,0 +1,29 @@
+import { JobPositionHistory, JobPositionHistoryParams } from "../../data/histories/jobPositionHistory";
+
+export class JobPositionHistoryBuilder {
+    static defaultParams(): JobPositionHistoryParams {
+        return {
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-12-31"),
+            jobPositionKey: "JP1"
+        };
+    }
+
+    static default(): { build: () => JobPositionHistory } {
+        return {
+            build: (): JobPositionHistory => {
+                return new JobPositionHistory(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<JobPositionHistoryParams>): { build: () => JobPositionHistory } {
+        return {
+            build: (): JobPositionHistory => {
+                const def = this.defaultParams();
+                const merged: JobPositionHistoryParams = { ...def, ...params };
+                return new JobPositionHistory(merged);
+            }
+        };
+    }
+}

package/src/test/builder/overtimeAuthorization.builder.ts

@@ -0,0 +1,42 @@
+import { OvertimeAuthorization, OvertimeAuthorizationParams } from "../../data/schedules/overtimeAuthorization";
+
+export class OvertimeAuthorizationBuilder {
+    private startDate: Date = new Date();
+    private endDate: Date = new Date();
+    private startTime: number = 0;
+    private endTime: number = 0;
+
+    static builder(): OvertimeAuthorizationBuilder {
+        return new OvertimeAuthorizationBuilder();
+    }
+
+    withStartDate(startDate: Date): OvertimeAuthorizationBuilder {
+        this.startDate = startDate;
+        return this;
+    }
+
+    withEndDate(endDate: Date): OvertimeAuthorizationBuilder {
+        this.endDate = endDate;
+        return this;
+    }
+
+    withStartTime(startTime: number): OvertimeAuthorizationBuilder {
+        this.startTime = startTime;
+        return this;
+    }
+
+    withEndTime(endTime: number): OvertimeAuthorizationBuilder {
+        this.endTime = endTime;
+        return this;
+    }
+
+    build(): OvertimeAuthorization {
+        const params: OvertimeAuthorizationParams = {
+            startDate: this.startDate,
+            endDate: this.endDate,
+            startTime: this.startTime,
+            endTime: this.endTime,
+        };
+        return new OvertimeAuthorization(params);
+    }
+}

package/src/test/builder/readinessBuilder.builder.ts

@@ -0,0 +1,57 @@
+import { Readiness, ReadinessParams } from '../../data/schedules/readiness';
+
+export class ReadinessBuilder {
+    
+    private startDate: Date = new Date();
+    private endDate: Date = new Date();
+    private startTime: number = 0;
+    private endTime: number = 0;
+    private continuous: boolean = false;
+    private situationId: string = '';
+
+    static builder(): ReadinessBuilder {
+        return new ReadinessBuilder();
+    }
+
+    withStartDate(startDate: Date): ReadinessBuilder {
+        this.startDate = startDate;
+        return this;
+    }
+
+    withEndDate(endDate: Date): ReadinessBuilder {
+        this.endDate = endDate;
+        return this;
+    }
+
+    withStartTime(startTime: number): ReadinessBuilder {
+        this.startTime = startTime;
+        return this;
+    }
+
+    withEndTime(endTime: number): ReadinessBuilder {
+        this.endTime = endTime;
+        return this;
+    }
+
+    withContinuous(continuous: boolean): ReadinessBuilder {
+        this.continuous = continuous;
+        return this;
+    }
+
+    withSituationId(situationId: string): ReadinessBuilder {
+        this.situationId = situationId;
+        return this;
+    }
+
+    build(): Readiness {
+        const params: ReadinessParams = {
+            startDate: this.startDate,
+            endDate: this.endDate,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            continuous: this.continuous,
+            situationId: this.situationId
+        };
+        return new Readiness(params);
+    }
+}