taxtank-core 0.17.7 → 0.17.10

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

@@ -1,218 +1,218 @@
-import { Inject, Injectable } from '@angular/core';
-import { ReplaySubject } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { replace } from '../../../functions/array';
-import { classToPlain, 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 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 Alex: refactor all services for work with collections instead of arrays
- * @TODO Alex: implement smart system of default toast messages
- */
-export class RestService {
-    constructor(http, eventDispatcherService, environment, toastService) {
-        this.http = http;
-        this.eventDispatcherService = eventDispatcherService;
-        this.environment = environment;
-        this.toastService = toastService;
-        // subject for service cache
-        this.cacheSubject = new ReplaySubject(1);
-        this.listenEvents();
-    }
-    /**
-     * get cached list of all instances
-     */
-    get() {
-        if (!this.cache) {
-            this.cache = [];
-            this.fetch().subscribe();
-        }
-        return this.cacheSubject.asObservable();
-    }
-    /**
-     * get instance by id from cache
-     * @param id ID of required item
-     */
-    findById(id) {
-        return this.get()
-            .pipe(map((items) => {
-            return items.find((item) => item['id'] === id);
-        }));
-    }
-    /**
-     * get list of items filtered by id.
-     * @param models Array of objects contains required items ids
-     */
-    getByIds(models) {
-        const idsArray = models.map((model) => model['id']);
-        return this.get()
-            .pipe(map((items) => {
-            return items.filter((item) => idsArray.includes(item['id']));
-        }));
-    }
-    /**
-     * add new instance and update cache
-     * @TODO rename to post
-     */
-    add(model, shouldUpdateCache = true) {
-        return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(model))
-            .pipe(map((newItem) => {
-            if (!shouldUpdateCache) {
-                return null;
-            }
-            const newInstance = this.createModelInstance(this.modelClass, newItem);
-            if (this.cache) {
-                this.cache.push(newInstance);
-                this.updateCache();
-            }
-            if (this.messageCreated) {
-                this.toastService.success(this.messageCreated);
-            }
-            return newInstance;
-        }));
-    }
-    /**
-     * Add several new items
-     * @param models Array of new items for saving
-     * @param queryParams query parameters for request
-     * @TODO 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(this.modelClass, 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 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(this.modelClass, 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 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(this.modelClass, 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.cache = this.cache.filter((item) => item['id'] !== model['id']);
-            this.updateCache();
-            if (this.messageDeleted) {
-                this.toastService.success(this.messageDeleted);
-            }
-        }));
-    }
-    /**
-     * delete multiple instances of class
-     * @param models Class instances array for deleting
-     */
-    deleteBatch(models) {
-        return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, models)
-            .pipe(map(() => {
-            const ids = models.map((model) => model['id']);
-            this.cache = this.cache.filter((item) => !ids.includes(item['id']));
-            this.updateCache();
-            if (this.messageDeletedBatch) {
-                this.toastService.success(this.messageDeletedBatch);
-            }
-        }));
-    }
-    /**
-     * clear service cache
-     */
-    resetCache() {
-        this.fetch().subscribe();
-    }
-    /**
-     * get list of base class instances directly from backend
-     */
-    fetch() {
-        return this.http.get(`${this.environment.apiV2}/${this.url}`)
-            .pipe(map((response) => {
-            const items = (this.isHydra ? response['hydra:member'] : response)
-                .map((item) => {
-                return this.createModelInstance(this.modelClass, item);
-            });
-            this.cache = items;
-            this.updateCache();
-            return items;
-        }));
-    }
-    /**
-     * Update cache subject with current cache array value
-     */
-    updateCache() {
-        this.cacheSubject.next(this.cache.slice());
-    }
-    /**
-     * Create new instance of class
-     * @param model The class for which you want to create an instance
-     * @param baseModel base model instance that we will use as constructor options
-     */
-    createModelInstance(model, baseModel) {
-        return plainToClass(model, baseModel, { excludePrefixes: ['@'] });
-    }
-    /**
-     * Method that call all listeners. Empty by default. Should be redefined by child services if required
-     */
-    listenEvents() { }
-}
-RestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RestService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Injectable });
-RestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RestService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RestService, 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":"rest.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/rest/rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { Observable, ReplaySubject } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { replace } from '../../../functions/array';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { EventDispatcherService } from '../../event/event-dispatcher.service';\r\nimport { classToPlain, plainToClass } from 'class-transformer';\r\nimport { ToastService } from '../../toast/toast.service';\r\nimport { IEventListener } from '../../../interfaces/event-listener.interface';\r\n\r\n/**\r\n * Abstract base service that implements common services functionality\r\n * and describe abstract methods/properties that have to be implemented in child services\r\n * Model - entity service is working with\r\n * BaseModel - base entity model that extends by Model\r\n * @TODO Alex: refactor all services for work with collections instead of arrays\r\n * @TODO Alex: implement smart system of default toast messages\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport abstract class RestService<BaseModel, Model extends BaseModel> implements IEventListener {\r\n  // url part for service entity API. Have to be defined in extended classes\r\n  abstract url: string;\r\n  // Model class for instances creating\r\n  abstract modelClass;\r\n  // @TODO Make cache Readonly\r\n  // cached array of service class instances\r\n  protected cache: Model[];\r\n  // subject for service cache\r\n  protected cacheSubject: ReplaySubject<Model[]> = new ReplaySubject<Model[]>(1);\r\n  // flag for work with API platform\r\n  protected isHydra: boolean;\r\n  messageCreated: string;\r\n  messageCreatedBatch: string;\r\n  messageUpdated: string;\r\n  messageUpdatedBatch: string;\r\n  messageDeleted: string;\r\n  messageDeletedBatch: string;\r\n\r\n  constructor(\r\n    protected http: HttpClient,\r\n    protected eventDispatcherService: EventDispatcherService,\r\n    @Inject('environment') protected environment: any,\r\n    protected toastService: ToastService\r\n  ) {\r\n    this.listenEvents();\r\n  }\r\n\r\n  /**\r\n   * get cached list of all instances\r\n   */\r\n  get(): Observable<Model[]> {\r\n    if (!this.cache) {\r\n      this.cache = [];\r\n      this.fetch().subscribe();\r\n    }\r\n\r\n    return this.cacheSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * get instance by id from cache\r\n   * @param id ID of required item\r\n   */\r\n  findById(id: number): Observable<Model> {\r\n    return this.get()\r\n      .pipe(\r\n        map((items: Model[]) => {\r\n          return items.find((item: Model) => item['id'] === id);\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * get list of items filtered by id.\r\n   * @param models Array of objects contains required items ids\r\n   */\r\n  getByIds(models: Model[]): Observable<Model[]> {\r\n    const idsArray: number[] = models.map((model: Model) => model['id']);\r\n\r\n    return this.get()\r\n      .pipe(\r\n        map((items: Model[]) => {\r\n          return items.filter((item: Model) => idsArray.includes(item['id']));\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * add new instance and update cache\r\n   * @TODO rename to post\r\n   */\r\n  add(model: Model, shouldUpdateCache: boolean = true): Observable<Model> {\r\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(model))\r\n      .pipe(\r\n        map((newItem: BaseModel) => {\r\n          if (!shouldUpdateCache) {\r\n            return null\r\n          }\r\n\r\n          const newInstance: Model = this.createModelInstance(this.modelClass, newItem);\r\n          if (this.cache) {\r\n            this.cache.push(newInstance);\r\n            this.updateCache();\r\n          }\r\n\r\n          if (this.messageCreated) {\r\n            this.toastService.success(this.messageCreated);\r\n          }\r\n\r\n          return newInstance;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Add several new items\r\n   * @param models Array of new items for saving\r\n   * @param queryParams query parameters for request\r\n   * @TODO rename to postBatch\r\n   */\r\n  addBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {\r\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)\r\n      .pipe(\r\n        map((newItems: BaseModel[]) => {\r\n          const newInstances: Model[] = newItems.map((item: BaseModel) => this.createModelInstance(this.modelClass, item));\r\n          if (this.cache) {\r\n            this.cache.push(...newInstances);\r\n            this.updateCache();\r\n          }\r\n\r\n          if (this.messageCreatedBatch) {\r\n            this.toastService.success(this.messageCreatedBatch);\r\n          }\r\n\r\n          return newInstances;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update item\r\n   * @param model Existing instance for updating\r\n   * @param queryParams query parameters for request\r\n   * @TODO rename to put\r\n   */\r\n  update(model: Model, queryParams: object = {}): Observable<Model> {\r\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${model['id']}`, classToPlain(model), queryParams)\r\n      .pipe(\r\n        map((updatedItem: BaseModel) => {\r\n          const updatedInstance: Model = this.createModelInstance(this.modelClass, updatedItem);\r\n          replace(this.cache, updatedInstance);\r\n          this.updateCache();\r\n\r\n          if (this.messageUpdated) {\r\n            this.toastService.success(this.messageUpdated);\r\n          }\r\n\r\n          return updatedInstance;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update several items\r\n   * @param models Array of items for updating\r\n   * @param queryParams query parameters for request\r\n   * TODO rename to putBatch\r\n   */\r\n  updateBatch(models: Model[], queryParams: object = {}): Observable<Model[]> {\r\n    return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(models), queryParams)\r\n      .pipe(\r\n        map((updatedItems: BaseModel[]) => {\r\n          const updatedInstances: Model[] = updatedItems.map((item: BaseModel) => this.createModelInstance(this.modelClass, item));\r\n          updatedInstances.forEach((instance: Model) => {\r\n            replace(this.cache, instance);\r\n          });\r\n\r\n          if (this.messageUpdatedBatch) {\r\n            this.toastService.success(this.messageUpdatedBatch);\r\n          }\r\n\r\n          this.updateCache();\r\n          return updatedInstances;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * delete instance of class\r\n   * @param model Class instance for deleting\r\n   */\r\n  delete(model: Model): Observable<void> {\r\n    return this.http.delete(`${this.environment.apiV2}/${this.url}/${model['id']}`)\r\n      .pipe(\r\n        map(() => {\r\n          this.cache = this.cache.filter((item: Model) => item['id'] !== model['id']);\r\n          this.updateCache();\r\n\r\n          if (this.messageDeleted) {\r\n            this.toastService.success(this.messageDeleted);\r\n          }\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * delete multiple instances of class\r\n   * @param models Class instances array for deleting\r\n   */\r\n  deleteBatch(models: Model[]): Observable<void> {\r\n    return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, models)\r\n      .pipe(\r\n        map(() => {\r\n          const ids: number[] = models.map((model: Model): number => model['id']);\r\n          this.cache = this.cache.filter((item: Model) => !ids.includes(item['id']));\r\n          this.updateCache();\r\n\r\n          if (this.messageDeletedBatch) {\r\n            this.toastService.success(this.messageDeletedBatch);\r\n          }\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * clear service cache\r\n   */\r\n  resetCache(): void {\r\n    this.fetch().subscribe();\r\n  }\r\n\r\n  /**\r\n   * get list of base class instances directly from backend\r\n   */\r\n  protected fetch(): Observable<Model[]> {\r\n    return this.http.get(`${this.environment.apiV2}/${this.url}`)\r\n      .pipe(\r\n        map((response: BaseModel[]): Model[] => {\r\n          const items: Model[] = (this.isHydra ? response['hydra:member'] : response)\r\n            .map((item: BaseModel): Model => {\r\n              return this.createModelInstance(this.modelClass, item);\r\n            });\r\n          this.cache = items;\r\n          this.updateCache();\r\n          return items;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update cache subject with current cache array value\r\n   */\r\n  protected updateCache(): void {\r\n    this.cacheSubject.next(this.cache.slice());\r\n  }\r\n\r\n  /**\r\n   * Create new instance of class\r\n   * @param model The class for which you want to create an instance\r\n   * @param baseModel base model instance that we will use as constructor options\r\n   */\r\n  protected createModelInstance(model: new(bm: BaseModel) => Model, baseModel: BaseModel): Model {\r\n    return plainToClass(model, baseModel, { excludePrefixes: ['@'] });\r\n  }\r\n\r\n  /**\r\n   * Method that call all listeners. Empty by default. Should be redefined by child services if required\r\n   */\r\n  listenEvents(): void {}\r\n}\r\n"]}
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { replace } from '../../../functions/array';
+import { classToPlain, 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 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 Alex: refactor all services for work with collections instead of arrays
+ * @TODO Alex: implement smart system of default toast messages
+ */
+export class RestService {
+    constructor(http, eventDispatcherService, environment, toastService) {
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.toastService = toastService;
+        // subject for service cache
+        this.cacheSubject = new ReplaySubject(1);
+        this.listenEvents();
+    }
+    /**
+     * get cached list of all instances
+     */
+    get() {
+        if (!this.cache) {
+            this.cache = [];
+            this.fetch().subscribe();
+        }
+        return this.cacheSubject.asObservable();
+    }
+    /**
+     * get instance by id from cache
+     * @param id ID of required item
+     */
+    findById(id) {
+        return this.get()
+            .pipe(map((items) => {
+            return items.find((item) => item['id'] === id);
+        }));
+    }
+    /**
+     * get list of items filtered by id.
+     * @param models Array of objects contains required items ids
+     */
+    getByIds(models) {
+        const idsArray = models.map((model) => model['id']);
+        return this.get()
+            .pipe(map((items) => {
+            return items.filter((item) => idsArray.includes(item['id']));
+        }));
+    }
+    /**
+     * add new instance and update cache
+     * @TODO rename to post
+     */
+    add(model, shouldUpdateCache = true) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(model))
+            .pipe(map((newItem) => {
+            if (!shouldUpdateCache) {
+                return null;
+            }
+            const newInstance = this.createModelInstance(this.modelClass, newItem);
+            if (this.cache) {
+                this.cache.push(newInstance);
+                this.updateCache();
+            }
+            if (this.messageCreated) {
+                this.toastService.success(this.messageCreated);
+            }
+            return newInstance;
+        }));
+    }
+    /**
+     * Add several new items
+     * @param models Array of new items for saving
+     * @param queryParams query parameters for request
+     * @TODO 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(this.modelClass, 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 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(this.modelClass, 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 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(this.modelClass, 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.cache = this.cache.filter((item) => item['id'] !== model['id']);
+            this.updateCache();
+            if (this.messageDeleted) {
+                this.toastService.success(this.messageDeleted);
+            }
+        }));
+    }
+    /**
+     * delete multiple instances of class
+     * @param models Class instances array for deleting
+     */
+    deleteBatch(models) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/delete`, models)
+            .pipe(map(() => {
+            const ids = models.map((model) => model['id']);
+            this.cache = this.cache.filter((item) => !ids.includes(item['id']));
+            this.updateCache();
+            if (this.messageDeletedBatch) {
+                this.toastService.success(this.messageDeletedBatch);
+            }
+        }));
+    }
+    /**
+     * clear service cache
+     */
+    resetCache() {
+        this.fetch().subscribe();
+    }
+    /**
+     * get list of base class instances directly from backend
+     */
+    fetch() {
+        return this.http.get(`${this.environment.apiV2}/${this.url}`)
+            .pipe(map((response) => {
+            const items = (this.isHydra ? response['hydra:member'] : response)
+                .map((item) => {
+                return this.createModelInstance(this.modelClass, item);
+            });
+            this.cache = items;
+            this.updateCache();
+            return items;
+        }));
+    }
+    /**
+     * Update cache subject with current cache array value
+     */
+    updateCache() {
+        this.cacheSubject.next(this.cache.slice());
+    }
+    /**
+     * Create new instance of class
+     * @param model The class for which you want to create an instance
+     * @param baseModel base model instance that we will use as constructor options
+     */
+    createModelInstance(model, baseModel) {
+        return plainToClass(model, baseModel, { excludePrefixes: ['@'] });
+    }
+    /**
+     * Method that call all listeners. Empty by default. Should be redefined by child services if required
+     */
+    listenEvents() { }
+}
+RestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RestService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Injectable });
+RestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RestService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RestService, 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":"rest.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/rest/rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { replace } from '../../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { EventDispatcherService } from '../../event/event-dispatcher.service';\nimport { classToPlain, plainToClass } from 'class-transformer';\nimport { ToastService } from '../../toast/toast.service';\nimport { IEventListener } from '../../../interfaces/event-listener.interface';\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 Alex: refactor all services for work with collections instead of arrays\n * @TODO Alex: implement smart system of default toast messages\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport abstract class RestService<BaseModel, Model extends BaseModel> implements IEventListener {\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  // flag for work with API platform\n  protected isHydra: boolean;\n  messageCreated: string;\n  messageCreatedBatch: string;\n  messageUpdated: string;\n  messageUpdatedBatch: string;\n  messageDeleted: string;\n  messageDeletedBatch: string;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any,\n    protected toastService: ToastService\n  ) {\n    this.listenEvents();\n  }\n\n  /**\n   * get cached list of all instances\n   */\n  get(): Observable<Model[]> {\n    if (!this.cache) {\n      this.cache = [];\n      this.fetch().subscribe();\n    }\n\n    return this.cacheSubject.asObservable();\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[]) => {\n          return items.find((item: Model) => item['id'] === id);\n        })\n      );\n  }\n\n  /**\n   * get list of items filtered by id.\n   * @param models Array of objects contains required items ids\n   */\n  getByIds(models: Model[]): Observable<Model[]> {\n    const idsArray: number[] = models.map((model: Model) => model['id']);\n\n    return this.get()\n      .pipe(\n        map((items: Model[]) => {\n          return items.filter((item: Model) => idsArray.includes(item['id']));\n        })\n      );\n  }\n\n  /**\n   * add new instance and update cache\n   * @TODO rename to post\n   */\n  add(model: Model, shouldUpdateCache: boolean = true): Observable<Model> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(model))\n      .pipe(\n        map((newItem: BaseModel) => {\n          if (!shouldUpdateCache) {\n            return null\n          }\n\n          const newInstance: Model = this.createModelInstance(this.modelClass, 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   * Add several new items\n   * @param models Array of new items for saving\n   * @param queryParams query parameters for request\n   * @TODO 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(this.modelClass, 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 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(this.modelClass, 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 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(this.modelClass, 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.cache = this.cache.filter((item: Model) => item['id'] !== model['id']);\n          this.updateCache();\n\n          if (this.messageDeleted) {\n            this.toastService.success(this.messageDeleted);\n          }\n        })\n      );\n  }\n\n  /**\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`, models)\n      .pipe(\n        map(() => {\n          const ids: number[] = models.map((model: Model): number => model['id']);\n          this.cache = this.cache.filter((item: Model) => !ids.includes(item['id']));\n          this.updateCache();\n\n          if (this.messageDeletedBatch) {\n            this.toastService.success(this.messageDeletedBatch);\n          }\n        })\n      );\n  }\n\n  /**\n   * clear service cache\n   */\n  resetCache(): void {\n    this.fetch().subscribe();\n  }\n\n  /**\n   * get list of base class instances directly from backend\n   */\n  protected fetch(): Observable<Model[]> {\n    return this.http.get(`${this.environment.apiV2}/${this.url}`)\n      .pipe(\n        map((response: BaseModel[]): Model[] => {\n          const items: Model[] = (this.isHydra ? response['hydra:member'] : response)\n            .map((item: BaseModel): Model => {\n              return this.createModelInstance(this.modelClass, item);\n            });\n          this.cache = items;\n          this.updateCache();\n          return items;\n        })\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   * Create new instance of class\n   * @param model The class for which you want to create an instance\n   * @param baseModel base model instance that we will use as constructor options\n   */\n  protected createModelInstance(model: new(bm: BaseModel) => Model, baseModel: BaseModel): Model {\n    return plainToClass(model, baseModel, { excludePrefixes: ['@'] });\n  }\n\n  /**\n   * Method that call all listeners. Empty by default. Should be redefined by child services if required\n   */\n  listenEvents(): void {}\n}\n"]}