taxtank-core 0.32.88 → 0.33.1

package/esm2022/src/lib/services/http/property/property-share/property-share.service.mjs

@@ -0,0 +1,66 @@
+import { Inject, Injectable } from '@angular/core';
+import { PropertySale, PropertyShare, User } from '../../../../models';
+import { RestService } from '../../rest';
+import { PropertyShareCollection } from '../../../../collections';
+import { PropertyShareStatusEnum } from '../../../../db/Enums/property/property-share-status.enum';
+import clone from 'lodash/clone';
+import * as i0 from "@angular/core";
+// @TODO check and improve logic during refactoring
+export class PropertyShareService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        // api url parameter for properties shares
+        this.endpointUri = 'properties/shares';
+        this.modelClass = PropertyShare;
+        this.collectionClass = PropertyShareCollection;
+        this.disabledMethods = ['deleteBatch', 'putBatch', 'postBatch'];
+        this.listenEvents();
+    }
+    /**
+     * Listen to Event Dispatcher events
+     */
+    listenEvents() {
+        this.listenUserUpdated();
+        this.listenSalesChanges();
+    }
+    accept(share) {
+        return this.put(Object.assign(clone(share), { status: PropertyShareStatusEnum.APPROVED }));
+    }
+    reject(share) {
+        return this.put(Object.assign(clone(share), { status: PropertyShareStatusEnum.REJECTED }));
+    }
+    /**
+     * 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.on2(User.getEventName('put')).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    /**
+     * @Todo Alex refactor after PropertyShare functionality in PropertyService will be cleared up
+     */
+    listenSalesChanges() {
+        this.listenCSE(PropertySale, this.refreshCache, ['post', 'delete']);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyShareService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyShareService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyShareService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/property/property-valuation/index.mjs

@@ -0,0 +1,3 @@
+export * from './property-valuation.service';
+export * from './property-valuation-messages.enum';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9wcm9wZXJ0eS9wcm9wZXJ0eS12YWx1YXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wcm9wZXJ0eS12YWx1YXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Byb3BlcnR5LXZhbHVhdGlvbi1tZXNzYWdlcy5lbnVtJztcbiJdfQ==

package/esm2022/src/lib/services/http/property/property-valuation/property-valuation-messages.enum.mjs

@@ -0,0 +1,7 @@
+export var PropertyValuationMessages;
+(function (PropertyValuationMessages) {
+    PropertyValuationMessages["CREATED"] = "Property valuation created";
+    PropertyValuationMessages["UPDATED"] = "Property valuation updated";
+    PropertyValuationMessages["DELETED"] = "Property valuation deleted";
+})(PropertyValuationMessages || (PropertyValuationMessages = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktdmFsdWF0aW9uLW1lc3NhZ2VzLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9wcm9wZXJ0eS9wcm9wZXJ0eS12YWx1YXRpb24vcHJvcGVydHktdmFsdWF0aW9uLW1lc3NhZ2VzLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVkseUJBSVg7QUFKRCxXQUFZLHlCQUF5QjtJQUNuQyxtRUFBc0MsQ0FBQTtJQUN0QyxtRUFBc0MsQ0FBQTtJQUN0QyxtRUFBc0MsQ0FBQTtBQUN4QyxDQUFDLEVBSlcseUJBQXlCLEtBQXpCLHlCQUF5QixRQUlwQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFByb3BlcnR5VmFsdWF0aW9uTWVzc2FnZXMge1xuICBDUkVBVEVEID0gJ1Byb3BlcnR5IHZhbHVhdGlvbiBjcmVhdGVkJyxcbiAgVVBEQVRFRCA9ICdQcm9wZXJ0eSB2YWx1YXRpb24gdXBkYXRlZCcsXG4gIERFTEVURUQgPSAnUHJvcGVydHkgdmFsdWF0aW9uIGRlbGV0ZWQnXG59XG4iXX0=

package/esm2022/src/lib/services/http/property/property-valuation/property-valuation.service.mjs

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

package/esm2022/src/lib/services/http/property/property.service.mjs

@@ -0,0 +1,87 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum, Property, PropertyCategoryMovement, PropertySale, PropertyShare, PropertySubscription, PropertyValuation } from '../../../models';
+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(environment) {
+        super(environment);
+        this.environment = environment;
+        this.modelClass = Property;
+        this.collectionClass = PropertyCollection;
+        this.endpointUri = 'properties';
+        this.disabledMethods = ['deleteBatch'];
+        this.listenEvents();
+    }
+    /**
+     * @TODO remove when forecast moved to separated api
+     */
+    put(property) {
+        return super.put(property)
+            .pipe(map((updatedProperty) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED, property));
+            return updatedProperty;
+        }));
+    }
+    /**
+     * @TODO no refresh cache with this.updateCache([this.getCache().findBy('id', change.model.property.id)], 'put');
+     */
+    listenEvents() {
+        // share invite accepted event gives access to new property
+        this.listenCSE(PropertyShare, this.refreshCache, ['put']);
+        // @TODO get from separated api?
+        this.listenCSE(PropertySale, this.refreshCache, ['post', 'put', 'delete']);
+        // property caches child entities to improve performance
+        this.listenCSE(PropertyValuation, this.refreshCache);
+        this.listenCSE(PropertyCategoryMovement, this.refreshCache);
+    }
+    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));
+        }));
+    }
+    /**
+     * @TODO move to separated api
+     * 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');
+        }));
+    }
+    /**
+     * @TODO move to separated api
+     * 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');
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: PropertyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# 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 { Inject, 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,\n  AppEventTypeEnum,\n  Property, PropertyCategoryMovement,\n  PropertySale,\n  PropertyShare,\n  PropertySubscription,\n  PropertyValuation\n} from '../../../models';\nimport { IEventListener } from '../../../interfaces';\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 = 'properties';\n  disabledMethods: RestMethod[] = ['deleteBatch'];\n\n  constructor(@Inject('environment') protected environment: any) {\n    super(environment);\n    this.listenEvents();\n  }\n\n  /**\n   * @TODO remove when forecast moved to separated api\n   */\n  put(property: Property): Observable<Property> {\n    return super.put(property)\n      .pipe(\n        map((updatedProperty: Property): Property => {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED, property));\n\n          return updatedProperty;\n        })\n      );\n  }\n\n  /**\n   * @TODO no refresh cache with this.updateCache([this.getCache().findBy('id', change.model.property.id)], 'put');\n   */\n  listenEvents(): void {\n    // share invite accepted event gives access to new property\n    this.listenCSE(PropertyShare, this.refreshCache, ['put']);\n    // @TODO get from separated api?\n    this.listenCSE(PropertySale, this.refreshCache, ['post', 'put', 'delete']);\n    // property caches child entities to improve performance\n    this.listenCSE(PropertyValuation, this.refreshCache);\n    this.listenCSE(PropertyCategoryMovement, this.refreshCache);\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   * @TODO move to separated api\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   * @TODO move to separated api\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"]}

package/esm2022/src/lib/services/http/rest/http-method.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1tZXRob2QudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL3Jlc3QvaHR0cC1tZXRob2QudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgdHlwZSBIdHRwTWV0aG9kID0gJ2dldCcgfCAncG9zdCcgfCAncHV0JyB8ICdkZWxldGUnO1xuIl19

package/esm2022/src/lib/services/http/rest/index.mjs

@@ -0,0 +1,4 @@
+export * from './rest.service';
+export * from './rest-method.type';
+export * from './http-method.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9yZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZXN0LnNlcnZpY2UnXG5leHBvcnQgKiBmcm9tICcuL3Jlc3QtbWV0aG9kLnR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1ldGhvZC50eXBlJztcbiJdfQ==

package/esm2022/src/lib/services/http/rest/rest-method.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdC1tZXRob2QudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL3Jlc3QvcmVzdC1tZXRob2QudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgdHlwZSBSZXN0TWV0aG9kID0gJ2dldCcgfCAncG9zdCcgfCAncG9zdEJhdGNoJyB8ICdwdXQnIHwgJ3B1dEJhdGNoJyB8ICdkZWxldGUnIHwgJ2RlbGV0ZUJhdGNoJztcbiJdfQ==

package/esm2022/src/lib/services/http/rest/rest-old.service.mjs

@@ -0,0 +1,240 @@
+import { Inject, Injectable, inject } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { first, map } from 'rxjs/operators';
+import { replace } from '../../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../../event';
+import { classToPlain, plainToClass } from 'class-transformer';
+import { ToastService } from '../../toast';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base service that implements common services functionality
+ * and describe abstract methods/properties that have to be implemented in child services
+ * Model - entity service is working with
+ * BaseModel - base entity model that extends by Model
+ * @TODO TT-1777 Alex: remove when all services refactored
+ */
+export class RestService {
+    constructor(environment) {
+        this.environment = environment;
+        this.toastService = inject(ToastService);
+        this.http = inject(HttpClient);
+        this.eventDispatcherService = inject(EventDispatcherService);
+        // subject for service cache
+        this.cacheSubject = new ReplaySubject(1);
+        this.roles = [];
+    }
+    get apiUrl() {
+        return `${this.environment.apiV2}/${this.url}`;
+    }
+    /**
+     * get list of base class instances directly from backend
+     */
+    fetch(path = this.apiUrl, cache = true) {
+        if (cache) {
+            this.setCache([]);
+        }
+        return this.http.get(path)
+            .pipe(map((response) => {
+            const items = response.map((item) => this.createModelInstance(item));
+            if (cache) {
+                this.setCache(items, true);
+            }
+            return items;
+        }));
+    }
+    /**
+     * get cached list of all instances
+     */
+    get(path = this.apiUrl) {
+        if (!this.cache) {
+            this.fetch(path).pipe(first()).subscribe();
+        }
+        return this.getCacheSubjectObservable();
+    }
+    /**
+     * get instance by id from cache
+     * @param id ID of required item
+     */
+    findById(id) {
+        return this.get()
+            .pipe(map((items) => items.find((item) => item['id'] === id)));
+    }
+    find(id) {
+        return this.cache.find((item) => item['id'] === id);
+    }
+    /**
+     * add new instance and update cache
+     */
+    create(data, shouldUpdateCache = true) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(data))
+            .pipe(map((newItem) => {
+            if (!shouldUpdateCache) {
+                return null;
+            }
+            const newInstance = this.createModelInstance(newItem);
+            if (this.cache) {
+                this.cache.push(newInstance);
+                this.updateCache();
+            }
+            if (this.messageCreated) {
+                this.toastService.success(this.messageCreated);
+            }
+            return newInstance;
+        }));
+    }
+    /**
+     * @TODO Alex TT-1777 rename to post
+     */
+    add(model, shouldUpdateCache = true) {
+        return this.create(classToPlain(model), shouldUpdateCache);
+    }
+    /**
+     * @TODO Alex TT-1777 rename to upload
+     */
+    postForm(file, params = {}) {
+        const formData = new FormData();
+        formData.append('file', file);
+        for (const key in params) {
+            formData.append(key, params[key]);
+        }
+        return this.create(formData);
+    }
+    /**
+     * Add several new items
+     * @param models Array of new items for saving
+     * @param queryParams query parameters for request
+     * @TODO Alex TT-1777 rename to postBatch
+     */
+    addBatch(models, queryParams = {}) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)
+            .pipe(map((newItems) => {
+            const newInstances = newItems.map((item) => this.createModelInstance(item));
+            if (this.cache) {
+                this.cache.push(...newInstances);
+                this.updateCache();
+            }
+            if (this.messageCreatedBatch) {
+                this.toastService.success(this.messageCreatedBatch);
+            }
+            return newInstances;
+        }));
+    }
+    /**
+     * Update item
+     * @param model Existing instance for updating
+     * @param queryParams query parameters for request
+     * @TODO Alex TT-1777 rename to put
+     */
+    update(model, queryParams = {}) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${model['id']}`, classToPlain(model), queryParams)
+            .pipe(map((updatedItem) => {
+            const updatedInstance = this.createModelInstance(updatedItem);
+            replace(this.cache, updatedInstance);
+            this.updateCache();
+            if (this.messageUpdated) {
+                this.toastService.success(this.messageUpdated);
+            }
+            return updatedInstance;
+        }));
+    }
+    /**
+     * Update several items
+     * @param models Array of items for updating
+     * @param queryParams query parameters for request
+     * TODO Alex TT-1777 rename to putBatch
+     */
+    updateBatch(models, queryParams = {}) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)
+            .pipe(map((updatedItems) => {
+            const updatedInstances = updatedItems.map((item) => this.createModelInstance(item));
+            updatedInstances.forEach((instance) => {
+                replace(this.cache, instance);
+            });
+            if (this.messageUpdatedBatch) {
+                this.toastService.success(this.messageUpdatedBatch);
+            }
+            this.updateCache();
+            return updatedInstances;
+        }));
+    }
+    /**
+     * delete instance of class
+     * @param model Class instance for deleting
+     */
+    delete(model) {
+        return this.http.delete(`${this.environment.apiV2}/${this.url}/${model['id']}`)
+            .pipe(map(() => {
+            this.setCache(this.cache.filter((item) => item['id'] !== model['id']), true);
+            if (this.messageDeleted) {
+                this.toastService.success(this.messageDeleted);
+            }
+        }));
+    }
+    /**
+     * @deprecated use removeBatch
+     * delete multiple instances of class
+     * @param models Class instances array for deleting
+     */
+    deleteBatch(models) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, classToPlain(models))
+            .pipe(map(() => {
+            const ids = models.map((model) => model['id']);
+            this.setCache(this.cache.filter((item) => !ids.includes(item['id'])), true);
+            if (this.messageDeletedBatch) {
+                this.toastService.success(this.messageDeletedBatch);
+            }
+        }));
+    }
+    /**
+     * collect array of redo transactions requests observable
+     */
+    removeBatch(models) {
+        return models.map(model => this.delete(model));
+    }
+    /**
+     * clear service cache
+     */
+    refreshCache() {
+        this.setCache(undefined);
+        this.get();
+    }
+    setCache(data, next = false) {
+        this.cache = data;
+        if (next) {
+            this.updateCache();
+        }
+    }
+    /**
+     * Update cache subject with current cache array value
+     */
+    updateCache() {
+        this.cacheSubject.next(this.cache.slice());
+    }
+    /**
+     * perform a shallow copy of the emitted data to make it immutable
+     */
+    getCacheSubjectObservable() {
+        return this.cacheSubject.asObservable().pipe(map((cache) => cache.slice()));
+    }
+    /**
+     * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+     * Create new instance of class
+     * @param model instance that we will use as constructor options
+     */
+    createModelInstance(model) {
+        return plainToClass(this.modelClass, model);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-old.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/rest/rest-old.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, inject } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { first, map } from 'rxjs/operators';\nimport { replace } from '../../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { EventDispatcherService } from '../../event';\nimport { classToPlain, plainToClass } from 'class-transformer';\nimport { ToastService } from '../../toast';\nimport { UserRolesEnum } from 'taxtank-core/common';\n\n/**\n * Abstract base service that implements common services functionality\n * and describe abstract methods/properties that have to be implemented in child services\n * Model - entity service is working with\n * BaseModel - base entity model that extends by Model\n * @TODO TT-1777 Alex: remove when all services refactored\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport abstract class RestService<BaseModel, Model extends BaseModel> {\n  protected toastService: ToastService = inject(ToastService);\n  protected http: HttpClient = inject(HttpClient);\n  protected eventDispatcherService: EventDispatcherService = inject(EventDispatcherService);\n  // url part for service entity API. Have to be defined in extended classes\n  abstract url: string;\n  // Model class for instances creating\n  abstract modelClass;\n  // @TODO Make cache Readonly\n  // cached array of service class instances\n  protected cache: Model[];\n  // subject for service cache\n  protected cacheSubject: ReplaySubject<Model[]> = new ReplaySubject<Model[]>(1);\n  messageCreated: string;\n  messageCreatedBatch: string;\n  messageUpdated: string;\n  messageUpdatedBatch: string;\n  messageDeleted: string;\n  messageDeletedBatch: string;\n  roles: UserRolesEnum[] = [];\n\n  constructor(@Inject('environment') protected environment: any) {}\n\n  protected get apiUrl(): string {\n    return `${this.environment.apiV2}/${this.url}`;\n  }\n\n  /**\n   * get list of base class instances directly from backend\n   */\n  protected fetch(path = this.apiUrl, cache = true): Observable<Model[]> {\n    if (cache) {\n      this.setCache([]);\n    }\n\n    return this.http.get(path)\n      .pipe(\n        map((response: BaseModel[]): Model[] => {\n          const items: Model[] = response.map((item: BaseModel): Model => this.createModelInstance(item));\n          if (cache) {\n            this.setCache(items, true);\n          }\n          return items;\n        })\n      );\n  }\n\n  /**\n   * get cached list of all instances\n   */\n  get(path: string = this.apiUrl): Observable<Model[]> {\n    if (!this.cache) {\n      this.fetch(path).pipe(first()).subscribe();\n    }\n\n    return this.getCacheSubjectObservable();\n  }\n\n  /**\n   * get instance by id from cache\n   * @param id ID of required item\n   */\n  findById(id: number): Observable<Model> {\n    return this.get()\n      .pipe(\n        map((items: Model[]) => items.find((item: Model) => item['id'] === id))\n      );\n  }\n\n  find(id: number): Model {\n    return this.cache.find((item: Model) => item['id'] === id);\n  }\n\n  /**\n   * add new instance and update cache\n   */\n  private create(data: object, shouldUpdateCache = true): Observable<Model> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(data))\n      .pipe(\n        map((newItem: BaseModel) => {\n          if (!shouldUpdateCache) {\n            return null\n          }\n\n          const newInstance: Model = this.createModelInstance(newItem);\n          if (this.cache) {\n            this.cache.push(newInstance);\n            this.updateCache();\n          }\n\n          if (this.messageCreated) {\n            this.toastService.success(this.messageCreated);\n          }\n\n          return newInstance;\n        })\n      );\n  }\n\n  /**\n   * @TODO Alex TT-1777 rename to post\n   */\n  add(model: Model, shouldUpdateCache = true): Observable<Model> {\n    return this.create(classToPlain(model), shouldUpdateCache);\n  }\n\n  /**\n   * @TODO Alex TT-1777 rename to upload\n   */\n  postForm(file: File, params: { [key: string]: string } = {}): Observable<Model> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n    for (const key in params) {\n      formData.append(key, params[key]);\n    }\n\n    return this.create(formData);\n  }\n\n  /**\n   * Add several new items\n   * @param models Array of new items for saving\n   * @param queryParams query parameters for request\n   * @TODO Alex TT-1777 rename to postBatch\n   */\n  addBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)\n      .pipe(\n        map((newItems: BaseModel[]) => {\n          const newInstances: Model[] = newItems.map((item: BaseModel) => this.createModelInstance(item));\n          if (this.cache) {\n            this.cache.push(...newInstances);\n            this.updateCache();\n          }\n\n          if (this.messageCreatedBatch) {\n            this.toastService.success(this.messageCreatedBatch);\n          }\n\n          return newInstances;\n        })\n      );\n  }\n\n  /**\n   * Update item\n   * @param model Existing instance for updating\n   * @param queryParams query parameters for request\n   * @TODO Alex TT-1777 rename to put\n   */\n  update(model: Model, queryParams: object = {}): Observable<Model> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${model['id']}`, classToPlain(model), queryParams)\n      .pipe(\n        map((updatedItem: BaseModel) => {\n          const updatedInstance: Model = this.createModelInstance(updatedItem);\n          replace(this.cache, updatedInstance);\n          this.updateCache();\n\n          if (this.messageUpdated) {\n            this.toastService.success(this.messageUpdated);\n          }\n\n          return updatedInstance;\n        })\n      );\n  }\n\n  /**\n   * Update several items\n   * @param models Array of items for updating\n   * @param queryParams query parameters for request\n   * TODO Alex TT-1777 rename to putBatch\n   */\n  updateBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)\n      .pipe(\n        map((updatedItems: BaseModel[]) => {\n          const updatedInstances: Model[] = updatedItems.map((item: BaseModel) => this.createModelInstance(item));\n          updatedInstances.forEach((instance: Model) => {\n            replace(this.cache, instance);\n          });\n\n          if (this.messageUpdatedBatch) {\n            this.toastService.success(this.messageUpdatedBatch);\n          }\n\n          this.updateCache();\n          return updatedInstances;\n        })\n      );\n  }\n\n  /**\n   * delete instance of class\n   * @param model Class instance for deleting\n   */\n  delete(model: Model): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/${this.url}/${model['id']}`)\n      .pipe(\n        map(() => {\n          this.setCache(this.cache.filter((item: Model) => item['id'] !== model['id']), true);\n\n          if (this.messageDeleted) {\n            this.toastService.success(this.messageDeleted);\n          }\n        })\n      );\n  }\n\n  /**\n   * @deprecated use removeBatch\n   * delete multiple instances of class\n   * @param models Class instances array for deleting\n   */\n  deleteBatch(models: Model[]): Observable<void> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, classToPlain(models))\n      .pipe(\n        map(() => {\n          const ids: number[] = models.map((model: Model): number => model['id']);\n          this.setCache(this.cache.filter((item: Model) => !ids.includes(item['id'])), true);\n\n          if (this.messageDeletedBatch) {\n            this.toastService.success(this.messageDeletedBatch);\n          }\n        })\n      );\n  }\n\n  /**\n   * collect array of redo transactions requests observable\n   */\n  removeBatch(models: Model[]): Observable<void>[] {\n    return models.map(model => this.delete(model));\n  }\n\n  /**\n   * clear service cache\n   */\n  refreshCache(): void {\n    this.setCache(undefined);\n    this.get();\n  }\n\n  setCache(data: any[], next = false): void {\n    this.cache = data;\n\n    if (next) {\n      this.updateCache();\n    }\n  }\n\n  /**\n   * Update cache subject with current cache array value\n   */\n  protected updateCache(): void {\n    this.cacheSubject.next(this.cache.slice());\n  }\n\n  /**\n   * perform a shallow copy of the emitted data to make it immutable\n   */\n  getCacheSubjectObservable(): Observable<Model[]> {\n    return this.cacheSubject.asObservable().pipe(map((cache) => cache.slice()));\n  }\n\n  /**\n   * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)\n   * Create new instance of class\n   * @param model instance that we will use as constructor options\n   */\n  protected createModelInstance(model: BaseModel | object): Model {\n    return plainToClass(this.modelClass, model);\n  }\n}\n"]}