taxtank-core 0.29.36 → 0.30.0

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

@@ -0,0 +1,204 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { of, ReplaySubject } from 'rxjs';
+import { User, AppEvent, AppEventTypeEnum, PropertySale, } from '../../../models';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import clone from 'lodash/clone';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../auth";
+import * as i3 from "../../event";
+/**
+ * Service to work with user
+ */
+export class UserService {
+    constructor(http, jwtService, eventDispatcherService, sseService, environment) {
+        this.http = http;
+        this.jwtService = jwtService;
+        this.eventDispatcherService = eventDispatcherService;
+        this.sseService = sseService;
+        this.environment = environment;
+        this.cacheSubject = new ReplaySubject(1);
+        this.listenEvents();
+    }
+    /**
+     * never return cache directly to prevent update
+     */
+    getCache() {
+        return clone(this.cache);
+    }
+    listenEvents() {
+        this.listenServiceSubscriptionUpdated();
+        this.listenPropertySale();
+    }
+    get() {
+        if (!this.cache) {
+            this.fetch().subscribe(() => { }, (error) => {
+                // force logout user (clear localStorage) when get current user return error
+                if (error.status === 500) {
+                    this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CURRENT_USER_GET_FAILED, null));
+                }
+            });
+        }
+        return this.cacheSubject.asObservable();
+    }
+    /**
+     * Get current user
+     */
+    fetch() {
+        return this.http.get(`${this.environment.apiV2}/users/current`)
+            .pipe(map((userBase) => {
+            const user = plainToClass(User, userBase);
+            // @TODO Vik remove
+            localStorage.setItem('userId', user.id.toString());
+            localStorage.setItem('financialYear', user.financialYear.toString());
+            this.cache = user;
+            this.cacheSubject.next(this.cache);
+            return user;
+        }));
+    }
+    /**
+     * Register new user
+     */
+    register(data) {
+        return this.http.post(`${this.environment.apiV2}/users/registration`, data);
+    }
+    /**
+     * Update user
+     */
+    update(user) {
+        return this.http.put(`${this.environment.apiV2}/users/${user.id}`, user)
+            .pipe(map((userBase) => {
+            this.cache = plainToClass(User, userBase);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.USER_UPDATED, null));
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+    /**
+     * Change user password
+     */
+    changePassword(currentPassword, newPassword) {
+        return this.http.put(`${this.environment.apiV2}/users/password/change`, { currentPassword, newPassword });
+    }
+    /**
+     * Recovery user password
+     */
+    recoveryPassword(email) {
+        return this.http.put(`${this.environment.apiV2}/users/password/recovery`, { email });
+    }
+    /**
+     * Reset user password
+     */
+    resetPassword(newPassword, resetToken) {
+        return this.http.put(`${this.environment.apiV2}/users/password/reset`, { newPassword, resetToken });
+    }
+    resendConfirmationEmail(email) {
+        return this.http.post(`${this.environment.apiV2}/users/confirmation/resend`, { email });
+    }
+    /**
+     * Confirm registered user
+     */
+    confirm(verificationCode) {
+        return this.http.post(`${this.environment.apiV2}/users/confirmation`, { verificationCode });
+    }
+    /**
+     * Search existing user
+     */
+    search(email) {
+        return this.http.get(`${this.environment.apiV2}/users/search?email=${email}`)
+            .pipe(map((userBase) => {
+            return plainToClass(User, userBase);
+        }));
+    }
+    /**
+     * Finish onboarding process
+     */
+    finishOnboarding(user) {
+        return this.http.put(`${this.environment.apiV2}/users/status`, user)
+            .pipe(map(() => {
+            this.cache = user;
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+    /**
+     * Update user photo
+     */
+    updatePhoto(photo) {
+        return this.http.post(`${this.environment.apiV2}/users/photo?_method=PUT`, photo)
+            .pipe(map((photoUrl) => {
+            this.cache = plainToClass(User, Object.assign(this.cache, { photo: photoUrl }));
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+    switchFinancialYear(year) {
+        return this.http.get(`${this.environment.apiV2}/financial-year/switch`, { params: new HttpParams({ fromString: `financialYear=${year}` }) }).pipe(map(() => {
+            localStorage.setItem('financialYear', year.toString());
+            window.location.reload();
+        }));
+    }
+    /**
+     * clear service cache
+     */
+    resetCache() {
+        this.fetch().subscribe();
+    }
+    /**
+     * Create basiq (if not exist yet) to provide access to basiq api
+     */
+    createBasiq() {
+        // no need to create basiqId if already exist
+        // @TODO Alex (TT-2431): move this check to component or separated method
+        if (this.cache?.basiqId) {
+            return of(this.cache.basiqId);
+        }
+        return this.http.post(`${this.environment.apiV2}/basiq/user`, {})
+            .pipe(map((basiqId) => {
+            this.cache = plainToClass(User, Object.assign(this.cache, { basiqId }));
+            this.cacheSubject.next(this.cache);
+            return basiqId;
+        }));
+    }
+    /**
+     * Update cache when user's service subscription is updated
+     */
+    listenServiceSubscriptionUpdated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED).subscribe(() => this.resetCache());
+    }
+    /**
+     * capital losses updates on property sale
+     */
+    listenPropertySale() {
+        this.eventDispatcherService.on2(...PropertySale.getEventNames('post', 'delete')).subscribe(() => {
+            this.resetCache();
+        });
+    }
+    /**
+     * @TODO remove when the class refactored on RestService
+     * Subscribe to http events and run callback.
+     * CSE - Cleint Sent Events
+     * @param modelClass
+     * @param methods The list of http methods should be listened for
+     * @param callback The function to be called when event triggered
+     */
+    listenCSE(modelClass, methods, callback) {
+        callback = callback.bind(this);
+        methods.forEach((method) => {
+            this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data) => {
+                callback(data);
+            });
+        });
+    }
+}
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserService, deps: [{ token: i1.HttpClient }, { token: i2.JwtService }, { token: i3.EventDispatcherService }, { token: i3.SseService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.JwtService }, { type: i3.EventDispatcherService }, { type: i3.SseService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/user/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse, HttpParams } from '@angular/common/http';\nimport { Observable, of, ReplaySubject } from 'rxjs';\nimport { User as UserBase } from '../../../db/Models/user/user';\nimport {User, AppEvent, AppEventTypeEnum, Depreciation, PropertySale,} from '../../../models';\nimport { EventDispatcherService, SseService } from '../../event';\nimport { JwtService } from '../../auth';\nimport { map } from 'rxjs/operators';\nimport { plainToClass } from 'class-transformer';\nimport { IEventListener } from '../../../interfaces';\nimport clone from 'lodash/clone';\nimport {ObservableModel} from '../../../db/Models';\nimport {HttpMethod} from '../rest';\n\n/**\n * Service to work with user\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class UserService implements IEventListener {\n  cache: User;\n  cacheSubject: ReplaySubject<User> = new ReplaySubject<User>(1);\n\n  constructor(\n    private http: HttpClient,\n    private jwtService: JwtService,\n    private eventDispatcherService: EventDispatcherService,\n    private sseService: SseService,\n    @Inject('environment') private environment: any\n  ) {\n    this.listenEvents();\n  }\n\n  /**\n   * never return cache directly to prevent update\n   */\n  getCache(): User {\n    return clone(this.cache);\n  }\n\n  listenEvents(): void {\n    this.listenServiceSubscriptionUpdated();\n    this.listenPropertySale();\n  }\n\n  get(): Observable<User> {\n    if (!this.cache) {\n      this.fetch().subscribe(() => {}, (error: HttpErrorResponse) => {\n        // force logout user (clear localStorage) when get current user return error\n        if (error.status === 500) {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CURRENT_USER_GET_FAILED, null));\n        }\n    });\n    }\n\n    return this.cacheSubject.asObservable();\n  }\n\n  /**\n   * Get current user\n   */\n  fetch(): Observable<User> {\n    return this.http.get(`${this.environment.apiV2}/users/current`)\n      .pipe(\n        map((userBase: UserBase) => {\n          const user: User = plainToClass(User, userBase);\n\n          // @TODO Vik remove\n          localStorage.setItem('userId', user.id.toString());\n          localStorage.setItem('financialYear', user.financialYear.toString());\n\n          this.cache = user;\n          this.cacheSubject.next(this.cache);\n\n          return user;\n        })\n      );\n  }\n\n  /**\n   * Register new user\n   */\n  register(data: object): Observable<object> {\n    return this.http.post(`${this.environment.apiV2}/users/registration`, data);\n  }\n\n  /**\n   * Update user\n   */\n  update(user: User): Observable<void> {\n    return this.http.put(`${this.environment.apiV2}/users/${user.id}`, user)\n      .pipe(\n        map((userBase: UserBase) => {\n          this.cache = plainToClass(User, userBase);\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.USER_UPDATED, null));\n          this.cacheSubject.next(this.cache);\n        })\n      );\n  }\n\n  /**\n   * Change user password\n   */\n  changePassword(currentPassword: string, newPassword: string): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/users/password/change`, {currentPassword, newPassword});\n  }\n\n  /**\n   * Recovery user password\n   */\n  recoveryPassword(email: string): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/users/password/recovery`, {email});\n  }\n\n  /**\n   * Reset user password\n   */\n  resetPassword(newPassword: string, resetToken: string): Observable<object> {\n    return this.http.put(`${this.environment.apiV2}/users/password/reset`, {newPassword, resetToken});\n  }\n\n  resendConfirmationEmail(email: string): Observable<object> {\n    return this.http.post(`${this.environment.apiV2}/users/confirmation/resend`, {email});\n  }\n\n  /**\n   * Confirm registered user\n   */\n  confirm(verificationCode: string): Observable<object> {\n    return this.http.post(`${this.environment.apiV2}/users/confirmation`, {verificationCode});\n  }\n\n  /**\n   * Search existing user\n   */\n  search(email: string): Observable<User> {\n    return this.http.get(`${this.environment.apiV2}/users/search?email=${email}`)\n      .pipe(\n        map((userBase: UserBase) => {\n          return plainToClass(User, userBase);\n        })\n      );\n  }\n\n  /**\n   * Finish onboarding process\n   */\n  finishOnboarding(user: User): Observable<void> {\n    return this.http.put(`${this.environment.apiV2}/users/status`, user)\n      .pipe(\n        map(() => {\n          this.cache = user;\n          this.cacheSubject.next(this.cache);\n        })\n      );\n  }\n\n  /**\n   * Update user photo\n   */\n  updatePhoto(photo: FormData): Observable<void> {\n    return this.http.post(`${this.environment.apiV2}/users/photo?_method=PUT`, photo)\n      .pipe(\n        map((photoUrl: string) => {\n          this.cache = plainToClass(User, Object.assign(this.cache, {photo: photoUrl}));\n          this.cacheSubject.next(this.cache);\n        })\n      );\n  }\n\n  switchFinancialYear(year: number): Observable<void> {\n    return this.http.get(\n      `${this.environment.apiV2}/financial-year/switch`,\n      {params: new HttpParams({ fromString: `financialYear=${year}` })}\n      ).pipe(\n        map(() => {\n          localStorage.setItem('financialYear', year.toString());\n          window.location.reload();\n        })\n      );\n  }\n\n  /**\n   * clear service cache\n   */\n  resetCache(): void {\n    this.fetch().subscribe();\n  }\n\n  /**\n   * Create basiq (if not exist yet) to provide access to basiq api\n   */\n  createBasiq(): Observable<string> {\n    // no need to create basiqId if already exist\n    // @TODO Alex (TT-2431): move this check to component or separated method\n    if (this.cache?.basiqId) {\n      return of(this.cache.basiqId);\n    }\n\n    return this.http.post(`${this.environment.apiV2}/basiq/user`, {})\n      .pipe(\n        map((basiqId: string) => {\n          this.cache = plainToClass(User, Object.assign(this.cache, {basiqId}));\n          this.cacheSubject.next(this.cache);\n\n          return basiqId;\n        })\n      );\n  }\n\n  /**\n   * Update cache when user's service subscription is updated\n   */\n  private listenServiceSubscriptionUpdated(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED).subscribe(() => this.resetCache());\n  }\n\n  /**\n   * capital losses updates on property sale\n   */\n  private listenPropertySale(): void {\n    this.eventDispatcherService.on2(...PropertySale.getEventNames('post', 'delete')).subscribe(() => {\n      this.resetCache()\n    });\n  }\n\n  /**\n   * @TODO remove when the class refactored on RestService\n   * Subscribe to http events and run callback.\n   * CSE - Cleint Sent Events\n   * @param modelClass\n   * @param methods The list of http methods should be listened for\n   * @param callback The function to be called when event triggered\n   */\n  protected listenCSE(modelClass: typeof ObservableModel, methods: HttpMethod[], callback: Function): void {\n    callback = callback.bind(this);\n\n    methods.forEach((method: HttpMethod) => {\n      this.eventDispatcherService.on2(modelClass.getEventName(method)).subscribe((data: ObservableModel[]) => {\n        callback(data);\n      });\n    })\n  }\n}\n"]}

package/esm2020/lib/services/http/user/users-invite/users-invite.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { RegistrationInvite } from '../../../../models/registration-invite/registration-invite';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with invitations for unregistered users
+ */
+export class UsersInviteService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = RegistrationInvite;
+        this.url = 'users/invite';
+    }
+}
+UsersInviteService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UsersInviteService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+UsersInviteService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UsersInviteService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UsersInviteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcnMtaW52aXRlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC91c2VyL3VzZXJzLWludml0ZS91c2Vycy1pbnZpdGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUxRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw0REFBNEQsQ0FBQzs7QUFFaEc7O0dBRUc7QUFJSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsV0FBdUQ7SUFIL0Y7O1FBSUUsZUFBVSxHQUE4QixrQkFBa0IsQ0FBQztRQUMzRCxRQUFHLEdBQVcsY0FBYyxDQUFDO0tBQzlCOzsrR0FIWSxrQkFBa0I7bUhBQWxCLGtCQUFrQixjQUZqQixNQUFNOzJGQUVQLGtCQUFrQjtrQkFIOUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXN0U2VydmljZSB9IGZyb20gJy4uLy4uL3Jlc3QvcmVzdC1vbGQuc2VydmljZSc7XG5pbXBvcnQgeyBSZWdpc3RyYXRpb25JbnZpdGUgYXMgUmVnaXN0cmF0aW9uSW52aXRlQmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uL2RiL01vZGVscy91c2VyL3JlZ2lzdHJhdGlvbi1pbnZpdGUnO1xuaW1wb3J0IHsgUmVnaXN0cmF0aW9uSW52aXRlIH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzL3JlZ2lzdHJhdGlvbi1pbnZpdGUvcmVnaXN0cmF0aW9uLWludml0ZSc7XG5cbi8qKlxuICogU2VydmljZSB0byB3b3JrIHdpdGggaW52aXRhdGlvbnMgZm9yIHVucmVnaXN0ZXJlZCB1c2Vyc1xuICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBVc2Vyc0ludml0ZVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxSZWdpc3RyYXRpb25JbnZpdGVCYXNlLCBSZWdpc3RyYXRpb25JbnZpdGU+IHtcbiAgbW9kZWxDbGFzczogdHlwZW9mIFJlZ2lzdHJhdGlvbkludml0ZSA9IFJlZ2lzdHJhdGlvbkludml0ZTtcbiAgdXJsOiBzdHJpbmcgPSAndXNlcnMvaW52aXRlJztcbn1cbiJdfQ==

package/esm2020/lib/services/http/vehicle/vehicle-claim-details.service.mjs

@@ -0,0 +1,92 @@
+import { Inject, Injectable } from '@angular/core';
+import { VehicleClaimDetails } from '../../../models';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { AppEvent } from '../../../models/event/app-event';
+import { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event/event-dispatcher.service";
+/**
+ * @TODO TT-1777 Alex: extend from rest service when it refactored
+ */
+export class VehicleClaimDetailsService {
+    constructor(environment, http, eventDispatcherService) {
+        this.environment = environment;
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.cacheSubject = new ReplaySubject(1);
+        this.url = 'vehicle-claim-details';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenBestPeriodChanges();
+    }
+    get() {
+        if (!this.cache) {
+            this.http.get(`${this.environment.apiV2}/${this.url}`)
+                .pipe(map((response) => plainToClass(VehicleClaimDetails, response['hydra:member'][0], { excludePrefixes: ['@'] })))
+                .subscribe((vehicleClaimDetails) => {
+                this.cache = vehicleClaimDetails;
+                this.cacheSubject.next(this.cache);
+            });
+        }
+        return this.cacheSubject.asObservable();
+    }
+    add(details) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, details).pipe(map((newDetails) => {
+            const details = plainToClass(VehicleClaimDetails, newDetails);
+            this.cache = details;
+            this.cacheSubject.next(details);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_CREATED, details));
+            return details;
+        }));
+    }
+    update(details) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${details.id}`, details).pipe(map((updatedDetails) => {
+            const details = plainToClass(VehicleClaimDetails, updatedDetails, { excludePrefixes: ['@'] });
+            this.cache = details;
+            this.cacheSubject.next(details);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED, details));
+            return details;
+        }));
+    }
+    /**
+     * Listen logbook best period updates
+     * @TODO Vik: Best period move this and related logic to backend
+     */
+    listenBestPeriodChanges() {
+        this.eventDispatcherService.on(AppEventTypeEnum.VEHICLE_LOGBOOK_BEST_PERIOD_UPDATED)
+            .subscribe((bestPeriod) => {
+            // Set details as manual if best period stop exist (removed logbook case)
+            if (!bestPeriod) {
+                this.updateToManual();
+            }
+        });
+    }
+    /**
+     * Set vehicle claim details as manual
+     * @TODO Vik: Best period move this and related logic to backend
+     */
+    updateToManual() {
+        // no need to update if cache not exist
+        if (!this.cache) {
+            return;
+        }
+        const vehicleClaimDetails = plainToClass(VehicleClaimDetails, Object.assign({}, this.cache, { isManual: true }));
+        this.update(vehicleClaimDetails).subscribe();
+    }
+}
+VehicleClaimDetailsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimDetailsService, deps: [{ token: 'environment' }, { token: i1.HttpClient }, { token: i2.EventDispatcherService }], target: i0.ɵɵFactoryTarget.Injectable });
+VehicleClaimDetailsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimDetailsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimDetailsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }, { type: i2.EventDispatcherService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vehicle-claim-details.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/vehicle/vehicle-claim-details.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { VehicleClaimDetails as VehicleClaimDetailsBase } from '../../../db/Models/vehicle/vehicle-claim-details';\nimport { LogbookPeriod, VehicleClaimDetails } from '../../../models';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map, take } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { plainToClass } from 'class-transformer';\nimport { EventDispatcherService } from '../../event/event-dispatcher.service';\nimport { AppEvent } from '../../../models/event/app-event';\nimport { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';\nimport { IEventListener } from '../../../interfaces/event-listener.interface';\n\n/**\n * @TODO TT-1777 Alex: extend from rest service when it refactored\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class VehicleClaimDetailsService implements IEventListener {\n  cache: VehicleClaimDetails;\n  cacheSubject: ReplaySubject<VehicleClaimDetails> = new ReplaySubject<VehicleClaimDetails>(1);\n  url: string = 'vehicle-claim-details';\n\n  constructor(\n    @Inject('environment') protected environment: any,\n    private http: HttpClient,\n    private eventDispatcherService: EventDispatcherService\n  ) {\n    this.listenEvents();\n  }\n\n  listenEvents(): void {\n    this.listenBestPeriodChanges();\n  }\n\n  get(): Observable<VehicleClaimDetails> {\n    if (!this.cache) {\n      this.http.get(`${this.environment.apiV2}/${this.url}`)\n        .pipe(\n          map((response: object): VehicleClaimDetails => plainToClass(VehicleClaimDetails, response['hydra:member'][0], {excludePrefixes: ['@']}))\n        )\n        .subscribe((vehicleClaimDetails: VehicleClaimDetails) => {\n          this.cache = vehicleClaimDetails;\n          this.cacheSubject.next(this.cache);\n        })\n    }\n\n    return this.cacheSubject.asObservable();\n  }\n\n  add(details: VehicleClaimDetails): Observable<VehicleClaimDetails> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, details).pipe(\n      map((newDetails: VehicleClaimDetailsBase) => {\n        const details: VehicleClaimDetails = plainToClass(VehicleClaimDetails, newDetails);\n\n        this.cache = details;\n        this.cacheSubject.next(details);\n\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_CREATED, details))\n\n        return details;\n      })\n    )\n  }\n\n  update(details: VehicleClaimDetails): Observable<VehicleClaimDetails> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${details.id}`, details).pipe(\n      map((updatedDetails: VehicleClaimDetailsBase) => {\n        const details: VehicleClaimDetails = plainToClass(VehicleClaimDetails, updatedDetails, {excludePrefixes: ['@']});\n\n        this.cache = details;\n        this.cacheSubject.next(details);\n\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED, details))\n\n        return details;\n      })\n    )\n  }\n\n\n  /**\n   * Listen logbook best period updates\n   * @TODO Vik: Best period move this and related logic to backend\n   */\n  private listenBestPeriodChanges() {\n    this.eventDispatcherService.on(AppEventTypeEnum.VEHICLE_LOGBOOK_BEST_PERIOD_UPDATED)\n      .subscribe((bestPeriod: LogbookPeriod) => {\n        // Set details as manual if best period stop exist (removed logbook case)\n        if (!bestPeriod) {\n          this.updateToManual();\n        }\n      });\n  }\n\n\n  /**\n   * Set vehicle claim details as manual\n   * @TODO Vik: Best period move this and related logic to backend\n   */\n  private updateToManual(): void {\n    // no need to update if cache not exist\n    if (!this.cache) {\n      return;\n    }\n\n    const vehicleClaimDetails: VehicleClaimDetails = plainToClass(\n      VehicleClaimDetails,\n      Object.assign({}, this.cache, {isManual: true})\n    );\n\n    this.update(vehicleClaimDetails).subscribe();\n  }\n}\n"]}

package/esm2020/lib/services/http/vehicle/vehicle-claim.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable } from '@angular/core';
+import { VehicleClaim } from '../../../models';
+import { RestService } from '../rest/rest-old.service';
+import { AppEventTypeEnum } from '../../../models/event/app-event-type.enum';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AppEvent } from '../../../models/event/app-event';
+import { plainToClass } from 'class-transformer';
+import * as i0 from "@angular/core";
+export class VehicleClaimService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = VehicleClaim;
+        this.url = 'vehicle-claims';
+    }
+    listenEvents() {
+        this.listenVehicleClaimDetailsChanges();
+        this.listenBestPeriodChanges();
+    }
+    add(model) {
+        return super.add(model).pipe(map((vehicleClaim) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_CREATED, vehicleClaim));
+            return vehicleClaim;
+        }));
+    }
+    update(model, queryParams = {}) {
+        return super.update(model, queryParams).pipe(map((vehicleClaim) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_UPDATED, vehicleClaim));
+            return vehicleClaim;
+        }));
+    }
+    /**
+     * Details changes may affect vehicle claims:
+     * when details method changed, all claims current values become 0
+     */
+    listenVehicleClaimDetailsChanges() {
+        this.eventDispatcherService.on(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED)
+            .subscribe(() => {
+            this.resetCache();
+        });
+    }
+    /**
+     * Best period changes affect to claims workUsage
+     * @TODO Vik: Best period move this and related logic to backend
+     */
+    listenBestPeriodChanges() {
+        this.eventDispatcherService.on(AppEventTypeEnum.VEHICLE_LOGBOOK_BEST_PERIOD_UPDATED)
+            .subscribe((bestPeriod) => {
+            // no need to update claims when best period become null
+            // (case when logbook removed and user don't have enough logbooks for claim period)
+            if (!bestPeriod) {
+                return;
+            }
+            this.updateWorkUsage(bestPeriod);
+        });
+    }
+    /**
+     * Update workUsage for all vehicle claims if logbook best period changed
+     * @TODO Vik: Best period move this and related logic to backend
+     */
+    updateWorkUsage(bestPeriod) {
+        // no need to update if cache not exist
+        if (!this.cache) {
+            return;
+        }
+        // @TODO Vik (TT-2210): need batch endpoint for this update
+        // @TODO Alex (TT-2210): fix frontend when endpoint ready
+        const batch$ = this.cache.map((claim) => {
+            const claimToUpdate = plainToClass(VehicleClaim, Object.assign({}, claim, { workUsage: bestPeriod?.getWorkUsageByClaim(claim) }));
+            return this.update(claimToUpdate);
+        });
+        combineLatest(batch$).subscribe();
+    }
+}
+VehicleClaimService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+VehicleClaimService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleClaimService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/http/vehicle/vehicle-logbook.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { VehicleLogbook } from '../../../models';
+import { RestService } from '../rest/rest-old.service';
+import * as i0 from "@angular/core";
+/**
+ * Vehicle logbook service. Allows user to add, update or delete vehicle trips
+ */
+export class VehicleLogbookService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'vehicles/logbooks';
+        this.modelClass = VehicleLogbook;
+    }
+}
+VehicleLogbookService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleLogbookService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+VehicleLogbookService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleLogbookService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleLogbookService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVoaWNsZS1sb2dib29rLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC92ZWhpY2xlL3ZlaGljbGUtbG9nYm9vay5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQzs7QUFFdkQ7O0dBRUc7QUFJSCxNQUFNLE9BQU8scUJBQXNCLFNBQVEsV0FBK0M7SUFIMUY7O1FBSUUsUUFBRyxHQUFXLG1CQUFtQixDQUFDO1FBQ2xDLGVBQVUsR0FBMEIsY0FBYyxDQUFDO0tBQ3BEOztrSEFIWSxxQkFBcUI7c0hBQXJCLHFCQUFxQixjQUZwQixNQUFNOzJGQUVQLHFCQUFxQjtrQkFIakMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBWZWhpY2xlTG9nYm9vayBhcyBWZWhpY2xlTG9nYm9va0Jhc2UgfSBmcm9tICcuLi8uLi8uLi9kYi9Nb2RlbHMvdmVoaWNsZS92ZWhpY2xlLWxvZ2Jvb2snO1xuaW1wb3J0IHsgVmVoaWNsZUxvZ2Jvb2sgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi9yZXN0L3Jlc3Qtb2xkLnNlcnZpY2UnO1xuXG4vKipcbiAqIFZlaGljbGUgbG9nYm9vayBzZXJ2aWNlLiBBbGxvd3MgdXNlciB0byBhZGQsIHVwZGF0ZSBvciBkZWxldGUgdmVoaWNsZSB0cmlwc1xuICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBWZWhpY2xlTG9nYm9va1NlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxWZWhpY2xlTG9nYm9va0Jhc2UsIFZlaGljbGVMb2dib29rPiB7XG4gIHVybDogc3RyaW5nID0gJ3ZlaGljbGVzL2xvZ2Jvb2tzJztcbiAgbW9kZWxDbGFzczogdHlwZW9mIFZlaGljbGVMb2dib29rID0gVmVoaWNsZUxvZ2Jvb2s7XG59XG4iXX0=

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

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { Vehicle } from '../../../models';
+import { RestService } from '../rest/rest-old.service';
+import * as i0 from "@angular/core";
+/**
+ * Service that allows to work with WorkTank operations
+ */
+export class VehicleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'vehicles';
+        this.modelClass = Vehicle;
+    }
+}
+VehicleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+VehicleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: VehicleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVoaWNsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvdmVoaWNsZS92ZWhpY2xlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQUV2RDs7R0FFRztBQUlILE1BQU0sT0FBTyxjQUFlLFNBQVEsV0FBaUM7SUFIckU7O1FBSUUsUUFBRyxHQUFXLFVBQVUsQ0FBQztRQUN6QixlQUFVLEdBQW1CLE9BQU8sQ0FBQztLQUN0Qzs7MkdBSFksY0FBYzsrR0FBZCxjQUFjLGNBRmIsTUFBTTsyRkFFUCxjQUFjO2tCQUgxQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFZlaGljbGUgYXMgVmVoaWNsZUJhc2UgfSBmcm9tICcuLi8uLi8uLi9kYi9Nb2RlbHMvdmVoaWNsZS92ZWhpY2xlJztcbmltcG9ydCB7IFZlaGljbGUgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi9yZXN0L3Jlc3Qtb2xkLnNlcnZpY2UnO1xuXG4vKipcbiAqIFNlcnZpY2UgdGhhdCBhbGxvd3MgdG8gd29yayB3aXRoIFdvcmtUYW5rIG9wZXJhdGlvbnNcbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgVmVoaWNsZVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxWZWhpY2xlQmFzZSwgVmVoaWNsZT4ge1xuICB1cmw6IHN0cmluZyA9ICd2ZWhpY2xlcyc7XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBWZWhpY2xlID0gVmVoaWNsZTtcbn1cbiJdfQ==

package/esm2020/lib/services/intercom/intercom.service.mjs

@@ -0,0 +1,41 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with intercom
+ */
+export class IntercomService {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    /**
+     * Init object with user credentials
+     * @param user
+     */
+    initUser(user) {
+        return {
+            app_id: this.environment.intercomAppId,
+            email: user.email,
+            user_hash: user.hashedEmail
+        };
+    }
+    /**
+     * Init connection for provided data
+     * @param user
+     */
+    initConnection(user) {
+        const connectionCredentials = this.initUser(user);
+        window.Intercom('boot', connectionCredentials);
+    }
+}
+IntercomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: IntercomService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+IntercomService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: IntercomService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: IntercomService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/pdf/pdf-from-dom-element/pdf-from-dom-element.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import * as html2pdf from 'html2pdf.js';
+import { FILE_SETTINGS } from './file-settings';
+import merge from 'lodash/merge';
+import * as i0 from "@angular/core";
+/**
+ * @TODO mikhail better typehint
+ *
+ * Service to generate and export PDF file from provided HTML elements
+ * The file is generated using the html2pdf library in order to get a canvas at the output,
+ * in which all the styles that the user sees on the page will be saved
+ */
+export class PdfFromDomElementService {
+    init(elements, fileSettings) {
+        const options = FILE_SETTINGS;
+        if (fileSettings) {
+            merge(options, fileSettings);
+        }
+        // HTML container in which the exported DOM elements will be placed
+        const htmlWrapper = document.createElement('div');
+        elements.forEach((element) => {
+            htmlWrapper.append(element.cloneNode(true));
+        });
+        // Set PDF options, save file and return result as Observable
+        return html2pdf().from(htmlWrapper).set(options);
+    }
+    download(elements, fileSettings) {
+        return from(this.init(elements, fileSettings)
+            .save()
+            .then());
+    }
+    export(elements, filename = FILE_SETTINGS.filename) {
+        return from(this.init(elements)
+            .outputPdf('blob')
+            .then((blob) => new File([blob], filename, { type: 'application/pdf' })));
+    }
+}
+PdfFromDomElementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDomElementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PdfFromDomElementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDomElementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDomElementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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