taxtank-core 0.0.1 → 0.1.1

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

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

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

@@ -0,0 +1,93 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { FirmTypeEnum } from '../../db/Enums/firm-type.enum';
+import { plainToClass } from 'class-transformer';
+import { Firm, Firm as FirmBase } from '../../db/Models/firm';
+
+// @TODO Alex: think about extend base rest service
+@Injectable({
+  providedIn: 'root'
+})
+export class FirmService {
+  firm: Firm;
+  firmSubject: ReplaySubject<Firm> = new ReplaySubject<Firm>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') protected environment: any
+  ) {}
+
+  /**
+   * Register new firm
+   * @param data: firm and firm owner data to register
+   */
+  register(data: Firm): Observable<Firm> {
+    return this.http.post(`${this.environment.apiV2}/firms/registration`, data)
+      .pipe(
+        map((firm: FirmBase): Firm => {
+          return plainToClass(Firm, firm);
+        })
+      );
+  }
+
+  get(): Observable<Firm> {
+    if (!this.firm) {
+      this.http.get(`${this.environment.apiV2}/firms/current`)
+        .pipe(
+          map((firm: FirmBase): Firm => {
+            return plainToClass(Firm, firm);
+          })
+        )
+        .subscribe((firm: Firm): void => {
+          this.firm = firm;
+          this.firmSubject.next(this.firm);
+        });
+    }
+
+    return this.firmSubject.asObservable();
+  }
+
+  update(firm: Firm): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/firms/current`, firm)
+      .pipe(
+        map((updatedItem: FirmBase) => {
+          const updatedInstance: Firm = plainToClass(Firm, updatedItem);
+          this.firmSubject.next(updatedInstance);
+        })
+      );
+  }
+
+  /**
+   * get list of all registered firms
+   */
+  getAll(): Observable<Firm[]> {
+    return this.http.get(`${this.environment.apiV2}/firms`)
+      .pipe(
+        map((response: object): Firm[] => {
+          return response['hydra:member'].map((firmBase: FirmBase): Firm => plainToClass(Firm, firmBase));
+        })
+      );
+  }
+
+  getByType(type: FirmTypeEnum): Observable<Firm[]> {
+    return this.getAll().pipe(
+      map((firms: Firm[]): Firm[] => {
+        return firms.filter((firm: Firm) => firm.type === type);
+      })
+    );
+  }
+
+  updatePhoto(firm: Firm, photo: FormData): Observable<Firm> {
+    return this.http.post(`${this.environment.apiV2}/firms/photo?_method=PUT`, photo)
+      .pipe(
+        map((firmPhoto: string) => {
+          this.firm = plainToClass(Firm, Object.assign(firm, {photo: firmPhoto}));
+          this.firmSubject.next(this.firm);
+
+          return firm;
+        })
+      );
+  }
+}

package/src/lib/services/header-title/header-title.service.spec.ts

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

package/src/lib/services/header-title/header-title.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { filter, map, mergeMap } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HeaderTitleService {
+
+  constructor(
+    private router: Router,
+    private activatedRoute: ActivatedRoute,
+  ) {
+  }
+
+  handleTitle(): Observable<any> {
+    return this.router.events.pipe(
+      filter((event: any) => event instanceof NavigationEnd),
+      map(() => this.activatedRoute),
+      map((route: any) => {
+        while (route.firstChild) {
+          route = route.firstChild;
+        }
+        return route;
+      }),
+      filter((route: any) => route.outlet === 'primary'),
+      mergeMap((route: any) => route.data)
+    );
+  }
+}

package/src/lib/services/income-source/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/src/lib/services/income-source/income-source-forecast.service.ts

@@ -0,0 +1,91 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { IncomeSourceForecast as IncomeSourceForecastBase } from '../../db/Models/income-source-forecast';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { IncomeSourceForecast } from '../../models/income-source/income-source-forecast';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { IncomeSource } from '../../models/income-source/income-source';
+import { AppEvent } from '../../models/event/app-event';
+
+/**
+ * Service to work with Other Income Forecasts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class IncomeSourceForecastService extends BaseRestService<IncomeSourceForecastBase, IncomeSourceForecast> {
+  modelClass: typeof IncomeSourceForecast = IncomeSourceForecast;
+  url: string = 'income-source-forecasts';
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, 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.isSalaryIncome()))
+      )
+      .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/src/lib/services/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/src/lib/services/income-source/income-source.service.ts

@@ -0,0 +1,127 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { IncomeSource as IncomeSourceBase } from '../../db/Models/income-source';
+import { BaseRestService } from '../base-rest.service';
+import { IncomeSourceType } from '../../models/income-source/income-source-type';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { replace } from '../../functions/array';
+import { IncomeSourceTypeEnum } from '../../db/Enums/income-source-type.enum';
+import { plainToClass } from 'class-transformer';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { IncomeSource } from '../../models/income-source/income-source';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+/**
+ * Service to work with income sources
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class IncomeSourceService extends BaseRestService<IncomeSourceBase, IncomeSource> {
+  url: string = 'income-sources';
+  modelClass = IncomeSource;
+  incomeSourceTypes: IncomeSourceType[];
+  incomeSourceTypeSubject: ReplaySubject<IncomeSourceType[]> = new ReplaySubject<IncomeSourceType[]>(1);
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+  }
+
+  /**
+   * 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) => {
+          return 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(this.modelClass, 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))));
+  }
+
+  /**
+   * Get other incomes types
+   */
+  getIncomeSourceTypes(): Observable<IncomeSourceType[]> {
+    if (!this.incomeSourceTypes) {
+      this.incomeSourceTypes = [];
+      this.http.get(`${this.environment.apiV2}/income-source-types`)
+        .pipe(
+          map((response: any) => {
+            return response.map((item: any) => plainToClass(IncomeSourceType, item));
+          })
+        )
+        .subscribe((otherIncomesTypes: IncomeSourceType[]) => {
+          this.incomeSourceTypes = otherIncomesTypes;
+          this.incomeSourceTypeSubject.next(this.incomeSourceTypes);
+        });
+    }
+
+    return this.incomeSourceTypeSubject.asObservable();
+  }
+}

package/src/lib/services/income-source/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/src/lib/services/income-source/salary-forecast.service.ts

@@ -0,0 +1,92 @@
+import { Inject, Injectable } from '@angular/core';
+import { SalaryForecast as SalaryForecastBase } from '../../db/Models/salary-forecast';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { IncomeSource } from '../../models/income-source/income-source';
+import { AppEvent } from '../../models/event/app-event';
+
+/**
+ * Service to work with Salary Forecasts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SalaryForecastService extends BaseRestService<SalaryForecastBase, SalaryForecast> implements IEventListener {
+  modelClass: typeof SalaryForecast = SalaryForecast;
+  url: string = 'salary-forecasts';
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, 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.isSalaryIncome()))
+      )
+      .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/src/lib/services/intercom/intercom.service.spec.ts

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

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

@@ -0,0 +1,37 @@
+import { Inject, Injectable } from '@angular/core';
+import { User } from '../../models/user/user';
+
+/**
+ * Service to work with intercom
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class IntercomService {
+  constructor(
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  /**
+   * Init object with user credentials
+   * @param user
+   */
+  initUser(user: User): object {
+    return {
+      app_id: this.environment.intercomAppId,
+      email: user.email,
+      user_hash: user.hashedEmail
+    };
+  }
+
+  /**
+   * Init connection for provided data
+   * @param user
+   */
+  initConnection(user: User): void {
+    const connectionCredentials: object = this.initUser(user);
+
+    (<any>window).Intercom('boot', connectionCredentials);
+  }
+}

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

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