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

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

@@ -0,0 +1,223 @@
+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";
+const moment = moment_;
+let HistoricalBankAccountListComponent = class HistoricalBankAccountListComponent {
+    constructor(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",
+            },
+        ];
+    }
+    ngOnInit() {
+        this.initParameters = { employeeId: this.employeeId, dependentId: this.dependentId };
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() {
+        this.cd.detectChanges();
+    }
+    onLazyLoad(payload) {
+        payload.forEach((value) => {
+            value.dateWhen = moment(value.dateWhen).format(this.dateFormat);
+        });
+        this.onGridLoad(payload);
+        this.loading = false;
+    }
+    getMenuActions(rowData) {
+        return [
+            {
+                label: this.translateService.instant("hcm.payroll.employees_image_cropper_view"),
+                command: () => {
+                    const 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: () => {
+                    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"),
+                        });
+                    }
+                },
+            },
+        ];
+    }
+    delete(id, dateWhen) {
+        if (id === this.lastRecord.id) {
+            const dateWhenToDto = 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: () => {
+                    this.loading = true;
+                    const service = this.withSidebar ? ServiceType.PAYROLL : ServiceType.DEPENDENT;
+                    this.historicalBankAccountListService
+                        .remove(this.employeeId, dateWhenToDto, service, this.dependentId)
+                        .pipe(takeUntil(this.ngUnsubscribe))
+                        .subscribe(() => {
+                        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 && Object.assign({}, this.parameters)) || {};
+                    }, () => {
+                        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"),
+            });
+        }
+    }
+    add() {
+        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"),
+            });
+        }
+    }
+    onGridLoad(payload) {
+        if (payload && payload.length) {
+            this.lastRecord = payload[0];
+        }
+    }
+    get isAllowToAddHistorical() {
+        return (this.permission["incluir"]);
+    }
+    get isAllowToDeleteHistorical() {
+        return (this.permission["excluir"]);
+    }
+    get scopedActions() {
+        return this.getMenuActions.bind(this);
+    }
+    set reloadList(condition) {
+        if (condition) {
+            this.loading = true;
+            this.parameters = (this.parameters && Object.assign({}, this.parameters)) || {};
+        }
+    }
+};
+HistoricalBankAccountListComponent.ctorParameters = () => [
+    { 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);
+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":"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","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/esm2015/components/historical-bank-account-list/historical-bank-account-list.module.js

@@ -0,0 +1,39 @@
+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";
+let HistoricalBankAccountListModule = class 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);
+export { HistoricalBankAccountListModule };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+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";
+let HistoricalBankAccountListService = class HistoricalBankAccountListService {
+    constructor(http, httpClient) {
+        this.http = http;
+        this.httpClient = httpClient;
+    }
+    remove(id, dateWhen, service = ServiceType.PAYROLL, dependentId) {
+        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 = () => [
+    { type: HttpClientService },
+    { type: HttpClient }
+];
+HistoricalBankAccountListService = tslib_1.__decorate([
+    Injectable()
+], HistoricalBankAccountListService);
+export { HistoricalBankAccountListService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/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/esm2015/components/image-cropper/image-crop.component.js

@@ -0,0 +1,146 @@
+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';
+let ImageCropComponent = class ImageCropComponent {
+    constructor(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;
+    }
+    set image(data) {
+        if (data && data.fileId && !this.personPhotoLink) {
+            this.imageCropService.blobServiceRequestAccess(this.service, data.fileId, true).subscribe(response => {
+                this.personPhotoLink = response.result.locationURI;
+            });
+        }
+    }
+    onUploadHandler($event) {
+        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;
+        const image = new Image();
+        const myReader = new FileReader();
+        myReader.onloadend = (loadEvent) => {
+            image.src = loadEvent.target.result;
+            this.cropper.setImage(image);
+        };
+        myReader.readAsDataURL(this.file);
+        this.display = true;
+    }
+    ngOnInit() {
+        this.data.image = null;
+        this.personPhotoLink = null;
+        this.personFirstName = '';
+        this.display = false;
+    }
+    showDialog() {
+        this.display = true;
+    }
+    onHide() {
+        this.display = false;
+    }
+    reset() {
+        this.file = null;
+        this.data = {};
+        this.imageCrop = [];
+        this.cropper.reset();
+        this.data.image = null;
+        this.personPhotoLink = null;
+        this.personFirstName = '';
+    }
+    saveImage() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.file) {
+                this.onClickSave.emit(null);
+                this.onHide();
+                return;
+            }
+            const fileName = this.file['name'];
+            if (this.cropper && this.cropper.image) {
+                const fileImage = yield this.urltoFile(this.cropper.image.image, fileName);
+                this.personPhotoLink = this.data.image;
+                let fileUpload = null;
+                if (this.file) {
+                    fileUpload = { fileName: this.file['name'] };
+                }
+                else if (this.data) {
+                    fileUpload = { fileName: this.data.fileId.split('/')[1] };
+                }
+                if (fileUpload) {
+                    const thisContext = this;
+                    this.imageCropService.blobServiceRequestUpload(this.service, fileUpload).subscribe(response => {
+                        const request = new XMLHttpRequest();
+                        request.open('PUT', response.result.locationURI, true);
+                        request.setRequestHeader('Translate', 'f');
+                        request.send(fileImage);
+                        this.onClickSave.emit(response.result);
+                        this.onHide();
+                    });
+                }
+            }
+        });
+    }
+    urltoFile(url, filename, 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 });
+        });
+    }
+    deleteImage() {
+        this.imageCropService.blobServiceFileDelete(this.service, this.data && this.data.image && this.data.image.fileId);
+        this.reset();
+    }
+};
+ImageCropComponent.ctorParameters = () => [
+    { 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);
+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/esm2015/components/image-cropper/image-crop.module.js

@@ -0,0 +1,39 @@
+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';
+let ImageCropModule = 
+/**
+ * @deprecated
+ */
+class ImageCropModule {
+};
+ImageCropModule = tslib_1.__decorate([
+    NgModule({
+        imports: [
+            CommonModule,
+            SharedModule,
+            DialogModule,
+            ButtonModule,
+            FileUploadModule,
+            ImageCropperModule,
+            ImageCropperModule,
+            ThumbnailModule
+        ],
+        declarations: [ImageCropComponent],
+        providers: [ImageCropService, ImageCropperService],
+        exports: [ImageCropComponent],
+    })
+    /**
+     * @deprecated
+     */
+], ImageCropModule);
+export { ImageCropModule };
+//# sourceMappingURL=data:application/json;base64,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