taxtank-core 0.32.89 → 0.33.1

package/esm2022/src/lib/services/http/firm/client-invite/client-invite.service.mjs

@@ -0,0 +1,100 @@
+import { Inject, Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest';
+import { AppEvent, AppEventTypeEnum, ClientInvite } from '../../../../models';
+import { ClientInviteCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class ClientInviteService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        this.endpointUri = 'clients/invites';
+        this.collectionClass = ClientInviteCollection;
+        this.modelClass = ClientInvite;
+        this.mercureTopic = 'clientInvites';
+        this.listenEvents();
+    }
+    listenEvents() {
+        // @TODO remove when TT-3826 is ready
+        this.listenSSE();
+    }
+    getFirmInvites() {
+        return super.get(`${this.apiUrl}/all`);
+    }
+    /**
+     * Get invite which employee is TaxTank Advisor
+     * @TODO move to collection? but we need to inject enviroment
+     */
+    getTTAdvisor() {
+        return this.get().pipe(map((invites) => invites.findBy('employee.email', this.environment.ttAdvisor)));
+    }
+    /**
+     * Import clients from CSV file
+     */
+    import(file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        // cant use parent method because of different parameters
+        return this.http.post(`${this.apiUrl}/import`, formData).pipe(map((clientInvite) => clientInvite));
+    }
+    /**
+     * Accept client invitation from firm to user
+     */
+    accept(invite) {
+        // cant use parent method because of custom specific handler
+        return this.http.put(`${this.apiUrl}/${invite.id}/accept`, invite).pipe(map(() => {
+            // @TODO remove when TaxReviewService refactored with the new rest and use there listenCSE instead
+            // TaxReviewService is listening client invites acception. With the new rest we are using listenCSE method, but old rest does not have this method.
+            // We need to refactor TaxReviewService with new rest first, then we can listenCSE and remove manual events
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED, null));
+            // this.handleResponse([invite], 'delete');
+        }));
+    }
+    /**
+     * Reject client invitation from firm to user
+     */
+    reject(invite) {
+        return super.put(invite, `${this.apiUrl}/${invite.id}/reject`);
+    }
+    /**
+     * Resend invitation from firm to client
+     */
+    resend(invite) {
+        // cant use parent method because of custom specific handler
+        return this.http.post(`${this.apiUrl}/${invite.id}/resend`, null)
+            .pipe(map((inviteBase) => {
+            const resentInvite = plainToClass(ClientInvite, inviteBase);
+            this.handleResponse([resentInvite], 'put');
+            return resentInvite;
+        }));
+    }
+    /**
+     * Send invitation from client to firm
+     */
+    inviteFirmByUser(invite) {
+        return super.post(invite, `${this.environment.apiV2}/firms/invite`)
+            .pipe(catchError((error) => {
+            if (error.error.email) {
+                this.toastService.error(error.error.email[0]);
+            }
+            else {
+                this.toastService.error(error.error);
+            }
+            return throwError(error);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientInviteService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientInviteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientInviteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-invite.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/tt-core/src/lib/services/http/firm/client-invite/client-invite.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { ClientInvite as ClientInviteBase } from '../../../../db/Models/firm/client-invite';\nimport { catchError, map } from 'rxjs/operators';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest';\nimport { AppEvent, AppEventTypeEnum, ClientInvite } from '../../../../models';\nimport { IEventListener } from '../../../../interfaces';\nimport { ClientInviteCollection } from '../../../../collections';\nimport { HttpErrorResponse } from '@angular/common/http';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ClientInviteService extends RestService<ClientInviteBase, ClientInvite, ClientInviteCollection> implements IEventListener {\n  protected endpointUri = 'clients/invites';\n  collectionClass: typeof ClientInviteCollection = ClientInviteCollection;\n  modelClass: typeof ClientInvite = ClientInvite;\n  mercureTopic = 'clientInvites';\n\n  constructor(@Inject('environment') protected environment: any) {\n    super(environment);\n    this.listenEvents();\n  }\n\n  listenEvents() {\n    // @TODO remove when TT-3826 is ready\n    this.listenSSE();\n  }\n\n  getFirmInvites(): Observable<ClientInviteCollection> {\n    return super.get(`${this.apiUrl}/all`);\n  }\n\n  /**\n   * Get invite which employee is TaxTank Advisor\n   * @TODO move to collection? but we need to inject enviroment\n   */\n  getTTAdvisor(): Observable<ClientInvite> {\n    return this.get().pipe(\n      map((invites: ClientInviteCollection) => invites.findBy('employee.email', this.environment.ttAdvisor))\n    );\n  }\n\n  /**\n   * Import clients from CSV file\n   */\n  import(file: File): Observable<ClientInvite[]> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n\n    // cant use parent method because of different parameters\n    return this.http.post(`${this.apiUrl}/import`, formData).pipe(\n      map((clientInvite: ClientInvite[]) => clientInvite)\n    );\n  }\n\n  /**\n   * Accept client invitation from firm to user\n   */\n  accept(invite: ClientInvite): Observable<void> {\n    // cant use parent method because of custom specific handler\n    return this.http.put(`${this.apiUrl}/${invite.id}/accept`, invite).pipe(\n      map(() => {\n        // @TODO remove when TaxReviewService refactored with the new rest and use there listenCSE instead\n        // TaxReviewService is listening client invites acception. With the new rest we are using listenCSE method, but old rest does not have this method.\n        // We need to refactor TaxReviewService with new rest first, then we can listenCSE and remove manual events\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED, null));\n\n        // this.handleResponse([invite], 'delete');\n      })\n    );\n  }\n\n  /**\n   * Reject client invitation from firm to user\n   */\n  reject(invite: ClientInvite): Observable<ClientInvite> {\n    return super.put(invite, `${this.apiUrl}/${invite.id}/reject`);\n  }\n\n  /**\n   * Resend invitation from firm to client\n   */\n  resend(invite: ClientInvite): Observable<ClientInvite> {\n    // cant use parent method because of custom specific handler\n    return this.http.post(`${this.apiUrl}/${invite.id}/resend`, null)\n      .pipe(\n        map((inviteBase: ClientInviteBase) => {\n          const resentInvite = plainToClass(ClientInvite, inviteBase);\n          this.handleResponse([resentInvite], 'put');\n\n          return resentInvite;\n        }),\n      );\n  }\n\n  /**\n   * Send invitation from client to firm\n   */\n  inviteFirmByUser(invite: ClientInvite): Observable<ClientInvite> {\n    return super.post(invite, `${this.environment.apiV2}/firms/invite`)\n      .pipe(\n        catchError((error: HttpErrorResponse) => {\n          if (error.error.email) {\n            this.toastService.error(error.error.email[0]);\n          } else {\n            this.toastService.error(error.error);\n          }\n\n          return throwError(error);\n        })\n      );\n  }\n}\n"]}

package/esm2022/src/lib/services/http/firm/client-invite/index.mjs

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

package/esm2022/src/lib/services/http/firm/client-movement/client-movement.service.mjs

@@ -0,0 +1,87 @@
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ClientMovementCollection } from '../../../../collections';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest';
+import { ClientMovement } from '../../../../models';
+import { AppEvent } from '../../../../models';
+import { AppEventTypeEnum } from '../../../../models';
+import * as i0 from "@angular/core";
+export class ClientMovementService extends RestService {
+    constructor(environment) {
+        super(environment);
+        this.environment = environment;
+        this.endpointUri = 'client-movements';
+        this.collectionClass = ClientMovementCollection;
+        this.modelClass = ClientMovement;
+        this.disabledMethods = ['postBatch', 'delete', 'deleteBatch'];
+        this.mercureTopic = 'clientMovements';
+        this.listenEvents();
+    }
+    listenEvents() {
+        // client invite accept triggers client movement update
+        this.eventDispatcherService.on([AppEventTypeEnum.CLIENT_INVITE_ACCEPTED]).subscribe(() => {
+            this.refreshCache();
+        });
+        // @TODO remove when TT-3826 is ready
+        this.listenSSE();
+    }
+    getActive() {
+        return this.get().pipe(map((clientMovements) => clientMovements.active));
+    }
+    getTTAdvisor() {
+        return this.getActive()
+            .pipe(map((movements) => movements.findBy('employee.email', this.environment.ttAdvisor) || null));
+    }
+    getActiveByFirmType(type) {
+        return this.getActive().pipe(map((clientMovements) => clientMovements.getByFirmType(type)));
+    }
+    /**
+     * Method is using for transfer client between employees.
+     * On backend we close passed movement and create a new one instead
+     */
+    put(movement) {
+        // extend base 'add' method and pass into it movement without id
+        return super.post(plainToClass(ClientMovement, Object.assign({}, movement, { id: null }))).pipe(map((updatedMovement) => {
+            // remove provided movement from cache
+            // this.cache = this.cache.filter((item: ClientMovement) => item.id !== movement.id);
+            // this.updateCache([updatedMovement], 'post');
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE, [updatedMovement.client]));
+            return updatedMovement;
+        }));
+    }
+    /**
+     * There is no actually direct updating of client movement, but we are using this method for transfer clients between employees
+     */
+    putBatch(clientMovements) {
+        const batch = clientMovements.map((clientMovement) => this.put(clientMovement));
+        return forkJoin(batch);
+    }
+    /**
+     * Reject current firm
+     */
+    close(clientMovement) {
+        // cant use parent method because of custom specific handler
+        return this.http.put(`${this.environment.apiV2}/client-movements/${clientMovement.id}/close`, {})
+            .pipe(map(() => {
+            // @TODO remove when TaxReviewService refactored with the new rest and use there listenCSE instead
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, null));
+            // @TODO why commented?
+            // this.cache = this.cache.filter((movement: ClientMovement): boolean => movement.id !== clientMovement.id);
+            // this.updateCache([clientMovement], 'delete');
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientMovementService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientMovementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientMovementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-movement.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/tt-core/src/lib/services/http/firm/client-movement/client-movement.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { ClientMovement as ClientMovementBase } from '../../../../db/Models/firm/client-movement';\nimport { Observable, forkJoin } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ClientMovementCollection } from '../../../../collections';\nimport { FirmTypeEnum } from '../../../../db/Enums/firm-type.enum';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest';\nimport { ClientMovement } from '../../../../models';\nimport { AppEvent } from '../../../../models';\nimport { AppEventTypeEnum } from '../../../../models';\nimport { IEventListener } from '../../../../interfaces';\nimport { RestMethod } from '../../rest';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ClientMovementService extends RestService<ClientMovementBase, ClientMovement, ClientMovementCollection> implements IEventListener {\n  protected endpointUri = 'client-movements';\n  collectionClass: typeof ClientMovementCollection = ClientMovementCollection;\n  modelClass: typeof ClientMovement = ClientMovement;\n  disabledMethods: RestMethod[] = ['postBatch', 'delete', 'deleteBatch'];\n  mercureTopic = 'clientMovements';\n\n  constructor(@Inject('environment') protected environment: any) {\n    super(environment);\n    this.listenEvents();\n  }\n\n  listenEvents(): void {\n    // client invite accept triggers client movement update\n    this.eventDispatcherService.on([AppEventTypeEnum.CLIENT_INVITE_ACCEPTED]).subscribe((): void => {\n      this.refreshCache();\n    });\n    // @TODO remove when TT-3826 is ready\n    this.listenSSE();\n  }\n\n  getActive(): Observable<ClientMovementCollection> {\n    return this.get().pipe(\n      map((clientMovements: ClientMovementCollection): ClientMovementCollection => clientMovements.active)\n    );\n  }\n\n  getTTAdvisor(): Observable<ClientMovement> {\n    return this.getActive()\n      .pipe(\n        map((movements: ClientMovementCollection) => movements.findBy('employee.email', this.environment.ttAdvisor) || null)\n      );\n  }\n\n  getActiveByFirmType(type: FirmTypeEnum): Observable<ClientMovementCollection> {\n    return this.getActive().pipe(\n      map((clientMovements: ClientMovementCollection): ClientMovementCollection => clientMovements.getByFirmType(type))\n    );\n  }\n\n  /**\n   * Method is using for transfer client between employees.\n   * On backend we close passed movement and create a new one instead\n   */\n  put(movement: ClientMovement): Observable<ClientMovement> {\n    // extend base 'add' method and pass into it movement without id\n    return super.post(plainToClass(ClientMovement, Object.assign({}, movement, { id: null }))).pipe(\n      map((updatedMovement: ClientMovement) => {\n        // remove provided movement from cache\n        // this.cache = this.cache.filter((item: ClientMovement) => item.id !== movement.id);\n        // this.updateCache([updatedMovement], 'post');\n\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE, [updatedMovement.client]));\n\n        return updatedMovement;\n      })\n    );\n  }\n\n  /**\n   * There is no actually direct updating of client movement, but we are using this method for transfer clients between employees\n   */\n  putBatch(clientMovements: ClientMovement[]): Observable<ClientMovement[]> {\n    const batch: Observable<ClientMovement>[] = clientMovements.map((clientMovement: ClientMovement) => this.put(clientMovement));\n\n    return forkJoin(batch);\n  }\n\n  /**\n   * Reject current firm\n   */\n  close(clientMovement: ClientMovement): Observable<void> {\n    // cant use parent method because of custom specific handler\n    return this.http.put(`${this.environment.apiV2}/client-movements/${clientMovement.id}/close`, {})\n      .pipe(\n        map((): void => {\n          // @TODO remove when TaxReviewService refactored with the new rest and use there listenCSE instead\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, null));\n\n          // @TODO why commented?\n          // this.cache = this.cache.filter((movement: ClientMovement): boolean => movement.id !== clientMovement.id);\n          // this.updateCache([clientMovement], 'delete');\n        })\n      );\n  }\n}\n"]}

package/esm2022/src/lib/services/http/firm/client-movement/index.mjs

@@ -0,0 +1,2 @@
+export * from './client-movement.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9maXJtL2NsaWVudC1tb3ZlbWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGllbnQtbW92ZW1lbnQuc2VydmljZSc7XG4iXX0=

package/esm2022/src/lib/services/http/firm/employee/employee-messages.enum.mjs

@@ -0,0 +1,13 @@
+export var EmployeeMessagesEnum;
+(function (EmployeeMessagesEnum) {
+    EmployeeMessagesEnum["ROLE_GRANTED"] = "Manager role granted to ";
+    EmployeeMessagesEnum["ROLE_REMOVED"] = "Manager role took away from ";
+    EmployeeMessagesEnum["CONFIRM_GRANT"] = "Are you sure you want to make this user manager?";
+    EmployeeMessagesEnum["CONFIRM_REMOVE"] = "Are you sure you want to remove manager right from this user?";
+    EmployeeMessagesEnum["CONFIRM_DEACTIVATE"] = "Are you sure you want to deactivate the employee account?";
+    EmployeeMessagesEnum["CONFIRM_ACTIVATE"] = "Are you sure you want to activate the employee account?";
+    EmployeeMessagesEnum["ACTIVATED"] = "Employee account activated";
+    EmployeeMessagesEnum["DEACTIVATED"] = "Employee account deactivated";
+    EmployeeMessagesEnum["DEACTIVATE_ERROR"] = "All clients must be transferred prior to removing an accountant";
+})(EmployeeMessagesEnum || (EmployeeMessagesEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wbG95ZWUtbWVzc2FnZXMuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL2Zpcm0vZW1wbG95ZWUvZW1wbG95ZWUtbWVzc2FnZXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxvQkFVWDtBQVZELFdBQVksb0JBQW9CO0lBQzlCLGlFQUF5QyxDQUFBO0lBQ3pDLHFFQUE2QyxDQUFBO0lBQzdDLDBGQUFrRSxDQUFBO0lBQ2xFLHdHQUFnRixDQUFBO0lBQ2hGLHdHQUFnRixDQUFBO0lBQ2hGLG9HQUE0RSxDQUFBO0lBQzVFLGdFQUF3QyxDQUFBO0lBQ3hDLG9FQUE0QyxDQUFBO0lBQzVDLDRHQUFvRixDQUFBO0FBQ3RGLENBQUMsRUFWVyxvQkFBb0IsS0FBcEIsb0JBQW9CLFFBVS9CIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRW1wbG95ZWVNZXNzYWdlc0VudW0ge1xuICBST0xFX0dSQU5URUQgPSAnTWFuYWdlciByb2xlIGdyYW50ZWQgdG8gJyxcbiAgUk9MRV9SRU1PVkVEID0gJ01hbmFnZXIgcm9sZSB0b29rIGF3YXkgZnJvbSAnLFxuICBDT05GSVJNX0dSQU5UID0gJ0FyZSB5b3Ugc3VyZSB5b3Ugd2FudCB0byBtYWtlIHRoaXMgdXNlciBtYW5hZ2VyPycsXG4gIENPTkZJUk1fUkVNT1ZFID0gJ0FyZSB5b3Ugc3VyZSB5b3Ugd2FudCB0byByZW1vdmUgbWFuYWdlciByaWdodCBmcm9tIHRoaXMgdXNlcj8nLFxuICBDT05GSVJNX0RFQUNUSVZBVEUgPSAnQXJlIHlvdSBzdXJlIHlvdSB3YW50IHRvIGRlYWN0aXZhdGUgdGhlIGVtcGxveWVlIGFjY291bnQ/JyxcbiAgQ09ORklSTV9BQ1RJVkFURSA9ICdBcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gYWN0aXZhdGUgdGhlIGVtcGxveWVlIGFjY291bnQ/JyxcbiAgQUNUSVZBVEVEID0gJ0VtcGxveWVlIGFjY291bnQgYWN0aXZhdGVkJyxcbiAgREVBQ1RJVkFURUQgPSAnRW1wbG95ZWUgYWNjb3VudCBkZWFjdGl2YXRlZCcsXG4gIERFQUNUSVZBVEVfRVJST1IgPSAnQWxsIGNsaWVudHMgbXVzdCBiZSB0cmFuc2ZlcnJlZCBwcmlvciB0byByZW1vdmluZyBhbiBhY2NvdW50YW50J1xufVxuIl19

package/esm2022/src/lib/services/http/firm/employee/employee.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { catchError } from 'rxjs/operators';
+import { User } from '../../../../models';
+import { throwError as observableThrowError } from 'rxjs';
+import { EmployeeMessagesEnum } from './employee-messages.enum';
+import { Collection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import * as i0 from "@angular/core";
+export class EmployeeService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'employees';
+        this.modelClass = User;
+        this.collectionClass = (Collection);
+        this.disabledMethods = ['postBatch', 'putBatch'];
+        this.messages = EmployeeMessagesEnum;
+        this.roles = [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.FIRM_OWNER];
+    }
+    activateEmployee(employee) {
+        return super.put(employee, `${this.environment.apiV2}/${this.endpointUri}/${employee.id}/activate`);
+    }
+    deactivateEmployee(employee) {
+        return super.put(employee, `${this.environment.apiV2}/${this.endpointUri}/${employee.id}/deactivate`)
+            .pipe(catchError((error) => {
+            // Show error when user provided another login (not login he used before)
+            if (error.status === 400) {
+                this.toastService.error(this.messages.DEACTIVATE_ERROR);
+            }
+            return observableThrowError(error);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/firm/employee/index.mjs

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

package/esm2022/src/lib/services/http/firm/employee-invite/employee-invite.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { EmployeeInvite } from '../../../../models/employee/employee-invite';
+import { RestService } from '../../rest';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Collection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class EmployeeInviteService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.endpointUri = 'employees/invites';
+        this.collectionClass = (Collection);
+        this.modelClass = EmployeeInvite;
+        this.roles = [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.FIRM_OWNER];
+    }
+    /**
+     * Import employees for firm from CSV file
+     * @param file
+     */
+    import(file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/${this.endpointUri}/import`, formData)
+            .pipe(map((employeeInvite) => employeeInvite));
+    }
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite) {
+        return this.http.post(`${this.environment.apiV2}/${this.endpointUri}/${invite.id}/resend`, null)
+            .pipe(map((resentInviteBase) => {
+            const updatedInvite = plainToClass(EmployeeInvite, resentInviteBase);
+            this.handleResponse([updatedInvite], 'put');
+            return updatedInvite;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeInviteService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeInviteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: EmployeeInviteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/http/firm/employee-invite/index.mjs

@@ -0,0 +1,2 @@
+export * from './employee-invite.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9maXJtL2VtcGxveWVlLWludml0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lbXBsb3llZS1pbnZpdGUuc2VydmljZSc7XG4iXX0=

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

@@ -0,0 +1,6 @@
+export var FirmMessagesEnum;
+(function (FirmMessagesEnum) {
+    FirmMessagesEnum["LOGO_UPDATED"] = "Firm logo updated";
+    FirmMessagesEnum["DATA_UPDATED"] = "Firm data updated";
+})(FirmMessagesEnum || (FirmMessagesEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlybS1tZXNzYWdlcy5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvZmlybS9maXJtLW1lc3NhZ2VzLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksZ0JBR1g7QUFIRCxXQUFZLGdCQUFnQjtJQUMxQixzREFBa0MsQ0FBQTtJQUNsQyxzREFBa0MsQ0FBQTtBQUNwQyxDQUFDLEVBSFcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQUczQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEZpcm1NZXNzYWdlc0VudW0ge1xuICBMT0dPX1VQREFURUQgPSAnRmlybSBsb2dvIHVwZGF0ZWQnLFxuICBEQVRBX1VQREFURUQgPSAnRmlybSBkYXRhIHVwZGF0ZWQnXG59XG4iXX0=

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

@@ -0,0 +1,63 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { Firm } from '../../../models/firm/firm';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @TODO Alex: think about extend base rest service
+export class FirmService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.firmSubject = new ReplaySubject(1);
+    }
+    /**
+     * Register new firm
+     * @param data: firm and firm owner data to register
+     */
+    register(data) {
+        return this.http.post(`${this.environment.apiV2}/firms/registration`, data)
+            .pipe(map((firm) => plainToClass(Firm, firm)));
+    }
+    get() {
+        if (!this.firm) {
+            this.http.get(`${this.environment.apiV2}/firms/current`)
+                .pipe(map((firm) => plainToClass(Firm, firm)))
+                .subscribe((firm) => {
+                this.firm = firm;
+                this.firmSubject.next(this.firm);
+            });
+        }
+        return this.firmSubject.asObservable();
+    }
+    update(firm) {
+        return this.http.put(`${this.environment.apiV2}/firms/current`, firm)
+            .pipe(map((updatedItem) => {
+            const updatedInstance = plainToClass(Firm, updatedItem);
+            this.firmSubject.next(updatedInstance);
+        }));
+    }
+    /**
+     * get list of all registered firms
+     */
+    getAll() {
+        return this.http.get(`${this.environment.apiV2}/firms`)
+            .pipe(map((response) => response.map((firmBase) => plainToClass(Firm, firmBase))));
+    }
+    getByType(type) {
+        return this.getAll().pipe(map((firms) => firms.filter((firm) => firm.type === type)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: FirmService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: FirmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: FirmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+export * from './client-invite';
+export * from './client-movement';
+export * from './employee';
+export * from './employee-invite';
+export * from './portfolio-report';
+export * from './firm-messages.enum';
+export * from './firm.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9maXJtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGllbnQtaW52aXRlJztcbmV4cG9ydCAqIGZyb20gJy4vY2xpZW50LW1vdmVtZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZW1wbG95ZWUnO1xuZXhwb3J0ICogZnJvbSAnLi9lbXBsb3llZS1pbnZpdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3J0Zm9saW8tcmVwb3J0JztcbmV4cG9ydCAqIGZyb20gJy4vZmlybS1tZXNzYWdlcy5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vZmlybS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/src/lib/services/http/firm/portfolio-report/client-portfolio-report.service.mjs

@@ -0,0 +1,37 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { ClientPortfolioReport } from '../../../../models/client/client-portfolio-report';
+import { ClientPortfolioReportCollection } from '../../../../collections/client-portfolio-report.collection';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @Todo refactor with BaseRest service
+/**
+ * Service to work with employee clients tax summary data
+ */
+export class ClientPortfolioReportService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.url = 'portfolio-reports';
+    }
+    get() {
+        return this.http.get(`${this.environment.apiV2}/${this.url}`)
+            .pipe(map((response) => {
+            const clientReports = response.map((item) => plainToClass(ClientPortfolioReport, item));
+            return new ClientPortfolioReportCollection(clientReports);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientPortfolioReportService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientPortfolioReportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ClientPortfolioReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LXBvcnRmb2xpby1yZXBvcnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL2Zpcm0vcG9ydGZvbGlvLXJlcG9ydC9jbGllbnQtcG9ydGZvbGlvLXJlcG9ydC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRW5ELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVyQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sbURBQW1ELENBQUM7QUFDMUYsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sNERBQTRELENBQUM7OztBQUU3Ryx1Q0FBdUM7QUFDdkM7O0dBRUc7QUFJSCxNQUFNLE9BQU8sNEJBQTRCO0lBR3ZDLFlBQW9CLElBQWdCLEVBQWlDLFdBQWdCO1FBQWpFLFNBQUksR0FBSixJQUFJLENBQVk7UUFBaUMsZ0JBQVcsR0FBWCxXQUFXLENBQUs7UUFGckYsUUFBRyxHQUFHLG1CQUFtQixDQUFDO0lBRThELENBQUM7SUFFekYsR0FBRztRQUNELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7YUFDMUQsSUFBSSxDQUNILEdBQUcsQ0FBQyxDQUFDLFFBQWtCLEVBQUUsRUFBRTtZQUN6QixNQUFNLGFBQWEsR0FBNEIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQVksRUFBRSxFQUFFLENBQUMsWUFBWSxDQUFDLHFCQUFxQixFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDekgsT0FBTyxJQUFJLCtCQUErQixDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQzVELENBQUMsQ0FBQyxDQUNILENBQUM7SUFDTixDQUFDOzhHQWJVLDRCQUE0Qiw0Q0FHTyxhQUFhO2tIQUhoRCw0QkFBNEIsY0FGM0IsTUFBTTs7MkZBRVAsNEJBQTRCO2tCQUh4QyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQjs7MEJBSXdDLE1BQU07MkJBQUMsYUFBYSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IHBsYWluVG9DbGFzcyB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJztcbmltcG9ydCB7IENsaWVudFBvcnRmb2xpb1JlcG9ydCB9IGZyb20gJy4uLy4uLy4uLy4uL21vZGVscy9jbGllbnQvY2xpZW50LXBvcnRmb2xpby1yZXBvcnQnO1xuaW1wb3J0IHsgQ2xpZW50UG9ydGZvbGlvUmVwb3J0Q29sbGVjdGlvbiB9IGZyb20gJy4uLy4uLy4uLy4uL2NvbGxlY3Rpb25zL2NsaWVudC1wb3J0Zm9saW8tcmVwb3J0LmNvbGxlY3Rpb24nO1xuXG4vLyBAVG9kbyByZWZhY3RvciB3aXRoIEJhc2VSZXN0IHNlcnZpY2Vcbi8qKlxuICogU2VydmljZSB0byB3b3JrIHdpdGggZW1wbG95ZWUgY2xpZW50cyB0YXggc3VtbWFyeSBkYXRhXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIENsaWVudFBvcnRmb2xpb1JlcG9ydFNlcnZpY2Uge1xuICB1cmwgPSAncG9ydGZvbGlvLXJlcG9ydHMnO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgaHR0cDogSHR0cENsaWVudCwgQEluamVjdCgnZW52aXJvbm1lbnQnKSBwcml2YXRlIGVudmlyb25tZW50OiBhbnkpIHt9XG5cbiAgZ2V0KCk6IE9ic2VydmFibGU8Q2xpZW50UG9ydGZvbGlvUmVwb3J0Q29sbGVjdGlvbj4ge1xuICAgIHJldHVybiB0aGlzLmh0dHAuZ2V0KGAke3RoaXMuZW52aXJvbm1lbnQuYXBpVjJ9LyR7dGhpcy51cmx9YClcbiAgICAgIC5waXBlKFxuICAgICAgICBtYXAoKHJlc3BvbnNlOiBvYmplY3RbXSkgPT4ge1xuICAgICAgICAgIGNvbnN0IGNsaWVudFJlcG9ydHM6IENsaWVudFBvcnRmb2xpb1JlcG9ydFtdID0gcmVzcG9uc2UubWFwKChpdGVtOiBvYmplY3QpID0+IHBsYWluVG9DbGFzcyhDbGllbnRQb3J0Zm9saW9SZXBvcnQsIGl0ZW0pKTtcbiAgICAgICAgICByZXR1cm4gbmV3IENsaWVudFBvcnRmb2xpb1JlcG9ydENvbGxlY3Rpb24oY2xpZW50UmVwb3J0cyk7XG4gICAgICAgIH0pXG4gICAgICApO1xuICB9XG59XG4iXX0=

package/esm2022/src/lib/services/http/firm/portfolio-report/index.mjs

@@ -0,0 +1,2 @@
+export * from './client-portfolio-report.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9maXJtL3BvcnRmb2xpby1yZXBvcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2xpZW50LXBvcnRmb2xpby1yZXBvcnQuc2VydmljZSc7XG4iXX0=

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

@@ -0,0 +1,77 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../toast";
+import * as i3 from "taxtank-core/common";
+import * as i4 from "@angular/router";
+/**
+ * Google instance
+ * https://developers.google.com/identity/oauth2/web/guides/overview
+ * https://developers.google.com/identity/gsi/web/guides/overview
+ */
+export class GoogleService {
+    constructor(http, toastService, jwtService, router, environment) {
+        this.http = http;
+        this.toastService = toastService;
+        this.jwtService = jwtService;
+        this.router = router;
+        this.environment = environment;
+        this.isLoggedInSubject = new BehaviorSubject(!this.jwtService.isTokenExpired());
+        this.isGoogleEnabled = !!this.environment['googleClientId'];
+        // depending on the level of access
+        this.googleScope = 'https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email';
+    }
+    /**
+     * prompt for user consent and obtain an access token to work with user data
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    // prompt for user consent and obtain an access token to work with user data
+    login() {
+        return google.accounts.oauth2.initTokenClient({
+            client_id: this.environment['googleClientId'],
+            scope: this.googleScope,
+            callback: (response) => {
+                this.setAuth(response.access_token);
+            },
+        }).requestAccessToken();
+    }
+    /**
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token:
+     * Choose their account;
+     * sign-in to the Google Account if not already signed-in;
+     * grant consent for your web app to access each requested scope.
+     */
+    setAuth(accessToken, redirectUrl = '/client') {
+        this.http.post(`${this.environment.apiV2}/users/authentication/google`, { accessToken })
+            .subscribe((response) => {
+            this.jwtService.saveTokens(response);
+            this.isLoggedInSubject.next(true);
+            this.router.navigate([redirectUrl]);
+        }, (error) => {
+            this.toastService.error(error.error.violations[0].message);
+            this.logout();
+        });
+    }
+    /**
+     * When the user signs out of your website, you need to call the method
+     * google.accounts.id.disableAutoSelect to record the status in cookies.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    logout() {
+        google.accounts.id.disableAutoSelect();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: GoogleService, deps: [{ token: i1.HttpClient }, { token: i2.ToastService }, { token: i3.JwtService }, { token: i4.Router }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: GoogleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: GoogleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ToastService }, { type: i3.JwtService }, { type: i4.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export * from './google.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9nb29nbGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ29vZ2xlLnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/http/holding/holding-import/holding-import-messages.enum.mjs

@@ -0,0 +1,9 @@
+export var HoldingImportMessagesEnum;
+(function (HoldingImportMessagesEnum) {
+    HoldingImportMessagesEnum["CREATED"] = "Import created successfully";
+    HoldingImportMessagesEnum["UPDATED"] = "Import updated successfully";
+    HoldingImportMessagesEnum["CONFIRM_DELETE"] = "Are you sure you want to delete this import?";
+    HoldingImportMessagesEnum["DELETED"] = "Import deleted successfully";
+    HoldingImportMessagesEnum["DELETE_ERROR"] = "Import including sold assets can not be deleted";
+})(HoldingImportMessagesEnum || (HoldingImportMessagesEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9sZGluZy1pbXBvcnQtbWVzc2FnZXMuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL2hvbGRpbmcvaG9sZGluZy1pbXBvcnQvaG9sZGluZy1pbXBvcnQtbWVzc2FnZXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSx5QkFNWDtBQU5ELFdBQVkseUJBQXlCO0lBQ25DLG9FQUF1QyxDQUFBO0lBQ3ZDLG9FQUF1QyxDQUFBO0lBQ3ZDLDRGQUErRCxDQUFBO0lBQy9ELG9FQUF1QyxDQUFBO0lBQ3ZDLDZGQUFnRSxDQUFBO0FBQ2xFLENBQUMsRUFOVyx5QkFBeUIsS0FBekIseUJBQXlCLFFBTXBDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gSG9sZGluZ0ltcG9ydE1lc3NhZ2VzRW51bSB7XG4gIENSRUFURUQgPSAnSW1wb3J0IGNyZWF0ZWQgc3VjY2Vzc2Z1bGx5JyxcbiAgVVBEQVRFRCA9ICdJbXBvcnQgdXBkYXRlZCBzdWNjZXNzZnVsbHknLFxuICBDT05GSVJNX0RFTEVURSA9ICdBcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gZGVsZXRlIHRoaXMgaW1wb3J0PycsXG4gIERFTEVURUQgPSAnSW1wb3J0IGRlbGV0ZWQgc3VjY2Vzc2Z1bGx5JyxcbiAgREVMRVRFX0VSUk9SID0gJ0ltcG9ydCBpbmNsdWRpbmcgc29sZCBhc3NldHMgY2FuIG5vdCBiZSBkZWxldGVkJ1xufVxuIl19