@seniorsistemas/exclusion-process-component 0.0.1-40efacd8-8a6c-4d38-8102-8c977c14410a → 0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805

package/lib/src/services/filter.service.spec.ts

@@ -0,0 +1,290 @@
+import { TestBed } from "@angular/core/testing";
+import { TranslateModule, TranslateService } from "@ngx-translate/core";
+import { FieldType, FormField } from "@seniorsistemas/angular-components";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "../models/project-config";
+import { FilterService } from "./filter.service";
+import { LogicalDeleteConfigService } from "./logical-delete-config.service";
+
+describe("FilterService", () => {
+    let service: FilterService;
+    let translateService: TranslateService;
+    let logicalDeleteConfigService: LogicalDeleteConfigService;
+
+    const defaultProjectConfigs: ProjectConfigs = {
+        domain: "domain",
+        service: "service"
+    };
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [TranslateModule.forRoot()],
+            providers: [
+                TranslateService,
+                LogicalDeleteConfigService,
+                {
+                    provide: ProjectConfigsInjectionToken,
+                    useValue: defaultProjectConfigs
+                }
+            ]
+        });
+        translateService = TestBed.inject(TranslateService);
+        logicalDeleteConfigService = TestBed.inject(LogicalDeleteConfigService);
+        service = new FilterService(logicalDeleteConfigService, translateService);
+    });
+
+    it("should be created", () => {
+        expect(service).toBeTruthy();
+    });
+
+    describe("getEnumQuery", () => {
+        it("should return filter for single selection enum with default param", () => {
+            const result = service.getEnumQuery("fieldName", "TEST");
+            expect(result).toBe("fieldName eq 'TEST'");
+        });
+
+        it("should return filter for single selection enum", () => {
+            const result = service.getEnumQuery("fieldName", "TEST", false);
+            expect(result).toBe("fieldName eq 'TEST'");
+        });
+
+        it("should return filter for multitle selection enum", () => {
+            const result = service.getEnumQuery("fieldName", ["VALUE1", "VALUE2"], true);
+            expect(result).toBe("(fieldName eq 'VALUE1' or fieldName eq 'VALUE2')");
+        });
+    });
+
+    describe("createFilterString", () => {
+        it("should return the filter for a number value", () => {
+            const formField = new FormField({ type: FieldType.Number, name: "fieldName" });
+            const result = service.createFilterString(formField, 15.2);
+            expect(result).toBe("fieldName eq 15.2");
+        });
+
+        it("should return the filter for a date value", () => {
+            const filterValue = new Date(2022, 5, 10);
+            const formField = new FormField({ type: FieldType.Date, name: "fieldName" });
+            const result = service.createFilterString(formField, filterValue);
+            expect(result).toBe("fieldName eq '2022-06-10'");
+        });
+
+        it("should return the filter for a time value", () => {
+            const filterValue = new Date(2022, 5, 10, 23, 41, 55);
+            const formField = new FormField({ type: FieldType.Time, name: "fieldName" });
+            const result = service.createFilterString(formField, filterValue);
+            expect(result).toBe("fieldName eq '23:41:55'");
+        });
+
+        it("should return the filter for a dateTime value", () => {
+            const filterValue = new Date(2022, 5, 10, 23, 41, 55);
+            const formField = new FormField({ type: FieldType.DateTime, name: "fieldName" });
+            const result = service.createFilterString(formField, filterValue);
+            expect(result).toBe("fieldName eq '2022-06-10T23:41:55-03:00'");
+        });
+
+        it("should return the filter for a single value enum", () => {
+            const filterValue = 'PF';
+            const formField = new FormField({ type: FieldType.Enum, name: "fieldName" });
+            const result = service.createFilterString(formField, filterValue);
+            expect(result).toBe("fieldName eq 'PF'");
+        });
+
+        it("should return the filter for a multiple value enum", () => {
+            const filterValue = ['PF', 'PJ'];
+            const formField = new FormField({ type: FieldType.Enum, name: "fieldName", multiple: true });
+            const result = service.createFilterString(formField, filterValue);
+            expect(result).toBe("(fieldName eq 'PF' or fieldName eq 'PJ')");
+        });
+
+        it("should return the filter for a string value", () => {
+            const formField = new FormField({ type: FieldType.String, name: "fieldName" });
+            const result = service.createFilterString(formField, "some text");
+            expect(result).toBe("containing(upper(fieldName), upper('some text'))");
+        });
+
+        it("should return the filter for a lookup value", () => {
+            const filterValue = {
+                id: 'filter id',
+                name: 'name'
+            };
+            const formField = { type: FieldType.Lookup, name: "fieldName" };
+            const result = service.createFilterString(formField as any, filterValue);
+            expect(result).toBe("fieldName eq 'filter id'");
+        });
+
+        it("should return the filter the other field types", () => {
+            let result = service.createFilterString({ type: FieldType.Binary, name: "fieldName" } as any, "some value");
+            expect(result).toBe("fieldName eq 'some value'");
+
+            result = service.createFilterString({ type: FieldType.Autocomplete, name: "fieldName" } as any, "some value");
+            expect(result).toBe("fieldName eq 'some value'");
+
+            result = service.createFilterString({ type: FieldType.Blob, name: "fieldName" } as any, "some value");
+            expect(result).toBe("fieldName eq 'some value'");
+
+            result = service.createFilterString({ type: FieldType.Boolean, name: "fieldName" } as any, true);
+            expect(result).toBe("fieldName eq 'true'");
+
+            result = service.createFilterString({ type: FieldType.Custom, name: "fieldName" } as any, "some value");
+            expect(result).toBe("fieldName eq 'some value'");
+        });
+    });
+
+    describe("createFilterTokens", () => {
+        it("should return the token for a date value", () => {
+            const filterValue = new Date(2022, 5, 10);
+            const formField = new FormField({ type: FieldType.Date, name: "fieldName", label: "Field" });
+            const result = service.createFilterTokens(formField, filterValue);
+            expect(result).toEqual({id: "fieldName", label: "Field: 06/10/2022"});
+        });
+
+        it("should return the token for a time value", () => {
+            const filterValue = new Date(2022, 5, 10, 23, 41, 55);
+            const formField = new FormField({ type: FieldType.Time, name: "fieldName", label: "Field" });
+            const result = service.createFilterTokens(formField, filterValue);
+            expect(result).toEqual({id: "fieldName", label: "Field: 11:41:55 PM"});
+        });
+
+        it("should return the token for a dateTime value", () => {
+            const filterValue = new Date(2022, 5, 10, 23, 41, 55);
+            const formField = new FormField({ type: FieldType.DateTime, name: "fieldName", label: "Field" });
+            const result = service.createFilterTokens(formField, filterValue);
+            expect(result).toEqual({id: "fieldName", label: "Field: 06/10/2022 11:41:55 PM"});
+        });
+
+        it("should return the token for a lookup field", () => {
+            const filterValue = {
+                id: 'id',
+                name: 'name'
+            };
+            const formField = {
+                type: FieldType.Lookup,
+                name: "fieldName",
+                label: "Field",
+                searchFields: [
+                    new FormField({type: FieldType.String, name: 'id'}),
+                    new FormField({type: FieldType.String, name: 'name'})
+                ]
+            };
+            const result = service.createFilterTokens(formField, filterValue);
+            expect(result).toEqual({id: "fieldName", label: "Field: id - name"});
+        });
+
+        it("should return the token for a enum field", () => {
+            const filterValue = 'VA';
+            const formField = {
+                type: FieldType.Enum,
+                name: "fieldName",
+                label: "Field",
+                options: [{
+                    value: 'VA',
+                    label: 'VA - Label'
+                },
+                {
+                    value: 'VI',
+                    label: 'VI - Label'
+                }]
+            };
+            const result = service.createFilterTokens(formField, filterValue);
+            expect(result).toEqual({id: "fieldName", label: "Field: VA - Label"});
+        });
+
+        it("should return the token for a boolean field", () => {
+            spyOn(translateService, "instant").and.callFake((value: any) => `translated_${value}`);
+            const formField = {
+                type: FieldType.Boolean,
+                name: "fieldName",
+                label: "Field"
+            };
+
+            let result = service.createFilterTokens(formField, true);
+            expect(result.label).toBe("Field: translated_domain.service.list_grid_boolean_true");
+
+            result = service.createFilterTokens(formField, false);
+            expect(result.label).toBe("Field: translated_domain.service.list_grid_boolean_false");
+        });
+    });
+
+    describe("getSuggestionValue", () => {
+        it("should return the suggestion value", () => {
+            const obj = {
+                id: 'id',
+                description: 'description',
+                innerField: {
+                    id: 'inner id',
+                    name: 'inner name'
+                }
+            };
+            const result = service.getSuggestionValue(["id", "name"], "innerField", obj, ' * ');
+            expect(result).toBe("inner id * inner name");
+        });
+    });
+
+    describe("getProp", () => {
+        it("should return the property value", () => {
+            const obj = {
+                prop: "Prop1",
+                otherProps: "OtherProps"
+            };
+
+            const result = service.getProp(obj, "prop");
+            expect(result).toBe("Prop1");
+        });
+
+        it("should return the property value if the path has inner props", () => {
+            const obj = {
+                prop: {
+                    innerProp: "InnerProp"
+                },
+                otherProps: "OtherProps"
+            };
+
+            const result = service.getProp(obj, "prop.innerProp");
+            expect(result).toBe("InnerProp");
+        });
+
+        it("should return an empty string if the value is undefined", () => {
+            const obj = {
+                prop: {},
+                otherProps: "OtherProps"
+            };
+
+            const result = service.getProp(obj, "prop.innerProp");
+            expect(result).toBe("");
+        });
+    });
+
+    describe("getLabelValueRequest", () => {
+        it("should return the content with the label prop", () => {
+            const content = [{
+                id: 'id',
+                description: 'description'
+            }];
+            const result = service.getLabelValueRequest(content, ['id', 'description']);
+            expect(result[0]).toEqual({
+                id: 'id',
+                description: 'description',
+                label: 'id - description'
+            });
+        });
+
+        it("should create the label with inner props", () => {
+            const content = [{
+                id: 'id',
+                description: 'description',
+                assoc: {
+                    description: 'assoc description'
+                }
+            }];
+
+            const result = service.getLabelValueRequest(content, ['assoc.description']);
+            expect(result[0]).toEqual({
+                id: 'id',
+                description: 'description',
+                assoc: {
+                    description: 'assoc description'
+                },
+                label: 'assoc description'
+            });
+        });
+    });
+});

package/lib/src/services/filter.service.ts

@@ -0,0 +1,109 @@
+import * as moment from "moment";
+import { Injectable } from "@angular/core";
+import { FieldType, FormField, Option } from "@seniorsistemas/angular-components";
+import { TranslateService } from "@ngx-translate/core";
+import { LogicalDeleteConfigService } from "./logical-delete-config.service";
+
+@Injectable()
+export class FilterService {
+    private readonly numberTypes = [FieldType.Integer, FieldType.Double];
+
+    constructor(
+        private readonly logicalDeleteConfigService: LogicalDeleteConfigService,
+        private readonly translate: TranslateService
+    ) {}
+
+    getEnumQuery(name: string, value: any, multiple: boolean = false) {
+        if (multiple) {
+            const filter = value.map((selected: any) => `${name} eq '${selected}'`).join(" or ");
+            return `(${filter})`;
+        }
+        return `${name} eq '${value}'`;
+    }
+
+    createFilterString(formField: FormField, value: any) {
+        const { name, type, multiple } = formField;
+        if (typeof value == "number") {
+            return `${name} eq ${value}`;
+        }
+
+        switch (type) {
+            case FieldType.Date:
+                return `${name} eq '${moment(value).format("YYYY-MM-DD")}'`;
+            case FieldType.Time:
+                return `${name} eq '${moment(value).format("HH:mm:ss")}'`;
+            case FieldType.DateTime:
+                return `${name} eq '${moment(value).format()}'`;
+            case FieldType.LocalDateTime:
+                return `${name} eq '${moment(value).format("YYYY-MM-DD[T]HH:mm:ss.SSS")}'`;
+            case FieldType.Enum:
+                return this.getEnumQuery(name, value, multiple);
+            case FieldType.String:
+                return `containing(upper(${name}), upper('${value.replace(/'/g, "'")}'))`;
+            case FieldType.Lookup:
+                return `${name} eq '${value.id}'`;
+            default:
+                return `${name} eq '${value}'`;
+        }
+    }
+
+    createFilterTokens(formField: FormField, value: any) {
+        const { name, type, label, searchFields, options } = formField as any;
+        let labelValue = value;
+
+        switch (type) {
+            case FieldType.Date:
+                labelValue = moment(value).format("L");
+                break;
+            case FieldType.Time:
+                labelValue = moment(value).format("LTS");
+                break;
+            case FieldType.LocalDateTime:
+            case FieldType.DateTime:
+                labelValue = moment(value).format("L LTS");
+                break;
+            case FieldType.Lookup:
+                labelValue = searchFields.map((field: FormField) => this.getProp(value, field.name)).join(" - ");
+                break;
+            case FieldType.Enum:
+                if (Array.isArray(value)) {
+                    labelValue = value.map((element: string) => {
+                        return options.filter((en: any) => en.value === element)[0].label;
+                    });
+                } else {
+                    labelValue = options.filter((option: Option) => option.value === labelValue)[0].label;
+                }
+                break;
+            case FieldType.Boolean:
+                labelValue = value
+                    ? this.translate.instant(`${this.logicalDeleteConfigService.getTranslationPrefix()}.list_grid_boolean_true`)
+                    : this.translate.instant(`${this.logicalDeleteConfigService.getTranslationPrefix()}.list_grid_boolean_false`);
+                break;
+        }
+
+        return { id: name, label: `${label}: ${labelValue}` };
+    }
+
+    getSuggestionValue(displayFields: string[], ownerEntity: string, value: any, separator: string) {
+        return displayFields.map(field => this.getProp(value, `${ownerEntity}.${field}`))
+                            .reduce((acc: any, val: any) => `${acc}${separator}${val}`) + "";
+    }
+
+    getProp(obj: any, path: any) {
+        return path.split(".").reduce((result: any, prop: any) => (result[prop] === undefined ? "" : result[prop]), obj);
+    }
+
+    getLabelValueRequest(contents: any[], displayFields: any[]) {
+        return contents.map((item: any) => ({
+            ...item,
+            label: displayFields.map(field => this.getProp(item, field)).join(" - ")
+        }));
+    }
+
+    isValidFilter(type: FieldType, value: any) {
+        const isTypeNumber = this.numberTypes.includes(type);
+        const numberPattern = /^\d+\b$/;
+        const isNumber = value.match(numberPattern);
+        return !(isTypeNumber && !isNumber);
+    }
+}

package/lib/src/services/logical-delete-config.service.spec.ts

@@ -0,0 +1,59 @@
+import { TestBed } from "@angular/core/testing";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "../models/project-config";
+import { LogicalDeleteConfigService } from "./logical-delete-config.service";
+
+describe("LogicalDeleteConfigService", () => {
+    let service: LogicalDeleteConfigService;
+    let projectConfigs: ProjectConfigs;
+
+    const defaultProjectConfigs: ProjectConfigs = {
+        domain: "domain",
+        service: "service"
+    };
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            providers: [{
+                provide: ProjectConfigsInjectionToken,
+                useValue: defaultProjectConfigs
+            }]
+        });
+        projectConfigs = TestBed.inject(ProjectConfigsInjectionToken);
+        service = new LogicalDeleteConfigService(projectConfigs);
+    });
+
+    it("should be created", () => {
+        expect(service).toBeTruthy();
+    });
+
+    describe("getDomain", () => {
+        it("should return the configured domain on getDomain", () => {
+            const response = service.getDomain();
+            expect(response).toBe("domain");
+        });
+    });
+
+    describe("getService", () => {
+        it("should return the configured service on getService", () => {
+            const response = service.getService();
+            expect(response).toBe("service");
+        });
+    });
+
+    describe("getTranslationPrefix", () => {
+        it("should return configured translationPrefix if configured", () => {
+            service = new LogicalDeleteConfigService({
+                ...defaultProjectConfigs,
+                translationPrefix: "custom translationPrefix"
+            });
+
+            const response = service.getTranslationPrefix();
+            expect(response).toBe("custom translationPrefix");
+        });
+
+        it("should return domain and service if translationPrefix is not configured", () => {
+            const response = service.getTranslationPrefix();
+            expect(response).toBe("domain.service");
+        });
+    });
+});

package/lib/src/services/logical-delete-config.service.ts

@@ -0,0 +1,25 @@
+import { Inject, Injectable } from "@angular/core";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "../models/project-config";
+
+@Injectable()
+export class LogicalDeleteConfigService {
+    constructor(
+        @Inject(ProjectConfigsInjectionToken)
+        private readonly projectConfigs: ProjectConfigs) {
+    }
+
+    public getDomain() {
+        return this.projectConfigs.domain;
+    }
+
+    public getService() {
+        return this.projectConfigs.service;
+    }
+
+    public getTranslationPrefix() {
+        if (this.projectConfigs.translationPrefix) {
+            return this.projectConfigs.translationPrefix;
+        }
+        return `${this.projectConfigs.domain}.${this.projectConfigs.service}`;
+    }
+}