taxtank 0.1.0

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

@@ -0,0 +1,98 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, throwError as observableThrowError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { BankConnection as BankConnectionBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { AppEventTypeEnum, BankConnection, Notification } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+import { HttpErrorResponse } from '@angular/common/http';
+import { Collection } from '../../../../collections';
+import { BankConnectionMessagesEnum } from './bank-connection-messages.enum';
+import { UserEventTypeTypeEnum } from '../../../../db/Enums/user-event-type-type.enum';
+
+/**
+ * BankConnection means user account at specific bank (usually each user has only one at the same bank)
+ * service handles BankConnection management
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankConnectionService extends RestService<BankConnectionBase, BankConnection, Collection<BankConnection>> implements IEventListener {
+  modelClass: typeof BankConnection = BankConnection;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'bank-connections';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'delete', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents() {
+    this.listenNotifications();
+  }
+
+  /**
+   * there is no put BankConnection method, we have to post to update
+   * POST endpoint is using for create and for update.
+   */
+  post(bankConnection: BankConnection): Observable<BankConnection> {
+    return super.post(bankConnection)
+      .pipe(
+        map((result: BankConnection) => {
+          if (result.isBasiq()) {
+            switch (true) {
+              case result.isLoginSuccess():
+                this.toastService.success(BankConnectionMessagesEnum.LOGIN_SUCCESS);
+                break;
+              case result.isAccountsRetrieved():
+                this.toastService.success(BankConnectionMessagesEnum.ACCOUNTS_RETRIEVED);
+                break;
+            }
+          }
+
+          return result;
+        }),
+        catchError((error: HttpErrorResponse) => {
+          // Show error when user provided wrong login data
+          if (error.status === 401) {
+            this.toastService.error(BankConnectionMessagesEnum.INVALID_CREDENTIALS);
+          }
+
+          // Show error when user provided another login (not login he used before)
+          if (error.status === 400) {
+            this.toastService.error(BankConnectionMessagesEnum.WRONG_LOGIN_DATA);
+          }
+
+          if (error.status === 500) {
+            this.toastService.error(BankConnectionMessagesEnum.TEMPORARY_UNAVAILABLE);
+          }
+
+          return observableThrowError(error);
+        })
+      )
+  }
+
+  activate(bankConnection: BankConnection): Observable<BankConnection> {
+    return this.put(bankConnection, `${this.apiUrl}/${bankConnection.id}/activate`);
+  }
+
+  deactivate(bankConnection: BankConnection): Observable<BankConnection> {
+    return this.put(bankConnection, `${this.apiUrl}/${bankConnection.id}/deactivate`);
+  }
+
+  private listenNotifications(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {
+      const events = [
+        UserEventTypeTypeEnum.BASIQ_NEW_ACCOUNTS,
+        UserEventTypeTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE,
+        UserEventTypeTypeEnum.BASIQ_AUTHORIZATION_FAIL,
+      ];
+
+      if (!notification.isRead && events.includes(notification.eventType)) {
+        // @TODO TT-3826 move to unified mercure event
+        this.refreshCache();
+      }
+    });
+  }
+}

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

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

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

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

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

@@ -0,0 +1,81 @@
+import { Inject, Injectable } from '@angular/core';
+import { BankTransaction as BankTransactionBase } from '../../../../db/Models';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { RestMethod, RestService } from '../../rest';
+import { plainToClass } from 'class-transformer';
+import { AppEvent, AppEventTypeEnum, BankTransaction, FinancialYear, Notification } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+import { UserEventTypeTypeEnum } from '../../../../db/Enums/user-event-type-type.enum';
+import { BankTransactionCollection } from '../../../../collections';
+
+/**
+ * Service for bank transactions business logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankTransactionService extends RestService<BankTransactionBase, BankTransaction, BankTransactionCollection> implements IEventListener {
+  endpointUri = 'bank-transactions';
+  modelClass: typeof BankTransaction = BankTransaction;
+  collectionClass: typeof BankTransactionCollection = BankTransactionCollection;
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenBankTransactionsImport();
+  }
+
+  /**
+   * Get list of bank transactions for provided financial year
+   * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years
+   */
+  getByYear(finYear: number): Observable<BankTransaction[]> {
+    return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)
+      .pipe(
+        map((bankTransactionsBase: BankTransactionBase[]) => bankTransactionsBase.map((bankTransaction: BankTransaction) => plainToClass(BankTransaction, bankTransaction)))
+      );
+  }
+
+  /**
+   * import bank transactions from csv file
+   * @param bankAccountId Bank account id we import bank transactions for
+   * @param file File with bank transactions for import
+   */
+  import(bankAccountId: number, file: File): Observable<BankTransaction[]> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)
+      .pipe(
+        map((response: BankTransactionBase[]) => {
+          const result: BankTransaction[] = response
+            .map((baseTransaction: BankTransactionBase) => plainToClass(BankTransaction, baseTransaction))
+            // we are interesting only current fin year bank transactions
+            .filter((bankTransaction: BankTransaction) => new FinancialYear().includes(bankTransaction.date));
+          // push new items to cache only if we already have cache. Otherwise cache will contain only new items.
+          if (this.cache) {
+            this.handleResponse(result, 'post');
+          }
+
+          return result;
+        })
+      );
+  }
+
+  /**
+   * @TODO move to sse when backend send mercure event
+   */
+  private listenBankTransactionsImport(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {
+      if (!notification.isRead && notification.eventType === UserEventTypeTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_TRANSACTIONS_ADDED, []));
+        this.refreshCache();
+      }
+    });
+  }
+}

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

@@ -0,0 +1 @@
+export * from './bank-transaction.service';

package/projects/tt-core/src/lib/services/http/bank/bank-transaction-comment/bank-transaction-comment-messages.enum.ts

@@ -0,0 +1,6 @@
+export enum BankTransactionCommentMessagesEnum {
+  CREATED = 'Note created',
+  UPDATED = 'Note updated',
+  DELETED = 'Note deleted',
+  CONFIRM_DELETE = 'Are you sure you want to delete this note?'
+}

package/projects/tt-core/src/lib/services/http/bank/bank-transaction-comment/bank-transaction-comment.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { BankTransactionComment, BankTransactionCommentInterface } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { Collection } from '../../../../collections';
+
+/**
+ * Service that handling banks logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankTransactionCommentService extends RestService<BankTransactionCommentInterface, BankTransactionComment, Collection<BankTransactionComment>> {
+  modelClass: typeof BankTransactionComment = BankTransactionComment;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'bank-transaction-comments';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

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

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

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

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { Bank as BankBase } from '../../../db/Models';
+import { Bank } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+
+/**
+ * Service that handling banks logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankService extends RestService<BankBase, Bank, Collection<Bank>> {
+  modelClass: typeof Bank = Bank;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'banks';
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/bank/basiq/basiq-messages.enum.ts

@@ -0,0 +1,5 @@
+export enum BasiqMessagesEnum {
+  REVOKE_CONFIRM_TITLE = 'Are you sure you want to revoke consent for bank feeds?',
+  REVOKE_CONFIRM_MESSAGE = 'Revoking consent will stop live feeds and delete all historic bank feed data in TaxTank. This will impede the functionality of both bank feeds and equity graphs. This cannot be undone.',
+  REVOKE_SUCCESS = 'Consent to bank feeds has been revoked.'
+}

package/projects/tt-core/src/lib/services/http/bank/basiq/basiq-token.service.spec.ts

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

package/projects/tt-core/src/lib/services/http/bank/basiq/basiq-token.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { AbstractModel } from '../../../../db/Models';
+import { Observable } from 'rxjs';
+import { BasiqToken } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { Collection } from '../../../../collections';
+
+/**
+ * @TODO Alex shouldn't be a separated service, move to basiqService or interceptor
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BasiqTokenService extends RestService<AbstractModel, BasiqToken, Collection<BasiqToken>> {
+  protected endpointUri = 'basiq/tokens';
+  modelClass: typeof BasiqToken = BasiqToken;
+  collectionClass: typeof Collection = Collection;
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+
+  /**
+   * Access token to use basiq flow
+   */
+  get(): Observable<Collection<BasiqToken>> {
+    if (this.getCacheFirst() && this.getCacheFirst().isExpired()) {
+      this.cache = undefined;
+    }
+
+    return super.get();
+  }
+
+  protected createModelInstance(tokenResponse: AbstractModel): BasiqToken {
+    const now: number = new Date().getTime();
+    return new BasiqToken(tokenResponse['access_token'], new Date(now + tokenResponse['expires_in'] * 1000));
+  }
+}

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

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

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

@@ -0,0 +1,194 @@
+import { Inject, Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import { BankAccount as BankAccountBase } from '../../../../db/Models';
+import { RestMethod, RestService } from '../../rest';
+import { IEventListener } from '../../../../interfaces';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../../../event';
+import { BankConnectionService } from '../bank-connection';
+import { BankAccountCollection } from '../../../../collections';
+import { plainToClass } from 'class-transformer';
+import { UserEventTypeTypeEnum } from '../../../../db/Enums/user-event-type-type.enum';
+import {
+  AppEventTypeEnum,
+  BankAccount, BankConnection, BasiqJobResponse,
+  Notification
+} from '../../../../models';
+import { Observable } from 'rxjs';
+
+/**
+ * @TODO vik move removeBasiq here from connectionService
+ * basiq is a middleman between bank and user
+ * service is responsible for fetching bank related information
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export  class BasiqService extends RestService<BankAccountBase, BankAccount, BankAccountCollection> implements IEventListener {
+  static basiqApiUrl = 'https://au-api.basiq.io';
+  static basiqConsentUrl = 'https://consent.basiq.io/home';
+
+  /**
+   * Basiq does not provide a hook, so we have to check job status manually every x seconds
+   */
+  static retrieveAccountsCheckInterval = 3000;
+
+  /**
+   * How long we will wait accounts retrieving, break after timeout if not retireved
+   */
+  static retrieveAccountsTimeout = 20000;
+
+  /**
+   * Flag shows retrieve accounts time is out
+   */
+  isRetrieveAccountsTimeOut: boolean;
+
+  /**
+   * Timeout for retrieve accounts status checking.
+   * Stop watch retrieve accounts status when time is out.
+   */
+  retrieveAccountsTimer;
+
+  protected endpointUri = 'basiq/accounts';
+  collectionClass: typeof BankAccountCollection = BankAccountCollection;
+  modelClass: typeof BankAccount = BankAccount;
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any,
+    // this inject required to init bank connection service and listen basiq login event
+    private bankConnectionService: BankConnectionService
+  ) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen events from Event Dispatcher service
+   */
+  listenEvents(): void {
+    this.listenNotifications();
+  }
+
+  /**
+   * remove basiq connection to create a new one (because basiq has no update option),
+   * used for upgrade to openBanking and manage shared bank accounts flow
+   */
+  deleteBasiq(connection: BankConnection): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/bank-connections/${connection.id}/remove-basiq`, {})
+      .pipe(
+        map((connection) =>
+          connection
+          // @TODO Alex token should be inside this service
+          // this.redirectToBasiqConsent(token.value, connection.bank.externalId, true);
+        )
+      );
+  }
+
+  revokeConsent(): Observable<any> {
+    return this.http.delete(`${this.environment.apiV2}/basiq/consent`);
+  }
+
+  /**
+   * Open basiq consent ui to allow user to log in to bank
+   * @param token User's basiq token
+   * @param bankId External id of selected bank
+   * @param consentExist
+   */
+  redirectToBasiqConsent(token: string, bankId: string, consentExist = false): void {
+    // keep bank id because we need it after redirect from basiq
+    localStorage.setItem('basiqBankId', bankId);
+    window.location.replace(`${BasiqService.basiqConsentUrl}?token=${token}&institutionId=${bankId}${consentExist ? '&action=connect' : ''}`);
+  }
+
+  /**
+   * redirect to basiq extend consent date to prolong it
+   */
+  extendConsent(token: string): void {
+    window.location.replace(`${BasiqService.basiqConsentUrl}?token=${token}&action=extend`);
+  }
+
+  /**
+   * redirect to basiq extend connection date to prolong it
+   */
+  reauthoriseConnection(token: string, connection: BankConnection): void {
+    let url = `${BasiqService.basiqConsentUrl}?token=${token}&action=reauthorise`;
+    if (connection.isExpiring()) {
+      url += `&connectionId=${connection.externalId}`;
+    }
+    window.location.replace(url);
+  }
+
+  /**
+   * Open basiq consent ui to allow user to manage basiq access to his bank data
+   * @param token User's basiq token
+   */
+  redirectToBasiqRevoke(token: string): void {
+    window.location.replace(`${BasiqService.basiqConsentUrl}?token=${token}&action=manage`);
+  }
+
+  /**
+   * Get Basiq job result
+   */
+  retrieveJob(jobId: string): Observable<BasiqJobResponse> {
+    return this.http.get(`${BasiqService.basiqApiUrl}/jobs/${jobId}`)
+      .pipe(
+        map((response: object) => plainToClass(BasiqJobResponse, response))
+      );
+  }
+
+  /**
+   * @TODO not used, remove?
+   * Recoursive method, watch basiq job retrieve accounts status
+   * @param jobId id of basiq job to check
+   * @returns observable boolean. True - accounts retrieved, false - accounts not retrieved (time is out)
+   */
+  watchBankAccountsRetrieved(jobId: string): Observable<boolean> {
+    // init timeout for the first iteration of recoursion
+    if (!this.retrieveAccountsTimer) {
+      this.isRetrieveAccountsTimeOut = false;
+
+      this.retrieveAccountsTimer = setTimeout(() => {
+        this.isRetrieveAccountsTimeOut = true;
+      }, BasiqService.retrieveAccountsTimeout);
+    }
+
+    return this.retrieveJob(jobId)
+      .pipe(
+        // continue when time is out or when accounts retireved successfully
+        filter((response: BasiqJobResponse) => {
+          // stop watcher when accounts retrieved successfully or time is out
+          if (this.isRetrieveAccountsTimeOut || response.getRetrieveAccountsStep().isSuccess()) {
+            clearTimeout(this.retrieveAccountsTimer);
+            return true;
+          }
+
+          // continue watch retrieve accounts status
+          setTimeout(() => {
+            this.watchBankAccountsRetrieved(jobId);
+          }, BasiqService.retrieveAccountsCheckInterval);
+
+          return false;
+        }),
+        map((response: BasiqJobResponse) => {
+          // no need to keep bank id anymore
+          localStorage.removeItem('basiqBankId');
+
+          return response.getRetrieveAccountsStep().isSuccess();
+        })
+      );
+  }
+
+  /**
+   * listen to notifications to update basiq accounts list
+   */
+  private listenNotifications(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification): void => {
+      if (!notification.isRead && notification.eventType === UserEventTypeTypeEnum.BASIQ_NEW_ACCOUNTS) {
+        this.refreshCache();
+      }
+    });
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './basiq-token.service';
+export * from './basiq.service';
+export * from './basiq-messages.enum';

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

@@ -0,0 +1,7 @@
+export * from './bank-account';
+export * from './bank-connection';
+export * from './bank-transaction';
+export * from './basiq';
+export * from './bank-transaction-comment/bank-transaction-comment.service';
+export * from './bank-transaction-comment/bank-transaction-comment-messages.enum';
+export * from './bank.service';

package/projects/tt-core/src/lib/services/http/budget/budget-messages.enum.ts

@@ -0,0 +1,6 @@
+export enum BudgetMessagesEnum {
+  CREATED = 'Budget created',
+  UPDATED = 'Budget updated',
+  DELETED = 'Budget deleted',
+  CONFIRM_DELETE = 'Are you sure you want to delete budgeting?'
+}

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

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { BudgetRule as BudgetRuleBase } from '../../../../db/Models';
+import { BudgetRule } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { BudgetRuleCollection } from '../../../../collections';
+import { UserRolesEnum } from '../../../../../../common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BudgetRuleService extends RestService<BudgetRuleBase, BudgetRule, BudgetRuleCollection> {
+  modelClass: typeof BudgetRule = BudgetRule;
+  collectionClass: typeof BudgetRuleCollection = BudgetRuleCollection;
+  endpointUri = 'budget-rules';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  roles = [UserRolesEnum.MONEY_TANK];
+}

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

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

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

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { Budget as BudgetBase } from '../../../db/Models';
+import { Budget } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { BudgetCollection } from '../../../collections';
+import { UserRolesEnum } from '../../../../../common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BudgetService extends RestService<BudgetBase, Budget, BudgetCollection> {
+  modelClass: typeof Budget = Budget;
+  collectionClass: typeof BudgetCollection = BudgetCollection;
+  endpointUri = 'budgets';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  roles = [UserRolesEnum.MONEY_TANK];
+}

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

@@ -0,0 +1,3 @@
+export * from './budget.service';
+export * from './budget-messages.enum';
+export * from './budget-rule/budget-rule.service';

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

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

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

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../../rest';
+import { ChartAccountsDepreciation as ChartAccountsDepreciationBase } from '../../../../db/Models';
+import { ChartAccountsDepreciation } from '../../../../models';
+import { Collection } from '../../../../collections';
+
+/**
+ * Service to work with depreciation chart accounts
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChartAccountsDepreciationService extends RestService<ChartAccountsDepreciationBase, ChartAccountsDepreciation, Collection<ChartAccountsDepreciation>> {
+  endpointUri = 'chart-accounts-depreciations';
+  modelClass: typeof ChartAccountsDepreciation = ChartAccountsDepreciation;
+  collectionClass: typeof Collection = Collection;
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+}

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

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

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

@@ -0,0 +1,7 @@
+export enum ChartAccountsMessagesEnum {
+  CREATED = 'Chart accounts created',
+  UPDATED = 'Chart accounts updated',
+  DELETED = 'Chart accounts deleted',
+  DELETE_CONFIRM = 'Are you sure you want to delete chart accounts?',
+  DELETE_ERROR = 'This category has allocated transactions, You’ll need to unallocate these transactions too make changes',
+}