taxtank-core 0.8.3 → 0.8.7

package/esm2015/lib/services/http/document/document-folder/document-folder.service.js

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { Document } from '../../../../models/document/document';
+import { replace } from '../../../../functions/array';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest.service';
+import { DocumentFolder } from '../../../../models/document/document-folder';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../event/event-dispatcher.service";
+/**
+ * Service to handle document-folders and depending documents logic
+ */
+export class DocumentFolderService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'folders';
+        this.modelClass = DocumentFolder;
+    }
+    /**
+     * Add new document to the folder
+     * @param file to be uploaded to the folder
+     * @param folder for document
+     */
+    addDocument(file, folder) {
+        // create formData object with provided file
+        const formDataDocument = new FormData();
+        formDataDocument.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/folders/${folder.id}/documents`, formDataDocument).pipe(map((response) => {
+            const updatedFolder = Object.assign(plainToClass(DocumentFolder, {}), folder);
+            updatedFolder.documents.push(plainToClass(Document, response));
+            replace(this.cache, plainToClass(DocumentFolder, updatedFolder));
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+    /**
+     * Edit folder document by moving it from one folder to another
+     * @param editedDocument
+     * @param selectedFolder to move the document to
+     * @param oldFolderId: id of old folder from which need to remove the document
+     */
+    updateDocument(editedDocument, selectedFolder, oldFolderId) {
+        return this.http.put(`${this.environment.apiV2}/folders/${selectedFolder.id}/documents/${editedDocument.id}`, editedDocument).pipe(map((response) => {
+            const oldFolder = this.cache.find((folder) => folder.id === oldFolderId);
+            // Remove document from old folder
+            oldFolder.documents = oldFolder.documents.filter((deletedDocument) => deletedDocument.id !== response.id);
+            // update old folder and replace it in cache
+            response.folder = plainToClass(DocumentFolder, { id: selectedFolder.id, name: selectedFolder.name });
+            replace(this.cache, plainToClass(DocumentFolder, oldFolder));
+            // update new document folder and replace it in cache
+            selectedFolder.documents.push(plainToClass(Document, response));
+            replace(this.cache, plainToClass(DocumentFolder, selectedFolder));
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+    /**
+     * Delete document from folder
+     * @param document to remove
+     * @param folder from which document should be removed
+     */
+    deleteDocument(document, folder) {
+        return this.http.delete(`${this.environment.apiV2}/folders/${folder.id}/documents/${document.id}`).pipe(map(() => {
+            folder.documents = folder.documents
+                .filter((deletedDocument) => deletedDocument.id !== document.id);
+            replace(this.cache, plainToClass(DocumentFolder, folder));
+            this.cacheSubject.next(this.cache);
+        }));
+    }
+}
+DocumentFolderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: DocumentFolderService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentFolderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: DocumentFolderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: DocumentFolderService, 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,{"version":3,"file":"document-folder.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/document/document-folder/document-folder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { DocumentFolder as DocumentFolderBase } from '../../../../db/Models/document-folder';\nimport { HttpClient } from '@angular/common/http';\nimport { Document as DocumentBase } from '../../../../db/Models/document';\nimport { Document } from '../../../../models/document/document';\nimport { replace } from '../../../../functions/array';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest/rest.service';\nimport { DocumentFolder } from '../../../../models/document/document-folder';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\n\n/**\n * Service to handle document-folders and depending documents logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class DocumentFolderService extends RestService<DocumentFolderBase, DocumentFolder> {\n  url: string = 'folders';\n  modelClass: typeof DocumentFolder = DocumentFolder;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n  }\n\n  /**\n   * Add new document to the folder\n   * @param file to be uploaded to the folder\n   * @param folder for document\n   */\n  addDocument(file: File, folder: DocumentFolder): Observable<void> {\n    // create formData object with provided file\n    const formDataDocument: FormData = new FormData();\n    formDataDocument.append('file', file);\n\n    return this.http.post(`${this.environment.apiV2}/folders/${folder.id}/documents`, formDataDocument).pipe(\n      map((response: DocumentBase) => {\n        const updatedFolder: DocumentFolder = Object.assign(plainToClass(DocumentFolder, {}), folder);\n        updatedFolder.documents.push(plainToClass(Document, response));\n\n        replace(this.cache, plainToClass(DocumentFolder, updatedFolder));\n        this.cacheSubject.next(this.cache);\n      })\n    );\n  }\n\n  /**\n   * Edit folder document by moving it from one folder to another\n   * @param editedDocument\n   * @param selectedFolder to move the document to\n   * @param oldFolderId: id of old folder from which need to remove the document\n   */\n  updateDocument(editedDocument: Document, selectedFolder: DocumentFolder, oldFolderId: number): Observable<void> {\n    return this.http.put(`${this.environment.apiV2}/folders/${selectedFolder.id}/documents/${editedDocument.id}`, editedDocument).pipe(\n      map((response: DocumentBase) => {\n        const oldFolder: DocumentFolder = this.cache.find((folder: DocumentFolder) => folder.id === oldFolderId);\n        // Remove document from old folder\n        oldFolder.documents = oldFolder.documents.filter((deletedDocument: Document) => deletedDocument.id !== response.id);\n\n        // update old folder and replace it in cache\n        response.folder = plainToClass(DocumentFolder, {id: selectedFolder.id, name: selectedFolder.name});\n        replace(this.cache, plainToClass(DocumentFolder, oldFolder));\n\n        // update new document folder and replace it in cache\n        selectedFolder.documents.push(plainToClass(Document, response));\n        replace(this.cache, plainToClass(DocumentFolder, selectedFolder));\n\n        this.cacheSubject.next(this.cache);\n      })\n    );\n  }\n\n  /**\n   * Delete document from folder\n   * @param document to remove\n   * @param folder from which document should be removed\n   */\n  deleteDocument(document: Document, folder: DocumentFolder): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/folders/${folder.id}/documents/${document.id}`).pipe(\n      map(() => {\n        folder.documents = folder.documents\n          .filter((deletedDocument: Document) => deletedDocument.id !== document.id);\n        replace(this.cache, plainToClass(DocumentFolder, folder));\n\n        this.cacheSubject.next(this.cache);\n      })\n    );\n  }\n}\n"]}

package/esm2015/lib/services/{client → http/firm/client-invite}/client-invite.service.js

@@ -1,14 +1,14 @@
 import { Injectable } from '@angular/core';
 import { map } from 'rxjs/operators';
-import { replace } from '../../functions/array';
+import { replace } from '../../../../functions/array';
 import _ from 'lodash';
 import { plainToClass } from 'class-transformer';
-import { BaseRestService } from '../base-rest.service';
-import { ClientInvite } from '../../models/client/client-invite';
-import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
-import { AppEvent } from '../../models/event/app-event';
+import { RestService } from '../../rest/rest.service';
+import { ClientInvite } from '../../../../models/client/client-invite';
+import { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';
+import { AppEvent } from '../../../../models/event/app-event';
 import * as i0 from "@angular/core";
-export class ClientInviteService extends BaseRestService {
+export class ClientInviteService extends RestService {
     constructor() {
         super(...arguments);
         this.url = 'clients/invites';
@@ -99,4 +99,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImpo
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-invite.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/client/client-invite.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { ClientInvite as ClientInviteBase } from '../../db/Models/client-invite';\nimport { map } from 'rxjs/operators';\nimport { replace } from '../../functions/array';\nimport _ from 'lodash';\nimport { plainToClass } from 'class-transformer';\nimport { BaseRestService } from '../base-rest.service';\nimport { ClientInvite } from '../../models/client/client-invite';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\nimport { AppEvent } from '../../models/event/app-event';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ClientInviteService extends BaseRestService<ClientInviteBase, ClientInvite> {\n  url: string = 'clients/invites';\n  modelClass: typeof ClientInvite = ClientInvite;\n\n  /**\n   * Import employees for firm from CSV file\n   * @param file\n   */\n  import(file: File): Observable<ClientInvite[]> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n\n    return this.http.post(`${this.environment.apiV2}/${this.url}/import`, formData)\n      .pipe(\n        map((clientInvite: ClientInvite[]) => {\n          return clientInvite;\n        })\n      );\n  }\n\n  /**\n   * Accept client invitation from firm to user\n   * @param invite\n   */\n  accept(invite: ClientInvite): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/accept`, null)\n      .pipe(\n        map((): void => {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED, invite));\n          // set cache without accepted invite\n          this.cache = this.cache.filter((clientInvite: ClientInvite) => invite.id !== clientInvite.id);\n          this.updateCache();\n        })\n      );\n  }\n\n  /**\n   * Reject client invitation from firm to user\n   * @param invite\n   */\n  reject(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/reject`, null)\n      .pipe(\n        map((rejectedInvite: ClientInviteBase): ClientInvite => {\n          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          replace(tempCache, plainToClass(ClientInvite, updatedInvite));\n          this.cache = tempCache;\n          this.updateCache();\n          return updatedInvite;\n        })\n      );\n  }\n\n  /**\n   * Resend invitation from firm to client\n   * @param invite\n   */\n  resend(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)\n      .pipe(\n        map((rejectedInvite: ClientInviteBase): ClientInvite => {\n          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          replace(tempCache, plainToClass(ClientInvite, updatedInvite));\n          this.cache = tempCache;\n          this.updateCache();\n          return updatedInvite;\n        })\n      );\n  }\n\n  /**\n   * Send invitation from client to firm\n   * @param invite\n   */\n  inviteFirmByUser(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/firms/invite`, invite)\n      .pipe(\n        map((inviteBase: ClientInviteBase): ClientInvite => {\n          const newInvite: ClientInvite = plainToClass(ClientInvite, inviteBase);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          tempCache.push(newInvite);\n          this.cache = tempCache;\n          this.updateCache();\n          return newInvite;\n        })\n      );\n  }\n}\n"]}
+//# 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 { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { ClientInvite as ClientInviteBase } from '../../../../db/Models/client-invite';\nimport { map } from 'rxjs/operators';\nimport { replace } from '../../../../functions/array';\nimport _ from 'lodash';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest/rest.service';\nimport { ClientInvite } from '../../../../models/client/client-invite';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\nimport { AppEvent } from '../../../../models/event/app-event';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ClientInviteService extends RestService<ClientInviteBase, ClientInvite> {\n  url: string = 'clients/invites';\n  modelClass: typeof ClientInvite = ClientInvite;\n\n  /**\n   * Import employees for firm from CSV file\n   * @param file\n   */\n  import(file: File): Observable<ClientInvite[]> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n\n    return this.http.post(`${this.environment.apiV2}/${this.url}/import`, formData)\n      .pipe(\n        map((clientInvite: ClientInvite[]) => {\n          return clientInvite;\n        })\n      );\n  }\n\n  /**\n   * Accept client invitation from firm to user\n   * @param invite\n   */\n  accept(invite: ClientInvite): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/accept`, null)\n      .pipe(\n        map((): void => {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED, invite));\n          // set cache without accepted invite\n          this.cache = this.cache.filter((clientInvite: ClientInvite) => invite.id !== clientInvite.id);\n          this.updateCache();\n        })\n      );\n  }\n\n  /**\n   * Reject client invitation from firm to user\n   * @param invite\n   */\n  reject(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/reject`, null)\n      .pipe(\n        map((rejectedInvite: ClientInviteBase): ClientInvite => {\n          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          replace(tempCache, plainToClass(ClientInvite, updatedInvite));\n          this.cache = tempCache;\n          this.updateCache();\n          return updatedInvite;\n        })\n      );\n  }\n\n  /**\n   * Resend invitation from firm to client\n   * @param invite\n   */\n  resend(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)\n      .pipe(\n        map((rejectedInvite: ClientInviteBase): ClientInvite => {\n          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          replace(tempCache, plainToClass(ClientInvite, updatedInvite));\n          this.cache = tempCache;\n          this.updateCache();\n          return updatedInvite;\n        })\n      );\n  }\n\n  /**\n   * Send invitation from client to firm\n   * @param invite\n   */\n  inviteFirmByUser(invite: ClientInvite): Observable<ClientInvite> {\n    return this.http.post(`${this.environment.apiV2}/firms/invite`, invite)\n      .pipe(\n        map((inviteBase: ClientInviteBase): ClientInvite => {\n          const newInvite: ClientInvite = plainToClass(ClientInvite, inviteBase);\n          // avoid cache changes\n          // @TODO make cache readonly\n          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);\n          tempCache.push(newInvite);\n          this.cache = tempCache;\n          this.updateCache();\n          return newInvite;\n        })\n      );\n  }\n}\n"]}

package/esm2015/lib/services/http/firm/client-movement/client-movement.service.js

@@ -0,0 +1,98 @@
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ClientMovementCollection } from '../../../../collections/client-movement.collection';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest.service';
+import { ClientMovement } from '../../../../models/client/client-movement';
+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";
+export class ClientMovementService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = ClientMovement;
+        this.url = 'client-movements';
+        this.isHydra = true;
+        this.listenEvents();
+    }
+    /**
+     * @TODO BaseRestService should return collection
+     */
+    getAll() {
+        return this.get().pipe(map((clientMovements) => {
+            return new ClientMovementCollection(clientMovements);
+        }));
+    }
+    getActive() {
+        return this.getAll().pipe(map((clientMovements) => {
+            return clientMovements.active;
+        }));
+    }
+    getActiveByFirmType(type) {
+        return this.getActive().pipe(map((clientMovements) => {
+            return clientMovements.getByFirmType(type);
+        }));
+    }
+    update(movement) {
+        // extend base 'add' method and pass into it movement without id
+        return super.add(plainToClass(ClientMovement, Object.assign({}, movement, { id: null }))).pipe(map((updatedMovement) => {
+            // remove provided movement from cache
+            this.cache = this.cache.filter((item) => item.id !== movement.id);
+            this.updateCache();
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE, [updatedMovement.client]));
+            return updatedMovement;
+        }));
+    }
+    updateBatch(clientMovements) {
+        const batch = clientMovements.map((clientMovement) => this.update(clientMovement));
+        return forkJoin(batch);
+    }
+    /**
+     * Reject current firm
+     */
+    close(clientMovement) {
+        clientMovement.dateTo = new Date();
+        return this.http.put(`${this.environment.apiV2}/client-movements/${clientMovement.id}/close`, clientMovement)
+            .pipe(map(() => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, null));
+            this.cache = this.cache.filter((movement) => movement.id !== clientMovement.id);
+            this.updateCache();
+        }));
+    }
+    /**
+     * Listen Event Dispatcher service
+     */
+    listenEvents() {
+        this.listenClientInvites();
+    }
+    /**
+     * Listen to EventDispatcherService event related to clients invitations
+     */
+    listenClientInvites() {
+        this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED)
+            .subscribe(() => {
+            this.fetch().subscribe((clientMovements) => {
+                this.cache = clientMovements;
+                this.updateCache();
+            });
+        });
+    }
+}
+ClientMovementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientMovementService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+ClientMovementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientMovementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientMovementService, 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,{"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/client-movement';\nimport { forkJoin, Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ClientMovementCollection } from '../../../../collections/client-movement.collection';\nimport { FirmTypeEnum } from '../../../../db/Enums/firm-type.enum';\nimport { HttpClient } from '@angular/common/http';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest/rest.service';\nimport { ClientMovement } from '../../../../models/client/client-movement';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { AppEvent } from '../../../../models/event/app-event';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ClientMovementService extends RestService<ClientMovementBase, ClientMovement> {\n  modelClass: typeof ClientMovement = ClientMovement;\n  url: string = 'client-movements';\n  isHydra: boolean = true;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * @TODO BaseRestService should return collection\n   */\n  getAll(): Observable<ClientMovementCollection> {\n    return this.get().pipe(\n      map((clientMovements: ClientMovement[]) => {\n        return new ClientMovementCollection(clientMovements);\n      })\n    );\n  }\n\n  getActive(): Observable<ClientMovementCollection> {\n    return this.getAll().pipe(\n      map((clientMovements: ClientMovementCollection): ClientMovementCollection => {\n        return clientMovements.active;\n      })\n    );\n  }\n\n  getActiveByFirmType(type: FirmTypeEnum): Observable<ClientMovementCollection> {\n    return this.getActive().pipe(\n      map((clientMovements: ClientMovementCollection): ClientMovementCollection => {\n        return clientMovements.getByFirmType(type);\n      })\n    );\n  }\n\n  update(movement: ClientMovement): Observable<ClientMovement> {\n    // extend base 'add' method and pass into it movement without id\n    return super.add(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();\n\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE, [updatedMovement.client]));\n\n        return updatedMovement;\n      })\n    );\n  }\n\n  updateBatch(clientMovements: ClientMovement[]): Observable<ClientMovement[]> {\n    const batch: Observable<ClientMovement>[] = clientMovements.map((clientMovement: ClientMovement) => this.update(clientMovement));\n    return forkJoin(batch);\n  }\n\n  /**\n   * Reject current firm\n   */\n  close(clientMovement: ClientMovement): Observable<void> {\n    clientMovement.dateTo = new Date();\n    return this.http.put(`${this.environment.apiV2}/client-movements/${clientMovement.id}/close`, clientMovement)\n      .pipe(\n        map((): void => {\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, null));\n          this.cache = this.cache.filter((movement: ClientMovement): boolean => movement.id !== clientMovement.id);\n          this.updateCache();\n        })\n      );\n  }\n\n  /**\n   * Listen Event Dispatcher service\n   */\n  listenEvents(): void {\n    this.listenClientInvites();\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to clients invitations\n   */\n  private listenClientInvites(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED)\n      .subscribe((): void => {\n        this.fetch().subscribe((clientMovements: ClientMovement[]) => {\n          this.cache = clientMovements;\n          this.updateCache();\n        });\n      });\n  }\n}\n"]}

package/esm2015/lib/services/http/firm/employee/employee.service.js

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest.service';
+import { map } from 'rxjs/operators';
+import { replace } from '../../../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { User } from '../../../../models/user/user';
+import * as i0 from "@angular/core";
+export class EmployeeService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'employees';
+        this.modelClass = User;
+    }
+    /**
+     * Grant/Remove Manager role to employee
+     * @param employee
+     */
+    toggleManagerRole(employee) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${employee.id}`, {})
+            .pipe(map((updatedEmployeeBase) => {
+            const tempCache = this.cache;
+            const updatedEmployee = plainToClass(User, updatedEmployeeBase);
+            replace(tempCache, updatedEmployee);
+            this.cache = _.cloneDeep(tempCache);
+            this.updateCache();
+            return updatedEmployee;
+        }));
+    }
+}
+EmployeeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+EmployeeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/firm/employee-invite/employee-invite.service.js

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace } from '../../../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { EmployeeInvite } from '../../../../models/employee/employee-invite';
+import { RestService } from '../../rest/rest.service';
+import * as i0 from "@angular/core";
+export class EmployeeInviteService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'employees/invites';
+        this.modelClass = EmployeeInvite;
+    }
+    /**
+     * 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.url}/import`, formData)
+            .pipe(map((employeeInvite) => {
+            return employeeInvite;
+        }));
+    }
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)
+            .pipe(map((resentInviteBase) => {
+            const updatedInvite = plainToClass(EmployeeInvite, resentInviteBase);
+            // avoid cache changes
+            // @TODO make cache readonly
+            const tempCache = _.cloneDeep(this.cache);
+            replace(tempCache, plainToClass(EmployeeInvite, updatedInvite));
+            this.cache = tempCache;
+            this.updateCache();
+            return updatedInvite;
+        }));
+    }
+}
+EmployeeInviteService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+EmployeeInviteService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+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) => {
+            return plainToClass(Firm, firm);
+        }));
+    }
+    get() {
+        if (!this.firm) {
+            this.http.get(`${this.environment.apiV2}/firms/current`)
+                .pipe(map((firm) => {
+                return 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) => {
+            return response['hydra:member'].map((firmBase) => plainToClass(Firm, firmBase));
+        }));
+    }
+    getByType(type) {
+        return this.getAll().pipe(map((firms) => {
+            return firms.filter((firm) => firm.type === type);
+        }));
+    }
+    updatePhoto(firm, photo) {
+        return this.http.post(`${this.environment.apiV2}/firms/photo?_method=PUT`, photo)
+            .pipe(map((firmPhoto) => {
+            this.firm = plainToClass(Firm, Object.assign(firm, { photo: firmPhoto }));
+            this.firmSubject.next(this.firm);
+            return firm;
+        }));
+    }
+}
+FirmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FirmService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+FirmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FirmService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FirmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/firm/portfolio-report/client-portfolio-report.service.js

@@ -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['hydra:member'].map((item) => plainToClass(ClientPortfolioReport, item));
+            return new ClientPortfolioReportCollection(clientReports);
+        }));
+    }
+}
+ClientPortfolioReportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientPortfolioReportService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+ClientPortfolioReportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientPortfolioReportService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ClientPortfolioReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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