@seniorsistemas/exclusion-process-component 0.0.1-c049d10c-e93a-4d63-9c2a-b17bca40c324 → 0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805

package/lib/src/exclusions-list/exclusions-list.component.ts

@@ -0,0 +1,335 @@
+import * as moment from 'moment';
+import { ChangeDetectorRef, Component, OnDestroy, OnInit, ViewChild } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { LazyLoadEvent } from 'primeng/api';
+import { Subject } from 'rxjs';
+import { catchError, finalize, takeUntil } from 'rxjs/operators';
+import { EnumBadgeColors, EnumColumnFieldType, FieldType, FormField, IToken, TableColumnLocaleOptions } from '@seniorsistemas/angular-components';
+import { EnumExclusionProcessStatus } from '../enums/enum-exclusion-process-status';
+import { ExclusionProcess } from '../models';
+import { Table } from 'primeng/table';
+import { LogicalDeleteService } from '../services';
+import { ActivatedRoute } from '@angular/router';
+import { ListParams } from '../models/list-params';
+import { LogicalDeleteConfigService } from '../services/logical-delete-config.service';
+import { ExclusionDetailsComponent } from '../exclusion-details';
+import { FilterService } from '../services/filter.service';
+
+@Component({
+    templateUrl: "./exclusions-list.component.html",
+    styleUrls: [],
+    providers: []
+})
+export class ExclusionsListComponent implements OnInit, OnDestroy  {
+    public locale!: TableColumnLocaleOptions;
+    public entityName: string;
+    public entityDescription: string;
+
+    public currentListParams: ListParams = { page: 0, size: 10, sort: [], filterData: {} };
+    public gridData: ExclusionProcess[];
+    public gridColumns: any[];
+    public showLoader: boolean = false;
+    public totalRecords = 0;
+
+    public filterFields: FormField[];
+    public filterFormGroup: FormGroup;
+    public filtersPanelCollapsed = true;
+    public searchTokens: IToken[] = [];
+    public serverError: boolean = false;
+
+    @ViewChild("exclusionsTable")
+    public table: Table;
+
+    @ViewChild(ExclusionDetailsComponent)
+    public exclusionDetailsComponent: ExclusionDetailsComponent;
+
+    private ngUnsubscribe = new Subject();
+
+    constructor(
+        private readonly route: ActivatedRoute,
+        private readonly translate: TranslateService,
+        private readonly formBuilder: FormBuilder,
+        private readonly changeDetectorRef: ChangeDetectorRef,
+        private readonly logicalDeleteService: LogicalDeleteService,
+        private readonly filterService: FilterService,
+        private readonly projectConfigs: LogicalDeleteConfigService
+    ) {
+    }
+
+    public ngOnInit() {
+        this.filterFormGroup = this.getFormBuilder();
+        this.filterFields = this.getFilterFields();
+        this.gridColumns = this.getGridColumns();
+
+        this.route.data
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((data: { [configs: string]: any, localeConfig: TableColumnLocaleOptions }) => {
+                this.locale = data.localeConfig;
+            });
+        this.route.params
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((params: any) => {
+                this.entityName = params.entityName;
+            });
+        this.route.queryParams
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((queryParams: any) => {
+                this.entityDescription = queryParams.entityDescription;
+            });
+    }
+
+    public ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+
+    private getFormBuilder() {
+        return this.formBuilder.group({
+            description: [undefined, Validators.compose([])],
+            state: [undefined, Validators.compose([])],
+            startDate: [{ value: undefined, disabled: false }, Validators.compose([])],
+            endDate: [{ value: undefined, disabled: false }, Validators.compose([])]
+        });
+    }
+
+    private getGridColumns() {
+        return [
+            {
+                field: "description",
+                attributes: ['description'],
+                header: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_description`),
+                type: EnumColumnFieldType.STRING,
+                style: {
+                    width: '300px'
+                }
+            },
+            {
+                field: "status",
+                attributes: ['status'],
+                header: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_status`),
+                type: EnumColumnFieldType.ENUM,
+                enumPrefix: `${this.projectConfigs.getTranslationPrefix()}.logical_delete_enum_exclusion_process_status_`,
+                style: {
+                    width: '100px'
+                },
+                badgeConfigs: [
+                    {
+                        enumValue: EnumExclusionProcessStatus.ERROR,
+                        color: EnumBadgeColors.RED
+                    },
+                    {
+                        enumValue: EnumExclusionProcessStatus.PENDING,
+                        color: EnumBadgeColors.YELLOW
+                    },
+                    {
+                        enumValue: EnumExclusionProcessStatus.PROCESSING,
+                        color: EnumBadgeColors.BLUE
+                    },
+                    {
+                        enumValue: EnumExclusionProcessStatus.SUCCESS,
+                        color: EnumBadgeColors.GREEN
+                    }
+                ]
+            },
+            {
+                field: "startDate",
+                attributes: ['startDate'],
+                header: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_start`),
+                type: EnumColumnFieldType.DATE,
+                dateFormat: "DD/MM/YYYY HH:mm",
+                style: {
+                    width: '100px'
+                }
+            },
+            {
+                field: "finishDate",
+                attributes: ['finishDate'],
+                header: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_finish`),
+                type: EnumColumnFieldType.DATE,
+                dateFormat: "DD/MM/YYYY HH:mm",
+                style: {
+                    width: '100px'
+                }
+            }
+        ];
+    }
+
+    private getFilterFields() {
+        return [
+            new FormField({
+                type: FieldType.String,
+                name: "description",
+                label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_description`)
+            }),
+            new FormField({
+                type: FieldType.Enum,
+                name: "state",
+                label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_status`),
+                placeholder: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_status`),
+                multiple: true,
+                options: [
+                    {
+                        label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_enum_exclusion_process_status_error`),
+                        value: EnumExclusionProcessStatus.ERROR
+                    },
+                    {
+                        label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_enum_exclusion_process_status_pending`),
+                        value: EnumExclusionProcessStatus.PENDING
+                    },
+                    {
+                        label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_enum_exclusion_process_status_processing`),
+                        value: EnumExclusionProcessStatus.PROCESSING
+                    },
+                    {
+                        label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_enum_exclusion_process_status_success`),
+                        value: EnumExclusionProcessStatus.SUCCESS
+                    }
+                ]
+            }),
+            new FormField({
+                type: FieldType.Date,
+                name: "startDate",
+                label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_start`)
+            }),
+
+            new FormField({
+                type: FieldType.Date,
+                name: "endDate",
+                label: this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_finish`)
+            })
+        ];
+    }
+
+    public getEmptyStateTitle() {
+        return this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_empty_state_title`);
+    }
+
+    public getEmptyStateDescription() {
+        return this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_empty_state_description`);
+    }
+
+    public getTitle() {
+        return this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_list_title`);
+    }
+
+    public getDetailsButtonTitle() {
+        return this.translate.instant(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_details`);
+    }
+
+    public onSearch() {
+        const filterData = this.filterFormGroup.getRawValue();
+        this.filtersPanelCollapsed = true;
+        this.resetGrid({ filterData });
+    }
+
+    public onClear() {
+        this.filterFormGroup.reset();
+        const filterData = this.filterFormGroup.getRawValue();
+        this.resetGrid({ filterData });
+    }
+
+    public onRemoveToken(token: IToken) {
+        this.filterFormGroup.get(token.id).setValue(undefined);
+        const filterData = this.filterFormGroup.getRawValue();
+        this.resetGrid({ filterData });
+    }
+
+    public onGridChange(event: LazyLoadEvent) {
+        const size = event.rows;
+        const page = event.first / size;
+        const sort = event.multiSortMeta ? event.multiSortMeta : [];
+        return this.updateGrid({ page, size, sort });
+    }
+
+    private getFilterTokens() {
+        const filterData = this.filterFormGroup.value;
+
+        return this.filterFields
+            .filter(({ name }) => filterData[name] != undefined && filterData[name] !== "")
+            .map(formField => this.filterService.createFilterTokens(formField, filterData[formField.name]));
+    }
+
+    private getFilterQuery(): string {
+        const { filterData } = this.currentListParams;
+        const dateFields = ['startDate', 'endDate'];
+
+        let filterQuery = this.filterFields
+            .filter(({ name }) => !dateFields.includes(name))
+            .filter(({ name }) => filterData[name] != undefined)
+            .map(formField => this.filterService.createFilterString(formField, filterData[formField.name]))
+            .join(" and ");
+
+        if (filterData.startDate && filterData.endDate) {
+            const startDate = moment(filterData.startDate).format('YYYY-MM-DD');
+            const endDate = moment(filterData.endDate).format('YYYY-MM-DD');
+            const dateQuery = `startDate between '${startDate}' and '${endDate}'`;
+            if (filterQuery) {
+                filterQuery += ` and ${dateQuery}`;
+            } else {
+                filterQuery = dateQuery;
+            }
+        }
+
+        return filterQuery;
+    }
+
+    private updateGrid(listParams: ListParams = {}) {
+        this.currentListParams = { ...this.currentListParams, ...listParams };
+        const { page, size, sort } = this.currentListParams;
+
+        this.searchTokens = this.getFilterTokens();
+        const filterQuery = this.getFilterQuery();
+        const displayFields = [
+            'recordId',
+            ...this.gridColumns.map(column => column.field)
+        ];
+
+        this.listExclusions({ page, size, sort, filterQuery, displayFields });
+    }
+
+    public listExclusions(params: any) {
+        this.showLoader = true;
+        this.serverError = false;
+
+        this.changeDetectorRef.detectChanges();
+
+        this.logicalDeleteService
+            .listExclusions(this.entityName, params)
+            .pipe(
+                takeUntil(this.ngUnsubscribe),
+                catchError((err: any) => {
+                    if (err.status >= 500 && err.status < 600) {
+                        this.serverError = true;
+                    }
+                    throw err;
+                }),
+                finalize(() => this.showLoader = false)
+            )
+            .subscribe((list: any) => {
+                this.gridData = list.contents;
+                this.totalRecords = list.totalElements;
+            });
+    }
+
+    public focusInput(elementId: string) {
+        const element: any = document.getElementById(`${elementId}`);
+        if (element) {
+            element.focus();
+        }
+    }
+
+    public resetGrid(listParams?: ListParams) {
+        if (listParams) this.currentListParams = { ...this.currentListParams, ...listParams };
+        this.currentListParams = { ...this.currentListParams, page: 0, sort: [] };
+        this.table.reset();
+    }
+
+    public onClickDetails(rowData: ExclusionProcess) {
+        this.exclusionDetailsComponent.showDetails({
+            recordId: rowData.recordId,
+            entityDescription: this.entityDescription,
+            entityName: this.entityName
+        });
+    }
+}

package/lib/src/exclusions-list/exclusions-list.module.ts

@@ -0,0 +1,52 @@
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { PanelModule } from "primeng/panel";
+import { TableModule as PrimeTableModule } from "primeng/table";
+import {
+    ButtonModule,
+    LoadingStateModule,
+    TableModule,
+    LocaleModule,
+    TokenListModule,
+    DynamicFormModule,
+    EmptyStateModule,
+    ControlErrorsModule,
+    InfoSignModule
+} from "@seniorsistemas/angular-components";
+import { ExclusionsListComponent } from "./exclusions-list.component";
+import { TranslateModule } from "@ngx-translate/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { DialogModule } from "primeng/dialog";
+import { ConfirmDialogModule } from "primeng/confirmdialog";
+import { InputTextModule } from "primeng/inputtext";
+import { ExclusionDetailsModule } from "../exclusion-details";
+import { ExclusionsListFeatureRouting } from "./exclusions-list.routing";
+
+@NgModule({
+    imports: [
+        FormsModule,
+        ReactiveFormsModule,
+        TranslateModule,
+        CommonModule,
+        ControlErrorsModule,
+        ButtonModule,
+        PanelModule,
+        InputTextModule,
+        InfoSignModule,
+        ConfirmDialogModule,
+        DialogModule,
+        PrimeTableModule,
+        TableModule,
+        LoadingStateModule,
+        EmptyStateModule,
+        DynamicFormModule,
+        TokenListModule,
+        LocaleModule.forChild(),
+        ExclusionDetailsModule,
+        ExclusionsListFeatureRouting
+    ],
+    declarations: [ExclusionsListComponent],
+    exports: [ExclusionsListComponent],
+    entryComponents: [ExclusionsListComponent]
+})
+export class ExclusionsListModule {}

package/lib/src/exclusions-list/exclusions-list.routing.ts

@@ -0,0 +1,89 @@
+import { NgModule, Injectable, Component } from "@angular/core";
+import { RouterModule, Routes, CanActivate } from "@angular/router";
+import { TranslateService } from "@ngx-translate/core";
+import { PermissionsService } from "@seniorsistemas/platform-components";
+import { LocaleService } from "@seniorsistemas/angular-components";
+import { ExclusionsListComponent } from "./exclusions-list.component";
+import { LogicalDeleteConfigService } from "../services/logical-delete-config.service";
+
+@Injectable()
+export class ExclusionsListFeatureRoutingGuard implements CanActivate {
+    public canActivate() {
+        return true;
+    }
+}
+
+@Injectable()
+export class ExclusionsListFeatureRoutingListTitleResolver {
+    constructor(
+        private readonly translate: TranslateService,
+        private readonly projectConfigs: LogicalDeleteConfigService
+    ) {}
+
+    public resolve() {
+        return this.translate.get(`${this.projectConfigs.getTranslationPrefix()}.logical_delete_list_title`);
+    }
+}
+
+@Injectable()
+export class ExclusionsListFeatureRoutingPermissionResolver {
+    constructor(private readonly permissionsService: PermissionsService) {}
+
+    public resolve() {
+        return this.permissionsService.get();
+    }
+}
+
+@Injectable()
+export class ExclusionsListFeatureRoutingLocaleResolver {
+    constructor(private readonly localeService: LocaleService) {}
+
+    public resolve() {
+        return this.localeService.get();
+    }
+}
+
+@Component({
+    template: `<router-outlet></router-outlet>`
+})
+export class EmptyComponent {}
+
+export const routes: Routes = [
+    {
+        path: "exclusions-list",
+        component: EmptyComponent,
+        canActivate: [
+            ExclusionsListFeatureRoutingGuard
+        ],
+        resolve: {
+            allPermissions: ExclusionsListFeatureRoutingPermissionResolver,
+            localeConfig: ExclusionsListFeatureRoutingLocaleResolver,
+            routeTitle: ExclusionsListFeatureRoutingListTitleResolver
+        },
+        children: [
+            {
+                path: ":entityName",
+                component: ExclusionsListComponent
+            }
+        ]
+    }
+];
+
+@NgModule({
+    imports: [
+        RouterModule.forChild(routes)
+    ],
+    exports: [
+        RouterModule
+    ],
+    providers: [
+        ExclusionsListFeatureRoutingGuard,
+        ExclusionsListFeatureRoutingPermissionResolver,
+        ExclusionsListFeatureRoutingLocaleResolver,
+        ExclusionsListFeatureRoutingListTitleResolver
+    ],
+    declarations: [
+        EmptyComponent
+    ]
+})
+export class ExclusionsListFeatureRouting {}

package/lib/src/exclusions-list/index.ts

@@ -0,0 +1,2 @@
+export * from "./exclusions-list.module";
+export * from "./exclusions-list.component";

package/lib/src/logical-delete.module.ts

@@ -0,0 +1,22 @@
+import { ModuleWithProviders, NgModule } from "@angular/core";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "./models/project-config";
+import { FilterService } from "./services/filter.service";
+import { LogicalDeleteConfigService } from "./services/logical-delete-config.service";
+import { LogicalDeleteService } from "./services/logical-delete.service";
+
+@NgModule({
+    providers: [LogicalDeleteService, LogicalDeleteConfigService, FilterService]
+})
+export class LogicalDeleteModule {
+    static forRoot(config: ProjectConfigs): ModuleWithProviders<LogicalDeleteModule> {
+        return {
+            ngModule: LogicalDeleteModule,
+            providers: [
+                {
+                    provide: ProjectConfigsInjectionToken,
+                    useValue: config
+                }
+            ]
+        };
+    }
+}

package/{models/exclusion-process-step-group.d.ts → lib/src/models/exclusion-process-step-group.ts}

@@ -1,6 +1,7 @@
 import { EnumExclusionProcessStatus } from "../enums/enum-exclusion-process-status";
 import { ExclusionProcess } from "./exclusion-process";
 import { ExclusionProcessStep } from "./exclusion-process-step";
+
 export interface ExclusionProcessStepGroup {
     id: string;
     description: string;

package/{models/exclusion-process-step.d.ts → lib/src/models/exclusion-process-step.ts}

@@ -1,4 +1,5 @@
 import { EnumExclusionProcessStatus } from "../enums/enum-exclusion-process-status";
+
 export interface ExclusionProcessStep {
     id: string;
     description: string;

package/{models/exclusion-process.d.ts → lib/src/models/exclusion-process.ts}

@@ -1,5 +1,6 @@
 import { EnumExclusionProcessStatus } from "../enums/enum-exclusion-process-status";
 import { ExclusionProcessStepGroup } from "./exclusion-process-step-group";
+
 export interface ExclusionProcess {
     id: string;
     entityName: string;

package/{models/list-params.d.ts → lib/src/models/list-params.ts}

@@ -1,4 +1,5 @@
 import { SortMeta } from "primeng/api";
+
 export interface ListParams {
     page?: number;
     size?: number;

package/{models/project-config.d.ts → lib/src/models/project-config.ts}

@@ -1,5 +1,7 @@
 import { InjectionToken } from "@angular/core";
-export declare const ProjectConfigsInjectionToken: InjectionToken<ProjectConfigs>;
+
+export const ProjectConfigsInjectionToken = new InjectionToken<ProjectConfigs>("projectConfigs");
+
 export interface ProjectConfigs {
     domain: string;
     service: string;