@senior-gestao-pessoas/payroll-core 8.7.0 → 9.0.0

package/esm5/services/report.service.js

@@ -0,0 +1,110 @@
+import * as tslib_1 from "tslib";
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { map } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+var ENDPOINTS = {
+    reportParameters: "platform/report/queries/getParameters",
+    reportUri: "platform/report/queries/getReportUri",
+    reportStatus: "platform/report/queries/getReportStatus",
+    reportsByName: "platform/report/queries/findReportsByName",
+    reportsRunning: "platform/report/queries/getRunningReports",
+    reportsGenerate: "platform/report/actions/generateReport"
+};
+var ReportService = /** @class */ (function () {
+    function ReportService(http) {
+        this.http = http;
+    }
+    /**
+     * Procura por relatórios que contenham no seu nome a string conforme parâmetro `name`
+     * @param name Nome ou parte do nome do relatório
+     */
+    ReportService.prototype.findReportsByName = function (name) {
+        return this.http
+            .post("" + ENDPOINTS.reportsByName, {
+            name: name
+        })
+            .pipe(map(function (payload) {
+            var result = payload.reports ? payload.reports : [];
+            return result;
+        }));
+    };
+    /**
+     * Procura por relatórios que contenham o nome exato conforme parâmetro `name`.
+     * No momento a plataforma não disponibilza uma query exata para isso.
+     * Portanto este método procura pelo nome informado dentro do resultado da query `findReportsByName`
+     * @param name Nome exato do relatório
+     */
+    ReportService.prototype.findReportByName = function (name) {
+        name = name || "";
+        return this.findReportsByName(name).pipe(map(function (payload) {
+            var filtered = payload && payload.filter(function (report) { return report.name && report.name === name; });
+            return filtered && filtered.length == 1 ? filtered[0] : null;
+        }));
+    };
+    /**
+     * Retorna a lista de parâmetros de entrada do relatório
+     * @param reportId Id do relatório
+     * @param reportFileId Identificador de um arquivo de relatório (opcional)
+     */
+    ReportService.prototype.getParameters = function (reportId, reportFileId) {
+        return this.http
+            .post("" + ENDPOINTS.reportParameters, { id: reportId, reportFileId: reportFileId })
+            .pipe(map(function (payload) {
+            return payload ? payload : null;
+        }));
+    };
+    /**
+     * Retorna a URL para visualização do relatório gerado
+     * @param reportTicket Ticket do relatório gerado
+     */
+    ReportService.prototype.getReportUri = function (reportTicket) {
+        return this.http.post("" + ENDPOINTS.reportUri, { reportTicket: reportTicket }).pipe(map(function (payload) {
+            return payload && payload.reportUri;
+        }));
+    };
+    /**
+     * Retorna o status do relatório
+     * @param reportTicket Ticket do relatório gerado
+     */
+    ReportService.prototype.getReportStatus = function (reportTicket) {
+        return this.http.post("" + ENDPOINTS.reportStatus, { reportTicket: reportTicket }).pipe(map(function (payload) {
+            return payload && payload.reportStatus;
+        }));
+    };
+    /**
+     * Gera o relatório
+     * @param reportIn Dados do relatório a ser gerado
+     */
+    ReportService.prototype.generateReport = function (reportIn) {
+        return this.http.post("" + ENDPOINTS.reportsGenerate, reportIn).pipe(map(function (payload) {
+            return payload ? payload : null;
+        }));
+    };
+    /**
+     * Retorna uma lista com os relatórios sendo executados ou já finalizados
+     * @param page página inicial
+     * @param size tamanho da página
+     */
+    ReportService.prototype.getRunningReports = function (page, size) {
+        return this.http.post("" + ENDPOINTS.reportsRunning, {
+            offset: page,
+            limit: size,
+            orderByDesc: true,
+            filterCancelled: true
+        });
+    };
+    ReportService.ctorParameters = function () { return [
+        { type: HttpClient }
+    ]; };
+    ReportService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function ReportService_Factory() { return new ReportService(i0.ɵɵinject(i1.HttpClient)); }, token: ReportService, providedIn: "root" });
+    ReportService = tslib_1.__decorate([
+        Injectable({
+            providedIn: "root"
+        })
+    ], ReportService);
+    return ReportService;
+}());
+export { ReportService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["services/report.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { Injectable } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\nimport { Report, ReportIn, ReportOut, GetParametersOut } from \"../core/interfaces\";\n\nconst ENDPOINTS = {\n    reportParameters: \"platform/report/queries/getParameters\",\n    reportUri: \"platform/report/queries/getReportUri\",\n    reportStatus: \"platform/report/queries/getReportStatus\",\n    reportsByName: \"platform/report/queries/findReportsByName\",\n    reportsRunning: \"platform/report/queries/getRunningReports\",\n    reportsGenerate: \"platform/report/actions/generateReport\"\n};\n\n@Injectable({\n    providedIn: \"root\"\n})\nexport class ReportService {\n    constructor(private http: HttpClient) {}\n\n    /**\n     * Procura por relatórios que contenham no seu nome a string conforme parâmetro `name`\n     * @param name Nome ou parte do nome do relatório\n     */\n    public findReportsByName(\n        name: string,\n    ): Observable<Report[]> {\n        return this.http\n            .post(`${ENDPOINTS.reportsByName}`, {\n                name: name\n            })\n            .pipe(\n                map((payload: any) => {\n                    const result = payload.reports ? payload.reports : [];\n                    return result as Report[];\n                })\n            );\n    }\n\n    /**\n     * Procura por relatórios que contenham o nome exato conforme parâmetro `name`.\n     * No momento a plataforma não disponibilza uma query exata para isso.\n     * Portanto este método procura pelo nome informado dentro do resultado da query `findReportsByName`\n     * @param name Nome exato do relatório\n     */\n    public findReportByName(\n        name: string,\n    ): Observable<Report> {\n        name = name || \"\";\n        return this.findReportsByName(name).pipe(\n            map((payload: any) => {\n                const filtered =\n                    payload && payload.filter((report: any) => report.name && report.name === name);\n                return filtered && filtered.length == 1 ? (filtered[0] as Report) : null;\n            })\n        );\n    }\n\n    /**\n     * Retorna a lista de parâmetros de entrada do relatório\n     * @param reportId Id do relatório\n     * @param reportFileId Identificador de um arquivo de relatório (opcional)\n     */\n    public getParameters(reportId: string, reportFileId?: any): Observable<GetParametersOut> {\n        return this.http\n            .post(`${ENDPOINTS.reportParameters}`, { id: reportId, reportFileId: reportFileId })\n            .pipe(\n                map((payload: any) => {\n                    return payload ? (payload as GetParametersOut) : null;\n                })\n            );\n    }\n\n    /**\n     * Retorna a URL para visualização do relatório gerado\n     * @param reportTicket Ticket do relatório gerado\n     */\n    public getReportUri(reportTicket: string): Observable<string> {\n        return this.http.post(`${ENDPOINTS.reportUri}`, { reportTicket: reportTicket }).pipe(\n            map((payload: any) => {\n                return payload && payload.reportUri;\n            })\n        );\n    }\n\n    /**\n     * Retorna o status do relatório\n     * @param reportTicket Ticket do relatório gerado\n     */\n    public getReportStatus(reportTicket: string): Observable<string> {\n        return this.http.post(`${ENDPOINTS.reportStatus}`, { reportTicket: reportTicket }).pipe(\n            map((payload: any) => {\n                return payload && payload.reportStatus;\n            })\n        );\n    }\n\n    /**\n     * Gera o relatório\n     * @param reportIn Dados do relatório a ser gerado\n     */\n    public generateReport(reportIn: ReportIn): Observable<ReportOut> {\n        return this.http.post(`${ENDPOINTS.reportsGenerate}`, reportIn).pipe(\n            map((payload: any) => {\n                return payload ? (payload as ReportOut) : null;\n            })\n        );\n    }\n\n    /**\n     * Retorna uma lista com os relatórios sendo executados ou já finalizados\n     * @param page página inicial\n     * @param size tamanho da página\n     */\n    public getRunningReports(page: number, size: number): Observable<any> {\n        return this.http.post(`${ENDPOINTS.reportsRunning}`, {\n            offset: page,\n            limit: size,\n            orderByDesc: true,\n            filterCancelled: true\n        });\n    }\n}\n"]}

package/esm5/services/services.module.js

@@ -0,0 +1,32 @@
+import * as tslib_1 from "tslib";
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { CompanyIndicationsService } from "./company-indications.service";
+import { IntegrationService } from "./integration.service";
+import { LookupParametersService } from "./lookup-parameters.service";
+import { AutocompleteParametersService } from "./autocomplete-parameters.service";
+import { ReportService } from "./report.service";
+import { WorkflowDataService } from './workflow-data.service';
+import { FormComparatorService } from "./form-comparator.service";
+export { WorkflowDataService } from './workflow-data.service';
+var ServicesModule = /** @class */ (function () {
+    function ServicesModule() {
+    }
+    ServicesModule = tslib_1.__decorate([
+        NgModule({
+            imports: [CommonModule],
+            providers: [
+                CompanyIndicationsService,
+                IntegrationService,
+                LookupParametersService,
+                AutocompleteParametersService,
+                ReportService,
+                WorkflowDataService,
+                FormComparatorService
+            ]
+        })
+    ], ServicesModule);
+    return ServicesModule;
+}());
+export { ServicesModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/services/workflow-data.service.js

@@ -0,0 +1,27 @@
+import * as tslib_1 from "tslib";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject, Subject } from "rxjs";
+var WorkflowDataService = /** @class */ (function () {
+    function WorkflowDataService() {
+        this.useWorkflowValueChange = new Subject();
+        this._draftJSON = new BehaviorSubject(null);
+    }
+    WorkflowDataService.prototype.setUseWorkflow = function (useWorkflow) {
+        this.useWorkflowValueChange.next(useWorkflow);
+    };
+    WorkflowDataService.prototype.getUseWorkflow = function () {
+        return this.useWorkflowValueChange.asObservable();
+    };
+    WorkflowDataService.prototype.setDraftJSON = function (draftJSON) {
+        this._draftJSON.next(draftJSON);
+    };
+    WorkflowDataService.prototype.getDraftJSON = function () {
+        return this._draftJSON.asObservable();
+    };
+    WorkflowDataService = tslib_1.__decorate([
+        Injectable()
+    ], WorkflowDataService);
+    return WorkflowDataService;
+}());
+export { WorkflowDataService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/services/workflow-integrator.service.js

@@ -0,0 +1,361 @@
+/**
+ * WorkflowIntegrator
+ * @version 1.0
+ * @releaseDate 2020-05-27
+ * @author Kallico Fróis <kallico.silva@senior.com.br>
+ * @thanks Adriner Andrade <adriner.andrade@senior.com.br>
+ *
+ * @description Módulo desenvolvido para facilitar a integração entre a API do
+ * Senior Workflow e Formulários WEB. A ferramenta foi desenvolvida para
+ * interferir o mínimo possível no formulário, desacoplando seus métodos,
+ * tratando as lógicas dentro da ferramenta, minimizando os impactos no
+ * componente na qual é implementada.
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+var WorkflowIntegrator = /** @class */ (function () {
+    /**
+     * ### WorkflowIntegrator - Integrador de componentes ao Senior Workflow.
+     *
+     * @Description
+     * Instancia a classe do integrador com Senior Workflow.
+     * Ao instanciar a classe automaticamente as Actions são resetadas.
+     *
+     * @Actions
+     * As Actions são ações a serem executadas durante o ciclo de vida do Workflow
+     * Estas podem ser definidas usando os métodos:
+     * `addOnLoadAction()`, `addOnSubmitAction()`, `addOnRollbackAction()`.
+     *
+     *
+     */
+    function WorkflowIntegrator() {
+        this._processVariables = {};
+        this._workflowPayload = {};
+        this.processInstanceId = new BehaviorSubject(null);
+        this.resetActions();
+    }
+    /**
+     * Instancia o workflowCockpit (API de integração)
+     *
+     * @description
+     * Ao executar este método, as `onLoadAtions` serão executadas!
+     * Se houverem ações para executar logo após o carregamento do formulário no
+     * Senior Workflow as **ações devem ser adicionadas anteriormente** à
+     * chamada dessa função, através do método `addOnLoadAction()`.
+     *
+     */
+    WorkflowIntegrator.prototype.init = function () {
+        var _this = this;
+        this.workflowCockpit = workflowCockpit({
+            init: function (data, info) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, _b, processVariablesFromWorkflow;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            this._isRequestNew = info && info.isRequestNew();
+                            _a = this;
+                            _b = info;
+                            if (!_b) return [3 /*break*/, 2];
+                            return [4 /*yield*/, info.getTaskData()];
+                        case 1:
+                            _b = (_c.sent());
+                            _c.label = 2;
+                        case 2:
+                            _a._taskData = _b;
+                            if (!!this._isRequestNew) return [3 /*break*/, 4];
+                            return [4 /*yield*/, info.getInfoFromProcessVariables()];
+                        case 3:
+                            processVariablesFromWorkflow = _c.sent();
+                            this.addProcessVariable("processVariablesFromWorkflow", processVariablesFromWorkflow);
+                            _c.label = 4;
+                        case 4:
+                            this.processInstanceId.next(data.processInstanceId);
+                            return [4 /*yield*/, this._onLoadWorkflow(data, info)];
+                        case 5: return [2 /*return*/, _c.sent()];
+                    }
+                });
+            }); },
+            onSubmit: function (data, info) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _a = this;
+                            _b = data;
+                            if (!_b) return [3 /*break*/, 2];
+                            return [4 /*yield*/, data.nextAction];
+                        case 1:
+                            _b = (_c.sent());
+                            _c.label = 2;
+                        case 2:
+                            _a._nextAction = _b;
+                            this._isFinishing = this._nextAction.finish;
+                            this._nextActionName = this._nextAction.name;
+                            return [4 /*yield*/, this._onSubmitWorkflow(data, info)];
+                        case 3:
+                            _c.sent();
+                            return [2 /*return*/, this._workflowPayload];
+                    }
+                });
+            }); },
+            onError: function (data, info) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this._onRollbackWorkflow(data, info)];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); },
+        });
+    };
+    /** # Workflow LOAD Section # **/
+    /**
+     * Método chamado no carregamento do formulário no Senior Workflow.
+     *
+     ** @important
+     * Deve finalizar chamando o método `_runActions(this.onSbumitActions)`.
+     */
+    WorkflowIntegrator.prototype._onLoadWorkflow = function (data, info) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runActions(this.onLoadActions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /** # Workflow SUBMIT Section # **/
+    /**
+     * Método chamado ao clicar no botão `Enviar` do Senior Workflow.
+     *
+     * @important
+     * Deve iniciar chamando o método `_runActions(this.onSbumitActions)`.
+     */
+    WorkflowIntegrator.prototype._onSubmitWorkflow = function (data, info) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runActions(this.onSubmitActions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /** # Workflow ROLLBACK Section # **/
+    /**
+     * Método chamado ao ocorrer um erro no processamento do formulário por
+     * parte do Senior Workflow
+     *
+     * * @important
+     * Deve iniciar chamando o método `_runActions(this.onRollbackActions)`.
+     */
+    WorkflowIntegrator.prototype._onRollbackWorkflow = function (data, info) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runActions(this.onRollbackActions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /** # ACTIONS Section # **/
+    /**
+     * Reseta os objetos com as Ações a serem efetuadas no ciclo de vida do
+     * Senior Workflow.
+     */
+    WorkflowIntegrator.prototype.resetActions = function () {
+        this.onLoadActions = {};
+        this.onSubmitActions = {};
+        this.onRollbackActions = {};
+    };
+    /**
+     * Executa as ações do objeto passado nos argumentos
+     *
+     * @param actionsToRun Objeto onde que deve conter uma chave
+     * identificadora e um valor com um *método* ou *promise* a ser executada/
+     * resolvida
+     */
+    WorkflowIntegrator.prototype._runActions = function (actionsToRun) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = {};
+                        return [4 /*yield*/, Promise.all(Object.entries(actionsToRun).map(function (_a) {
+                                var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
+                                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var _c, _d, err_1;
+                                    return tslib_1.__generator(this, function (_e) {
+                                        switch (_e.label) {
+                                            case 0:
+                                                _e.trys.push([0, 2, , 3]);
+                                                _c = result;
+                                                _d = key;
+                                                return [4 /*yield*/, value()];
+                                            case 1:
+                                                _c[_d] = _e.sent();
+                                                return [2 /*return*/];
+                                            case 2:
+                                                err_1 = _e.sent();
+                                                throw Error(err_1);
+                                            case 3: return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /** # Actions SETTERs # */
+    /**
+     * Adiciona um ação à pilha para execução no momento do carregamento do
+     * formulário no Senior Workflow;
+     *
+     * @important
+     * As Ações de carregamento **devem ser adicionadas antes da chamada do
+     * método** `init()`!
+     *
+     * @param id Nome identificador para a callback a ser executada;
+     * @param callback Função a ser executada;
+     */
+    WorkflowIntegrator.prototype.addOnLoadAction = function (id, callback) {
+        this.onLoadActions[id] = callback;
+    };
+    /**
+     * Adiciona um ação à pilha para execução no momento do envio do formulário
+     * para o Senior Workflow
+     *
+     * @param id Nome identificador para a callback a ser executada;
+     * @param callback Função a ser executada;
+     */
+    WorkflowIntegrator.prototype.addOnSubmitAction = function (id, callback) {
+        this.onSubmitActions[id] = callback;
+    };
+    /**
+     * Adiciona um ação à pilha para execução em caso de haver um erro no
+     * processamento do formulário por parte do Senior Workflow.
+     *
+     * @param id Nome identificador para a callback a ser executada;
+     * @param callback Função a ser executada;
+     */
+    WorkflowIntegrator.prototype.addOnRollbackAction = function (id, callback) {
+        this.onRollbackActions[id] = callback;
+    };
+    /**
+     * Adiciona um objeto às Variáveis do Processo (`_processVariables`)
+     *
+     * @param id Nome identificador do objeto a ser adicionado
+     * @param processVariable Objeto a ser adicionado as variáveis do processo
+     */
+    WorkflowIntegrator.prototype.addProcessVariable = function (id, processVariable) {
+        try {
+            this._processVariables[id] = processVariable;
+        }
+        catch (err) {
+            var error = {
+                erro: err,
+                message: "N\u00E3o foi poss\u00EDvel adicionar a vari\u00E1vel " + id + " \u00E0s vari\u00E1veis do processo.",
+            };
+            throw error;
+        }
+    };
+    /**
+     * Define o objecto payload que será enviado ao Senior Worfkflow quando o usuário
+     * clicar no botão enviar.
+     *
+     * @param payload Objeto a ser enviado para o Workflow
+     */
+    WorkflowIntegrator.prototype.setWorkflowPayload = function (payload) {
+        this._workflowPayload = payload;
+        return;
+    };
+    Object.defineProperty(WorkflowIntegrator.prototype, "loadActions", {
+        /** # Actions GETTERs # */
+        get: function () {
+            return this.onLoadActions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "submitActions", {
+        get: function () {
+            return this.onSubmitActions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "rollbackActions", {
+        get: function () {
+            return this.onRollbackActions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "isRequestNew", {
+        /** # GETTERs # **/
+        get: function () {
+            return this._isRequestNew;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "isFinishing", {
+        get: function () {
+            return this._isFinishing;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "nextActionName", {
+        get: function () {
+            return this._nextActionName;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "taskData", {
+        get: function () {
+            return this._taskData;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowIntegrator.prototype, "processVariables", {
+        get: function () {
+            var _this = this;
+            var p = new Promise(function (resolve, reject) {
+                if (_this._processVariables) {
+                    resolve(_this._processVariables);
+                }
+                else {
+                    reject("Não foram encontradas variáveis para o processo");
+                }
+            });
+            p.then(function (data) {
+                _this._processVariables = data;
+            }).catch(function (err) {
+                throw err;
+            });
+            return this._processVariables;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    WorkflowIntegrator = tslib_1.__decorate([
+        Injectable()
+    ], WorkflowIntegrator);
+    return WorkflowIntegrator;
+}());
+export { WorkflowIntegrator };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-integrator.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["services/workflow-integrator.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WorkflowIntegrator\n * @version 1.0\n * @releaseDate 2020-05-27\n * @author Kallico Fróis <kallico.silva@senior.com.br>\n * @thanks Adriner Andrade <adriner.andrade@senior.com.br>\n *\n * @description Módulo desenvolvido para facilitar a integração entre a API do\n * Senior Workflow e Formulários WEB. A ferramenta foi desenvolvida para\n * interferir o mínimo possível no formulário, desacoplando seus métodos,\n * tratando as lógicas dentro da ferramenta, minimizando os impactos no\n * componente na qual é implementada.\n */\n\nimport { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\ndeclare const workflowCockpit: any;\n\nexport interface TaskData {\n    processName: string;\n    taskName: string;\n}\n\nexport interface NextAction {\n    connectsWithAutomaticGateway: boolean; // Se a ação está associada a algum elemento de decisão automática.\n    finish: boolean; // Se a ação finaliza a execução do processo.\n    name: string; // Nome da ação a ser realizada.\n}\n\n@Injectable()\nexport class WorkflowIntegrator {\n    private workflowCockpit: any;\n    private _isRequestNew: boolean;\n    private _nextAction: NextAction;\n    private _nextActionName: string;\n    private _taskData: TaskData;\n    private _isFinishing: any;\n    private _processVariables: object = {};\n    private _workflowPayload: object = {};\n\n    private onLoadActions: object;\n    private onSubmitActions: object;\n    private onRollbackActions: object;\n    public processInstanceId: BehaviorSubject<number> = new BehaviorSubject(null);\n\n    /**\n     * ### WorkflowIntegrator - Integrador de componentes ao Senior Workflow.\n     *\n     * @Description\n     * Instancia a classe do integrador com Senior Workflow.\n     * Ao instanciar a classe automaticamente as Actions são resetadas.\n     *\n     * @Actions\n     * As Actions são ações a serem executadas durante o ciclo de vida do Workflow\n     * Estas podem ser definidas usando os métodos:\n     * `addOnLoadAction()`, `addOnSubmitAction()`, `addOnRollbackAction()`.\n     *\n     *\n     */\n    constructor() {\n        this.resetActions();\n    }\n\n    /**\n     * Instancia o workflowCockpit (API de integração)\n     *\n     * @description\n     * Ao executar este método, as `onLoadAtions` serão executadas!\n     * Se houverem ações para executar logo após o carregamento do formulário no\n     * Senior Workflow as **ações devem ser adicionadas anteriormente** à\n     * chamada dessa função, através do método `addOnLoadAction()`.\n     *\n     */\n    public init(): void {\n        this.workflowCockpit = workflowCockpit({\n            init: async (data: any, info: any): Promise<any> => {\n                this._isRequestNew = info && info.isRequestNew();\n                this._taskData = info && (await info.getTaskData());\n\n                if (!this._isRequestNew) {\n                    const processVariablesFromWorkflow = await info.getInfoFromProcessVariables();\n\n                    this.addProcessVariable(\n                        \"processVariablesFromWorkflow\",\n                        processVariablesFromWorkflow\n                    );\n                }\n\n                this.processInstanceId.next(data.processInstanceId);\n\n                return await this._onLoadWorkflow(data, info);\n            },\n            onSubmit: async (data: any, info: any): Promise<object> => {\n                this._nextAction = data && (await data.nextAction);\n                this._isFinishing = this._nextAction.finish;\n                this._nextActionName = this._nextAction.name;\n\n\n                await this._onSubmitWorkflow(data, info);\n\n                return this._workflowPayload;\n            },\n            onError: async (data: any, info: any): Promise<any> => {\n                await this._onRollbackWorkflow(data, info);\n            },\n        });\n    }\n\n    /** # Workflow LOAD Section # **/\n\n    /**\n     * Método chamado no carregamento do formulário no Senior Workflow.\n     *\n     ** @important\n     * Deve finalizar chamando o método `_runActions(this.onSbumitActions)`.\n     */\n    private async _onLoadWorkflow(data: any, info: any): Promise<any> {\n        return await this._runActions(this.onLoadActions);\n    }\n\n    /** # Workflow SUBMIT Section # **/\n\n    /**\n     * Método chamado ao clicar no botão `Enviar` do Senior Workflow.\n     *\n     * @important\n     * Deve iniciar chamando o método `_runActions(this.onSbumitActions)`.\n     */\n    private async _onSubmitWorkflow(data: any, info: any): Promise<any> {\n        return await this._runActions(this.onSubmitActions);\n    }\n\n    /** # Workflow ROLLBACK Section # **/\n\n    /**\n     * Método chamado ao ocorrer um erro no processamento do formulário por\n     * parte do Senior Workflow\n     *\n     * * @important\n     * Deve iniciar chamando o método `_runActions(this.onRollbackActions)`.\n     */\n    private async _onRollbackWorkflow(data: any, info: any): Promise<any> {\n        return await this._runActions(this.onRollbackActions);\n    }\n\n    /** # ACTIONS Section # **/\n\n    /**\n     * Reseta os objetos com as Ações a serem efetuadas no ciclo de vida do\n     * Senior Workflow.\n     */\n    public resetActions(): void {\n        this.onLoadActions = {};\n        this.onSubmitActions = {};\n        this.onRollbackActions = {};\n    }\n\n    /**\n     * Executa as ações do objeto passado nos argumentos\n     *\n     * @param actionsToRun Objeto onde que deve conter uma chave\n     * identificadora e um valor com um *método* ou *promise* a ser executada/\n     * resolvida\n     */\n    private async _runActions(actionsToRun: object): Promise<any> {\n        const result: object = {};\n\n        await Promise.all(\n            Object.entries(actionsToRun).map(async ([key, value]) => {\n                try {\n                    result[key] = await value();\n                    return;\n                } catch (err) {\n                    throw Error(err);\n                }\n            })\n        );\n\n        return result;\n    }\n\n    /** # Actions SETTERs # */\n\n    /**\n     * Adiciona um ação à pilha para execução no momento do carregamento do\n     * formulário no Senior Workflow;\n     *\n     * @important\n     * As Ações de carregamento **devem ser adicionadas antes da chamada do\n     * método** `init()`!\n     *\n     * @param id Nome identificador para a callback a ser executada;\n     * @param callback Função a ser executada;\n     */\n    public addOnLoadAction(id: string, callback: any) {\n        this.onLoadActions[id] = callback;\n    }\n\n    /**\n     * Adiciona um ação à pilha para execução no momento do envio do formulário\n     * para o Senior Workflow\n     *\n     * @param id Nome identificador para a callback a ser executada;\n     * @param callback Função a ser executada;\n     */\n    public addOnSubmitAction(id: string, callback: any) {\n        this.onSubmitActions[id] = callback;\n    }\n\n    /**\n     * Adiciona um ação à pilha para execução em caso de haver um erro no\n     * processamento do formulário por parte do Senior Workflow.\n     *\n     * @param id Nome identificador para a callback a ser executada;\n     * @param callback Função a ser executada;\n     */\n    public addOnRollbackAction(id: string, callback: any) {\n        this.onRollbackActions[id] = callback;\n    }\n\n    /**\n     * Adiciona um objeto às Variáveis do Processo (`_processVariables`)\n     *\n     * @param id Nome identificador do objeto a ser adicionado\n     * @param processVariable Objeto a ser adicionado as variáveis do processo\n     */\n    public addProcessVariable(id: string, processVariable: any): void {\n        try {\n            this._processVariables[id] = processVariable;\n        } catch (err) {\n            const error = {\n                erro: err,\n                message: `Não foi possível adicionar a variável ${id} às variáveis do processo.`,\n            };\n            throw error;\n        }\n    }\n\n    /**\n     * Define o objecto payload que será enviado ao Senior Worfkflow quando o usuário\n     * clicar no botão enviar.\n     *\n     * @param payload Objeto a ser enviado para o Workflow\n     */\n    public setWorkflowPayload(payload: object): void {\n\n        this._workflowPayload = payload;\n\n        return;\n    }\n\n    /** # Actions GETTERs # */\n\n    public get loadActions(): object {\n        return this.onLoadActions;\n    }\n\n    public get submitActions(): object {\n        return this.onSubmitActions;\n    }\n\n    public get rollbackActions(): object {\n        return this.onRollbackActions;\n    }\n\n    /** # GETTERs # **/\n\n    public get isRequestNew(): boolean {\n        return this._isRequestNew;\n    }\n\n    public get isFinishing(): boolean {\n        return this._isFinishing;\n    }\n\n    public get nextActionName(): string {\n        return this._nextActionName;\n    }\n\n    public get taskData(): TaskData {\n        return this._taskData;\n    }\n\n    public get processVariables(): any {\n        const p = new Promise((resolve, reject) => {\n            if (this._processVariables) {\n                resolve(this._processVariables);\n            } else {\n                reject(\"Não foram encontradas variáveis para o processo\");\n            }\n        });\n\n        p.then((data: any) => {\n            this._processVariables = data;\n        }).catch((err: any) => {\n            throw err;\n        });\n\n        return this._processVariables;\n    }\n}\n"]}