taxtank-core 0.31.61 → 0.32.0

package/esm2022/lib/services/http/transaction/transaction.service.mjs

@@ -0,0 +1,271 @@
+import { EventEmitter, Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace, sort } from '../../../functions/array';
+import { TransactionOperationEnum } from '../../../db/Enums/transaction-operation.enum';
+import { RestService } from '../rest/rest-old.service';
+import { AppEvent, AppEventTypeEnum, Depreciation, Transaction } from '../../../models';
+import _ from 'lodash';
+import { PropertyCategoryListEnum } from '../../../db/Enums/property/property-category-list.enum';
+import { classToPlain } from 'class-transformer';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../event";
+import * as i3 from "../../toast";
+/**
+ * Service for transactions business logic
+ */
+export class TransactionService extends RestService {
+    constructor(http, eventDispatcherService, environment, toastService) {
+        super(http, eventDispatcherService, environment, toastService);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.toastService = toastService;
+        // url part for Transaction API
+        this.url = 'transactions';
+        this.modelClass = Transaction;
+        this.transactionDeleted = new EventEmitter();
+    }
+    /**
+     * Listen events from Event Dispatcher services
+     */
+    listenEvents() {
+        this.listenDepreciationChange();
+        this.listenPropertyShareUpdate();
+        this.listenVehicleClaimChanges();
+        this.listenPropertyForecastUpdate();
+        this.listenInvoicesPublish();
+    }
+    /**
+     * get list of all user's TaxTank transactions
+     */
+    get() {
+        return super.get().pipe(
+        // assign child transactions (fees) to parent transactions
+        map((transactions) => {
+            transactions.forEach((transaction) => {
+                transaction.transactions = transactions
+                    // get list of child transactions
+                    .filter((t) => t.parentTransaction && t.parentTransaction.id === transaction.id);
+            });
+            sort(transactions, 'date', false);
+            return transactions;
+        }));
+    }
+    /**
+     * Add single new transaction
+     * @param model New Transaction instance for saving
+     */
+    add(model) {
+        // we don't have POST API endpoint for single transaction
+        return this.addBatch([model])
+            .pipe(map((newTransactions) => {
+            // @TODO alex
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TRANSACTION_CREATED, newTransactions[0]));
+            return newTransactions[0];
+        }));
+    }
+    /**
+     * get transactions related with property
+     */
+    getByPropertyId(propertyId) {
+        return this.get()
+            .pipe(map((transactions) => transactions.filter((transaction) => transaction.property?.id === propertyId)));
+    }
+    /**
+     * get list of transactions with tank type 'Work'
+     */
+    getWorkTransactions() {
+        return this.get()
+            .pipe(map((transactions) => transactions.filter((transaction) => transaction.isWorkTank())));
+    }
+    /**
+     * Get list of property holding costs (transactions related to vacant land property)
+     */
+    getPropertyHoldingCosts(propertyId) {
+        return super.fetch(`${this.environment.apiV2}/${this.url}?propertyId=${propertyId}&propertyCategoryId=${PropertyCategoryListEnum.VACANT_LAND}`, false);
+    }
+    /**
+     * get list of taxable transactions with tank type 'Work'
+     */
+    getTaxableWorkTransactions() {
+        return this.getWorkTransactions()
+            .pipe(map((transactions) => transactions.filter((transaction) => !!transaction.chartAccounts.taxReturnItem)));
+    }
+    /**
+     * add multiple transactions
+     * @param transactions List of new Transaction instances for saving
+     */
+    addBatch(transactions) {
+        transactions = _.cloneDeep(transactions);
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(transactions))
+            .pipe(map((response) => {
+            const addedTransactions = response.map((item) => this.createModelInstance(item));
+            transactions.forEach((transaction, index) => {
+                // @TODO Viktor: implement API for saving of nested transactions
+                // add child transactions if exist
+                if (transaction.transactions.length) {
+                    transaction.transactions.forEach((childTransaction) => {
+                        childTransaction.parentTransaction = this.createModelInstance({ id: addedTransactions[index].id });
+                    });
+                    this.addBatch(transaction.transactions).subscribe();
+                }
+                // add transfer transaction to cache
+                if (transaction.operation === TransactionOperationEnum.TRANSFER) {
+                    addedTransactions.push(addedTransactions[0].transfer);
+                }
+            });
+            if (this.cache) {
+                this.cache.push(...addedTransactions);
+                this.updateCache();
+            }
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TRANSACTIONS_CREATED, addedTransactions));
+            return addedTransactions;
+        }));
+    }
+    /**
+     * update existing transaction
+     * @param transaction Transaction instance for updating
+     */
+    update(transaction) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${transaction.id}`, classToPlain(transaction))
+            .pipe(map((response) => {
+            const updatedTransaction = this.createModelInstance(response);
+            // @TODO Viktor: implement API for saving of nested transactions
+            if (transaction.transactions.length) {
+                // add parent transaction to child transactions
+                transaction.transactions.forEach((childTransaction) => {
+                    childTransaction.parentTransaction = this.createModelInstance({ id: updatedTransaction.id });
+                });
+                // separate child transactions by id existing to define add or update action.
+                const childTransactionsToUpdate = transaction.transactions.filter((t) => t.id);
+                const childTransactionsToAdd = transaction.transactions.filter((t) => !t.id);
+                // update child transactions
+                if (childTransactionsToUpdate.length) {
+                    this.updateBatch(childTransactionsToUpdate).subscribe();
+                }
+                // add child transactions
+                if (childTransactionsToAdd.length) {
+                    this.addBatch(childTransactionsToAdd).subscribe();
+                }
+            }
+            this.replaceInCache(updatedTransaction);
+            return updatedTransaction;
+        }));
+    }
+    /**
+     * update multiple transactions
+     * @param transactions list of transactions for updating
+     */
+    updateBatch(transactions) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(transactions))
+            .pipe(map((response) => {
+            const updatedTransactions = response.map((item) => this.createModelInstance(item));
+            updatedTransactions.forEach((updatedTransaction) => {
+                replace(this.cache, updatedTransaction);
+            });
+            this.updateCache();
+            return updatedTransactions;
+        }));
+    }
+    /**
+     * delete transaction and related transactions
+     * @param model
+     */
+    delete(model) {
+        return this.http.delete(`${this.environment.apiV2}/${this.url}/${model.id}`)
+            .pipe(map(() => {
+            this.cache = this.cache.filter((transaction) => {
+                // when delete transfer we delete actually 2 transactions
+                if (model.isTransfer) {
+                    const ids = [model.id];
+                    // get id of related transfer transaction
+                    if (model.transfer) {
+                        // just take id if we delete source transaction
+                        ids.push(model.transfer.id);
+                    }
+                    else {
+                        // find source transaction id if we delete destination transaction
+                        ids.push(this.cache.find((t) => t.transfer.id === model.id).id);
+                    }
+                    return !ids.includes(transaction.id);
+                }
+                return transaction.id !== model.id && transaction.parentTransaction?.id !== model.id;
+            });
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TRANSACTION_DELETED, model));
+            this.updateCache();
+            this.transactionDeleted.emit(model);
+        }));
+    }
+    /**
+     * @TODO Alex wrong place for this logic, move to model
+     * calculate gross income amount based on transaction amount and taxes (fees)
+     * @param transaction Transaction instance for calculation
+     */
+    calculateGrossAmount(transaction) {
+        let amount = transaction.amount || 0;
+        // gross income amount includes amount of fees for property tank and tax for work tank
+        if (transaction.isPropertyTank()) {
+            amount += transaction.transactions.reduce((sum, item) => sum + item.amount, 0);
+        }
+        else {
+            // @TODO Alex: fix logic after TT-641 ready
+            amount += (transaction.tax || 0);
+        }
+        return amount;
+    }
+    /**
+     * Listen to EventDispatcherService event related to Depreciation changing
+     */
+    listenDepreciationChange() {
+        // @TODO reset cache only when required (depreciation has transaction)
+        this.eventDispatcherService.on2(...Depreciation.getEventNames('post', 'delete')).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    /**
+     * Listen to EventDispatcherService event related to Property Share changing
+     */
+    listenPropertyShareUpdate() {
+        this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_SHARE_UPDATED).subscribe(() => this.refreshCache());
+    }
+    listenVehicleClaimChanges() {
+        this.eventDispatcherService.on([
+            AppEventTypeEnum.VEHICLE_CLAIM_CREATED,
+            AppEventTypeEnum.VEHICLE_CLAIM_UPDATED,
+            AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED
+        ]).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    /**
+     * property forecast includes claimPercent which affects property related expenses
+     * @TODO Alex move to forecast api instead of property
+     */
+    listenPropertyForecastUpdate() {
+        this.eventDispatcherService.on([AppEventTypeEnum.PROPERTY_UPDATED]).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    replaceInCache(transactionToReplace) {
+        replace(this.cache, transactionToReplace);
+        this.updateCache();
+    }
+    listenInvoicesPublish() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SOLE_INVOICE_PUBLISHED).subscribe(() => {
+            this.refreshCache();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TransactionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.ToastService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TransactionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TransactionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i3.ToastService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/transaction/transaction.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Inject, Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Transaction as TransactionBase } from '../../../db/Models/transaction/transaction';\nimport { map } from 'rxjs/operators';\nimport { replace, sort } from '../../../functions/array';\nimport { TransactionOperationEnum } from '../../../db/Enums/transaction-operation.enum';\nimport { RestService } from '../rest/rest-old.service';\nimport { AppEvent, AppEventTypeEnum, Depreciation, Transaction } from '../../../models';\nimport _ from 'lodash';\nimport { PropertyCategoryListEnum } from '../../../db/Enums/property/property-category-list.enum';\nimport { HttpClient } from '@angular/common/http';\nimport { EventDispatcherService } from '../../event';\nimport { ToastService } from '../../toast';\nimport { IEventListener } from '../../../interfaces';\nimport { classToPlain } from 'class-transformer';\n/**\n * Service for transactions business logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class TransactionService extends RestService<TransactionBase, Transaction> implements IEventListener {\n  // url part for Transaction API\n  url = 'transactions';\n  modelClass = Transaction;\n  transactionDeleted: EventEmitter<Transaction> = new EventEmitter<Transaction>();\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any,\n    protected toastService: ToastService\n  ) {\n    super(http, eventDispatcherService, environment, toastService);\n  }\n\n  /**\n   * Listen events from Event Dispatcher services\n   */\n  listenEvents(): void {\n    this.listenDepreciationChange();\n    this.listenPropertyShareUpdate();\n    this.listenVehicleClaimChanges();\n    this.listenPropertyForecastUpdate();\n    this.listenInvoicesPublish();\n  }\n\n  /**\n   * get list of all user's TaxTank transactions\n   */\n  get(): Observable<Transaction[]> {\n    return super.get().pipe(\n      // assign child transactions (fees) to parent transactions\n      map((transactions: Transaction[]): Transaction[] => {\n        transactions.forEach((transaction: Transaction): void => {\n          transaction.transactions = transactions\n            // get list of child transactions\n            .filter((t: Transaction): boolean => t.parentTransaction && t.parentTransaction.id === transaction.id);\n        });\n        sort(transactions, 'date', false);\n        return transactions;\n      })\n    );\n  }\n\n  /**\n   * Add single new transaction\n   * @param model New Transaction instance for saving\n   */\n  add(model: Transaction): Observable<Transaction> {\n    // we don't have POST API endpoint for single transaction\n    return this.addBatch([model])\n      .pipe(\n        map((newTransactions: Transaction[]): Transaction => {\n          // @TODO alex\n          this.eventDispatcherService.dispatch(\n            new AppEvent<Transaction>(AppEventTypeEnum.TRANSACTION_CREATED, newTransactions[0])\n          );\n\n          return newTransactions[0];\n        })\n      );\n  }\n\n  /**\n   * get transactions related with property\n   */\n  getByPropertyId(propertyId: number): Observable<Transaction[]> {\n    return this.get()\n      .pipe(\n        map((transactions: Transaction[]): Transaction[] => transactions.filter((transaction: Transaction): boolean => transaction.property?.id === propertyId))\n      );\n  }\n\n  /**\n   * get list of transactions with tank type 'Work'\n   */\n  getWorkTransactions(): Observable<Transaction[]> {\n    return this.get()\n      .pipe(\n        map((transactions: Transaction[]): Transaction[] => transactions.filter((transaction: Transaction): boolean => transaction.isWorkTank()))\n      );\n  }\n\n  /**\n   * Get list of property holding costs (transactions related to vacant land property)\n   */\n  getPropertyHoldingCosts(propertyId: number): Observable<Transaction[]> {\n    return super.fetch(`${this.environment.apiV2}/${this.url}?propertyId=${propertyId}&propertyCategoryId=${PropertyCategoryListEnum.VACANT_LAND}`, false);\n  }\n\n  /**\n   * get list of taxable transactions with tank type 'Work'\n   */\n  getTaxableWorkTransactions(): Observable<Transaction[]> {\n    return this.getWorkTransactions()\n      .pipe(\n        map((transactions: Transaction[]): Transaction[] => transactions.filter((transaction: Transaction): boolean => !!transaction.chartAccounts.taxReturnItem))\n      );\n  }\n\n  /**\n   * add multiple transactions\n   * @param transactions List of new Transaction instances for saving\n   */\n  addBatch(transactions: Transaction[]): Observable<Transaction[]> {\n    transactions = _.cloneDeep(transactions);\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, classToPlain(transactions))\n      .pipe(\n        map((response: TransactionBase[]) => {\n          const addedTransactions: Transaction[] = response.map((item: TransactionBase) => this.createModelInstance(item));\n\n          transactions.forEach((transaction: Transaction, index: number) => {\n            // @TODO Viktor: implement API for saving of nested transactions\n            // add child transactions if exist\n            if (transaction.transactions.length) {\n              transaction.transactions.forEach((childTransaction: Transaction) => {\n                childTransaction.parentTransaction = this.createModelInstance({ id: addedTransactions[index].id });\n              });\n              this.addBatch(transaction.transactions).subscribe();\n            }\n\n            // add transfer transaction to cache\n            if (transaction.operation === TransactionOperationEnum.TRANSFER) {\n              addedTransactions.push(addedTransactions[0].transfer);\n            }\n          });\n\n          if (this.cache) {\n            this.cache.push(...addedTransactions);\n            this.updateCache();\n          }\n\n          this.eventDispatcherService.dispatch(\n            new AppEvent<Transaction[]>(AppEventTypeEnum.TRANSACTIONS_CREATED, addedTransactions)\n          );\n\n          return addedTransactions;\n        })\n      );\n  }\n\n  /**\n   * update existing transaction\n   * @param transaction Transaction instance for updating\n   */\n  update(transaction: Transaction): Observable<Transaction> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${transaction.id}`, classToPlain(transaction))\n      .pipe(\n        map((response: TransactionBase) => {\n          const updatedTransaction: Transaction = this.createModelInstance(response);\n          // @TODO Viktor: implement API for saving of nested transactions\n          if (transaction.transactions.length) {\n            // add parent transaction to child transactions\n            transaction.transactions.forEach((childTransaction: Transaction) => {\n              childTransaction.parentTransaction = this.createModelInstance({ id: updatedTransaction.id });\n            });\n            // separate child transactions by id existing to define add or update action.\n            const childTransactionsToUpdate: Transaction[] = transaction.transactions.filter((t: Transaction) => t.id);\n            const childTransactionsToAdd: Transaction[] = transaction.transactions.filter((t: Transaction) => !t.id);\n\n            // update child transactions\n            if (childTransactionsToUpdate.length) {\n              this.updateBatch(childTransactionsToUpdate).subscribe();\n            }\n\n            // add child transactions\n            if (childTransactionsToAdd.length) {\n              this.addBatch(childTransactionsToAdd).subscribe();\n            }\n          }\n\n          this.replaceInCache(updatedTransaction);\n\n          return updatedTransaction;\n        })\n      );\n  }\n\n  /**\n   * update multiple transactions\n   * @param transactions list of transactions for updating\n   */\n  updateBatch(transactions: Transaction[]): Observable<Transaction[]> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}`, classToPlain(transactions))\n      .pipe(\n        map((response: TransactionBase[]) => {\n          const updatedTransactions: Transaction[] = response.map((item: TransactionBase) => this.createModelInstance(item));\n\n          updatedTransactions.forEach((updatedTransaction: Transaction) => {\n            replace(this.cache, updatedTransaction);\n          });\n\n          this.updateCache();\n          return updatedTransactions;\n        })\n      );\n  }\n\n  /**\n   * delete transaction and related transactions\n   * @param model\n   */\n  delete(model: Transaction): Observable<void> {\n    return this.http.delete(`${this.environment.apiV2}/${this.url}/${model.id}`)\n      .pipe(\n        map((): void => {\n          this.cache = this.cache.filter((transaction: Transaction): boolean => {\n            // when delete transfer we delete actually 2 transactions\n            if (model.isTransfer) {\n              const ids: number[] = [model.id];\n\n              // get id of related transfer transaction\n              if (model.transfer) {\n                // just take id if we delete source transaction\n                ids.push(model.transfer.id);\n              } else {\n                // find source transaction id if we delete destination transaction\n                ids.push(this.cache.find((t: Transaction): boolean => t.transfer.id === model.id).id);\n              }\n\n              return !ids.includes(transaction.id);\n            }\n\n            return transaction.id !== model.id && transaction.parentTransaction?.id !== model.id;\n          });\n\n          this.eventDispatcherService.dispatch(\n            new AppEvent<Transaction>(AppEventTypeEnum.TRANSACTION_DELETED, model)\n          );\n\n          this.updateCache();\n          this.transactionDeleted.emit(model);\n        })\n      );\n  }\n\n  /**\n   * @TODO Alex wrong place for this logic, move to model\n   * calculate gross income amount based on transaction amount and taxes (fees)\n   * @param transaction Transaction instance for calculation\n   */\n  calculateGrossAmount(transaction: Transaction): number {\n    let amount: number = transaction.amount || 0;\n\n    // gross income amount includes amount of fees for property tank and tax for work tank\n    if (transaction.isPropertyTank()) {\n      amount += transaction.transactions.reduce((sum: number, item: Transaction) => sum + item.amount, 0);\n    } else {\n      // @TODO Alex: fix logic after TT-641 ready\n      amount += (transaction.tax || 0);\n    }\n\n    return amount;\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to Depreciation changing\n   */\n  private listenDepreciationChange(): void {\n    // @TODO reset cache only when required (depreciation has transaction)\n    this.eventDispatcherService.on2(...Depreciation.getEventNames('post', 'delete')).subscribe(() => {\n      this.refreshCache();\n    });\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to Property Share changing\n   */\n  private listenPropertyShareUpdate(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_SHARE_UPDATED).subscribe(() => this.refreshCache());\n  }\n\n  private listenVehicleClaimChanges(): void {\n    this.eventDispatcherService.on([\n      AppEventTypeEnum.VEHICLE_CLAIM_CREATED,\n      AppEventTypeEnum.VEHICLE_CLAIM_UPDATED,\n      AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED\n    ]).subscribe(() => {\n      this.refreshCache();\n    })\n  }\n\n  /**\n   * property forecast includes claimPercent which affects property related expenses\n   * @TODO Alex move to forecast api instead of property\n   */\n  private listenPropertyForecastUpdate(): void {\n    this.eventDispatcherService.on([AppEventTypeEnum.PROPERTY_UPDATED]).subscribe(() => {\n      this.refreshCache();\n    });\n  }\n\n  private replaceInCache(transactionToReplace: Transaction): void {\n    replace(this.cache, transactionToReplace);\n    this.updateCache();\n  }\n\n  private listenInvoicesPublish(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.SOLE_INVOICE_PUBLISHED).subscribe(() => {\n      this.refreshCache();\n    })\n  }\n}\n"]}

package/esm2022/lib/services/http/tutorial-video/tutorial-video.service.mjs

@@ -0,0 +1,35 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @TODO Artem: implement cache and extend rest?
+export class TutorialVideoService {
+    static { this.googleUrl = `https://www.googleapis.com/drive/v3/files?fields=*&mimeType='video/mp4'&orderBy=name`; }
+    static { this.parents = '1uLMLzi8WUy2go9xhfzJEwgFwOM43dukM'; }
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+    }
+    get() {
+        return this.http.get(`${TutorialVideoService.googleUrl}&q='${TutorialVideoService.parents}'+in+parents&key=${this.environment.googleDriveId}`)
+            .pipe(map((response) => {
+            // video has a title like "1. Title".
+            response.files.forEach((item) => {
+                item.name = item.name.split('.', 2)[1];
+            });
+            return response.files;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TutorialVideoService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TutorialVideoService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TutorialVideoService, 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/esm2022/lib/services/http/user/financial-year/financial-year.service.mjs

@@ -0,0 +1,32 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../mixpanel/mixpanel.service";
+export class FinancialYearService {
+    constructor(http, environment, mpService) {
+        this.http = http;
+        this.environment = environment;
+        this.mpService = mpService;
+    }
+    switch(year) {
+        return this.http.get(`${this.environment.apiV2}/financial-year/switch`, { params: new HttpParams({ fromString: `financialYear=${year}` }) }).pipe(map(() => {
+            localStorage.setItem('financialYear', year.toString());
+            this.mpService.track('switchYear', { year });
+            window.location.reload();
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FinancialYearService, deps: [{ token: i1.HttpClient }, { token: 'environment' }, { token: i2.MixpanelService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FinancialYearService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FinancialYearService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.MixpanelService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/user/user-event-setting/user-event-setting.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { UserEventSetting } from '../../../../models/user-event/user-event-setting';
+import { RestService } from '../../rest';
+import { UserEventSettingCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class UserEventSettingService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = UserEventSetting;
+        this.collectionClass = UserEventSettingCollection;
+        this.endpointUri = 'user-event-settings';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['postBatch', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventSettingService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventSettingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventSettingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/user/user-event-type/user-event-type.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { UserEventType } from '../../../../models/user-event/user-event-type';
+import { RestService } from '../../rest';
+import { UserEventTypeCollection } from '../../../../collections';
+import * as i0 from "@angular/core";
+export class UserEventTypeService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = UserEventType;
+        this.collectionClass = UserEventTypeCollection;
+        this.endpointUri = 'user-event-types';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTypeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTypeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTypeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,134 @@
+import { Injectable } from '@angular/core';
+import { AppEventTypeEnum, User, } from '../../../models';
+import { catchError, map } from 'rxjs/operators';
+import { RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { throwError as observableThrowError } from 'rxjs';
+import clone from 'lodash/clone';
+import * as i0 from "@angular/core";
+export class UserService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = User;
+        this.collectionClass = Collection;
+        this.endpointUri = 'users';
+        this.isApiPlatform = false;
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch', 'delete'];
+    }
+    listenEvents() {
+        this.listenServiceSubscriptionUpdated();
+        this.listenBasiqConsentUpdated();
+    }
+    fetch() {
+        return super.fetch(`${this.apiUrl}/current`).pipe(map((users) => {
+            // @TODO vik use separated service to handle global user storage
+            localStorage.setItem('userId', this.getCacheFirst().id.toString());
+            localStorage.setItem('financialYear', this.getCacheFirst().financialYear.toString());
+            localStorage.setItem('roles', JSON.stringify(this.getCacheFirst().roles));
+            return users;
+        }));
+    }
+    register(data) {
+        return this.http.post(`${this.apiUrl}/registration`, data)
+            .pipe(map((user) => {
+            this.mpService.identify(user['id']);
+            return user;
+        }));
+    }
+    changePassword(currentPassword, newPassword) {
+        return this.http.put(`${this.apiUrl}/password/change`, { currentPassword, newPassword })
+            .pipe(map((response) => {
+            this.mpService.track('passwordChange');
+            return response;
+        }), catchError((error) => {
+            this.mpService.track('passwordChangeError');
+            return observableThrowError(error);
+        }));
+    }
+    recoveryPassword(email) {
+        return this.http.put(`${this.apiUrl}/password/recovery`, { email })
+            .pipe(map((response) => {
+            this.mpService.track('passwordRecovery', { email });
+            return response;
+        }), catchError((error) => {
+            this.mpService.track('passwordRecoveryError', { email });
+            return observableThrowError(error);
+        }));
+    }
+    resetPassword(newPassword, resetToken) {
+        return this.http.put(`${this.apiUrl}/password/reset`, { newPassword, resetToken })
+            .pipe(catchError((error) => {
+            // success tracked on back-end side to attach it to existing user before login
+            this.mpService.track('passwordResetError', { resetToken });
+            return observableThrowError(error);
+        }));
+    }
+    resendConfirmationEmail(email) {
+        return this.http.post(`${this.apiUrl}/confirmation/resend`, { email })
+            .pipe(map((response) => {
+            this.mpService.track('emailConfirmResend', { email });
+            return response;
+        }), catchError((error) => {
+            this.mpService.track('emailConfirmResendError', { email });
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Confirm registered user
+     */
+    confirm(verificationCode) {
+        return this.http.post(`${this.apiUrl}/confirmation`, { verificationCode })
+            .pipe(catchError((error) => {
+            // success tracked on back-end side to attach it to existing user before login
+            this.mpService.track('emailConfirmError', { verificationCode });
+            return observableThrowError(error);
+        }));
+    }
+    /**
+     * Search existing user
+     */
+    search(email) {
+        return this.http.get(`${this.apiUrl}/search`, { params: { email } }).pipe(map((userBase) => this.createModelInstance(userBase)));
+    }
+    finishOnboarding(user) {
+        return this.put(user, null, `${this.apiUrl}/status`);
+    }
+    updatePhoto(photo) {
+        return this.http.post(`${this.apiUrl}/photo?_method=PUT`, photo).pipe(map((photoUrl) => {
+            this.setCache([Object.assign(this.getCacheFirst(), { photo: photoUrl })], true);
+        }));
+    }
+    createBasiq() {
+        return this.http.post(`${this.environment.apiV2}/basiq/user`, {})
+            .pipe(map((basiqId) => {
+            this.setCache([Object.assign(this.getCacheFirst(), { basiqId })], true);
+            return basiqId;
+        }));
+    }
+    skipSetupItem(item) {
+        const user = clone(this.getCacheFirst());
+        user.blacklistSetupItems.push(item);
+        return this.put(user);
+    }
+    /**
+     * Update cache when user's service subscription is updated
+     */
+    listenServiceSubscriptionUpdated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED).subscribe(() => this.refreshCache());
+    }
+    /**
+     * Update cache when user's basiq consent flag is updated
+     */
+    listenBasiqConsentUpdated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BASIQ_CONSENT_UPDATED).subscribe(() => this.refreshCache());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# 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 } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { User as UserBase } from '../../../db/Models/user/user';\nimport { AppEventTypeEnum, User, } from '../../../models';\nimport { EventDispatcherService } from '../../event';\nimport { catchError, map } from 'rxjs/operators';\nimport { RestMethod, RestService } from '../rest';\nimport { Collection } from '../../../collections';\nimport { throwError as observableThrowError } from 'rxjs';\nimport { AccountSetupItem } from '../../../models/account-setup/account-setup-item';\nimport clone from 'lodash/clone';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class UserService extends RestService<UserBase, User, Collection<User>> {\n  modelClass: typeof User = User;\n  collectionClass: typeof Collection = Collection;\n  endpointUri = 'users';\n  isApiPlatform = false;\n  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch', 'delete'];\n\n  listenEvents(): void {\n    this.listenServiceSubscriptionUpdated();\n    this.listenBasiqConsentUpdated();\n  }\n\n  fetch(): Observable<Collection<User>> {\n    return super.fetch(`${this.apiUrl}/current`).pipe(map((users) => {\n      // @TODO vik use separated service to handle global user storage\n      localStorage.setItem('userId', this.getCacheFirst().id.toString());\n      localStorage.setItem('financialYear', this.getCacheFirst().financialYear.toString());\n      localStorage.setItem('roles', JSON.stringify(this.getCacheFirst().roles));\n\n      return users;\n    }));\n  }\n\n  register(data: object): Observable<object> {\n    return this.http.post(`${this.apiUrl}/registration`, data)\n      .pipe(map((user) => {\n        this.mpService.identify(user['id']);\n\n        return user;\n      }));\n  }\n\n  changePassword(currentPassword: string, newPassword: string): Observable<object> {\n    return this.http.put(`${this.apiUrl}/password/change`, { currentPassword, newPassword })\n      .pipe(\n        map((response: any) => {\n          this.mpService.track('passwordChange');\n          return response;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.mpService.track('passwordChangeError');\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  recoveryPassword(email: string): Observable<object> {\n    return this.http.put(`${this.apiUrl}/password/recovery`, { email })\n      .pipe(\n        map((response: any) => {\n          this.mpService.track('passwordRecovery', { email });\n          return response;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.mpService.track('passwordRecoveryError', { email });\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  resetPassword(newPassword: string, resetToken: string): Observable<object> {\n    return this.http.put(`${this.apiUrl}/password/reset`, { newPassword, resetToken })\n      .pipe(\n        catchError((error: HttpErrorResponse) => {\n          // success tracked on back-end side to attach it to existing user before login\n          this.mpService.track('passwordResetError', { resetToken });\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  resendConfirmationEmail(email: string): Observable<object> {\n    return this.http.post(`${this.apiUrl}/confirmation/resend`, { email })\n      .pipe(\n        map((response: any) => {\n          this.mpService.track('emailConfirmResend', { email });\n          return response;\n        }),\n        catchError((error: HttpErrorResponse) => {\n          this.mpService.track('emailConfirmResendError', { email });\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Confirm registered user\n   */\n  confirm(verificationCode: string): Observable<object> {\n    return this.http.post(`${this.apiUrl}/confirmation`, { verificationCode })\n      .pipe(\n        catchError((error: HttpErrorResponse) => {\n          // success tracked on back-end side to attach it to existing user before login\n          this.mpService.track('emailConfirmError', { verificationCode });\n          return observableThrowError(error);\n        })\n      );\n  }\n\n  /**\n   * Search existing user\n   */\n  search(email: string): Observable<User> {\n    return this.http.get(`${this.apiUrl}/search`, { params: { email } }).pipe(\n      map((userBase: UserBase) => this.createModelInstance(userBase))\n    );\n  }\n\n  finishOnboarding(user: User): Observable<User> {\n    return this.put(user, null, `${this.apiUrl}/status`);\n  }\n\n  updatePhoto(photo: FormData): Observable<void> {\n    return this.http.post(`${this.apiUrl}/photo?_method=PUT`, photo).pipe(\n      map((photoUrl: string) => {\n        this.setCache([Object.assign(this.getCacheFirst(), { photo: photoUrl })], true);\n      })\n    );\n  }\n\n  createBasiq(): Observable<string> {\n    return this.http.post(`${this.environment.apiV2}/basiq/user`, {})\n      .pipe(\n        map((basiqId: string) => {\n          this.setCache([Object.assign(this.getCacheFirst(), { basiqId })], true);\n\n          return basiqId;\n        })\n      );\n  }\n\n  skipSetupItem(item: AccountSetupItem): Observable<User> {\n    const user = clone(this.getCacheFirst());\n    user.blacklistSetupItems.push(item);\n\n    return this.put(user);\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.refreshCache());\n  }\n\n  /**\n   * Update cache when user's basiq consent flag is updated\n   */\n  private listenBasiqConsentUpdated(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BASIQ_CONSENT_UPDATED).subscribe(() => this.refreshCache());\n  }\n}\n"]}