taxtank-core 0.8.3 → 0.8.7

package/esm2015/lib/services/http/loan/loan.service.js

@@ -0,0 +1,145 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace } from '../../../functions/array';
+import { RestService } from '../rest/rest.service';
+import { plainToClass } from 'class-transformer';
+import { Loan } from '../../../models/loan/loan';
+import { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';
+import { AppEvent } from '../../../models/event/app-event';
+import { LoanPayout } from '../../../models/loan/loan-payout';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event/event-dispatcher.service";
+/**
+ * Service that handling loans logic
+ */
+export class LoanService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'bank-accounts/loans';
+        this.modelClass = Loan;
+        this.listenEvents();
+    }
+    /**
+     * Listen to Loans events
+     */
+    listenEvents() {
+        this.listenToAddedLoans();
+        this.listenToUpdatedBankAccounts();
+    }
+    listenToAddedLoans() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED)
+            .subscribe((bankAccounts) => {
+            // fetch loans when loan bank account created
+            if (bankAccounts.find(ba => !!ba.loan)) {
+                this.resetCache();
+            }
+        });
+    }
+    listenToUpdatedBankAccounts() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_UPDATED)
+            .subscribe((updatedBankAccount) => {
+            if (!!updatedBankAccount.loan) {
+                this.resetCache();
+            }
+        });
+    }
+    /**
+     * Create Loan
+     */
+    add(model) {
+        return this.addBatch([model])
+            .pipe(map((newLoan) => {
+            return newLoan[0];
+        }));
+    }
+    /**
+     * Updated loan
+     * @param loan
+     */
+    update(loan) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${loan.id}`, loan)
+            .pipe(map((updatedLoanBase) => {
+            const updatedLoan = plainToClass(Loan, updatedLoanBase);
+            // if loan type is NOT vehicle - fire EventDispatcher event
+            if (!updatedLoan.isVehicle()) {
+                this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_UPDATED, null));
+            }
+            replace(this.cache, updatedLoan);
+            this.updateCache();
+            return updatedLoan;
+        }));
+    }
+    /**
+     * Get list of vehicle loans
+     */
+    getVehicleLoans() {
+        return this.get()
+            .pipe(map((loans) => {
+            return loans.filter((loan) => loan.isVehicle());
+        }));
+    }
+    /**
+     * Calculate loan payments
+     * @param loan
+     */
+    calculateLoanPayments(loan) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/calculation`, loan).pipe(map((response) => {
+            return plainToClass(Loan, response);
+        }));
+    }
+    /**
+     * Add new loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    addPayoutLoan(loan, paidOutLoan) {
+        return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(map((response) => {
+            loan.payout = plainToClass(LoanPayout, response);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+            // reset cache to fetch loans with updated data
+            this.resetCache();
+        }));
+    }
+    /**
+     * Delete loan payout
+     * @param loan
+     * @param payout
+     */
+    deletePayoutLoan(loan, payout) {
+        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.resetCache();
+        }));
+    }
+    /**
+     * Update loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    updatePayoutLoan(loan, paidOutLoan) {
+        return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(map((response) => {
+            loan.payout = plainToClass(LoanPayout, response);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+            // reset cache to fetch loans with updated data
+            this.resetCache();
+        }));
+    }
+}
+LoanService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+LoanService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loan.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/loan/loan.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Loan as LoanBase } from '../../../db/Models/loan';\nimport { map } from 'rxjs/operators';\nimport { replace } from '../../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { RestService } from '../rest/rest.service';\nimport { plainToClass } from 'class-transformer';\nimport { Loan } from '../../../models/loan/loan';\nimport { EventDispatcherService } from '../../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';\nimport { BankAccount } from '../../../models/bank/bank-account';\nimport { AppEvent } from '../../../models/event/app-event';\nimport { LoanPayout } from '../../../models/loan/loan-payout';\n\n/**\n * Service that handling loans logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class LoanService extends RestService<LoanBase, Loan> {\n  url: string = 'bank-accounts/loans';\n  modelClass: typeof Loan = Loan;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen to Loans events\n   */\n  listenEvents(): void {\n    this.listenToAddedLoans();\n    this.listenToUpdatedBankAccounts();\n  }\n\n  listenToAddedLoans(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED)\n      .subscribe((bankAccounts: BankAccount[]) => {\n        // fetch loans when loan bank account created\n        if (bankAccounts.find(ba => !!ba.loan)) {\n          this.resetCache();\n        }\n      });\n  }\n\n  listenToUpdatedBankAccounts(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_UPDATED)\n      .subscribe((updatedBankAccount: BankAccount): void => {\n        if (!!updatedBankAccount.loan) {\n          this.resetCache();\n        }\n      });\n  }\n\n  /**\n   * Create Loan\n   */\n  add(model: Loan): Observable<Loan> {\n    return this.addBatch([model])\n      .pipe(\n        map((newLoan: Loan[]): Loan => {\n          return newLoan[0];\n        })\n      );\n  }\n\n  /**\n   * Updated loan\n   * @param loan\n   */\n  update(loan: Loan): Observable<Loan> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${loan.id}`, loan)\n      .pipe(\n        map((updatedLoanBase: LoanBase) => {\n          const updatedLoan: Loan = plainToClass(Loan, updatedLoanBase);\n          // if loan type is NOT vehicle - fire EventDispatcher event\n          if (!updatedLoan.isVehicle()) {\n            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_UPDATED, null));\n          }\n\n          replace(this.cache, updatedLoan);\n          this.updateCache();\n          return updatedLoan;\n        })\n      );\n  }\n\n  /**\n   * Get list of vehicle loans\n   */\n  getVehicleLoans(): Observable<Loan[]> {\n    return this.get()\n      .pipe(\n        map((loans: Loan[]) => {\n          return loans.filter((loan: Loan) => loan.isVehicle());\n        })\n      );\n  }\n\n  /**\n   * Calculate loan payments\n   * @param loan\n   */\n  calculateLoanPayments(loan: Loan): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/calculation`, loan).pipe(\n      map((response: any) => {\n        return plainToClass(Loan, response);\n      })\n    );\n  }\n\n  /**\n   * Add new loan payout\n   * @param loan\n   * @param paidOutLoan\n   */\n  addPayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(\n      map((response: any) => {\n          loan.payout = plainToClass(LoanPayout, response);\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n\n  /**\n   * Delete loan payout\n   * @param loan\n   * @param payout\n   */\n  deletePayoutLoan(loan: Loan, payout: LoanPayout): Observable<any> {\n    return this.http.delete(`${this.environment.apiV2}/loans/${loan.id}/payout/${payout.id}`).pipe(\n      map(() => {\n          loan.payout = null;\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n\n  /**\n   * Update loan payout\n   * @param loan\n   * @param paidOutLoan\n   */\n  updatePayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(\n      map((response: any) => {\n          loan.payout = plainToClass(LoanPayout, response);\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n}\n"]}

package/esm2015/lib/services/http/property/property-category/property-category.service.js

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest.service';
+import { PropertyCategory } from '../../../../models/property/property-category';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property Categories
+ */
+export class PropertyCategoryService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertyCategory;
+        this.url = 'properties/categories';
+    }
+}
+PropertyCategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktY2F0ZWdvcnkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL3Byb3BlcnR5L3Byb3BlcnR5LWNhdGVnb3J5L3Byb3BlcnR5LWNhdGVnb3J5LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sK0NBQStDLENBQUM7O0FBRWpGOztHQUVHO0FBSUgsTUFBTSxPQUFPLHVCQUF3QixTQUFRLFdBQW1EO0lBSGhHOztRQUlFLGVBQVUsR0FBNEIsZ0JBQWdCLENBQUM7UUFDdkQsUUFBRyxHQUFXLHVCQUF1QixDQUFDO0tBQ3ZDOztxSEFIWSx1QkFBdUI7eUhBQXZCLHVCQUF1QixjQUZ0QixNQUFNOzRGQUVQLHVCQUF1QjtrQkFIbkMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQcm9wZXJ0eUNhdGVnb3J5IGFzIFByb3BlcnR5Q2F0ZWdvcnlCYXNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZGIvTW9kZWxzL3Byb3BlcnR5L3Byb3BlcnR5LWNhdGVnb3J5JztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vcmVzdC9yZXN0LnNlcnZpY2UnO1xuaW1wb3J0IHsgUHJvcGVydHlDYXRlZ29yeSB9IGZyb20gJy4uLy4uLy4uLy4uL21vZGVscy9wcm9wZXJ0eS9wcm9wZXJ0eS1jYXRlZ29yeSc7XG5cbi8qKlxuICogU2VydmljZSBmb3Igd29yayB3aXRoIFByb3BlcnR5IENhdGVnb3JpZXNcbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUHJvcGVydHlDYXRlZ29yeVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxQcm9wZXJ0eUNhdGVnb3J5QmFzZSwgUHJvcGVydHlDYXRlZ29yeT57XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBQcm9wZXJ0eUNhdGVnb3J5ID0gUHJvcGVydHlDYXRlZ29yeTtcbiAgdXJsOiBzdHJpbmcgPSAncHJvcGVydGllcy9jYXRlZ29yaWVzJztcbn1cbiJdfQ==

package/esm2015/lib/services/http/property/property-category-movement/property-category-movement.service.js

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { PropertyCategoryMovement } from '../../../../models/property/property-category-movement';
+import { RestService } from '../../rest/rest.service';
+import { map } from 'rxjs/operators';
+import { AppEvent } from '../../../../models/event/app-event';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+export class PropertyCategoryMovementService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertyCategoryMovement;
+        this.url = 'properties/category-movements';
+    }
+    add(model) {
+        return super.add(model).pipe(map((newMovement) => {
+            // @TODO Alex: we need to teach restService to dispatch events + limit list of methods (not all services have all 4 or even more considering batch requests) + collections
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_MOVEMENT_CREATED, null));
+            return newMovement;
+        }));
+    }
+    update(model) {
+        return super.update(model).pipe(map((updatedMovement) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_MOVEMENT_CREATED, null));
+            return updatedMovement;
+        }));
+    }
+    delete(model) {
+        return super.delete(model).pipe(map(() => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_MOVEMENT_CREATED, null));
+        }));
+    }
+    // @TODO Alex: Move to collection
+    getByPropertyId(id) {
+        return this.get().pipe(map((movements) => {
+            return movements.filter((movement) => movement.property.id === id);
+        }));
+    }
+}
+PropertyCategoryMovementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryMovementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCategoryMovementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryMovementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCategoryMovementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/property/property-document/property-document.service.js

@@ -0,0 +1,70 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { PropertyDocument } from '../../../../models/property/property-document';
+import { RestService } from '../../rest/rest.service';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../event/event-dispatcher.service";
+/**
+ * Class for work with Property Documents
+ */
+export class PropertyDocumentService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = PropertyDocument;
+        this.url = 'properties/documents';
+        this.listenEvents();
+    }
+    /**
+     * Add new Property Document
+     */
+    upload(file, propertyId) {
+        // create formData object with provided file
+        const formDataDocument = new FormData();
+        formDataDocument.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/properties/${propertyId}/documents`, formDataDocument).pipe(map((documentBase) => {
+            const newDocument = plainToClass(PropertyDocument, documentBase);
+            if (this.cache) {
+                this.cache.push(newDocument);
+                this.updateCache();
+            }
+            return newDocument;
+        }));
+    }
+    /**
+     * Get documents by property id
+     * @param propertyId to get desired documents
+     */
+    getByPropertyId(propertyId) {
+        return this.get()
+            .pipe(map((documents) => {
+            return documents
+                .filter((document) => document.property.id === propertyId);
+        }));
+    }
+    listenEvents() {
+        this.listenPropertyUpdateWithDocument();
+    }
+    listenPropertyUpdateWithDocument() {
+        this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_UPDATED_WITH_DOCUMENT).subscribe((property) => {
+            this.upload(property.documentFile, property.id).subscribe();
+        });
+    }
+}
+PropertyDocumentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyDocumentService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+PropertyDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyDocumentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyDocumentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/property/property-sale/property-sale.service.js

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { PropertySale } from '../../../../models/property/property-sale/property-sale';
+import { RestService } from '../../rest/rest.service';
+import * as i0 from "@angular/core";
+export class PropertySaleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertySale;
+        this.url = 'properties/sales';
+    }
+}
+PropertySaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertySaleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertySaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertySaleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertySaleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktc2FsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvcHJvcGVydHkvcHJvcGVydHktc2FsZS9wcm9wZXJ0eS1zYWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0seURBQXlELENBQUM7QUFDdkYsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQUt0RCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsV0FBMkM7SUFIcEY7O1FBSUUsZUFBVSxHQUF3QixZQUFZLENBQUM7UUFDL0MsUUFBRyxHQUFXLGtCQUFrQixDQUFDO0tBQ2xDOztpSEFIWSxtQkFBbUI7cUhBQW5CLG1CQUFtQixjQUZsQixNQUFNOzRGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQcm9wZXJ0eVNhbGUgYXMgUHJvcGVydHlTYWxlQmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uL2RiL01vZGVscy9wcm9wZXJ0eS9wcm9wZXJ0eS1zYWxlL3Byb3BlcnR5LXNhbGUnO1xuaW1wb3J0IHsgUHJvcGVydHlTYWxlIH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzL3Byb3BlcnR5L3Byb3BlcnR5LXNhbGUvcHJvcGVydHktc2FsZSc7XG5pbXBvcnQgeyBSZXN0U2VydmljZSB9IGZyb20gJy4uLy4uL3Jlc3QvcmVzdC5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUHJvcGVydHlTYWxlU2VydmljZSBleHRlbmRzIFJlc3RTZXJ2aWNlPFByb3BlcnR5U2FsZUJhc2UsIFByb3BlcnR5U2FsZT4ge1xuICBtb2RlbENsYXNzOiB0eXBlb2YgUHJvcGVydHlTYWxlID0gUHJvcGVydHlTYWxlO1xuICB1cmw6IHN0cmluZyA9ICdwcm9wZXJ0aWVzL3NhbGVzJztcbn1cbiJdfQ==

package/esm2015/lib/services/http/property/property-sale/tax-exemption/tax-exemption.service.js

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../../rest/rest.service';
+import { TaxExemption } from '../../../../../models/property/property-sale/tax-exemption';
+import * as i0 from "@angular/core";
+export class TaxExemptionService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = TaxExemption;
+        this.url = 'tax-exemptions';
+        this.isHydra = true;
+    }
+}
+TaxExemptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxExemptionService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+TaxExemptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxExemptionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxExemptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGF4LWV4ZW1wdGlvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvcHJvcGVydHkvcHJvcGVydHktc2FsZS90YXgtZXhlbXB0aW9uL3RheC1leGVtcHRpb24uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNERBQTRELENBQUM7O0FBSzFGLE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxXQUEyQztJQUhwRjs7UUFJRSxlQUFVLEdBQXdCLFlBQVksQ0FBQztRQUMvQyxRQUFHLEdBQVcsZ0JBQWdCLENBQUM7UUFDL0IsWUFBTyxHQUFZLElBQUksQ0FBQztLQUN6Qjs7aUhBSlksbUJBQW1CO3FIQUFuQixtQkFBbUIsY0FGbEIsTUFBTTs0RkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi8uLi8uLi9yZXN0L3Jlc3Quc2VydmljZSc7XG5pbXBvcnQgeyBUYXhFeGVtcHRpb24gYXMgQmFzZVRheEV4ZW1wdGlvbiB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL2RiL01vZGVscy9wcm9wZXJ0eS9wcm9wZXJ0eS1zYWxlL3RheC1leGVtcHRpb24nO1xuaW1wb3J0IHsgVGF4RXhlbXB0aW9uIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vbW9kZWxzL3Byb3BlcnR5L3Byb3BlcnR5LXNhbGUvdGF4LWV4ZW1wdGlvbic7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFRheEV4ZW1wdGlvblNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxCYXNlVGF4RXhlbXB0aW9uLCBUYXhFeGVtcHRpb24+IHtcbiAgbW9kZWxDbGFzczogdHlwZW9mIFRheEV4ZW1wdGlvbiA9IFRheEV4ZW1wdGlvbjtcbiAgdXJsOiBzdHJpbmcgPSAndGF4LWV4ZW1wdGlvbnMnO1xuICBpc0h5ZHJhOiBib29sZWFuID0gdHJ1ZTtcbn1cbiJdfQ==

package/esm2015/lib/services/http/property/property-share/property-share.service.js

@@ -0,0 +1,115 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace } from '../../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { PropertyShare } from '../../../../models/property/property-share';
+import { RestService } from '../../rest/rest.service';
+import { AppEvent } from '../../../../models/event/app-event';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../event/event-dispatcher.service";
+// @TODO check and improve logic during refactoring
+export class PropertyShareService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // api url parameter for properties shares
+        this.url = 'properties/shares';
+        this.modelClass = PropertyShare;
+        this.listenEvents();
+    }
+    /**
+     * Listen to Event Dispatcher events
+     */
+    listenEvents() {
+        this.listenUserUpdated();
+    }
+    /**
+     * Updated loan
+     */
+    update(propertyShare) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${propertyShare.id}`, propertyShare)
+            .pipe(map((updatedPropertyShareBase) => {
+            const updatedPropertyShare = plainToClass(PropertyShare, updatedPropertyShareBase);
+            // if loan type is NOT vehicle - fire EventDispatcher event
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_SHARE_UPDATED, null));
+            replace(this.cache, updatedPropertyShare);
+            this.updateCache();
+            return updatedPropertyShare;
+        }));
+    }
+    /**
+     * Re-invite property share
+     * @param share user to share property
+     */
+    reinvite(share) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/${share.id}/reinvite`, {});
+    }
+    getIncoming() {
+        return this.get()
+            .pipe(map((propertyShares) => {
+            const propertySharesIncoming = [];
+            propertyShares.forEach((propertyShare) => {
+                var _a;
+                if (((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn()) && propertyShare.isPending() && propertyShare.property.user.id !== +localStorage.getItem('userId')) {
+                    propertySharesIncoming.push(propertyShare);
+                }
+            });
+            return propertySharesIncoming;
+        }));
+    }
+    /**
+     * Get outcoming property shares list
+     */
+    getOutcoming() {
+        return this.get().pipe(map((propertyShares) => {
+            return this.filterOutcoming(propertyShares);
+        }));
+    }
+    /**
+     * Filter outcoming property shares
+     */
+    filterOutcoming(propertyShares) {
+        const propertySharesOutcoming = [];
+        propertyShares.forEach((propertyShare) => {
+            var _a;
+            if (!((_a = propertyShare.user) === null || _a === void 0 ? void 0 : _a.isLoggedIn())) {
+                propertySharesOutcoming.push(propertyShare);
+            }
+        });
+        return propertySharesOutcoming;
+    }
+    getByPropertyId(propertyId) {
+        return this.get()
+            .pipe(map((propertyShares) => {
+            return propertyShares.filter((propertyShare) => propertyShare.property.id === propertyId);
+        }));
+    }
+    /**
+     * Listen to User updated event
+     */
+    listenUserUpdated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.USER_UPDATED)
+            .subscribe(() => {
+            this.fetch().subscribe((propertyShares) => {
+                this.cache = propertyShares;
+                this.updateCache();
+            });
+        });
+    }
+}
+PropertyShareService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyShareService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+PropertyShareService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyShareService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyShareService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-share.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/property/property-share/property-share.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { map } from 'rxjs/operators';\nimport { Observable } from 'rxjs';\nimport { PropertyShare as PropertyShareBase } from '../../../../db/Models/property/property-share';\nimport { replace } from '../../../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { plainToClass } from 'class-transformer';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { PropertyShare } from '../../../../models/property/property-share';\nimport { RestService } from '../../rest/rest.service';\nimport { AppEvent } from '../../../../models/event/app-event';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\n\n// @TODO check and improve logic during refactoring\n@Injectable({\n  providedIn: 'root'\n})\nexport class PropertyShareService extends RestService<PropertyShareBase, PropertyShare> {\n  // api url parameter for properties shares\n  url: string = 'properties/shares';\n  modelClass = PropertyShare;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen to Event Dispatcher events\n   */\n  listenEvents(): void {\n    this.listenUserUpdated();\n  }\n\n  /**\n   * Updated loan\n   */\n  update(propertyShare: PropertyShare): Observable<PropertyShare> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${propertyShare.id}`, propertyShare)\n      .pipe(\n        map((updatedPropertyShareBase: PropertyShareBase) => {\n          const updatedPropertyShare: PropertyShare = plainToClass(PropertyShare, updatedPropertyShareBase);\n          // if loan type is NOT vehicle - fire EventDispatcher event\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_SHARE_UPDATED, null));\n\n          replace(this.cache, updatedPropertyShare);\n          this.updateCache();\n          return updatedPropertyShare;\n        })\n      );\n  }\n\n  /**\n   * Re-invite property share\n   * @param share user to share property\n   */\n  reinvite(share: PropertyShare): Observable<object> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${share.id}/reinvite`, {});\n  }\n\n  getIncoming(): Observable<PropertyShare[]> {\n    return this.get()\n      .pipe(map((propertyShares: PropertyShare[]) => {\n        const propertySharesIncoming: PropertyShare[] = [];\n\n        propertyShares.forEach((propertyShare: PropertyShare) => {\n          if (propertyShare.user?.isLoggedIn() && propertyShare.isPending() && propertyShare.property.user.id !== +localStorage.getItem('userId')) {\n            propertySharesIncoming.push(propertyShare);\n          }\n        });\n\n        return propertySharesIncoming;\n      }));\n  }\n\n  /**\n   * Get outcoming property shares list\n   */\n  getOutcoming(): Observable<PropertyShare[]> {\n    return this.get().pipe(\n      map((propertyShares: PropertyShare[]): PropertyShare[] => {\n        return this.filterOutcoming(propertyShares);\n      })\n    );\n  }\n\n  /**\n   * Filter outcoming property shares\n   */\n  filterOutcoming(propertyShares: PropertyShare[]): PropertyShare[] {\n    const propertySharesOutcoming: PropertyShare[] = [];\n\n    propertyShares.forEach((propertyShare: PropertyShare) => {\n      if (!propertyShare.user?.isLoggedIn()) {\n        propertySharesOutcoming.push(propertyShare);\n      }\n    });\n\n    return propertySharesOutcoming;\n  }\n\n  getByPropertyId(propertyId: number): Observable<PropertyShare[]> {\n    return this.get()\n      .pipe(\n        map((propertyShares: PropertyShare[]) => {\n        return propertyShares.filter((propertyShare: PropertyShare) => propertyShare.property.id === propertyId);\n      }));\n  }\n\n  /**\n   * Listen to User updated event\n   */\n  private listenUserUpdated(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.USER_UPDATED)\n      .subscribe((): void => {\n        this.fetch().subscribe((propertyShares: PropertyShare[]) => {\n          this.cache = propertyShares;\n          this.updateCache();\n        });\n      });\n  }\n}\n"]}