taxtank-core 0.1.1 → 0.1.5

package/esm2015/lib/services/user-event/user-event-setting.service.js

@@ -0,0 +1,59 @@
+import { Inject, Injectable } from '@angular/core';
+import { UserEventSetting } from '../../models/user-event/user-event-setting';
+import { BaseRestService } from '../base-rest.service';
+import { forkJoin } 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";
+export class UserEventSettingService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = UserEventSetting;
+        this.url = 'user-event-settings';
+        this.isHydra = true;
+    }
+    /**
+     * Send batch to add/updated settings
+     */
+    saveBatch(settings) {
+        // batch with post/put requests based on setting id
+        const batch = settings.map((setting) => {
+            setting.isUpdating = true;
+            if (setting.id) {
+                return this.http.put(`${this.environment.apiV2}/${this.url}/${setting.id}`, classToPlain(setting));
+            }
+            return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(setting));
+        });
+        return forkJoin(batch).pipe(map((eventSettings) => {
+            eventSettings.forEach((eventSetting) => {
+                // get setting from cache by saved setting id
+                const cachedSetting = this.cache.find((setting) => setting.id === eventSetting.id);
+                if (cachedSetting) {
+                    replace(this.cache, eventSetting);
+                }
+                else {
+                    this.cache.push(plainToClass(UserEventSetting, eventSetting));
+                }
+            });
+            this.updateCache();
+        }));
+    }
+}
+UserEventSettingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventSettingService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+UserEventSettingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventSettingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventSettingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/user-event/user-event-type.service.js

@@ -0,0 +1,29 @@
+import { Inject, Injectable } from '@angular/core';
+import { UserEventType } from '../../models/user-event/user-event-type';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+export class UserEventTypeService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = UserEventType;
+        this.url = 'user-event-types';
+        this.isHydra = true;
+    }
+}
+UserEventTypeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventTypeService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+UserEventTypeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventTypeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UserEventTypeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/work/work-tank.service.js

@@ -0,0 +1,236 @@
+import { Inject, Injectable } from '@angular/core';
+import { combineLatest, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChartAccountsHeadingVehicleListEnum } from '../../db/Enums/chart-accounts-heading-vehicle-list.enum';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { plainToClass } from 'class-transformer';
+import { enumToList } from '../../functions/enum-to-list';
+import { Vehicle } from '../../models/logbook/vehicle';
+import { VehicleClaim } from '../../models/logbook/vehicle-claim';
+import { VehicleLogbook } from '../../models/logbook/vehicle-logbook';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+import { Depreciation } from '../../models/depreciation/depreciation';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../transaction/transaction.service";
+import * as i3 from "../depreciation/depreciation.service";
+import * as i4 from "../chart-accounts/chart-accounts.service";
+import * as i5 from "../event/event-dispatcher.service";
+/**
+ * Service that allows to work with WorkTank operations
+ */
+export class WorkTankService {
+    constructor(http, transactionService, depreciationService, chartAccountsService, eventDispatcherService, environment) {
+        this.http = http;
+        this.transactionService = transactionService;
+        this.depreciationService = depreciationService;
+        this.chartAccountsService = chartAccountsService;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.vehiclesSubject = new ReplaySubject(1);
+        this.vehicleClaimSubject = new ReplaySubject(1);
+        this.vehicleClaimRateSubject = new ReplaySubject(1);
+        this.vehicleTaxReturnSubject = new ReplaySubject(1);
+        this.incomePositionsSubject = new ReplaySubject(1);
+    }
+    getVehicles() {
+        // @TODO create backend for get logbook
+        if (!this._vehicles) {
+            this.http.get(`${this.environment.apiV2}/vehicles`)
+                .pipe(map((response) => {
+                return response.map((item) => plainToClass(Vehicle, item));
+            }))
+                .subscribe((vehicles) => {
+                this._vehicles = vehicles;
+                this.vehiclesSubject.next(vehicles);
+            });
+        }
+        return this.vehiclesSubject.asObservable();
+    }
+    /**
+     * Get vehicles claim amount
+     */
+    getVehiclesClaim() {
+        if (!this._vehicleClaim) {
+            this.http.get(`${this.environment.apiV2}/vehicle-claims`)
+                .pipe(map((response) => {
+                // return Vehicle claim from backend or create new if it not exist
+                return response.length ? response.map((item) => plainToClass(VehicleClaim, item))[0] : plainToClass(VehicleClaim, {});
+            }))
+                .subscribe((vehicleClaim) => {
+                this._vehicleClaim = vehicleClaim;
+                this.vehicleClaimSubject.next(vehicleClaim);
+            });
+        }
+        return this.vehicleClaimSubject.asObservable();
+    }
+    /**
+     * Add new vehicle claim
+     * @param claim object which should be added
+     */
+    addVehicleClaim(claim) {
+        return this.http.post(`${this.environment.apiV2}/vehicle-claims`, claim).pipe(map((response) => {
+            this._vehicleClaim = plainToClass(VehicleClaim, response);
+            this.vehicleClaimSubject.next(this._vehicleClaim);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_CREATED, null));
+        }));
+    }
+    /**
+     * Get vehicles claim rate for current financial year
+     */
+    getVehiclesClaimRate() {
+        if (!this._vehicleClaimRate) {
+            this.chartAccountsService.getChartAccountsById(ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK)
+                .pipe(map((response) => {
+                return response.values.find((chartAccount) => chartAccount.financialYear === new FinancialYear().year).value;
+            }))
+                .subscribe((claimRate) => {
+                this._vehicleClaimRate = claimRate;
+                this.vehicleClaimRateSubject.next(this._vehicleClaimRate);
+            });
+        }
+        return this.vehicleClaimRateSubject.asObservable();
+    }
+    /**
+     * Get vehicles tax return for vehicle transactions & depreciations
+     */
+    getVehiclesTaxReturn() {
+        if (!this._vehicleTaxReturn) {
+            combineLatest([
+                // @Todo refactor to avoid injection of another services
+                this.transactionService.get(),
+                this.depreciationService.get(),
+                this.getVehiclesClaim()
+            ]).pipe(map(([transactions, depreciations, vehicleClaim]) => {
+                const chartAccountsHeadingsIds = enumToList(ChartAccountsHeadingVehicleListEnum)
+                    .map((item) => item.value);
+                // get transactions & depreciations which chart accounts headings are belong to vehicle category
+                // but except KLMS transaction
+                const filteredItems = [...transactions, ...depreciations].filter((item) => {
+                    var _a;
+                    return chartAccountsHeadingsIds.includes((_a = item.chartAccounts.heading) === null || _a === void 0 ? void 0 : _a.id) && !item.chartAccounts.isKlmsForWork();
+                });
+                // get claim amount sum
+                return filteredItems.reduce((sum, item) => 
+                // @Todo remove item.amount negative sign when depreciations will be refactored and will have negative sign
+                sum + ((item instanceof Depreciation ? item.currentYearForecast.amount : -item.amount) * (vehicleClaim.workUsage / 100)), 0);
+            }))
+                .subscribe((taxReturn) => {
+                this._vehicleTaxReturn = taxReturn;
+                this.vehicleTaxReturnSubject.next(this._vehicleTaxReturn);
+            });
+        }
+        return this.vehicleTaxReturnSubject.asObservable();
+    }
+    /**
+     * Update vehicle claim
+     * @param claim which should be updated
+     *
+     * @TODO alex refresh depreciation/transaction cache
+     */
+    updateVehicleClaim(claim) {
+        return this.http.put(`${this.environment.apiV2}/vehicle-claims/${claim.id}`, claim).pipe(map((response) => {
+            const updatedVehicleClaim = plainToClass(VehicleClaim, response);
+            this._vehicleClaim = updatedVehicleClaim;
+            this.vehicleClaimSubject.next(this._vehicleClaim);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_UPDATED, null));
+            return updatedVehicleClaim;
+        }));
+    }
+    /**
+     * Add new logbook for desired vehicle
+     * @param logbook which should be added
+     * @param vehicle for which logbook object should be added
+     */
+    addLogbook(logbook, vehicle) {
+        return this.http.post(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks`, logbook)
+            .pipe(map((response) => {
+            this._vehicles.find((v) => v.id === vehicle.id).logbook.push(response);
+            // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+            // that is why we recreate vehicles array
+            this.vehiclesSubject.next(this._vehicles.map((item) => plainToClass(Vehicle, item)));
+        }));
+    }
+    /**
+     * Update logbook
+     * @param logbook which should be updated
+     * @param vehicle for which logbook object should be updated
+     */
+    updateLogbook(logbook, vehicle) {
+        return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`, logbook).pipe(map((response) => {
+            const editedVehicle = this._vehicles.find((v) => v.id === vehicle.id);
+            const editedLogbookIndex = editedVehicle.logbook.findIndex((l) => l.id === logbook.id);
+            editedVehicle.logbook.splice(editedLogbookIndex, 1, plainToClass(VehicleLogbook, response));
+            // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+            // that is why we recreate vehicles array
+            this.vehiclesSubject.next(this._vehicles.map((item) => plainToClass(Vehicle, item)));
+        }));
+    }
+    /**
+     * Delete trip
+     * @param logbook for which trip should be deleted
+     * @param vehicle for which trip should be deleted
+     */
+    deleteTrip(logbook, vehicle) {
+        return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`)
+            .pipe(map(() => {
+            const editedVehicle = this._vehicles.find((v) => v.id === vehicle.id);
+            const deletedLogbookIndex = editedVehicle.logbook.findIndex((l) => l.id === logbook.id);
+            editedVehicle.logbook.splice(deletedLogbookIndex, 1);
+            // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+            // that is why we recreate vehicles array
+            this.vehiclesSubject.next(this._vehicles.map((item) => plainToClass(Vehicle, item)));
+        }));
+    }
+    /**
+     * Add new vehicle
+     * @param vehicle which should be added
+     */
+    addVehicle(vehicle) {
+        return this.http.post(`${this.environment.apiV2}/vehicles`, { name: vehicle.name })
+            .pipe(map((response) => {
+            this._vehicles.push(plainToClass(Vehicle, response));
+            this.vehiclesSubject.next(this._vehicles);
+        }));
+    }
+    /**
+     * Update vehicle
+     * @param vehicle which should be updated
+     */
+    updateVehicle(vehicle) {
+        return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}`, { name: vehicle.name })
+            .pipe(map((response) => {
+            const editedVehicleIndex = this._vehicles.findIndex((v) => v.id === vehicle.id);
+            this._vehicles.splice(editedVehicleIndex, 1, plainToClass(Vehicle, response));
+            this.vehiclesSubject.next(this._vehicles);
+        }));
+    }
+    /**
+     * Delete vehicle
+     * @param vehicle which should be deleted
+     */
+    deleteVehicle(vehicle) {
+        return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}`)
+            .pipe(map(() => {
+            const deletedVehicleIndex = this._vehicles.findIndex((v) => v.id === vehicle.id);
+            this._vehicles.splice(deletedVehicleIndex, 1);
+            // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+            // that is why we recreate vehicles array
+            this.vehiclesSubject.next(this._vehicles.map((item) => plainToClass(Vehicle, item)));
+        }));
+    }
+}
+WorkTankService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: WorkTankService, deps: [{ token: i1.HttpClient }, { token: i2.TransactionService }, { token: i3.DepreciationService }, { token: i4.ChartAccountsService }, { token: i5.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+WorkTankService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: WorkTankService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: WorkTankService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TransactionService }, { type: i3.DepreciationService }, { type: i4.ChartAccountsService }, { type: i5.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-tank.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/work/work-tank.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { combineLatest, Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ChartAccountsHeadingVehicleListEnum } from '../../db/Enums/chart-accounts-heading-vehicle-list.enum';\nimport { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';\nimport { plainToClass } from 'class-transformer';\nimport { TransactionService } from '../transaction/transaction.service';\nimport { enumToList } from '../../functions/enum-to-list';\nimport { Vehicle } from '../../models/logbook/vehicle';\nimport { VehicleClaim } from '../../models/logbook/vehicle-claim';\nimport { VehicleLogbook } from '../../models/logbook/vehicle-logbook';\nimport { IncomePosition } from '../../models/income-position/income-position';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\nimport { AppEvent } from '../../models/event/app-event';\nimport { FinancialYear } from '../../models/financial-year/financial-year';\nimport { Transaction } from '../../models/transaction/transaction';\nimport { Depreciation } from '../../models/depreciation/depreciation';\nimport { DepreciationService } from '../depreciation/depreciation.service';\nimport { ChartAccountsService } from '../chart-accounts/chart-accounts.service';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\n\n/**\n * Service that allows to work with WorkTank operations\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class WorkTankService {\n  // @TODO refactor and maybe break to separated services\n  _vehicles: Vehicle[];\n  vehiclesSubject: ReplaySubject<Vehicle[]> = new ReplaySubject<Vehicle[]>(1);\n  _vehicleClaim: VehicleClaim;\n  vehicleClaimSubject: ReplaySubject<VehicleClaim> = new ReplaySubject<VehicleClaim>(1);\n  _vehicleClaimRate: number;\n  vehicleClaimRateSubject: ReplaySubject<number> = new ReplaySubject<number>(1);\n  _vehicleTaxReturn: number;\n  vehicleTaxReturnSubject: ReplaySubject<number> = new ReplaySubject<number>(1);\n  _incomePositions: IncomePosition[];\n  incomePositionsSubject: ReplaySubject<IncomePosition[]> = new ReplaySubject<IncomePosition[]>(1);\n\n  constructor(\n    private http: HttpClient,\n    private transactionService: TransactionService,\n    private depreciationService: DepreciationService,\n    private chartAccountsService: ChartAccountsService,\n    private eventDispatcherService: EventDispatcherService,\n    @Inject('environment') private environment: any\n  ) {\n  }\n\n  getVehicles(): Observable<Vehicle[]> {\n    // @TODO create backend for get logbook\n    if (!this._vehicles) {\n      this.http.get(`${this.environment.apiV2}/vehicles`)\n        .pipe(\n          map((response: any) => {\n            return response.map((item: any) => plainToClass(Vehicle, item));\n          })\n        )\n        .subscribe((vehicles: Vehicle[]) => {\n          this._vehicles = vehicles;\n          this.vehiclesSubject.next(vehicles);\n        });\n    }\n\n    return this.vehiclesSubject.asObservable();\n  }\n\n  /**\n   * Get vehicles claim amount\n   */\n  getVehiclesClaim(): Observable<VehicleClaim> {\n    if (!this._vehicleClaim) {\n      this.http.get(`${this.environment.apiV2}/vehicle-claims`)\n        .pipe(\n          map((response: any) => {\n            // return Vehicle claim from backend or create new if it not exist\n            return response.length ? response.map((item: any) => plainToClass(VehicleClaim, item))[0] : plainToClass(VehicleClaim, {});\n          })\n        )\n        .subscribe((vehicleClaim: VehicleClaim) => {\n          this._vehicleClaim = vehicleClaim;\n          this.vehicleClaimSubject.next(vehicleClaim);\n        });\n    }\n\n    return this.vehicleClaimSubject.asObservable();\n  }\n\n  /**\n   * Add new vehicle claim\n   * @param claim object which should be added\n   */\n  addVehicleClaim(claim: VehicleClaim): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/vehicle-claims`, claim).pipe(\n      map((response: any) => {\n        this._vehicleClaim = plainToClass(VehicleClaim, response);\n        this.vehicleClaimSubject.next(this._vehicleClaim);\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_CREATED, null));\n      }));\n  }\n\n  /**\n   * Get vehicles claim rate for current financial year\n   */\n  getVehiclesClaimRate(): Observable<number> {\n    if (!this._vehicleClaimRate) {\n      this.chartAccountsService.getChartAccountsById(ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK)\n        .pipe(\n          map((response: any) => {\n            return response.values.find((chartAccount: any) => chartAccount.financialYear === new FinancialYear().year).value;\n          })\n        )\n        .subscribe((claimRate: number) => {\n          this._vehicleClaimRate = claimRate;\n          this.vehicleClaimRateSubject.next(this._vehicleClaimRate);\n        });\n    }\n\n    return this.vehicleClaimRateSubject.asObservable();\n  }\n\n  /**\n   * Get vehicles tax return for vehicle transactions & depreciations\n   */\n  getVehiclesTaxReturn(): Observable<number> {\n    if (!this._vehicleTaxReturn) {\n      combineLatest([\n        // @Todo refactor to avoid injection of another services\n        this.transactionService.get(),\n        this.depreciationService.get(),\n        this.getVehiclesClaim()\n      ]).pipe(\n          map(([transactions, depreciations, vehicleClaim]: [Transaction[], Depreciation[], VehicleClaim]) => {\n            const chartAccountsHeadingsIds: number[] = enumToList(ChartAccountsHeadingVehicleListEnum)\n              .map((item: { label: string, value: number }) => item.value);\n            // get transactions & depreciations which chart accounts headings are belong to vehicle category\n            // but except KLMS transaction\n            const filteredItems: Array<Transaction | Depreciation> = [...transactions, ...depreciations].filter((item: Transaction | Depreciation) => {\n              return chartAccountsHeadingsIds.includes(item.chartAccounts.heading?.id) && !item.chartAccounts.isKlmsForWork();\n            });\n\n            // get claim amount sum\n            return filteredItems.reduce((sum: number, item: Transaction | Depreciation) =>\n              // @Todo remove item.amount negative sign when depreciations will be refactored and will have negative sign\n              sum + ((item instanceof Depreciation ? item.currentYearForecast.amount : -item.amount) * (vehicleClaim.workUsage / 100)), 0);\n          })\n        )\n      .subscribe((taxReturn: number) => {\n        this._vehicleTaxReturn = taxReturn;\n        this.vehicleTaxReturnSubject.next(this._vehicleTaxReturn);\n      });\n    }\n\n    return this.vehicleTaxReturnSubject.asObservable();\n  }\n\n  /**\n   * Update vehicle claim\n   * @param claim which should be updated\n   *\n   * @TODO alex refresh depreciation/transaction cache\n   */\n  updateVehicleClaim(claim: VehicleClaim): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/vehicle-claims/${claim.id}`, claim).pipe(\n      map((response: any) => {\n        const updatedVehicleClaim: VehicleClaim = plainToClass(VehicleClaim, response);\n        this._vehicleClaim = updatedVehicleClaim;\n        this.vehicleClaimSubject.next(this._vehicleClaim);\n\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_UPDATED, null));\n\n        return updatedVehicleClaim;\n      }));\n  }\n\n  /**\n   * Add new logbook for desired vehicle\n   * @param logbook which should be added\n   * @param vehicle for which logbook object should be added\n   */\n  addLogbook(logbook: VehicleLogbook, vehicle: Vehicle): Observable<void> {\n    return this.http.post(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks`, logbook)\n      .pipe(\n        map((response: any) => {\n          this._vehicles.find((v: Vehicle) => v.id === vehicle.id).logbook.push(response);\n          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.\n          // that is why we recreate vehicles array\n          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));\n        })\n      );\n  }\n\n  /**\n   * Update logbook\n   * @param logbook which should be updated\n   * @param vehicle for which logbook object should be updated\n   */\n  updateLogbook(logbook: VehicleLogbook, vehicle: Vehicle): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`, logbook).pipe(\n      map((response: any) => {\n        const editedVehicle: Vehicle = this._vehicles.find((v: Vehicle) => v.id === vehicle.id);\n        const editedLogbookIndex: number = editedVehicle.logbook.findIndex((l: VehicleLogbook) => l.id === logbook.id);\n        editedVehicle.logbook.splice(editedLogbookIndex, 1, plainToClass(VehicleLogbook, response));\n        // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.\n        // that is why we recreate vehicles array\n        this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));\n      })\n    );\n  }\n\n  /**\n   * Delete trip\n   * @param logbook for which trip should be deleted\n   * @param vehicle for which trip should be deleted\n   */\n  deleteTrip(logbook: VehicleLogbook, vehicle: Vehicle): Observable<any> {\n    return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`)\n      .pipe(\n        map(() => {\n          const editedVehicle: Vehicle = this._vehicles.find((v: Vehicle) => v.id === vehicle.id);\n          const deletedLogbookIndex: number = editedVehicle.logbook.findIndex((l: VehicleLogbook) => l.id === logbook.id);\n          editedVehicle.logbook.splice(deletedLogbookIndex, 1);\n          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.\n          // that is why we recreate vehicles array\n          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));\n        })\n      );\n  }\n\n  /**\n   * Add new vehicle\n   * @param vehicle which should be added\n   */\n  addVehicle(vehicle: Vehicle): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/vehicles`, {name: vehicle.name})\n      .pipe(\n        map((response: any) => {\n          this._vehicles.push(plainToClass(Vehicle, response));\n          this.vehiclesSubject.next(this._vehicles);\n        })\n      );\n  }\n\n  /**\n   * Update vehicle\n   * @param vehicle which should be updated\n   */\n  updateVehicle(vehicle: Vehicle): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}`, {name: vehicle.name})\n      .pipe(\n        map((response: any) => {\n          const editedVehicleIndex: number = this._vehicles.findIndex((v: Vehicle) => v.id === vehicle.id);\n          this._vehicles.splice(editedVehicleIndex, 1, plainToClass(Vehicle, response));\n          this.vehiclesSubject.next(this._vehicles);\n        })\n      );\n  }\n\n  /**\n   * Delete vehicle\n   * @param vehicle which should be deleted\n   */\n  deleteVehicle(vehicle: Vehicle): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}`)\n      .pipe(\n        map(() => {\n          const deletedVehicleIndex: number = this._vehicles.findIndex((v: Vehicle) => v.id === vehicle.id);\n          this._vehicles.splice(deletedVehicleIndex, 1);\n          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.\n          // that is why we recreate vehicles array\n          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));\n        })\n      );\n  }\n}\n"]}

package/esm2015/lib/tt-core.module.js

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+export class TtCoreModule {
+    static forRoot(environment) {
+        localStorage.setItem('api_uri', environment['api_uri']);
+        return {
+            ngModule: TtCoreModule,
+            providers: [
+                {
+                    provide: 'environment',
+                    useValue: environment
+                }
+            ]
+        };
+    }
+}
+TtCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TtCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TtCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TtCoreModule, imports: [CommonModule] });
+TtCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TtCoreModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TtCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHQtY29yZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvdHQtY29yZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUF1QixRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQVEvQyxNQUFNLE9BQU8sWUFBWTtJQUNoQixNQUFNLENBQUMsT0FBTyxDQUFDLFdBQW1CO1FBQ3ZDLFlBQVksQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO1FBRXhELE9BQU87WUFDTCxRQUFRLEVBQUUsWUFBWTtZQUN0QixTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsT0FBTyxFQUFFLGFBQWE7b0JBQ3RCLFFBQVEsRUFBRSxXQUFXO2lCQUN0QjthQUNGO1NBQ0YsQ0FBQztJQUNKLENBQUM7OzBHQWJVLFlBQVk7MkdBQVosWUFBWSxZQUhyQixZQUFZOzJHQUdILFlBQVksWUFKZDtZQUNQLFlBQVk7U0FDYjs0RkFFVSxZQUFZO2tCQU54QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUU7d0JBQ1AsWUFBWTtxQkFDYjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZHVsZVdpdGhQcm92aWRlcnMsIE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVHRDb3JlTW9kdWxlIHtcbiAgcHVibGljIHN0YXRpYyBmb3JSb290KGVudmlyb25tZW50OiBvYmplY3QpOiBNb2R1bGVXaXRoUHJvdmlkZXJzPFR0Q29yZU1vZHVsZT4ge1xuICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKCdhcGlfdXJpJywgZW52aXJvbm1lbnRbJ2FwaV91cmknXSk7XG5cbiAgICByZXR1cm4ge1xuICAgICAgbmdNb2R1bGU6IFR0Q29yZU1vZHVsZSxcbiAgICAgIHByb3ZpZGVyczogW1xuICAgICAgICB7XG4gICAgICAgICAgcHJvdmlkZTogJ2Vudmlyb25tZW50JyxcbiAgICAgICAgICB1c2VWYWx1ZTogZW52aXJvbm1lbnRcbiAgICAgICAgfVxuICAgICAgXVxuICAgIH07XG4gIH1cbn1cbiJdfQ==