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

package/src/data/dataset/database.ts

@@ -0,0 +1,130 @@
+import { TimeEvaluationSituationDefinitionHistory } from "../definition/timeEvaluationSituationDefinitionHistory";
+import { CompanyBranch } from "../foundation/companyBranch";
+import { JobPosition } from "../foundation/jobPosition";
+import { Holiday } from "./../foundation/holiday";
+import { Situation } from "./../foundation/situation";
+import { Workschedule } from "../foundation/workschedule";
+import { Workshift, WorkshiftDetail, WorkshiftGroup } from "../foundation/workshift";
+import { Syndicate } from "../foundation/syndicate";
+import { EmploymentRelationship } from "../foundation/employmentRelationship";
+import { CostCenter } from "../foundation/costCenter";
+
+/**
+ * @hidden
+ */
+export interface DatabaseParams {
+    situations: Situation[];
+    holidays: Holiday[];
+    jobPositions: JobPosition[];
+    workshifts: Workshift[];
+    workshiftGroups: WorkshiftGroup[];
+    workshiftDetails: WorkshiftDetail[];
+    workschedules: Workschedule[];
+    companyBranches: CompanyBranch[];
+    timeEvaluationSituationDefinitions: TimeEvaluationSituationDefinitionHistory[];
+    syndicates: Syndicate[];
+    employmentRelationships: EmploymentRelationship[];
+    costCenters: CostCenter[];
+}
+
+/**
+ * @hidden
+ * Representa o banco de dados do sistema, contendo informações sobre situações, feriados, cargos, filiais, definições de situações de avaliação de tempo, escalas de trabalho, turnos, sindicatos e relacionamentos empregatícios.
+ * Fornece métodos para acessar essas informações de forma organizada.
+ */
+export class Database {
+    private readonly _situations: Situation[];
+    private readonly _holidays: Holiday[];
+    private readonly _jobPosition: JobPosition[];
+    private readonly _companyBranches: CompanyBranch[];
+    private readonly _timeEvaluationSituationDefinitions: TimeEvaluationSituationDefinitionHistory[];
+    private readonly _workschedules: Workschedule[];
+    private readonly _workshifts: Workshift[];
+    private readonly _workshiftGroups: WorkshiftGroup[];
+    private readonly _workshiftDetails: WorkshiftDetail[];
+    private readonly _syndicates: Syndicate[];
+    private readonly _employmentRelationships: EmploymentRelationship[];
+    private readonly _costCenters: CostCenter[];
+
+    constructor(params: DatabaseParams) {
+        this._situations = params.situations;
+        this._holidays = params.holidays;
+        this._jobPosition = params.jobPositions;
+        this._companyBranches = params.companyBranches;
+        this._timeEvaluationSituationDefinitions = params.timeEvaluationSituationDefinitions;
+        this._workschedules = params.workschedules;
+        this._workshifts = params.workshifts;
+        this._workshiftGroups = params.workshiftGroups;
+        this._workshiftDetails = params.workshiftDetails;
+        this._syndicates = params.syndicates;
+        this._employmentRelationships = params.employmentRelationships;
+        this._costCenters = params.costCenters;
+    }
+
+
+    get situations(): Situation[] {
+        return this._situations;
+    }
+
+    get workschedules(): Workschedule[] {
+        return this._workschedules;
+    }
+
+    get workshifts(): Workshift[] {
+        return this._workshifts;
+    }
+
+    get workshiftGroups(): WorkshiftGroup[] {
+        return this._workshiftGroups;
+    }
+
+    get workshiftDetails(): WorkshiftDetail[] {
+        return this._workshiftDetails;
+    }
+
+    get holidays(): Holiday[] {
+        return this._holidays;
+    }
+
+
+    get timeEvaluationSituationDefinitions(): TimeEvaluationSituationDefinitionHistory[] {
+        return this._timeEvaluationSituationDefinitions;
+    }
+
+    get jobPositions(): JobPosition[] {
+        return this._jobPosition;
+    }
+
+    get companyBranches(): CompanyBranch[] {
+        return this._companyBranches;
+    }
+
+    get syndicates(): Syndicate[] {
+        return this._syndicates;
+    }
+
+    get employmentRelationships(): EmploymentRelationship[] {
+        return this._employmentRelationships;
+    }
+
+    get costCenters(): CostCenter[] {
+        return this._costCenters;
+    }
+
+    static empty(): Database {
+        return new Database({
+            situations: [],
+            holidays: [],
+            jobPositions: [],
+            workshifts: [],
+            workshiftGroups: [],
+            workshiftDetails: [],
+            workschedules: [],
+            companyBranches: [],
+            timeEvaluationSituationDefinitions: [],
+            syndicates: [],
+            employmentRelationships: [],
+            costCenters: []
+        });
+    }
+}

package/src/data/dataset/dataset.ts

@@ -0,0 +1,275 @@
+import { ObjectUtils } from "../../utils/object.utils";
+import { DateUtils } from "../../utils/dateUtils";
+import { Changes, ChangesItems, ChangesType } from "../changes/changes";
+import { ContextReference } from "../context/contextReference";
+import { Contract, ContractParams } from "../contract/contract";
+import { Log, LogType } from "../log/log";
+import { TimeEvaluation } from "./../timeEvaluation/timeEvaluation";
+import { TimeEvaluationSituation } from "../timeEvaluation/timeEvaluationSituation";
+import { Database } from "./database";
+import { User } from "../user/user";
+import fs from 'fs';
+import findUp from 'find-up';
+/**
+ * Representa o parâmetros recebidos pela regra de apuração.
+ * Nas informações estão diponíveis: data inicial e final da apuração, data da apuração, contratos e logs.
+ * 
+ * O Consultor deve iterar sobre os contratos e apurar as situações de cada contrato.
+ * @hidden
+ */
+export interface DatasetParams {
+    batchId: string;
+    startDate: Date;
+    endDate: Date;
+    contracts: Contract[];
+    database: Database;
+    currentUser: User;
+}
+
+
+/**
+ * @hidden
+ */
+export class Dataset {
+
+    private readonly _batchId: string;
+    /**
+     * Data inicial da apuração.
+     */
+    private readonly _startDate: Date;
+    /**
+     * Data final da apuração.
+     */
+    private readonly _endDate: Date;
+    /**
+     * Contratos.
+     */
+    private readonly _contracts: Contract[];
+    private readonly _logs: Log[];
+    private readonly _database: Database;
+    /**
+     * Usuário corrente.
+     */
+    private readonly _currentUser: User;
+
+    /** @hidden */
+    constructor(params: DatasetParams) {
+        this._batchId = params.batchId;
+        this._startDate = ObjectUtils.toDateOrThrow(params.startDate, "Dataset.startDate");
+        this._endDate = ObjectUtils.toDateOrThrow(params.endDate, "Dataset.endDate");
+        this._contracts = [];
+        this._logs = [];
+        this._database = params.database;
+        this._currentUser = new User({ userName: params.currentUser.userName });
+
+        const contextRef = new ContextReference({
+            situations: params.database.situations,
+            holidays: params.database.holidays,
+            timeEvaluationSituationDefinitions: params.database.timeEvaluationSituationDefinitions,
+            jobPositions: params.database.jobPositions,
+            companyBranches: params.database.companyBranches,
+            workschedules: params.database.workschedules,
+            workshifts: params.database.workshifts,
+            workshiftGroups: params.database.workshiftGroups,
+            workshiftDetails: params.database.workshiftDetails,
+            syndicates: params.database.syndicates,
+            employmentRelationships: params.database.employmentRelationships,
+            costCenters: params.database.costCenters,
+        });
+
+        ContextReference.setGlobalInstance(contextRef);
+
+        if (Array.isArray(params.contracts)) {
+            for (const contract of params.contracts) {
+                const contractParams: ContractParams = {
+                    id: contract.id,
+                    holidaysKeys: contract.holidaysKeys,
+                    timeEvaluation: contract.timeEvaluation,
+                    employee: contract.employee,
+                    histories: contract.histories,
+                    schedules: contract.schedules,
+                    hourBankAccounts: contract.hourBankAccounts
+                };
+
+                const newContract = new Contract(contractParams);
+                this._contracts.push(newContract);
+            }
+        }
+    }
+
+    static empty(): Dataset {
+        return new Dataset({
+            batchId: "",
+            startDate: new Date(),
+            endDate: new Date(),
+            contracts: [],
+            database: new Database({
+                situations: [],
+                holidays: [],
+                timeEvaluationSituationDefinitions: [],
+                jobPositions: [],
+                companyBranches: [],
+                workschedules: [],
+                workshifts: [],
+                workshiftGroups: [],
+                workshiftDetails: [],
+                syndicates: [],
+                employmentRelationships: [],
+                costCenters: []            
+            }),
+            currentUser: new User({ userName: "" })
+        });
+    }
+
+
+    get batchId(): string {
+        return this._batchId;
+    }
+
+    /**
+     * Data inicial da apuração.
+     */
+    get startDate(): Date {
+        return this._startDate;
+    }
+
+    /**
+     * Data final da apuração.
+     */
+    get endDate(): Date {
+        return this._endDate;
+    }
+
+    /**
+     * Contratos apurados.
+     */
+    get contracts(): Contract[] {
+        return this._contracts;
+    }
+
+    get database(): Database {
+        return this._database;
+    }
+
+    /**
+     *  Usuário corrente.
+     */
+    get currentUser(): User {
+        return this._currentUser;
+    }
+
+    /**
+     * Extrai as alterações feitas na regra para serem enviadas ao cálculo de apuração.
+     * @returns Json com as alteraçõe da regra.
+     */
+    processChanges(): Changes {
+
+        const changes = new Changes();
+        let sequence = 0;
+
+        this.contracts.forEach((contract: Contract) => {
+            contract.timeEvaluation.forEach((timeEvaluation: TimeEvaluation) => {
+                if (timeEvaluation.errorMessage) {
+                    changes.changesItems.push(
+                        new ChangesItems({
+                            contractId: contract.id || null,
+                            type: ChangesType.ERROR,
+                            timeEvaluationDate: DateUtils.dateToIsoDateStr(timeEvaluation.date),
+                            key: "",
+                            value: timeEvaluation.errorMessage || "",
+                            sequence,
+                        })
+                    );
+                    sequence++;
+                } else {
+                    timeEvaluation.timeEvaluationSituations.forEach((timeEvaluationSituation: TimeEvaluationSituation) => {
+                        if (timeEvaluationSituation.changed) {
+                            changes.changesItems.push(
+                                new ChangesItems({
+                                    contractId: contract.id || null,
+                                    type: ChangesType.SITUATION,
+                                    timeEvaluationDate: DateUtils.dateToIsoDateStr(timeEvaluation.date),
+                                    key: String(timeEvaluationSituation.situation.code),
+                                    value: String(timeEvaluationSituation.numberOfHours),
+                                    sequence,
+                                })
+                            );
+
+                            sequence++
+                        }
+                    });
+                    if (timeEvaluation.generatePendingAdjustment !== undefined) {
+                        changes.changesItems.push(
+                            new ChangesItems({
+                                contractId: contract.id || null,
+                                type: ChangesType.PENDENCY,
+                                timeEvaluationDate: DateUtils.dateToIsoDateStr(timeEvaluation.date),
+                                key: "",
+                                value: timeEvaluation.generatePendingAdjustment ? "true" : "false",
+                                sequence,
+                            })
+                        );
+                        sequence++;
+                    }
+
+                }
+            });
+        });
+
+        this._logs.forEach((log: Log) => {
+            changes.changesItems.push(
+                new ChangesItems({
+                    contractId: null,
+                    type: ChangesType.LOG,
+                    timeEvaluationDate: null,
+                    key: log.type,
+                    value: log.message,
+                    sequence,
+                })
+            );
+            sequence++;
+        });
+
+        sequence++;
+        return changes;
+    }
+
+    /**
+     * @hidden
+     */
+    public getProjectVersionSync(): string | undefined {
+        const packageJsonPath = findUp.sync('package.json');
+        if (!packageJsonPath) {
+            return undefined;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+        return packageJson.dependencies?.['hcm-clocking-event-rule-nodejs'];
+
+    }
+
+
+    /**
+     * Logar de informações no log de processo.
+     * @param message Mensagem de informação.
+     */
+    public logInfo(message: string) {
+        this._logs.push(new Log({ type: LogType.INFO, message }));
+    }
+
+    /**
+     * Logar de aviso no log de processo.
+     * @param message Mensagem de aviso.
+     */
+    public logWarning(message: string) {
+        this._logs.push(new Log({ type: LogType.WARNING, message }));
+    }
+
+    /**
+     * Logar de erro no log de processo.
+     * @param message Mensagem de erro.
+     */
+    public logError(message: string) {
+        this._logs.push(new Log({ type: LogType.ERROR, message }));
+    }
+}