taxtank-core 0.0.1 → 0.1.1

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

@@ -0,0 +1,374 @@
+import { EventEmitter, Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Transaction as TransactionBase } from '../../db/Models/transaction';
+import { map } from 'rxjs/operators';
+import { replace, sort } from '../../functions/array';
+import { enumToList } from '../../functions/enum-to-list';
+import { ChartAccountsHeadingTaxableEnum } from '../../db/Enums/chart-accounts-heading-taxable.enum';
+import { ChartAccountsHeadingTaxDeductibleEnum } from '../../db/Enums/chart-accounts-heading-tax-deductible.enum';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { BaseRestService } from '../base-rest.service';
+import { plainToClass } from 'class-transformer';
+import { CHART_ACCOUNTS_CATEGORIES } from '../../models/chart-accounts/chart-accounts-categories.const';
+import { Transaction } from '../../models/transaction/transaction';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { TransactionReceipt } from '../../models/transaction/transaction-receipt';
+import { ChartAccounts } from '../../models/chart-accounts/chart-accounts';
+import _ from 'lodash';
+import { ChartAccountsTaxLabelsEnum } from '../../models/chart-accounts/chart-accounts-tax-labels.enum';
+
+/**
+ * Service for transactions business logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TransactionService extends BaseRestService<TransactionBase, Transaction> {
+  // url part for Transaction API
+  url: string = 'transactions';
+  modelClass = Transaction;
+  transactionDeleted: EventEmitter<Transaction> = new EventEmitter<Transaction>();
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen events from Event Dispatcher services
+   */
+  listenEvents(): void {
+    this.listenDepreciationChange();
+  }
+
+  /**
+   * get list of all user's TaxTank transactions
+   */
+  get(): Observable<Transaction[]> {
+    if (!this.cache) {
+      // set cache as default empty array to avoid multiple backend requests
+      this.cache = [];
+      this.fetch()
+        .subscribe((transactions: Transaction[]) => {
+          this.cache = transactions;
+          this.updateCache();
+        });
+    }
+
+    return this.cacheSubject.asObservable().pipe(
+      // assign child transactions (fees) to parent transactions
+      map((transactions: Transaction[]): Transaction[] => {
+        transactions.forEach((transaction: Transaction): void => {
+          transaction.transactions = transactions
+            // get list of child transactions
+            .filter((t: Transaction): boolean => t.parentTransaction && t.parentTransaction.id === transaction.id);
+        });
+        sort(transactions, 'date', false);
+        return transactions;
+      })
+    );
+  }
+
+  /**
+   * Add single new transaction
+   * @param model New Transaction instance for saving
+   */
+  add(model: Transaction): Observable<Transaction> {
+    // we don't have POST API endpoint for single transaction
+    return this.addBatch([model])
+      .pipe(
+        map((newTransactions: Transaction[]): Transaction => {
+          // @TODO alex
+          this.eventDispatcherService.dispatch(
+            new AppEvent<Transaction>(AppEventTypeEnum.TRANSACTION_CREATED, newTransactions[0])
+          );
+
+          return newTransactions[0];
+        })
+      );
+  }
+
+  /**
+   * get transactions related with property
+   */
+  getByPropertyId(propertyId: number): Observable<Transaction[]> {
+    return this.get()
+      .pipe(
+        map((transactions: Transaction[]): Transaction[] => {
+          return transactions.filter((transaction: Transaction): boolean => {
+            return transaction.property?.id === propertyId;
+          });
+        })
+      );
+  }
+
+  /**
+   * get list of transactions with tank type 'Work'
+   */
+  getWorkTransactions(): Observable<Transaction[]> {
+    return this.get()
+      .pipe(
+        map((transactions: Transaction[]): Transaction[] => {
+          return transactions.filter((transaction: Transaction): boolean => transaction.isWorkTank());
+        })
+      );
+  }
+
+  /**
+   * get list of taxable transactions with tank type 'Work'
+   */
+  getTaxableWorkTransactions(): Observable<Transaction[]> {
+    return this.getWorkTransactions()
+      .pipe(
+        map((transactions: Transaction[]): Transaction[] => {
+          return transactions.filter((transaction: Transaction): boolean => !!transaction.chartAccounts.taxReturnItem);
+        })
+      );
+  }
+
+  /**
+   * add multiple transactions
+   * @param transactions List of new Transaction instances for saving
+   */
+  addBatch(transactions: Transaction[]): Observable<Transaction[]> {
+    transactions = _.cloneDeep(transactions);
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, transactions)
+      .pipe(
+        map((response: TransactionBase[]) => {
+          const addedTransactions: Transaction[] = response.map((item: TransactionBase) => plainToClass(Transaction, item));
+
+          transactions.forEach((transaction: Transaction, index: number) => {
+            // @TODO backend: need to upload file in the same backend endpoint with transaction add/update
+            // check if passed receipt and upload file
+            if (transaction.file) {
+              transaction.id = response[index].id;
+              addedTransactions[index].file = transaction.file;
+              this.uploadReceipt(addedTransactions[index]);
+            }
+
+            // @TODO Viktor: implement API for saving of nested transactions
+            // add child transactions if exist
+            if (transaction.transactions.length) {
+              transaction.transactions.forEach((childTransaction: Transaction) => {
+                childTransaction.parentTransaction = plainToClass(Transaction, {id: addedTransactions[index].id});
+              });
+              this.addBatch(transaction.transactions).subscribe();
+            }
+
+            // add transfer transaction to cache
+            if (transaction.operation === TransactionOperationEnum.TRANSFER) {
+              addedTransactions.push(addedTransactions[0].transfer);
+            }
+          });
+
+          if (this.cache) {
+            this.cache.push(...addedTransactions);
+            this.updateCache();
+          }
+
+          this.eventDispatcherService.dispatch(
+            new AppEvent<Transaction[]>(AppEventTypeEnum.TRANSACTIONS_CREATED, addedTransactions)
+          );
+
+          return addedTransactions;
+        })
+      );
+  }
+
+  /**
+   * update existing transaction
+   * @param transaction Transaction instance for updating
+   */
+  update(transaction: Transaction): Observable<Transaction> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${transaction.id}`, transaction)
+      .pipe(
+        map((response: TransactionBase) => {
+          const updatedTransaction: Transaction = plainToClass(Transaction, response);
+
+          // @TODO need to upload file in the same backend endpoint with transaction add/update
+          // check if passed new receipt and upload file
+          if (transaction.file) {
+            updatedTransaction.file = transaction.file;
+            this.uploadReceipt(updatedTransaction);
+          }
+
+          // @TODO Viktor: implement API for saving of nested transactions
+          if (transaction.transactions.length) {
+            // add parent transaction to child transactions
+            transaction.transactions.forEach((childTransaction: Transaction) => {
+              childTransaction.parentTransaction = plainToClass(Transaction, {id: updatedTransaction.id});
+            });
+            // separate child transactions by id existing to define add or update action.
+            const childTransactionsToUpdate: Transaction[] = transaction.transactions.filter((t: Transaction) => t.id);
+            const childTransactionsToAdd: Transaction[] = transaction.transactions.filter((t: Transaction) => !t.id);
+
+            // update child transactions
+            if (childTransactionsToUpdate.length) {
+              this.updateBatch(childTransactionsToUpdate).subscribe();
+            }
+
+            // add child transactions
+            if (childTransactionsToAdd.length) {
+              this.addBatch(childTransactionsToAdd).subscribe();
+            }
+          }
+
+          replace(this.cache, updatedTransaction);
+          this.updateCache();
+          return updatedTransaction;
+        })
+      );
+  }
+
+  /**
+   * update multiple transactions
+   * @param transactions list of transactions for updating
+   */
+  updateBatch(transactions: Transaction[]): Observable<Transaction[]> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}`, transactions)
+      .pipe(
+        map((response: TransactionBase[]) => {
+          const updatedTransactions: Transaction[] = response.map((item: TransactionBase) => plainToClass(Transaction, item));
+
+          updatedTransactions.forEach((updatedTransaction: Transaction) => {
+            replace(this.cache, updatedTransaction);
+          });
+
+          this.updateCache();
+          return updatedTransactions;
+        })
+      );
+  }
+
+  /**
+   * delete transaction and related transactions
+   * @param model
+   */
+  delete(model: Transaction): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/${this.url}/${model.id}`)
+      .pipe(
+        map((): void => {
+          this.cache = this.cache.filter((transaction: Transaction): boolean => {
+            // when delete transfer we delete actually 2 transactions
+            if (model.isTransfer) {
+              const ids: number[] = [model.id];
+
+              // get id of related transfer transaction
+              if (model.transfer) {
+                // just take id if we delete source transaction
+                ids.push(model.transfer.id);
+              } else {
+                // find source transaction id if we delete destination transaction
+                ids.push(this.cache.find((t: Transaction): boolean => t.transfer.id === model.id).id);
+              }
+
+              return !ids.includes(transaction.id);
+            }
+
+            return transaction.id !== model.id && transaction.parentTransaction?.id !== model.id;
+          });
+
+          this.eventDispatcherService.dispatch(
+            new AppEvent<Transaction>(AppEventTypeEnum.TRANSACTION_DELETED, model)
+          );
+
+          this.updateCache();
+          this.transactionDeleted.emit(model);
+        })
+      );
+  }
+
+  /**
+   * upload transaction receipt image
+   * @param transaction Еhe transaction for which the receipt will be imported
+   */
+  uploadReceipt(transaction: Transaction): void {
+    const formData: FormData = new FormData();
+    formData.append('file', transaction.file);
+    transaction.receipt = null;
+
+    this.http.post(`${this.environment.apiV2}/${this.url}/${transaction.id}/receipts`, formData)
+      .subscribe((receiptResponse: any) => {
+        // we don't need to keep file after save
+        transaction.file = null;
+        transaction.receipt = plainToClass(TransactionReceipt, receiptResponse);
+        replace(this.cache, transaction);
+        this.updateCache();
+      });
+  }
+
+  /**
+   * calculate gross income amount based on transaction amount and taxes (fees)
+   * @param transaction Transaction instance for calculation
+   */
+  calculateGrossAmount(transaction: Transaction): number {
+    let amount: number = transaction.amount || 0;
+
+    // gross income amount includes amount of fees for property tank and tax for work tank
+    if (transaction.isPropertyTank()) {
+      amount += transaction.transactions.reduce((sum: number, item: Transaction) => sum + item.amount, 0);
+    } else {
+      // @TODO Alex: fix logic after TT-641 ready
+      amount += (transaction.tax || 0);
+    }
+
+    return amount;
+  }
+
+  /**
+   * get label for transaction tax field depended of selected chart account.
+   * tax type depends of chart account heading or category.
+   */
+  getTaxLabel(chartAccounts: ChartAccounts): ChartAccountsTaxLabelsEnum {
+    // get simple array of ids from enum with taxable chart accounts headings
+    const taxableCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxableEnum)
+      .map((item: { label: string, value: number }) => item.value);
+    // get simple array of ids from enum with tax deductible chart accounts headings
+    const deductibleCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxDeductibleEnum)
+      .map((item: { label: string, value: number }) => item.value);
+
+    // check if one of ids arrays includes current chart accounts heading id and set tax label
+    // otherwise label is empty for this class
+    switch (true) {
+      case taxableCAHeadingsIds.includes(chartAccounts.heading?.id):
+        return ChartAccountsTaxLabelsEnum.TAX_PAID;
+      case deductibleCAHeadingsIds.includes(chartAccounts.heading?.id):
+        return ChartAccountsTaxLabelsEnum.TAX_DEDUCTED;
+      case CHART_ACCOUNTS_CATEGORIES.workIncome.includes(chartAccounts.category):
+        return ChartAccountsTaxLabelsEnum.TAX_WITHHELD;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Get transactions related to Vehicle category
+   */
+  getVehicleTransactions(): Observable<Transaction[]> {
+    return this.get().pipe(
+      map((transactions: Transaction[]) => {
+        return transactions.filter((transaction: Transaction): boolean => transaction.isVehicleTransaction());
+      })
+    );
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to Depreciation changing
+   */
+  private listenDepreciationChange(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.DEPRECIATION_DELETED).subscribe(() => {
+      this.fetch()
+        .subscribe((transactions: Transaction[]) => {
+          this.cache = transactions;
+          this.updateCache();
+        });
+    });
+  }
+}

package/src/lib/services/user/occupation.service.spec.ts

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

package/src/lib/services/user/occupation.service.ts

@@ -0,0 +1,42 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { Occupation } from '../../models/user/occupation';
+
+/**
+ * Service that works with Occupations
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class OccupationService {
+  _occupations: Occupation[];
+  occupationsSubject: ReplaySubject<Occupation[]> = new ReplaySubject<Occupation[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) { }
+
+  /**
+   * Get list of occupations
+   */
+  getOccupations(): Observable<Occupation[]> {
+    if (!this._occupations) {
+      this.http.get(`${this.environment.apiV2}/occupations`)
+        .pipe(
+          map((response: any) => {
+            return response.map((item: object) => plainToClass(Occupation, item));
+          })
+        )
+        .subscribe((occupations: Occupation[]) => {
+          this._occupations = occupations;
+          this.occupationsSubject.next(occupations);
+        });
+    }
+
+    return this.occupationsSubject.asObservable();
+  }
+}

package/src/lib/services/user/user-switcher.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+
+const KEY = '_switch_user';
+
+/**
+ * provides user management to managers (users with ROLE_ACCOUNTANT for now, more in future)
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class UserSwitcherService {
+  /**
+   * get switched username
+   */
+  get(): string {
+    return localStorage[KEY];
+  }
+
+  /**
+   * switch to user (username should be used for correct work of backend)
+   */
+  set(username: string): void {
+    localStorage[KEY] = username;
+    window.location.replace('/client/dashboard');
+  }
+
+  /**
+   * go back to original user
+   */
+  reset(): void {
+    localStorage.removeItem(KEY);
+    window.location.replace('/firm/dashboard');
+  }
+}

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

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

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

@@ -0,0 +1,140 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { User as UserBase } from '../../db/Models/user';
+import { User } from '../../models/user/user';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { JwtService } from '../auth/jwt.service';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+
+/**
+ * Service to work with user
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class UserService {
+  cache: User;
+  cacheSubject: ReplaySubject<User> = new ReplaySubject<User>(1);
+
+  constructor(
+    private http: HttpClient,
+    private jwtService: JwtService,
+    private eventDispatcherService: EventDispatcherService,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  /**
+   * Get current user
+   */
+  get(): Observable<User> {
+    if (!this.cache) {
+      this.http.get(`${this.environment.apiV2}/users/current`)
+        .pipe(
+          map((userBase: UserBase) => {
+            return plainToClass(User, userBase);
+          }),
+        )
+        .subscribe((user: User) => {
+          localStorage.setItem('userId', user.id.toString());
+          // @TODO remove
+          localStorage.setItem('financialYear', user.financialYear.toString());
+          this.cache = user;
+          this.cacheSubject.next(this.cache);
+        });
+    }
+
+    return this.cacheSubject.asObservable();
+  }
+
+  /**
+   * Register new user
+   */
+  register(data: object): Observable<object> {
+    return this.http.post(`${this.environment.apiV2}/users/registration`, data);
+  }
+
+  /**
+   * Update user
+   */
+  update(user: User): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/users/${user.id}`, user)
+      .pipe(
+        map((userBase: UserBase) => {
+          this.cache = plainToClass(User, userBase);
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.USER_UPDATED, null));
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+
+  /**
+   * Change user password
+   */
+  changePassword(currentPassword: string, newPassword: string): Observable<object> {
+    return this.http.put(`${this.environment.apiV2}/users/current/password`, {currentPassword, newPassword});
+  }
+
+  /**
+   * Reset user password
+   */
+  resetPassword(email: string): Observable<object> {
+    return this.http.put(`${this.environment.apiV2}/users/reset-password`, {email});
+  }
+
+  /**
+   * Confirm registered user
+   */
+  confirm(verificationCode: string): Observable<object> {
+    return this.http.post(`${this.environment.apiV2}/users/confirmation`, {verificationCode});
+  }
+
+  /**
+   * Search existing user
+   */
+  search(email: string): Observable<User> {
+    return this.http.get(`${this.environment.apiV2}/users/search?email=${email}`)
+      .pipe(
+        map((userBase: UserBase) => {
+          return plainToClass(User, userBase);
+        })
+      );
+  }
+
+  /**
+   * Finish onboarding process
+   */
+  finishOnboarding(user: User): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/users/status`, user)
+      .pipe(
+        map(() => {
+          this.cache = user;
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+
+  /**
+   * Update user photo
+   */
+  updatePhoto(photo: FormData): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/users/photo?_method=PUT`, photo)
+      .pipe(
+        map((photoUrl: string) => {
+          this.cache = plainToClass(User, Object.assign(this.cache, {photo: photoUrl}));
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+
+  /**
+   * Run forecast update script on backend when user switched financial year
+   */
+  switchFinancialYear(): Observable<object> {
+    return this.http.get(`${this.environment.apiV2}/financial-year/switch`);
+  }
+}

package/src/lib/services/user-event/user-event-setting.service.spec.ts

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

package/src/lib/services/user-event/user-event-setting.service.ts

@@ -0,0 +1,60 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { UserEventSetting } from '../../models/user-event/user-event-setting';
+import { UserEventSetting as UserEventSettingBase } from '../../db/Models/user-event-setting';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { BaseRestService } from '../base-rest.service';
+import { forkJoin, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import { classToPlain, plainToClass } from 'class-transformer';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserEventSettingService extends BaseRestService<UserEventSettingBase, UserEventSetting> {
+  modelClass: typeof UserEventSetting = UserEventSetting;
+  url: string = 'user-event-settings';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+  }
+
+  /**
+   * Send batch to add/updated settings
+   */
+  saveBatch(settings: UserEventSetting[]): Observable<void> {
+    // batch with post/put requests based on setting id
+    const batch: Observable<object>[] = settings.map((setting: UserEventSetting) => {
+      setting.isUpdating = true;
+
+      if (setting.id) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${setting.id}`, classToPlain(setting));
+      }
+
+      return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(setting));
+    });
+
+    return forkJoin(batch).pipe(
+      map((eventSettings: UserEventSetting[]) => {
+        eventSettings.forEach((eventSetting: UserEventSetting) => {
+          // get setting from cache by saved setting id
+          const cachedSetting: UserEventSetting = this.cache.find((setting: UserEventSetting) => setting.id === eventSetting.id);
+
+          if (cachedSetting) {
+            replace(this.cache, eventSetting);
+          } else {
+            this.cache.push(plainToClass(UserEventSetting, eventSetting));
+          }
+        });
+
+        this.updateCache();
+      })
+    );
+  }
+}