@colijnit/corecomponents_v12 12.2.23 → 12.2.25

package/projects/corecomponents/src/lib/pipes/filter.pipe.ts

@@ -0,0 +1,14 @@
+import {Pipe, PipeTransform} from "@angular/core";
+
+@Pipe({
+  name: "filter",
+  pure: false
+})
+export class FilterPipe implements PipeTransform {
+  transform(items: any[], field: string, value: any): any {
+    if (!items || !field) {
+      return items;
+    }
+    return items.filter(item => item[field] === value);
+  }
+}

package/projects/corecomponents/src/lib/pipes/master-pipe.module.ts

@@ -0,0 +1,13 @@
+import {MasterPipe} from "./master.pipe";
+import {NgModule} from "@angular/core";
+
+@NgModule({
+    declarations: [
+        MasterPipe
+    ],
+    exports: [
+        MasterPipe
+    ]
+})
+export class MasterPipeModule {
+}

package/projects/corecomponents/src/lib/pipes/master.pipe.ts

@@ -0,0 +1,71 @@
+import {Pipe, PipeTransform} from "@angular/core";
+import {DatePipe, LowerCasePipe, UpperCasePipe} from "@angular/common";
+import {notNill} from "../core/function/not-nill.function";
+import {UCfirstPipe} from "./ucfirst.pipe";
+import {CoCurrencyPipe} from "./co-currency.pipe";
+import {EnumKeysPipe} from "./emun-keys.pipe";
+
+@Pipe({
+    name: "master"
+})
+export class MasterPipe implements PipeTransform {
+
+    constructor(/*private _dictionaryService: DictionaryService*/) {
+    }
+
+    transform(value: any, pipe: string): string {
+        if (!pipe) {
+            if (notNill(value)) {
+                return value;
+            } else {
+                return "";
+            }
+        }
+        const pipes: string[] = pipe.split('|');
+        pipes.forEach((p: string) => {
+            p = p.trim();
+            if (p) {
+                const pipeParts: string[] = p.split(':');
+                const pipeName: string = pipeParts.shift();
+                let pipeInstance: PipeTransform;
+                switch (pipeName) {
+                    //todo support localize pipe (but how to implement, we don't have any localization in core components yet)?
+                    /*
+                    case 'localize':
+                        pipeInstance = new LocalizePipe(this._dictionaryService);
+                        break;
+                    */
+                    case 'ucfirst':
+                        pipeInstance = new UCfirstPipe();
+                        break;
+                    case 'uppercase':
+                        pipeInstance = new UpperCasePipe();
+                        break;
+                    case 'lowercase':
+                        pipeInstance = new LowerCasePipe();
+                        break;
+                    case 'date':
+                        // todo give proper locale info to date pipe (but where does this info reside?! We don't have localization yet)
+                        pipeInstance = new DatePipe("nl-NL");
+                        break;
+                    case 'coCurrency':
+                        pipeInstance = new CoCurrencyPipe();
+                        break;
+                    // todo support coDefault pipe (but we don't have any localization mechanism yet)
+                    /*
+                    case 'coDefault':
+                        pipeInstance = new DefaultPipe(this._dictionaryService); //NOSONAR
+                        break;
+                    */
+                    case 'enumkeys':
+                        pipeInstance = new EnumKeysPipe();
+                        break;
+                }
+                if (pipeInstance) {
+                    value = pipeInstance.transform(value, ...pipeParts);
+                }
+            }
+        });
+        return value;
+    }
+}

package/projects/corecomponents/src/lib/pipes/prepend.pipe.module.ts

@@ -0,0 +1,13 @@
+import {NgModule} from '@angular/core';
+import {PrependPipe} from './prepend.pipe';
+
+@NgModule({
+  declarations: [
+    PrependPipe
+  ],
+  exports: [
+    PrependPipe
+  ]
+})
+export class PrependPipeModule {
+}

package/projects/corecomponents/src/lib/pipes/prepend.pipe.ts

@@ -0,0 +1,17 @@
+import {Pipe, PipeTransform} from "@angular/core";
+
+// A pipe for prepending strings to other strings in view templates.
+@Pipe({name: "prepend"})
+export class PrependPipe implements PipeTransform {
+  transform(value: string, prepend?: string): string {
+    if (!value) {
+      return "";
+    }
+
+    if (!prepend) {
+      return value;
+    }
+
+    return prepend + value;
+  }
+}

package/projects/corecomponents/src/lib/pipes/price-display-pipe.module.ts

@@ -0,0 +1,14 @@
+import {NgModule} from "@angular/core";
+
+import {PriceDisplayPipe} from "./price-display.pipe";
+
+@NgModule({
+    declarations: [
+        PriceDisplayPipe
+    ],
+    exports: [
+        PriceDisplayPipe
+    ]
+})
+export class PriceDisplayPipeModule {
+}

package/projects/corecomponents/src/lib/pipes/price-display.pipe.ts

@@ -0,0 +1,20 @@
+import {Pipe, PipeTransform} from "@angular/core";
+import {NumberUtils} from "../core/utils/number-utils";
+import {notNill} from "../core/function/not-nill.function";
+
+@Pipe({name: "priceDisplay"})
+export class PriceDisplayPipe implements PipeTransform {
+    transform(value: number | string): string {
+        let priceStr: string = "";
+
+        if (notNill(value) && value !== 0 && value !== "") {
+            value = NumberUtils.ParseFloat(value, 2);
+            priceStr = "€ " + NumberUtils.AddThousandsCommasTo(value);
+            if (NumberUtils.GetDecimalPlaces(priceStr) === 0) {
+                priceStr += ",-";
+            }
+        }
+
+        return priceStr;
+    }
+}

package/projects/corecomponents/src/lib/pipes/safe-style.pipe.module.ts

@@ -0,0 +1,13 @@
+import {NgModule} from "@angular/core";
+import {SafeStylePipe} from "./safe-style.pipe";
+
+@NgModule({
+    declarations: [
+        SafeStylePipe
+    ],
+    exports: [
+        SafeStylePipe
+    ]
+})
+export class SafeStylePipeModule {
+}

package/projects/corecomponents/src/lib/pipes/safe-style.pipe.ts

@@ -0,0 +1,14 @@
+import {Pipe, PipeTransform} from "@angular/core";
+import {DomSanitizer, SafeStyle} from "@angular/platform-browser";
+
+@Pipe({
+    name: "safeStyle"
+})
+export class SafeStylePipe implements PipeTransform {
+
+    constructor(private _sanitizer: DomSanitizer) {}
+
+    transform(value: string): SafeStyle | any {
+        return this._sanitizer.bypassSecurityTrustStyle(value);
+    }
+}

package/projects/corecomponents/src/lib/pipes/ucfirst-pipe.module.ts

@@ -0,0 +1,13 @@
+import {NgModule} from "@angular/core";
+import {UCfirstPipe} from "./ucfirst.pipe";
+
+@NgModule({
+    declarations: [
+        UCfirstPipe
+    ],
+    exports: [
+        UCfirstPipe
+    ]
+})
+export class UcfirstPipeModule {
+}

package/projects/corecomponents/src/lib/pipes/ucfirst.pipe.ts

@@ -0,0 +1,14 @@
+import {Pipe, PipeTransform} from "@angular/core";
+
+@Pipe({
+    name: "ucfirst"
+})
+// Pipe capable of transforming the first character of a string-value to upper case.
+export class UCfirstPipe implements PipeTransform {
+    transform(value: string): string {
+        if (typeof value === 'string') {
+            return value.charAt(0).toUpperCase() + value.slice(1);
+        }
+        return value;
+    }
+}

package/projects/corecomponents/src/lib/service/base-module-screen-config.service.ts

@@ -0,0 +1,241 @@
+// 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, Subject} from 'rxjs';
+import {ArrayUtils} from '@colijnit/ioneconnector/build/utils/array-utils';
+import {BusinessObject} from '@colijnit/ioneconnector/build/model/business-object';
+import {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';
+import {ObjectConfigurationDefaultValueType} from '@colijnit/ioneconnector/build/type/object-configuration-default-value-type';
+import {ObjectConfigKind} from '@colijnit/ioneconnector/build/enum/object-config-kind';
+import {ValidationMessage} from '@colijnit/ioneconnector/build/model/validation-message';
+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';
+
+@Injectable()
+export abstract class BaseModuleScreenConfigService {
+    // manually given module name
+    public abstract screenModuleName: string;
+
+    // emits the params of the loaded config, each time when a new config was loaded
+    public readonly configSet: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);
+
+    public get configObjects(): ObjectConfiguration[] {
+        return this._configObjects;
+    }
+
+    public controlValidityByBoMap: {bo: BusinessObject, controlKey: string, valid: boolean}[];
+
+    private _configObjects: ObjectConfiguration[] = [];
+
+    // key: configName, value: the ObjectConfiguration with that configName. For faster ObjectConfiguration lookups, given a configName string (vs. array).
+    private _objectConfigsMap: Map<string, ObjectConfiguration> = new Map<string, ObjectConfiguration>();
+
+    // POST: this.configObjects are loaded. Returns the loaded config objects.
+    public async loadConfig(params: string[] = DEFAULT_GET_OBJECT_CONFIGURATION_PARAMS, insertRights?: boolean): Promise<ObjectConfiguration[]> {
+        const configObjects: ObjectConfiguration[] = await this.loadConfigForModule(params, insertRights);
+        this._configObjects = configObjects;
+        if (configObjects && Array.isArray(configObjects)) {
+            this._buildScreenConfigMap();
+            this.configSet.next(params);
+        }
+        return this._configObjects;
+    }
+
+    public async lazyLoadConfig(): Promise<void> {
+        if (!this.configObjects.length) {
+            await this.loadConfig();
+        }
+    }
+
+    public isActiveFieldValidationObject(configObject: ObjectConfiguration): boolean {
+        if (configObject) {
+            return configObject.isActiveFieldValidationObject() && !this.isDataNameHiddenByAnyOfItsParentRubrics(configObject.dataName);
+        }
+    }
+
+    public isBoValid(bo: BusinessObject): boolean {
+        if (this.controlValidityByBoMap && !ArrayUtils.IsEmptyArray(this.controlValidityByBoMap)) {
+            const mapEntry: {bo: BusinessObject, controlKey: string, valid: boolean} = this.controlValidityByBoMap.find(value => value.bo === bo && value.valid === false);
+            if (mapEntry) {
+                return mapEntry.valid;
+            }
+        }
+        return true;
+    }
+
+    public getObjectConfigurationFor(configName: string): ObjectConfiguration {
+        const configuration: ObjectConfiguration = this._objectConfigsMap.get(configName);
+
+        // If configuration not found by configname, try by data name
+        if (!!this._objectConfigsMap.size && !configuration && configName) {
+            const configNameByDataName: string = 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;
+    }
+
+    public setObjectConfigurationFor(configName: string, configObject: ObjectConfiguration): void {
+        this._objectConfigsMap.set(configName, configObject);
+    }
+
+    // Whether the user may read the component that's associated with given config object (visibility).
+    public mayRead(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.mayRead() : false;
+    }
+
+    public isReadonly(configName: string): boolean {
+        return !this.mayWrite(configName);
+    }
+
+    // Whether the user may write onto the component that's associated with given config object.
+    public mayWrite(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = 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.
+    public immediatelyVisible(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = 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.
+    public immediatelyHidden(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.immediatelyHidden() : false;
+    }
+
+    public noRights(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.noRights() : false;
+    }
+
+    public isHidden(configName: string): boolean {
+        return !this.immediatelyVisible(configName);
+    }
+
+    public isRequired(configName: string): boolean {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? !objectConfig.nullable : false;
+    }
+
+    public getDefaultValue(configName: string): ObjectConfigurationDefaultValueType {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultValue() : undefined;
+    }
+
+    public getDefaultStringValue(configName: string): string {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultStringValue() : undefined;
+    }
+
+    public getDefaultNumberValue(configName: string): number {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.getDefaultNumberValue() : undefined;
+    }
+
+    public getMaxLength(configName: string): number {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.maxLength : undefined;
+    }
+
+    public getDecimals(configName: string): number {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.scale : undefined;
+    }
+
+    public hasConfigObjects(): boolean {
+        return this._configObjects && this._configObjects.length > 0 && this._objectConfigsMap.size > 0;
+    }
+
+    public isKind(configName: string, kind: ObjectConfigKind): boolean {
+        const objectConfig: ObjectConfiguration = this._objectConfigsMap.get(configName);
+        return objectConfig ? objectConfig.isKind(kind) : false;
+    }
+
+    public isDataNameHiddenByItselfOrAnyOfItsParentRubrics(dataName: string): boolean {
+        const isHiddenItself: boolean = ArrayUtils.ContainsAnElementFoundBy(this._configObjects, ((item: ObjectConfiguration) => {
+            return item.dataName === dataName && item.isHidden();
+        }));
+        if (isHiddenItself) {
+            return true;
+        } else {
+            return this.isDataNameHiddenByAnyOfItsParentRubrics(dataName);
+        }
+    }
+
+    // needs to be implemented by descendants
+    protected abstract loadConfigForModule(params: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;
+
+    private isDataNameHiddenByAnyOfItsParentRubrics(dataName: string): boolean {
+        // 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
+    private _getConfigNameByDataName(dataName: string): string {
+        const itsConfigObject: ObjectConfiguration = this._getConfigObjectByDataName(dataName);
+        if (itsConfigObject) {
+            return itsConfigObject.configName;
+        }
+    }
+
+    // return the first found config object with given data name
+    private _getConfigObjectByDataName(dataName: string): ObjectConfiguration {
+        return ArrayUtils.Find(this._configObjects, (cfgObj: ObjectConfiguration) => {
+            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.
+    private _buildScreenConfigMap(): void {
+        this._objectConfigsMap.clear();
+        this.configObjects.forEach(item => this._objectConfigsMap.set(item.configName, item));
+    }
+
+    public setScreenConfigurationObjectsReadOnly(value: boolean): void {
+        this.configObjects.forEach((object: ObjectConfiguration) => {
+            const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), object);
+            copy.variableReadOnly = value;
+            this.setObjectConfigurationFor(object.configName, copy);
+        });
+    }
+
+    public setScreenConfigurationObjectsRedErrorBackground(errorValidation: ValidationResult, setAllFalse: boolean = false): void {
+        if (setAllFalse) {
+            this.configObjects.forEach((object: ObjectConfiguration) => {
+                const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), object);
+                copy.redErrorBackground = false;
+                this.setObjectConfigurationFor(object.configName, copy);
+            });
+        } else if (errorValidation) {
+            const errorMessages: ValidationMessage[] = errorValidation.getAllErrorMessagesOfMyValidationFields();
+            for (let i: number = 0, len: number = errorMessages.length; i < len; i++) {
+                const errorMsg: ValidationMessage = errorMessages[i];
+                const configObject: ObjectConfiguration = this.configObjects.find(object => object.configName === errorMsg.fieldId);
+                if (configObject) {
+                    const copy: ObjectConfiguration = Object.assign(new ObjectConfiguration(), configObject);
+                    copy.redErrorBackground = false;
+                    this.setObjectConfigurationFor(configObject.configName, copy);
+                }
+            }
+        }
+    }
+}

package/projects/corecomponents/src/lib/service/base-module.service.ts

@@ -0,0 +1,50 @@
+import {Injectable, OnDestroy} from '@angular/core';
+import {Subject, Subscription} from 'rxjs';
+import {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';
+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.
+ */
+@Injectable()
+export abstract class BaseModuleService implements OnDestroy {
+    public readonly readonlyChange: Subject<boolean> = new Subject<boolean>();
+    // Emits this each time a new error validation was received. (there will be zero error tooltips on the screen after this fires)
+    public readonly errorValidationReceived: Subject<ValidationResult> = new Subject<ValidationResult>();
+    // Emits once after succesful BO update (i.e. there were no errors)
+    public readonly successfulUpdate: Subject<void> = new Subject<void>();
+
+    // Whether the module is in readonly modus or not. Input fields etc. will be readonly throughout the module.
+    public get readonly(): boolean {
+        return this._readonly;
+    }
+
+    public set readonly(readonly: boolean) {
+        if (this._readonly !== readonly) {
+            this._readonly = readonly;
+            this.readonlyChange.next(this._readonly);
+        }
+    }
+
+    protected _readonly: boolean = true;
+
+    private _subscriptions: Subscription[] = [];
+
+    constructor(
+        protected screenConfigService: BaseModuleScreenConfigService
+    ) {
+        this._subscriptions.push(
+            this.errorValidationReceived.subscribe((errorValidation: ValidationResult) => this.screenConfigService.setScreenConfigurationObjectsRedErrorBackground(errorValidation)),
+            this.successfulUpdate.subscribe(() => this.screenConfigService.setScreenConfigurationObjectsRedErrorBackground(null, true)),
+            this.readonlyChange.subscribe((readOnly: boolean) => this.screenConfigService.setScreenConfigurationObjectsReadOnly(readOnly))
+        )
+    }
+
+    ngOnDestroy() {
+        this._subscriptions.forEach((subscription: Subscription) => subscription.unsubscribe());
+    }
+
+}

package/projects/corecomponents/src/lib/service/color-sequence.service.ts

@@ -0,0 +1,20 @@
+import {Injectable} from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ColorSequenceService {
+
+  public colors: Map<number, string> = new Map<number, string>();
+
+  public getRandomColor(id: number): string {
+    if (this.colors.has(id)) {
+      return this.colors.get(id);
+    }
+    const randomColor = Math.floor(Math.random() * 16777215).toString(16);
+    const result: string = '#' + randomColor;
+    this.colors.set(id, result);
+    return result;
+  }
+
+}

package/projects/corecomponents/src/lib/service/overlay.service.ts

@@ -0,0 +1,81 @@
+import {ApplicationRef, ComponentFactoryResolver, ComponentRef, ElementRef, EmbeddedViewRef, Injectable, Injector} from '@angular/core';
+
+@Injectable()
+export class OverlayService {
+
+    private _componentRefs: Map<any, ComponentRef<any>> = new Map<any, ComponentRef<any>>();
+
+    constructor(
+        private _componentFactoryResolver: ComponentFactoryResolver,
+        private _appRef: ApplicationRef,
+        private _injector: Injector
+    ) {
+    }
+
+    public createComponent(compClass: any, inputs: any, events?: any): ComponentRef<any> {
+      if (this._componentRefExists(compClass)) {
+        this._removeComponentRef(compClass);
+      }
+        const componentRef = this._componentFactoryResolver
+            .resolveComponentFactory(compClass)
+            .create(this._injector);
+
+        if (inputs) {
+            for (let property in inputs) {
+                if (inputs.hasOwnProperty(property)) {
+                    componentRef.instance[property] = inputs[property];
+                }
+            }
+        }
+
+        if (events) {
+            for (let event in events) {
+                if (events.hasOwnProperty(event)) {
+                  componentRef.instance[event].subscribe((value) => events[event](value));
+                }
+            }
+        }
+
+        this._appRef.attachView(componentRef.hostView);
+
+        const domElem = (componentRef.hostView as EmbeddedViewRef<any>)
+            .rootNodes[0] as HTMLElement;
+
+        document.body.appendChild(domElem);
+
+        componentRef.onDestroy(() => {
+            this._appRef.detachView(componentRef.hostView);
+        });
+
+        this._componentRefs.set(compClass, componentRef);
+        return componentRef;
+    }
+
+    public removeComponent(componentRef: ComponentRef<any>): void {
+        if (componentRef) {
+            const compClass: any = this._getClassFromComponentRef(componentRef);
+            componentRef.destroy();
+            this._componentRefs.delete(compClass);
+        }
+    }
+
+    private _componentRefExists(compClass: any): boolean {
+        return this._componentRefs.has(compClass);
+    }
+
+    private _removeComponentRef(compClass: any): void {
+        const componentRef: ComponentRef<any> = this._componentRefs.get(compClass);
+        this.removeComponent(componentRef);
+    }
+
+    private _getClassFromComponentRef(componentRef: ComponentRef<any>): any {
+        let result: any;
+        this._componentRefs.forEach((value: ComponentRef<any>, key: any) => {
+            if (value === componentRef) {
+                result = key;
+                return;
+            }
+        });
+        return result;
+    }
+}

package/projects/corecomponents/src/lib/translation/core-components-translation.module.ts

@@ -0,0 +1,27 @@
+import {ModuleWithProviders, NgModule} from '@angular/core';
+import {CoreComponentsTranslationService} from './core-components-translation.service';
+import {CoreDictionaryService} from './core-dictionary.service';
+import {CoreLocalizePipe} from './core-localize.pipe';
+
+@NgModule({
+    declarations: [
+        CoreLocalizePipe
+    ],
+    providers: [
+        CoreComponentsTranslationService,
+        CoreDictionaryService
+    ],
+    exports: [
+        CoreLocalizePipe
+    ]
+})
+export class CoreComponentsTranslationModule {
+    static forRoot(): ModuleWithProviders<CoreComponentsTranslationModule> {
+        return {
+            ngModule: CoreComponentsTranslationModule,
+            providers: [
+                CoreComponentsTranslationService
+            ]
+        };
+    }
+}

package/projects/corecomponents/src/lib/translation/core-components-translation.service.ts

@@ -0,0 +1,15 @@
+import {Injectable} from '@angular/core';
+import {CoreDictionaryService} from './core-dictionary.service';
+
+@Injectable()
+export class CoreComponentsTranslationService {
+
+    constructor(
+        private _dictionaryService: CoreDictionaryService
+    ) {
+    }
+
+    public setTranslation(translation: {}): void {
+        this._dictionaryService.translation = translation;
+    }
+}