taxtank-core 0.0.1 → 0.1.1

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

@@ -0,0 +1,97 @@
+import { Inject, Injectable } from '@angular/core';
+import { BankTransaction as BankTransactionBase } from '../../db/Models/bank-transaction';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BaseRestService } from '../base-rest.service';
+import { plainToClass } from 'class-transformer';
+import { HttpClient } from '@angular/common/http';
+import { UserEventTypeTypeEnum } from '../../db/Enums/user-event-type-type.enum';
+import { BankTransaction } from '../../models/bank/bank-transaction';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { Notification } from '../../models/notification/notification';
+
+/**
+ * Service for bank transactions business logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankTransactionService extends BaseRestService<BankTransactionBase, BankTransaction> {
+  // url part for BankTransaction API
+  url: string = 'bank-transactions';
+  modelClass = BankTransaction;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  private listenEvents(): void {
+    this.listenBankTransactionsImport();
+  };
+
+  /**
+   * get list of bank transactions for passed bank account id
+   * @param bankAccountId Id of bank account we search bank transactions for
+   */
+  getByBankAccountId(bankAccountId: number): Observable<BankTransaction[]> {
+    return this.get()
+      .pipe(
+        map((bankTransactions: BankTransaction[]) => {
+          return bankTransactions.filter((bankTransaction: BankTransaction) => bankTransaction.bankAccount.id === bankAccountId);
+        })
+      );
+  }
+
+  /**
+   * Get list of bank transactions for provided financial year
+   * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years
+   */
+  getTransactionsByYear(finYear: number): Observable<BankTransaction[]> {
+    return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)
+      .pipe(
+        map((bankTransactionsBase: BankTransactionBase[]) => {
+          return bankTransactionsBase.map((bankTransaction: BankTransaction) => plainToClass(BankTransaction, bankTransaction));
+        })
+      );
+  }
+
+  /**
+   * import bank transactions from csv file
+   * @param bankAccountId Bank account id we import bank transactions for
+   * @param file File with bank transactions for import
+   */
+  import(bankAccountId: number, file: File): Observable<BankTransaction[]> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)
+      .pipe(
+        map((response: BankTransactionBase[]) => {
+          const newBankTransactions: BankTransaction[] = response.map((bankTransaction: BankTransactionBase) => plainToClass(BankTransaction, bankTransaction));
+          // push new items to cache only if we already have cache. Otherwise cache will contain only new items.
+          if (this.cache) {
+            // just current year's transactions should be added
+            this.cache.push(...newBankTransactions.filter((bt: BankTransaction) => new FinancialYear().includes(bt.date)));
+            this.updateCache();
+          }
+
+          return newBankTransactions;
+        })
+      );
+  }
+
+  private listenBankTransactionsImport(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {
+      if (!notification.isRead && notification.eventType === UserEventTypeTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {
+        this.resetCache();
+      }
+    });
+  }
+}

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

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

package/src/lib/services/bank/bank.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { Bank as BankBase } from '../../db/Models/bank';
+import { Bank } from '../../models/bank/bank';
+import { BaseRestService } from '../base-rest.service';
+
+/**
+ * Service that handling banks logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankService extends BaseRestService<BankBase, Bank> {
+  modelClass: typeof Bank = Bank;
+  url: string = 'banks';
+  isHydra: boolean = true;
+}

package/src/lib/services/bank/basiq.service.spec.ts

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

package/src/lib/services/bank/basiq.service.ts

@@ -0,0 +1,103 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BankAccount as BankAccountBase } from '../../db/Models/bank-account';
+import { UserEventTypeTypeEnum } from '../../db/Enums/user-event-type-type.enum';
+import { BaseRestService } from '../base-rest.service';
+import { BankAccount } from '../../models/bank/bank-account';
+import { BasiqToken } from '../../models/bank/basiq-token';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { BankConnection } from '../../models/bank/bank-connection';
+import { Notification } from '../../models/notification/notification';
+
+/**
+ * basiq is a middleman between bank and user
+ * service is responsible for fetching bank related information
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BasiqService extends BaseRestService<BankAccountBase, BankAccount> {
+  token: BasiqToken;
+  tokenSubject: ReplaySubject<BasiqToken> = new ReplaySubject<BasiqToken>();
+  url: string = 'basiq/accounts';
+  modelClass = BankAccount;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen events from Event Dispatcher service
+   */
+  listenEvents(): void {
+    this.listenToBankConnectionAdded();
+    this.listenNotifications();
+  }
+
+  /**
+   * access token to use basiq connect ui iframe
+   */
+  getToken(): Observable<BasiqToken> {
+    if (!this.token || this.token.isExpired()) {
+      this.http.get(`${this.environment.apiV2}/basiq/tokens`)
+        .pipe(
+          map((response: object) => {
+            const now: number = new Date().getTime();
+
+            return new BasiqToken(response['access_token'], new Date(now + response['expires_in'] * 1000));
+          })
+        )
+        .subscribe((token: BasiqToken) => {
+          this.tokenSubject.next(token);
+        });
+    }
+
+    return this.tokenSubject.asObservable();
+  }
+
+  getConnections(): Observable<BankConnection[]> {
+    return this.get().pipe(
+      map((bankAccounts: BankAccount[]) => {
+        // get all connections
+        const connections: BankConnection[] = bankAccounts.map((bankAccount: BankAccount) => {
+          return bankAccount.bankConnection;
+        });
+
+        // return without duplicates
+        return [...new Map(connections.map((connection: BankConnection) => [connection.id, connection])).values()];
+      })
+    );
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to added Bank connection
+   */
+  private listenToBankConnectionAdded(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.BANK_CONNECTION_ADDED).subscribe(() => {
+      this.fetch().subscribe((bankAccounts: BankAccount[]) => {
+        this.cache = bankAccounts;
+        this.updateCache();
+      });
+    });
+  }
+
+  /**
+   * listen to notifications to update basiq accounts list
+   */
+  private listenNotifications(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification): void => {
+      if (!notification.isRead && notification.eventType === UserEventTypeTypeEnum.BASIQ_NEW_ACCOUNTS) {
+        this.resetCache();
+        this.get().subscribe();
+      }
+    });
+  }
+}

package/src/lib/services/base-rest.service.spec.ts

@@ -0,0 +1,13 @@
+// @Todo fix tests
+// import { TestBed } from '@angular/core/testing';
+//
+// import { BaseRestService } from './base-rest.service';
+//
+// describe('BaseService', () => {
+//   beforeEach(() => TestBed.configureTestingModule({}));
+//
+//   it('should be created', () => {
+//     const service: BaseRestService = TestBed.get(BaseRestService);
+//     expect(service).toBeTruthy();
+//   });
+// });

package/src/lib/services/base-rest.service.ts

@@ -0,0 +1,229 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { replace } from '../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from './event/event-dispatcher.service';
+import { classToPlain, plainToClass } from 'class-transformer';
+
+/**
+ * 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
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class BaseRestService<BaseModel, Model extends BaseModel> {
+  // url part for service entity API. Have to be defined in extended classes
+  abstract url: string;
+  // Model class for instances creating
+  abstract modelClass;
+  // @TODO Make cache Readonly
+  // cached array of service class instances
+  protected cache: Model[];
+  // subject for service cache
+  protected cacheSubject: ReplaySubject<Model[]> = new ReplaySubject<Model[]>(1);
+  // flag for work with API platform
+  protected isHydra: boolean;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+  }
+
+  /**
+   * get cached list of all instances
+   */
+  get(): Observable<Model[]> {
+    if (!this.cache) {
+      this.fetch().subscribe();
+    }
+
+    return this.cacheSubject.asObservable();
+  }
+
+  /**
+   * get instance by id from cache
+   * @param id ID of required item
+   */
+  getById(id: number): Observable<Model> {
+    return this.get()
+      .pipe(
+        map((items: Model[]) => {
+          return items.find((item: Model) => item['id'] === id);
+        })
+      );
+  }
+
+  /**
+   * get list of items filtered by id.
+   * @param models Array of objects contains required items ids
+   */
+  getByIds(models: Model[]): Observable<Model[]> {
+    const idsArray: number[] = models.map((model: Model) => model['id']);
+
+    return this.get()
+      .pipe(
+        map((items: Model[]) => {
+          return items.filter((item: Model) => idsArray.includes(item['id']));
+        })
+      );
+  }
+
+  /**
+   * add new instance and update cache
+   * @TODO rename to post
+   */
+  add(model: Model, shouldUpdateCache: boolean = true): Observable<Model> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(model))
+      .pipe(
+        map((newItem: BaseModel) => {
+          if (!shouldUpdateCache) {
+            return null
+          }
+
+          const newInstance: Model = this.createModelInstance(this.modelClass, newItem);
+          if (this.cache) {
+            this.cache.push(newInstance);
+            this.updateCache();
+          }
+
+          return newInstance;
+        })
+      );
+  }
+
+  /**
+   * Add several new items
+   * @param models Array of new items for saving
+   * @param queryParams query parameters for request
+   * @TODO rename to postBatch
+   */
+  addBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)
+      .pipe(
+        map((newItems: BaseModel[]) => {
+          const newInstances: Model[] = newItems.map((item: BaseModel) => this.createModelInstance(this.modelClass, item));
+          if (this.cache) {
+            this.cache.push(...newInstances);
+            this.updateCache();
+          }
+
+          return newInstances;
+        })
+      );
+  }
+
+  /**
+   * Update item
+   * @param model Existing instance for updating
+   * @param queryParams query parameters for request
+   * @TODO rename to put
+   */
+  update(model: Model, queryParams: object = {}): Observable<Model> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${model['id']}`, classToPlain(model), queryParams)
+      .pipe(
+        map((updatedItem: BaseModel) => {
+          const updatedInstance: Model = this.createModelInstance(this.modelClass, updatedItem);
+          replace(this.cache, updatedInstance);
+          this.updateCache();
+
+          return updatedInstance;
+        })
+      );
+  }
+
+  /**
+   * Update several items
+   * @param models Array of items for updating
+   * @param queryParams query parameters for request
+   * TODO rename to putBatch
+   */
+  updateBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)
+      .pipe(
+        map((updatedItems: BaseModel[]) => {
+          const updatedInstances: Model[] = updatedItems.map((item: BaseModel) => this.createModelInstance(this.modelClass, item));
+          updatedInstances.forEach((instance: Model) => {
+            replace(this.cache, instance);
+          });
+          this.updateCache();
+          return updatedInstances;
+        })
+      );
+  }
+
+  /**
+   * delete instance of class
+   * @param model Class instance for deleting
+   */
+  delete(model: Model): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/${this.url}/${model['id']}`)
+      .pipe(
+        map(() => {
+          this.cache = this.cache.filter((item: Model) => item['id'] !== model['id']);
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * delete multiple instances of class
+   * @param models Class instances array for deleting
+   */
+  deleteBatch(models: Model[]): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, models)
+      .pipe(
+        map(() => {
+          const ids: number[] = models.map((model: Model): number => model['id']);
+          this.cache = this.cache.filter((item: Model) => !ids.includes(item['id']));
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * clear service cache
+   */
+  resetCache(): void {
+    this.fetch().subscribe();
+  }
+
+  /**
+   * get list of base class instances directly from backend
+   */
+  protected fetch(): Observable<Model[]> {
+    return this.http.get(`${this.environment.apiV2}/${this.url}`)
+      .pipe(
+        map((response: BaseModel[]): Model[] => {
+          const items: Model[] = (this.isHydra ? response['hydra:member'] : response)
+            .map((item: BaseModel): Model => {
+              return this.createModelInstance(this.modelClass, item);
+            });
+          this.cache = items;
+          this.updateCache();
+          return items;
+        })
+      );
+  }
+
+  /**
+   * Update cache subject with current cache array value
+   */
+  protected updateCache(): void {
+    this.cacheSubject.next(this.cache.slice());
+  }
+
+  /**
+   * Create new instance of class
+   * @param model The class for which you want to create an instance
+   * @param baseModel base model instance that we will use as constructor options
+   */
+  protected createModelInstance(model: new(bm: BaseModel) => Model, baseModel: BaseModel): Model {
+    return plainToClass(model, baseModel, { excludePrefixes: ['@'] });
+  }
+}

package/src/lib/services/borrowing-expense/borrowing-expense.service.spec.ts

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

package/src/lib/services/borrowing-expense/borrowing-expense.service.ts

@@ -0,0 +1,82 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { BorrowingExpense } from '../../models/borrowing-expense/borrowing-expense';
+import { Loan } from '../../models/loan/loan';
+import { BorrowingExpenseLoan } from '../../models/borrowing-expense/borrowing-expense-loan';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BorrowingExpenseService {
+  _borrowingExpenses: BorrowingExpense[];
+  borrowingExpensesSubject: ReplaySubject<BorrowingExpense[]> = new ReplaySubject<BorrowingExpense[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') protected environment: any
+  ) { }
+
+  /**
+   * Get borrowing expenses
+   */
+  get(): Observable<BorrowingExpense[]> {
+    if (!this._borrowingExpenses) {
+      this.http.get(`${this.environment.apiV2}/borrowing-expenses`)
+        .pipe(
+          map((response: any) => {
+            return response.map((item: any) => plainToClass(BorrowingExpense, item));
+          })
+        )
+        .subscribe((borrowingExpenses: BorrowingExpense[]) => {
+          this._borrowingExpenses = borrowingExpenses;
+          this.borrowingExpensesSubject.next(this._borrowingExpenses);
+        });
+    }
+
+    return this.borrowingExpensesSubject.asObservable();
+  }
+
+  getLoanBorrowingExpenses(loan?: Loan): Observable<any> {
+    return this.get()
+      .pipe(
+        map((borrowingExpenses: BorrowingExpense[]) => {
+          // Loan borrowing expenses array
+          const borrowingExpensesLoan: BorrowingExpenseLoan[] = [];
+          // Combined array of borrowing expenses list & loan borrowing expenses
+          const combinedBorrowingExpenses: BorrowingExpenseLoan[] = [];
+
+
+          borrowingExpenses.forEach((borrowingExpense: BorrowingExpense, index: number) => {
+            // Fill borrowingExpensesLoan with values based on borrowingExpenses list
+            borrowingExpensesLoan.push(plainToClass(BorrowingExpenseLoan, {
+              borrowingExpense: borrowingExpense,
+              loan: loan,
+              amount: 0,
+              id: null,
+              createdAt: null,
+              updatedAt: null,
+              createdBy: null,
+              updatedBy: null
+            }));
+
+            combinedBorrowingExpenses
+              .push(Object.assign(plainToClass(BorrowingExpenseLoan, {} as BorrowingExpenseLoan), borrowingExpenses[index], borrowingExpensesLoan[index]));
+
+            // Find current loan borrowing expense in loan object by index
+            const targetBorrowingExpense: any = loan.borrowingExpenses.find((updBorrowingExpensesLoan: BorrowingExpenseLoan) =>
+              updBorrowingExpensesLoan.borrowingExpense.id === borrowingExpensesLoan[index].borrowingExpense.id);
+
+            // ... and set its value to current loan borrowing expense in combinedBorrowingExpenses array
+            combinedBorrowingExpenses[index].amount = targetBorrowingExpense ? targetBorrowingExpense.amount : 0;
+
+            return combinedBorrowingExpenses;
+          });
+
+          return combinedBorrowingExpenses;
+        })
+      );
+  }
+}

package/src/lib/services/chart-accounts/chart-accounts-depreciations.service.spec.ts

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

package/src/lib/services/chart-accounts/chart-accounts-depreciations.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { BaseRestService } from '../base-rest.service';
+import { ChartAccountsDepreciation as ChartAccountsDepreciationBase } from '../../db/Models/chart-accounts-depreciation';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChartAccountsDepreciation } from '../../models/chart-accounts/chart-accounts-depreciation';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+
+/**
+ * Service to work with depreciation chart accounts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChartAccountsDepreciationService extends BaseRestService<ChartAccountsDepreciationBase, ChartAccountsDepreciation> {
+  url: string = 'chart-accounts-depreciations';
+  modelClass: typeof ChartAccountsDepreciation = ChartAccountsDepreciation;
+  isHydra: boolean = true;
+
+  /**
+   * Get depreciation chart accounts for current financial year
+   */
+  getCurrent(): Observable<ChartAccountsDepreciation> {
+    return this.get()
+      .pipe(
+        map((chartAccountsDepreciations: ChartAccountsDepreciation[]) => {
+          return chartAccountsDepreciations
+            .find((chartAccountsDepreciation: ChartAccountsDepreciation): boolean => {
+              return chartAccountsDepreciation.effectiveYear === new FinancialYear().year;
+            });
+        })
+      );
+  }
+}

package/src/lib/services/chart-accounts/chart-accounts.service.spec.ts

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