taxtank 0.1.0

package/projects/tt-core/src/lib/services/http/loan/borrowing-expense/borrowing-expense.service.ts

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

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

@@ -0,0 +1 @@
+export * from './borrowing-expense.service';

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

@@ -0,0 +1,4 @@
+export * from './borrowing-expense';
+export * from './loan.service';
+export * from './loan-messages.enum';
+

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

@@ -0,0 +1,6 @@
+export enum LoanMessagesEnum {
+  POST = 'Loan added successfully',
+  PUT = 'Loan updated successfully',
+  DELETE = 'Loan deleted successfully',
+  DELETE_CONFIRM = 'Are you sure you want to delete this loan?',
+}

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

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

@@ -0,0 +1,103 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Loan as LoanBase } from '../../../db/Models';
+import { map } from 'rxjs/operators';
+import { RestMethod, RestService } from '../rest';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum, BankAccount, Loan, LoanPayout } from '../../../models';
+import { IEventListener } from '../../../interfaces';
+import { LoanCollection } from '../../../collections';
+
+/**
+ * Service that handling loans logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class LoanService extends RestService<LoanBase, Loan, LoanCollection> implements IEventListener {
+  endpointUri = 'bank-accounts/loans';
+  modelClass: typeof Loan = Loan;
+  collectionClass: typeof LoanCollection = LoanCollection;
+  disabledMethods: RestMethod[] = ['post', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Loans events
+   */
+  listenEvents(): void {
+    // Update list of loans when added/changed loan bank account
+    this.listenCSE(BankAccount, (bankAccounts: BankAccount[]) => {
+      if (bankAccounts.find(ba => !!ba.loan)) {
+        this.refreshCache();
+      }
+    }, ['post', 'put']);
+
+    this.listenCSE(LoanPayout, this.refreshCache, ['post', 'put', 'delete']);
+  }
+
+  /**
+   * Calculate loan payments
+   */
+  calculateLoanPayments(loan: Loan): Observable<any> {
+    return this.http.post(`${this.apiUrl}/calculation`, loan).pipe(
+      map((response: any) => plainToClass(Loan, response))
+    );
+  }
+
+  /**
+   * Add new loan payout
+   * @TODO Vik (TT-2670): fix api (remove loan id from URL)
+   * @TODO Alex: move to separated service
+   */
+  addPayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(
+      map((response: any) => {
+        loan.payout = plainToClass(LoanPayout, response);
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+        // reset cache to fetch loans with updated data
+        this.refreshCache();
+      })
+    );
+  }
+
+  /**
+   * Delete loan payout
+   * @TODO (TT-2670): Vik: fix api (remove loan id from URL)
+   * @TODO Alex: move to separated service
+   */
+  deletePayoutLoan(loan: Loan, payout: LoanPayout): Observable<any> {
+    return this.http.delete(`${this.environment.apiV2}/loans/${loan.id}/payout/${payout.id}`).pipe(
+      map(() => {
+        loan.payout = null;
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+        // reset cache to fetch loans with updated data
+        this.refreshCache();
+      })
+    );
+  }
+
+  /**
+   * Update loan payout
+   *
+   * @TODO Vik (TT-2670): fix api (remove loan id from URL)
+   * @TODO Alex: move to separated service
+   */
+  updatePayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(
+      map((response: any) => {
+        loan.payout = plainToClass(LoanPayout, response);
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+        // reset cache to fetch loans with updated data
+        this.refreshCache();
+      })
+    );
+  }
+
+  delete(loan: Loan): Observable<void> {
+    return super.delete(loan, `${this.environment.apiV2}/loans/${loan.id}`)
+  }
+}

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

@@ -0,0 +1,23 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+
+/**
+ * @TODO TT-3846 upgrade
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PdfService {
+  constructor(private http: HttpClient, @Inject('environment') protected environment: any) {}
+
+  fromHTMLElements(elements: NodeListOf<HTMLElement>, landscape: boolean) {
+    const formData: FormData = new FormData();
+    formData.append('file', new Blob(
+      [...Array.from(elements).map(element => element.outerHTML)],
+      { type: 'text/html' }
+    ));
+    formData.append('landscape', landscape ? '1' : '0');
+
+    return this.http.post(`${this.environment.apiV2}/pdf/html`, formData, { responseType: 'blob' });
+  }
+}

package/projects/tt-core/src/lib/services/http/property/borrowing-report/borrowing-report-messages.enum.ts

@@ -0,0 +1,5 @@
+export enum BorrowingReportMessagesEnum {
+  POST = 'Borrowing report successfully added',
+  PUT = 'Borrowing report successfully updated',
+  DELETE = 'Borrowing report successfully reset'
+}

package/projects/tt-core/src/lib/services/http/property/borrowing-report/borrowing-report.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../../rest';
+import { BorrowingReport as BorrowingReportBase } from '../../../../db/Models/property/borrowing-report';
+import { BorrowingReport } from '../../../../models';
+import { Collection } from '../../../../collections';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BorrowingReportService extends RestService<BorrowingReportBase, BorrowingReport, Collection<BorrowingReport>> {
+  endpointUri = 'borrowing-reports';
+  modelClass: typeof BorrowingReport = BorrowingReport;
+  collectionClass: typeof Collection = Collection;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

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

@@ -0,0 +1,2 @@
+export * from './borrowing-report.service';
+export * from './borrowing-report-messages.enum';

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

@@ -0,0 +1,9 @@
+export * from './borrowing-report';
+export * from './property-category';
+export * from './property-category-movement';
+export * from './property-sale';
+export * from './property-share';
+export * from './property-valuation';
+
+export * from './property-messages.enum';
+export * from './property.service';

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

@@ -0,0 +1 @@
+export * from './property-category.service';

package/projects/tt-core/src/lib/services/http/property/property-category/property-category.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/property/property-category/property-category.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { PropertyCategory as PropertyCategoryBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertyCategory } from '../../../../models';
+import { Collection } from '../../../../collections';
+
+/**
+ * Service for work with Property Categories
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyCategoryService extends RestService<PropertyCategoryBase, PropertyCategory, Collection<PropertyCategory>>{
+  modelClass: typeof PropertyCategory = PropertyCategory;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'properties/categories';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

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

@@ -0,0 +1 @@
+export * from './property-category-movement.service';

package/projects/tt-core/src/lib/services/http/property/property-category-movement/property-category-movement.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/property/property-category-movement/property-category-movement.service.ts

@@ -0,0 +1,27 @@
+import { Inject, Injectable } from '@angular/core';
+import { Property, PropertyCategoryMovement, PropertyValuation } from '../../../../models';
+import { PropertyCategoryMovement as PropertyCategoryMovementBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertyCategoryMovementCollection } from '../../../../collections';
+import { IEventListener } from '../../../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyCategoryMovementService extends RestService<PropertyCategoryMovementBase, PropertyCategoryMovement, PropertyCategoryMovementCollection> implements IEventListener {
+  modelClass: typeof PropertyCategoryMovement = PropertyCategoryMovement;
+  collectionClass: typeof PropertyCategoryMovementCollection = PropertyCategoryMovementCollection;
+  endpointUri = 'property-category-movements';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    // property created together with categories, we need to update the list
+    this.listenCSE(Property, this.refreshCache, ['post']);
+    this.listenCSE(PropertyValuation, this.refreshCache);
+  }
+}

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

@@ -0,0 +1,9 @@
+export enum PropertyMessagesEnum {
+  PHOTO_UPDATED = 'Property photo updated',
+  PROPERTY_UPDATED = 'Property updated',
+  DELETE_CONFIRM = 'Are you sure you want to delete property?',
+  DELETE = 'Property deleted',
+  DELETE_500 = 'Only properties without transactions can be removed',
+  SHARESIGHT_CONNECTED = 'Property connected to sharesight',
+  SHARESIGHT_DISCONNECTED = 'Property disconnected from sharesight',
+}

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

@@ -0,0 +1,2 @@
+export * from '../../../json/tax-exemption/tax-exemption.service';
+export * from './property-sale.service';

package/projects/tt-core/src/lib/services/http/property/property-sale/property-sale.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/property/property-sale/property-sale.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { PropertySale as PropertySaleBase } from '../../../../db/Models';
+import { PropertySale } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { PropertySaleCollection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertySaleService extends RestService<PropertySaleBase, PropertySale, PropertySaleCollection> {
+  modelClass: typeof PropertySale = PropertySale;
+  collectionClass: typeof PropertySaleCollection = PropertySaleCollection;
+  endpointUri = 'properties/sales';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  roles = [UserRolesEnum.PROPERTY_TANK];
+}

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

@@ -0,0 +1 @@
+export * from './property-share.service';

package/projects/tt-core/src/lib/services/http/property/property-share/property-share.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/property/property-share/property-share.service.ts

@@ -0,0 +1,72 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PropertyShare as PropertyShareBase } from '../../../../db/Models';
+import { PropertySale, PropertyShare, User } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { IEventListener } from '../../../../interfaces';
+import { PropertyShareCollection } from '../../../../collections';
+import { PropertyShareStatusEnum } from '../../../../db/Enums/property/property-share-status.enum';
+import clone from 'lodash/clone';
+import { UserRolesEnum } from 'taxtank-core/common';
+
+// @TODO check and improve logic during refactoring
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyShareService extends RestService<PropertyShareBase, PropertyShare, PropertyShareCollection> implements IEventListener {
+  // api url parameter for properties shares
+  endpointUri = 'properties/shares';
+  modelClass: typeof PropertyShare = PropertyShare;
+  collectionClass: typeof PropertyShareCollection = PropertyShareCollection;
+  disabledMethods: RestMethod[] = ['deleteBatch', 'putBatch', 'postBatch'];
+  roles = [UserRolesEnum.PROPERTY_TANK];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Event Dispatcher events
+   */
+  listenEvents(): void {
+    this.listenUserUpdated();
+    this.listenSalesChanges();
+  }
+
+  accept(share: PropertyShare): Observable<PropertyShare> {
+    return this.put(
+      Object.assign(clone(share), { status: PropertyShareStatusEnum.APPROVED })
+    );
+  }
+
+  reject(share: PropertyShare): Observable<PropertyShare> {
+    return this.put(
+      Object.assign(clone(share), { status: PropertyShareStatusEnum.REJECTED })
+    );
+  }
+
+  /**
+   * Re-invite property share
+   * @param share user to share property
+   */
+  reinvite(share: PropertyShare): Observable<object> {
+    return this.http.post(`${this.apiUrl}/${share.id}/reinvite`, {});
+  }
+
+  /**
+   * Listen to User updated event
+   */
+  private listenUserUpdated(): void {
+    this.eventDispatcherService.on2(User.getEventName('put')).subscribe((): void => {
+      this.refreshCache();
+    });
+  }
+
+  /**
+   * @Todo Alex refactor after PropertyShare functionality in PropertyService will be cleared up
+   */
+  private listenSalesChanges(): void {
+    this.listenCSE(PropertySale, this.refreshCache, ['post', 'delete']);
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './property-valuation.service';
+export * from './property-valuation-messages.enum';

package/projects/tt-core/src/lib/services/http/property/property-valuation/property-valuation-messages.enum.ts

@@ -0,0 +1,5 @@
+export enum PropertyValuationMessages {
+  CREATED = 'Property valuation created',
+  UPDATED = 'Property valuation updated',
+  DELETED = 'Property valuation deleted'
+}

package/projects/tt-core/src/lib/services/http/property/property-valuation/property-valuation.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/property/property-valuation/property-valuation.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../../rest';
+import { PropertyValuation as PropertyValuationBase } from '../../../../db/Models';
+import { PropertyValuation } from '../../../../models';
+import { PropertyValuationCollection } from '../../../../collections';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyValuationService extends RestService<PropertyValuationBase, PropertyValuation, PropertyValuationCollection> {
+  protected endpointUri = 'property-valuations';
+  modelClass: typeof PropertyValuation = PropertyValuation;
+  collectionClass: typeof PropertyValuationCollection = PropertyValuationCollection;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch'];
+  useBackendError = true;
+}

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

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