taxtank 0.1.0

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

@@ -0,0 +1,8 @@
+export * from './holding-trade.service';
+export * from './holding-type.service';
+export * from './holding-sale.service';
+export * from './holding-trade-import/holding-trade-import.service';
+export * from './holding-trade-import/holding-trade-import-messages.enum';
+export * from '../../json/holding/holding-type-exchange.service';
+export * from './holding-trade-messages.enum';
+export * from './holding-type-messages.enum';

package/projects/tt-core/src/lib/services/http/home-office/home-office-claim-messages.enum.ts

@@ -0,0 +1,6 @@
+export enum HomeOfficeClaimMessagesEnum {
+  CREATED = 'Claim created',
+  UPDATED = 'Claim updated',
+  DELETED = 'Claim deleted',
+  CONFIRM_DELETE = 'Are you sure you want to delete this claim?',
+}

package/projects/tt-core/src/lib/services/http/home-office/home-office-claim.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../rest';
+import { HomeOfficeClaimCollection } from '../../../collections';
+import { HomeOfficeClaim, HomeOfficeClaimInterface } from '../../../models';
+import { UserRolesEnum } from 'taxtank-core/common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HomeOfficeClaimService extends RestService<HomeOfficeClaimInterface, HomeOfficeClaim, HomeOfficeClaimCollection> {
+  protected endpointUri = 'home-office-claims';
+  modelClass: typeof HomeOfficeClaim = HomeOfficeClaim;
+  collectionClass: typeof HomeOfficeClaimCollection = HomeOfficeClaimCollection;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  roles = [UserRolesEnum.WORK_TANK, UserRolesEnum.SOLE_TANK];
+}

package/projects/tt-core/src/lib/services/http/home-office/home-office-log-messages.enum.ts

@@ -0,0 +1,6 @@
+export enum HomeOfficeLogMessagesEnum {
+  CREATED = 'Log created',
+  UPDATED = 'Log updated',
+  DELETED = 'Log deleted',
+  CONFIRM_DELETE = 'Are you sure you want to delete this Log?',
+}

package/projects/tt-core/src/lib/services/http/home-office/home-office-log.service.ts

@@ -0,0 +1,28 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import {
+  HomeOfficeClaim,
+  HomeOfficeLog,
+  HomeOfficeLogInterface
+} from '../../../models';
+import { IEventListener } from '../../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HomeOfficeLogService extends RestService<HomeOfficeLogInterface, HomeOfficeLog, Collection<HomeOfficeLog>> implements IEventListener {
+  protected endpointUri = 'home-office-logs';
+  modelClass: typeof HomeOfficeLog = HomeOfficeLog;
+  collectionClass: typeof Collection<HomeOfficeLog> = Collection<HomeOfficeLog>;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenCSE(HomeOfficeClaim, this.refreshCache, ['post']);
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './home-office-claim.service';
+export * from './home-office-claim-messages.enum';
+export * from './home-office-log.service';
+export * from './home-office-log-messages.enum';

package/projects/tt-core/src/lib/services/http/income-source/income-source-forecast/income-source-forecast.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/income-source/income-source-forecast/income-source-forecast.service.ts

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { IncomeSourceForecast as IncomeSourceForecastBase } from '../../../../db/Models/incomeSource/income-source-forecast';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum, IncomeSource, IncomeSourceForecast } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+
+/**
+ * Service to work with Other Income Forecasts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class IncomeSourceForecastService extends RestService<IncomeSourceForecastBase, IncomeSourceForecast> implements IEventListener {
+  modelClass: typeof IncomeSourceForecast = IncomeSourceForecast;
+  url = 'income-source-forecasts';
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Income Sources events
+   */
+  listenEvents(): void {
+    this.listenToAddedIncomeSources();
+    this.listenToUpdatedIncomeSources();
+  }
+
+  /**
+   * @TODO vik refactor
+   * Listen to EventDispatcherService event related to added Income Sources
+   */
+  private listenToAddedIncomeSources(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)
+      .pipe(
+        map((incomeSources: IncomeSource[]) => incomeSources
+          .filter((incomeSource: IncomeSource) => !incomeSource.isWorkIncome()))
+      )
+      .subscribe((incomeSources: IncomeSource[]) => {
+
+        const incomeSourceForecasts: IncomeSourceForecast[] = this.assignIncomeSourceForecasts(incomeSources);
+        if (incomeSourceForecasts.length) {
+          this.addBatch(incomeSourceForecasts).subscribe((createdIncomeSourceForecasts: IncomeSourceForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdIncomeSourceForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated Income Sources
+   */
+  private listenToUpdatedIncomeSources(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+      .subscribe((incomeSources: IncomeSource[]) => {
+        const incomeSourceForecasts: IncomeSourceForecast[] = this.assignIncomeSourceForecasts(incomeSources);
+        if (incomeSourceForecasts.length) {
+          this.updateBatch(incomeSourceForecasts).subscribe((updatedIncomeSourceForecasts: IncomeSourceForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedIncomeSourceForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Assign other income forecasts based on provided income sources
+   * @param incomeSources by which other income forecasts will be assigned
+   */
+  private assignIncomeSourceForecasts(incomeSources: IncomeSource[]): IncomeSourceForecast[] {
+    return incomeSources.map((incomeSource: IncomeSource) => {
+      incomeSource.incomeSourceForecasts = incomeSource.incomeSourceForecasts
+        .map((incomeSourceForecast: IncomeSourceForecast) => {
+          incomeSourceForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+          return incomeSourceForecast;
+        });
+      return incomeSource.incomeSourceForecasts;
+    }).flat();
+  }
+}

package/projects/tt-core/src/lib/services/http/income-source/income-source-forecast/index.ts

@@ -0,0 +1 @@
+export * from './income-source-forecast.service';

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

@@ -0,0 +1,8 @@
+export enum IncomeSourceMessagesEnum {
+  CREATED = 'Employment details have been created',
+  UPDATED = 'Employment details have been updated.',
+  DELETED = 'This employer, and the related forecasts, have been deleted.',
+  CLOSE_ERROR = 'End date can`t be before your final payment, please enter a date on or after the xx/xx/xxxx',
+  DELETE_CONFIRM = 'Are you sure you want to delete employer?',
+  DELETE_ERROR = 'You have received payments from this employer so it cannot be deleted. Instead please select the edit icon and add an end date.'
+}

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

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

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

@@ -0,0 +1,108 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { IncomeSource as IncomeSourceBase } from '../../../db/Models/incomeSource/income-source';
+import { RestService } from '../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum, IncomeSource, SalaryForecast, SoleBusiness } from '../../../models';
+import { replace } from '../../../functions/array';
+import { IncomeSourceTypeEnum } from '../../../db/Enums/income-source';
+import { plainToClass } from 'class-transformer';
+import { IEventListener } from '../../../interfaces';
+
+/**
+ * Service to work with income sources
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class IncomeSourceService extends RestService<IncomeSourceBase, IncomeSource> implements IEventListener {
+  url = 'income-sources';
+  modelClass = IncomeSource;
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenSoleBusinessCreated();
+  }
+
+  /**
+   * Get income sources tax calculation
+   * @param salaryForecast for which tax should be calculated
+   */
+  getTaxCalculation(salaryForecast: SalaryForecast): Observable<SalaryForecast> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/tax-calculation`, salaryForecast)
+      .pipe(
+        map((response: any) => plainToClass(SalaryForecast, response))
+      );
+  }
+
+  /**
+   * Add batch of income sources
+   * @param incomeSources to add
+   */
+  addBatch(incomeSources: IncomeSource[]): Observable<IncomeSource[]> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, incomeSources)
+      .pipe(
+        map((addedIncomeSources: IncomeSourceBase[]) => {
+          // assign respond income sources to provided income sources
+          const assignedIncomeSources: IncomeSource[] = addedIncomeSources
+            .map((incomeSource: IncomeSource, index: number) => Object.assign(plainToClass(IncomeSource, {}), incomeSource, incomeSources[index]));
+
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_CREATED, assignedIncomeSources));
+
+          this.cache.push(...assignedIncomeSources);
+          this.updateCache();
+          return assignedIncomeSources;
+        })
+      );
+  }
+
+  /**
+   * Update batch of income sources
+   */
+
+  updateBatch(incomeSources: IncomeSource[], queryParams: object = {}): Observable<IncomeSource[]> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}`, incomeSources, queryParams)
+      .pipe(
+        map((updatedItems: IncomeSource[]) => {
+          const updatedInstances: IncomeSource[] = updatedItems.map(
+            (item: IncomeSource) => this.createModelInstance(item)
+          );
+          updatedInstances.forEach((instance: IncomeSource) => {
+            replace(this.cache, instance);
+          });
+
+          if (incomeSources[0].forecasts.length) {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_UPDATED, incomeSources));
+          }
+
+          this.updateCache();
+          return updatedInstances;
+        })
+      );
+  }
+
+  /**
+   * Get income sources by provided types
+   * @param types
+   */
+  getByTypes(types: IncomeSourceTypeEnum[]): Observable<IncomeSource[]> {
+    return this.get()
+      .pipe(
+        map((incomeSources: IncomeSource[]) => incomeSources
+          .filter((incomeSource: IncomeSource) => types.includes(incomeSource.type))));
+  }
+
+  /**
+   * Sole businesses create together with income source
+   */
+  private listenSoleBusinessCreated() {
+    this.eventDispatcherService.on2(SoleBusiness.getEventName('post')).subscribe(() => {
+      // @TODO Alex/Vik (TT-1777): we clear cache a lot, a better and easier way required, add todo and task to refactor
+      this.refreshCache();
+    });
+  }
+}

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

@@ -0,0 +1,5 @@
+export * from './income-source-forecast';
+export * from './salary-forecast';
+export * from './sole-forecast';
+export * from './income-source.service';
+export * from './income-source-messages.enum';

package/projects/tt-core/src/lib/services/http/income-source/salary-forecast/index.ts

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

package/projects/tt-core/src/lib/services/http/income-source/salary-forecast/salary-forecast.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/income-source/salary-forecast/salary-forecast.service.ts

@@ -0,0 +1,83 @@
+import { Inject, Injectable } from '@angular/core';
+import { SalaryForecast as SalaryForecastBase } from '../../../../db/Models/incomeSource/salary-forecast';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum, IncomeSource, SalaryForecast } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+
+/**
+ * Service to work with Salary Forecasts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SalaryForecastService extends RestService<SalaryForecastBase, SalaryForecast> implements IEventListener {
+  modelClass: typeof SalaryForecast = SalaryForecast;
+  url = 'salary-forecasts';
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Income Sources events
+   */
+  listenEvents(): void {
+    this.listenToAddedIncomeSources();
+    this.listenToUpdatedIncomeSources();
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to added Income Sources
+   */
+  private listenToAddedIncomeSources(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)
+      .pipe(
+        map((incomeSources: IncomeSource[]) => incomeSources
+          .filter((incomeSource: IncomeSource) => incomeSource.isWorkIncome()))
+      )
+      .subscribe((incomeSources: IncomeSource[]) => {
+
+        const salaryForecasts: SalaryForecast[] = this.assignSalaryForecasts(incomeSources);
+        if (salaryForecasts.length) {
+          this.addBatch(salaryForecasts).subscribe((createdSalaryForecasts: SalaryForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSalaryForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated Income Sources
+   */
+  private listenToUpdatedIncomeSources(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+      .subscribe((incomeSources: IncomeSource[]) => {
+        const salaryForecasts: SalaryForecast[] = this.assignSalaryForecasts(incomeSources);
+        if (salaryForecasts.length) {
+          this.updateBatch(salaryForecasts).subscribe((updatedSalaryForecasts: SalaryForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSalaryForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Assign salary forecasts based on provided income sources
+   * @param incomeSources by which salary forecasts will be assigned
+   */
+  private assignSalaryForecasts(incomeSources: IncomeSource[]): SalaryForecast[] {
+    return incomeSources.map((incomeSource: IncomeSource) => {
+      incomeSource.salaryForecasts = incomeSource.salaryForecasts
+        .map((salaryForecast: SalaryForecast) => {
+          salaryForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+          return salaryForecast;
+        });
+      return incomeSource.salaryForecasts;
+    }).flat();
+  }
+}

package/projects/tt-core/src/lib/services/http/income-source/sole-forecast/index.ts

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

package/projects/tt-core/src/lib/services/http/income-source/sole-forecast/sole-forecast.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/income-source/sole-forecast/sole-forecast.service.ts

@@ -0,0 +1,92 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { SoleForecast as SoleForecastBase } from '../../../../db/Models/sole/sole-forecast';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum, IncomeSource, SoleBusiness, SoleForecast } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleForecastService extends RestService<SoleForecastBase, SoleForecast> implements IEventListener {
+  modelClass: typeof SoleForecast = SoleForecast;
+  url = 'sole-forecasts';
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Income Sources events
+   */
+  listenEvents(): void {
+    this.listenToAddedIncomeSources();
+    this.listenToUpdatedIncomeSources();
+    this.listenBusinessCreated();
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to added Income Sources
+   */
+  private listenToAddedIncomeSources(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)
+      .pipe(
+        map((incomeSources: IncomeSource[]) => incomeSources
+          .filter((incomeSource: IncomeSource) => incomeSource.isSoleIncome()))
+      )
+      .subscribe((incomeSources: IncomeSource[]) => {
+
+        const soleForecasts: SoleForecast[] = this.assignSoleForecasts(incomeSources);
+        if (soleForecasts.length) {
+          this.addBatch(soleForecasts).subscribe((createdSoleForecasts: SoleForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSoleForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated Income Sources
+   */
+  private listenToUpdatedIncomeSources(): void {
+    // return;
+    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+      .subscribe((incomeSources: IncomeSource[]) => {
+        const soleForecasts: SoleForecast[] = this.assignSoleForecasts(incomeSources);
+        if (soleForecasts.length) {
+          const method = soleForecasts[0].id ? 'updateBatch' : 'addBatch';
+          this[method](soleForecasts).subscribe((updatedSoleForecasts: SoleForecast[]) => {
+            this.eventDispatcherService
+              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSoleForecasts));
+          });
+        }
+      });
+  }
+
+  /**
+   * Assign sole forecasts based on provided income sources
+   * @param incomeSources by which sole forecasts will be assigned
+   */
+  private assignSoleForecasts(incomeSources: IncomeSource[]): SoleForecast[] {
+    return incomeSources.map((incomeSource: IncomeSource) => {
+      incomeSource.soleForecasts = incomeSource.soleForecasts
+        .map((soleForecast: SoleForecast) => {
+          soleForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+          return soleForecast;
+        });
+      return incomeSource.soleForecasts;
+    }).flat();
+  }
+
+  /**
+   * Listen business created because we create sole forests together with business
+   */
+  private listenBusinessCreated() {
+    this.eventDispatcherService.on2(SoleBusiness.getEventName('post')).subscribe(() => {
+      this.refreshCache();
+    })
+  }
+}

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

@@ -0,0 +1,46 @@
+export * from './address';
+export * from './pdf/pdf.service';
+
+export * from './bank';
+export * from './budget';
+export * from './financial-goal';
+
+export * from './chart-accounts';
+export * from './chat';
+
+export * from './depreciation';
+export * from './document';
+
+export * from './facebook';
+export * from './google';
+export * from './file';
+export * from './firm';
+
+export * from './income-source';
+
+export * from './loan';
+
+export * from './property';
+
+export * from './rest';
+
+export * from './service-notification';
+export * from './sole';
+export * from './subscription';
+
+export * from './tax-review';
+export * from './tax-summary';
+export * from './transaction';
+export * from './youtube';
+
+export * from './vehicle';
+
+export * from './client';
+export * from './user';
+
+export * from './document';
+export * from './holding';
+export * from './home-office';
+export * from './rest-messages.enum';
+export * from './aussie';
+export * from './sharesight';

package/projects/tt-core/src/lib/services/http/loan/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();
+  });
+});