@senior-gestao-relacionamento/angular-components 1.3.0 → 1.5.0

package/fesm2015/senior-gestao-relacionamento-angular-components.js

@@ -1,172 +1,411 @@
-import { get } from 'js-cookie';
 import { __decorate } from 'tslib';
-import { ɵɵdefineInjectable, Injectable, NgModule } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
+import { Injectable, EventEmitter, Input, Output, Component, NgModule, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
+import { FormControl, FormGroup, Validators, FormBuilder, FormsModule } from '@angular/forms';
+import { FormField, FieldType, LocaleModule, ButtonModule, DynamicFormModule, SidebarModule, LoadingStateModule } from '@seniorsistemas/angular-components';
+import { TranslateService, TranslateModule } from '@ngx-translate/core';
+import { throwError, BehaviorSubject, Observable, Subject } from 'rxjs';
+import { HttpParams, HttpClient, HttpClientModule } from '@angular/common/http';
+import { map, catchError, takeUntil, concatMap, distinctUntilChanged } from 'rxjs/operators';
+import { MessageService } from 'primeng/api';
+import { RouterModule, Router } from '@angular/router';
+import { CommonModule } from '@angular/common';
+import { SelectButtonModule } from 'primeng/selectbutton';
+import { DialogModule } from 'primeng/dialog';
+import { PanelModule } from 'primeng/panel';
+import { ToastModule } from 'primeng/toast';
+import { CookieService } from 'ngx-cookie-service';
 import { Stomp } from '@stomp/stompjs';
 import * as SockJS from 'sockjs-client';
-import { HttpClient, HttpClientModule } from '@angular/common/http';
-import { takeUntil, catchError } from 'rxjs/operators';
 
-class StorageService {
-    static getUser() {
-        return JSON.parse(localStorage.getItem('SENIOR_USER_INFO')).data;
-    }
-    static getUserId() {
-        return StorageService.getUser().id;
+var FormatEnum;
+(function (FormatEnum) {
+    FormatEnum["PDF"] = "Pdf";
+    FormatEnum["CSV"] = "Csv";
+    FormatEnum["HTML"] = "Html";
+    FormatEnum["XLSX"] = "Xlsx";
+    FormatEnum["XML"] = "Xml";
+    FormatEnum["ODT"] = "Odt";
+    FormatEnum["RTF"] = "Rtf";
+})(FormatEnum || (FormatEnum = {}));
+
+var ViewModeEnum;
+(function (ViewModeEnum) {
+    ViewModeEnum["SIDEBAR"] = "sidebar";
+    ViewModeEnum["DIALOG"] = "dialog";
+})(ViewModeEnum || (ViewModeEnum = {}));
+
+let ReportsService = class ReportsService {
+    constructor(_httpClient, _translate, _messageService) {
+        this._httpClient = _httpClient;
+        this._translate = _translate;
+        this._messageService = _messageService;
+        this.queriesPlatformReportUrl = `platform/report/queries`;
+        this.actionsCrmxReportUrl = `crmx/report/actions`;
     }
-    static store(key, value) {
-        const userId = StorageService.getUserId();
-        localStorage.setItem(`${userId}_${key}`, JSON.stringify(value));
+    listReports(tag, ids) {
+        let params = new HttpParams();
+        params = params.append('searchValue', tag);
+        return this._httpClient.get(`${this.queriesPlatformReportUrl}/listReports`, { params }).pipe(map((response) => response.reports.filter((report) => ids ? ids.includes(report.id) : true)), this.defaultCatch());
     }
-    static get(key) {
-        const userId = StorageService.getUserId();
-        const value = localStorage.getItem(`${userId}_${key}`);
-        if (value) {
-            return JSON.parse(value);
-        }
-        return null;
+    getSharedReport(tag) {
+        let params = new HttpParams();
+        params = params.append('searchValue', tag);
+        return this._httpClient.get(`${this.queriesPlatformReportUrl}/listSharedReports`, { params }).pipe(map((response) => {
+            return response.reports.filter((report) => report.enabled);
+        }), this.defaultCatch());
     }
-    static getComSeniorToken() {
-        return JSON.parse(get('com.senior.token'));
+    generateReport(inputDto) {
+        return this._httpClient.post(`${this.actionsCrmxReportUrl}/generateReport`, inputDto).pipe(this.defaultCatch());
     }
-    static getBaseUrl() {
-        return get('com.senior.base.url');
+    defaultCatch() {
+        return catchError((err) => {
+            if (err) {
+                let summary = err.status ? String(err.status) : 'Error';
+                let detail;
+                if (err.error && err.error.message) {
+                    detail = err.error.message;
+                }
+                else if (err.statusText) {
+                    detail = err.statusText;
+                }
+                else if (err.message) {
+                    detail = err.message;
+                }
+                else {
+                    detail = 'Error';
+                }
+                const errorUnauthorized = 401;
+                if (err.status === errorUnauthorized) {
+                    summary = this._translate.instant('crmx.angular_components.error_unauthorized_title');
+                    detail = this._translate.instant('crmx.angular_components.error_unauthorized_description');
+                }
+                this._messageService.add({
+                    severity: 'error',
+                    summary,
+                    detail,
+                    sticky: true,
+                });
+            }
+            return throwError(err);
+        });
     }
-    static getTenantDomain() {
-        return StorageService.getComSeniorToken().username.split('@')[1];
+};
+ReportsService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: TranslateService },
+    { type: MessageService }
+];
+ReportsService = __decorate([
+    Injectable()
+], ReportsService);
+
+let ReportsComponent = class ReportsComponent {
+    constructor(_translate, _formBuilder, _reportsService) {
+        this._translate = _translate;
+        this._formBuilder = _formBuilder;
+        this._reportsService = _reportsService;
+        this.formGroups = [];
+        this.visibleChange = new EventEmitter();
+        this.reportGenerated = new EventEmitter();
+        this.reportsObservable = new BehaviorSubject([]);
+        this.viewModeEnum = ViewModeEnum;
+        this.loading = false;
+        this._reports = [];
+        this._formatEnum = [];
     }
-    static getTenantName() {
-        return StorageService.getComSeniorToken().tenantName;
+    ngOnChanges(changes) {
+        if (this.options) {
+            this.options.header = this.options.header || this._translate.instant('crmx.angular_components.reports_title');
+            this.options.labelConfirmButton = this.options.labelConfirmButton || this._translate.instant('crmx.angular_components.confirm');
+            this._formatEnum = Object.keys(FormatEnum)
+                .filter(key => !this.options.formats || this.options.formats.includes(FormatEnum[key]))
+                .map(key => ({ label: key.toUpperCase(), value: FormatEnum[key] }));
+            if (this.visible) {
+                this.loading = true;
+                this._executeObservable(this._reportsService.listReports(this.options.tenantReport || this.options.sharedReport))
+                    .subscribe((nextAction) => {
+                    if (nextAction) {
+                        this._executeObservable(this._reportsService.getSharedReport(this.options.sharedReport))
+                            .subscribe((nextAction) => {
+                            this.loading = false;
+                        });
+                    }
+                });
+            }
+        }
     }
-    static getUsername() {
-        return StorageService.getComSeniorToken().username.split('@')[0];
+    ngOnInit() {
+        this.formGroup = this._getFormGroup();
+        this.formFields = this._getFormFields();
     }
-    static getLogin() {
-        return StorageService.getComSeniorToken().username;
+    onCancel() {
+        this.formGroup.reset();
+        this.visible = false;
+        this.visibleChange.emit(this.visible);
     }
-    static getToken() {
-        return StorageService.getComSeniorToken().access_token;
+    onConfirm() {
+        this.loading = true;
+        const data = this.formGroup.getRawValue();
+        let isValid = true;
+        this.formGroups.forEach((formGroup) => isValid = isValid && formGroup.valid);
+        if (!this.formGroup.valid || !isValid) {
+            this.loading = false;
+            this._validateAllFormFields(this.formGroup);
+            this.formGroups.forEach(this._validateAllFormFields);
+        }
+        else {
+            const input = {
+                report: {
+                    id: data.reports.id,
+                    parameters: this.options.parametersReport,
+                    format: data.format,
+                    timeToLive: 1000,
+                },
+                callbackEvent: this.options.callbackEvent,
+            };
+            this._reportsService.generateReport(input).subscribe((outputDto) => {
+                this.reportGenerated.emit(outputDto);
+                this.onCancel();
+            }, () => {
+                this.loading = false;
+            });
+        }
     }
-    static isUserAdmin() {
-        return StorageService.getUsername() === 'admin';
+    getErrorMessages() {
+        return {
+            required: this._translate.instant('crmx.angular_components.error_required'),
+        };
     }
-}
-
-class StringConverterService {
-    static toUnderscore(camelCase) {
-        const regex = /([a-z])([A-Z])/g;
-        return camelCase.replace(regex, '$1_$2').toLowerCase();
+    onVisibleChange(visible) {
+        if (!visible) {
+            this.onCancel();
+        }
     }
-}
-
-class FormGroupValidatorsService {
-    static startDataGreaterThanEndDataValidator(endDateField, errorMessage) {
-        const fn = function (control) {
-            var _a;
-            if (control.parent) {
-                const startDate = new Date(control.value);
-                const endDate = new Date((_a = control.parent.controls[endDateField]) === null || _a === void 0 ? void 0 : _a.value);
-                if (startDate > endDate) {
-                    const rtn = {};
-                    rtn[errorMessage] = true;
-                    return rtn;
+    _executeObservable(observable) {
+        return new Observable((observer) => {
+            observable
+                .pipe(catchError((err) => {
+                this.loading = false;
+                return throwError(err);
+            }))
+                .subscribe((reports) => {
+                this._reports = reports;
+                if (reports.length > 0) {
+                    this.loading = false;
+                    this._setValuesDefault();
+                    observer.next(false);
+                }
+                else {
+                    observer.next(true);
                 }
+            }, () => {
+                this.loading = false;
+            });
+        });
+    }
+    _setValuesDefault() {
+        var _a;
+        this.formGroup.controls.reports.setValue(this._reports[0]);
+        this.formGroup.controls.format.setValue((_a = this._formatEnum[0]) === null || _a === void 0 ? void 0 : _a.value);
+    }
+    _hasEmpty(target) {
+        return (Object.keys(target).filter((key) => target[key] === '' || target[key] === undefined).length > 0);
+    }
+    _validateAllFormFields(formGroup) {
+        Object.keys(formGroup.controls).forEach((field) => {
+            const control = formGroup.get(field);
+            if (control instanceof FormControl) {
+                control.markAsDirty({ onlySelf: true });
             }
-            return null;
-        };
-        return fn;
+            else if (control instanceof FormGroup) {
+                this._validateAllFormFields(control);
+            }
+        });
     }
-    static endDateLessThanStartDateValidator(startDateField, errorMessage) {
-        const fn = function (control) {
-            var _a;
-            if (control.parent) {
-                const startDate = new Date((_a = control.parent.controls[startDateField]) === null || _a === void 0 ? void 0 : _a.value);
-                const endDate = new Date(control.value);
-                if (startDate > endDate) {
-                    const rtn = {};
-                    rtn[errorMessage] = true;
-                    return rtn;
+    _getFormGroup() {
+        return this._formBuilder.group({
+            reports: [{ value: null, disabled: false }, Validators.compose([Validators.required])],
+            format: [{ value: null, disabled: false }, Validators.compose([Validators.required])],
+        });
+    }
+    _getFormFields() {
+        return [
+            new FormField({
+                type: FieldType.Autocomplete,
+                name: "reports",
+                label: this._translate.instant('crmx.angular_components.report'),
+                size: { xl: 12, lg: 12, md: 12, sm: 12 },
+                multiple: false,
+                dataKey: "id",
+                appendTo: "body",
+                emptyMessage: "Nenhuma sugestão encontrada",
+                displayField: "name",
+                required: () => true,
+                suggestionsObservable: this.reportsObservable,
+                onSearch: (val) => this.reportsObservable.next(this._reports.filter((reportDto) => reportDto.name.match(new RegExp(val, "ig")))),
+                footer: {
+                    help: {
+                        text: this._translate.instant('crmx.angular_components.reports_help', { tag: this.options.tenantReport }),
+                        icon: 'fa fa-info-circle'
+                    }
                 }
-            }
-            return null;
-        };
-        return fn;
+            }),
+            new FormField({
+                type: FieldType.Enum,
+                name: 'format',
+                label: this._translate.instant('crmx.angular_components.format'),
+                placeholder: this._translate.instant('crmx.angular_components.format_placeholder'),
+                size: { xl: 12, lg: 12, md: 12, sm: 12 },
+                multiple: false,
+                required: () => true,
+                options: this._formatEnum,
+            }),
+        ];
     }
-    ;
-}
+};
+ReportsComponent.ctorParameters = () => [
+    { type: TranslateService },
+    { type: FormBuilder },
+    { type: ReportsService }
+];
+__decorate([
+    Input()
+], ReportsComponent.prototype, "visible", void 0);
+__decorate([
+    Input()
+], ReportsComponent.prototype, "options", void 0);
+__decorate([
+    Input()
+], ReportsComponent.prototype, "formGroups", void 0);
+__decorate([
+    Output()
+], ReportsComponent.prototype, "visibleChange", void 0);
+__decorate([
+    Output()
+], ReportsComponent.prototype, "reportGenerated", void 0);
+ReportsComponent = __decorate([
+    Component({
+        selector: 'report',
+        template: "<div *ngIf=\"options\">\n    <ng-container *ngIf=\"options.viewMode === viewModeEnum.SIDEBAR else reportsDialog\" >\n        <s-sidebar [(visible)]=\"visible\" (visibleChange)=\"onVisibleChange($event)\" [header]=\"options.header\">\n            <ng-container *ngTemplateOutlet=\"content\"></ng-container>\n            <s-footer>\n                <ng-container *ngTemplateOutlet=\"footer\"></ng-container>\n            </s-footer>\n        </s-sidebar>\n    </ng-container>\n\n    <ng-template #reportsDialog>\n        <p-dialog\n            [(visible)]=\"visible\" (visibleChange)=\"visible = $event\"\n            [resizable]=\"false\" [draggable]=\"false\" [modal]=\"true\" [closable]=\"false\"\n        >\n            <p-header [textContent]=\"options.header\"></p-header>\n            <ng-container *ngTemplateOutlet=\"content\"></ng-container>\n            <p-footer>\n                <ng-container *ngTemplateOutlet=\"footer\"></ng-container>\n            </p-footer>\n        </p-dialog>\n    </ng-template>\n\n    <ng-template #content>\n        <div class=\"ui-g\" *sLoadingState=\"loading\">\n            <div class=\"ui-g-12\">\n                <s-dynamic-form\n                    [fields]=\"formFields\"\n                    [form]=\"formGroup\"\n                    [errorMessages]=\"getErrorMessages()\"\n                ></s-dynamic-form>\n            </div>\n            <div class=\"ui-g-12\">\n                <ng-content></ng-content>\n            </div>\n        </div>\n    </ng-template>\n\n    <ng-template #footer>\n        <s-button\n            tooltip=\"{{'crmx.angular_components.generate' | translate}}\"\n            tooltipPosition=\"left\" type=\"submit\" class=\"sds-float-right\"\n            priority=\"primary\" [label]=\"options.labelConfirmButton\"\n            (onClick)=\"onConfirm()\"\n            [disabled]=\"loading\"\n        ></s-button>\n        <s-button\n            tooltip=\"{{'crmx.angular_components.cancel' | translate}}\"\n            type=\"button\" class=\"sds-float-left\" priority=\"link\"\n            [label]=\"'crmx.angular_components.cancel' | translate\"\n            (onClick)=\"onCancel()\"\n            [disabled]=\"loading\"\n        ></s-button>\n    </ng-template>\n</div>\n"
+    })
+], ReportsComponent);
 
-class DateValidatorsService {
-    static isLastWeekdayOfMonth(date) {
-        const newDate = new Date(date);
-        const day = 7;
-        newDate.setDate(date.getDate() + day);
-        return newDate.getMonth() > date.getMonth() || newDate.getFullYear() > date.getFullYear();
-    }
-}
+let ReportsModule = class ReportsModule {
+};
+ReportsModule = __decorate([
+    NgModule({
+        imports: [
+            LocaleModule.forChild(),
+            FormsModule,
+            RouterModule,
+            CommonModule,
+            TranslateModule,
+            SelectButtonModule,
+            DialogModule,
+            ButtonModule,
+            DynamicFormModule,
+            SidebarModule,
+            PanelModule,
+            LoadingStateModule,
+        ],
+        declarations: [
+            ReportsComponent,
+        ],
+        exports: [
+            ReportsComponent,
+        ],
+        providers: [
+            ReportsService,
+        ]
+    })
+], ReportsModule);
 
-let WebsocketService = class WebsocketService {
-    constructor() {
-        this.primitiveEventObservables = [];
-        const url = StorageService.getBaseUrl().concat('/websocket/subscription');
-        const socket = new SockJS(url);
-        this.client = Stomp.over(socket);
-    }
-    startConnect() {
-        this.client.connect({}, () => this.onConnected(), () => this.onConnectError());
-    }
-    onEvent(primitiveEvent) {
-        const { domain, service, primitive, allUsers } = primitiveEvent;
-        const observable = new Subject();
-        const primitiveEventWithObservable = {
-            domain,
-            service,
-            primitive,
-            allUsers,
-            observable,
-        };
-        this.primitiveEventObservables.push(primitiveEventWithObservable);
-        return observable;
-    }
-    sendEvent(params) {
-        const topic = this.getTopicEvent(params);
-        this.client.send(topic, params.headers, JSON.stringify({
-            data: params.message
-        }));
+let RefreshWebsocketAlertComponent = class RefreshWebsocketAlertComponent {
+    constructor(_messageService, _translateService) {
+        this._messageService = _messageService;
+        this._translateService = _translateService;
+        this.open = false;
+        this.closeRefreshSocket = new EventEmitter();
+        this.refresh = new EventEmitter();
     }
-    onConnected() {
-        this.primitiveEventObservables.forEach(event => {
-            this.client.subscribe(this.getTopicEvent(event), ((message) => {
-                const body = JSON.parse(message.body);
-                event.observable.next(body.data);
-            }));
+    ngOnInit() {
+        this.closeRefreshSocket.subscribe(() => {
+            this.open = false;
+        });
+        this.refresh.subscribe(() => {
+            this._messageService.clear(this.key);
+            this.closeRefreshSocket.emit();
         });
     }
-    onConnectError() {
-        console.log('Error in connect!');
-    }
-    getTopicEvent(primitiveEvent) {
-        let topic = '/topic/'.concat(StorageService.getTenantDomain());
-        if (primitiveEvent.allUsers === false) {
-            topic = topic
-                .concat('/')
-                .concat(StorageService.getToken());
+    show(message) {
+        if (!this.open) {
+            this.open = true;
+            const thisMessage = {
+                key: this.key,
+                summary: (message === null || message === void 0 ? void 0 : message.summary) || this._translateService.instant('crmx.angular_components.refresh_websocket_alert_summary_default'),
+                detail: (message === null || message === void 0 ? void 0 : message.detail) || this._translateService.instant('crmx.angular_components.refresh_websocket_alert_detail_default'),
+                severity: (message === null || message === void 0 ? void 0 : message.severity) || 'info',
+                life: 10000,
+            };
+            this._messageService.add(thisMessage);
         }
-        topic = topic
-            .concat('/')
-            .concat(primitiveEvent.domain)
-            .concat('/')
-            .concat(primitiveEvent.service)
-            .concat('/')
-            .concat(primitiveEvent.primitive);
-        return topic;
     }
 };
-WebsocketService.ɵprov = ɵɵdefineInjectable({ factory: function WebsocketService_Factory() { return new WebsocketService(); }, token: WebsocketService, providedIn: "root" });
-WebsocketService = __decorate([
-    Injectable({
-        providedIn: 'root',
+RefreshWebsocketAlertComponent.ctorParameters = () => [
+    { type: MessageService },
+    { type: TranslateService }
+];
+__decorate([
+    Input()
+], RefreshWebsocketAlertComponent.prototype, "key", void 0);
+__decorate([
+    Output()
+], RefreshWebsocketAlertComponent.prototype, "closeRefreshSocket", void 0);
+__decorate([
+    Output()
+], RefreshWebsocketAlertComponent.prototype, "refresh", void 0);
+RefreshWebsocketAlertComponent = __decorate([
+    Component({
+        selector: 'refresh-websocket-alert',
+        template: "<p-toast [key]=\"key\" (onClose)=\"closeRefreshSocket.emit($event)\">\n    <ng-template let-message pTemplate=\"message\">\n        <span class=\"ui-toast-icon pi\"></span>\n        <div class=\"ui-toast-message-text-content\">\n            <div class=\"ui-toast-summary\">{{ message.summary }}</div>\n            <div class=\"ui-toast-detail\">\n                <span>{{ message.detail }}</span>\n                <s-button\n                    [label]=\"'crmx.angular_components.refresh_websocket_alert_click_here' | translate\"\n                    priority=\"link\"\n                    (onClick)=\"refresh.emit()\"\n                    styleClass=\"refresh-websocket\"\n                ></s-button>\n            </div>\n        </div>\n    </ng-template>\n</p-toast>\n",
+        styles: [".refresh-websocket{height:20px!important}"]
     })
-], WebsocketService);
+], RefreshWebsocketAlertComponent);
+
+let RefreshWebsocketAlertModule = class RefreshWebsocketAlertModule {
+};
+RefreshWebsocketAlertModule = __decorate([
+    NgModule({
+        imports: [
+            LocaleModule.forChild(),
+            ButtonModule,
+            TranslateModule,
+            ToastModule,
+        ],
+        declarations: [
+            RefreshWebsocketAlertComponent,
+        ],
+        exports: [
+            RefreshWebsocketAlertComponent,
+        ]
+    })
+], RefreshWebsocketAlertModule);
+
+const fallback = {
+    "crmx.angular_components.cancel": "Cancelar",
+    "crmx.angular_components.confirm": "Gerar",
+    "crmx.angular_components.error_required": "Campo obrigatório",
+    "crmx.angular_components.error_unauthorized_title": "Acesso não autorizado",
+    "crmx.angular_components.error_unauthorized_description": "Você não tem permissão para utilizar o recurso desejado",
+    "crmx.angular_components.format": "Formato",
+    "crmx.angular_components.format_placeholder": "Selecione uma Opção",
+    "crmx.angular_components.report": "Relatório",
+    "crmx.angular_components.reports_help": "Listando todos relatórios com a tag '{{tag}}'",
+    "crmx.angular_components.reports_title": "Gerar Relatório",
+    "crmx.angular_components.refresh_websocket_alert_click_here": "Clique aqui",
+    "crmx.angular_components.refresh_websocket_alert_detail_default": "Para atualizar a tela",
+    "crmx.angular_components.refresh_websocket_alert_summary_default": "Atualização de dados"
+};
 
 class User {
     constructor() {
@@ -365,15 +604,70 @@ class Collaborator {
     }
 }
 
+let StorageService = class StorageService {
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+    }
+    getUser() {
+        return JSON.parse(localStorage.getItem('SENIOR_USER_INFO')).data;
+    }
+    getUserId() {
+        return this.getUser().id;
+    }
+    store(key, value) {
+        const userId = this.getUserId();
+        localStorage.setItem(`${userId}_${key}`, JSON.stringify(value));
+    }
+    get(key) {
+        const userId = this.getUserId();
+        const value = localStorage.getItem(`${userId}_${key}`);
+        if (value) {
+            return JSON.parse(value);
+        }
+        return null;
+    }
+    getComSeniorToken() {
+        return JSON.parse(this.cookieService.get('com.senior.token'));
+    }
+    getBaseUrl() {
+        return this.cookieService.get('com.senior.base.url');
+    }
+    getTenantDomain() {
+        return this.getComSeniorToken().username.split('@')[1];
+    }
+    getTenantName() {
+        return this.getComSeniorToken().tenantName;
+    }
+    getUsername() {
+        return this.getComSeniorToken().username.split('@')[0];
+    }
+    getLogin() {
+        return this.getComSeniorToken().username;
+    }
+    getToken() {
+        return this.getComSeniorToken().access_token;
+    }
+    isUserAdmin() {
+        return this.getUsername() === 'admin';
+    }
+};
+StorageService.ctorParameters = () => [
+    { type: CookieService }
+];
+StorageService = __decorate([
+    Injectable()
+], StorageService);
+
 let CurrentCollaboratorService = class CurrentCollaboratorService {
-    constructor(http) {
+    constructor(http, storageService) {
         this.http = http;
+        this.storageService = storageService;
         this.ngUnsubscribe = new Subject();
         this.COLLABORATOR_KEY = 'CRMX_COLLABORATOR';
     }
     validate() {
         this.call(false).subscribe((collaborator) => {
-            if (collaborator.active === false && !StorageService.isUserAdmin()) {
+            if (collaborator.active === false) {
                 this.redirect('collaborator-inactive');
             }
         });
@@ -381,9 +675,21 @@ let CurrentCollaboratorService = class CurrentCollaboratorService {
     get() {
         return this.call(true);
     }
+    getE070FilCrmxMaster() {
+        return new Observable(observer => {
+            this.call(true).subscribe((collaborator) => {
+                const e070FilCrmxMaster = Object.assign({}, collaborator.branches.find((branch) => branch.master));
+                if (e070FilCrmxMaster) {
+                    e070FilCrmxMaster.collaborator = collaborator;
+                    observer.next(e070FilCrmxMaster);
+                }
+                observer.complete();
+            });
+        });
+    }
     call(useCache) {
         return new Observable(observer => {
-            const collaboratorDto = StorageService.get(this.COLLABORATOR_KEY);
+            const collaboratorDto = this.storageService.get(this.COLLABORATOR_KEY);
             if (collaboratorDto !== null && useCache) {
                 observer.next(Collaborator.fromDto(collaboratorDto));
             }
@@ -391,21 +697,23 @@ let CurrentCollaboratorService = class CurrentCollaboratorService {
                 this.http.get('crmx_collaborator/foundation/queries/getCurrentCollaborator')
                     .pipe(takeUntil(this.ngUnsubscribe), catchError((err) => {
                     const statusCode = 404;
-                    if (err.status === statusCode && !StorageService.isUserAdmin()) {
+                    if (err.status === statusCode) {
                         this.redirect('collaborator-not-found');
                     }
                     ;
                     throw err;
                 }))
                     .subscribe(collaboratorDto => {
-                    StorageService.store(this.COLLABORATOR_KEY, this.removeCircularReferences(collaboratorDto));
+                    collaboratorDto = this.removeCircularReferences(collaboratorDto);
+                    this.storageService.store(this.COLLABORATOR_KEY, collaboratorDto);
                     observer.next(Collaborator.fromDto(collaboratorDto));
                 });
             }
+            observer.complete();
         });
     }
     redirect(page) {
-        location.href = StorageService.getBaseUrl() + '/gestao-relacionamento/crmx_collaborator/foundation/#/' + page;
+        location.href = `${this.storageService.getBaseUrl()}/gestao-relacionamento/crmx_collaborator/foundation/#/${page}`;
     }
     removeCircularReferences(obj) {
         const seen = new WeakSet();
@@ -421,18 +729,32 @@ let CurrentCollaboratorService = class CurrentCollaboratorService {
     }
 };
 CurrentCollaboratorService.ctorParameters = () => [
-    { type: HttpClient }
+    { type: HttpClient },
+    { type: StorageService }
 ];
 CurrentCollaboratorService = __decorate([
     Injectable()
 ], CurrentCollaboratorService);
 
+let StorageModule = class StorageModule {
+};
+StorageModule = __decorate([
+    NgModule({
+        imports: [],
+        providers: [
+            StorageService,
+            CookieService
+        ],
+    })
+], StorageModule);
+
 let CurrentCollaboratorModule = class CurrentCollaboratorModule {
 };
 CurrentCollaboratorModule = __decorate([
     NgModule({
         imports: [
-            HttpClientModule
+            HttpClientModule,
+            StorageModule,
         ],
         providers: [
             CurrentCollaboratorService
@@ -440,6 +762,165 @@ CurrentCollaboratorModule = __decorate([
     })
 ], CurrentCollaboratorModule);
 
+var MonthEnum;
+(function (MonthEnum) {
+    MonthEnum["JANUARY"] = "JANUARY";
+    MonthEnum["FEBRUARY"] = "FEBRUARY";
+    MonthEnum["MARCH"] = "MARCH";
+    MonthEnum["APRIL"] = "APRIL";
+    MonthEnum["MAY"] = "MAY";
+    MonthEnum["JUNE"] = "JUNE";
+    MonthEnum["JULY"] = "JULY";
+    MonthEnum["AUGUST"] = "AUGUST";
+    MonthEnum["SEPTEMBER"] = "SEPTEMBER";
+    MonthEnum["OCTOBER"] = "OCTOBER";
+    MonthEnum["NOVEMBER"] = "NOVEMBER";
+    MonthEnum["DECEMBER"] = "DECEMBER";
+})(MonthEnum || (MonthEnum = {}));
+
+var OrdinalWeekDayEnum;
+(function (OrdinalWeekDayEnum) {
+    OrdinalWeekDayEnum["FIRST"] = "FIRST";
+    OrdinalWeekDayEnum["SECOND"] = "SECOND";
+    OrdinalWeekDayEnum["THIRD"] = "THIRD";
+    OrdinalWeekDayEnum["FOURTH"] = "FOURTH";
+    OrdinalWeekDayEnum["LAST"] = "LAST";
+})(OrdinalWeekDayEnum || (OrdinalWeekDayEnum = {}));
+
+var RecurrenceEnum;
+(function (RecurrenceEnum) {
+    RecurrenceEnum["DAILY"] = "DAILY";
+    RecurrenceEnum["WEEKLY"] = "WEEKLY";
+    RecurrenceEnum["MONTHLY"] = "MONTHLY";
+    RecurrenceEnum["YEARLY"] = "YEARLY";
+})(RecurrenceEnum || (RecurrenceEnum = {}));
+
+var RepeatWhenEnum;
+(function (RepeatWhenEnum) {
+    RepeatWhenEnum["IN_DAY"] = "IN_DAY";
+    RepeatWhenEnum["IN_ORDINAL_WEEK_DAY"] = "IN_ORDINAL_WEEK_DAY";
+})(RepeatWhenEnum || (RepeatWhenEnum = {}));
+
+var WeekDayEnum;
+(function (WeekDayEnum) {
+    WeekDayEnum["SUNDAY"] = "SUNDAY";
+    WeekDayEnum["MONDAY"] = "MONDAY";
+    WeekDayEnum["TUESDAY"] = "TUESDAY";
+    WeekDayEnum["WEDNESDAY"] = "WEDNESDAY";
+    WeekDayEnum["THURSDAY"] = "THURSDAY";
+    WeekDayEnum["FRIDAY"] = "FRIDAY";
+    WeekDayEnum["SATURDAY"] = "SATURDAY";
+})(WeekDayEnum || (WeekDayEnum = {}));
+
+let ScheduleFormRulesService = class ScheduleFormRulesService {
+    constructor() {
+        this.ngUnsubscribe = new Subject();
+    }
+    recurrencesValueChangeSubscribe(formGroup, formFields) {
+        this.recurrenceValueChangeSubscribe(formGroup, formFields);
+        this.repeatWhenValueChangeSubscribe(formGroup, formFields);
+    }
+    valueChangeSubscribe(formGroup, formFields) {
+        this.allDayValueChangeSubscribe(formGroup, formFields);
+    }
+    allDayValueChangeSubscribe(formGroup, formFields) {
+        formGroup.controls.allDay.valueChanges.pipe(takeUntil(this.ngUnsubscribe)).subscribe((value) => {
+            const fields = ['startTime', 'endTime'];
+            if (value) {
+                this.disableFields(formGroup, formFields, fields);
+            }
+            else {
+                this.enableFields(formGroup, formFields, fields);
+            }
+        });
+    }
+    recurrenceValueChangeSubscribe(formGroup, formFields) {
+        formGroup.controls.recurrence.valueChanges.pipe(takeUntil(this.ngUnsubscribe)).subscribe((value) => {
+            const fieldsToDisable = ['weekDays', 'repeatWhen', 'repeatWhenDay', 'repeatWhenMonth', 'repeatWhenOrdinalWeekDay', 'repeatWhenWeekMonth'];
+            this.disableFields(formGroup, formFields, fieldsToDisable);
+            if (value === RecurrenceEnum.WEEKLY) {
+                const fieldWeekDays = formFields.find((field) => field.name === 'weekDays');
+                fieldWeekDays.visible = () => true;
+                fieldWeekDays.required = () => true;
+                formGroup.controls.weekDays.setValidators([Validators.required]);
+            }
+            if (value === RecurrenceEnum.MONTHLY || value === RecurrenceEnum.YEARLY) {
+                const fieldRepeatWhen = formFields.find((field) => field.name === 'repeatWhen');
+                fieldRepeatWhen.visible = () => true;
+                fieldRepeatWhen.required = () => true;
+                formGroup.controls.repeatWhen.setValidators([Validators.required]);
+                formGroup.controls.repeatWhen.setValue(RepeatWhenEnum.IN_DAY);
+            }
+        });
+    }
+    repeatWhenValueChangeSubscribe(formGroup, formFields) {
+        formGroup.controls.repeatWhen.valueChanges.pipe(takeUntil(this.ngUnsubscribe)).subscribe((value) => {
+            const fieldsToDisable = ['repeatWhenDay', 'repeatWhenOrdinalWeekDay', 'repeatWhenWeekMonth', 'repeatWhenMonth'];
+            this.disableFields(formGroup, formFields, fieldsToDisable);
+            if (value === RepeatWhenEnum.IN_DAY) {
+                const fieldRepeatWhenDay = formFields.find((field) => field.name === 'repeatWhenDay');
+                fieldRepeatWhenDay.visible = () => true;
+                fieldRepeatWhenDay.required = () => true;
+                formGroup.controls.repeatWhenDay.setValidators([Validators.required]);
+            }
+            if (value === RepeatWhenEnum.IN_ORDINAL_WEEK_DAY) {
+                const fieldsToEnable = ['repeatWhenOrdinalWeekDay', 'repeatWhenWeekMonth'];
+                this.enableFields(formGroup, formFields, fieldsToEnable);
+            }
+            if (value !== undefined && formGroup.controls.recurrence.value === RecurrenceEnum.YEARLY) {
+                const fieldRepeatWhenMonth = formFields.find((field) => field.name === 'repeatWhenMonth');
+                fieldRepeatWhenMonth.visible = () => true;
+                fieldRepeatWhenMonth.required = () => true;
+                formGroup.controls.repeatWhenMonth.setValidators([Validators.required]);
+            }
+        });
+    }
+    disableFields(formGroup, formFields, fields) {
+        formFields
+            .filter((field) => fields.includes(field.name))
+            .forEach((field) => {
+            field.visible = () => false;
+            field.required = () => false;
+        });
+        for (const controlsKey in formGroup.controls) {
+            if (fields.includes(controlsKey)) {
+                const fieldFormGroup = formGroup.controls[controlsKey];
+                fieldFormGroup.setValue(undefined);
+                fieldFormGroup.clearValidators();
+                fieldFormGroup.setErrors(null);
+            }
+        }
+    }
+    enableFields(formGroup, formFields, fields) {
+        formFields
+            .filter((field) => fields.includes(field.name))
+            .forEach((field) => {
+            field.visible = () => true;
+            field.required = () => true;
+        });
+        for (const controlsKey in formGroup.controls) {
+            if (fields.includes(controlsKey)) {
+                const fieldFormGroup = formGroup.controls[controlsKey];
+                fieldFormGroup.setValidators([Validators.required]);
+            }
+        }
+    }
+};
+ScheduleFormRulesService = __decorate([
+    Injectable()
+], ScheduleFormRulesService);
+
+let ScheduleFormRulesModule = class ScheduleFormRulesModule {
+};
+ScheduleFormRulesModule = __decorate([
+    NgModule({
+        imports: [],
+        providers: [
+            ScheduleFormRulesService
+        ],
+    })
+], ScheduleFormRulesModule);
+
 let StandardFiltersService = class StandardFiltersService {
     constructor(currentCollaboratorService) {
         this.currentCollaboratorService = currentCollaboratorService;
@@ -495,9 +976,228 @@ StandardFiltersModule = __decorate([
     })
 ], StandardFiltersModule);
 
+class FormGroupValidatorsService {
+    static startDataGreaterThanEndDataValidator(endDateField, errorMessage) {
+        const fn = function (control) {
+            var _a;
+            if (control.parent) {
+                const startDate = new Date(control.value);
+                const endDate = new Date((_a = control.parent.controls[endDateField]) === null || _a === void 0 ? void 0 : _a.value);
+                if (startDate > endDate) {
+                    const rtn = {};
+                    rtn[errorMessage] = true;
+                    return rtn;
+                }
+            }
+            return null;
+        };
+        return fn;
+    }
+    static endDateLessThanStartDateValidator(startDateField, errorMessage) {
+        const fn = function (control) {
+            var _a;
+            if (control.parent) {
+                const startDate = new Date((_a = control.parent.controls[startDateField]) === null || _a === void 0 ? void 0 : _a.value);
+                const endDate = new Date(control.value);
+                if (startDate > endDate) {
+                    const rtn = {};
+                    rtn[errorMessage] = true;
+                    return rtn;
+                }
+            }
+            return null;
+        };
+        return fn;
+    }
+    ;
+}
+
+class DateValidatorsService {
+    static isLastWeekdayOfMonth(date) {
+        const newDate = new Date(date);
+        const day = 7;
+        newDate.setDate(date.getDate() + day);
+        return newDate.getMonth() > date.getMonth() || newDate.getFullYear() > date.getFullYear();
+    }
+}
+
+class Topic {
+    static fromDto(topicDto) {
+        const topic = new Topic();
+        Object.assign(topic, topicDto);
+        return topic;
+    }
+    getTopic(tenantDomain, token) {
+        let topic = '/topic/'.concat(tenantDomain);
+        if (this.allUsers === false) {
+            topic = topic
+                .concat('/')
+                .concat(token);
+        }
+        return topic.concat(this.toString());
+    }
+    toString() {
+        return '/'
+            .concat(this.domain)
+            .concat('/')
+            .concat(this.service)
+            .concat('/')
+            .concat(this.primitive);
+    }
+}
+
+class Event extends Topic {
+    static fromDto(eventDto) {
+        const event = new Event();
+        Object.assign(event, eventDto);
+        return event;
+    }
+    match(event) {
+        return this.toString() === event.toString()
+            && this.originCallback === event.originCallback;
+    }
+}
+
+let WebsocketService = class WebsocketService {
+    constructor(router, storageService) {
+        this.router = router;
+        this.storageService = storageService;
+        this._client = Stomp.over(new SockJS(this.storageService.getBaseUrl().concat('/websocket/subscription')));
+        this._bindQueue = new Subject();
+        this._eventBindingList = [];
+        this._messageQueue = [];
+        this._bindQueue.pipe(concatMap(event => this._bindObservable(event))).subscribe();
+    }
+    bind(eventDto) {
+        eventDto.originCallback = eventDto.originCallback || this.router.url;
+        this._bindQueue.next(Event.fromDto(eventDto));
+    }
+    _bindObservable(event) {
+        return new Observable(observer => {
+            if (this._client.connected) {
+                this._registerBind(event);
+                this._finishBindObservable(observer);
+            }
+            else {
+                this._connectClient(event, observer);
+            }
+        });
+    }
+    _finishBindObservable(observer) {
+        observer.next();
+        observer.complete();
+    }
+    _connectClient(event, observer) {
+        this._client.connect({}, () => {
+            this._registerBind(event);
+            this._finishBindObservable(observer);
+        }, () => observer.error(new Error('Websocket connection error!')));
+    }
+    _registerBind(event) {
+        const eventBinding = this._findEventBinding(event);
+        if (eventBinding) {
+            this._remakeBind(event, eventBinding);
+        }
+        else {
+            this._makeBind(event);
+        }
+    }
+    _remakeBind(event, eventBinding) {
+        eventBinding.callback = event.callback;
+        this._messageQueue
+            .filter(messageQueue => messageQueue.event.match(event))
+            .forEach(messageQueue => this._executeCallback(messageQueue.message, event));
+    }
+    _makeBind(event) {
+        this._eventBindingList.push(event);
+        this._client.subscribe(event.getTopic(this.storageService.getTenantDomain(), this.storageService.getToken()), (message) => this._executeCallback(message, event));
+    }
+    _executeCallback(message, event) {
+        const eventBinding = this._findEventBinding(event);
+        if (eventBinding.originCallback === this.router.url) {
+            this._findEventBinding(event).callback(this._resolveRefs(JSON.parse(message.body).data));
+        }
+        else {
+            this._messageQueue
+                .filter(messageQueue => messageQueue.event.match(event))
+                .forEach((messageQueue, index) => this._messageQueue.splice(index, 1));
+            this._messageQueue.push({ message, event });
+        }
+    }
+    _findEventBinding(event) {
+        return this._eventBindingList.find(eventBinding => eventBinding.match(event));
+    }
+    _resolveRefs(payload) {
+        const resolve = (obj, rootObj) => {
+            if (Array.isArray(obj)) {
+                obj.forEach(item => resolve(item, rootObj));
+            }
+            if (obj !== null && typeof obj === 'object') {
+                Object.keys(obj).forEach(key => {
+                    if (key === '$ref' && obj[key]) {
+                        const refPath = obj[key]; // Caminho da referência
+                        Object.assign(obj, getDataFromRef(refPath, rootObj));
+                        delete obj[key];
+                    }
+                    else {
+                        resolve(obj[key], rootObj);
+                    }
+                });
+            }
+        };
+        const getDataFromRef = (ref, rootObj) => {
+            const regex = /\["(.*?)"\]/g;
+            const result = [];
+            let match;
+            while ((match = regex.exec(ref)) !== null) {
+                result.push(match[1]);
+            }
+            return result.reduce((acc, part) => acc && acc[part], rootObj);
+        };
+        resolve(payload, payload);
+        return payload;
+    }
+};
+WebsocketService.ctorParameters = () => [
+    { type: Router },
+    { type: StorageService }
+];
+WebsocketService.ɵprov = ɵɵdefineInjectable({ factory: function WebsocketService_Factory() { return new WebsocketService(ɵɵinject(Router), ɵɵinject(StorageService)); }, token: WebsocketService, providedIn: "root" });
+WebsocketService = __decorate([
+    Injectable({
+        providedIn: 'root',
+    })
+], WebsocketService);
+
+let WebsocketModule = class WebsocketModule {
+};
+WebsocketModule = __decorate([
+    NgModule({
+        imports: [
+            RouterModule,
+        ],
+        providers: [
+            WebsocketService,
+        ]
+    })
+], WebsocketModule);
+
+class StringConverterService {
+    static toUnderscore(camelCase) {
+        const regex = /([a-z])([A-Z])/g;
+        return camelCase.replace(regex, '$1_$2').toLowerCase();
+    }
+}
+
+class ValueChangesService {
+    static pipeDefault(control) {
+        return control.valueChanges.pipe(distinctUntilChanged());
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { Collaborator, CollaboratorE070FilCrmx, CollaboratorSquad, CurrentCollaboratorModule, CurrentCollaboratorService, DateValidatorsService, E070Emp, E070Fil, E070FilCrmx, FormGroupValidatorsService, Squad, StandardFiltersModule, StandardFiltersService, StorageService, StringConverterService, User, WebsocketService, CurrentCollaboratorModule as ɵa, CurrentCollaboratorService as ɵb };
+export { Collaborator, CollaboratorE070FilCrmx, CollaboratorSquad, CurrentCollaboratorModule, CurrentCollaboratorService, DateValidatorsService, E070Emp, E070Fil, E070FilCrmx, Event, FormGroupValidatorsService, FormatEnum, MonthEnum, OrdinalWeekDayEnum, RecurrenceEnum, RefreshWebsocketAlertComponent, RefreshWebsocketAlertModule, RepeatWhenEnum, ReportsComponent, ReportsModule, ReportsService, ScheduleFormRulesModule, ScheduleFormRulesService, Squad, StandardFiltersModule, StandardFiltersService, StorageService, StringConverterService, Topic, User, ValueChangesService, ViewModeEnum, WebsocketModule, WebsocketService, WeekDayEnum, fallback, StorageModule as ɵa, CurrentCollaboratorModule as ɵb, CurrentCollaboratorService as ɵc };
 //# sourceMappingURL=senior-gestao-relacionamento-angular-components.js.map