taxtank-core 0.0.1 → 0.1.1

package/src/lib/services/client/client-portfolio-report.service.spec.ts

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

package/src/lib/services/client/client-portfolio-report.service.ts

@@ -0,0 +1,34 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { ClientPortfolioReport } from '../../models/client/client-portfolio-report';
+import { ClientPortfolioReportCollection } from '../../collections/client-portfolio-report.collection';
+
+// @Todo refactor with BaseRest service
+/**
+ * Service to work with employee clients tax summary data
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ClientPortfolioReportService {
+  url: string = 'portfolio-reports';
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  get(): Observable<ClientPortfolioReportCollection> {
+    return this.http.get(`${this.environment.apiV2}/${this.url}`)
+      .pipe(
+        map((response: object) => {
+          const clientReports: ClientPortfolioReport[] = response['hydra:member'].map((item: object) => plainToClass(ClientPortfolioReport, item));
+          return new ClientPortfolioReportCollection(clientReports);
+        })
+      );
+  }
+}

package/src/lib/services/depreciation/capital-project.service.spec.ts

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

package/src/lib/services/depreciation/capital-project.service.ts

@@ -0,0 +1,69 @@
+import { Inject, Injectable } from '@angular/core';
+import { DepreciationCapitalProject as DepreciationCapitalProjectBase } from '../../db/Models/depreciation-capital-project';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { DepreciationCapitalProject } from '../../models/depreciation/depreciation-capital-project';
+
+/**
+ * Service for work with DepreciationCapitalProjects
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class CapitalProjectService {
+  cache: DepreciationCapitalProject[];
+  cacheSubject: ReplaySubject<DepreciationCapitalProject[]> = new ReplaySubject<DepreciationCapitalProject[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  get(propertyId: number): Observable<DepreciationCapitalProject[]> {
+    this.cacheSubject.next([]);
+
+    this.http.get(`${this.environment.apiV2}/properties/${propertyId}/depreciation-capital-projects`)
+      .subscribe((capitalProjectsBase: DepreciationCapitalProjectBase[]) => {
+        this.cache = capitalProjectsBase.map((capitalProjectBase: DepreciationCapitalProjectBase) => {
+          return plainToClass(DepreciationCapitalProject, capitalProjectBase);
+        });
+        this.cacheSubject.next(this.cache);
+      });
+
+    return this.cacheSubject.asObservable();
+  }
+
+  add(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/properties/${propertyId}/depreciation-capital-projects`, capitalProject)
+      .pipe(
+        map((capitalProjectBase: DepreciationCapitalProjectBase): void => {
+          this.cache.push(plainToClass(DepreciationCapitalProject, capitalProjectBase));
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+
+  update(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/properties/${propertyId}/depreciation-capital-projects/${capitalProject.id}`, capitalProject)
+      .pipe(
+        map((capitalProjectBase: DepreciationCapitalProjectBase): void => {
+          replace(this.cache, plainToClass(DepreciationCapitalProject, capitalProjectBase));
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+
+  delete(capitalProject: DepreciationCapitalProject, propertyId: number): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/properties/${propertyId}/depreciation-capital-projects/${capitalProject.id}`)
+      .pipe(
+        map((): void => {
+          this.cache = this.cache.filter((item: DepreciationCapitalProject) => capitalProject.id !== item.id);
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+}

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

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

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

@@ -0,0 +1,171 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Depreciation as DepreciationBase } from '../../db/Models/depreciation';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { Depreciation } from '../../models/depreciation/depreciation';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+import { DepreciationReceipt } from '../../models/depreciation/depreciation-receipt';
+import { BankAccount } from '../../models/bank/bank-account';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DepreciationService extends BaseRestService<DepreciationBase, Depreciation> {
+  modelClass: typeof Depreciation = Depreciation;
+  url: string = 'depreciations';
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Add a single depreciation
+   * @TODO add auto-generation for events
+   */
+  add(depreciation: Depreciation): Observable<Depreciation> {
+    return this.addBatch([depreciation])
+      .pipe(
+        map((newDepreciations: Depreciation[]): Depreciation => {
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.DEPRECIATIONS_CREATED, newDepreciations[0]));
+          return newDepreciations[0];
+        })
+      );
+  }
+
+
+  /**
+   * Add multiple depreciations
+   * @TODO add auto-generation for events
+   */
+  addBatch(depreciations: Depreciation[]): Observable<Depreciation[]> {
+    return super.addBatch(depreciations).pipe(
+      map((newDepreciations: Depreciation[]): Depreciation[] => {
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.DEPRECIATIONS_CREATED, newDepreciations));
+        return newDepreciations;
+      })
+    );
+  }
+
+  /**
+   * Listen to Depreciations events
+   */
+  listenEvents(): void {
+    this.listenToUpdatedLoan();
+    this.listenToVehicleClaim();
+    this.listenToUpdatedBankAccount();
+  }
+
+  /**
+   * Get depreciations related to Vehicle category
+   */
+  getVehicleDepreciations(): Observable<Depreciation[]> {
+    return this.get().pipe(
+      map((depreciations: Depreciation[]) => {
+        return depreciations.filter((depreciation: Depreciation) => depreciation.isVehicleDepreciation());
+      })
+    );
+  }
+
+
+  getCloseBalance(depreciation: Depreciation): Observable<number> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/closing-balance?financialYear=${new FinancialYear().year}`, depreciation)
+      .pipe(
+        map((response: number) => {
+          return response || 0;
+        })
+      );
+  }
+
+  /**
+   * @TODO wrong place, move to collection model
+   */
+  calculateSummaryAmount(depreciationList: Depreciation[]): number {
+    return depreciationList.reduce((sum: number, depreciation: Depreciation) => {
+      // depreciation may not have forecast item for current financial year
+      if (!depreciation.currentYearForecast) {
+        return sum;
+      }
+
+      return sum + depreciation.currentYearForecast.claimAmount;
+    }, 0);
+  }
+
+  calculateBorrowingExpenses(depreciationList: Depreciation[]): Observable<number> {
+    return this.getByIds(depreciationList)
+      .pipe(
+        map((depreciations: Depreciation[]) => {
+          return this.calculateSummaryAmount(depreciations.filter((depreciation: Depreciation) => depreciation.isBorrowingExpense()));
+        })
+      );
+  }
+
+  calculateDepreciations(depreciationList: Depreciation[]): Observable<number> {
+    return this.getByIds(depreciationList)
+      .pipe(
+        map((depreciations: Depreciation[]) => {
+          return this.calculateSummaryAmount(depreciations.filter((depreciation: Depreciation) => !depreciation.isBorrowingExpense()));
+        })
+      );
+  }
+
+
+  /**
+   * Upload depreciation receipt
+   * @param depreciation for which will be uploaded receipt
+   */
+  uploadReceipt(depreciation: Depreciation): void {
+    const formData: FormData = new FormData();
+    formData.append('file', depreciation.file);
+    depreciation.receipt = null;
+
+    this.http.post(`${this.environment.apiV2}/${this.url}/${depreciation.id}/receipts`, formData)
+      .subscribe((receiptResponse: any) => {
+        // we don't need to keep file after save
+        depreciation.file = null;
+        depreciation.receipt = plainToClass(DepreciationReceipt, receiptResponse);
+        replace(this.cache, depreciation);
+        this.cacheSubject.next(this.cache.slice());
+      });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated bank loan
+   */
+  private listenToUpdatedLoan(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.LOAN_UPDATED, AppEventTypeEnum.PROPERTY_OWNER_UPDATED]).subscribe(() => {
+      this.fetch().subscribe();
+    });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated bank account
+   */
+  private listenToUpdatedBankAccount(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.BANK_ACCOUNT_UPDATED]).subscribe((bankAccount: BankAccount) => {
+      if (bankAccount.isPropertyTank()) {
+        this.fetch().subscribe();
+      }
+    });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated vehicle claim
+   */
+  private listenToVehicleClaim(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.VEHICLE_CLAIM_CREATED, AppEventTypeEnum.VEHICLE_CLAIM_UPDATED]).subscribe(() => {
+      this.fetch().subscribe();
+    });
+  }
+}

package/src/lib/services/document/document-folder.service.spec.ts

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

package/src/lib/services/document/document-folder.service.ts

@@ -0,0 +1,95 @@
+import { Inject, Injectable } from '@angular/core';
+import { DocumentFolder as DocumentFolderBase } from '../../db/Models/document-folder';
+import { HttpClient } from '@angular/common/http';
+import { Document as DocumentBase } from '../../db/Models/document';
+import { Document } from '../../models/document/document';
+import { replace } from '../../functions/array';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { DocumentFolder } from '../../models/document/document-folder';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+
+/**
+ * Service to handle document-folders and depending documents logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentFolderService extends BaseRestService<DocumentFolderBase, DocumentFolder> {
+  url: string = 'folders';
+  modelClass: typeof DocumentFolder = DocumentFolder;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+  }
+
+  /**
+   * Add new document to the folder
+   * @param file to be uploaded to the folder
+   * @param folder for document
+   */
+  addDocument(file: File, folder: DocumentFolder): Observable<void> {
+    // create formData object with provided file
+    const formDataDocument: FormData = new FormData();
+    formDataDocument.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/folders/${folder.id}/documents`, formDataDocument).pipe(
+      map((response: DocumentBase) => {
+        const updatedFolder: DocumentFolder = Object.assign(plainToClass(DocumentFolder, {}), folder);
+        updatedFolder.documents.push(plainToClass(Document, response));
+
+        replace(this.cache, plainToClass(DocumentFolder, updatedFolder));
+        this.cacheSubject.next(this.cache);
+      })
+    );
+  }
+
+  /**
+   * Edit folder document by moving it from one folder to another
+   * @param editedDocument
+   * @param selectedFolder to move the document to
+   * @param oldFolderId: id of old folder from which need to remove the document
+   */
+  updateDocument(editedDocument: Document, selectedFolder: DocumentFolder, oldFolderId: number): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/folders/${selectedFolder.id}/documents/${editedDocument.id}`, editedDocument).pipe(
+      map((response: DocumentBase) => {
+        const oldFolder: DocumentFolder = this.cache.find((folder: DocumentFolder) => folder.id === oldFolderId);
+        // Remove document from old folder
+        oldFolder.documents = oldFolder.documents.filter((deletedDocument: Document) => deletedDocument.id !== response.id);
+
+        // update old folder and replace it in cache
+        response.folder = plainToClass(DocumentFolder, {id: selectedFolder.id, name: selectedFolder.name});
+        replace(this.cache, plainToClass(DocumentFolder, oldFolder));
+
+        // update new document folder and replace it in cache
+        selectedFolder.documents.push(plainToClass(Document, response));
+        replace(this.cache, plainToClass(DocumentFolder, selectedFolder));
+
+        this.cacheSubject.next(this.cache);
+      })
+    );
+  }
+
+  /**
+   * Delete document from folder
+   * @param document to remove
+   * @param folder from which document should be removed
+   */
+  deleteDocument(document: Document, folder: DocumentFolder): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/folders/${folder.id}/documents/${document.id}`).pipe(
+      map(() => {
+        folder.documents = folder.documents
+          .filter((deletedDocument: Document) => deletedDocument.id !== document.id);
+        replace(this.cache, plainToClass(DocumentFolder, folder));
+
+        this.cacheSubject.next(this.cache);
+      })
+    );
+  }
+}

package/src/lib/services/employee/employee-invite.service.spec.ts

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

package/src/lib/services/employee/employee-invite.service.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { EmployeeInvite as EmployeeInviteBase } from '../../db/Models/employee-invite';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { EmployeeInvite } from '../../models/employee/employee-invite';
+import { BaseRestService } from '../base-rest.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EmployeeInviteService extends BaseRestService<EmployeeInviteBase, EmployeeInvite> {
+  url: string = 'employees/invites';
+  modelClass: typeof EmployeeInvite = EmployeeInvite;
+
+  /**
+   * Import employees for firm from CSV file
+   * @param file
+   */
+  import(file: File): Observable<EmployeeInvite[]> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/${this.url}/import`, formData)
+      .pipe(
+        map((employeeInvite: EmployeeInvite[]) => {
+          return employeeInvite;
+        })
+      );
+  }
+
+  /**
+   * Resend invitation from firm to client
+   * @param invite
+   */
+  resend(invite: EmployeeInvite): Observable<EmployeeInvite> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)
+      .pipe(
+        map((resentInviteBase: EmployeeInviteBase): EmployeeInvite => {
+          const updatedInvite: EmployeeInvite = plainToClass(EmployeeInvite, resentInviteBase);
+          // avoid cache changes
+          // @TODO make cache readonly
+          const tempCache: EmployeeInvite[] = _.cloneDeep(this.cache);
+          replace(tempCache, plainToClass(EmployeeInvite, updatedInvite));
+          this.cache = tempCache;
+          this.updateCache();
+          return updatedInvite;
+        })
+      );
+  }
+}

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

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

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

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { BaseRestService } from '../base-rest.service';
+import { User as UserBase } from '../../db/Models/user';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import { replace } from '../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { User } from '../../models/user/user';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EmployeeService extends BaseRestService<UserBase, User>{
+  url: string = 'employees';
+  modelClass: typeof User = User;
+
+  /**
+   * Grant/Remove Manager role to employee
+   * @param employee
+   */
+  toggleManagerRole(employee: User): Observable<User> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${employee.id}`, {})
+      .pipe(
+        map((updatedEmployeeBase: UserBase): User => {
+          const tempCache: User[] = this.cache;
+          const updatedEmployee: User = plainToClass(User, updatedEmployeeBase);
+          replace(tempCache, updatedEmployee);
+          this.cache = _.cloneDeep(tempCache);
+          this.updateCache();
+          return updatedEmployee;
+        })
+      );
+  }
+}

package/src/lib/services/event/event-dispatcher.service.spec.ts

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

package/src/lib/services/event/event-dispatcher.service.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { Observable, Subject } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EventDispatcherService {
+  private eventSubject: Subject<AppEvent<any>> = new Subject();
+
+  /**
+   * subscription to specific event type
+   */
+  on(eventType: AppEventTypeEnum | AppEventTypeEnum[]): Observable<any> {
+    return this.eventSubject.pipe(
+      filter((event: AppEvent<any>): boolean => [].concat(eventType).includes(event.type)),
+      map((event: AppEvent<any>): any => event.payload)
+    );
+  }
+
+  /**
+   * deliver new event
+   */
+  dispatch<T>(event: AppEvent<T>): void {
+    this.eventSubject.next(event);
+  }
+}

package/src/lib/services/event/sse.service.spec.ts

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

package/src/lib/services/event/sse.service.ts

@@ -0,0 +1,42 @@
+import { Inject, Injectable, NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { EventSourcePolyfill } from 'event-source-polyfill/src/eventsource.min.js';
+import { JwtService } from '../auth/jwt.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SseService {
+  constructor(
+    private zone: NgZone,
+    private jwtService: JwtService,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  /**
+   * list to url for server events
+   */
+  on(topic: string): Observable<object> {
+    const url: URL = new URL(this.environment.mercureUrl);
+    url.searchParams.append('topic', `${this.environment.apiV2}/users/${this.jwtService.decodeToken().username}/${topic}`);
+    // tslint:disable-next-line:typedef
+    return new Observable((observer) => {
+      const es: EventSourcePolyfill = new EventSourcePolyfill(url, {
+        headers: {
+          Authorization: 'Bearer ' + this.jwtService.getToken(),
+        }
+      });
+
+      es.onmessage = (event: MessageEvent): void => {
+        this.zone.run((): void => observer.next(event));
+      };
+    })
+      .pipe(
+        map((messageEvent: MessageEvent): object => {
+          return JSON.parse(messageEvent.data);
+        })
+      );
+  }
+}