@colijnit/transaction 12.1.77 → 12.1.78

package/projects/transaction/src/lib/cache/cache-field.ts

@@ -0,0 +1,91 @@
+import {EventEmitter} from "@angular/core";
+
+// Class represents a value that is to be loaded only once, lazily, by its .loadFunction, despite how many times or how fast its getValue() is called.
+export class CacheField<T> {
+  public readonly onLoad: EventEmitter<any> = new EventEmitter<any>();
+
+  // The value of this cache field. Warning: might not have been loaded yet. Call ensureLoaded() or getvalue() for true value.
+  public get value(): T {
+    return this._value;
+  }
+
+  public set value(value: T) {
+    this._value = value;
+    this._promiseValue = Promise.resolve(value);
+    this._isLoaded = true;
+  }
+
+  // Whether the value has been loaded or not.
+  public get isLoaded(): boolean {
+    return this._isLoaded;
+  }
+
+  // Whether the value is currently loading or not.
+  public get isLoading(): boolean {
+    return !this._isLoaded && (this._promiseValue !== null && this._promiseValue !== undefined);
+  }
+
+  public get loadNeverCalled(): boolean {
+    return !this.isLoading && !this.isLoaded;
+  }
+
+  // Assign the load function to this field. The function should return a promise that resolves with the value as data.
+  public loadFunction: (params?: any) => Promise<T>;
+
+  private _promiseValue: Promise<T>;
+  private _value: T;
+  private _isLoaded: boolean = false;
+
+  constructor() {
+  }
+
+  // Loads and returns the value. Only loads from db if it wasn't loaded before (or forceReload was given true)
+  public getValue(forceReload?: boolean): Promise<T> {
+    return this.ensureLoaded(forceReload);
+  }
+
+  public setValue(value: any): void { //NOSONAR
+    this.value = value;
+  }
+
+  /**
+   * POSTCONDITION: The .value of this cache field contains the loaded value as fetched by the resolve data of its .loadFunction.
+   * Will load only once, consecutive calls will resolve immediately or wait until the first original database fetch was finished.
+   * @returns {Promise<any>} Postcondition holds after resolve
+   */
+  public ensureLoaded(forceReload?: boolean): Promise<T> {
+    if (!forceReload && this._promiseValue) {
+      return this._promiseValue;
+    } else {
+      return this._load();
+    }
+  }
+
+  // POSTCONDITION: The .value of this cache field contains a freshly loaded value as fetched by the resolve data of its loadFunction.
+  public reload(): Promise<T> {
+    return this.ensureLoaded(true);
+  }
+
+  // Resets / invaldates this cache field. Makes sure that the next load() will really perform its load function body again (e.g. visit the DB,
+  // if that's ur function)
+  public reset(): void {
+    this._value = undefined;
+    this._promiseValue = undefined;
+    this._isLoaded = false;
+  }
+
+  private _load(): Promise<T> {
+    if (this.loadFunction) {
+      this._promiseValue = this.loadFunction.call(this);
+      this._promiseValue.then((value: T) => {
+        this._value = value;
+        this._isLoaded = true;
+        this.onLoad.emit();
+        return value;
+      });
+      return this._promiseValue;
+    } else {
+      return Promise.resolve(undefined);
+    }
+  }
+}

package/projects/transaction/src/lib/cache/parameter-cache-field.ts

@@ -0,0 +1,63 @@
+import {CacheField} from "./cache-field";
+import {ObjectUtils} from "@colijnit/ioneconnector/build/utils/object-utils";
+
+// Class represents cached values retrieved by a load function that is to be called only once per unique input parameter combination.
+export class ParameterCacheField<T> {
+  public loadFunction: (...params: any[]) => Promise<T>;
+
+  // A map from cache params (keys: the loadFunction arguments) to their cache fields
+  private _paramsToCacheItems: Map<any[], CacheField<T>> = new Map<any[], CacheField<T>>();
+
+  constructor() {
+  }
+
+  // Returns the value for given loadfunction parameters. Loads if not yet loaded.
+  public getValue(...params: any[]): Promise<T> {
+    return this._getCacheField(params).getValue();
+  }
+
+  public setValue(value: any, ...params: any[]): void {
+    return this._getCacheField(params).setValue(value);
+  }
+
+  // Returns the freshly reloaded value for given loadfunction parameters.
+  public reload(...params: any[]): Promise<T> {
+    return this._getCacheField(params).reload();
+  }
+
+  // Resets one or all cache items. If no params given, resets ALL cache items.
+  public reset(...params: any[]): void {
+    if (params && params.length > 0) {
+      this._getCacheField(params).reset();
+    } else {
+      this._paramsToCacheItems.forEach(cacheItem => cacheItem.reset());
+      this._paramsToCacheItems.clear();
+      this._paramsToCacheItems = new Map<any, CacheField<T>>(); // not sure if clear() is enough for garbage collector?
+    }
+  }
+
+  // Makes a new cache field if none existed for these params. Returns the cache field that matches given params.
+  private _getCacheField(params: any[]): CacheField<T> {
+    let existingCacheField: CacheField<T> = undefined;
+
+    this._paramsToCacheItems.forEach((value: CacheField<T>, key: any[]) => {
+      if (!existingCacheField && ObjectUtils.DeepEquals(params, key)) {
+        existingCacheField = value;
+      }
+    });
+
+    if (existingCacheField) {
+      return existingCacheField;
+    } else {
+      return this._makeNewCacheField(params);
+    }
+  }
+
+  // Creates and returns a new loadField for given params
+  private _makeNewCacheField(params: any[]): CacheField<T> {
+    const cacheField: CacheField<T> = new CacheField<T>();
+    cacheField.loadFunction = this.loadFunction.bind(cacheField, ...params);
+    this._paramsToCacheItems.set(params, cacheField);
+    return cacheField;
+  }
+}

package/projects/transaction/src/lib/cache/service/business-object-cache-manager.service.ts

@@ -0,0 +1,194 @@
+import {Injectable, OnDestroy} from "@angular/core";
+import {Subject, Subscription} from "rxjs";
+import {CacheField} from "../cache-field";
+import {ParameterCacheField} from "../parameter-cache-field";
+import {BusinessObject} from "@colijnit/ioneconnector/build/model/business-object";
+import {ObjectUtils} from "@colijnit/ioneconnector/build/utils/object-utils";
+import {BusinessObjectIDType} from "@colijnit/ioneconnector/build/type/business-object-id-type";
+
+/**
+ * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.
+ *
+ * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.
+ *
+ * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually
+ * LOAD these cache items from the database, or what exact types the items are.
+ *
+ * All caches are reset when the user logs out.
+ */
+@Injectable({
+    providedIn: "root"
+  }
+)
+export class BusinessObjectCacheManagerService implements OnDestroy {
+  // emits after this BO cache manager has been reset (e.g. after user logs out)
+  public readonly reset: Subject<void> = new Subject<void>();
+
+  private static _NullBoId: number = -1;
+
+  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+  private _selectMultipleCache: Map<any, CacheField<BusinessObject[]>> = new Map();
+
+  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+  private _selectMultipleParameterizedCache: Map<any, ParameterCacheField<BusinessObject[]>>
+    = new Map<any, ParameterCacheField<BusinessObject[]>>();
+
+  private _selectSingleCache: Map<{ new(): BusinessObject }, { [id: string]: CacheField<BusinessObject> }> = new Map();
+  private _selectSingleParameterizedCache: Map<any, ParameterCacheField<BusinessObject>>
+    = new Map<any, ParameterCacheField<BusinessObject>>();
+
+  private _logoutSub: Subscription;
+
+  // constructor(private _transactionService: TransactionService) {
+  //   this._logoutSub = this._transactionService.logout.subscribe(() => {
+  //     this._reset();
+  //   });
+  // }
+
+  ngOnDestroy(): void {
+    this._logoutSub.unsubscribe();
+  }
+
+  /**
+   * Creates and adds a new simple cache item for the given key with the given load function.
+   * @param key
+   * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }
+   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+   * @returns The newly created cache item.
+   */
+  public addNewSelectMultipleCacheItem<T extends BusinessObject>(
+    key: any,
+    loadFunction: () => Promise<T[]>,
+    overrideOld: boolean = false
+  ): CacheField<T[]> {
+    if (!overrideOld && this._selectMultipleCache.has(key)) {
+      return;
+    }
+
+    const newCacheItem: CacheField<T[]> = new CacheField<T[]>();
+    newCacheItem.loadFunction = loadFunction;
+    this._selectMultipleCache.set(key, newCacheItem);
+    return newCacheItem;
+  }
+
+  public addNewSelectSingleCacheItem<T extends BusinessObject>(
+    key: { new(): T },
+    id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId,
+    loadFunction: () => Promise<T>,
+    overrideOld: boolean = false
+  ): CacheField<T> {
+    const cacheId: string = id.toString();
+    if (!overrideOld && this.hasSingleCacheItem(key, id)) {
+      return;
+    }
+    if (!this._selectSingleCache.has(key)) {
+      this._selectSingleCache.set(key, {});
+    }
+    const newCacheItem: CacheField<T> = new CacheField<T>();
+    newCacheItem.loadFunction = loadFunction;
+    this._selectSingleCache.get(key)[cacheId] = newCacheItem;
+    return newCacheItem;
+  }
+
+  public addNewSelectSingleParameterizedCacheItem<T extends BusinessObject>(
+    key: any,
+    loadFunction: (params?: any) => Promise<T>,
+    overrideOld: boolean = false
+  ): ParameterCacheField<T> {
+    if (!overrideOld && this._selectSingleParameterizedCache.has(key)) {
+      return;
+    }
+
+    const newCacheItem: ParameterCacheField<T> = new ParameterCacheField<T>();
+    newCacheItem.loadFunction = loadFunction;
+    this._selectSingleParameterizedCache.set(key, newCacheItem);
+    return newCacheItem;
+  }
+
+  /**
+   * Creates and adds a new parameterized cache item for the given key with the given load function.
+   * @param key
+   * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }
+   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+   */
+  public addNewSelectMultipleParameterizedCacheItem<T extends BusinessObject>(
+    key: any,
+    loadFunction: (params?: any) => Promise<T[]>,
+    overrideOld: boolean = false
+  ): ParameterCacheField<T[]> {
+    if (!overrideOld && this._selectMultipleParameterizedCache.has(key)) {
+      return;
+    }
+
+    const newCacheItem: ParameterCacheField<T[]> = new ParameterCacheField<T[]>();
+    newCacheItem.loadFunction = loadFunction;
+    this._selectMultipleParameterizedCache.set(key, newCacheItem);
+    return newCacheItem;
+  }
+
+  public hasSelectMultipleCacheItem(key: any): boolean {
+    return this._selectMultipleCache.has(key);
+  }
+
+  public hasSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId): boolean {
+    const cacheId: string = id.toString();
+    return this._selectSingleCache.has(key) && !!this._selectSingleCache.get(key)[cacheId];
+  }
+
+  public hasSelectMultipleParameterizedCacheItem(key: any): boolean {
+    return this._selectMultipleParameterizedCache.has(key);
+  }
+
+  public hasSelectSingleParameterizedCacheItem(key: any): boolean {
+    return this._selectSingleParameterizedCache.has(key);
+  }
+
+  // Returns the simple cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+  public getSelectMultipleCacheItem<T extends BusinessObject>(key: any): CacheField<T[]> {
+    return <CacheField<T[]>>this._selectMultipleCache.get(key);
+  }
+
+  public getSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId): CacheField<T> {
+    const cacheId: string = id.toString();
+    return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId] as CacheField<T>;
+  }
+
+  // Returns the parameterized cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+  public getSelectMultipleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T[]> {
+    return <ParameterCacheField<T[]>>this._selectMultipleParameterizedCache.get(key);
+  }
+
+  public getSelectSingleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T> {
+    return <ParameterCacheField<T>>this._selectSingleParameterizedCache.get(key);
+  }
+
+  private _reset(): void {
+    this._selectMultipleCache.forEach((cacheItem: CacheField<BusinessObject[]>) => {
+      if (cacheItem) {
+        cacheItem.reset();
+      }
+    });
+
+    this._selectSingleCache.forEach((cache: { [p: string]: CacheField<BusinessObject> }) => {
+      if (cache) {
+        ObjectUtils.ForOwnProperty(cache, (cacheField: CacheField<BusinessObject>) => {
+          cacheField.reset();
+        });
+      }
+    });
+
+    this._selectSingleParameterizedCache.forEach((selSinParamCacheItem: ParameterCacheField<BusinessObject>) => {
+      if (selSinParamCacheItem) {
+        selSinParamCacheItem.reset();
+      }
+    });
+
+    this._selectMultipleParameterizedCache.forEach((selMulParamCacheItem: ParameterCacheField<BusinessObject[]>) => {
+      if (selMulParamCacheItem) {
+        selMulParamCacheItem.reset();
+      }
+    });
+
+    this.reset.next();
+  }
+}

package/projects/transaction/src/lib/cache/service/select-multiple-cache.service.ts

@@ -0,0 +1,36 @@
+import {Injectable} from "@angular/core";
+import {BusinessObjectCacheManagerService} from "./business-object-cache-manager.service";
+import {CacheField} from "../cache-field";
+import {BusinessObject} from "@colijnit/ioneconnector/build/model/business-object";
+
+@Injectable({
+  providedIn: "root"
+})
+export class SelectMultipleCacheService {
+  private static _NullCache: CacheField<any> = new CacheField<any>();
+
+  constructor(
+    private _boCacheManager: BusinessObjectCacheManagerService
+  ) {
+  }
+
+  /**
+   * Returns the global cache item for the select multiple of the given business object class. Creates a new cache item if not yet exists.
+   * @param clazz The BO class, e.g. CustomerFullObject
+   * @returns {CacheField<T[]>}
+   */
+  public requestCache<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: () => Promise<T[]>): CacheField<T[]> {
+    if (!this._boCacheManager.hasSelectMultipleCacheItem(clazz)) {
+      this._createCacheItem<T>(clazz, loadFunction);
+    }
+
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.getSelectMultipleCacheItem<T>(clazz);
+  }
+
+  // Creates and returns a new select multiple cache item into the global business object cache manager for given business object class.
+  private _createCacheItem<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: () => Promise<T[]>): CacheField<T[]> {
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.addNewSelectMultipleCacheItem<T>(clazz, loadFunction);
+  }
+}

package/projects/transaction/src/lib/cache/service/select-multiple-parameterized-cache.service.ts

@@ -0,0 +1,46 @@
+import {Injectable, OnDestroy} from "@angular/core";
+import {Subject, Subscription} from "rxjs";
+import {BusinessObjectCacheManagerService} from "./business-object-cache-manager.service";
+import {BusinessObject} from "@colijnit/ioneconnector/build/model/business-object";
+import {ParameterCacheField} from "../parameter-cache-field";
+
+// service resonsible for filling the global BO cache manager service with parameterized select multiple cache items
+@Injectable({
+  providedIn: "root"
+})
+export class SelectMultipleParameterizedCacheService implements OnDestroy {
+  // emits after this select multiple parameterized cache service has been reset (e.g. after user logs out)
+  public readonly reset: Subject<void> = new Subject<void>();
+
+  private _subs: Subscription[] = [];
+
+  constructor(private _boCacheManager: BusinessObjectCacheManagerService) {
+    this._subs.push(this._boCacheManager.reset.subscribe(() => {
+      this.reset.next();
+    }));
+  }
+
+  ngOnDestroy(): void {
+    this._subs.forEach(sub => sub.unsubscribe());
+  }
+
+  /**
+   * Returns the global cache item for the parameterized select multiple of the given business object class. Creates a new cache item if not yet exists.
+   * @param clazz The BO class, used for undeflying dataService.selectMultiple(clazz) call.
+   * @returns {CacheField<T[]>}
+   */
+  public requestCache<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: (...params: any) => Promise<T[]>): ParameterCacheField<T[]> {
+    if (!this._boCacheManager.hasSelectMultipleParameterizedCacheItem(clazz)) {
+      this._createParameterizedCacheItem<T>(clazz, loadFunction);
+    }
+
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.getSelectMultipleParameterCacheItem<T>(clazz);
+  }
+
+  // Creates and returns a new  parameterized select multiple cache item into the global business object cache manager for given business object class.
+  private _createParameterizedCacheItem<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: (...params: any) => Promise<T[]>): ParameterCacheField<T[]> {
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.addNewSelectMultipleParameterizedCacheItem<T>(clazz, loadFunction);
+  }
+}

package/projects/transaction/src/lib/cache/service/select-single-cache.service.ts

@@ -0,0 +1,28 @@
+import {Injectable} from "@angular/core";
+import {BusinessObjectCacheManagerService} from "./business-object-cache-manager.service";
+import {BusinessObject} from "@colijnit/ioneconnector/build/model/business-object";
+import {CacheField} from "../cache-field";
+import {BusinessObjectIDType} from "@colijnit/ioneconnector/build/type/business-object-id-type";
+
+@Injectable({
+  providedIn: "root"
+})
+export class SelectSingleCacheService {
+
+  constructor(private _boCacheManager: BusinessObjectCacheManagerService) {
+  }
+
+  public requestCache<T extends BusinessObject>(clazz: { new(): T }, sourceId: BusinessObjectIDType, loadFunction: () => Promise<T>): CacheField<T> {
+    if (!this._boCacheManager.hasSingleCacheItem<T>(clazz, sourceId)) {
+      this._createCacheItem<T>(clazz, sourceId, loadFunction);
+    }
+
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.getSingleCacheItem<T>(clazz, sourceId);
+  }
+
+  private _createCacheItem<T extends BusinessObject>(clazz: { new(): T }, sourceId: BusinessObjectIDType, loadFunction: () => Promise<T>): CacheField<T> {
+    // noinspection TypeScriptValidateTypes
+    return this._boCacheManager.addNewSelectSingleCacheItem<T>(clazz, sourceId, loadFunction);
+  }
+}

package/projects/transaction/src/lib/component/animated-checkbox/animated-checkbox.component.ts

@@ -0,0 +1,26 @@
+import {Component, HostBinding, Input, ViewEncapsulation} from "@angular/core";
+
+@Component({
+  selector: "co-animated-checkbox",
+  template: `
+    <div class="checkbox">
+      <div class="checkmark" [class.show]="checked"></div>
+    </div>
+    <div class="label" *ngIf="label" [textContent]="label | localize"></div>
+  `,
+  encapsulation: ViewEncapsulation.None
+})
+export class AnimatedCheckboxComponent {
+
+  @Input()
+  public checked: boolean = false;
+
+  @Input()
+  public label: string;
+
+  @HostBinding("class.co-animated-checkbox")
+  public showClass() {
+    return true;
+  }
+
+}

package/projects/transaction/src/lib/component/animated-checkbox/animated-checkbox.module.ts

@@ -0,0 +1,19 @@
+import {NgModule} from "@angular/core";
+import {CommonModule} from "@angular/common";
+import {AnimatedCheckboxComponent} from "./animated-checkbox.component";
+import {PipeModule} from "../../pipe/pipe.module";
+
+@NgModule({
+    imports: [
+        CommonModule,
+        PipeModule
+    ],
+  declarations: [
+    AnimatedCheckboxComponent
+  ],
+  exports: [
+    AnimatedCheckboxComponent
+  ]
+})
+export class AnimatedCheckboxModule {
+}

package/projects/transaction/src/lib/component/avatar/avatar.component.ts

@@ -0,0 +1,120 @@
+import {AfterViewInit, Component, HostBinding, Input, ViewEncapsulation} from "@angular/core";
+import {TransactionService} from "../../service/transaction.service";
+import {RelationRequest} from "@colijnit/relationapi/build/model/relation-request";
+import {SharedService} from "../../service/shared.service";
+import {ColorSequenceService} from "@colijnit/corecomponents_v12";
+import {CoDocument} from "@colijnit/mainapi/build/model/co-document";
+import {RelationListObject} from "@colijnit/relationapi/build/model/relation-list-object.bo";
+import {RelationService} from "../../service/relation.service";
+
+@Component({
+  selector: "co-avatar",
+  template: `
+    <co-image-display [model]="imageSrc" *ngIf="imageSrc; else showInitials"></co-image-display>
+    <ng-template #showInitials>
+      <svg viewBox="0 0 30 30">
+        <text x="50%" y="50%" dominant-baseline="central" text-anchor="middle">{{ initials }}</text>
+      </svg>
+    </ng-template>
+  `,
+  encapsulation: ViewEncapsulation.None
+})
+export class AvatarComponent implements AfterViewInit {
+  @Input()
+  public set image(value: CoDocument) {
+    this._image = value;
+    this._getImageSrcFromCoDocument();
+  }
+
+  public get image(): CoDocument {
+    return this._image;
+  }
+
+  @Input()
+  public set relationId(value: number) {
+    this._relationId = value;
+  }
+
+  public get relationId(): number {
+    return this._relationId;
+  }
+
+  @Input()
+  public relation: RelationListObject;
+
+  @HostBinding("class.co-avatar")
+  public showClass(): boolean {
+    return true;
+  }
+
+  public set initials(value: string) {
+    this._initials = value;
+    this._setBackgroundColor();
+  }
+
+  public get initials(): string {
+    return this._initials;
+  }
+
+  public imageSrc: string;
+
+  @HostBinding("style.background-color")
+  public backgroundColor: string;
+
+  private _initials: string;
+  private _relationId: number;
+  private _image: CoDocument;
+
+  constructor(
+    private _transactionService: TransactionService,
+    private _sharedService: SharedService,
+    private _colorSequenceService: ColorSequenceService,
+    private _relationService: RelationService
+  ) {
+  }
+
+  ngAfterViewInit(): void {
+    this._getRelation();
+  }
+
+  private _getRelation(): void {
+    if (!isNaN(this._relationId) && !this.image) {
+      const request: RelationRequest = new RelationRequest();
+      request.relationId = this._relationId;
+      this._relationService.getRelationListObjects(request).then((data) => {
+        if (data && data.length > 0) {
+          this.relation = data[0];
+          if (this.relation && this.relation.image && this.relation.image.documentId) {
+            this._sharedService.getDocumentContent(this.relation.image.documentId)
+              .then((content: string) => {
+                this.imageSrc = content;
+              })
+              .catch((e) => {
+                this.imageSrc = "";
+              })
+          }
+          this.initials = this.relation.displayInitials;
+        }
+      });
+    }
+  }
+
+  private _getImageSrcFromCoDocument(): void {
+    if (this.image) {
+      this._sharedService.getDocumentContent(this.image.documentId)
+        .then((content: string) => {
+          this.image.thumbnailBody = content;
+          this.imageSrc = this.image.thumbnailBodyAsDataUri;
+        })
+        .catch((e) => {
+          this.imageSrc = "";
+        })
+    }
+  }
+
+  private _setBackgroundColor(): void {
+    if (this.relation) {
+      this.backgroundColor = this._colorSequenceService.getRandomColor(this.relation.relationId);
+    }
+  }
+}

package/projects/transaction/src/lib/component/avatar/avatar.module.ts

@@ -0,0 +1,20 @@
+import {NgModule} from "@angular/core";
+import {CommonModule} from "@angular/common";
+import {AvatarComponent} from "./avatar.component";
+import {CoreModule} from "../core/core.module";
+
+@NgModule({
+  imports: [
+    CommonModule,
+    CoreModule
+  ],
+  declarations: [
+    AvatarComponent
+  ],
+  exports: [
+    AvatarComponent
+  ]
+})
+export class AvatarModule {
+
+}