taxtank-core 0.31.61 → 0.32.1

package/esm2022/lib/services/http/rest/rest.service.mjs

@@ -0,0 +1,302 @@
+import { Inject, Injectable, inject } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { catchError, first, map } from 'rxjs/operators';
+import { SseService } from '../../event';
+import { classToPlain } from 'class-transformer';
+import { ObservableModel } from '../../../db/Models';
+import { AppEvent2 } from '../../../models';
+import { toArray } from '../../../functions/array';
+import { DataService } from '../../data.service';
+import { MixpanelService } from '../../mixpanel/mixpanel.service';
+import { throwError as observableThrowError } from 'rxjs';
+import { ToastService } from '../../toast';
+import intersection from 'lodash/intersection';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event";
+/**
+ * Abstract base service that implements common services functionality
+ * and describe abstract methods/properties that have to be implemented in child services
+ * Model - entity service is working with
+ * BaseModel - base entity model that extends by Model
+ * CollectionModel - entity collection class
+ */
+export class RestService extends DataService {
+    constructor(http, eventDispatcherService, environment) {
+        super();
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        /**
+         * Subject for service cache
+         */
+        this.cacheSubject = new ReplaySubject(1);
+        /**
+         * List of methods unavailable for current API
+         * @TODO Alex: add and handle enabled methods too
+         * @TODO Alex: disable batch by default
+         */
+        this.disabledMethods = [];
+        this.mpService = inject(MixpanelService);
+        this.sseService = inject(SseService);
+        this.toastService = inject(ToastService);
+        this.roles = [];
+        /**
+         * disable cache update by requests, update only by SSE events
+         */
+        this.disableCache = false;
+        // @TODO Alex remove, bad idea to call empty method overrided in child (because it will be called with parent context)
+        this.listenEvents();
+        // @TODO Alex remove, bad idea to call empty method overrided in child (because it will be called with parent context)
+        this.listenSSE();
+    }
+    get apiUrl() {
+        return `${this.environment.apiV2}/${this.endpointUri}`;
+    }
+    setCache(data, next = false) {
+        super.setCache(data);
+        if (next) {
+            this.cacheSubject.next(this.cache);
+        }
+    }
+    /**
+     * Refresh cache with actual backend data
+     */
+    refreshCache() {
+        this.cache = undefined;
+        this.get();
+    }
+    /**
+     * Get data from backend and fill the cache
+     */
+    fetch(path = this.apiUrl) {
+        this.handleAccessError('get');
+        if (!this.hasRoles()) {
+            this.setCache([], true);
+            return this.cacheSubject.asObservable();
+        }
+        // Set cache as empty collection to avoid multiple requests before cache filled
+        this.setCache([]);
+        return this.http.get(path)
+            .pipe(map((response) => this.isApiPlatform ? response['hydra:member'] : toArray(response)), map((response) => {
+            this.setCache(response, true);
+            return this.cache;
+        }));
+    }
+    get(path = this.apiUrl) {
+        if (!this.cache) {
+            this.fetch(path).pipe(first()).subscribe();
+        }
+        return this.cacheSubject.asObservable();
+    }
+    getFirst() {
+        this.handleAccessError('get');
+        return this.get().pipe(map((collection) => collection.first));
+    }
+    hasInCache(id) {
+        return !!this.getCache().findBy('id', id);
+    }
+    getArray() {
+        return this.get().pipe(map((collection) => collection.toArray()));
+    }
+    /**
+     * Create a new Model instance in database
+     */
+    post(model, mpData, path = this.apiUrl) {
+        this.handleAccessError('post');
+        return this.http.post(path, classToPlain(model))
+            .pipe(map((response) => {
+            const result = this.createModelInstance(response);
+            this.handleResponse([result], 'post', mpData);
+            return result;
+        }), catchError((error) => {
+            this.handleResponseError([model], 'post', mpData);
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Create multiple new Model instances in database
+     */
+    postBatch(models) {
+        this.handleAccessError('postBatch');
+        return this.http.post(this.apiUrl, classToPlain(models))
+            .pipe(map((response) => {
+            const result = response.map((item) => this.createModelInstance(item));
+            this.handleResponse(result, 'post');
+            return result;
+        }), catchError((error) => {
+            this.handleResponseError(models, 'post');
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Change an existing Model instance in database
+     */
+    put(model, mpData, path = `${this.apiUrl}/${model.id}`) {
+        this.handleAccessError('put');
+        return this.http.put(path, classToPlain(model))
+            .pipe(map((response) => {
+            const result = this.createModelInstance(response);
+            this.handleResponse([result], 'put', mpData);
+            return result;
+        }), catchError((error) => {
+            this.handleResponseError([model], 'put', mpData);
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Change multiple existing Model instances in database
+     */
+    putBatch(models) {
+        this.handleAccessError('putBatch');
+        return this.http.put(this.apiUrl, classToPlain(models))
+            .pipe(map((response) => {
+            const result = response.map((item) => this.createModelInstance(item));
+            this.handleResponse(result, 'put');
+            return result;
+        }), catchError((error) => {
+            this.handleResponseError(models, 'put');
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Remove a Model instance from database
+     */
+    delete(model, mpData) {
+        this.handleAccessError('delete');
+        return this.http.delete(`${this.apiUrl}/${model.id}`)
+            .pipe(map(() => {
+            this.handleResponse([model], 'delete', mpData);
+        }), catchError((error) => {
+            this.handleResponseError([model], 'delete', mpData);
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Remove multiple Model instances from database
+     */
+    deleteBatch(models) {
+        this.handleAccessError('deleteBatch');
+        return this.http.post(`${this.apiUrl}/delete`, classToPlain(models))
+            .pipe(map(() => {
+            this.handleResponse(models, 'delete');
+        }), catchError((error) => {
+            this.handleResponseError(models, 'delete');
+            return observableThrowError(error);
+        }));
+    }
+    track(response, method, mpData, postfix = '') {
+        // check if result exist, sometimes response may be empty (for example ClientInvite accept/reject/etc)
+        if (!response[0]) {
+            return;
+        }
+        // no other way to check interface
+        if ('getMpData' in response[0]) {
+            response.forEach((model) => {
+                this.mpService.track(`${method}${this.modelClass.name}${postfix}`, model['getMpData'](mpData));
+            });
+        }
+    }
+    handleResponseError(response, method, mpData) {
+        // @TODO error notification?
+        this.track(response, method, mpData, 'Error');
+    }
+    /**
+     * Handle response data - update cache and dispatch event if it is needed
+     */
+    handleResponse(response, method, mpData) {
+        this.track(response, method, mpData);
+        if (this.getCache() && !this.disableCache) {
+            this.updateCache(response, method);
+        }
+        // dispatch event for interested services
+        if (response[0] instanceof ObservableModel) {
+            this.dispatchEvent(method, response);
+        }
+    }
+    /**
+     * Update cache with passed items. Add/Update detects automatically, Delete via optional flag
+     */
+    updateCache(items, method) {
+        let cache;
+        switch (method) {
+            case 'post':
+                cache = this.cache.push(...items);
+                break;
+            case 'put':
+                // @TODO Alex old instance
+                items.forEach((item) => {
+                    cache = this.cache.replaceBy('id', item.id, item);
+                });
+                break;
+            case 'delete':
+                cache = this.cache.removeBy('id', items.map((item) => item.id));
+                break;
+            case 'get':
+                cache = this.createCollectionInstance(this.collectionClass, items);
+        }
+        this.setCache(cache.toArray(), true);
+    }
+    /**
+     * Generate and dispatch rest event
+     */
+    dispatchEvent(method, items) {
+        const eventName = this.modelClass.getEventName(method);
+        this.eventDispatcherService.dispatch2(new AppEvent2(eventName, items));
+    }
+    /**
+     * Check if method is not disabled. Throw exception otherwise.
+     * Some entities does not have endpoints for all methods.
+     */
+    handleAccessError(method) {
+        if (!this.disabledMethods.includes(method)) {
+            return;
+        }
+        throw new Error(`Method ${method}() is not allowed for ${this.constructor.name}`);
+    }
+    /**
+     * Subscribe to http events and run callback.
+     * CSE - Cleint Sent Events
+     * @param modelClass
+     * @param methods The list of http methods should be listened for
+     * @param callback The function to be called when event triggered
+     */
+    listenCSE(modelClass, methods, callback) {
+        callback = callback.bind(this);
+        methods.forEach((method) => {
+            this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data) => {
+                callback(data);
+            });
+        });
+    }
+    /**
+     * check if user has subscription role to access api
+     */
+    hasRoles() {
+        if (!this.roles.length) {
+            return true;
+        }
+        return !!intersection(JSON.parse(localStorage.getItem('roles')), this.roles).length;
+    }
+    /**
+     * // @TODO Alex remove
+     * Method that call all listeners. Empty by default. Should be redefined by child services if required
+     */
+    listenEvents() { }
+    /**
+     * Listen SSE events
+     */
+    listenSSE() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/rest/rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, inject } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { catchError, first, map } from 'rxjs/operators';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { EventDispatcherService, SseService } from '../../event';\nimport { classToPlain } from 'class-transformer';\nimport { IEventListener } from '../../../interfaces';\nimport { Collection } from '../../../collections';\nimport { AbstractModel, ObservableModel } from '../../../db/Models';\nimport { AppEvent2 } from '../../../models';\nimport { toArray } from '../../../functions/array';\nimport { RestMethod } from './rest-method.type';\nimport { HttpMethod } from './http-method.type';\nimport { DataService } from '../../data.service';\nimport { UserRolesEnum } from '../../../db/Enums/user-roles.enum';\nimport { MixpanelService } from '../../mixpanel/mixpanel.service';\nimport { throwError as observableThrowError } from 'rxjs';\nimport { ToastService } from '../../toast';\nimport intersection from 'lodash/intersection';\n\n/**\n * Abstract base service that implements common services functionality\n * and describe abstract methods/properties that have to be implemented in child services\n * Model - entity service is working with\n * BaseModel - base entity model that extends by Model\n * CollectionModel - entity collection class\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport abstract class RestService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>>\n  extends DataService<BaseModel, Model, CollectionModel> implements IEventListener {\n\n  /**\n   * Url part for service entity API\n   */\n  protected abstract endpointUri: string;\n  /**\n   * Subject for service cache\n   */\n  protected cacheSubject: ReplaySubject<CollectionModel> = new ReplaySubject(1);\n  /**\n   * Flag for work with API platform\n   */\n  protected isApiPlatform: boolean;\n  /**\n   * List of methods unavailable for current API\n   * @TODO Alex: add and handle enabled methods too\n   * @TODO Alex: disable batch by default\n   */\n  disabledMethods: RestMethod[] = [];\n  protected mpService: MixpanelService = inject(MixpanelService);\n  protected sseService: SseService = inject(SseService);\n  protected toastService: ToastService = inject(ToastService);\n  roles: UserRolesEnum[] = [];\n\n  /**\n   * disable cache update by requests, update only by SSE events\n   */\n  disableCache: boolean = false;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super();\n    // @TODO Alex remove, bad idea to call empty method overrided in child (because it will be called with parent context)\n    this.listenEvents();\n    // @TODO Alex remove, bad idea to call empty method overrided in child (because it will be called with parent context)\n    this.listenSSE();\n  }\n\n  protected get apiUrl(): string {\n    return `${this.environment.apiV2}/${this.endpointUri}`;\n  }\n\n  setCache(data: any[], next = false): void {\n    super.setCache(data);\n\n    if (next) {\n      this.cacheSubject.next(this.cache);\n    }\n  }\n\n  /**\n   * Refresh cache with actual backend data\n   */\n  refreshCache(): void {\n    this.cache = undefined;\n    this.get();\n  }\n\n  /**\n   * Get data from backend and fill the cache\n   */\n  protected fetch(path = this.apiUrl): Observable<CollectionModel> {\n    this.handleAccessError('get');\n\n    if (!this.hasRoles()) {\n      this.setCache([], true);\n      return this.cacheSubject.asObservable();\n    }\n\n    // Set cache as empty collection to avoid multiple requests before cache filled\n    this.setCache([]);\n    return this.http.get(path)\n      .pipe(\n        map((response: object) => this.isApiPlatform ? response['hydra:member'] : toArray(response)),\n        map((response: BaseModel[]) => {\n          this.setCache(response, true);\n\n          return this.cache;\n        })\n      );\n  }\n\n  get(path: string = this.apiUrl): Observable<CollectionModel> {\n    if (!this.cache) {\n      this.fetch(path).pipe(first()).subscribe();\n    }\n\n    return this.cacheSubject.asObservable();\n  }\n\n  getFirst(): Observable<Model> {\n    this.handleAccessError('get');\n\n    return this.get().pipe(\n      map((collection: CollectionModel) => collection.first)\n    );\n  }\n\n  hasInCache(id: number): boolean {\n    return !!this.getCache().findBy('id', id);\n  }\n\n  getArray(): Observable<Model[]> {\n    return this.get().pipe(map((collection: CollectionModel) => collection.toArray()));\n  }\n\n  /**\n   * Create a new Model instance in database\n   */\n  post(model: Model, mpData?: AbstractModel, path: string = this.apiUrl): Observable<Model> {\n    this.handleAccessError('post');\n\n    return this.http.post(path, classToPlain(model))\n      .pipe(\n        map((response: BaseModel) => {\n          const result: Model = this.createModelInstance(response);\n          this.handleResponse([result], 'post', mpData);\n\n          return result;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError([model], 'post', mpData);\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Create multiple new Model instances in database\n   */\n  postBatch(models: Model[]): Observable<Model[]> {\n    this.handleAccessError('postBatch');\n\n    return this.http.post(this.apiUrl, classToPlain(models))\n      .pipe(\n        map((response: BaseModel[]) => {\n          const result: Model[] = response.map((item: BaseModel): Model => this.createModelInstance(item));\n          this.handleResponse(result, 'post');\n\n          return result;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError(models, 'post');\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Change an existing Model instance in database\n   */\n  put(model: Model, mpData?: AbstractModel, path = `${this.apiUrl}/${model.id}`): Observable<Model> {\n    this.handleAccessError('put');\n\n    return this.http.put(path, classToPlain(model))\n      .pipe(\n        map((response: BaseModel) => {\n          const result: Model = this.createModelInstance(response);\n          this.handleResponse([result], 'put', mpData);\n\n          return result;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError([model], 'put', mpData);\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Change multiple existing Model instances in database\n   */\n  putBatch(models: Model[]): Observable<Model[]> {\n    this.handleAccessError('putBatch');\n\n    return this.http.put(this.apiUrl, classToPlain(models))\n      .pipe(\n        map((response: BaseModel[]) => {\n          const result: Model[] = response.map((item: BaseModel): Model => this.createModelInstance(item));\n          this.handleResponse(result, 'put');\n\n          return result;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError(models, 'put');\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Remove a Model instance from database\n   */\n  delete(model: Model, mpData?: AbstractModel): Observable<void> {\n    this.handleAccessError('delete');\n\n    return this.http.delete(`${this.apiUrl}/${model.id}`)\n      .pipe(\n        map(() => {\n          this.handleResponse([model], 'delete', mpData);\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError([model], 'delete', mpData);\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Remove multiple Model instances from database\n   */\n  deleteBatch(models: Model[]): Observable<void> {\n    this.handleAccessError('deleteBatch');\n\n    return this.http.post(`${this.apiUrl}/delete`, classToPlain(models))\n      .pipe(\n        map(() => {\n          this.handleResponse(models, 'delete');\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.handleResponseError(models, 'delete');\n\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  protected track(response: Model[], method: HttpMethod, mpData?: AbstractModel, postfix = '') {\n    // check if result exist, sometimes response may be empty (for example ClientInvite accept/reject/etc)\n    if (!response[0]) {\n      return;\n    }\n\n    // no other way to check interface\n    if ('getMpData' in response[0]) {\n      response.forEach((model) => {\n        this.mpService.track(`${method}${this.modelClass.name}${postfix}`, model['getMpData'](mpData))\n      });\n    }\n  }\n\n  protected handleResponseError(response: Model[], method: HttpMethod, mpData?: AbstractModel) {\n    // @TODO error notification?\n    this.track(response, method, mpData, 'Error');\n  }\n\n  /**\n   * Handle response data - update cache and dispatch event if it is needed\n   */\n  protected handleResponse(response: Model[], method: HttpMethod, mpData?: AbstractModel) {\n    this.track(response, method, mpData);\n\n    if (this.getCache() && !this.disableCache) {\n      this.updateCache(response, method);\n    }\n\n    // dispatch event for interested services\n    if (response[0] instanceof ObservableModel) {\n      this.dispatchEvent(method, response);\n    }\n  }\n\n  /**\n   * Update cache with passed items. Add/Update detects automatically, Delete via optional flag\n   */\n  protected updateCache(items: Model[], method: HttpMethod): void {\n    let cache: CollectionModel;\n\n    switch (method) {\n      case 'post':\n        cache = this.cache.push(...items);\n        break;\n\n      case 'put':\n        // @TODO Alex old instance\n        items.forEach((item: Model) => {\n          cache = this.cache.replaceBy('id', item.id, item);\n        });\n        break;\n\n      case 'delete':\n        cache = this.cache.removeBy('id', items.map((item: Model) => item.id));\n        break;\n\n      case 'get':\n        cache = this.createCollectionInstance(this.collectionClass, items);\n    }\n\n    this.setCache(cache.toArray(), true);\n  }\n\n  /**\n   * Generate and dispatch rest event\n   */\n  protected dispatchEvent(method: HttpMethod, items: Model[]): void {\n    const eventName: string = (this.modelClass as typeof ObservableModel).getEventName(method);\n    this.eventDispatcherService.dispatch2(new AppEvent2(eventName, items));\n  }\n\n  /**\n   * Check if method is not disabled. Throw exception otherwise.\n   * Some entities does not have endpoints for all methods.\n   */\n  private handleAccessError(method: RestMethod): void {\n    if (!this.disabledMethods.includes(method)) {\n      return;\n    }\n\n    throw new Error(`Method ${method}() is not allowed for ${this.constructor.name}`);\n  }\n\n  /**\n   * Subscribe to http events and run callback.\n   * CSE - Cleint Sent Events\n   * @param modelClass\n   * @param methods The list of http methods should be listened for\n   * @param callback The function to be called when event triggered\n   */\n  protected listenCSE(modelClass: typeof ObservableModel, methods: HttpMethod[], callback: Function): void {\n    callback = callback.bind(this);\n\n    methods.forEach((method: HttpMethod) => {\n      this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data: ObservableModel[]) => {\n        callback(data);\n      });\n    })\n  }\n\n  /**\n   * check if user has subscription role to access api\n   */\n  hasRoles(): boolean {\n    if (!this.roles.length) {\n      return true;\n    }\n\n    return !!intersection(JSON.parse(localStorage.getItem('roles')), this.roles).length;\n  }\n\n  /**\n   * // @TODO Alex remove\n   * Method that call all listeners. Empty by default. Should be redefined by child services if required\n   */\n  listenEvents(): void {}\n\n  /**\n   * Listen SSE events\n   */\n  listenSSE(): void {}\n}\n"]}

package/esm2022/lib/services/http/service-notification/service-notification.service.mjs

@@ -0,0 +1,74 @@
+import { Inject, Injectable } from '@angular/core';
+import { Notification } from '../../../models/notification/notification';
+import { replace } from '../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../rest/rest-old.service';
+import { AppEvent } from '../../../models/event/app-event';
+import { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';
+import clone from 'lodash/clone';
+import { Toast } from "../../../models/toast/toast";
+import { ToastTypeEnum } from "../../../models/toast/toast-type.enum";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event/event-dispatcher.service";
+import * as i3 from "../../toast/toast.service";
+import * as i4 from "../../event/sse.service";
+/**
+ * Service to handle service notifications logic
+ */
+export class ServiceNotificationService extends RestService {
+    constructor(http, eventDispatcherService, environment, toastService, sseService) {
+        super(http, eventDispatcherService, environment, toastService);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.toastService = toastService;
+        this.sseService = sseService;
+        this.modelClass = Notification;
+        this.url = 'service-notifications';
+        this.isHydra = true;
+        this.listenNotifications();
+    }
+    /**
+     * subscribe to new chat messages
+     */
+    listenNotifications() {
+        this.sseService.on(`serviceNotification`).subscribe((notificationBase) => {
+            const notification = plainToClass(Notification, notificationBase);
+            const cache = clone(this.cache);
+            // update existing notification if read and add new notification if not read
+            if (notification.isRead) {
+                replace(cache, notification);
+            }
+            else {
+                cache.unshift(notification);
+                this.toastService.add(plainToClass(Toast, {
+                    type: ToastTypeEnum.INFO,
+                    title: 'Information',
+                    message: notification.message,
+                    // read notification when user manually closed toast
+                    onCloseClick: () => {
+                        notification.isRead = true;
+                        this.update(notification).subscribe();
+                    }
+                }));
+            }
+            this.cache = cache;
+            this.cacheSubject.next(this.cache);
+            // @TODO TT-2280 Alex wrong event, it's updated, added or deleted. Not just added
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.NOTIFICATION_ADDED, notification));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ServiceNotificationService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.ToastService }, { token: i4.SseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ServiceNotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ServiceNotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i3.ToastService }, { type: i4.SseService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/setup-item/setup-item.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { AccountSetupItemCollection } from '../../../collections';
+import { AccountSetupItem } from '../../../models/account-setup/account-setup-item';
+import { RestService } from '../rest';
+import * as i0 from "@angular/core";
+export class SetupItemService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'setup-items';
+        this.isApiPlatform = true;
+        this.modelClass = AccountSetupItem;
+        this.collectionClass = AccountSetupItemCollection;
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SetupItemService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SetupItemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SetupItemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/sole/bas-report/bas-report.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { BasReport } from '../../../../models';
+import * as i0 from "@angular/core";
+export class BasReportService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = BasReport;
+        this.url = 'bas-reports';
+        this.isHydra = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasReportService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasReportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzLXJlcG9ydC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc29sZS9iYXMtcmVwb3J0L2Jhcy1yZXBvcnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSw2QkFBNkIsQ0FBQztBQUV4RCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0sb0JBQW9CLENBQUM7O0FBSzdDLE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxXQUFxQztJQUgzRTs7UUFJRSxlQUFVLEdBQXFCLFNBQVMsQ0FBQztRQUN6QyxRQUFHLEdBQUcsYUFBYSxDQUFDO1FBQ3BCLFlBQU8sR0FBRyxJQUFJLENBQUM7S0FDaEI7K0dBSlksZ0JBQWdCO21IQUFoQixnQkFBZ0IsY0FGZixNQUFNOzs0RkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7UmVzdFNlcnZpY2V9IGZyb20gJy4uLy4uL3Jlc3QvcmVzdC1vbGQuc2VydmljZSc7XG5pbXBvcnQge0Jhc1JlcG9ydCBhcyBCYXNSZXBvcnRCYXNlfSBmcm9tICcuLi8uLi8uLi8uLi9kYi9Nb2RlbHMvc29sZS9iYXMtcmVwb3J0JztcbmltcG9ydCB7QmFzUmVwb3J0fSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCYXNSZXBvcnRTZXJ2aWNlIGV4dGVuZHMgUmVzdFNlcnZpY2U8QmFzUmVwb3J0QmFzZSwgQmFzUmVwb3J0PntcbiAgbW9kZWxDbGFzczogdHlwZW9mIEJhc1JlcG9ydCA9IEJhc1JlcG9ydDtcbiAgdXJsID0gJ2Jhcy1yZXBvcnRzJztcbiAgaXNIeWRyYSA9IHRydWU7XG59XG4iXX0=

package/esm2022/lib/services/http/sole/sole-business/sole-business.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusiness } from '../../../../models';
+import { map } from 'rxjs/operators';
+import { AppEvent } from '../../../../models/event/app-event';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+export class SoleBusinessService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusiness;
+        this.url = 'sole-businesses';
+        this.isHydra = true;
+    }
+    add(soleBusiness) {
+        return super.add(soleBusiness).pipe(map((business) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_BUSINESS_CREATED, business));
+            return business;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/sole/sole-business-activity/sole-business-activity.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusinessActivity } from '../../../../models';
+import * as i0 from "@angular/core";
+export class SoleBusinessActivityService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusinessActivity;
+        this.url = 'sole-business-activities';
+        this.isHydra = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessActivityService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessActivityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessActivityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sZS1idXNpbmVzcy1hY3Rpdml0eS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvc29sZS9zb2xlLWJ1c2luZXNzLWFjdGl2aXR5L3NvbGUtYnVzaW5lc3MtYWN0aXZpdHkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUxRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFLMUQsTUFBTSxPQUFPLDJCQUE0QixTQUFRLFdBQTJEO0lBSDVHOztRQUlFLGVBQVUsR0FBZ0Msb0JBQW9CLENBQUM7UUFDL0QsUUFBRyxHQUFHLDBCQUEwQixDQUFDO1FBQ2pDLFlBQU8sR0FBRyxJQUFJLENBQUM7S0FDaEI7K0dBSlksMkJBQTJCO21IQUEzQiwyQkFBMkIsY0FGMUIsTUFBTTs7NEZBRVAsMkJBQTJCO2tCQUh2QyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vcmVzdC9yZXN0LW9sZC5zZXJ2aWNlJztcbmltcG9ydCB7IFNvbGVCdXNpbmVzc0FjdGl2aXR5IGFzIFNvbGVCdXNpbmVzc0FjdGl2aXR5QmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uL2RiL01vZGVscy9zb2xlL3NvbGUtYnVzaW5lc3MtYWN0aXZpdHknO1xuaW1wb3J0IHsgU29sZUJ1c2luZXNzQWN0aXZpdHkgfSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBTb2xlQnVzaW5lc3NBY3Rpdml0eVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxTb2xlQnVzaW5lc3NBY3Rpdml0eUJhc2UsIFNvbGVCdXNpbmVzc0FjdGl2aXR5PntcbiAgbW9kZWxDbGFzczogdHlwZW9mIFNvbGVCdXNpbmVzc0FjdGl2aXR5ID0gU29sZUJ1c2luZXNzQWN0aXZpdHk7XG4gIHVybCA9ICdzb2xlLWJ1c2luZXNzLWFjdGl2aXRpZXMnO1xuICBpc0h5ZHJhID0gdHJ1ZTtcbn1cbiJdfQ==

package/esm2022/lib/services/http/sole/sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../../rest/rest-old.service';
+import { SoleBusinessLossOffsetRule } from '../../../../../models';
+import * as i0 from "@angular/core";
+/**
+ * @TODO vik replace with json when the final list is confirmed
+ */
+export class SoleBusinessLossOffsetRuleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusinessLossOffsetRule;
+        this.url = 'sole-business-loss-offset-rules';
+        this.isHydra = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossOffsetRuleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossOffsetRuleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossOffsetRuleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9zb2xlL3NvbGUtYnVzaW5lc3MtbG9zcy9zb2xlLWJ1c2luZXNzLWxvc3MtcnVsZXMvc29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDN0QsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRW5FOztHQUVHO0FBSUgsTUFBTSxPQUFPLGlDQUFrQyxTQUFRLFdBQW1FO0lBSDFIOztRQUlFLGVBQVUsR0FBc0MsMEJBQTBCLENBQUM7UUFDM0UsUUFBRyxHQUFHLGlDQUFpQyxDQUFDO1FBQ3hDLFlBQU8sR0FBRyxJQUFJLENBQUM7S0FDaEI7K0dBSlksaUNBQWlDO21IQUFqQyxpQ0FBaUMsY0FGaEMsTUFBTTs7NEZBRVAsaUNBQWlDO2tCQUg3QyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vcmVzdC9yZXN0LW9sZC5zZXJ2aWNlJztcbmltcG9ydCB7IFNvbGVCdXNpbmVzc0xvc3NPZmZzZXRSdWxlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vbW9kZWxzJztcblxuLyoqXG4gKiBAVE9ETyB2aWsgcmVwbGFjZSB3aXRoIGpzb24gd2hlbiB0aGUgZmluYWwgbGlzdCBpcyBjb25maXJtZWRcbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgU29sZUJ1c2luZXNzTG9zc09mZnNldFJ1bGVTZXJ2aWNlIGV4dGVuZHMgUmVzdFNlcnZpY2U8U29sZUJ1c2luZXNzTG9zc09mZnNldFJ1bGUsIFNvbGVCdXNpbmVzc0xvc3NPZmZzZXRSdWxlPiB7XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBTb2xlQnVzaW5lc3NMb3NzT2Zmc2V0UnVsZSA9IFNvbGVCdXNpbmVzc0xvc3NPZmZzZXRSdWxlO1xuICB1cmwgPSAnc29sZS1idXNpbmVzcy1sb3NzLW9mZnNldC1ydWxlcyc7XG4gIGlzSHlkcmEgPSB0cnVlO1xufVxuIl19

package/esm2022/lib/services/http/sole/sole-business-loss/sole-business-loss.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusinessLoss } from '../../../../models';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+export class SoleBusinessLossService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SoleBusinessLoss;
+        this.url = 'sole-business-losses';
+        this.isHydra = true;
+    }
+    listenEvents() {
+        this.listenBusinessCreated();
+    }
+    /**
+     * Listen business created because we create prior year losses together with business
+     */
+    listenBusinessCreated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SOLE_BUSINESS_CREATED).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SoleBusinessLossService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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