taxtank-core 0.29.36 → 0.30.0

package/esm2020/lib/services/http/loan/loan.service.mjs

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { RestService } from '../rest';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum, BankAccount, Loan, LoanPayout } from '../../../models';
+import { LoanCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling loans logic
+ */
+export class LoanService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'bank-accounts/loans';
+        this.modelClass = Loan;
+        this.collectionClass = LoanCollection;
+        this.disabledMethods = ['post', 'delete', 'deleteBatch'];
+    }
+    /**
+     * Listen to Loans events
+     */
+    listenEvents() {
+        // Update list of loans when added/changed loan bank account
+        this.listenCSE(BankAccount, ['post', 'put'], (bankAccounts) => {
+            if (bankAccounts.find(ba => !!ba.loan)) {
+                this.resetCache();
+            }
+        });
+        this.listenCSE(LoanPayout, ['post', 'put', 'delete'], this.resetCache);
+    }
+    /**
+     * Calculate loan payments
+     */
+    calculateLoanPayments(loan) {
+        return this.http.post(`${this.apiUrl}/calculation`, loan).pipe(map((response) => {
+            return 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, 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
+     * @TODO (TT-2670): Vik: fix api (remove loan id from URL)
+     * @TODO Alex: move to separated service
+     */
+    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
+     *
+     * @TODO Vik (TT-2670): fix api (remove loan id from URL)
+     * @TODO Alex: move to separated service
+     */
+    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: "15.1.5", ngImport: i0, type: LoanService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+LoanService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: LoanService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: LoanService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# 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 { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Loan as LoanBase } from '../../../db/Models';\nimport { map } from 'rxjs/operators';\nimport { RestMethod, RestService } from '../rest';\nimport { plainToClass } from 'class-transformer';\nimport { AppEvent, AppEventTypeEnum, BankAccount, Loan, LoanPayout } from '../../../models';\nimport { IEventListener } from '../../../interfaces';\nimport { LoanCollection } from '../../../collections';\n\n/**\n * Service that handling loans logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class LoanService extends RestService<LoanBase, Loan, LoanCollection> implements IEventListener {\n  endpointUri: string = 'bank-accounts/loans';\n  modelClass: typeof Loan = Loan;\n  collectionClass: typeof LoanCollection = LoanCollection;\n  disabledMethods: RestMethod[] = ['post', 'delete', 'deleteBatch'];\n\n  /**\n   * Listen to Loans events\n   */\n  listenEvents(): void {\n    // Update list of loans when added/changed loan bank account\n    this.listenCSE(BankAccount, ['post', 'put'], (bankAccounts: BankAccount[]) => {\n      if (bankAccounts.find(ba => !!ba.loan)) {\n        this.resetCache();\n      }\n    });\n\n    this.listenCSE(LoanPayout, ['post', 'put', 'delete'], this.resetCache);\n  }\n\n  /**\n   * Calculate loan payments\n   */\n  calculateLoanPayments(loan: Loan): Observable<any> {\n    return this.http.post(`${this.apiUrl}/calculation`, loan).pipe(\n      map((response: any) => {\n        return plainToClass(Loan, response);\n      })\n    );\n  }\n\n  /**\n   * Add new loan payout\n   * @TODO Vik (TT-2670): fix api (remove loan id from URL)\n   * @TODO Alex: move to separated service\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   * @TODO (TT-2670): Vik: fix api (remove loan id from URL)\n   * @TODO Alex: move to separated service\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   *\n   * @TODO Vik (TT-2670): fix api (remove loan id from URL)\n   * @TODO Alex: move to separated service\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/esm2020/lib/services/http/property/property-category/property-category.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { PropertyCategory } from '../../../../models';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * Service for work with Property Categories
+ */
+export class PropertyCategoryService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertyCategory;
+        this.collectionClass = Collection;
+        this.endpointUri = 'properties/categories';
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+    }
+}
+PropertyCategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktY2F0ZWdvcnkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL3Byb3BlcnR5L3Byb3BlcnR5LWNhdGVnb3J5L3Byb3BlcnR5LWNhdGVnb3J5LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQWMsV0FBVyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFFckQ7O0dBRUc7QUFJSCxNQUFNLE9BQU8sdUJBQXdCLFNBQVEsV0FBaUY7SUFIOUg7O1FBSUUsZUFBVSxHQUE0QixnQkFBZ0IsQ0FBQztRQUN2RCxvQkFBZSxHQUFzQixVQUFVLENBQUM7UUFDaEQsZ0JBQVcsR0FBVyx1QkFBdUIsQ0FBQztRQUM5QyxvQkFBZSxHQUFpQixDQUFDLFdBQVcsRUFBRSxVQUFVLEVBQUUsYUFBYSxDQUFDLENBQUM7S0FDMUU7O29IQUxZLHVCQUF1Qjt3SEFBdkIsdUJBQXVCLGNBRnRCLE1BQU07MkZBRVAsdUJBQXVCO2tCQUhuQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFByb3BlcnR5Q2F0ZWdvcnkgYXMgUHJvcGVydHlDYXRlZ29yeUJhc2UgfSBmcm9tICcuLi8uLi8uLi8uLi9kYi9Nb2RlbHMnO1xuaW1wb3J0IHsgUmVzdE1ldGhvZCwgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi8uLi9yZXN0JztcbmltcG9ydCB7IFByb3BlcnR5Q2F0ZWdvcnkgfSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgQ29sbGVjdGlvbiB9IGZyb20gJy4uLy4uLy4uLy4uL2NvbGxlY3Rpb25zJztcblxuLyoqXG4gKiBTZXJ2aWNlIGZvciB3b3JrIHdpdGggUHJvcGVydHkgQ2F0ZWdvcmllc1xuICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBQcm9wZXJ0eUNhdGVnb3J5U2VydmljZSBleHRlbmRzIFJlc3RTZXJ2aWNlPFByb3BlcnR5Q2F0ZWdvcnlCYXNlLCBQcm9wZXJ0eUNhdGVnb3J5LCBDb2xsZWN0aW9uPFByb3BlcnR5Q2F0ZWdvcnk+PntcbiAgbW9kZWxDbGFzczogdHlwZW9mIFByb3BlcnR5Q2F0ZWdvcnkgPSBQcm9wZXJ0eUNhdGVnb3J5O1xuICBjb2xsZWN0aW9uQ2xhc3M6IHR5cGVvZiBDb2xsZWN0aW9uID0gQ29sbGVjdGlvbjtcbiAgZW5kcG9pbnRVcmk6IHN0cmluZyA9ICdwcm9wZXJ0aWVzL2NhdGVnb3JpZXMnO1xuICBkaXNhYmxlZE1ldGhvZHM6IFJlc3RNZXRob2RbXSA9IFsncG9zdEJhdGNoJywgJ3B1dEJhdGNoJywgJ2RlbGV0ZUJhdGNoJ107XG59XG4iXX0=

package/esm2020/lib/services/http/property/property-category-movement/property-category-movement.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { PropertyCategoryMovement } from '../../../../models';
+import { RestService } from '../../rest';
+import { PropertyCategoryMovementCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class PropertyCategoryMovementService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertyCategoryMovement;
+        this.collectionClass = PropertyCategoryMovementCollection;
+        this.endpointUri = 'properties/category-movements';
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+    }
+}
+PropertyCategoryMovementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryMovementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCategoryMovementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryMovementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCategoryMovementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/http/property/property-document/property-document.service.mjs

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest';
+import { AppEventTypeEnum, PropertyDocument } from '../../../../models';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * Class for work with Property Documents
+ */
+export class PropertyDocumentService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertyDocument;
+        this.collectionClass = Collection;
+        this.endpointUri = 'properties/documents';
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch'];
+    }
+    /**
+     * 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.updateCache([newDocument], 'post');
+            }
+            return newDocument;
+        }));
+    }
+    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: "15.1.5", ngImport: i0, type: PropertyDocumentService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyDocumentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyDocumentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/http/property/property-sale/property-sale.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { PropertySale } from '../../../../models';
+import { RestService } from '../../rest';
+import { PropertySaleCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class PropertySaleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = PropertySale;
+        this.collectionClass = PropertySaleCollection;
+        this.endpointUri = 'properties/sales';
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+    }
+}
+PropertySaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertySaleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertySaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertySaleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertySaleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktc2FsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvcHJvcGVydHkvcHJvcGVydHktc2FsZS9wcm9wZXJ0eS1zYWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFjLFdBQVcsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUNyRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFLakUsTUFBTSxPQUFPLG1CQUFvQixTQUFRLFdBQW1FO0lBSDVHOztRQUlFLGVBQVUsR0FBd0IsWUFBWSxDQUFDO1FBQy9DLG9CQUFlLEdBQWtDLHNCQUFzQixDQUFDO1FBQ3hFLGdCQUFXLEdBQVcsa0JBQWtCLENBQUM7UUFDekMsb0JBQWUsR0FBaUIsQ0FBQyxXQUFXLEVBQUUsVUFBVSxFQUFFLGFBQWEsQ0FBQyxDQUFBO0tBQ3pFOztnSEFMWSxtQkFBbUI7b0hBQW5CLG1CQUFtQixjQUZsQixNQUFNOzJGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQcm9wZXJ0eVNhbGUgYXMgUHJvcGVydHlTYWxlQmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uL2RiL01vZGVscyc7XG5pbXBvcnQgeyBQcm9wZXJ0eVNhbGUgfSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgUmVzdE1ldGhvZCwgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi8uLi9yZXN0JztcbmltcG9ydCB7IFByb3BlcnR5U2FsZUNvbGxlY3Rpb24gfSBmcm9tICcuLi8uLi8uLi8uLi9jb2xsZWN0aW9ucyc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFByb3BlcnR5U2FsZVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxQcm9wZXJ0eVNhbGVCYXNlLCBQcm9wZXJ0eVNhbGUsIFByb3BlcnR5U2FsZUNvbGxlY3Rpb24+IHtcbiAgbW9kZWxDbGFzczogdHlwZW9mIFByb3BlcnR5U2FsZSA9IFByb3BlcnR5U2FsZTtcbiAgY29sbGVjdGlvbkNsYXNzOiB0eXBlb2YgUHJvcGVydHlTYWxlQ29sbGVjdGlvbiA9IFByb3BlcnR5U2FsZUNvbGxlY3Rpb247XG4gIGVuZHBvaW50VXJpOiBzdHJpbmcgPSAncHJvcGVydGllcy9zYWxlcyc7XG4gIGRpc2FibGVkTWV0aG9kczogUmVzdE1ldGhvZFtdID0gWydwb3N0QmF0Y2gnLCAncHV0QmF0Y2gnLCAnZGVsZXRlQmF0Y2gnXVxufVxuIl19

package/esm2020/lib/services/http/property/property-sale/tax-exemption/tax-exemption.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../../rest';
+import { TaxExemption } from '../../../../../models';
+import { Collection } from '../../../../../collections';
+import * as i0 from "@angular/core";
+export class TaxExemptionService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = TaxExemption;
+        this.collectionClass = Collection;
+        this.endpointUri = 'tax-exemptions';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+}
+TaxExemptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: TaxExemptionService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+TaxExemptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: TaxExemptionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: TaxExemptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/http/property/property-share/property-share.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { AppEventTypeEnum, PropertyShare, PropertySale } from '../../../../models';
+import { RestService } from '../../rest';
+import { PropertyShareCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+// @TODO check and improve logic during refactoring
+export class PropertyShareService extends RestService {
+    constructor() {
+        super(...arguments);
+        // api url parameter for properties shares
+        this.endpointUri = 'properties/shares';
+        this.modelClass = PropertyShare;
+        this.collectionClass = PropertyShareCollection;
+        this.disabledMethods = ['deleteBatch', 'putBatch', 'postBatch'];
+    }
+    /**
+     * Listen to Event Dispatcher events
+     */
+    listenEvents() {
+        this.listenUserUpdated();
+        this.listenSalesChanges();
+    }
+    /**
+     * Re-invite property share
+     * @param share user to share property
+     */
+    reinvite(share) {
+        return this.http.post(`${this.apiUrl}/${share.id}/reinvite`, {});
+    }
+    /**
+     * Listen to User updated event
+     */
+    listenUserUpdated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.USER_UPDATED)
+            .subscribe(() => {
+            this.resetCache();
+        });
+    }
+    /**
+     * @Todo Alex refactor after PropertyShare functionality in PropertyService will be cleared up
+     */
+    listenSalesChanges() {
+        this.listenCSE(PropertySale, ['post', 'delete'], this.resetCache);
+    }
+}
+PropertyShareService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyShareService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyShareService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyShareService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyShareService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/http/property/property.service.mjs

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum, Property, PropertyCategoryMovement, PropertySubscription, PropertySale, PropertyShare } from '../../../models';
+import merge from 'lodash/merge';
+import { RestService } from '../rest';
+import { PropertyCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+/**
+ * @Todo Alex remove functionality related to PropertyShare
+ * @TODO Alex (TT-1777): replace all event listeners with the new this.listen()
+ * Service for work with Property
+ */
+export class PropertyService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = Property;
+        this.collectionClass = PropertyCollection;
+        this.endpointUri = 'properties';
+        this.disabledMethods = ['deleteBatch'];
+    }
+    put(property) {
+        return super.put(property)
+            // @TODO Alex (TT-1777): handle this events and refactor
+            .pipe(map((updatedProperty) => {
+            if (property.documentFile) {
+                this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED_WITH_DOCUMENT, property));
+            }
+            else {
+                this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED, property));
+            }
+            return updatedProperty;
+        }));
+    }
+    listenEvents() {
+        this.listenShareInviteAccepted();
+        // @TODO Alex: consider to refactor property movements logic similar to client-movements
+        this.listenMovementsChanges();
+        this.listenSalesChanges();
+    }
+    /**
+     * Update cache when share invitation accepted
+     */
+    listenShareInviteAccepted() {
+        this.listenCSE(PropertyShare, ['put'], this.resetCache);
+    }
+    /**
+     * Update cache when property category changed
+     */
+    listenMovementsChanges() {
+        this.listenCSE(PropertyCategoryMovement, ['post', 'put', 'delete'], this.resetCache);
+    }
+    /**
+     * Update cache when property sales changed
+     */
+    listenSalesChanges() {
+        this.listenCSE(PropertySale, ['post', 'delete'], this.resetCache);
+    }
+    updateDepreciationCalculation(property) {
+        const propertyToUpdate = plainToClass(Property, { id: property.id, depreciationCalculation: property.depreciationCalculation });
+        return this.put(propertyToUpdate)
+            .pipe(map((updatedProperty) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_DEPRECIATION_CALCULATION_UPDATED, updatedProperty));
+        }));
+    }
+    /**
+     * Activate deactivated property
+     */
+    activate(property) {
+        return this.http.post(`${this.environment.apiV2}/property-subscriptions`, { property })
+            .pipe(map((propertySubscriptionBase) => {
+            const newPropertySubscription = plainToClass(PropertySubscription, propertySubscriptionBase);
+            const activatedProperty = plainToClass(Property, Object.assign({}, property, { subscriptions: [newPropertySubscription] }));
+            this.updateCache([activatedProperty], 'put');
+        }));
+    }
+    /**
+     * Deactivate activated property
+     */
+    deactivate(property) {
+        return this.http.delete(`${this.environment.apiV2}/property-subscriptions/${property.getCurrentSubscription().id}`)
+            .pipe(map(() => {
+            const deactivatedProperty = plainToClass(Property, Object.assign({}, property, { subscriptions: [] }));
+            this.updateCache([deactivatedProperty], 'put');
+        }));
+    }
+    /**
+     * Update property photo
+     * @param property Property instance for photo update
+     * @param photoFormData FormData with property photo image
+     */
+    updatePhoto(property, photoFormData) {
+        return this.http.post(`${this.environment.apiV2}/properties/${property.id}/photo?_method=PUT`, photoFormData)
+            .pipe(map((photoLink) => {
+            this.updateCache([plainToClass(Property, merge(property, { photo: photoLink }))], 'put');
+        }));
+    }
+}
+PropertyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PropertyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/property/property.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Property as PropertyBase,\n  PropertySubscription as PropertySubscriptionBase\n} from '../../../db/Models';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { plainToClass } from 'class-transformer';\nimport {\n  AppEvent, AppEventTypeEnum,\n  Property, PropertyCategoryMovement, PropertySubscription, PropertySale, PropertyShare\n} from '../../../models';\nimport { IEventListener } from '../../../interfaces';\nimport merge from 'lodash/merge';\nimport { RestMethod, RestService } from '../rest';\nimport { PropertyCollection } from '../../../collections';\n\n/**\n * @Todo Alex remove functionality related to PropertyShare\n * @TODO Alex (TT-1777): replace all event listeners with the new this.listen()\n * Service for work with Property\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PropertyService extends RestService<PropertyBase, Property, PropertyCollection> implements IEventListener {\n  modelClass: typeof Property = Property;\n  collectionClass: typeof PropertyCollection = PropertyCollection;\n  endpointUri: string = 'properties';\n  disabledMethods: RestMethod[] = ['deleteBatch'];\n\n  put(property: Property): Observable<Property> {\n    return super.put(property)\n      // @TODO Alex (TT-1777): handle this events and refactor\n      .pipe(\n        map((updatedProperty: Property): Property => {\n          if (property.documentFile) {\n            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED_WITH_DOCUMENT, property));\n          } else {\n            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED, property));\n          }\n\n          return updatedProperty;\n        })\n      );\n  }\n\n  listenEvents(): void {\n    this.listenShareInviteAccepted();\n    // @TODO Alex: consider to refactor property movements logic similar to client-movements\n    this.listenMovementsChanges();\n    this.listenSalesChanges();\n  }\n\n  /**\n   * Update cache when share invitation accepted\n   */\n  private listenShareInviteAccepted(): void {\n    this.listenCSE(PropertyShare, ['put'], this.resetCache);\n  }\n\n  /**\n   * Update cache when property category changed\n   */\n  private listenMovementsChanges(): void {\n    this.listenCSE(PropertyCategoryMovement, ['post', 'put', 'delete'], this.resetCache);\n  }\n\n  /**\n   * Update cache when property sales changed\n   */\n  private listenSalesChanges(): void {\n    this.listenCSE(PropertySale, ['post', 'delete'], this.resetCache);\n  }\n\n  updateDepreciationCalculation(property: Property): Observable<void> {\n    const propertyToUpdate: Property = plainToClass(Property, { id: property.id, depreciationCalculation: property.depreciationCalculation })\n\n    return this.put(propertyToUpdate)\n      .pipe(\n        map((updatedProperty: Property) => {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_DEPRECIATION_CALCULATION_UPDATED, updatedProperty));\n        })\n      );\n  }\n\n  /**\n   * Activate deactivated property\n   */\n  activate(property: Property): Observable<void> {\n    return this.http.post(`${this.environment.apiV2}/property-subscriptions`, { property })\n      .pipe(\n        map((propertySubscriptionBase: PropertySubscriptionBase) => {\n          const newPropertySubscription: PropertySubscription = plainToClass(PropertySubscription, propertySubscriptionBase);\n          const activatedProperty: Property = plainToClass(Property, Object.assign({}, property, { subscriptions: [newPropertySubscription] }));\n\n          this.updateCache([activatedProperty], 'put');\n        })\n      );\n  }\n\n  /**\n   * Deactivate activated property\n   */\n  deactivate(property: Property): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/property-subscriptions/${property.getCurrentSubscription().id}`)\n      .pipe(\n        map(() => {\n          const deactivatedProperty: Property = plainToClass(Property, Object.assign({}, property, { subscriptions: [] }));\n\n          this.updateCache([deactivatedProperty], 'put');\n        })\n      );\n  }\n\n  /**\n   * Update property photo\n   * @param property Property instance for photo update\n   * @param photoFormData FormData with property photo image\n   */\n  updatePhoto(property: Property, photoFormData: FormData): Observable<void> {\n    return this.http.post(`${this.environment.apiV2}/properties/${property.id}/photo?_method=PUT`, photoFormData)\n      .pipe(\n        map((photoLink: string): void => {\n          this.updateCache([plainToClass(Property, merge(property, { photo: photoLink }))], 'put');\n        })\n      );\n  }\n}\n"]}

package/esm2020/lib/services/http/receipt/receipt.service.mjs

@@ -0,0 +1,76 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AppEvent } from '../../../models/event/app-event';
+import { plainToClass } from 'class-transformer';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event/event-dispatcher.service";
+import * as i3 from "../../toast/toast.service";
+/**
+ * Abstract service class to work with transactions-like receipt files (transactions, depreciations, e.t.c.)
+ * @Todo TT-2191 refactor service when receipts API will be updated
+ */
+export class ReceiptService {
+    constructor(http, eventDispatcherService, environment, toastService) {
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.toastService = toastService;
+    }
+    listenEvents() {
+        this.listenParentWithReceiptUpdated();
+        this.listenParentWithoutReceiptUpdated();
+    }
+    /**
+     * Entity is necessary to take the ID and the receipt file from it.
+     */
+    add(receiptEntity) {
+        const formData = new FormData();
+        formData.append('file', receiptEntity.file);
+        return this.http.post(`${this.environment.apiV2}/${this.entityType}/${receiptEntity.id}/receipts`, formData)
+            .pipe(map((receipt) => {
+            const uploadedReceipt = this.createModelInstance(receipt);
+            this.eventDispatcherService.dispatch(new AppEvent(this.receiptCreatedEvent, uploadedReceipt));
+            return uploadedReceipt;
+        }));
+    }
+    delete(receiptEntity) {
+        return this.http.delete(`${this.environment.apiV2}/${this.entityType}/${receiptEntity.id}/receipts/${receiptEntity.receipt.id}`)
+            .pipe(map(() => {
+            this.eventDispatcherService.dispatch(new AppEvent(this.receiptDeletedEvent, receiptEntity));
+        }));
+    }
+    /**
+     * Parent entity was updated with attached receipt
+     */
+    listenParentWithReceiptUpdated() {
+        this.eventDispatcherService.on(this.entityUpdatedWithReceiptEvent)
+            .subscribe((receiptEntity) => {
+            this.add(receiptEntity).subscribe();
+        });
+    }
+    /**
+     * Parent entity was updated, but receipt was removed
+     */
+    listenParentWithoutReceiptUpdated() {
+        this.eventDispatcherService.on(this.entityUpdatedWithDeletedReceiptEvent)
+            .subscribe((receiptEntity) => {
+            this.delete(receiptEntity).subscribe();
+        });
+    }
+    createModelInstance(data) {
+        return plainToClass(this.modelClass, data);
+    }
+}
+ReceiptService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ReceiptService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Injectable });
+ReceiptService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ReceiptService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ReceiptService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i3.ToastService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"receipt.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/receipt/receipt.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAQ,MAAM,eAAe,CAAC;AASzD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAI3D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;;;;;AAEjD;;;GAGG;AAIH,MAAM,OAAgB,cAAc;IA8BlC,YACY,IAAgB,EAChB,sBAA8C,EACvB,WAAgB,EACvC,YAA0B;QAH1B,SAAI,GAAJ,IAAI,CAAY;QAChB,2BAAsB,GAAtB,sBAAsB,CAAwB;QACvB,gBAAW,GAAX,WAAW,CAAK;QACvC,iBAAY,GAAZ,YAAY,CAAc;IAEtC,CAAC;IAED,YAAY;QACV,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,IAAI,CAAC,iCAAiC,EAAE,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,aAA0B;QAC5B,MAAM,QAAQ,GAAa,IAAI,QAAQ,EAAE,CAAC;QAC1C,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;QAE5C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,IAAI,aAAa,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC;aACzG,IAAI,CACH,GAAG,CAAC,CAAC,OAAkB,EAAE,EAAE;YACzB,MAAM,eAAe,GAAU,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YAEjE,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,CAAA;YAC7F,OAAO,eAAe,CAAC;QACzB,CAAC,CAAC,CACH,CAAA;IACL,CAAC;IAED,MAAM,CAAC,aAA0B;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,IAAI,aAAa,CAAC,EAAE,aAAa,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;aAC7H,IAAI,CACH,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAA;QAC7F,CAAC,CAAC,CACH,CAAA;IACL,CAAC;IAED;;OAEG;IACK,8BAA8B;QACpC,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC,IAAI,CAAC,6BAA6B,CAAC;aAC/D,SAAS,CAAC,CAAC,aAA0B,EAAE,EAAE;YACxC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,SAAS,EAAE,CAAC;QACtC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,iCAAiC;QACvC,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC,IAAI,CAAC,oCAAoC,CAAC;aACtE,SAAS,CAAC,CAAC,aAA0B,EAAE,EAAE;YACxC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,SAAS,EAAE,CAAC;QACzC,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,mBAAmB,CAAC,IAAe;QACzC,OAAO,YAAY,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;;2GA5FmB,cAAc,kFAiCxB,aAAa;+GAjCH,cAAc,cAFtB,MAAM;2FAEE,cAAc;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAkCI,MAAM;2BAAC,aAAa","sourcesContent":["import { Inject, Injectable, Type } from '@angular/core';\nimport { AssetEntityTypeEnum } from '../../../interfaces/asset-entity-type.enum';\nimport { IEventListener } from '../../../interfaces/event-listener.interface';\nimport { Transaction } from '../../../models/transaction/transaction';\nimport { Depreciation } from '../../../models/depreciation/depreciation';\nimport { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';\nimport { TransactionReceipt as TransactionReceiptBase } from '../../../db/Models/transaction/transaction-receipt';\nimport { DepreciationReceipt as DepreciationReceiptBase } from '../../../db/Models/depreciation/depreciation-receipt';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { AppEvent } from '../../../models/event/app-event';\nimport { HttpClient } from '@angular/common/http';\nimport { EventDispatcherService } from '../../event/event-dispatcher.service';\nimport { ToastService } from '../../toast/toast.service';\nimport { plainToClass } from 'class-transformer';\n\n/**\n * Abstract service class to work with transactions-like receipt files (transactions, depreciations, e.t.c.)\n * @Todo TT-2191 refactor service when receipts API will be updated\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport abstract class ReceiptService<ParentModel extends Transaction | Depreciation,\n  BaseModel extends TransactionReceiptBase | DepreciationReceiptBase,\n  Model extends BaseModel> implements IEventListener {\n\n  /**\n   * Needed to fulfill endpoint to API\n   */\n  abstract entityType: AssetEntityTypeEnum;\n  abstract modelClass: Type<Model>;\n\n  /**\n   * Event type that will be dispatched when receipt will be uploaded\n   */\n  abstract receiptCreatedEvent: AppEventTypeEnum;\n\n  /**\n   * Event type that will be dispatched when receipt will be deleted\n   */\n  abstract receiptDeletedEvent: AppEventTypeEnum;\n\n  /**\n   * Event type that will be dispatched when parent entity (transaction-like class) will be updated with attached receipt\n   */\n  abstract entityUpdatedWithReceiptEvent: AppEventTypeEnum;\n\n  /**\n   * Event type that will be dispatched when parent entity (transaction-like class) will be updated with deleted receipt\n   */\n  abstract entityUpdatedWithDeletedReceiptEvent: AppEventTypeEnum;\n\n  protected constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any,\n    protected toastService: ToastService,\n  ) {\n  }\n\n  listenEvents() {\n    this.listenParentWithReceiptUpdated();\n    this.listenParentWithoutReceiptUpdated();\n  }\n\n  /**\n   * Entity is necessary to take the ID and the receipt file from it.\n   */\n  add(receiptEntity: ParentModel): Observable<Model> {\n    const formData: FormData = new FormData();\n    formData.append('file', receiptEntity.file);\n\n    return this.http.post(`${this.environment.apiV2}/${this.entityType}/${receiptEntity.id}/receipts`, formData)\n      .pipe(\n        map((receipt: BaseModel) => {\n          const uploadedReceipt: Model = this.createModelInstance(receipt);\n\n          this.eventDispatcherService.dispatch(new AppEvent(this.receiptCreatedEvent, uploadedReceipt))\n          return uploadedReceipt;\n        })\n      )\n  }\n\n  delete(receiptEntity: ParentModel): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/${this.entityType}/${receiptEntity.id}/receipts/${receiptEntity.receipt.id}`)\n      .pipe(\n        map(() => {\n          this.eventDispatcherService.dispatch(new AppEvent(this.receiptDeletedEvent, receiptEntity))\n        })\n      )\n  }\n\n  /**\n   * Parent entity was updated with attached receipt\n   */\n  private listenParentWithReceiptUpdated() {\n    this.eventDispatcherService.on(this.entityUpdatedWithReceiptEvent)\n      .subscribe((receiptEntity: ParentModel) => {\n        this.add(receiptEntity).subscribe();\n      });\n  }\n\n  /**\n   * Parent entity was updated, but receipt was removed\n   */\n  private listenParentWithoutReceiptUpdated() {\n    this.eventDispatcherService.on(this.entityUpdatedWithDeletedReceiptEvent)\n      .subscribe((receiptEntity: ParentModel) => {\n        this.delete(receiptEntity).subscribe();\n      });\n  }\n\n  private createModelInstance(data: BaseModel): Model {\n    return plainToClass(this.modelClass, data);\n  }\n}\n"]}