taxtank-core 0.0.2 → 0.1.2

package/esm2015/lib/services/tax-review/tax-review-history.service.js

@@ -0,0 +1,41 @@
+import { Inject, Injectable } from '@angular/core';
+import { BaseRestService } from '../base-rest.service';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+/**
+ * Service to work with tax review history
+ */
+export class TaxReviewHistoryService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'tax-reviews/history';
+        this.modelClass = TaxReview;
+        // subscribe on tax review updating
+        eventDispatcherService.on(AppEventTypeEnum.TAX_REVIEW_UPDATED).subscribe((taxReview) => {
+            const tempCache = _.cloneDeep(this.cache);
+            // insert element at the beginning of the array
+            tempCache.unshift(taxReview);
+            this.cache = tempCache;
+            this.updateCache();
+        });
+    }
+}
+TaxReviewHistoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+TaxReviewHistoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/tax-review/tax-review.service.js

@@ -0,0 +1,103 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import _ from 'lodash';
+import { replace } from '../../functions/array';
+import { BaseRestService } from '../base-rest.service';
+import { plainToClass } from 'class-transformer';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+/**
+ * Service to work with tax review
+ */
+export class TaxReviewService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'tax-reviews';
+        this.modelClass = TaxReview;
+        this.listenEvents();
+    }
+    /**
+     * Listen events from SSE and Event Dispatcher services
+     */
+    listenEvents() {
+        this.listenFirmChanges();
+        this.listenClientTransfer();
+    }
+    /**
+     * Add new Tax Review (request from client to firm)
+     * @param finYear
+     */
+    request(finYear) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}?financialYear=${finYear}`, {})
+            .pipe(map((newTaxReview) => {
+            const taxReview = plainToClass(TaxReview, newTaxReview);
+            const tempCache = _.cloneDeep(this.cache);
+            tempCache.push(taxReview);
+            this.cache = tempCache;
+            this.updateCache();
+            return taxReview;
+        }));
+    }
+    /**
+     * Update tax review
+     * @param taxReview to be updated
+     */
+    update(taxReview) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${taxReview.id}`, taxReview)
+            .pipe(map((updatedTaxReview) => {
+            const updatedInstance = plainToClass(TaxReview, updatedTaxReview);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TAX_REVIEW_UPDATED, updatedInstance));
+            const tempCache = _.cloneDeep(this.cache);
+            replace(tempCache, updatedInstance);
+            this.cache = tempCache;
+            this.updateCache();
+            return updatedInstance;
+        }));
+    }
+    /**
+     * Clear cache when user reject firm
+     */
+    listenFirmChanges() {
+        this.eventDispatcherService.on([AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, AppEventTypeEnum.CLIENT_INVITE_ACCEPTED])
+            .subscribe(() => {
+            this.cache = [];
+            this.updateCache();
+        });
+    }
+    /**
+     * Update firm for all transferred clients
+     * @private
+     */
+    listenClientTransfer() {
+        this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE)
+            .subscribe((transferredClients) => {
+            const tempCache = _.cloneDeep(this.cache);
+            transferredClients.forEach((transferredClient) => {
+                const taxReviewIndex = tempCache.findIndex((taxReview) => taxReview.id === transferredClient.id);
+                // @TODO vik
+                // tempCache[taxReviewIndex].employee = transferredClient.accountant;
+            });
+            this.cache = tempCache;
+            this.updateCache();
+        });
+    }
+}
+TaxReviewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+TaxReviewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewService, 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":"tax-review.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/tax-review/tax-review.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport _ from 'lodash';\nimport { replace } from '../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { BaseRestService } from '../base-rest.service';\nimport { IEventListener } from '../../interfaces/event-listener.interface';\nimport { plainToClass } from 'class-transformer';\nimport { TaxReview } from '../../models/tax-review/tax-review';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\nimport { AppEvent } from '../../models/event/app-event';\nimport { User } from '../../models/user/user';\n\n/**\n * Service to work with tax review\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class TaxReviewService extends BaseRestService<TaxReviewBase, TaxReview> implements IEventListener {\n  url: string = 'tax-reviews';\n  modelClass: typeof TaxReview = TaxReview;\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   * Listen events from SSE and Event Dispatcher services\n   */\n  listenEvents(): void {\n    this.listenFirmChanges();\n    this.listenClientTransfer();\n  }\n\n  /**\n   * Add new Tax Review (request from client to firm)\n   * @param finYear\n   */\n  request(finYear: number): Observable<TaxReview> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}?financialYear=${finYear}`, {})\n      .pipe(\n        map((newTaxReview: TaxReviewBase): TaxReview => {\n          const taxReview: TaxReview = plainToClass(TaxReview, newTaxReview);\n          const tempCache: TaxReview[] = _.cloneDeep(this.cache);\n          tempCache.push(taxReview);\n          this.cache = tempCache;\n          this.updateCache();\n          return taxReview;\n        })\n      );\n  }\n\n  /**\n   * Update tax review\n   * @param taxReview to be updated\n   */\n  update(taxReview: TaxReview): Observable<TaxReview> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${taxReview.id}`, taxReview)\n      .pipe(\n        map((updatedTaxReview: TaxReviewBase) => {\n          const updatedInstance: TaxReview = plainToClass(TaxReview, updatedTaxReview);\n\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.TAX_REVIEW_UPDATED, updatedInstance));\n\n          const tempCache: TaxReview[] = _.cloneDeep(this.cache);\n          replace(tempCache, updatedInstance);\n          this.cache = tempCache;\n          this.updateCache();\n\n          return updatedInstance;\n        })\n      );\n  }\n\n  /**\n   * Clear cache when user reject firm\n   */\n  private listenFirmChanges(): void {\n    this.eventDispatcherService.on([AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, AppEventTypeEnum.CLIENT_INVITE_ACCEPTED])\n      .subscribe((): void => {\n        this.cache = [];\n        this.updateCache();\n      });\n  }\n\n  /**\n   * Update firm for all transferred clients\n   * @private\n   */\n  private listenClientTransfer(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE)\n      .subscribe((transferredClients: User[]): void => {\n        const tempCache: TaxReview[] = _.cloneDeep(this.cache);\n\n        transferredClients.forEach((transferredClient: User): void => {\n          const taxReviewIndex: number = tempCache.findIndex((taxReview: TaxReview): boolean => taxReview.id === transferredClient.id);\n          // @TODO vik\n          // tempCache[taxReviewIndex].employee = transferredClient.accountant;\n        });\n\n        this.cache = tempCache;\n        this.updateCache();\n      });\n  }\n}\n"]}

package/esm2015/lib/services/tax-summary/tax-summary.service.js

@@ -0,0 +1,71 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { plainToClass } from 'class-transformer';
+import { TaxSummary } from '../../models/tax-summary/tax-summary';
+import { TaxSummaryTypeEnum } from '../../models/tax-summary/tax-summary-type.enum';
+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";
+/**
+ * Service to work with tax summary logic
+ */
+export class TaxSummaryService {
+    constructor(http, eventDispatcherService, environment) {
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.taxSummaryActualsSubject = new ReplaySubject(1);
+        this.taxSummaryForecastsSubject = new ReplaySubject(1);
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenToIncomeSourceForecastsEvents();
+    }
+    /**
+     * Get actual tax summary items
+     */
+    getActuals() {
+        this.http.get(`${this.environment.apiV2}/tax-summary/${TaxSummaryTypeEnum.ACTUALS}`, {})
+            .subscribe((response) => {
+            const taxSummary = plainToClass(TaxSummary, response);
+            this.taxSummaryActualsSubject.next(taxSummary);
+            return taxSummary;
+        });
+        return this.taxSummaryActualsSubject.asObservable();
+    }
+    /**
+     * Get forecast tax summary items
+     */
+    getForecast() {
+        this.http.get(`${this.environment.apiV2}/tax-summary/${TaxSummaryTypeEnum.FORECASTS}`, {})
+            .subscribe((response) => {
+            const taxSummary = plainToClass(TaxSummary, response);
+            this.taxSummaryForecastsSubject.next(taxSummary);
+            return taxSummary;
+        });
+        return this.taxSummaryForecastsSubject.asObservable();
+    }
+    /**
+     * Listen to EventDispatcherService events related to Income source forecasts
+     */
+    listenToIncomeSourceForecastsEvents() {
+        this.eventDispatcherService
+            .on([AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED])
+            .subscribe(() => {
+            this.getForecast().subscribe();
+        });
+    }
+}
+TaxSummaryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxSummaryService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+TaxSummaryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxSummaryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxSummaryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/transaction/transaction-allocation.service.js

@@ -0,0 +1,85 @@
+import { Inject, Injectable } from '@angular/core';
+import { TransactionAllocation } from '../../models/transaction/transaction-allocation';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { BaseRestService } from '../base-rest.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+// @TODO Don't look at the commented code. Will be refactored/removed during TT-1503
+/**
+ * Service for transaction allocations business logic
+ * @TODO alex refactor
+ */
+export class TransactionAllocationService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // API URL param for transaction allocations
+        this.url = 'transactions-allocations';
+        this.modelClass = TransactionAllocation;
+        this.listenEvents();
+    }
+    /**
+     * Add single transaction allocation
+     */
+    add(allocation) {
+        return this.addBatch([allocation]).pipe(map((newAllocations) => newAllocations[0]));
+    }
+    /**
+     * get list of transactions allocations related with passed bank transactions list
+     */
+    getByTransactions(transactions) {
+        const ids = transactions.map((transaction) => transaction.id);
+        return this.get()
+            .pipe(map((transactionAllocations) => {
+            return transactionAllocations.filter((allocation) => ids.includes(allocation.transaction.id));
+        }));
+    }
+    listenEvents() {
+        this.onTransactionsCreated();
+        this.onDepreciationCreated();
+        this.onTransactionDeleted();
+    }
+    /**
+     * Reset cache on transactions created
+     */
+    onTransactionsCreated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.TRANSACTIONS_CREATED).subscribe(() => {
+            // Update allocations cache to synchronize data and fire subscriptions
+            this.resetCache();
+        });
+    }
+    /**
+     * Reset cache on depreciation created
+     */
+    onDepreciationCreated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.DEPRECIATIONS_CREATED).subscribe(() => {
+            // Update allocations cache to synchronize data and fire subscriptions
+            this.resetCache();
+        });
+    }
+    /**
+     * Reset cache on transaction deleted
+     */
+    onTransactionDeleted() {
+        this.eventDispatcherService.on(AppEventTypeEnum.TRANSACTION_DELETED).subscribe(() => {
+            // Update allocations cache to synchronize data and fire subscriptions
+            this.resetCache();
+        });
+    }
+}
+TransactionAllocationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionAllocationService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+TransactionAllocationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionAllocationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionAllocationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/transaction/transaction-calculation.service.js

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { TransactionCollection } from '../../collections/transaction.collection';
+import * as i0 from "@angular/core";
+/**
+ * @TODO move to collection
+ */
+export class TransactionCalculationService {
+    /**
+     * Sum of allocations for passed transactions
+     */
+    getAllocatedAmount(transactions, allocations) {
+        return allocations.getByTransactionsIds(transactions.getIds()).amount;
+    }
+    /**
+     * Check if transaction is allocated
+     */
+    isAllocated(transaction, allocations) {
+        return transaction.getNetAmount() === this.getAllocatedAmount(new TransactionCollection([transaction]), allocations);
+    }
+    /**
+     * Get collection of allocated transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getAllocatedTransactions(transactions, allocations) {
+        return new TransactionCollection(transactions.items.filter((transaction) => {
+            return this.isAllocated(transaction, allocations);
+        }));
+    }
+    /**
+     * Get collection of unallocated transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getUnallocatedTransactions(transactions, allocations) {
+        return new TransactionCollection(transactions.items.filter((transaction) => {
+            return !this.isAllocated(transaction, allocations);
+        }));
+    }
+}
+TransactionCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TransactionCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TransactionCalculationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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