@gipisistemas/ng-core 1.1.0 → 1.1.2

package/core/utils/object.util.d.ts

@@ -0,0 +1,20 @@
+import { GIPIIndexableObject } from '../types/ng-class.type';
+/** @dynamic */
+export declare class ObjectUtil {
+    static isNull(value: Object): boolean;
+    static isNewModel(value: Object): boolean;
+    static isNotNil<T>(value: T): value is NonNullable<T>;
+    static isNil(value: unknown): value is null | undefined;
+    static clone(value: Object): any;
+    static resolveFieldData(data: any, field: any): any;
+    static isFunction(obj: any): boolean;
+    static equals(obj1: any, obj2: any, field?: string): boolean;
+    static equalsByValue(obj1: any, obj2: any): boolean;
+    static removeAccents(str: any): any;
+    static merge(obj1?: any, obj2?: any): any;
+    /**
+     * Examine se dois objetos são superficialmente igualados.
+     */
+    static shallowEqual(objA?: GIPIIndexableObject, objB?: GIPIIndexableObject): boolean;
+    static hasPropertyInObj(obj: Object, property: string): boolean;
+}

package/core/utils/password.util.d.ts

@@ -0,0 +1,11 @@
+/** @dynamic */
+export declare class PasswordUtil {
+    static isValid(password: string): boolean;
+    static isValidMinLength(password: string): boolean;
+    static isValidMaxLength(password: string): boolean;
+    static hasUppercase(password: string): boolean;
+    static hasLowercase(password: string): boolean;
+    static hasNumber(password: string): boolean;
+    static hasSpecialChar(password: string): boolean;
+    static hasBackspace(password: string): boolean;
+}

package/core/utils/phone.util.d.ts

@@ -0,0 +1,13 @@
+import * as libPhone from 'libphonenumber-js';
+/** @dynamic */
+export declare class PhoneUtil {
+    static removeCharacters(value: string): string;
+    static maskLib(phoneNumber: string, state?: libPhone.Examples, country?: libPhone.CountryCode): string;
+    static formatLib(phoneNumber: string, country?: libPhone.CountryCode): string;
+    static format(number: string, mask?: string): string;
+    static mask(phone: string): string;
+    static isPossible(phoneNumber: string, country?: libPhone.CountryCode): boolean;
+    static isValid(phoneNumber: string, country?: libPhone.CountryCode): boolean;
+    static getType(phoneNumber: string, country?: libPhone.CountryCode): libPhone.NumberType | null;
+    static isEqual(phoneNumber1: string, phoneNumber2: string, country?: libPhone.CountryCode): boolean;
+}

package/core/utils/string.util.d.ts

@@ -0,0 +1,9 @@
+/** @dynamic */
+export declare class StringUtil {
+    static EMPTY: string;
+    static replaceAccents(value: string): string;
+    static removeAccents(value: string): string;
+    static isEmpty(value: string): boolean;
+    static format(value: string, mask: string): string;
+    static truncateWithEllipses(text: string, max: number): '' | '...';
+}

package/core/utils/table-column-builder.d.ts

@@ -0,0 +1,40 @@
+import { TemplateRef } from '@angular/core';
+import { AbstractModel } from '../models/abstract.model';
+import { TableColumnDTO } from '../models/dto/table-column.dto';
+import { BreakpointObserverService } from '../services/breakpoint-observer.service';
+/** @dynamic */
+export declare class TableColumnBuilder {
+    private name$;
+    private property$;
+    private value$;
+    private sortable$;
+    private hiddenSm$;
+    private visible$;
+    private width$;
+    private marginLeft$;
+    private marginRight$;
+    private align$;
+    private template$;
+    private templateHeader$;
+    private sliceLength$;
+    private action$;
+    private breakpointObserverService$;
+    constructor(breakpointObserverService?: BreakpointObserverService);
+    static instance(breakpointObserverService?: BreakpointObserverService): TableColumnBuilder;
+    name(name: any): TableColumnBuilder;
+    property(property: any): TableColumnBuilder;
+    value(value: any): TableColumnBuilder;
+    sortable(sortable: boolean): TableColumnBuilder;
+    hiddenSm(hiddenSm: boolean): TableColumnBuilder;
+    visible(visible: boolean): TableColumnBuilder;
+    width(width: number | string): TableColumnBuilder;
+    marginLeft(marginLeft: number | string): TableColumnBuilder;
+    marginRight(marginRight: number | string): TableColumnBuilder;
+    align(align: string): TableColumnBuilder;
+    breakpointWidth(breakpointMap: Map<string, string | number>): TableColumnBuilder;
+    template(template: TemplateRef<any>): TableColumnBuilder;
+    templateHeader(templateHeader: TemplateRef<any>): TableColumnBuilder;
+    sliceLength(sliceLength: number): TableColumnBuilder;
+    action(action: (obj: AbstractModel) => void): TableColumnBuilder;
+    build(): TableColumnDTO;
+}

package/core/utils/time.util.d.ts

@@ -0,0 +1,9 @@
+import { LocalTimeType } from '../enums/local-time.enum';
+import { GIPILocalTime } from '../types/local-time.type';
+/** @dynamic */
+export declare class TimeUtil {
+    static TIME_FORMAT: string;
+    static format(time: GIPILocalTime | Date, format: LocalTimeType | string, period?: boolean): string;
+    private static _formatDate;
+    private static _padToAnyDigits;
+}

package/core/utils/url-params.util.d.ts

@@ -0,0 +1,7 @@
+/** @dynamic */
+export declare class URLParamsUtil {
+    /** @Internal */
+    private static _queryParams;
+    static get(param: string): any;
+    static has(param: string): boolean;
+}

package/core/utils/uuid.util.d.ts

@@ -0,0 +1,5 @@
+import { GIPIUuid } from '../gipi-components/types/uuid.type';
+/** @dynamic */
+export declare class UUIDUtil {
+    static isValid(id: GIPIUuid): boolean;
+}

package/core/utils/zindex.util.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    get: (el: any) => number;
+    set: (key: any, el: any, baseZIndex: any) => void;
+    clear: (el: any) => void;
+    getCurrent: () => any;
+};
+export default _default;

package/core.d.ts

@@ -0,0 +1,88 @@
+export * from './core/app-messages';
+export * from './core/app.messages';
+export * from './core/components/abstract-crud.component';
+export * from './core/components/abstract-find.component';
+export * from './core/components/abstract.component';
+export * from './core/components/alert/alert.component';
+export * from './core/core.module';
+export * from './core/enums/local-time.enum';
+export * from './core/guards/auth.guard';
+export * from './core/guards/permission.guard';
+export * from './core/guards/public.guard';
+export * from './core/interceptors/auth.interceptor';
+export * from './core/interceptors/error.interceptor';
+export * from './core/models/abstract.model';
+export * from './core/models/archive.model';
+export * from './core/models/base-user.model';
+export * from './core/models/dto/abstract.dto';
+export * from './core/models/dto/chart.dto';
+export * from './core/models/dto/confirmation.dto';
+export * from './core/models/dto/dialog.dto';
+export * from './core/models/dto/filter.dto';
+export * from './core/models/dto/input-listbox.dto';
+export * from './core/models/dto/menu.dto';
+export * from './core/models/dto/message.dto';
+export * from './core/models/dto/page.dto';
+export * from './core/models/dto/sort.dto';
+export * from './core/models/dto/tab.dto';
+export * from './core/models/dto/table-column.dto';
+export * from './core/models/dto/token.dto';
+export * from './core/models/enums/criteria-operation.enum';
+export * from './core/models/enums/criteria-sort-direction.enum';
+export * from './core/models/enums/menu-type.enum';
+export * from './core/models/enums/radio-button.enum';
+export * from './core/models/enums/sort-direction.enum';
+export * from './core/models/multitenant.model';
+export * from './core/models/permission.model';
+export * from './core/models/role.model';
+export * from './core/pipes/local-time.pipe';
+export * from './core/services/abstract-crud.service';
+export * from './core/services/abstract-find.service';
+export * from './core/services/abstract.service';
+export * from './core/services/authentication.service';
+export * from './core/services/breakpoint-observer.service';
+export * from './core/services/confirmation.service';
+export * from './core/services/dialog.service';
+export * from './core/services/message.service';
+export * from './core/services/nav.service';
+export * from './core/services/svg-register.service';
+export * from './core/types/local-time.type';
+export * from './core/utils/array.util';
+export * from './core/utils/browser.util';
+export * from './core/utils/currency.util';
+export * from './core/utils/date.util';
+export * from './core/utils/document.util';
+export * from './core/utils/email.util';
+export * from './core/utils/number.util';
+export * from './core/utils/object.util';
+export * from './core/utils/password.util';
+export * from './core/utils/phone.util';
+export * from './core/utils/string.util';
+export * from './core/utils/table-column-builder';
+export * from './core/utils/time.util';
+export * from './core/utils/url-params.util';
+export * from './core/utils/uuid.util';
+export * from './core/utils/zindex.util';
+export * from './core/custom-breakpoints';
+export * from './core/gipi-components/components/abstract-crud.component';
+export * from './core/gipi-components/components/abstract-find.component';
+export * from './core/gipi-components/components/abstract.component';
+export * from './core/gipi-components/decorators/autowired.decorator';
+export * from './core/gipi-components/enums/sort-direction.enum';
+export * from './core/gipi-components/interface/abstract-crud.interface';
+export * from './core/gipi-components/interface/abstract-find.interface';
+export * from './core/gipi-components/interface/abstract.interface';
+export * from './core/gipi-components/models/abstract-filter.model';
+export * from './core/gipi-components/models/abstract.model';
+export * from './core/gipi-components/models/applied-filter.model';
+export * from './core/gipi-components/models/dto/abstract.dto';
+export * from './core/gipi-components/models/page-event.model';
+export * from './core/gipi-components/models/page.model';
+export * from './core/gipi-components/models/sort.model';
+export * from './core/gipi-components/services/abstract-crud.service';
+export * from './core/gipi-components/services/abstract.service';
+export * from './core/gipi-components/services/base.service';
+export * from './core/gipi-components/services/file.service';
+export * from './core/gipi-components/services/session-storage.service';
+export * from './core/gipi-components/types/generic.type';
+export * from './core/gipi-components/types/uuid.type';

package/esm2015/core/app-messages.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLW1lc3NhZ2VzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9hcHAtbWVzc2FnZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQXBwTWVzc2FnZXMge1xuICAgIFNVQ0NFU1M6IHN0cmluZztcbiAgICBSRVRVUk5fQ09ORklSTUFUSU9OOiBzdHJpbmc7XG4gICAgREVMRVRFX0NPTkZJUk1BVElPTjogc3RyaW5nO1xuICAgIERFTEVURV9BTExfQ09ORklSTUFUSU9OOiBzdHJpbmc7XG4gICAgQlVUVE9OX09LX0NPTkZJUk1BVElPTjogc3RyaW5nO1xuICAgIEJVVFRPTl9DQU5DRUxfQ09ORklSTUFUSU9OOiBzdHJpbmc7XG4gICAgTk9UX1BFUk1JU1NJT046IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/core/app.messages.js

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+export const APP_MESSAGES = new InjectionToken('app.messages');
+export const DEFAULT_MESSAGES = {
+    SUCCESS: 'Operação realizada com sucesso',
+    RETURN_CONFIRMATION: 'Deseja retornar para à tela de consulta?',
+    DELETE_CONFIRMATION: 'Deseja realmente excluir este registro?',
+    DELETE_ALL_CONFIRMATION: 'Deseja realmente excluir os registros selecionados?',
+    BUTTON_OK_CONFIRMATION: 'OK',
+    BUTTON_CANCEL_CONFIRMATION: 'Cancelar',
+    NOT_PERMISSION: 'Infelizmente, esta ação não é permitida para o seu perfil',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLm1lc3NhZ2VzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9hcHAubWVzc2FnZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUkvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWMsY0FBYyxDQUFDLENBQUM7QUFFNUUsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQWdCO0lBQ3pDLE9BQU8sRUFBRSxnQ0FBZ0M7SUFDekMsbUJBQW1CLEVBQUUsMENBQTBDO0lBQy9ELG1CQUFtQixFQUFFLHlDQUF5QztJQUM5RCx1QkFBdUIsRUFBRSxxREFBcUQ7SUFDOUUsc0JBQXNCLEVBQUUsSUFBSTtJQUM1QiwwQkFBMEIsRUFBRSxVQUFVO0lBQ3RDLGNBQWMsRUFBRSwyREFBMkQ7Q0FDOUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEFwcE1lc3NhZ2VzIH0gZnJvbSAnLi9hcHAtbWVzc2FnZXMnO1xuXG5leHBvcnQgY29uc3QgQVBQX01FU1NBR0VTID0gbmV3IEluamVjdGlvblRva2VuPEFwcE1lc3NhZ2VzPignYXBwLm1lc3NhZ2VzJyk7XG5cbmV4cG9ydCBjb25zdCBERUZBVUxUX01FU1NBR0VTOiBBcHBNZXNzYWdlcyA9IHtcbiAgICBTVUNDRVNTOiAnT3BlcmHDp8OjbyByZWFsaXphZGEgY29tIHN1Y2Vzc28nLFxuICAgIFJFVFVSTl9DT05GSVJNQVRJT046ICdEZXNlamEgcmV0b3JuYXIgcGFyYSDDoCB0ZWxhIGRlIGNvbnN1bHRhPycsXG4gICAgREVMRVRFX0NPTkZJUk1BVElPTjogJ0Rlc2VqYSByZWFsbWVudGUgZXhjbHVpciBlc3RlIHJlZ2lzdHJvPycsXG4gICAgREVMRVRFX0FMTF9DT05GSVJNQVRJT046ICdEZXNlamEgcmVhbG1lbnRlIGV4Y2x1aXIgb3MgcmVnaXN0cm9zIHNlbGVjaW9uYWRvcz8nLFxuICAgIEJVVFRPTl9PS19DT05GSVJNQVRJT046ICdPSycsXG4gICAgQlVUVE9OX0NBTkNFTF9DT05GSVJNQVRJT046ICdDYW5jZWxhcicsXG4gICAgTk9UX1BFUk1JU1NJT046ICdJbmZlbGl6bWVudGUsIGVzdGEgYcOnw6NvIG7Do28gw6kgcGVybWl0aWRhIHBhcmEgbyBzZXUgcGVyZmlsJyxcbn07XG4iXX0=

package/esm2015/core/components/abstract-crud.component.js

@@ -0,0 +1,97 @@
+import { __decorate, __metadata } from "tslib";
+import { EventEmitter, Input, Output } from '@angular/core';
+import { INJECTOR } from '../../shared/shared.module';
+import { APP_MESSAGES } from '../app.messages';
+import { AbstractFindComponent } from './abstract-find.component';
+export class AbstractCrudComponent extends AbstractFindComponent {
+    constructor(service, messageService, confirmationService, router, activatedRoute) {
+        super(service, messageService, confirmationService, router, activatedRoute);
+        this.service = service;
+        this.messageService = messageService;
+        this.confirmationService = confirmationService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.entityChange = new EventEmitter(true);
+    }
+    get entity() {
+        return this.entityValue;
+    }
+    set entity(entity) {
+        this.entityValue = entity;
+        this.entityChange.emit(this.entityValue);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.entity = this.newEntity();
+        this.initializeForm();
+    }
+    save(edit, filter) {
+        try {
+            this.loading = true;
+            this.loadingChange.emit(this.loading);
+            if (filter) {
+                this.page = this.newPage();
+            }
+            this.preSave();
+            this.service.save(this.entity).subscribe(entity => {
+                this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);
+                if (edit) {
+                    this.edit(entity);
+                }
+                else if (filter) {
+                    this.find();
+                }
+                else {
+                    this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(() => this.router.navigate([this.getPath()]));
+                }
+            }, error => this.handleError(error));
+        }
+        catch (e) {
+            this.handleError(e);
+        }
+    }
+    preSave() { }
+    return() {
+        if (this.isViewing()) {
+            this.router.navigateByUrl(this.service.returnPath, { skipLocationChange: true })
+                .then(() => this.router.navigate([this.service.returnPath]));
+        }
+        else {
+            this.confirmationService.confirm({
+                title: 'Confirmação',
+                message: INJECTOR.get(APP_MESSAGES).RETURN_CONFIRMATION,
+                accept: () => this.router.navigateByUrl(this.service.returnPath, { skipLocationChange: true })
+                    .then(() => this.router.navigate([this.service.returnPath]))
+            });
+        }
+    }
+    initializeForm() {
+        this.loading = true;
+        this.loadingChange.emit(this.loading);
+        const id = this.activatedRoute.snapshot.params.id;
+        if (id) {
+            this.service.getOne(id).subscribe(entity => {
+                this.entity = entity;
+                this.afterInitializeForm();
+                this.loading = false;
+                this.loadingChange.emit(this.loading);
+            }, error => this.handleError(error));
+        }
+        else {
+            this.entity = this.newEntity();
+            this.loading = false;
+            this.loadingChange.emit(this.loading);
+        }
+    }
+    afterInitializeForm() { }
+}
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], AbstractCrudComponent.prototype, "entityChange", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], AbstractCrudComponent.prototype, "entity", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-crud.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/components/abstract-crud.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AAGpE,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAM/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,OAAgB,qBAAoE,SAAQ,qBAA2B;IAYzH,YACc,OAAkC,EAClC,cAA8B,EAC9B,mBAAwC,EACxC,MAAc,EACd,cAA8B;QAExC,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;QANlE,YAAO,GAAP,OAAO,CAA2B;QAClC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,WAAM,GAAN,MAAM,CAAQ;QACd,mBAAc,GAAd,cAAc,CAAgB;QAdlC,iBAAY,GAAoB,IAAI,YAAY,CAAI,IAAI,CAAC,CAAC;IAiBpE,CAAC;IAhBQ,IAAI,MAAM;QACf,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IACD,IAAI,MAAM,CAAC,MAAS;QAChB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC;IAYD,QAAQ;QACJ,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC/B,IAAI,CAAC,cAAc,EAAE,CAAC;IAC1B,CAAC;IAED,IAAI,CAAC,IAAc,EAAE,MAAgB;QACjC,IAAI;YACA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtC,IAAI,MAAM,EAAE;gBACR,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;aAC9B;YACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;gBAC9C,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC;gBAC3D,IAAI,IAAI,EAAE;oBACN,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;iBACrB;qBAAM,IAAI,MAAM,EAAE;oBACf,IAAI,CAAC,IAAI,EAAE,CAAC;iBACf;qBAAM;oBACH,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;iBAC9H;YACL,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;SACxC;QAAC,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;SACvB;IACL,CAAC;IAED,OAAO,KAAW,CAAC;IAEnB,MAAM;QACF,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;YAClB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;iBAC3E,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;SACpE;aAAM;YACH,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;gBAC7B,KAAK,EAAE,aAAa;gBACpB,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,mBAAmB;gBACvD,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;qBACzF,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;aACnE,CAAC,CAAC;SACN;IACL,CAAC;IAIS,cAAc;QACpB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtC,MAAM,EAAE,GAAoB,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACnE,IAAI,EAAE,EAAE;YACJ,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;gBACvC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;gBACrB,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1C,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;SACxC;aAAM;YACH,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACzC;IACL,CAAC;IAEM,mBAAmB,KAAW,CAAC;CAEzC;AAtFa;IAAT,MAAM,EAAE;8BAAe,YAAY;2DAAgC;AAC3D;IAAR,KAAK,EAAE;;;mDAEP","sourcesContent":["import { EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { INJECTOR } from '../../shared/shared.module';\nimport { APP_MESSAGES } from '../app.messages';\nimport { AbstractModel } from '../models/abstract.model';\nimport { FilterDTO } from '../models/dto/filter.dto';\nimport { AbstractCrudService } from '../services/abstract-crud.service';\nimport { ConfirmationService } from '../services/confirmation.service';\nimport { MessageService } from '../services/message.service';\nimport { AbstractFindComponent } from './abstract-find.component';\n\nexport abstract class AbstractCrudComponent<T extends AbstractModel, F extends FilterDTO> extends AbstractFindComponent<T, F> implements OnInit {\n\n    entityValue: T;\n    @Output() entityChange: EventEmitter<T> = new EventEmitter<T>(true);\n    @Input() get entity(): T {\n        return this.entityValue;\n    }\n    set entity(entity: T) {\n        this.entityValue = entity;\n        this.entityChange.emit(this.entityValue);\n    }\n\n    constructor(\n        protected service: AbstractCrudService<T, F>,\n        protected messageService: MessageService,\n        protected confirmationService: ConfirmationService,\n        protected router: Router,\n        protected activatedRoute: ActivatedRoute\n    ) {\n        super(service, messageService, confirmationService, router, activatedRoute);\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this.entity = this.newEntity();\n        this.initializeForm();\n    }\n\n    save(edit?: boolean, filter?: boolean): void {\n        try {\n            this.loading = true;\n            this.loadingChange.emit(this.loading);\n            if (filter) {\n                this.page = this.newPage();\n            }\n            this.preSave();\n            this.service.save(this.entity).subscribe(entity => {\n                this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);\n                if (edit) {\n                    this.edit(entity);\n                } else if (filter) {\n                    this.find();\n                } else {\n                    this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(() => this.router.navigate([this.getPath()]));\n                }\n            }, error => this.handleError(error));\n        } catch (e) {\n            this.handleError(e);\n        }\n    }\n\n    preSave(): void { }\n\n    return(): void {\n        if (this.isViewing()) {\n            this.router.navigateByUrl(this.service.returnPath, { skipLocationChange: true })\n                .then(() => this.router.navigate([this.service.returnPath]));\n        } else {\n            this.confirmationService.confirm({\n                title: 'Confirmação',\n                message: INJECTOR.get(APP_MESSAGES).RETURN_CONFIRMATION,\n                accept: () => this.router.navigateByUrl(this.service.returnPath, { skipLocationChange: true })\n                    .then(() => this.router.navigate([this.service.returnPath]))\n            });\n        }\n    }\n\n    protected abstract newEntity(): T;\n\n    protected initializeForm(): void {\n        this.loading = true;\n        this.loadingChange.emit(this.loading);\n        const id: number | string = this.activatedRoute.snapshot.params.id;\n        if (id) {\n            this.service.getOne(id).subscribe(entity => {\n                this.entity = entity;\n                this.afterInitializeForm();\n                this.loading = false;\n                this.loadingChange.emit(this.loading);\n            }, error => this.handleError(error));\n        } else {\n            this.entity = this.newEntity();\n            this.loading = false;\n            this.loadingChange.emit(this.loading);\n        }\n    }\n\n    public afterInitializeForm(): void { }\n\n}\n"]}

package/esm2015/core/components/abstract-find.component.js

@@ -0,0 +1,189 @@
+import { INJECTOR } from '../../shared/shared.module';
+import { APP_MESSAGES } from '../app.messages';
+import { PageDTO } from '../models/dto/page.dto';
+import { SortDTO } from '../models/dto/sort.dto';
+import { SortDirectionEnum } from '../models/enums/sort-direction.enum';
+import { ObjectUtil } from '../utils/object.util';
+import { StringUtil } from '../utils/string.util';
+import { AbstractComponent } from './abstract.component';
+export class AbstractFindComponent extends AbstractComponent {
+    constructor(service, messageService, confirmationService, router, activatedRoute) {
+        super(messageService, router, activatedRoute);
+        this.service = service;
+        this.messageService = messageService;
+        this.confirmationService = confirmationService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.service.returnPath = this.getPath();
+        this.page = this.newPage();
+        this.filter = this.newFilterDTO();
+        this.getFilterDTOSessionStorage();
+        this.columns = this.createTableColumns();
+    }
+    new() {
+        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(() => this.router.navigate([this.getPath(), 'new']));
+    }
+    edit(entity) {
+        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(() => this.router.navigate([this.getPath(), 'edit', entity.id]));
+    }
+    view(entity) {
+        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(() => this.router.navigate([this.getPath(), 'view', entity.id]));
+    }
+    delete(entity, filter) {
+        this.confirmationService.confirm({
+            title: 'Confirmação',
+            message: INJECTOR.get(APP_MESSAGES).DELETE_CONFIRMATION,
+            accept: () => {
+                try {
+                    this.loading = true;
+                    this.loadingChange.emit(this.loading);
+                    this.page = this.newPage();
+                    this.preDelete();
+                    this.service.delete(entity.id).subscribe(() => {
+                        if (filter) {
+                            this.find();
+                        }
+                        else {
+                            this.new();
+                            this.loading = false;
+                            this.loadingChange.emit(this.loading);
+                        }
+                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);
+                    }, error => {
+                        if (this.isFinding()) {
+                            this.clear();
+                        }
+                        this.handleError(error);
+                    });
+                }
+                catch (e) {
+                    this.handleError(e);
+                }
+            }
+        });
+    }
+    deleteAll(entityList, filter) {
+        this.confirmationService.confirm({
+            title: 'Confirmação',
+            message: INJECTOR.get(APP_MESSAGES).DELETE_ALL_CONFIRMATION,
+            accept: () => {
+                try {
+                    this.loading = true;
+                    this.loadingChange.emit(this.loading);
+                    this.page = this.newPage();
+                    this.preDelete();
+                    this.service.deleteAll(entityList).subscribe(() => {
+                        if (filter) {
+                            this.find();
+                        }
+                        else {
+                            this.new();
+                            this.loading = false;
+                            this.loadingChange.emit(this.loading);
+                        }
+                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);
+                    }, error => {
+                        if (this.isFinding()) {
+                            this.clear();
+                        }
+                        this.handleError(error);
+                    });
+                }
+                catch (e) {
+                    this.handleError(e);
+                }
+            }
+        });
+    }
+    updateStatus(entity, enabled) {
+        this.confirmationService.confirm({
+            title: 'Confirmação',
+            message: `Deseja realmente ${enabled ? 'ativar' : 'inativar'} este registro?`,
+            accept: () => {
+                try {
+                    this.loading = true;
+                    this.loadingChange.emit(this.loading);
+                    this.service.save(entity).subscribe(() => {
+                        this.clear();
+                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);
+                    }, error => {
+                        this.clear();
+                        this.handleError(error);
+                    });
+                }
+                catch (e) {
+                    this.handleError(e);
+                }
+            },
+            cancel: () => this.clear()
+        });
+    }
+    preDelete() {
+    }
+    clear() {
+        this.page = this.newPage();
+        this.filter = this.newFilterDTO();
+        this.find();
+    }
+    getPath() {
+        return `${this.activatedRoute.snapshot.parent.parent.url[0].path}/${this.activatedRoute.snapshot.parent.url[0].path}`;
+    }
+    newPage() {
+        return new PageDTO();
+    }
+    newFilterDTO() {
+        return null;
+    }
+    getFilterDTOSessionStorage() {
+        return Promise.resolve();
+    }
+    createTableColumns() {
+        return [];
+    }
+    createSorts() {
+        return [];
+    }
+    find(pageEvent) {
+        this.loading = true;
+        this.loadingChange.emit(this.loading);
+        this.page = this.newPage();
+        if (ObjectUtil.isNull(this.filter)) {
+            this.filter = this.newFilterDTO();
+        }
+        if (ObjectUtil.isNull(pageEvent) && !ObjectUtil.isNull(this.tablePageEventDTO)) {
+            pageEvent = this.tablePageEventDTO;
+        }
+        if (pageEvent) {
+            this.tablePageEventDTO = pageEvent;
+            this.filter.pageNumber = pageEvent.pageIndex;
+            this.filter.pageSize = pageEvent.pageSize;
+            this.filter.offset = pageEvent.pageIndex * pageEvent.pageSize;
+            if (pageEvent.sort) {
+                this.filter.sorts = [new SortDTO(pageEvent.sort.active, StringUtil.isEmpty(pageEvent.sort.direction) ? SortDirectionEnum.DESC : pageEvent.sort.direction.toUpperCase())];
+            }
+        }
+        else {
+            this.filter.pageNumber = 0;
+            this.filter.offset = 0;
+            this.filter.pageSize = 10;
+        }
+        this.service.find(this.filter).subscribe(page => {
+            this.page = page;
+            this.loading = false;
+            this.loadingChange.emit(this.loading);
+        }, error => this.handleError(error));
+    }
+    isFinding() {
+        return this.router.url.split('/').filter(path => path === 'new' || path === 'edit').length === 0;
+    }
+    isViewing() {
+        return this.router.url.split('/').filter(path => path === 'view').length > 0;
+    }
+    isCreating() {
+        return this.router.url.split('/').filter(path => path === 'new').length > 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-find.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/components/abstract-find.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OnInit } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { INJECTOR } from '../../shared/shared.module';\nimport { APP_MESSAGES } from '../app.messages';\nimport { AbstractModel } from '../models/abstract.model';\nimport { FilterDTO } from '../models/dto/filter.dto';\nimport { PageDTO } from '../models/dto/page.dto';\nimport { SortDTO } from '../models/dto/sort.dto';\nimport { TableColumnDTO } from '../models/dto/table-column.dto';\nimport { TablePageEventDTO } from '../models/dto/table-page-event.dto';\nimport { SortDirectionEnum } from '../models/enums/sort-direction.enum';\nimport { AbstractCrudService } from '../services/abstract-crud.service';\nimport { ConfirmationService } from '../services/confirmation.service';\nimport { MessageService } from '../services/message.service';\nimport { ObjectUtil } from '../utils/object.util';\nimport { StringUtil } from '../utils/string.util';\nimport { AbstractComponent } from './abstract.component';\n\nexport abstract class AbstractFindComponent<T extends AbstractModel, F extends FilterDTO> extends AbstractComponent implements OnInit {\n\n    filter: F;\n\n    page: PageDTO<T>;\n\n    columns: TableColumnDTO[];\n\n    tablePageEventDTO: TablePageEventDTO;\n\n    constructor(\n        protected service: AbstractCrudService<T, F>,\n        protected messageService: MessageService,\n        protected confirmationService: ConfirmationService,\n        protected router: Router,\n        protected activatedRoute: ActivatedRoute,\n    ) {\n        super(messageService, router, activatedRoute);\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this.service.returnPath = this.getPath();\n        this.page = this.newPage();\n        this.filter = this.newFilterDTO();\n        this.getFilterDTOSessionStorage();\n        this.columns = this.createTableColumns();\n    }\n\n    new(): void {\n        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(\n            () => this.router.navigate([this.getPath(), 'new'])\n        );\n    }\n\n    edit(entity: T): void {\n        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(\n            () => this.router.navigate([this.getPath(), 'edit', entity.id])\n        );\n    }\n\n    view(entity: T): void {\n        this.router.navigateByUrl(this.getPath(), { skipLocationChange: true }).then(\n            () => this.router.navigate([this.getPath(), 'view', entity.id])\n        );\n    }\n\n    delete(entity: T, filter?: boolean): void {\n        this.confirmationService.confirm({\n            title: 'Confirmação',\n            message: INJECTOR.get(APP_MESSAGES).DELETE_CONFIRMATION,\n            accept: () => {\n                try {\n                    this.loading = true;\n                    this.loadingChange.emit(this.loading);\n                    this.page = this.newPage();\n                    this.preDelete();\n                    this.service.delete(entity.id).subscribe(() => {\n                        if (filter) {\n                            this.find();\n                        } else {\n                            this.new();\n                            this.loading = false;\n                            this.loadingChange.emit(this.loading);\n                        }\n                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);\n                    }, error => {\n                        if (this.isFinding()) {\n                            this.clear();\n                        }\n                        this.handleError(error);\n                    });\n                } catch (e) {\n                    this.handleError(e);\n                }\n            }\n        });\n    }\n\n    deleteAll(entityList: T[], filter?: boolean): void {\n        this.confirmationService.confirm({\n            title: 'Confirmação',\n            message: INJECTOR.get(APP_MESSAGES).DELETE_ALL_CONFIRMATION,\n            accept: () => {\n                try {\n                    this.loading = true;\n                    this.loadingChange.emit(this.loading);\n                    this.page = this.newPage();\n                    this.preDelete();\n                    this.service.deleteAll(entityList).subscribe(() => {\n                        if (filter) {\n                            this.find();\n                        } else {\n                            this.new();\n                            this.loading = false;\n                            this.loadingChange.emit(this.loading);\n                        }\n                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);\n                    }, error => {\n                        if (this.isFinding()) {\n                            this.clear();\n                        }\n                        this.handleError(error);\n                    });\n                } catch (e) {\n                    this.handleError(e);\n                }\n            }\n        });\n    }\n\n    updateStatus(entity: T, enabled: boolean): void {\n        this.confirmationService.confirm({\n            title: 'Confirmação',\n            message: `Deseja realmente ${enabled ? 'ativar' : 'inativar'} este registro?`,\n            accept: () => {\n                try {\n                    this.loading = true;\n                    this.loadingChange.emit(this.loading);\n                    this.service.save(entity).subscribe(() => {\n                        this.clear();\n                        this.addSuccessMessage(INJECTOR.get(APP_MESSAGES).SUCCESS);\n                    }, error => {\n                        this.clear();\n                        this.handleError(error);\n                    });\n                } catch (e) {\n                    this.handleError(e);\n                }\n            },\n            cancel: () => this.clear()\n        });\n    }\n\n    preDelete(): void {\n    }\n\n    clear(): void {\n        this.page = this.newPage();\n        this.filter = this.newFilterDTO();\n        this.find();\n    }\n\n    protected getPath(): string {\n        return `${this.activatedRoute.snapshot.parent.parent.url[0].path}/${this.activatedRoute.snapshot.parent.url[0].path}`;\n    }\n\n    protected newPage(): PageDTO<T> {\n        return new PageDTO<T>();\n    }\n\n    protected newFilterDTO(): F {\n        return null;\n    }\n\n    protected getFilterDTOSessionStorage(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    protected createTableColumns(): TableColumnDTO[] {\n        return [];\n    }\n\n    protected createSorts(): SortDTO[] {\n        return [];\n    }\n\n    find(pageEvent?: any): void {\n        this.loading = true;\n        this.loadingChange.emit(this.loading);\n        this.page = this.newPage();\n        if (ObjectUtil.isNull(this.filter)) {\n            this.filter = this.newFilterDTO();\n        }\n\n        if (ObjectUtil.isNull(pageEvent) && !ObjectUtil.isNull(this.tablePageEventDTO)) {\n            pageEvent = this.tablePageEventDTO;\n        }\n\n        if (pageEvent) {\n            this.tablePageEventDTO = pageEvent;\n            this.filter.pageNumber = pageEvent.pageIndex;\n            this.filter.pageSize = pageEvent.pageSize;\n            this.filter.offset = pageEvent.pageIndex * pageEvent.pageSize;\n            if (pageEvent.sort) {\n                this.filter.sorts = [new SortDTO(\n                    pageEvent.sort.active,\n                    StringUtil.isEmpty(pageEvent.sort.direction) ? SortDirectionEnum.DESC : pageEvent.sort.direction.toUpperCase()\n                )];\n            }\n        } else {\n            this.filter.pageNumber = 0;\n            this.filter.offset = 0;\n            this.filter.pageSize = 10;\n        }\n        this.service.find(this.filter).subscribe(page => {\n            this.page = page;\n            this.loading = false;\n            this.loadingChange.emit(this.loading);\n        }, error => this.handleError(error));\n    }\n\n    isFinding(): boolean {\n        return this.router.url.split('/').filter(path => path === 'new' || path === 'edit').length === 0;\n    }\n\n    isViewing(): boolean {\n        return this.router.url.split('/').filter(path => path === 'view').length > 0;\n    }\n\n    isCreating(): boolean {\n        return this.router.url.split('/').filter(path => path === 'new').length > 0;\n    }\n\n}\n"]}