@colijnit/corecomponents_v12 12.2.4 → 12.2.6

package/esm2015/lib/directives/screen-configuration/screen-configuration.directive.js

@@ -1,68 +1,158 @@
 import { __decorate } from "tslib";
-import { ComponentFactoryResolver, Directive, Inject, Input, ViewContainerRef } from "@angular/core";
-import { InputBoolean } from "../../core/decorator/input-boolean.decorator";
-import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from "../../interfaces/screen-config-adapter-component-interface-name";
-import { ScreenConfigComponentWrapper } from "./screen-config-component-wrapper.component";
+import { Directive, ElementRef, Inject, Input, Renderer2 } from '@angular/core';
+import { InputBoolean } from '../../core/decorator/input-boolean.decorator';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '../../interfaces/screen-config-adapter-component-interface-name';
+import { BaseModuleScreenConfigService } from '../../service/base-module-screen-config.service';
+import { BaseModuleService } from '../../service/base-module.service';
 // Directive to represents the marker of "screen config name ID's" of components within a module.
 // Manipulates visibility, readonly and other dynamic states of an input element according to its db-fetched screen configuration object.
 export class ScreenConfigurationDirective {
-    constructor(hostComponent, _viewContainerRef, _componentFactoryResolver) {
+    constructor(hostComponent, _element, 
+    // we must always have a config service to fetch config objects with
+    _configService, _renderer, 
+    // to make host readonly when MODULE switches to readonly:
+    _moduleService) {
         this.hostComponent = hostComponent;
-        this._viewContainerRef = _viewContainerRef;
-        this._componentFactoryResolver = _componentFactoryResolver;
+        this._element = _element;
+        this._configService = _configService;
+        this._renderer = _renderer;
+        this._moduleService = _moduleService;
+        this.screenConfigNativeElement = false;
         this.noModuleService = false;
+        // feature toggle for devs so you can see the whole screen with all inputs etc by temporarily turning off the hiding effects of this directive on its host
+        this._isTurnedOff = false;
+        this._subs = [];
+        this._subs.push(this._configService.configSet.subscribe((configObjects) => {
+            if (configObjects && configObjects.length > 0) {
+                this._updateHost();
+            }
+        }));
+        if (this._moduleService && !this.noModuleService) {
+            this._subs.push(this._moduleService.readonlyChange.subscribe((moduleInReadonlyState) => {
+                if (this.hostComponent) {
+                    this.hostComponent.readonly = this.hostComponent.forceReadonly || moduleInReadonlyState;
+                }
+            }), this._moduleService.errorValidationReceived.subscribe((validationResult) => {
+                this._setErrorRedBackgroundAfterScrCfgValidate(validationResult);
+            }), this._moduleService.successfulUpdate.subscribe(() => {
+                if (this.hostComponent) {
+                    this.hostComponent.redErrorBackground = false;
+                }
+            }));
+        }
     }
-    set screenConfigurationObject(screenConfigurationObject) {
-        if (screenConfigurationObject) {
-            this._screenConfigurationObject = screenConfigurationObject;
-            this._initWrapperComponent();
+    set screenConfigurationObject(value) {
+        if (value) {
+            this._screenConfigurationObject = value;
             this._updateHost();
         }
     }
     get screenConfigurationObject() {
         return this._screenConfigurationObject;
     }
+    ngOnInit() {
+        this._updateHost();
+        // this._updateHeaderStateOnHostComponent(true);
+        // show initial error message if any
+        if (!this.noModuleService) {
+            // this._setErrorRedBackgroundAfterScrCfgValidate(this._moduleService.lastError);
+        }
+    }
     ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+        if (this._isHeader) {
+            // this._doubleClickHeaders.handleCollapseableDestroy(this.screenConfigurationObject);
+        }
+        this._element = undefined;
         this.hostComponent = undefined;
-        this._wrapperComponentInstance = undefined;
     }
-    _initWrapperComponent() {
-        if (!this._wrapperComponentInstance) {
-            const componentFactory = this._componentFactoryResolver.resolveComponentFactory(ScreenConfigComponentWrapper);
-            const componentRef = this._viewContainerRef.createComponent(componentFactory);
-            const visibleOnViewInit = !!this.screenConfigurationObject ? this.screenConfigurationObject.immediatelyVisible() : false;
-            this._wrapperComponentInstance = componentRef.instance;
-            this._wrapperComponentInstance.setWrapperContent(this._viewContainerRef.element.nativeElement, visibleOnViewInit);
+    // Sets host component visibility, required, readonly etc. if specified in backend screen config OR module readonly status.
+    _updateHost() {
+        if (this._mayUpdateHost() || this.screenConfigNativeElement) {
+            if (!this.screenConfigNativeElement) {
+                this.hostComponent.objectConfigName = this.screenConfigurationObject;
+            }
+            const myCfgObj = this._configService.getObjectConfigurationFor(this.screenConfigurationObject);
+            if (myCfgObj) {
+                this._setHostVisible(myCfgObj.immediatelyVisible());
+                // if (this.hostComponent instanceof GridColumnComponent) {
+                //   this.hostComponent.rights = myCfgObj.rights;
+                // }
+                if (!this.screenConfigNativeElement) {
+                    this.hostComponent.required = myCfgObj.isRequired();
+                    this.hostComponent.readonly = this.hostComponent.forceReadonly || this._moduleInReadonlyMode() || myCfgObj.isReadonly();
+                    this.hostComponent.decimals = myCfgObj.scale;
+                    this.hostComponent.maxLength = myCfgObj.maxLength;
+                }
+            }
+            else {
+                this._setHostVisible(false);
+                if (!this.screenConfigNativeElement) {
+                    this.hostComponent.readonly = this._moduleInReadonlyMode();
+                }
+            }
+        }
+    }
+    /**
+     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);
+     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.
+     */
+    _setErrorRedBackgroundAfterScrCfgValidate(errorValidation) {
+        if (this.hostComponent && errorValidation) {
+            const errorMessages = errorValidation.getAllErrorMessagesOfMyValidationFields();
+            for (let i = 0, len = errorMessages.length; i < len; i++) {
+                const errorMsg = errorMessages[i];
+                const configName = this.dataName ? this.dataName : this.screenConfigurationObject;
+                if (errorMsg.fieldId === configName && this._element /*&& this._properHost(errorMsg.boId)*/) {
+                    this.hostComponent.redErrorBackground = true;
+                }
+            }
         }
     }
-    _updateHost() {
-        if (!!this.hostComponent && !!this._screenConfigurationObject) {
-            this.hostComponent.objectConfigName = this.screenConfigurationObject.configName;
-            if (this.screenConfigurationObject) {
-                this.hostComponent.required = this.screenConfigurationObject.isRequired();
-                // readonly based on forced boolean, based on rights value or based on variable value affected by module read only state
-                this.hostComponent.readonly = this.hostComponent.forceReadonly || this.screenConfigurationObject.isReadonly() || this.screenConfigurationObject.variableReadOnly;
-                this.hostComponent.decimals = this.screenConfigurationObject.scale;
-                this.hostComponent.maxLength = this.screenConfigurationObject.maxLength;
+    _moduleInReadonlyMode() {
+        return !this.noModuleService ? (this._moduleService ? this._moduleService.readonly : false) : false;
+    }
+    _mayUpdateHost() {
+        return !!this.hostComponent && !this._isTurnedOff && !!this.screenConfigurationObject;
+    }
+    _setHostVisible(visible) {
+        if (!this.screenConfigNativeElement) {
+            this.hostComponent.hidden = !visible;
+        }
+        else {
+            if (this._element && this._element.nativeElement) {
+                if (!visible) {
+                    this._renderer.addClass(this._element.nativeElement, 'hidden');
+                }
+                else {
+                    this._renderer.removeClass(this._element.nativeElement, 'hidden');
+                }
             }
         }
     }
 }
 ScreenConfigurationDirective.decorators = [
     { type: Directive, args: [{
-                selector: "[screenConfigurationObject]"
+                selector: '[screenConfigurationObject]'
             },] }
 ];
 ScreenConfigurationDirective.ctorParameters = () => [
     { type: undefined, decorators: [{ type: Inject, args: [SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,] }] },
-    { type: ViewContainerRef },
-    { type: ComponentFactoryResolver }
+    { type: ElementRef },
+    { type: BaseModuleScreenConfigService },
+    { type: Renderer2 },
+    { type: BaseModuleService }
 ];
 ScreenConfigurationDirective.propDecorators = {
-    screenConfigurationObject: [{ type: Input }],
+    screenConfigurationObject: [{ type: Input, args: ['screenConfigurationObject',] }],
+    dataName: [{ type: Input }],
+    screenConfigNativeElement: [{ type: Input }],
     noModuleService: [{ type: Input }]
 };
+__decorate([
+    InputBoolean()
+], ScreenConfigurationDirective.prototype, "screenConfigNativeElement", void 0);
 __decorate([
     InputBoolean()
 ], ScreenConfigurationDirective.prototype, "noModuleService", void 0);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen-configuration.directive.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/screen-configuration/screen-configuration.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Inject, Input, OnDestroy, Renderer2} from '@angular/core';\r\nimport {InputBoolean} from '../../core/decorator/input-boolean.decorator';\r\nimport {ScreenConfigAdapterComponent} from '../../interfaces/screen-config-adapter.component.interface';\r\nimport {SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME} from '../../interfaces/screen-config-adapter-component-interface-name';\r\nimport {Subscription} from 'rxjs';\r\nimport {BaseModuleScreenConfigService} from '../../service/base-module-screen-config.service';\r\nimport {BaseModuleService} from '../../service/base-module.service';\r\nimport {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';\r\nimport {ValidationMessage} from '@colijnit/ioneconnector/build/model/validation-message';\r\nimport {ObjectConfiguration} from '@colijnit/ioneconnector/build/model/object-configuration';\r\n\r\n// Directive to represents the marker of \"screen config name ID's\" of components within a module.\r\n// Manipulates visibility, readonly and other dynamic states of an input element according to its db-fetched screen configuration object.\r\n@Directive({\r\n    selector: '[screenConfigurationObject]'\r\n})\r\nexport class ScreenConfigurationDirective implements OnDestroy {\r\n    @Input('screenConfigurationObject')\r\n    public set screenConfigurationObject(value: string) {\r\n        if (value) {\r\n            this._screenConfigurationObject = value;\r\n            this._updateHost();\r\n        }\r\n    }\r\n\r\n    public get screenConfigurationObject(): string {\r\n        return this._screenConfigurationObject;\r\n    }\r\n\r\n    @Input()\r\n    public dataName: string;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public screenConfigNativeElement: boolean = false;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public noModuleService: boolean = false;\r\n\r\n    private _isHeader: boolean;\r\n\r\n    private _screenConfigurationObject: string;\r\n\r\n    // feature toggle for devs so you can see the whole screen with all inputs etc by temporarily turning off the hiding effects of this directive on its host\r\n    private _isTurnedOff: boolean = false;\r\n\r\n    private _subs: Subscription[] = [];\r\n\r\n    constructor(\r\n        @Inject(SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME)\r\n        public hostComponent: ScreenConfigAdapterComponent,\r\n        private _element: ElementRef,\r\n        // we must always have a config service to fetch config objects with\r\n        private _configService: BaseModuleScreenConfigService,\r\n        private _renderer: Renderer2,\r\n        // to make host readonly when MODULE switches to readonly:\r\n        private _moduleService?: BaseModuleService\r\n    ) {\r\n        this._subs.push(this._configService.configSet.subscribe((configObjects: string[]) => {\r\n            if (configObjects && configObjects.length > 0) {\r\n                this._updateHost();\r\n            }\r\n        }));\r\n\r\n        if (this._moduleService && !this.noModuleService) {\r\n            this._subs.push(\r\n                this._moduleService.readonlyChange.subscribe((moduleInReadonlyState: boolean) => {\r\n                    if (this.hostComponent) {\r\n                        this.hostComponent.readonly = this.hostComponent.forceReadonly || moduleInReadonlyState;\r\n                    }\r\n                }),\r\n                this._moduleService.errorValidationReceived.subscribe((validationResult: any) => {\r\n                    this._setErrorRedBackgroundAfterScrCfgValidate(validationResult);\r\n                }),\r\n                this._moduleService.successfulUpdate.subscribe(() => {\r\n                    if (this.hostComponent) {\r\n                        this.hostComponent.redErrorBackground = false;\r\n                    }\r\n                })\r\n            );\r\n        }\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this._updateHost();\r\n\r\n        // this._updateHeaderStateOnHostComponent(true);\r\n\r\n        // show initial error message if any\r\n        if (!this.noModuleService) {\r\n            // this._setErrorRedBackgroundAfterScrCfgValidate(this._moduleService.lastError);\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._subs.forEach(sub => sub.unsubscribe());\r\n        if (this._isHeader) {\r\n            // this._doubleClickHeaders.handleCollapseableDestroy(this.screenConfigurationObject);\r\n        }\r\n        this._element = undefined;\r\n        this.hostComponent = undefined;\r\n    }\r\n\r\n    // Sets host component visibility, required, readonly etc. if specified in backend screen config OR module readonly status.\r\n    private _updateHost(): void {\r\n        if (this._mayUpdateHost() || this.screenConfigNativeElement) {\r\n            if (!this.screenConfigNativeElement) {\r\n                this.hostComponent.objectConfigName = this.screenConfigurationObject;\r\n            }\r\n            const myCfgObj: ObjectConfiguration = this._configService.getObjectConfigurationFor(this.screenConfigurationObject);\r\n            if (myCfgObj) {\r\n                this._setHostVisible(myCfgObj.immediatelyVisible());\r\n                // if (this.hostComponent instanceof GridColumnComponent) {\r\n                //   this.hostComponent.rights = myCfgObj.rights;\r\n                // }\r\n                if (!this.screenConfigNativeElement) {\r\n                    this.hostComponent.required = myCfgObj.isRequired();\r\n                    this.hostComponent.readonly = this.hostComponent.forceReadonly || this._moduleInReadonlyMode() || myCfgObj.isReadonly();\r\n                    this.hostComponent.decimals = myCfgObj.scale;\r\n                    this.hostComponent.maxLength = myCfgObj.maxLength;\r\n                }\r\n            } else {\r\n                this._setHostVisible(false);\r\n                if (!this.screenConfigNativeElement) {\r\n                    this.hostComponent.readonly = this._moduleInReadonlyMode();\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);\r\n     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.\r\n     */\r\n    private _setErrorRedBackgroundAfterScrCfgValidate(errorValidation: ValidationResult): void {\r\n        if (this.hostComponent && errorValidation) {\r\n            const errorMessages: ValidationMessage[] = errorValidation.getAllErrorMessagesOfMyValidationFields();\r\n            for (let i: number = 0, len: number = errorMessages.length; i < len; i++) {\r\n                const errorMsg: ValidationMessage = errorMessages[i];\r\n                const configName: string = this.dataName ? this.dataName : this.screenConfigurationObject;\r\n                if (errorMsg.fieldId === configName && this._element /*&& this._properHost(errorMsg.boId)*/) {\r\n                    this.hostComponent.redErrorBackground = true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    private _moduleInReadonlyMode(): boolean {\r\n        return !this.noModuleService ? (this._moduleService ? this._moduleService.readonly : false) : false;\r\n    }\r\n\r\n    private _mayUpdateHost(): boolean {\r\n        return !!this.hostComponent && !this._isTurnedOff && !!this.screenConfigurationObject;\r\n    }\r\n\r\n    private _setHostVisible(visible: boolean): void {\r\n        if (!this.screenConfigNativeElement) {\r\n            this.hostComponent.hidden = !visible;\r\n        } else {\r\n            if (this._element && this._element.nativeElement) {\r\n                if (!visible) {\r\n                    this._renderer.addClass(this._element.nativeElement, 'hidden');\r\n                } else {\r\n                    this._renderer.removeClass(this._element.nativeElement, 'hidden');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/directives/screen-configuration/screen-configuration.module.js

@@ -1,7 +1,6 @@
 import { NgModule } from '@angular/core';
-import { ScreenConfigurationDirective } from "./screen-configuration.directive";
-import { CommonModule } from "@angular/common";
-import { ScreenConfigComponentWrapper } from "./screen-config-component-wrapper.component";
+import { ScreenConfigurationDirective } from './screen-configuration.directive';
+import { CommonModule } from '@angular/common';
 export class ScreenConfigurationModule {
 }
 ScreenConfigurationModule.decorators = [
@@ -10,12 +9,11 @@ ScreenConfigurationModule.decorators = [
                     CommonModule
                 ],
                 declarations: [
-                    ScreenConfigurationDirective,
-                    ScreenConfigComponentWrapper
+                    ScreenConfigurationDirective
                 ],
                 exports: [
                     ScreenConfigurationDirective,
                 ]
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyZWVuLWNvbmZpZ3VyYXRpb24ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9kaXJlY3RpdmVzL3NjcmVlbi1jb25maWd1cmF0aW9uL3NjcmVlbi1jb25maWd1cmF0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyw0QkFBNEIsRUFBQyxNQUFNLGtDQUFrQyxDQUFDO0FBQzlFLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsNEJBQTRCLEVBQUMsTUFBTSw2Q0FBNkMsQ0FBQztBQWN6RixNQUFNLE9BQU8seUJBQXlCOzs7WUFackMsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWiw0QkFBNEI7b0JBQzVCLDRCQUE0QjtpQkFDN0I7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLDRCQUE0QjtpQkFDN0I7YUFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1NjcmVlbkNvbmZpZ3VyYXRpb25EaXJlY3RpdmV9IGZyb20gXCIuL3NjcmVlbi1jb25maWd1cmF0aW9uLmRpcmVjdGl2ZVwiO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcbmltcG9ydCB7U2NyZWVuQ29uZmlnQ29tcG9uZW50V3JhcHBlcn0gZnJvbSBcIi4vc2NyZWVuLWNvbmZpZy1jb21wb25lbnQtd3JhcHBlci5jb21wb25lbnRcIjtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZVxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBTY3JlZW5Db25maWd1cmF0aW9uRGlyZWN0aXZlLFxuICAgIFNjcmVlbkNvbmZpZ0NvbXBvbmVudFdyYXBwZXJcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFNjcmVlbkNvbmZpZ3VyYXRpb25EaXJlY3RpdmUsXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgU2NyZWVuQ29uZmlndXJhdGlvbk1vZHVsZSB7IH1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyZWVuLWNvbmZpZ3VyYXRpb24ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9kaXJlY3RpdmVzL3NjcmVlbi1jb25maWd1cmF0aW9uL3NjcmVlbi1jb25maWd1cmF0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyw0QkFBNEIsRUFBQyxNQUFNLGtDQUFrQyxDQUFDO0FBQzlFLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQWE3QyxNQUFNLE9BQU8seUJBQXlCOzs7WUFYckMsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWiw0QkFBNEI7aUJBQzdCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCw0QkFBNEI7aUJBQzdCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7U2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZX0gZnJvbSAnLi9zY3JlZW4tY29uZmlndXJhdGlvbi5kaXJlY3RpdmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgU2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZVxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgU2NyZWVuQ29uZmlndXJhdGlvbkRpcmVjdGl2ZSxcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBTY3JlZW5Db25maWd1cmF0aW9uTW9kdWxlIHsgfVxuIl19

package/esm2015/lib/service/base-module-screen-config.service.js

@@ -0,0 +1,205 @@
+import { __awaiter } from "tslib";
+// Base screen configuration service for one "screen module", e.g. 'Crm'. Db-loads, stores and and interprets ObjectConfiguration config objects.
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ArrayUtils } from '@colijnit/ioneconnector/build/utils/array-utils';
+import { DEFAULT_GET_OBJECT_CONFIGURATION_PARAMS } from '@colijnit/ioneconnector/build/model/default-get-object-configurations-params';
+import { ObjectConfiguration } from '@colijnit/ioneconnector/build/model/object-configuration';
+export class BaseModuleScreenConfigService {
+    constructor() {
+        // emits the params of the loaded config, each time when a new config was loaded
+        this.configSet = new BehaviorSubject([]);
+        this._configObjects = [];
+        // key: configName, value: the ObjectConfiguration with that configName. For faster ObjectConfiguration lookups, given a configName string (vs. array).
+        this._objectConfigsMap = new Map();
+    }
+    get configObjects() {
+        return this._configObjects;
+    }
+    // POST: this.configObjects are loaded. Returns the loaded config objects.
+    loadConfig(params = DEFAULT_GET_OBJECT_CONFIGURATION_PARAMS, insertRights) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configObjects = yield this.loadConfigForModule(params, insertRights);
+            this._configObjects = configObjects;
+            if (configObjects && Array.isArray(configObjects)) {
+                this._buildScreenConfigMap();
+                this.configSet.next(params);
+            }
+            return this._configObjects;
+        });
+    }
+    lazyLoadConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.configObjects.length) {
+                yield this.loadConfig();
+            }
+        });
+    }
+    isActiveFieldValidationObject(configObject) {
+        if (configObject) {
+            return configObject.isActiveFieldValidationObject() && !this.isDataNameHiddenByAnyOfItsParentRubrics(configObject.dataName);
+        }
+    }
+    isBoValid(bo) {
+        if (this.controlValidityByBoMap && !ArrayUtils.IsEmptyArray(this.controlValidityByBoMap)) {
+            const mapEntry = this.controlValidityByBoMap.find(value => value.bo === bo && value.valid === false);
+            if (mapEntry) {
+                return mapEntry.valid;
+            }
+        }
+        return true;
+    }
+    getObjectConfigurationFor(configName) {
+        const configuration = this._objectConfigsMap.get(configName);
+        // If configuration not found by configname, try by data name
+        if (!!this._objectConfigsMap.size && !configuration && configName) {
+            const configNameByDataName = this._getConfigNameByDataName(configName);
+            if (this._objectConfigsMap.get(configNameByDataName)) {
+                return this._objectConfigsMap.get(configNameByDataName);
+            } /*else if (!environment.production) {
+                console.warn("No configuration object was found by the name of: ", configName, " or dataname ", configNameByDataName);
+            }*/
+        }
+        return configuration;
+    }
+    setObjectConfigurationFor(configName, configObject) {
+        this._objectConfigsMap.set(configName, configObject);
+    }
+    // Whether the user may read the component that's associated with given config object (visibility).
+    mayRead(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.mayRead() : false;
+    }
+    isReadonly(configName) {
+        return !this.mayWrite(configName);
+    }
+    // Whether the user may write onto the component that's associated with given config object.
+    mayWrite(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.mayWrite() : false;
+    }
+    // Whether the component associated with given config object should, from the start, be visible to the user.
+    immediatelyVisible(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.immediatelyVisible() : false;
+    }
+    // Whether the component associated with given config object should, from the start, be visible to the user.
+    immediatelyHidden(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.immediatelyHidden() : false;
+    }
+    noRights(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.noRights() : false;
+    }
+    isHidden(configName) {
+        return !this.immediatelyVisible(configName);
+    }
+    isRequired(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? !objectConfig.nullable : false;
+    }
+    getDefaultValue(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultValue() : undefined;
+    }
+    getDefaultStringValue(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultStringValue() : undefined;
+    }
+    getDefaultNumberValue(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultNumberValue() : undefined;
+    }
+    getMaxLength(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.maxLength : undefined;
+    }
+    getDecimals(configName) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.scale : undefined;
+    }
+    hasConfigObjects() {
+        return this._configObjects && this._configObjects.length > 0 && this._objectConfigsMap.size > 0;
+    }
+    isKind(configName, kind) {
+        const objectConfig = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.isKind(kind) : false;
+    }
+    isDataNameHiddenByItselfOrAnyOfItsParentRubrics(dataName) {
+        const isHiddenItself = ArrayUtils.ContainsAnElementFoundBy(this._configObjects, ((item) => {
+            return item.dataName === dataName && item.isHidden();
+        }));
+        if (isHiddenItself) {
+            return true;
+        }
+        else {
+            return this.isDataNameHiddenByAnyOfItsParentRubrics(dataName);
+        }
+    }
+    isDataNameHiddenByAnyOfItsParentRubrics(dataName) {
+        // if (this._hardCodedConfigStructure) {
+        //     const parentConfigNames: string[] = this._hardCodedConfigStructure.getParentConfigNamesOfFieldConfigName(this._getConfigNameByDataName(dataName));
+        //     if (parentConfigNames) {
+        //         for (let i: number = 0, len: number = parentConfigNames.length; i < len; i++) {
+        //             const parentConfigObj: ObjectConfiguration = this.getObjectConfigurationFor(parentConfigNames[i]);
+        //             if (parentConfigObj && parentConfigObj.isHidden()) {
+        //                 return true;
+        //             }
+        //         }
+        //     }
+        //     return false;
+        // }
+        return false;
+    }
+    // return the first found config name for given data name
+    _getConfigNameByDataName(dataName) {
+        const itsConfigObject = this._getConfigObjectByDataName(dataName);
+        if (itsConfigObject) {
+            return itsConfigObject.configName;
+        }
+    }
+    // return the first found config object with given data name
+    _getConfigObjectByDataName(dataName) {
+        return ArrayUtils.Find(this._configObjects, (cfgObj) => {
+            return cfgObj.dataName === dataName;
+        });
+    }
+    // PRE: this.configObjects is loaded. POST: this._objectConfigsMap contains the latest map of configName -> to -> ObjectConfiguration for a live screen module.
+    _buildScreenConfigMap() {
+        this._objectConfigsMap.clear();
+        this.configObjects.forEach(item => this._objectConfigsMap.set(item.configName, item));
+    }
+    setScreenConfigurationObjectsReadOnly(value) {
+        this.configObjects.forEach((object) => {
+            const copy = Object.assign(new ObjectConfiguration(), object);
+            copy.variableReadOnly = value;
+            this.setObjectConfigurationFor(object.configName, copy);
+        });
+    }
+    setScreenConfigurationObjectsRedErrorBackground(errorValidation, setAllFalse = false) {
+        if (setAllFalse) {
+            this.configObjects.forEach((object) => {
+                const copy = Object.assign(new ObjectConfiguration(), object);
+                copy.redErrorBackground = false;
+                this.setObjectConfigurationFor(object.configName, copy);
+            });
+        }
+        else if (errorValidation) {
+            const errorMessages = errorValidation.getAllErrorMessagesOfMyValidationFields();
+            for (let i = 0, len = errorMessages.length; i < len; i++) {
+                const errorMsg = errorMessages[i];
+                const configObject = this.configObjects.find(object => object.configName === errorMsg.fieldId);
+                if (configObject) {
+                    const copy = Object.assign(new ObjectConfiguration(), configObject);
+                    copy.redErrorBackground = false;
+                    this.setObjectConfigurationFor(configObject.configName, copy);
+                }
+            }
+        }
+    }
+}
+BaseModuleScreenConfigService.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-module-screen-config.service.js","sourceRoot":"","sources":["../../../../../projects/corecomponents/src/lib/service/base-module-screen-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Base screen configuration service for one \"screen module\", e.g. 'Crm'. Db-loads, stores and and interprets ObjectConfiguration config objects.\r\nimport {Injectable} from '@angular/core';\r\nimport {BehaviorSubject, Subject} from 'rxjs';\r\nimport {ArrayUtils} from '@colijnit/ioneconnector/build/utils/array-utils';\r\nimport {BusinessObject} from '@colijnit/ioneconnector/build/model/business-object';\r\nimport {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';\r\nimport {ObjectConfigurationDefaultValueType} from '@colijnit/ioneconnector/build/type/object-configuration-default-value-type';\r\nimport {ObjectConfigKind} from '@colijnit/ioneconnector/build/enum/object-config-kind';\r\nimport {ValidationMessage} from '@colijnit/ioneconnector/build/model/validation-message';\r\nimport {DEFAULT_GET_OBJECT_CONFIGURATION_PARAMS} from '@colijnit/ioneconnector/build/model/default-get-object-configurations-params';\r\nimport {ObjectConfiguration} from '@colijnit/ioneconnector/build/model/object-configuration';\r\n\r\n@Injectable()\r\nexport abstract class BaseModuleScreenConfigService {\r\n    // manually given module name\r\n    public abstract screenModuleName: string;\r\n\r\n    // emits the params of the loaded config, each time when a new config was loaded\r\n    public readonly configSet: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);\r\n\r\n    public get configObjects(): ObjectConfiguration[] {\r\n        return this._configObjects;\r\n    }\r\n\r\n    public controlValidityByBoMap: {bo: BusinessObject, controlKey: string, valid: boolean}[];\r\n\r\n    private _configObjects: ObjectConfiguration[] = [];\r\n\r\n    // key: configName, value: the ObjectConfiguration with that configName. For faster ObjectConfiguration lookups, given a configName string (vs. array).\r\n    private _objectConfigsMap: Map<string, ObjectConfiguration> = new Map<string, ObjectConfiguration>();\r\n\r\n    // POST: this.configObjects are loaded. Returns the loaded config objects.\r\n    public async loadConfig(params: string[] = DEFAULT_GET_OBJECT_CONFIGURATION_PARAMS, insertRights?: boolean): Promise<ObjectConfiguration[]> {\r\n        const configObjects: ObjectConfiguration[] = await this.loadConfigForModule(params, insertRights);\r\n        this._configObjects = configObjects;\r\n        if (configObjects && Array.isArray(configObjects)) {\r\n            this._buildScreenConfigMap();\r\n            this.configSet.next(params);\r\n        }\r\n        return this._configObjects;\r\n    }\r\n\r\n    public async lazyLoadConfig(): Promise<void> {\r\n        if (!this.configObjects.length) {\r\n            await this.loadConfig();\r\n        }\r\n    }\r\n\r\n    public isActiveFieldValidationObject(configObject: ObjectConfiguration): boolean {\r\n        if (configObject) {\r\n            return configObject.isActiveFieldValidationObject() && !this.isDataNameHiddenByAnyOfItsParentRubrics(configObject.dataName);\r\n        }\r\n    }\r\n\r\n    public isBoValid(bo: BusinessObject): boolean {\r\n        if (this.controlValidityByBoMap && !ArrayUtils.IsEmptyArray(this.controlValidityByBoMap)) {\r\n            const mapEntry: {bo: BusinessObject, controlKey: string, valid: boolean} = this.controlValidityByBoMap.find(value => value.bo === bo && value.valid === false);\r\n            if (mapEntry) {\r\n                return mapEntry.valid;\r\n            }\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public getObjectConfigurationFor(configName: string): ObjectConfiguration {\r\n        const configuration: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n\r\n        // If configuration not found by configname, try by data name\r\n        if (!!this._objectConfigsMap.size && !configuration && configName) {\r\n            const configNameByDataName: string = this._getConfigNameByDataName(configName);\r\n\r\n            if (this._objectConfigsMap.get(configNameByDataName)) {\r\n                return this._objectConfigsMap.get(configNameByDataName);\r\n            } /*else if (!environment.production) {\r\n                console.warn(\"No configuration object was found by the name of: \", configName, \" or dataname \", configNameByDataName);\r\n            }*/\r\n        }\r\n\r\n        return configuration;\r\n    }\r\n\r\n    public setObjectConfigurationFor(configName: string, configObject: ObjectConfiguration): void {\r\n        this._objectConfigsMap.set(configName, configObject);\r\n    }\r\n\r\n    // Whether the user may read the component that's associated with given config object (visibility).\r\n    public mayRead(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.mayRead() : false;\r\n    }\r\n\r\n    public isReadonly(configName: string): boolean {\r\n        return !this.mayWrite(configName);\r\n    }\r\n\r\n    // Whether the user may write onto the component that's associated with given config object.\r\n    public mayWrite(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.mayWrite() : false;\r\n    }\r\n\r\n    // Whether the component associated with given config object should, from the start, be visible to the user.\r\n    public immediatelyVisible(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.immediatelyVisible() : false;\r\n    }\r\n\r\n    // Whether the component associated with given config object should, from the start, be visible to the user.\r\n    public immediatelyHidden(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.immediatelyHidden() : false;\r\n    }\r\n\r\n    public noRights(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.noRights() : false;\r\n    }\r\n\r\n    public isHidden(configName: string): boolean {\r\n        return !this.immediatelyVisible(configName);\r\n    }\r\n\r\n    public isRequired(configName: string): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? !objectConfig.nullable : false;\r\n    }\r\n\r\n    public getDefaultValue(configName: string): ObjectConfigurationDefaultValueType {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.getDefaultValue() : undefined;\r\n    }\r\n\r\n    public getDefaultStringValue(configName: string): string {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.getDefaultStringValue() : undefined;\r\n    }\r\n\r\n    public getDefaultNumberValue(configName: string): number {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.getDefaultNumberValue() : undefined;\r\n    }\r\n\r\n    public getMaxLength(configName: string): number {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.maxLength : undefined;\r\n    }\r\n\r\n    public getDecimals(configName: string): number {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.scale : undefined;\r\n    }\r\n\r\n    public hasConfigObjects(): boolean {\r\n        return this._configObjects && this._configObjects.length > 0 && this._objectConfigsMap.size > 0;\r\n    }\r\n\r\n    public isKind(configName: string, kind: ObjectConfigKind): boolean {\r\n        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);\r\n        return objectConfig ? objectConfig.isKind(kind) : false;\r\n    }\r\n\r\n    public isDataNameHiddenByItselfOrAnyOfItsParentRubrics(dataName: string): boolean {\r\n        const isHiddenItself: boolean = ArrayUtils.ContainsAnElementFoundBy(this._configObjects, ((item: ObjectConfiguration) => {\r\n            return item.dataName === dataName && item.isHidden();\r\n        }));\r\n        if (isHiddenItself) {\r\n            return true;\r\n        } else {\r\n            return this.isDataNameHiddenByAnyOfItsParentRubrics(dataName);\r\n        }\r\n    }\r\n\r\n    // needs to be implemented by descendants\r\n    protected abstract loadConfigForModule(params: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;\r\n\r\n    private isDataNameHiddenByAnyOfItsParentRubrics(dataName: string): boolean {\r\n        // if (this._hardCodedConfigStructure) {\r\n        //     const parentConfigNames: string[] = this._hardCodedConfigStructure.getParentConfigNamesOfFieldConfigName(this._getConfigNameByDataName(dataName));\r\n        //     if (parentConfigNames) {\r\n        //         for (let i: number = 0, len: number = parentConfigNames.length; i < len; i++) {\r\n        //             const parentConfigObj: ObjectConfiguration = this.getObjectConfigurationFor(parentConfigNames[i]);\r\n        //             if (parentConfigObj && parentConfigObj.isHidden()) {\r\n        //                 return true;\r\n        //             }\r\n        //         }\r\n        //     }\r\n        //     return false;\r\n        // }\r\n        return false;\r\n    }\r\n\r\n    // return the first found config name for given data name\r\n    private _getConfigNameByDataName(dataName: string): string {\r\n        const itsConfigObject: ObjectConfiguration = this._getConfigObjectByDataName(dataName);\r\n        if (itsConfigObject) {\r\n            return itsConfigObject.configName;\r\n        }\r\n    }\r\n\r\n    // return the first found config object with given data name\r\n    private _getConfigObjectByDataName(dataName: string): ObjectConfiguration {\r\n        return ArrayUtils.Find(this._configObjects, (cfgObj: ObjectConfiguration) => {\r\n            return cfgObj.dataName === dataName;\r\n        });\r\n    }\r\n\r\n    // PRE: this.configObjects is loaded. POST: this._objectConfigsMap contains the latest map of configName -> to -> ObjectConfiguration for a live screen module.\r\n    private _buildScreenConfigMap(): void {\r\n        this._objectConfigsMap.clear();\r\n        this.configObjects.forEach(item => this._objectConfigsMap.set(item.configName, item));\r\n    }\r\n\r\n    public setScreenConfigurationObjectsReadOnly(value: boolean): void {\r\n        this.configObjects.forEach((object: ObjectConfiguration) => {\r\n            const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), object);\r\n            copy.variableReadOnly = value;\r\n            this.setObjectConfigurationFor(object.configName, copy);\r\n        });\r\n    }\r\n\r\n    public setScreenConfigurationObjectsRedErrorBackground(errorValidation: ValidationResult, setAllFalse: boolean = false): void {\r\n        if (setAllFalse) {\r\n            this.configObjects.forEach((object: ObjectConfiguration) => {\r\n                const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), object);\r\n                copy.redErrorBackground = false;\r\n                this.setObjectConfigurationFor(object.configName, copy);\r\n            });\r\n        } else if (errorValidation) {\r\n            const errorMessages: ValidationMessage[] = errorValidation.getAllErrorMessagesOfMyValidationFields();\r\n            for (let i: number = 0, len: number = errorMessages.length; i < len; i++) {\r\n                const errorMsg: ValidationMessage = errorMessages[i];\r\n                const configObject: ObjectConfiguration = this.configObjects.find(object => object.configName === errorMsg.fieldId);\r\n                if (configObject) {\r\n                    const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), configObject);\r\n                    copy.redErrorBackground = false;\r\n                    this.setObjectConfigurationFor(configObject.configName, copy);\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/service/base-module.service.js

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { BaseModuleScreenConfigService } from './base-module-screen-config.service';
+/**
+ * Base class for top-level services of CRUD-style iOne modules (the Relation, Article and Transaction modules).
+ * What sets these modules apart, is the concept of a relatively bulky, 'single businessobject' being manipulated throughout all the tabs.
+ *
+ * Many other (smaller?) iOne modules work with multiple LISTS of different business object types instead.
+ */
+export class BaseModuleService {
+    constructor(screenConfigService) {
+        this.screenConfigService = screenConfigService;
+        this.readonlyChange = new Subject();
+        // Emits this each time a new error validation was received. (there will be zero error tooltips on the screen after this fires)
+        this.errorValidationReceived = new Subject();
+        // Emits once after succesful BO update (i.e. there were no errors)
+        this.successfulUpdate = new Subject();
+        this._readonly = true;
+        this._subscriptions = [];
+        this._subscriptions.push(this.errorValidationReceived.subscribe((errorValidation) => this.screenConfigService.setScreenConfigurationObjectsRedErrorBackground(errorValidation)), this.successfulUpdate.subscribe(() => this.screenConfigService.setScreenConfigurationObjectsRedErrorBackground(null, true)), this.readonlyChange.subscribe((readOnly) => this.screenConfigService.setScreenConfigurationObjectsReadOnly(readOnly)));
+    }
+    // Whether the module is in readonly modus or not. Input fields etc. will be readonly throughout the module.
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(readonly) {
+        if (this._readonly !== readonly) {
+            this._readonly = readonly;
+            this.readonlyChange.next(this._readonly);
+        }
+    }
+    ngOnDestroy() {
+        this._subscriptions.forEach((subscription) => subscription.unsubscribe());
+    }
+}
+BaseModuleService.decorators = [
+    { type: Injectable }
+];
+BaseModuleService.ctorParameters = () => [
+    { type: BaseModuleScreenConfigService }
+];
+//# sourceMappingURL=data:application/json;base64,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