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

package/src/test/builder/schedules.builder.ts

@@ -0,0 +1,126 @@
+import { Schedules, SchedulesParams } from "../../../src/data/schedules/schedules";
+import { Bridge } from "../../../src/data/schedules/bridge";
+import { BridgeBuilder } from "./bridgeBuilder.builder";
+import { WorkscheduleChange } from "../../data/schedules/workscheduleChange";
+import { Readiness } from "../../data/schedules/readiness";
+import { ReadinessBuilder } from "./readinessBuilder.builder";
+import { OvertimeAuthorization } from "../../data/schedules/overtimeAuthorization";
+import { OvertimeAuthorizationBuilder } from "./overtimeAuthorization.builder";
+import { Compensation } from "../../../src/data/schedules/compensation";
+import { CompensationBuilder } from "./compensation.builder";
+import { CompensationType, PeriodType } from '../../data/schedules/compensation';
+
+export class SchedulesBuilder {
+    private bridges: Bridge[] = [
+        BridgeBuilder.builder().withOriginDate(new Date("2023-01-01")).withDestinationDate(new Date("2023-01-02")).build(),
+        BridgeBuilder.builder().withOriginDate(new Date("2023-02-01")).withDestinationDate(new Date("2023-02-02")).build()
+    ];
+
+    private readiness: Readiness[] = [
+        ReadinessBuilder.builder()
+            .withStartDate(new Date("2023-01-01"))
+            .withEndDate(new Date("2023-01-02"))
+            .withStartTime(8)
+            .withEndTime(17)
+            .withContinuous(true)
+            .withSituationId("situation123")
+            .build(),
+        ReadinessBuilder.builder()
+            .withStartDate(new Date("2023-02-01"))
+            .withEndDate(new Date("2023-02-02"))
+            .withStartTime(9)
+            .withEndTime(18)
+            .withContinuous(false)
+            .withSituationId("situation456")
+            .build()
+    ];
+
+    private overtimeAuthorizations: OvertimeAuthorization[] = [
+        OvertimeAuthorizationBuilder.builder()
+            .withStartDate(new Date("2023-01-01"))
+            .withEndDate(new Date("2023-01-02"))
+            .withStartTime(9)
+            .withEndTime(17)
+            .build(),
+        OvertimeAuthorizationBuilder.builder()
+            .withStartDate(new Date("2023-02-01"))
+            .withEndDate(new Date("2023-02-02"))
+            .withStartTime(10)
+            .withEndTime(18)
+            .build()
+    ];
+
+    private compensations: Compensation[] = [
+        CompensationBuilder.default()
+            .withStartDate(new Date("2023-01-01"))
+            .withEndDate(new Date("2023-01-31"))
+            .withIntervalStart(480) // 08:00
+            .withIntervalEnd(1020) // 17:00
+            .withCompensationType(CompensationType.ABSENCE_FOR_COMPENSATION)
+            .withPeriodType(PeriodType.ANY_PART_OF_WORKDAY)
+            .withNumberOfHours(8)
+            .withSituationId("situation-123")
+            .withWorkscheduleId("workschedule-456")
+            .build(),
+        CompensationBuilder.default()
+            .withStartDate(new Date("2023-02-01"))
+            .withEndDate(new Date("2023-02-28"))
+            .withIntervalStart(480) // 08:00
+            .withIntervalEnd(1020) // 17:00
+            .withCompensationType(CompensationType.ABSENCE_FOR_COMPENSATION)
+            .withPeriodType(PeriodType.ANY_PART_OF_WORKDAY)
+            .withNumberOfHours(8)
+            .withSituationId("situation-456")
+            .withWorkscheduleId("workschedule-789")
+            .build()
+    ];
+
+    private workscheduleChanges: WorkscheduleChange[] = []; // Placeholder for future workshift changes
+
+    static builder(): SchedulesBuilder {
+        return new SchedulesBuilder();
+    }
+
+    static default(): SchedulesBuilder {
+        return new SchedulesBuilder();
+    }
+
+    withBridges(bridges: Bridge[]): SchedulesBuilder {
+        this.bridges = bridges;
+        return this;
+    }
+
+    withWorkscheduleChanges(workscheduleChanges: WorkscheduleChange[]): SchedulesBuilder {
+        this.workscheduleChanges = workscheduleChanges;
+        return this;
+    }
+
+    withReadiness(readiness: Readiness[]): SchedulesBuilder {
+        this.readiness = readiness;
+        return this;
+    }
+
+    withOvertimeAuthorizations(overtimeAuthorizations: OvertimeAuthorization[]): SchedulesBuilder {
+        this.overtimeAuthorizations = overtimeAuthorizations;
+        return this;
+    }
+
+    withCompensations(compensations: Compensation[]): SchedulesBuilder {
+        this.compensations = compensations;
+        return this;
+    }
+    
+    build(): Schedules {
+        const params: SchedulesParams = {
+            bridges: this.bridges,
+            workscheduleChanges: [],
+            workshiftChanges: [],
+            readinesses: this.readiness,
+            overtimeAuthorizations: this.overtimeAuthorizations,
+            compensations: this.compensations,
+        };
+        return new Schedules(
+            params
+        );
+    }
+}

package/src/test/builder/situation.builder.ts

@@ -0,0 +1,59 @@
+import { Situation, SituationParams, SituationType } from "../../../src/data/foundation/situation";
+
+export class SituationBuilder {
+  private id = "02190811-5317-451c-bbe7-8920a570677d";
+  private code = 1;
+  private type = SituationType.WORKING;
+  private exception = false;
+  private daytime = true;
+  private complementarySituationId = "02190811-5317-451c-bbe7-8920a570677d";
+
+  static builder(): SituationBuilder {
+    return new SituationBuilder();
+  }
+
+  public withId(id: string): SituationBuilder {
+    this.id = id;
+    return this;
+  }
+
+  public withCode(code: number): SituationBuilder {
+    this.code = code;
+    return this;
+  }
+
+  public withType(type: SituationType): SituationBuilder {
+    this.type = type;
+    return this;
+  }
+
+  public withException(exception: boolean): SituationBuilder {
+    this.exception = exception;
+    return this;
+  }
+
+  public withDaytime(daytime: boolean): SituationBuilder {
+    this.daytime = daytime;
+    return this;
+  }
+
+  public withComplementarySituationId(complementarySituationId: string): SituationBuilder {
+    this.complementarySituationId = complementarySituationId;
+    return this;
+  }
+
+
+
+  public build(): Situation {
+    const params: SituationParams = {
+      id: this.id,
+      code: this.code,
+      type: this.type,
+      exception: this.exception,
+      daytime: this.daytime,
+      complementarySituationId: this.complementarySituationId
+    };
+
+    return new Situation(params);
+  }
+}

package/src/test/builder/syndicate.builder.ts

@@ -0,0 +1,96 @@
+import { Syndicate, SyndicateParams } from "../../data/foundation/syndicate";
+
+export class SyndicateBuilder {
+  
+  private key = "1";
+  private code = 1;
+  private nightStartHour = 1320;
+  private nightEndHour = 300;
+  private minimumInterval4to6Hours = 540;
+  private minimumInterval6Hours = 60;
+  private minimumWorkDuration6Hours = 60;
+  private maxDailyWorkTime = 480;
+  private maxContinuousDrivingTime = 540;
+  private minContinuousRestTime = 60;
+  private allowDailyRestFractionation = false;
+  private calculateWeeklyRest = false;
+
+  public withKey(key: string): SyndicateBuilder {
+    this.key = key;
+    return this;
+  }
+
+  public withCode(code: number): SyndicateBuilder {
+    this.code = code;
+    return this;
+  }
+
+  public withNightStartHour(hour: number): SyndicateBuilder {
+    this.nightStartHour = hour;
+    return this;
+  }
+
+  public withNightEndHour(hour: number): SyndicateBuilder {
+    this.nightEndHour = hour;
+    return this;
+  }
+
+  public withMinimumInterval4to6Hours(interval: number): SyndicateBuilder {
+    this.minimumInterval4to6Hours = interval;
+    return this;
+  }
+
+  public withMinimumInterval6Hours(interval: number): SyndicateBuilder {
+    this.minimumInterval6Hours = interval;
+    return this;
+  }
+
+  public withMinimumWorkDuration6Hours(duration: number): SyndicateBuilder {
+    this.minimumWorkDuration6Hours = duration;
+    return this;
+  }
+
+  public withMaxDailyWorkTime(time: number): SyndicateBuilder {
+    this.maxDailyWorkTime = time;
+    return this;
+  }
+
+  public withMaxContinuousDrivingTime(time: number): SyndicateBuilder {
+    this.maxContinuousDrivingTime = time;
+    return this;
+  }
+
+  public withMinContinuousRestTime(time: number): SyndicateBuilder {
+    this.minContinuousRestTime = time;
+    return this;
+  }
+
+  public withAllowDailyRestFractionation(allow: boolean): SyndicateBuilder {
+    this.allowDailyRestFractionation = allow;
+    return this;
+  }
+
+  public withCalculateWeeklyRest(calculate: boolean): SyndicateBuilder {
+    this.calculateWeeklyRest = calculate;
+    return this;
+  }
+
+  public build(): Syndicate {
+    const params: SyndicateParams = {
+      key: this.key,
+      code: this.code,
+      nightStartHour: this.nightStartHour,
+      nightEndHour: this.nightEndHour,
+      minimumInterval4to6Hours: this.minimumInterval4to6Hours,
+      minimumInterval6Hours: this.minimumInterval6Hours,
+      minimumWorkDuration6Hours: this.minimumWorkDuration6Hours,
+      maxDailyWorkTime: this.maxDailyWorkTime,
+      maxContinuousDrivingTime: this.maxContinuousDrivingTime,
+      minContinuousRestTime: this.minContinuousRestTime,
+      allowDailyRestFractionation: this.allowDailyRestFractionation,
+      calculateWeeklyRest: this.calculateWeeklyRest,
+    };
+    
+    return new Syndicate(params);
+  }
+}

package/src/test/builder/syndicateHistoryBuilder.ts

@@ -0,0 +1,33 @@
+import { SyndicateHistory, SyndicateHistoryParams } from "../../data/histories/syndicateHistory";
+import { CollectiveNegotiation } from "../../data/collectiveNegotiation";
+import { Syndicate } from "../../data/syndicate";
+
+export class SyndicateHistoryBuilder {
+    static defaultParams(): SyndicateHistoryParams {
+        return {
+            id: "sh1",
+            collectiveNegotiation: {} as CollectiveNegotiation,
+            syndicate: {} as Syndicate,
+            startDate: new Date("2023-01-01"),
+            endDate: new Date("2023-12-31"),
+        };
+    }
+
+    static default(): { build: () => SyndicateHistory } {
+        return {
+            build: (): SyndicateHistory => {
+                return new SyndicateHistory(this.defaultParams());
+            }
+        };
+    }
+
+    static withParams(params: Partial<SyndicateHistoryParams>): { build: () => SyndicateHistory } {
+        return {
+            build: (): SyndicateHistory => {
+                const def = this.defaultParams();
+                const merged: SyndicateHistoryParams = { ...def, ...params };
+                return new SyndicateHistory(merged);
+            }
+        };
+    }
+}

package/src/test/builder/timeEvaluation.builder.ts

@@ -0,0 +1,138 @@
+import { ClockingEventBuilder } from "./clockingEvent.builder";
+import { IntervalBuilder } from "./interval.builder";
+import { TimeEvaluationSituationBuilder } from "./timeEvaluationSituation.builder";
+import { TimeEvaluation, TimeEvaluationParams } from "../../../src/data/timeEvaluation/timeEvaluation";
+import { TimeEvaluationSituation } from "../../../src/data/timeEvaluation/timeEvaluationSituation";
+import { ClockingEvent } from "../../../src/data/timeEvaluation/clockingEvent";
+import { Interval } from "../../../src/data/timeEvaluation/interval";
+import { SchedulesBuilder } from "./schedules.builder";
+import { Schedules } from "../../../src/data/schedules/schedules";
+import { HourBankAccountBuilder } from "./hourBankAccountBuilder";
+import { HourBankAccount } from "../../data/hourBank/hourBankAccount";
+import { Histories } from "../../data/histories/histories";
+import { EstimatedHours } from '../../data/timeEvaluation/estimatedHours';
+
+/**
+ * Builder para a classe TimeEvaluation.
+ * Este builder é utilizado para criar objetos de teste da classe TimeEvaluation.
+ */
+export class TimeEvaluationBuilder {
+  private date = new Date("2025-01-01");
+  private workscheduleId = "";
+  private workscheduleWorkshiftId = "";
+  private workshiftId = "";
+  private timeEvaluationSituations = [new TimeEvaluationSituationBuilder().build()];
+  private clockingEvents = [new ClockingEventBuilder().build()];
+  private intervals = [new IntervalBuilder().build()];
+  private schedule = SchedulesBuilder.builder().build();
+  private hourBankAccounts = [HourBankAccountBuilder.builder().build()];
+  private situationDefinitionKey = "";
+  private costCenterKey = "";
+  private histories = new Histories({
+    jobPositionHistories: [],
+    companyBranchHistories: [],
+    employmentRelationshipHistories: [],
+    timeEvaluationHistories: [],
+    workshiftHistories: [],
+    leaveHistories: [],
+    costCenterHistories: []
+  });
+  private estimatedHoursObject = {
+    meal: [],
+    snack: [],
+    work: [],
+  };
+  private estimatedHours = new EstimatedHours(this.estimatedHoursObject);
+  private syndicateId = "";
+
+  static builder(): TimeEvaluationBuilder {
+    return new TimeEvaluationBuilder();
+  }
+
+  static default(): TimeEvaluation {
+    return new TimeEvaluationBuilder().build();
+  }
+  
+
+  withSchedule(schedule: Schedules): TimeEvaluationBuilder {
+    this.schedule = schedule;
+    return this;
+  }
+
+  withSituationDefinitionKey(situationDefinitionKey: string): TimeEvaluationBuilder {
+    this.situationDefinitionKey = situationDefinitionKey;
+    return this;
+  }
+
+  withDate(date: Date): TimeEvaluationBuilder {
+    this.date = date;
+    return this;
+  }
+
+  withWorkschedule(workscheduleId: string): TimeEvaluationBuilder {
+    this.workscheduleId = workscheduleId;
+    return this;
+  }
+
+  withWorkscheduleWorkshift(workscheduleWorkshiftId: string): TimeEvaluationBuilder {
+    this.workscheduleWorkshiftId = workscheduleWorkshiftId;
+    return this;
+  }
+
+  withWorkshift(workshiftId: string): TimeEvaluationBuilder {
+    this.workshiftId = workshiftId;
+    return this;
+  }
+
+  withTimeEvaluationSituations(timeEvaluationSituations: TimeEvaluationSituation[]): TimeEvaluationBuilder {
+    this.timeEvaluationSituations = timeEvaluationSituations;
+    return this;
+  }
+
+  withClockingEvents(clockingEvents: ClockingEvent[]): TimeEvaluationBuilder {
+    this.clockingEvents = clockingEvents;
+    return this;
+  }
+
+  withIntervals(intervals: Interval[]): TimeEvaluationBuilder {
+    this.intervals = intervals;
+    return this;
+  }
+
+  withHourBankAccounts(hourBankAccounts: HourBankAccount[]): TimeEvaluationBuilder {
+    this.hourBankAccounts = hourBankAccounts;
+    return this;
+  }
+
+  withSyndicate(syndicateId: string): TimeEvaluationBuilder {
+    this.syndicateId = syndicateId;
+    return this;
+  }
+
+  withCostCenter(costCenterKey: string): TimeEvaluationBuilder {
+    this.costCenterKey = costCenterKey;
+    return this;
+  }
+
+  build(): TimeEvaluation {
+    const params: TimeEvaluationParams = {
+      date: this.date,
+      missingClockingEvent: false,
+      workscheduleId: this.workscheduleId,
+      workscheduleWorkshiftId: this.workscheduleWorkshiftId,
+      workshiftId: this.workshiftId,
+      timeEvaluationSituations: this.timeEvaluationSituations,
+      clockingEvents: this.clockingEvents,
+      intervals: this.intervals,
+      schedules: this.schedule,
+      hourBankAccounts: this.hourBankAccounts,
+      situationDefinitionKey: this.situationDefinitionKey,
+      histories: this.histories,
+      estimatedHours: this.estimatedHours,
+      syndicateKey: this.syndicateId,
+      costCenterKey: this.costCenterKey,
+    };
+
+    return new TimeEvaluation(params);
+  }
+}

package/src/test/builder/timeEvaluationHistory.builder.ts

@@ -0,0 +1,49 @@
+import { TimeEvaluationHistory, TimeEvaluationType } from "../../data/histories/timeEvaluationHistory";
+import { ContextReferenceBuilder } from "./contextReference.builder";
+
+
+export class TimeEvaluationHistoryBuilder {
+    private startDate = new Date("2024-1-1");
+    private endDate: Date | null = null;
+    private type = TimeEvaluationType.NORMAL;
+    private situationDefinitionKey: string[] = ["1_2022-11-23_null"];
+    private context = ContextReferenceBuilder.empty();
+
+    static builder(): TimeEvaluationHistoryBuilder {
+        return new TimeEvaluationHistoryBuilder();
+    }
+
+    withStartDate(startDate: Date): TimeEvaluationHistoryBuilder {
+        this.startDate = startDate;
+        return this;
+    }
+
+    withEndDate(endDate: Date | null): TimeEvaluationHistoryBuilder {
+        this.endDate = endDate;
+        return this;
+    }
+
+    withType(type: TimeEvaluationType): TimeEvaluationHistoryBuilder {
+        this.type = type;
+        return this;
+    }
+
+    withSituationDefinitionKey(situationDefinitionKey: string): TimeEvaluationHistoryBuilder {
+        if (Array.isArray(situationDefinitionKey)) {
+            this.situationDefinitionKey = situationDefinitionKey;
+        } else {
+            this.situationDefinitionKey = [situationDefinitionKey];
+        }
+        return this;
+    }
+
+
+    build(): TimeEvaluationHistory {
+        return new TimeEvaluationHistory({
+            startDate: this.startDate,
+            endDate: this.endDate,
+            type: this.type,
+            situationDefinitionKey: this.situationDefinitionKey
+        });
+    }
+}

package/src/test/builder/timeEvaluationSituation.builder.ts

@@ -0,0 +1,34 @@
+import { TimeEvaluationSituation, TimeEvaluationSituationParams } from "../../data/timeEvaluation/timeEvaluationSituation";
+
+export class TimeEvaluationSituationBuilder {
+  private id = "default-id";
+  private situationId = "";
+  private situationCode = 1;
+  private numberOfHours = 8;
+
+  withId(id: string): this {
+    this.id = id;
+    return this;
+  }
+
+  withSituation(situation: number): this {
+    this.situationCode = situation;
+    return this;
+  }
+
+  withNumberOfHours(hours: number): this {
+    this.numberOfHours = hours;
+    return this;
+  }
+
+
+  build(): TimeEvaluationSituation {
+    const params: TimeEvaluationSituationParams = {
+      situationId: this.situationId,
+      situationCode: this.situationCode,
+      numberOfHours: this.numberOfHours
+    };
+    
+    return new TimeEvaluationSituation(params);
+  }
+}

package/src/test/builder/workschedule.builder.ts

@@ -0,0 +1,96 @@
+import { 
+  Workschedule, 
+  WorkscheduleClockingRegister, 
+  WorkscheduleClockingEvent, 
+  WorkscheduleParams, 
+  WorkscheduleType, 
+  ClockingEventScheduleType, 
+  WorkscheduleDefinitionType, 
+  UsingType, 
+  IntervalType 
+} from "../../data/foundation/workschedule";
+
+export class WorkscheduleBuilder {
+  private id = "1";
+  private code = 1;
+  private type = WorkscheduleType.FLEXIBLE;
+  private definitionType = WorkscheduleDefinitionType.NORMAL;
+  private workload = 1;
+  private clockingRegisters = [
+    new WorkscheduleClockingRegister({
+      sequence: 1,
+      clockingEvent: 1,
+      toleranceBefore: 1,
+      toleranceAfter: 1,
+      mobilityBefore: 1,
+      mobilityAfter: 1,
+      intervalType: IntervalType.FLEXIBLE,
+      clockingEventScheduleType: ClockingEventScheduleType.GENERATED,
+      usingType: UsingType.MANDATORY_ENTRY_OR_EXIT,
+    }),
+    new WorkscheduleClockingRegister({
+      sequence: 2,
+      clockingEvent: 2,
+      toleranceBefore: 2,
+      toleranceAfter: 2,
+      mobilityBefore: 1,
+      mobilityAfter: 1,
+      intervalType: IntervalType.RIGID,
+      clockingEventScheduleType: ClockingEventScheduleType.GENERATED,
+      usingType: UsingType.NON_MANDATORY_ENTRY_OR_EXIT,
+    }),
+  ];
+
+  private clockingEvent = new WorkscheduleClockingEvent({
+    workStartEndOvertimeTolerance: 1,
+    mealOvertimeTolerance: 1,
+    overtimeDailyTotalTolerance: 1,
+    absenceDailyTotalTolerance: 1,
+    workStartEndAbsenceTolerance: 1,
+    mealAbsenceTolerance: 1,
+  });
+
+  withCode(code: number): this {
+    this.code = code;
+    return this;
+  }
+
+  withType(type: WorkscheduleType): this {
+    this.type = type;
+    return this;
+  }
+
+  withDefinitionType(definitionType: WorkscheduleDefinitionType): this {
+    this.definitionType = definitionType;
+    return this;
+  }
+
+  withClockingRegister(clockingRegisters: WorkscheduleClockingRegister[]): this {
+    this.clockingRegisters = clockingRegisters;
+    return this;
+  }
+
+  withClockingEvent(clockingEvent: WorkscheduleClockingEvent): this {
+    this.clockingEvent = clockingEvent;
+    return this;
+  }
+
+  withWorkload(workload: number): this {
+    this.workload = workload;
+    return this;
+  }
+
+  build(): Workschedule {
+    const params: WorkscheduleParams = {
+      id :this.id,
+      code: this.code,
+      type: this.type,
+      definitionType: this.definitionType,
+      workload: this.workload,
+      clockingRegisters: this.clockingRegisters,
+      clockingEvent: this.clockingEvent,
+    };
+
+    return new Workschedule(params);
+  }
+}