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

package/esm5/components/historical-bank-account-list/historical-bank-account-list.component.js

@@ -0,0 +1,243 @@
+import * as tslib_1 from "tslib";
+import { Component, OnInit, ViewChild, ChangeDetectorRef, AfterViewInit, OnDestroy, Input, Output, EventEmitter, } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+import { TranslateService } from "@ngx-translate/core";
+import { CustomFieldsComponent } from "@seniorsistemas/angular-components";
+import * as moment_ from "moment";
+import { ConfirmationService, MessageService } from "primeng/api";
+import { ServiceType } from '../../core/enums/serviceType';
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+import { HistoricalBankAccountListService } from "./historical-bank-account-list.service";
+var moment = moment_;
+var HistoricalBankAccountListComponent = /** @class */ (function () {
+    function HistoricalBankAccountListComponent(confirmationService, translateService, activatedRoute, cd, router, messageService, historicalBankAccountListService) {
+        this.confirmationService = confirmationService;
+        this.translateService = translateService;
+        this.activatedRoute = activatedRoute;
+        this.cd = cd;
+        this.router = router;
+        this.messageService = messageService;
+        this.historicalBankAccountListService = historicalBankAccountListService;
+        this.endPoint = "hcm/payroll/queries/historicalEmployeeBankAccountQuery";
+        this.keyPayload = "historicalEmployeeBankAccount";
+        this.withSidebar = true;
+        this.enableView = new EventEmitter();
+        this.ngUnsubscribe = new Subject();
+        this.loading = true;
+        this.columns = [
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_date_when"),
+                field: "dateWhen",
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_bank"),
+                field: "bank.name",
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_bank_branch"),
+                field: "bankBranch.name",
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_account"),
+                field: "bankAccount",
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_percentage"),
+                field: "percentage",
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.historical_bank_account_label_qtd_account"),
+                field: "numberOfBankAccount",
+            },
+        ];
+    }
+    HistoricalBankAccountListComponent.prototype.ngOnInit = function () {
+        this.initParameters = { employeeId: this.employeeId, dependentId: this.dependentId };
+    };
+    HistoricalBankAccountListComponent.prototype.ngOnDestroy = function () {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    };
+    HistoricalBankAccountListComponent.prototype.ngAfterViewInit = function () {
+        this.cd.detectChanges();
+    };
+    HistoricalBankAccountListComponent.prototype.onLazyLoad = function (payload) {
+        var _this = this;
+        payload.forEach(function (value) {
+            value.dateWhen = moment(value.dateWhen).format(_this.dateFormat);
+        });
+        this.onGridLoad(payload);
+        this.loading = false;
+    };
+    HistoricalBankAccountListComponent.prototype.getMenuActions = function (rowData) {
+        var _this = this;
+        return [
+            {
+                label: this.translateService.instant("hcm.payroll.employees_image_cropper_view"),
+                command: function () {
+                    var dateWhen = rowData && rowData.dateWhen && moment(rowData.dateWhen, _this.dateFormat).format("YYYY-MM-DD");
+                    if (_this.withSidebar)
+                        _this.router.navigate(["historical-bank-account/" + dateWhen], {
+                            relativeTo: _this.activatedRoute,
+                        });
+                    else
+                        _this.enableView.emit(dateWhen);
+                },
+            },
+            {
+                label: this.translateService.instant("hcm.payroll.delete"),
+                command: function () {
+                    if (_this.isAllowToDeleteHistorical && rowData) {
+                        _this.delete(rowData.id, rowData.dateWhen);
+                    }
+                    else {
+                        _this.messageService.add({
+                            severity: "error",
+                            summary: _this.translateService.instant("hcm.payroll.error"),
+                            detail: _this.translateService.instant("hcm.payroll.permission_error_not_allowed"),
+                        });
+                    }
+                },
+            },
+        ];
+    };
+    HistoricalBankAccountListComponent.prototype.delete = function (id, dateWhen) {
+        var _this = this;
+        if (id === this.lastRecord.id) {
+            var dateWhenToDto_1 = moment(dateWhen, this.dateFormat).format("YYYY-MM-DD");
+            this.confirmationService.confirm({
+                message: this.translateService.instant("hcm.payroll.employees_movimentation_historical_bank_account_question_confirm_delete") + "?",
+                accept: function () {
+                    _this.loading = true;
+                    var service = _this.withSidebar ? ServiceType.PAYROLL : ServiceType.DEPENDENT;
+                    _this.historicalBankAccountListService
+                        .remove(_this.employeeId, dateWhenToDto_1, service, _this.dependentId)
+                        .pipe(takeUntil(_this.ngUnsubscribe))
+                        .subscribe(function () {
+                        _this.messageService.add({
+                            severity: "success",
+                            summary: _this.translateService.instant("hcm.payroll.success"),
+                            detail: _this.translateService.instant("hcm.payroll.employees_movimentation_historical_bank_account_remove"),
+                        });
+                        _this.parameters = (_this.parameters && tslib_1.__assign({}, _this.parameters)) || {};
+                    }, function () {
+                        _this.messageService.add({
+                            severity: "error",
+                            summary: _this.translateService.instant("hcm.payroll.error"),
+                            detail: _this.translateService.instant("hcm.payroll.employees_movimentation_historical_bank_account_error_remove"),
+                        });
+                        _this.loading = false;
+                    });
+                },
+            });
+        }
+        else {
+            this.messageService.add({
+                severity: "error",
+                summary: this.translateService.instant("hcm.payroll.error"),
+                detail: this.translateService.instant("hcm.payroll.not_allowed_delete_last"),
+            });
+        }
+    };
+    HistoricalBankAccountListComponent.prototype.add = function () {
+        if (this.isAllowToAddHistorical) {
+            this.router.navigate(["historical-irrf-new"], {
+                relativeTo: this.activatedRoute,
+            });
+        }
+        else {
+            this.messageService.add({
+                severity: "error",
+                summary: this.translateService.instant("hcm.payroll.error"),
+                detail: this.translateService.instant("hcm.payroll.permission_error_not_allowed"),
+            });
+        }
+    };
+    HistoricalBankAccountListComponent.prototype.onGridLoad = function (payload) {
+        if (payload && payload.length) {
+            this.lastRecord = payload[0];
+        }
+    };
+    Object.defineProperty(HistoricalBankAccountListComponent.prototype, "isAllowToAddHistorical", {
+        get: function () {
+            return (this.permission["incluir"]);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HistoricalBankAccountListComponent.prototype, "isAllowToDeleteHistorical", {
+        get: function () {
+            return (this.permission["excluir"]);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HistoricalBankAccountListComponent.prototype, "scopedActions", {
+        get: function () {
+            return this.getMenuActions.bind(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HistoricalBankAccountListComponent.prototype, "reloadList", {
+        set: function (condition) {
+            if (condition) {
+                this.loading = true;
+                this.parameters = (this.parameters && tslib_1.__assign({}, this.parameters)) || {};
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    HistoricalBankAccountListComponent.ctorParameters = function () { return [
+        { type: ConfirmationService },
+        { type: TranslateService },
+        { type: ActivatedRoute },
+        { type: ChangeDetectorRef },
+        { type: Router },
+        { type: MessageService },
+        { type: HistoricalBankAccountListService }
+    ]; };
+    tslib_1.__decorate([
+        ViewChild(CustomFieldsComponent, { static: false })
+    ], HistoricalBankAccountListComponent.prototype, "customFields", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "permission", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "employeeId", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "dependentId", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "dateFormat", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "endPoint", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "keyPayload", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "withSidebar", void 0);
+    tslib_1.__decorate([
+        Output()
+    ], HistoricalBankAccountListComponent.prototype, "enableView", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], HistoricalBankAccountListComponent.prototype, "reloadList", null);
+    HistoricalBankAccountListComponent = tslib_1.__decorate([
+        Component({
+            // tslint:disable-next-line:component-selector
+            selector: "c-historical-bank-account-list",
+            template: "<div class=\"ui-g\">\n    <div class=\"ui-g-12\">\n        <c-data-list-rest\n            id=\"ta-irrf\"\n            [columns]=\"columns\"\n            actionLabel=\"{{ 'hcm.payroll.movimentation_generic_action' | translate }}\"\n            emptyMessage=\"{{ 'hcm.payroll.admission_empty_message' | translate }}\"\n            [endpoint]=\"endPoint\"\n            singularMessageRecords=\"{{\n                    'hcm.payroll.admission_register' | translate\n                }}\"\n            [actions]=\"scopedActions\"\n            pluralMessageRecords=\"{{\n                    'hcm.payroll.admission_registers' | translate\n                }}\"\n            [keyPayload]=\"keyPayload\"\n            [lazy]=\"true\"\n            (lazyLoad)=\"onLazyLoad($event)\"\n            [(loading)]=\"loading\"\n            [initParameters]=\"initParameters\"\n            [parameters]=\"parameters\"\n            [isSortable]=\"false\"\n        ></c-data-list-rest>\n    </div>\n</div>\n\n",
+            styles: [""]
+        })
+    ], HistoricalBankAccountListComponent);
+    return HistoricalBankAccountListComponent;
+}());
+export { HistoricalBankAccountListComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"historical-bank-account-list.component.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/historical-bank-account-list/historical-bank-account-list.component.ts"],"names":[],"mappings":";AAAA,OAAO,EACH,SAAS,EACT,MAAM,EACN,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAE1F,IAAM,MAAM,GAAG,OAAO,CAAC;AAQvB;IAoEI,4CACY,mBAAwC,EACxC,gBAAkC,EAClC,cAA8B,EAC9B,EAAqB,EACrB,MAAc,EACd,cAA8B,EAC9B,gCAAkE;QANlE,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,OAAE,GAAF,EAAE,CAAmB;QACrB,WAAM,GAAN,MAAM,CAAQ;QACd,mBAAc,GAAd,cAAc,CAAgB;QAC9B,qCAAgC,GAAhC,gCAAgC,CAAkC;QA9DvE,aAAQ,GAAW,wDAAwD,CAAC;QAE5E,eAAU,GAAW,+BAA+B,CAAC;QAErD,gBAAW,GAAY,IAAI,CAAC;QAI5B,eAAU,GAAsB,IAAI,YAAY,EAAO,CAAC;QAGvD,kBAAa,GAAG,IAAI,OAAO,EAAE,CAAC;QAE/B,YAAO,GAAY,IAAI,CAAC;QAGxB,YAAO,GAAG;YACb;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,qDAAqD,CACxD;gBACD,KAAK,EAAE,UAAU;aACpB;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,gDAAgD,CACnD;gBACD,KAAK,EAAE,WAAW;aACrB;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,uDAAuD,CAC1D;gBACD,KAAK,EAAE,iBAAiB;aAC3B;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,mDAAmD,CACtD;gBACD,KAAK,EAAE,aAAa;aACvB;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,sDAAsD,CACzD;gBACD,KAAK,EAAE,YAAY;aACtB;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAChC,uDAAuD,CAC1D;gBACD,KAAK,EAAE,qBAAqB;aAC/B;SACJ,CAAC;IAWF,CAAC;IAED,qDAAQ,GAAR;QACI,IAAI,CAAC,cAAc,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC;IACzF,CAAC;IAGD,wDAAW,GAAX;QACI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAED,4DAAe,GAAf;QACI,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC;IAC5B,CAAC;IAEM,uDAAU,GAAjB,UAAkB,OAAY;QAA9B,iBAQC;QAPG,OAAO,CAAC,OAAO,CAAC,UAAC,KAAU;YACvB,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAI,CAAC,UAAU,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAEzB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACzB,CAAC;IAEM,2DAAc,GAArB,UAAsB,OAAY;QAAlC,iBA6BC;QA5BG,OAAO;YACH;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,0CAA0C,CAAC;gBAChF,OAAO,EAAE;oBACL,IAAM,QAAQ,GAAG,OAAO,IAAI,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;oBAC/G,IAAI,KAAI,CAAC,WAAW;wBAChB,KAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,6BAA4B,QAAW,CAAC,EAAE;4BAC5D,UAAU,EAAE,KAAI,CAAC,cAAc;yBAClC,CAAC,CAAC;;wBAEH,KAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACvC,CAAC;aACJ;YACD;gBACI,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,oBAAoB,CAAC;gBAC1D,OAAO,EAAE;oBACL,IAAI,KAAI,CAAC,yBAAyB,IAAI,OAAO,EAAE;wBAC3C,KAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;qBAC7C;yBAAM;wBACH,KAAI,CAAC,cAAc,CAAC,GAAG,CAAC;4BACpB,QAAQ,EAAE,OAAO;4BACjB,OAAO,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,mBAAmB,CAAC;4BAC3D,MAAM,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,0CAA0C,CAAC;yBACpF,CAAC,CAAC;qBACN;gBACL,CAAC;aACJ;SACJ,CAAC;IACN,CAAC;IAEM,mDAAM,GAAb,UAAc,EAAO,EAAE,QAAgB;QAAvC,iBAwCC;QAvCG,IAAI,EAAE,KAAK,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE;YAC3B,IAAM,eAAa,GAAG,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC7E,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;gBAC7B,OAAO,EAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CACtC,qFAAqF,CACxF,MAAI;gBACL,MAAM,EAAE;oBACJ,KAAI,CAAC,OAAO,GAAG,IAAI,CAAC;oBACpB,IAAM,OAAO,GAAG,KAAI,CAAC,WAAW,CAAC,CAAC,CAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC;oBAChF,KAAI,CAAC,gCAAgC;yBAChC,MAAM,CAAC,KAAI,CAAC,UAAU,EAAE,eAAa,EAAE,OAAO,EAAE,KAAI,CAAC,WAAW,CAAC;yBACjE,IAAI,CAAC,SAAS,CAAC,KAAI,CAAC,aAAa,CAAC,CAAC;yBACnC,SAAS,CACN;wBACI,KAAI,CAAC,cAAc,CAAC,GAAG,CAAC;4BACpB,QAAQ,EAAE,SAAS;4BACnB,OAAO,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,qBAAqB,CAAC;4BAC7D,MAAM,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,oEAAoE,CAAC;yBAC9G,CAAC,CAAC;wBACH,KAAI,CAAC,UAAU,GAAG,CAAC,KAAI,CAAC,UAAU,yBAAS,KAAI,CAAC,UAAU,CAAE,CAAC,IAAI,EAAE,CAAC;oBACxE,CAAC,EACD;wBACI,KAAI,CAAC,cAAc,CAAC,GAAG,CAAC;4BACpB,QAAQ,EAAE,OAAO;4BACjB,OAAO,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,mBAAmB,CAAC;4BAC3D,MAAM,EAAE,KAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,0EAA0E,CAAC;yBACpH,CAAC,CAAC;wBACH,KAAI,CAAC,OAAO,GAAG,KAAK,CAAC;oBACzB,CAAC,CACJ,CAAC;gBACV,CAAC;aACJ,CAAC,CAAC;SACN;aAAM;YACH,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACpB,QAAQ,EAAE,OAAO;gBACjB,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,mBAAmB,CAAC;gBAC3D,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,qCAAqC,CAAC;aAC/E,CAAC,CAAC;SACN;IACL,CAAC;IAEM,gDAAG,GAAV;QACI,IAAI,IAAI,CAAC,sBAAsB,EAAE;YAC7B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,qBAAqB,CAAC,EAAE;gBAC1C,UAAU,EAAE,IAAI,CAAC,cAAc;aAClC,CAAC,CAAC;SACN;aAAM;YACH,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACpB,QAAQ,EAAE,OAAO;gBACjB,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,mBAAmB,CAAC;gBAC3D,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,0CAA0C,CAAC;aACpF,CAAC,CAAC;SACN;IACL,CAAC;IAEO,uDAAU,GAAlB,UAAmB,OAAY;QAC3B,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE;YAC3B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;SAChC;IACL,CAAC;IAED,sBAAY,sEAAsB;aAAlC;YACI,OAAO,CACH,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAC7B,CAAC;QACN,CAAC;;;OAAA;IAED,sBAAY,yEAAyB;aAArC;YACI,OAAO,CACH,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAC7B,CAAC;QACN,CAAC;;;OAAA;IAED,sBAAW,6DAAa;aAAxB;YACI,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;;;OAAA;IAGD,sBAAW,0DAAU;aAArB,UAAsB,SAAkB;YACpC,IAAI,SAAS,EAAE;gBACX,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;gBACpB,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,UAAU,yBAAS,IAAI,CAAC,UAAU,CAAE,CAAC,IAAI,EAAE,CAAC;aACvE;QACL,CAAC;;;OAAA;;gBArJgC,mBAAmB;gBACtB,gBAAgB;gBAClB,cAAc;gBAC1B,iBAAiB;gBACb,MAAM;gBACE,cAAc;gBACI,gCAAgC;;IAzE9E;QADC,SAAS,CAAC,qBAAqB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;4EACT;IAG3C;QADC,KAAK,EAAE;0EACkB;IAE1B;QADC,KAAK,EAAE;0EACkB;IAE1B;QADC,KAAK,EAAE;2EACmB;IAE3B;QADC,KAAK,EAAE;0EACkB;IAE1B;QADC,KAAK,EAAE;wEAC2E;IAEnF;QADC,KAAK,EAAE;0EACoD;IAE5D;QADC,KAAK,EAAE;2EAC2B;IAInC;QADC,MAAM,EAAE;0EACsD;IAgM/D;QADC,KAAK,EAAE;wEAMP;IA1NQ,kCAAkC;QAN9C,SAAS,CAAC;YACP,8CAA8C;YAC9C,QAAQ,EAAE,gCAAgC;YAC1C,o+BAA4D;;SAE/D,CAAC;OACW,kCAAkC,CA4N9C;IAAD,yCAAC;CAAA,AA5ND,IA4NC;SA5NY,kCAAkC","sourcesContent":["import {\n    Component,\n    OnInit,\n    ViewChild,\n    ChangeDetectorRef,\n    AfterViewInit,\n    OnDestroy,\n    Input,\n    Output,\n    EventEmitter,\n} from \"@angular/core\";\nimport { ActivatedRoute, Router } from \"@angular/router\";\nimport { TranslateService } from \"@ngx-translate/core\";\nimport { CustomFieldsComponent } from \"@seniorsistemas/angular-components\";\nimport * as moment_ from \"moment\";\nimport { ConfirmationService, MessageService } from \"primeng/api\";\nimport { ServiceType } from '../../core/enums/serviceType';\nimport { Subject } from \"rxjs\";\nimport { takeUntil } from \"rxjs/operators\";\nimport { HistoricalBankAccountListService } from \"./historical-bank-account-list.service\";\n\nconst moment = moment_;\n\n@Component({\n    // tslint:disable-next-line:component-selector\n    selector: \"c-historical-bank-account-list\",\n    templateUrl: \"./historical-bank-account-list.component.html\",\n    styleUrls: [\"./historical-bank-account-list.component.scss\"],\n})\nexport class HistoricalBankAccountListComponent implements OnInit, OnDestroy, AfterViewInit {\n    @ViewChild(CustomFieldsComponent, { static: false })\n    public customFields: CustomFieldsComponent;\n\n    @Input()\n    public permission: object;\n    @Input()\n    public employeeId: string;\n    @Input()\n    public dependentId: string;\n    @Input()\n    public dateFormat: string;\n    @Input()\n    public endPoint: string = \"hcm/payroll/queries/historicalEmployeeBankAccountQuery\";\n    @Input()\n    public keyPayload: string = \"historicalEmployeeBankAccount\";\n    @Input()\n    public withSidebar: boolean = true;\n\n\n    @Output()\n    public enableView: EventEmitter<any> = new EventEmitter<any>();\n\n    private lastRecord: any;\n    private ngUnsubscribe = new Subject();\n    public initParameters: any;\n    public loading: boolean = true;\n    public parameters: any;\n\n    public columns = [\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_date_when\",\n            ),\n            field: \"dateWhen\",\n        },\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_bank\",\n            ),\n            field: \"bank.name\",\n        },\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_bank_branch\",\n            ),\n            field: \"bankBranch.name\",\n        },\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_account\",\n            ),\n            field: \"bankAccount\",\n        },\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_percentage\",\n            ),\n            field: \"percentage\",\n        },\n        {\n            label: this.translateService.instant(\n                \"hcm.payroll.historical_bank_account_label_qtd_account\",\n            ),\n            field: \"numberOfBankAccount\",\n        },\n    ];\n\n    constructor(\n        private confirmationService: ConfirmationService,\n        private translateService: TranslateService,\n        private activatedRoute: ActivatedRoute,\n        private cd: ChangeDetectorRef,\n        private router: Router,\n        private messageService: MessageService,\n        private historicalBankAccountListService: HistoricalBankAccountListService,\n    ) {\n    }\n\n    ngOnInit() {\n        this.initParameters = { employeeId: this.employeeId, dependentId: this.dependentId };\n    }\n\n\n    ngOnDestroy() {\n        this.ngUnsubscribe.next();\n        this.ngUnsubscribe.complete();\n    }\n\n    ngAfterViewInit() {\n        this.cd.detectChanges();\n    }\n\n    public onLazyLoad(payload: any) {\n        payload.forEach((value: any) => {\n            value.dateWhen = moment(value.dateWhen).format(this.dateFormat);\n        });\n\n        this.onGridLoad(payload);\n\n        this.loading = false;\n    }\n\n    public getMenuActions(rowData: any) {\n        return [\n            {\n                label: this.translateService.instant(\"hcm.payroll.employees_image_cropper_view\"),\n                command: () => {\n                    const dateWhen = rowData && rowData.dateWhen && moment(rowData.dateWhen, this.dateFormat).format(\"YYYY-MM-DD\");\n                    if (this.withSidebar)\n                        this.router.navigate([`historical-bank-account/${ dateWhen }`], {\n                            relativeTo: this.activatedRoute,\n                        });\n                    else\n                        this.enableView.emit(dateWhen);\n                },\n            },\n            {\n                label: this.translateService.instant(\"hcm.payroll.delete\"),\n                command: () => {\n                    if (this.isAllowToDeleteHistorical && rowData) {\n                        this.delete(rowData.id, rowData.dateWhen);\n                    } else {\n                        this.messageService.add({\n                            severity: \"error\",\n                            summary: this.translateService.instant(\"hcm.payroll.error\"),\n                            detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed\"),\n                        });\n                    }\n                },\n            },\n        ];\n    }\n\n    public delete(id: any, dateWhen: string) {\n        if (id === this.lastRecord.id) {\n            const dateWhenToDto = moment(dateWhen, this.dateFormat).format(\"YYYY-MM-DD\");\n            this.confirmationService.confirm({\n                message: `${ this.translateService.instant(\n                    \"hcm.payroll.employees_movimentation_historical_bank_account_question_confirm_delete\",\n                ) }?`,\n                accept: () => {\n                    this.loading = true;\n                    const service = this.withSidebar ?  ServiceType.PAYROLL : ServiceType.DEPENDENT;\n                    this.historicalBankAccountListService\n                        .remove(this.employeeId, dateWhenToDto, service, this.dependentId)\n                        .pipe(takeUntil(this.ngUnsubscribe))\n                        .subscribe(\n                            () => {\n                                this.messageService.add({\n                                    severity: \"success\",\n                                    summary: this.translateService.instant(\"hcm.payroll.success\"),\n                                    detail: this.translateService.instant(\"hcm.payroll.employees_movimentation_historical_bank_account_remove\"),\n                                });\n                                this.parameters = (this.parameters && { ...this.parameters }) || {};\n                            },\n                            () => {\n                                this.messageService.add({\n                                    severity: \"error\",\n                                    summary: this.translateService.instant(\"hcm.payroll.error\"),\n                                    detail: this.translateService.instant(\"hcm.payroll.employees_movimentation_historical_bank_account_error_remove\"),\n                                });\n                                this.loading = false;\n                            },\n                        );\n                },\n            });\n        } else {\n            this.messageService.add({\n                severity: \"error\",\n                summary: this.translateService.instant(\"hcm.payroll.error\"),\n                detail: this.translateService.instant(\"hcm.payroll.not_allowed_delete_last\"),\n            });\n        }\n    }\n\n    public add() {\n        if (this.isAllowToAddHistorical) {\n            this.router.navigate([\"historical-irrf-new\"], {\n                relativeTo: this.activatedRoute,\n            });\n        } else {\n            this.messageService.add({\n                severity: \"error\",\n                summary: this.translateService.instant(\"hcm.payroll.error\"),\n                detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed\"),\n            });\n        }\n    }\n\n    private onGridLoad(payload: any) {\n        if (payload && payload.length) {\n            this.lastRecord = payload[0];\n        }\n    }\n\n    private get isAllowToAddHistorical() {\n        return (\n            this.permission[\"incluir\"]\n        );\n    }\n\n    private get isAllowToDeleteHistorical() {\n        return (\n            this.permission[\"excluir\"]\n        );\n    }\n\n    public get scopedActions() {\n        return this.getMenuActions.bind(this);\n    }\n\n    @Input()\n    public set reloadList(condition: boolean) {\n        if (condition) {\n            this.loading = true;\n            this.parameters = (this.parameters && { ...this.parameters }) || {};\n        }\n    }\n\n}\n"]}

package/esm5/components/historical-bank-account-list/historical-bank-account-list.module.js

@@ -0,0 +1,42 @@
+import * as tslib_1 from "tslib";
+import { CommonModule } from "@angular/common";
+import { HttpClientModule } from "@angular/common/http";
+import { NgModule } from "@angular/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { ButtonModule, LoadingStateModule } from "@seniorsistemas/angular-components";
+import { AutoCompleteModule } from "primeng/autocomplete";
+import { ConfirmDialogModule } from "primeng/confirmdialog";
+import { TableModule } from "primeng/table";
+import { TooltipModule } from "primeng/tooltip";
+import { DataListRestModule } from "../data-list-rest/index";
+import { SharedModule } from "../shared/shared.module";
+import { HistoricalBankAccountListComponent } from "./historical-bank-account-list.component";
+import { HistoricalBankAccountListService } from "./historical-bank-account-list.service";
+var HistoricalBankAccountListModule = /** @class */ (function () {
+    function HistoricalBankAccountListModule() {
+    }
+    HistoricalBankAccountListModule = tslib_1.__decorate([
+        NgModule({
+            imports: [
+                CommonModule,
+                FormsModule,
+                HttpClientModule,
+                AutoCompleteModule,
+                SharedModule,
+                ReactiveFormsModule,
+                TableModule,
+                ButtonModule,
+                TooltipModule,
+                LoadingStateModule,
+                DataListRestModule,
+                ConfirmDialogModule,
+            ],
+            declarations: [HistoricalBankAccountListComponent],
+            providers: [HistoricalBankAccountListService],
+            exports: [HistoricalBankAccountListComponent],
+        })
+    ], HistoricalBankAccountListModule);
+    return HistoricalBankAccountListModule;
+}());
+export { HistoricalBankAccountListModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/historical-bank-account-list/historical-bank-account-list.service.js

@@ -0,0 +1,37 @@
+import * as tslib_1 from "tslib";
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { ServiceType } from '../../core/enums/serviceType';
+import { HttpClientService } from "../shared/http-client.service";
+var HistoricalBankAccountListService = /** @class */ (function () {
+    function HistoricalBankAccountListService(http, httpClient) {
+        this.http = http;
+        this.httpClient = httpClient;
+    }
+    HistoricalBankAccountListService.prototype.remove = function (id, dateWhen, service, dependentId) {
+        if (service === void 0) { service = ServiceType.PAYROLL; }
+        if (service === ServiceType.DEPENDENT) {
+            return this.httpClient
+                .post("hcm/dependent/queries/historicalJudicialPensionBankAccountDelete", {
+                dependentId: dependentId,
+                dateWhen: dateWhen,
+            });
+        }
+        else {
+            return this.http.post("actions/historicalEmployeeBankAccountDelete", {
+                employeeId: id,
+                dateWhen: dateWhen
+            });
+        }
+    };
+    HistoricalBankAccountListService.ctorParameters = function () { return [
+        { type: HttpClientService },
+        { type: HttpClient }
+    ]; };
+    HistoricalBankAccountListService = tslib_1.__decorate([
+        Injectable()
+    ], HistoricalBankAccountListService);
+    return HistoricalBankAccountListService;
+}());
+export { HistoricalBankAccountListService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/historical-bank-account-list/index.js

@@ -0,0 +1,4 @@
+export * from './historical-bank-account-list.component';
+export * from './historical-bank-account-list.module';
+export * from './historical-bank-account-list.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1wZXNzb2FzL3BheXJvbGwtY29yZS8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvaGlzdG9yaWNhbC1iYW5rLWFjY291bnQtbGlzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyx3Q0FBd0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaGlzdG9yaWNhbC1iYW5rLWFjY291bnQtbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9oaXN0b3JpY2FsLWJhbmstYWNjb3VudC1saXN0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2hpc3RvcmljYWwtYmFuay1hY2NvdW50LWxpc3Quc2VydmljZSc7XG4iXX0=

package/esm5/components/image-cropper/image-crop.component.js

@@ -0,0 +1,164 @@
+import * as tslib_1 from "tslib";
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { CropperSettings } from 'ng2-img-cropper';
+import { ToastService } from '../toast/toast.service';
+import { ImageCropService } from './image-crop.service';
+var ImageCropComponent = /** @class */ (function () {
+    function ImageCropComponent(imageCropService, toastService) {
+        this.imageCropService = imageCropService;
+        this.toastService = toastService;
+        this.service = 'payroll';
+        this.onClickSave = new EventEmitter();
+        this.defaulPerson = 'assets/default-person.png';
+        this.display = false;
+        this.imageCrop = [];
+        this.data = {};
+        this.cropperSettings = new CropperSettings();
+        this.cropperSettings.width = 100;
+        this.cropperSettings.height = 100;
+        this.cropperSettings.keepAspect = false;
+        this.cropperSettings.preserveSize = true;
+        this.cropperSettings.canvasWidth = 600;
+        this.cropperSettings.canvasHeight = 450;
+        this.cropperSettings.rounded = true;
+        this.cropperSettings.minWithRelativeToResolution = false;
+        this.cropperSettings.noFileInput = true;
+        this.cropperSettings.cropperDrawSettings.strokeColor = 'rgba(255,255,255,1)';
+        this.cropperSettings.cropperDrawSettings.strokeWidth = 1;
+    }
+    Object.defineProperty(ImageCropComponent.prototype, "image", {
+        set: function (data) {
+            var _this = this;
+            if (data && data.fileId && !this.personPhotoLink) {
+                this.imageCropService.blobServiceRequestAccess(this.service, data.fileId, true).subscribe(function (response) {
+                    _this.personPhotoLink = response.result.locationURI;
+                });
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ImageCropComponent.prototype.onUploadHandler = function ($event) {
+        var _this = this;
+        this.file = $event.files[0];
+        if (this.file && this.file.size > 5000000) {
+            this.file = null;
+            this.imageCrop = [];
+            this.toastService.showError('O tamanho máximo permitido para a imagem é de 5MB');
+            return;
+        }
+        this.display = false;
+        var image = new Image();
+        var myReader = new FileReader();
+        myReader.onloadend = function (loadEvent) {
+            image.src = loadEvent.target.result;
+            _this.cropper.setImage(image);
+        };
+        myReader.readAsDataURL(this.file);
+        this.display = true;
+    };
+    ImageCropComponent.prototype.ngOnInit = function () {
+        this.data.image = null;
+        this.personPhotoLink = null;
+        this.personFirstName = '';
+        this.display = false;
+    };
+    ImageCropComponent.prototype.showDialog = function () {
+        this.display = true;
+    };
+    ImageCropComponent.prototype.onHide = function () {
+        this.display = false;
+    };
+    ImageCropComponent.prototype.reset = function () {
+        this.file = null;
+        this.data = {};
+        this.imageCrop = [];
+        this.cropper.reset();
+        this.data.image = null;
+        this.personPhotoLink = null;
+        this.personFirstName = '';
+    };
+    ImageCropComponent.prototype.saveImage = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var fileName, fileImage_1, fileUpload, thisContext;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.file) {
+                            this.onClickSave.emit(null);
+                            this.onHide();
+                            return [2 /*return*/];
+                        }
+                        fileName = this.file['name'];
+                        if (!(this.cropper && this.cropper.image)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.urltoFile(this.cropper.image.image, fileName)];
+                    case 1:
+                        fileImage_1 = _a.sent();
+                        this.personPhotoLink = this.data.image;
+                        fileUpload = null;
+                        if (this.file) {
+                            fileUpload = { fileName: this.file['name'] };
+                        }
+                        else if (this.data) {
+                            fileUpload = { fileName: this.data.fileId.split('/')[1] };
+                        }
+                        if (fileUpload) {
+                            thisContext = this;
+                            this.imageCropService.blobServiceRequestUpload(this.service, fileUpload).subscribe(function (response) {
+                                var request = new XMLHttpRequest();
+                                request.open('PUT', response.result.locationURI, true);
+                                request.setRequestHeader('Translate', 'f');
+                                request.send(fileImage_1);
+                                _this.onClickSave.emit(response.result);
+                                _this.onHide();
+                            });
+                        }
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ImageCropComponent.prototype.urltoFile = function (url, filename, mimeType) {
+        if (mimeType === void 0) { mimeType = null; }
+        mimeType = mimeType || (url.match(/^data:([^;]+);/) || '')[1];
+        return fetch(url)
+            .then(function (res) {
+            return res.arrayBuffer();
+        })
+            .then(function (buf) {
+            return new File([buf], filename, { type: mimeType });
+        });
+    };
+    ImageCropComponent.prototype.deleteImage = function () {
+        this.imageCropService.blobServiceFileDelete(this.service, this.data && this.data.image && this.data.image.fileId);
+        this.reset();
+    };
+    ImageCropComponent.ctorParameters = function () { return [
+        { type: ImageCropService },
+        { type: ToastService }
+    ]; };
+    tslib_1.__decorate([
+        Input()
+    ], ImageCropComponent.prototype, "service", void 0);
+    tslib_1.__decorate([
+        Output()
+    ], ImageCropComponent.prototype, "onClickSave", void 0);
+    tslib_1.__decorate([
+        ViewChild('cropper', { static: false })
+    ], ImageCropComponent.prototype, "cropper", void 0);
+    tslib_1.__decorate([
+        Input()
+    ], ImageCropComponent.prototype, "image", null);
+    ImageCropComponent = tslib_1.__decorate([
+        Component({
+            selector: 'image-crop',
+            template: "<a (click)=\"showDialog()\">\n  <span class=\"result rounded\">\n        <img class=\"center-block\" style=\"max-width: 100%; height: auto\"\n             [src]=\"personPhotoLink ? personPhotoLink : defaulPerson\" [alt]=\"personFirstName\"\n             width=\"auto\" height=\"140\">\n  </span>\n</a>\n\n<p-dialog [(visible)]=\"display\" modal=\"true\" [minWidth]=\"450\" (onHide)=\"onHide()\">\n  <p-header>\n    {{'hcm.payroll.employees_image_cropper_edit' | translate}}\n  </p-header>\n\n  <div class=\"ui-g\" *ngIf=\"!data.image\">\n    <div class=\"ui-md-12 img-user-modal\" *ngIf=\"!personPhotoLink\">\n      <i class=\"fa fa-user-circle fa-5x\"></i>\n      <div id=\"txt-select-image\">{{'hcm.payroll.employees_image_cropper_viewing' | translate}}</div>\n      <div class=\"ui-md-4 btn-center\">\n        <p-fileUpload [chooseLabel]=\"'hcm.payroll.employees_image_cropper_select'|translate\"\n                      mode=\"basic\"\n                      name=\"imageCrop[]\"\n                      accept=\"image/*\"\n                      customUpload=\"true\"\n                      auto=\"true\"\n                      [files]=\"imageCrop\"\n                      (uploadHandler)=\"onUploadHandler($event)\"\n        >\n        </p-fileUpload>\n      </div>\n    </div>\n  </div>\n  <div class=\"ui-g\" *ngIf=\"!data.image\">\n      <div class=\"ui-md-4 btn-left\" *ngIf=\"personPhotoLink\">\n          <p-fileUpload [chooseLabel]=\"'hcm.payroll.employees_image_cropper_select'|translate\"\n                        mode=\"basic\"\n                        name=\"imageCrop[]\"\n                        accept=\"image/*\"\n                        customUpload=\"true\"\n                        auto=\"true\"\n                        [files]=\"imageCrop\"\n                        (uploadHandler)=\"onUploadHandler($event)\"\n          >\n          </p-fileUpload>\n        </div>\n        <div class=\"ui-md-4 btn-left\" *ngIf=\"personPhotoLink\">\n          <button pButton class=\"ui-button-secondary\" type=\"button\" (click)=\"deleteImage()\"\n                  label=\"{{'hcm.payroll.employees_image_cropper_delete' | translate}}\"></button>\n        </div>\n        <div class=\"ui-g-12 ui-md-12\" *ngIf=\"personPhotoLink\">\n            <span class=\"result rounded\">\n                <img class=\"center-block default-image\"\n                   [src]=\"personPhotoLink ? personPhotoLink : defaulPerson\"\n                   [alt]=\"personFirstName\"\n                   width=\"auto\"\n                   height=\"140\">\n            </span>\n          </div>\n  </div>\n  <div class=\"ui-g\" [style.display]=\"data.image ? 'block' : 'none'\">\n    <div class=\"ui-md-4 btn-left\">\n      <p-fileUpload chooseLabel=\"Selecionar foto\"\n                    mode=\"basic\"\n                    name=\"imageCrop[]\"\n                    accept=\"image/*\"\n                    customUpload=\"true\"\n                    auto=\"true\"\n                    [files]=\"imageCrop\"\n                    (uploadHandler)=\"onUploadHandler($event)\"\n      >\n      </p-fileUpload>\n    </div>\n    <div class=\"ui-md-4 btn-left\">\n      <button pButton class=\"ui-button-secondary\" type=\"button\" (click)=\"deleteImage()\"\n              label=\"{{'hcm.payroll.employees_image_cropper_delete'|translate}}\"></button>\n    </div>\n    <div class=\"ui-md-12\">\n      <img-cropper #cropper [image]=\"data\" [settings]=\"cropperSettings\"></img-cropper>\n    </div>\n  </div>\n\n  <p-footer>\n    <button pButton type=\"button\" class=\"btn-link ui-button-link\" (click)=\"display=false\"\n      label=\"{{'hcm.payroll.employees_image_cropper_cancel' | translate}}\"></button>\n    <button pButton type=\"button\" (click)=\"saveImage()\" label=\"{{'hcm.payroll.employees_image_cropper_save'|translate}}\"></button>\n  </p-footer>\n</p-dialog>\n",
+            styles: [".center{float:left;position:relative;left:30%}.btn-center{float:left;position:relative;left:33%}.btn-left{float:left;position:relative}.rounded{cursor:pointer}.result.rounded>img{border-radius:50%}div.cropper{height:400px}.center-block{display:block;margin-right:auto;margin-left:auto}.ui-fileupload-choose{width:300px!important}.fa-user-circle{color:#ccc}.img-user-modal{text-align:center!important}#txt-select-image{margin:20px 0;font-weight:700;font-size:16px}"]
+        })
+    ], ImageCropComponent);
+    return ImageCropComponent;
+}());
+export { ImageCropComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-crop.component.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/image-cropper/image-crop.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output, ViewChild } from '@angular/core';\nimport { CropperSettings, ImageCropperComponent } from 'ng2-img-cropper';\n\nimport { ToastService } from '../toast/toast.service';\nimport { ImageCropService } from './image-crop.service';\n\n@Component({\n  selector: 'image-crop',\n  templateUrl: './image-crop.component.html',\n  styleUrls: ['./image-crop.component.css'],\n})\nexport class ImageCropComponent implements OnInit {\n  @Input()\n  service = 'payroll';\n  @Output()\n  onClickSave: EventEmitter<any> = new EventEmitter();\n\n  private file: Blob;\n  @ViewChild('cropper', { static: false })\n  private cropper: ImageCropperComponent;\n  defaulPerson = 'assets/default-person.png';\n  personPhotoLink: string;\n  personFirstName: string;\n  display = false;\n  cropperSettings: CropperSettings;\n  imageCrop = [];\n  data: any = {};\n\n  constructor(private imageCropService: ImageCropService, private toastService: ToastService) {\n    this.cropperSettings = new CropperSettings();\n    this.cropperSettings.width = 100;\n    this.cropperSettings.height = 100;\n    this.cropperSettings.keepAspect = false;\n    this.cropperSettings.preserveSize = true;\n    this.cropperSettings.canvasWidth = 600;\n    this.cropperSettings.canvasHeight = 450;\n    this.cropperSettings.rounded = true;\n    this.cropperSettings.minWithRelativeToResolution = false;\n    this.cropperSettings.noFileInput = true;\n    this.cropperSettings.cropperDrawSettings.strokeColor = 'rgba(255,255,255,1)';\n    this.cropperSettings.cropperDrawSettings.strokeWidth = 1;\n  }\n\n  @Input()\n  set image(data) {\n    if (data && data.fileId && !this.personPhotoLink) {\n      this.imageCropService.blobServiceRequestAccess(this.service, data.fileId, true).subscribe(response => {\n        this.personPhotoLink = response.result.locationURI;\n      });\n    }\n  }\n\n  onUploadHandler($event) {\n    this.file = $event.files[0];\n\n    if (this.file && this.file.size > 5000000) {\n      this.file = null;\n      this.imageCrop = [];\n      this.toastService.showError('O tamanho máximo permitido para a imagem é de 5MB');\n      return;\n    }\n    this.display = false;\n\n    const image: any = new Image();\n    const myReader: FileReader = new FileReader();\n    myReader.onloadend = (loadEvent: any) => {\n      image.src = loadEvent.target.result;\n      this.cropper.setImage(image);\n    };\n\n    myReader.readAsDataURL(this.file);\n    this.display = true;\n  }\n\n  ngOnInit(): void {\n    this.data.image = null;\n    this.personPhotoLink = null;\n    this.personFirstName = '';\n    this.display = false;\n  }\n\n  showDialog(): void {\n    this.display = true;\n  }\n\n  onHide() {\n    this.display = false;\n  }\n\n  reset() {\n    this.file = null;\n    this.data = {};\n    this.imageCrop = [];\n    this.cropper.reset();\n    this.data.image = null;\n    this.personPhotoLink = null;\n    this.personFirstName = '';\n  }\n\n  async saveImage() {\n    if (!this.file) {\n      this.onClickSave.emit(null);\n      this.onHide();\n      return;\n    }\n\n    const fileName = this.file['name'];\n    if (this.cropper && this.cropper.image) {\n      const fileImage = await this.urltoFile(this.cropper.image.image, fileName);\n      this.personPhotoLink = this.data.image;\n      let fileUpload = null;\n      if (this.file) {\n        fileUpload = { fileName: this.file['name'] };\n      } else if (this.data) {\n        fileUpload = { fileName: this.data.fileId.split('/')[1] };\n      }\n      if (fileUpload) {\n        const thisContext = this;\n        this.imageCropService.blobServiceRequestUpload(this.service, fileUpload).subscribe(response => {\n          const request = new XMLHttpRequest();\n          request.open('PUT', response.result.locationURI, true);\n          request.setRequestHeader('Translate', 'f');\n          request.send(fileImage);\n          this.onClickSave.emit(response.result);\n          this.onHide();\n        });\n      }\n    }\n  }\n\n  urltoFile(url, filename, mimeType = null) {\n    mimeType = mimeType || (url.match(/^data:([^;]+);/) || '')[1];\n    return fetch(url)\n      .then(function(res) {\n        return res.arrayBuffer();\n      })\n      .then(function(buf) {\n        return new File([buf], filename, { type: mimeType });\n      });\n  }\n\n  deleteImage() {\n    this.imageCropService.blobServiceFileDelete(this.service, this.data && this.data.image && this.data.image.fileId);\n    this.reset();\n  }\n}\n"]}

package/esm5/components/image-cropper/image-crop.module.js

@@ -0,0 +1,41 @@
+import * as tslib_1 from "tslib";
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ImageCropperModule } from 'ng2-img-cropper';
+import { ButtonModule } from 'primeng/button';
+import { DialogModule } from 'primeng/dialog';
+import { FileUploadModule } from 'primeng/fileupload';
+import { SharedModule } from '../shared/shared.module';
+import { ImageCropComponent } from './image-crop.component';
+import { ImageCropService } from './image-crop.service';
+import { ThumbnailModule, ImageCropperService } from '@seniorsistemas/angular-components';
+var ImageCropModule = /** @class */ (function () {
+    /**
+     * @deprecated
+     */
+    function ImageCropModule() {
+    }
+    ImageCropModule = tslib_1.__decorate([
+        NgModule({
+            imports: [
+                CommonModule,
+                SharedModule,
+                DialogModule,
+                ButtonModule,
+                FileUploadModule,
+                ImageCropperModule,
+                ImageCropperModule,
+                ThumbnailModule
+            ],
+            declarations: [ImageCropComponent],
+            providers: [ImageCropService, ImageCropperService],
+            exports: [ImageCropComponent],
+        })
+        /**
+         * @deprecated
+         */
+    ], ImageCropModule);
+    return ImageCropModule;
+}());
+export { ImageCropModule };
+//# sourceMappingURL=data:application/json;base64,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