taxtank 0.1.0

package/projects/tt-core/src/lib/services/http/chart-accounts/chart-accounts.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ChartAccountsService } from './chart-accounts.service';
+
+describe('ChartAccountService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: ChartAccountsService = TestBed.get(ChartAccountsService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/chart-accounts/chart-accounts.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChartAccountsCategoryEnum } from '../../../db/Enums';
+import { ChartAccounts as ChartAccountsBase } from '../../../db/Models';
+import { plainToClass } from 'class-transformer';
+import {
+  CHART_ACCOUNTS_CATEGORIES,
+  ChartAccounts,
+  ChartAccountsHeading,
+} from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { ChartAccountsCollection } from '../../../collections';
+
+/**
+ * Chart accounts service
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChartAccountsService extends RestService<ChartAccountsBase, ChartAccounts, ChartAccountsCollection> {
+  protected endpointUri = 'chart-accounts';
+  modelClass: typeof ChartAccounts = ChartAccounts;
+  collectionClass: typeof ChartAccountsCollection = ChartAccountsCollection;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+
+  /**
+   * Get list of chart accounts headings by catogory with chart accounts inside
+   */
+  getChartAccountsHeadings(categories: ChartAccountsCategoryEnum[] = CHART_ACCOUNTS_CATEGORIES.all): Observable<ChartAccountsHeading[]> {
+    return this.get()
+      .pipe(
+        map((chartAccounts: ChartAccountsCollection) => {
+          const filteredChartAccounts: ChartAccounts[] = chartAccounts.toArray()
+            .filter((ca: ChartAccounts) => categories.includes(ca.category));
+
+          const headings: ChartAccountsHeading[] = [];
+
+          filteredChartAccounts.forEach((ca: ChartAccounts) => {
+            let heading: ChartAccountsHeading = headings.find((h: ChartAccountsHeading) => h.id === ca.heading?.id);
+
+            if (!heading) {
+              heading = plainToClass(ChartAccountsHeading, ca.heading);
+              heading.chartAccounts = [];
+              headings.push(heading);
+            }
+
+            heading.chartAccounts.push(ca);
+          });
+
+          return headings;
+        })
+      );
+  }
+}

package/projects/tt-core/src/lib/services/http/chart-accounts/index.ts

@@ -0,0 +1,3 @@
+export * from './chart-accounts-depreciations';
+export * from './chart-accounts.service';
+export * from './chart-accounts-messages.enum';

package/projects/tt-core/src/lib/services/http/chat/chat.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ChatService } from './chat.service';
+
+describe('ChatService', () => {
+  let service: ChatService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ChatService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/chat/chat.service.ts

@@ -0,0 +1,93 @@
+import { Inject, Injectable } from '@angular/core';
+import { Chat as ChatBase } from '../../../db/Models';
+import { RestMethod, RestService } from '../rest';
+import { plainToClass } from 'class-transformer';
+import { Chat, Message } from '../../../models';
+import { ChatCollection } from '../../../collections';
+import { IEventListener } from '../../../interfaces';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+/**
+ * Service for work with chats
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChatService extends RestService<ChatBase, Chat, ChatCollection> implements IEventListener {
+  modelClass: typeof Chat = Chat;
+  collectionClass: typeof ChatCollection = ChatCollection;
+  endpointUri = 'chats';
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents() {
+    this.listenChats();
+    this.listenMessages();
+  }
+
+  get(path: string = this.apiUrl): Observable<ChatCollection> {
+    // users contact ttAdvisor through intercom support
+    return super.get(path).pipe(
+      map((chats) => chats.filter((chat) => chat.employee.email !== this.environment.ttAdvisor))
+    );
+  }
+
+  /**
+   * @TODO refactor with listenSSE method
+   */
+  listenChats(): void {
+    this.sseService.on(`chats`).subscribe((chatBase: ChatBase): void => {
+      const array: Chat[] = this.cache.toArray();
+      // chat instance from event
+      const eventChat: Chat = plainToClass(Chat, chatBase);
+      // chat instance from cache
+      const cachedChat: Chat = array.find((chat: Chat): boolean => chat.id === eventChat.id);
+
+      switch (true) {
+        // add new chat
+        case (!cachedChat):
+          this.handleResponse([eventChat], 'post');
+          break;
+
+        // remove deactivated chat
+        case !eventChat.isActive():
+          this.handleResponse([eventChat], 'delete');
+          break;
+
+        // update chat with new firm (reassign)
+        case eventChat.employee.id !== cachedChat.employee.id:
+          this.handleResponse([eventChat], 'put');
+          break;
+
+        // @TODO typing works bad with mat-tabs on user-area. Need to refactor typing functionality
+        // update cache with typing user
+        // default:
+        // cachedChat.typingUsers.push(new User(eventChat.typingUser));
+        // replace(cache, _.clone(cachedChat));
+      }
+    });
+  }
+
+  /**
+   * Update chat's 'updatedAt' field with the last chat's message date for chat list sorting
+   */
+  private listenMessages(): void {
+    this.listenCSE(Message, (messages: Message[]) => {
+      const message: Message = messages[0];
+      const cache: Chat[] = this.cache.toArray();
+      const updatedChat: Chat = cache.find((chat: Chat): boolean => chat?.id === message.chat?.id);
+      if (!updatedChat || !cache.indexOf(updatedChat)) {
+        return;
+      }
+
+      // sort chats by the last message date
+      cache.unshift(cache.splice(cache.indexOf(updatedChat), 1)[0]);
+      this.setCache(cache, true);
+    }, ['post']);
+  }
+}

package/projects/tt-core/src/lib/services/http/chat/index.ts

@@ -0,0 +1,3 @@
+export * from './chat.service';
+export * from './message.service';
+export * from './message-document.service';

package/projects/tt-core/src/lib/services/http/chat/message-document.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { MessageDocumentService } from './message-document.service';
+
+describe('MessageDocumentService', () => {
+  let service: MessageDocumentService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(MessageDocumentService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/chat/message-document.service.ts

@@ -0,0 +1,89 @@
+import { Inject, Injectable } from '@angular/core';
+import { MessageDocument as MessageDocumentBase } from '../../../db/Models';
+import { Observable, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { IEventListener } from '../../../interfaces';
+import { plainToClass } from 'class-transformer';
+import { Message, MessageDocument } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { MessageDocumentCollection } from '../../../collections';
+
+/**
+ * Service for work with Message Documents
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageDocumentService extends RestService<MessageDocumentBase, MessageDocument, MessageDocumentCollection> implements IEventListener {
+  modelClass: typeof MessageDocument = MessageDocument;
+  collectionClass: typeof MessageDocumentCollection = MessageDocumentCollection;
+  endpointUri = 'message-documents';
+  disabledMethods: RestMethod[] = ['postBatch', 'deleteBatch', 'put', 'putBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * SSE and Event Dispatcher Services listeners
+   */
+  listenEvents(): void {
+    this.listenMessages();
+  }
+
+  /**
+   * listen new messages event to update documents cache
+   */
+  listenMessages(): void {
+    this.listenCSE(Message, (messages: Message[]) => {
+      const message: Message = messages[0];
+
+      if (message.documents?.length) {
+        const array: MessageDocument[] = this.cache.toArray();
+        const documentsIds: number[] = this.cache.getIds();
+
+        message.documents.forEach((document: MessageDocument): void => {
+          document.chat = message.chat;
+
+          if (!documentsIds.includes(document.id)) {
+            array.push(document);
+          }
+        });
+
+        this.cache = new MessageDocumentCollection(array);
+        this.cacheSubject.next(this.cache);
+      }
+    }, ['post']);
+  }
+
+  /**
+   * Upload file to chat
+   */
+  add(chatId: number, file: File): Observable<MessageDocument> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+    formData.append('chat', chatId.toString());
+
+    return this.http.post(`${this.apiUrl}`, formData)
+      .pipe(
+        map((documentBase: MessageDocumentBase): MessageDocument => {
+          const document: MessageDocument = plainToClass(MessageDocument, documentBase);
+          this.handleResponse([document], 'post');
+
+          return document;
+        })
+      );
+  }
+
+  /**
+   * Upload multiple files to chat
+   */
+  addBatch(chatId: number, files: File[]): Observable<MessageDocument[]> {
+    return combineLatest(
+      files.map((file: File): Observable<MessageDocument> => this.add(chatId, file))
+    ).pipe(
+      map((docsBase: MessageDocumentBase[]): MessageDocument[] => docsBase.map((docBase: MessageDocumentBase): MessageDocument => plainToClass(MessageDocument, docBase)))
+    );
+  }
+}

package/projects/tt-core/src/lib/services/http/chat/message.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { MessageService } from './message.service';
+
+describe('MessageService', () => {
+  let service: MessageService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(MessageService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/chat/message.service.ts

@@ -0,0 +1,35 @@
+import { Inject, Injectable } from '@angular/core';
+import { Message as MessageBase } from '../../../db/Models';
+import { Message } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { MessageCollection } from '../../../collections';
+import { IEventListener } from '../../../interfaces';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+/**
+ * Service for work with messages
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageService extends RestService<MessageBase, Message, MessageCollection> implements IEventListener {
+  modelClass: typeof Message = Message;
+  collectionClass: typeof MessageCollection = MessageCollection;
+  endpointUri = 'messages';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch'];
+  mercureTopic = 'messages';
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents() {
+    this.listenSSE();
+  }
+
+  getUnreadChatsAmount(): Observable<number> {
+    return this.get().pipe(map((messages) => messages.getUnreadChatsAmount()));
+  }
+}

package/projects/tt-core/src/lib/services/http/client/annual-client-details.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { AnnualClientDetails as AnnualClientDetailsBase } from '../../../db/Models';
+import { AnnualClientDetails } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AnnualClientDetailsService extends RestService<AnnualClientDetailsBase, AnnualClientDetails, Collection<AnnualClientDetails>> {
+  modelClass: typeof AnnualClientDetails = AnnualClientDetails;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'annual-client-details';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch', 'delete'];
+}

package/projects/tt-core/src/lib/services/http/client/capital-loss/capital-loss-messages.enum.ts

@@ -0,0 +1,5 @@
+export enum CapitalLossMessagesEnum {
+  POST = 'Capital loss created',
+  PUT = 'capital loss updated',
+  DELETE = 'capital loss deleted'
+}

package/projects/tt-core/src/lib/services/http/client/capital-loss/capital-loss.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../../rest';
+import { Collection } from '../../../../collections';
+import { CapitalLoss, CapitalLossInterface } from '../../../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CapitalLossService extends RestService<CapitalLossInterface, CapitalLoss, Collection<CapitalLoss>> {
+  protected endpointUri = 'capital-losses';
+  modelClass: typeof CapitalLoss = CapitalLoss;
+  collectionClass: typeof Collection<CapitalLoss> = Collection<CapitalLoss>;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/client/capital-loss/index.ts

@@ -0,0 +1,2 @@
+export * from './capital-loss.service';
+export * from './capital-loss-messages.enum';

package/projects/tt-core/src/lib/services/http/client/client-coupon.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ClientCouponService } from './client-coupon.service';
+
+describe('ClientCouponService', () => {
+  let service: ClientCouponService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ClientCouponService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/client/client-coupon.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../rest';
+import { ServicePromoCode } from '../../../models';
+import { Collection } from '../../../collections';
+
+/**
+ * discount coupon, applied automatically to the first subscription,
+ * can be received through registration referral campaigns
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ClientCouponService extends RestService<ServicePromoCode, ServicePromoCode, Collection<ServicePromoCode>> {
+  modelClass: typeof ServicePromoCode = ServicePromoCode;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'users/current/promo-code';
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/client/index.ts

@@ -0,0 +1,4 @@
+export * from './annual-client-details.service';
+export * from './occupation/occupation.service';
+export * from './client-coupon.service';
+export * from './capital-loss';

package/projects/tt-core/src/lib/services/http/client/occupation/occupation.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { OccupationService } from './occupation.service';
+
+describe('OccupationService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: OccupationService = TestBed.get(OccupationService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/client/occupation/occupation.service.ts

@@ -0,0 +1,40 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { Occupation } from '../../../../models/user/occupation';
+
+/**
+ * Service that works with Occupations
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class OccupationService {
+  _occupations: Occupation[];
+  occupationsSubject: ReplaySubject<Occupation[]> = new ReplaySubject<Occupation[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) { }
+
+  /**
+   * Get list of occupations
+   */
+  getOccupations(): Observable<Occupation[]> {
+    if (!this._occupations) {
+      this.http.get(`${this.environment.apiV2}/occupations`)
+        .pipe(
+          map((response: any) => response.map((item: object) => plainToClass(Occupation, item)))
+        )
+        .subscribe((occupations: Occupation[]) => {
+          this._occupations = occupations;
+          this.occupationsSubject.next(occupations);
+        });
+    }
+
+    return this.occupationsSubject.asObservable();
+  }
+}

package/projects/tt-core/src/lib/services/http/depreciation/depreciation-capital-project/depreciation-capital-project.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DepreciationCapitalProjectService } from './depreciation-capital-project.service';
+
+describe('DepreciationCapitalProjectsService', () => {
+  let service: DepreciationCapitalProjectService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DepreciationCapitalProjectService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/depreciation/depreciation-capital-project/depreciation-capital-project.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { DepreciationCapitalProject as DepreciationCapitalProjectBase } from '../../../../db/Models/depreciation/depreciation-capital-project';
+import { DepreciationCapitalProject } from '../../../../models';
+import { Collection } from '../../../../collections';
+import { RestMethod, RestService } from '../../rest';
+
+/**
+ * Service for work with DepreciationCapitalProjects
+ * @TODO Alex: refactor with new rest when backend ready (TT-3571)
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DepreciationCapitalProjectService extends RestService<DepreciationCapitalProjectBase, DepreciationCapitalProject, Collection<DepreciationCapitalProject>> {
+  modelClass: typeof DepreciationCapitalProject = DepreciationCapitalProject;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'depreciation-capital-projects';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/depreciation/depreciation-capital-project/index.ts

@@ -0,0 +1 @@
+export * from './depreciation-capital-project.service';

package/projects/tt-core/src/lib/services/http/depreciation/depreciation.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DepreciationService } from './depreciation.service';
+
+describe('DepreciationService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: DepreciationService = TestBed.get(DepreciationService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/depreciation/depreciation.service.ts

@@ -0,0 +1,119 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Depreciation as DepreciationBase } from '../../../db/Models';
+import { map } from 'rxjs/operators';
+import { RestMethod, RestService } from '../rest';
+import {
+  AppEventTypeEnum,
+  BankAccount,
+  Depreciation, DepreciationCapitalProject,
+  FinancialYear,
+  Loan, VehicleClaim
+} from '../../../models';
+import { DepreciationCollection } from '../../../collections';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../../event';
+import { IEventListener } from '../../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DepreciationService extends RestService<DepreciationBase, Depreciation, DepreciationCollection> implements IEventListener{
+  modelClass: typeof Depreciation = Depreciation;
+  collectionClass: typeof DepreciationCollection = DepreciationCollection;
+  endpointUri = 'depreciations';
+  disabledMethods: RestMethod[] = ['post', 'putBatch', 'deleteBatch'];
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Depreciations events
+   */
+  listenEvents(): void {
+    this.listenToUpdatedLoan();
+    this.listenLoanPayout();
+    this.listenVehicleClaimChanges();
+    this.listenToUpdatedBankAccount();
+    this.listenSoleDepreciationMethodChanges();
+    this.listenPropertyDepreciationCalculationChanges();
+    this.listenCSE(DepreciationCapitalProject, this.refreshCache, ['put']);
+  }
+
+  getOpenBalance(depreciation: Depreciation): Observable<number> {
+    return this.http.post(`${this.apiUrl}/opening-balance?financialYear=${new FinancialYear().year}`, depreciation)
+      .pipe(
+        map((response: number) => response || 0)
+      );
+  }
+
+  /**
+   * loan payout triggers depreciation writeOff event for borrowingExpenses
+   */
+  private listenLoanPayout(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.LOAN_PAYOUT_UPDATED]).subscribe(() => {
+      this.refreshCache();
+    });
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated bank loan
+   */
+  private listenToUpdatedLoan(): void {
+    this.listenCSE(Loan, this.refreshCache, ['put']);
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated bank account
+   */
+  private listenToUpdatedBankAccount(): void {
+    this.listenCSE(BankAccount, (bankAccounts: BankAccount[]) => {
+      if (bankAccounts.find(ba => ba.isPropertyTank())) {
+        this.refreshCache();
+      }
+    }, ['put']);
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated vehicle claim
+   */
+  private listenVehicleClaimChanges(): void {
+    this.eventDispatcherService.on2(...VehicleClaim.getEventNames('post', 'put')).subscribe(() => this.refreshCache());
+    this.eventDispatcherService.on([
+      AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED
+    ]).subscribe(() => {
+      this.refreshCache();
+    })
+  }
+
+  /**
+   * @TODO Alex: create common method resetCacheOn(events: AppEventType[])
+   */
+  private listenSoleDepreciationMethodChanges(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.SOLE_DEPRECIATION_METHOD_UPDATED).subscribe(() => {
+      this.refreshCache();
+    })
+  }
+
+  /**
+   * @TODO Alex: create common method resetCacheOn(events: AppEventType[])
+   */
+  private listenPropertyDepreciationCalculationChanges(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_DEPRECIATION_CALCULATION_UPDATED).subscribe(() => {
+      this.refreshCache();
+    });
+  }
+
+  private listenTransactions(): void {
+    // @TODO reset cache only when required (transaction has depreciation)
+    this.eventDispatcherService.on(AppEventTypeEnum.TRANSACTION_DELETED).subscribe(() => {
+      this.refreshCache();
+    });
+  }
+}

package/projects/tt-core/src/lib/services/http/depreciation/index.ts

@@ -0,0 +1,2 @@
+export * from './depreciation.service';
+export * from './depreciation-capital-project';