taxtank 0.1.0

package/projects/tt-core/src/lib/services/http/rest/rest.service.ts

@@ -0,0 +1,481 @@
+import { Inject, Injectable, inject } from '@angular/core';
+import { Observable, ReplaySubject, forkJoin, of, shareReplay, throwError } from 'rxjs';
+import { catchError, finalize, first, map, switchMap } from 'rxjs/operators';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { EventDispatcherService, SseService } from '../../event';
+import { classToPlain } from 'class-transformer';
+import { Collection } from '../../../collections';
+import { AbstractModel, ObservableModel } from '../../../db/Models';
+import { AppEvent2 } from '../../../models';
+import { toArray } from '../../../functions/array';
+import { RestMethod } from './rest-method.type';
+import { HttpMethod } from './http-method.type';
+import { DataService } from '../../data.service';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { ToastService } from '../../toast';
+import merge from 'lodash/merge';
+import intersection from 'lodash/intersection';
+import last from 'lodash/last';
+import cloneDeep from 'lodash/cloneDeep';
+import { HTTP_ERROR_MESSAGES } from './http-error-messages.const';
+
+/**
+ * @TODO refactor to behavior subject?
+ * 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
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class RestService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>>
+  extends DataService<BaseModel, Model, CollectionModel> {
+  private inFlight$?: Observable<CollectionModel>;
+
+  /**
+   * Url part for service entity API
+   */
+  protected abstract endpointUri: string;
+
+  /**
+   * Subject for service cache
+   */
+  protected cacheSubject: ReplaySubject<CollectionModel> = new ReplaySubject(1);
+
+  /**
+   * List of methods unavailable for current API
+   * @TODO Alex: add and handle enabled methods too
+   * @TODO Alex: disable batch by default
+   */
+  disabledMethods: RestMethod[] = [];
+  protected sseService: SseService = inject(SseService);
+  protected toastService: ToastService = inject(ToastService);
+  protected http: HttpClient = inject(HttpClient);
+  protected eventDispatcherService: EventDispatcherService = inject(EventDispatcherService);
+  /**
+   * adds new entities to the beginning when true
+   * @TODO make true by default when all services refactored
+   */
+  protected orderByDesc = false;
+
+  roles: UserRolesEnum[] = [];
+  mercureTopic: string;
+  /**
+   * flag to use error messages from api or default ones
+   * @TODO: TT-4642 check customHttpErrorMessages fix change to backend errors
+   */
+  protected useBackendError = false;
+
+  /**
+   * mapping with HTTP errors codes and general messages
+   */
+  protected httpErrorMessages: {[key: number]: string};
+
+  constructor(@Inject('environment') protected environment: any) {
+    super();
+    // @TODO upgrade to include success messages?
+    this.httpErrorMessages = { ...HTTP_ERROR_MESSAGES, ...this.getCustomHttpErrorMessages() };
+  }
+
+  public get apiUrl(): string {
+    return `${this.environment.apiV2}/${this.endpointUri}`;
+  }
+
+  setCache(data: any[], next = false): void {
+    super.setCache(data);
+
+    if (next) {
+      this.cacheSubject.next(this.cache);
+    }
+  }
+
+  /**
+   * Refresh cache with actual backend data
+   */
+  refreshCache(): void {
+    // todo why not fetch?
+    this.cache = undefined;
+    this.get().subscribe();
+  }
+
+  /**
+   * perform a shallow copy of the emitted data to make it immutable
+   */
+  getCacheSubjectObservable(): Observable<CollectionModel> {
+    return this.cacheSubject.asObservable().pipe(map((cache) => cloneDeep(cache)));
+  }
+
+  /**
+   * Get data from backend and fill the cache
+   */
+  fetch(path = this.apiUrl, cache = true, queryParams = {}): Observable<CollectionModel> {
+    if (this.inFlight$ && cache) {
+      return this.inFlight$;
+    }
+
+    this.inFlight$ = this.http.get(path, queryParams)
+      .pipe(
+        map((response: object | object[]) => Array.isArray(response) ? response : toArray(response)),
+        map((response: BaseModel[]) => {
+          if (cache) {
+            this.setCache(response, true);
+          }
+
+          return this.createCollectionInstance(this.collectionClass, response);
+        }),
+        catchError((error: unknown) => this.handleError(error)),
+        finalize(() => this.inFlight$ = null),
+        shareReplay({ bufferSize: 1, refCount: true })
+      );
+
+    return this.inFlight$;
+  }
+
+  fetchFirst(path = this.apiUrl, cache = true, queryParams = {}): Observable<Model> {
+    return this.fetch(path, cache, { params: queryParams })
+      .pipe(map((collection: CollectionModel) => collection.first));
+  }
+
+  get(path: string = this.apiUrl): Observable<CollectionModel> {
+    this.handleAccessError('get');
+
+    if (!this.hasRoles()) {
+      // @TODO it completes observable and doesn't watch anymore
+      return of(this.createCollectionInstance(this.collectionClass, []));
+    }
+
+    if (!this.cache) {
+      return this.fetch(path).pipe(
+        switchMap(() => this.getCacheSubjectObservable())
+      );
+    }
+
+    return this.getCacheSubjectObservable();
+  }
+
+  getBy(path: string, values: any): Observable<CollectionModel> {
+    return this.get().pipe(map((projects) => projects.filterBy(path, values)));
+  }
+
+  getFirst(): Observable<Model> {
+    return this.get().pipe(map((collection: CollectionModel) => collection.first));
+  }
+
+  hasInCache(id: number): boolean {
+    return !!this.getCache()?.findBy('id', id);
+  }
+
+  getArray(): Observable<Model[]> {
+    return this.get().pipe(map((collection: CollectionModel) => collection.toArray()));
+  }
+
+  getArrayBy(path: string, values: any): Observable<Model[]> {
+    return this.getBy(path, values).pipe(map((collection: CollectionModel) => collection.toArray()));
+  }
+
+  /**
+   * Create a new Model instance in database
+   */
+  post(model: Model, path: string = this.apiUrl): Observable<Model> {
+    this.handleAccessError('post');
+
+    return this.http.post(path, classToPlain(model))
+      .pipe(
+        first(),
+        map((response: object) => {
+          const result: Model = this.createModelInstance(response);
+          if (!this.mercureTopic) {
+            this.handleResponse([result], 'post');
+          }
+
+          return result;
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * Create multiple new Model instances in database
+   */
+  postBatch(models: Model[]): Observable<Model[]> {
+    this.handleAccessError('postBatch');
+
+    return this.http.post(this.apiUrl, classToPlain(models))
+      .pipe(
+        first(),
+        map((response: object[]) => {
+          const result: Model[] = response.map((item: object): Model => this.createModelInstance(item));
+          if (!this.mercureTopic) {
+            this.handleResponse(result, 'post');
+          }
+
+          return result;
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * Create multiple new Model instances in database for resources which support only single entity post
+   */
+  postParallel(models: Model[]): Observable<Model[]> {
+    return forkJoin(models.map(model => this.post(model)));
+  }
+
+  /**
+   * Change an existing Model instance in database
+   */
+  put(model: Model, path = `${this.apiUrl}/${model.id}`): Observable<Model> {
+    this.handleAccessError('put');
+
+    return this.http.put(path, classToPlain(model))
+      .pipe(
+        first(),
+        map((response: object) => {
+          const result: Model = this.createModelInstance(response);
+          if (!this.mercureTopic) {
+            this.handleResponse([result], 'put');
+          }
+
+          return result;
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * Change multiple existing Model instances in database
+   */
+  putBatch(models: Model[]): Observable<Model[]> {
+    this.handleAccessError('putBatch');
+
+    return this.http.put(this.apiUrl, classToPlain(models))
+      .pipe(
+        first(),
+        map((response: object[]) => {
+          const result: Model[] = response.map((item: object): Model => this.createModelInstance(item));
+          if (!this.mercureTopic) {
+            this.handleResponse(result, 'put');
+          }
+
+          return result;
+        })
+      );
+  }
+
+  /**
+   * Change multiple existing Model instances in database for resources which support only single entity put
+   */
+  putParallel(models: Model[]): Observable<Model[]> {
+    return forkJoin(models.map(model => this.post(model)));
+  }
+
+  /**
+   * Remove a Model instance from database
+   */
+  delete(model: Model, path = `${this.apiUrl}/${model.id}`): Observable<void> {
+    this.handleAccessError('delete');
+
+    return this.http.delete(path)
+      .pipe(
+        first(),
+        map(() => {
+          if (!this.mercureTopic) {
+            this.handleResponse([model], 'delete');
+          }
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * Remove multiple Model instances from database
+   */
+  deleteBatch(models: Model[]): Observable<void> {
+    this.handleAccessError('deleteBatch');
+
+    return this.http.post(`${this.apiUrl}/delete`, classToPlain(models))
+      .pipe(
+        first(),
+        map(() => {
+          if (!this.mercureTopic) {
+            this.handleResponse(models, 'delete');
+          }
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * @todo: remove deleteBatch after backend refactor
+   */
+  deleteBatchV2(models: Model[]) {
+    this.handleAccessError('deleteBatch');
+
+    return this.http.delete(`${this.apiUrl}`, { body: { ids: models.map(model => model.id) } })
+      .pipe(
+        first(),
+        map(() => {
+          if (!this.mercureTopic) {
+            this.handleResponse(models, 'delete');
+          }
+        }),
+        catchError((error: unknown) => this.handleError(error))
+      );
+  }
+
+  /**
+   * Remove multiple Model instances from database for resources which support only single entity delete
+   */
+  deleteParallel(models: Model[]): Observable<void> {
+    return forkJoin(models.map(model => this.delete(model))).pipe(map(() => undefined));
+  }
+
+  /**
+   * method with messages that can be redefined in other classes to customize httpErrorMessages
+   */
+  protected getCustomHttpErrorMessages(): Record<number, string> {
+    return {};
+  }
+  /**
+   * Handle response errors - shows error in toast
+   * and throws error further
+   * @param error - any backend error
+   * @throws HttpErrorResponse | Error - Always throws the error further as an Observable<never>
+   */
+  handleError(error: unknown) {
+    if (error instanceof HttpErrorResponse) {
+      if (this.useBackendError) {
+        if (error.error.detail) {
+          this.toastService.error(error.error.detail);
+        } else {
+          this.toastService.error(error.error.map((error: { message: string }) => error.message).join(' '));
+        }
+      } else {
+        this.toastService.error(this.httpErrorMessages[error.status] || 'Unexpected error occurred.');
+      }
+    }
+
+    return throwError(() => error);
+  }
+
+  /**
+   * Handle response data - update cache and dispatch event if it is needed
+   */
+  protected handleResponse(response: Model[], method: HttpMethod) {
+    if (this.getCache() !== undefined) {
+      this.updateCache(response, method);
+    }
+
+    // dispatch event for interested services
+    if (response[0] instanceof ObservableModel) {
+      this.dispatchEvent(method, response as unknown as ObservableModel[]);
+    }
+  }
+
+  /**
+   * Update cache with passed items. Add/Update detects automatically, Delete via optional flag
+   */
+  protected updateCache(items: Model[], method: HttpMethod): void {
+    let cache: CollectionModel;
+
+    switch (method) {
+      case 'post':
+        cache = this.orderByDesc ? this.cache.unshift(...items) : this.cache.push(...items);
+        break;
+
+      case 'put':
+        // @TODO Alex old instance
+        items.forEach((item: Model) => {
+          cache = this.cache.replaceBy('id', item.id, item);
+        });
+        break;
+
+      case 'delete':
+        cache = this.cache.removeBy('id', items.map((item: Model) => item.id));
+        break;
+
+      // case 'get':
+      //   cache = this.createCollectionInstance(this.collectionClass, items);
+    }
+
+    this.setCache(cache.toArray(), true);
+  }
+
+  /**
+   * Generate and dispatch rest event
+   */
+  protected dispatchEvent(method: HttpMethod, items: ObservableModel[]): void {
+    const eventName: string = 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.
+   */
+  private handleAccessError(method: RestMethod): void {
+    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
+   */
+  protected listenCSE(modelClass: typeof ObservableModel, callback: Function, methods: HttpMethod[] = ['post', 'put', 'delete']): void {
+    callback = callback.bind(this);
+
+    methods.forEach((method: HttpMethod) => {
+      this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data: ObservableModel[]) => {
+        callback(data);
+      });
+    })
+  }
+
+  /**
+   * check if user has subscription role to access api
+   */
+  hasRoles(): boolean {
+    if (!this.roles.length) {
+      return true;
+    }
+
+    return !!intersection(JSON.parse(localStorage.getItem('roles')), this.roles).length;
+  }
+
+  /**
+   * Listen for Server-Sent Events (SSE) on the specified Mercure topic
+   */
+  listenSSE(): void {
+    if (!this.mercureTopic) {
+      return;
+    }
+
+    this.sseService.on(this.mercureTopic).pipe(
+      map((response: object) => {
+        let model = this.createModelInstance(response);
+        let method: HttpMethod;
+        if (model.id) {
+          method = this.hasInCache(model.id) ? 'put' : 'post';
+        } else {
+          method = 'delete';
+          // we got empty body when item deleted, so we should get id from Api Platform data (@id)
+          model = merge(model, { id: +last(model['@id'].split('/')) });
+        }
+
+        return { method, model };
+      })
+    ).subscribe((change) => {
+      this.handleResponse([change.model], change.method)
+    });
+  }
+}

package/projects/tt-core/src/lib/services/http/rest-messages.enum.ts

@@ -0,0 +1,5 @@
+export enum RestMessagesEnum {
+  POST = 'Created',
+  PUT = 'Updated',
+  DELETE = 'Deleted'
+}

package/projects/tt-core/src/lib/services/http/service-notification/index.ts

@@ -0,0 +1 @@
+export * from './service-notification.service';

package/projects/tt-core/src/lib/services/http/service-notification/service-notification.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ServiceNotificationService } from './service-notification.service';
+
+describe('ServiceNotificationService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: ServiceNotificationService = TestBed.get(ServiceNotificationService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/service-notification/service-notification.service.ts

@@ -0,0 +1,69 @@
+import { Inject, Injectable } from '@angular/core';
+import { ServiceNotification as NotificationBase } from '../../../db/Models/service-notification';
+import { Notification } from '../../../models';
+import { replace } from '../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../rest/rest-old.service';
+import { EventDispatcherService } from '../../event';
+import { SseService } from '../../event';
+import { AppEvent, AppEventTypeEnum } from '../../../models';
+import clone from 'lodash/clone';
+import { ToastService } from '../../toast';
+import { Toast } from '../../../models/toast/toast';
+import { ToastTypeEnum } from '../../../models/toast/toast-type.enum';
+import { IEventListener } from '../../../interfaces';
+
+/**
+ * Service to handle service notifications logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ServiceNotificationService extends RestService<NotificationBase, Notification> implements IEventListener {
+  modelClass: typeof Notification = Notification;
+  url = 'service-notifications';
+
+  constructor(
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any,
+    protected toastService: ToastService,
+    private sseService: SseService
+  ) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents() {
+    this.listenNotifications();
+  }
+
+  /**
+   * @TODO refactor with listenSSE
+   */
+  private listenNotifications(): void {
+    this.sseService.on(`serviceNotification`).subscribe((notificationBase: NotificationBase): void => {
+      const notification: Notification = plainToClass(Notification, notificationBase);
+      const cache: Notification[] = 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));
+    });
+  }
+}

package/projects/tt-core/src/lib/services/http/setup-item/setup-item.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SetupItemService } from './setup-item.service';
+
+describe('SetupItemService', () => {
+  let service: SetupItemService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SetupItemService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/setup-item/setup-item.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { AccountSetupItemCollection } from '../../../collections';
+import { SetupItem } from '../../../db/Models/setup-item';
+import { AccountSetupItem } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SetupItemService extends RestService<SetupItem, AccountSetupItem, AccountSetupItemCollection> {
+  protected endpointUri = 'setup-items';
+  modelClass: typeof AccountSetupItem = AccountSetupItem;
+  collectionClass: typeof AccountSetupItemCollection = AccountSetupItemCollection;
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/sharesight/index.ts

@@ -0,0 +1,2 @@
+export * from './sharesight-details.service';
+export * from './sharesight-portfolio.service';

package/projects/tt-core/src/lib/services/http/sharesight/sharesight-details.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { SharesightDetails, SharesightDetailsInterface, SharesightDetailsMessagesEnum } from '../../../models';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SharesightDetailsService extends RestService<SharesightDetailsInterface, SharesightDetails, Collection<SharesightDetails>> {
+  modelClass: typeof SharesightDetails = SharesightDetails;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'sharesight-details';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  protected getCustomHttpErrorMessages(): Record<number, string> {
+    return { 503: SharesightDetailsMessagesEnum.ERROR };
+  }
+
+  reconnect(sharesightDetails: SharesightDetails): Observable<SharesightDetails> {
+    return this.put(sharesightDetails, `${this.apiUrl}/${sharesightDetails.id}/reconnect`);
+  }
+}

package/projects/tt-core/src/lib/services/http/sharesight/sharesight-portfolio.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { SharesightPortfolio, SharesightPortfolioInterface } from '../../../models';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SharesightPortfolioService extends RestService<SharesightPortfolioInterface, SharesightPortfolio, Collection<SharesightPortfolio>> {
+  modelClass: typeof SharesightPortfolio = SharesightPortfolio;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'sharesight-portfolios';
+  disabledMethods: RestMethod[] = ['putBatch'];
+
+  getExternal(): Observable<Collection<SharesightPortfolio>> {
+    return this.fetch(`${this.apiUrl}/external`, false);
+  }
+}

package/projects/tt-core/src/lib/services/http/sole/bas-report/bas-report-messages.enum.ts

@@ -0,0 +1,6 @@
+export enum BasReportMessagesEnum {
+  CREATED = 'Your bas report has been saved',
+  UPDATED = 'Your bas report has been updated',
+  DELETED = 'Your bas report has been deleted',
+  CONFIRM_DELETE = 'Are you sure you want to delete this BAS report?'
+}

package/projects/tt-core/src/lib/services/http/sole/bas-report/bas-report.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BasReportService } from './bas-report.service';
+
+describe('BasReportService', () => {
+  let service: BasReportService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(BasReportService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/bas-report/bas-report.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { BasReport as BasReportBase } from '../../../../db/Models/sole/bas-report';
+import { BasReport } from '../../../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BasReportService extends RestService<BasReportBase, BasReport>{
+  modelClass: typeof BasReport = BasReport;
+  url = 'bas-reports';
+}