taxtank-core 0.0.1 → 0.1.1

package/src/lib/services/tax-review/tax-review.service.ts

@@ -0,0 +1,114 @@
+import { Inject, Injectable } from '@angular/core';
+import { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import _ from 'lodash';
+import { replace } from '../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { plainToClass } from 'class-transformer';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { User } from '../../models/user/user';
+
+/**
+ * Service to work with tax review
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TaxReviewService extends BaseRestService<TaxReviewBase, TaxReview> implements IEventListener {
+  url: string = 'tax-reviews';
+  modelClass: typeof TaxReview = TaxReview;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen events from SSE and Event Dispatcher services
+   */
+  listenEvents(): void {
+    this.listenFirmChanges();
+    this.listenClientTransfer();
+  }
+
+  /**
+   * Add new Tax Review (request from client to firm)
+   * @param finYear
+   */
+  request(finYear: number): Observable<TaxReview> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}?financialYear=${finYear}`, {})
+      .pipe(
+        map((newTaxReview: TaxReviewBase): TaxReview => {
+          const taxReview: TaxReview = plainToClass(TaxReview, newTaxReview);
+          const tempCache: TaxReview[] = _.cloneDeep(this.cache);
+          tempCache.push(taxReview);
+          this.cache = tempCache;
+          this.updateCache();
+          return taxReview;
+        })
+      );
+  }
+
+  /**
+   * Update tax review
+   * @param taxReview to be updated
+   */
+  update(taxReview: TaxReview): Observable<TaxReview> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${taxReview.id}`, taxReview)
+      .pipe(
+        map((updatedTaxReview: TaxReviewBase) => {
+          const updatedInstance: TaxReview = plainToClass(TaxReview, updatedTaxReview);
+
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TAX_REVIEW_UPDATED, updatedInstance));
+
+          const tempCache: TaxReview[] = _.cloneDeep(this.cache);
+          replace(tempCache, updatedInstance);
+          this.cache = tempCache;
+          this.updateCache();
+
+          return updatedInstance;
+        })
+      );
+  }
+
+  /**
+   * Clear cache when user reject firm
+   */
+  private listenFirmChanges(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, AppEventTypeEnum.CLIENT_INVITE_ACCEPTED])
+      .subscribe((): void => {
+        this.cache = [];
+        this.updateCache();
+      });
+  }
+
+  /**
+   * Update firm for all transferred clients
+   * @private
+   */
+  private listenClientTransfer(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE)
+      .subscribe((transferredClients: User[]): void => {
+        const tempCache: TaxReview[] = _.cloneDeep(this.cache);
+
+        transferredClients.forEach((transferredClient: User): void => {
+          const taxReviewIndex: number = tempCache.findIndex((taxReview: TaxReview): boolean => taxReview.id === transferredClient.id);
+          // @TODO vik
+          // tempCache[taxReviewIndex].employee = transferredClient.accountant;
+        });
+
+        this.cache = tempCache;
+        this.updateCache();
+      });
+  }
+}

package/src/lib/services/tax-summary/tax-summary.service.ts

@@ -0,0 +1,70 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { plainToClass } from 'class-transformer';
+import { TaxSummary } from '../../models/tax-summary/tax-summary';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { TaxSummaryTypeEnum } from '../../models/tax-summary/tax-summary-type.enum';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+/**
+ * Service to work with tax summary logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TaxSummaryService {
+  taxSummaryActualsSubject: ReplaySubject<TaxSummary> = new ReplaySubject<TaxSummary>(1);
+  taxSummaryForecastsSubject: ReplaySubject<TaxSummary> = new ReplaySubject<TaxSummary>(1);
+
+  constructor(
+    private http: HttpClient,
+    private eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenToIncomeSourceForecastsEvents();
+  }
+
+  /**
+   * Get actual tax summary items
+   */
+  getActuals(): Observable<TaxSummary> {
+    this.http.get(`${this.environment.apiV2}/tax-summary/${TaxSummaryTypeEnum.ACTUALS}`, {})
+      .subscribe((response: object): TaxSummary => {
+          const taxSummary: TaxSummary = plainToClass(TaxSummary, response);
+          this.taxSummaryActualsSubject.next(taxSummary);
+          return taxSummary;
+        }
+      );
+    return this.taxSummaryActualsSubject.asObservable();
+  }
+
+  /**
+   * Get forecast tax summary items
+   */
+  getForecast(): Observable<TaxSummary> {
+    this.http.get(`${this.environment.apiV2}/tax-summary/${TaxSummaryTypeEnum.FORECASTS}`, {})
+      .subscribe((response: object): TaxSummary => {
+          const taxSummary: TaxSummary = plainToClass(TaxSummary, response);
+          this.taxSummaryForecastsSubject.next(taxSummary);
+          return taxSummary;
+        }
+      );
+    return this.taxSummaryForecastsSubject.asObservable();
+  }
+
+  /**
+   * Listen to EventDispatcherService events related to Income source forecasts
+   */
+  private listenToIncomeSourceForecastsEvents(): void {
+    this.eventDispatcherService
+      .on([AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED])
+      .subscribe((): void => {
+        this.getForecast().subscribe();
+      });
+  }
+}

package/src/lib/services/transaction/transaction-allocation.service.spec.ts

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

package/src/lib/services/transaction/transaction-allocation.service.ts

@@ -0,0 +1,92 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction-allocation';
+import { TransactionAllocation } from '../../models/transaction/transaction-allocation';
+import { Transaction } from '../../models/transaction/transaction';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { BaseRestService } from '../base-rest.service';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+// @TODO Don't look at the commented code. Will be refactored/removed during TT-1503
+
+/**
+ * Service for transaction allocations business logic
+ * @TODO alex refactor
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TransactionAllocationService extends BaseRestService<TransactionAllocationBase, TransactionAllocation> {
+  // API URL param for transaction allocations
+  url: string = 'transactions-allocations';
+  modelClass = TransactionAllocation;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Add single transaction allocation
+   */
+  add(allocation: TransactionAllocation): Observable<TransactionAllocation> {
+    return this.addBatch([allocation]).pipe(
+      map((newAllocations: TransactionAllocation[]): TransactionAllocation => newAllocations[0])
+    );
+  }
+
+  /**
+   * get list of transactions allocations related with passed bank transactions list
+   */
+  getByTransactions(transactions: Transaction[]): Observable<TransactionAllocation[]> {
+    const ids: number[] = transactions.map((transaction: Transaction) => transaction.id);
+    return this.get()
+      .pipe(
+        map((transactionAllocations: TransactionAllocation[]) => {
+          return transactionAllocations.filter((allocation: TransactionAllocation) => ids.includes(allocation.transaction.id));
+        })
+      );
+  }
+
+  private listenEvents(): void {
+    this.onTransactionsCreated();
+    this.onDepreciationCreated();
+    this.onTransactionDeleted();
+  }
+
+  /**
+   * Reset cache on transactions created
+   */
+  private onTransactionsCreated(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.TRANSACTIONS_CREATED).subscribe((): void => {
+      // Update allocations cache to synchronize data and fire subscriptions
+      this.resetCache();
+    });
+  }
+
+  /**
+   * Reset cache on depreciation created
+   */
+  private onDepreciationCreated(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.DEPRECIATIONS_CREATED).subscribe((): void => {
+      // Update allocations cache to synchronize data and fire subscriptions
+      this.resetCache();
+    });
+  }
+
+  /**
+   * Reset cache on transaction deleted
+   */
+  private onTransactionDeleted(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.TRANSACTION_DELETED).subscribe((): void => {
+      // Update allocations cache to synchronize data and fire subscriptions
+      this.resetCache();
+    });
+  }
+}

package/src/lib/services/transaction/transaction-calculation.service.spec.ts

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

package/src/lib/services/transaction/transaction-calculation.service.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import { TransactionCollection } from '../../collections/transaction.collection';
+import { Transaction } from '../../models/transaction/transaction';
+
+/**
+ * @TODO move to collection
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TransactionCalculationService {
+  /**
+   * Sum of allocations for passed transactions
+   */
+  getAllocatedAmount(transactions: TransactionCollection, allocations: TransactionAllocationCollection): number {
+    return allocations.getByTransactionsIds(transactions.getIds()).amount;
+  }
+
+  /**
+   * Check if transaction is allocated
+   */
+  isAllocated(transaction: Transaction, allocations: TransactionAllocationCollection): boolean {
+    return transaction.getNetAmount() === this.getAllocatedAmount(new TransactionCollection([transaction]), allocations);
+  }
+
+  /**
+   * Get collection of allocated transactions
+   * @TODO Alex: consider to move to collection
+   */
+  getAllocatedTransactions(transactions: TransactionCollection, allocations: TransactionAllocationCollection): TransactionCollection {
+    return new TransactionCollection(
+      transactions.items.filter((transaction: Transaction): boolean => {
+        return this.isAllocated(transaction, allocations);
+      })
+    );
+  }
+
+  /**
+   * Get collection of unallocated transactions
+   * @TODO Alex: consider to move to collection
+   */
+  getUnallocatedTransactions(transactions: TransactionCollection, allocations: TransactionAllocationCollection): TransactionCollection {
+    return new TransactionCollection(
+      transactions.items.filter((transaction: Transaction): boolean => {
+        return !this.isAllocated(transaction, allocations);
+      })
+    );
+  }
+}

package/src/lib/services/transaction/transaction.service.spec.ts

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