taxtank 0.1.0

package/projects/tt-core/src/lib/models/user-event/user-event-type.ts

@@ -0,0 +1,24 @@
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user/user-event-type';
+import { UserEventTypeCategory } from './user-event-type-category';
+import { UserEventSetting } from './user-event-setting';
+import { Type, plainToClass } from 'class-transformer';
+import { LoanInterestTypeEnum, LoanInterestTypeLabelEnum } from '../../db/Enums/bank/loan';
+import { UserEventTypeFrequencyEnum } from '../../db/Enums/user-event-type-frequency.enum';
+
+export class UserEventType extends UserEventTypeBase {
+  @Type(() => UserEventTypeCategory)
+  category: UserEventTypeCategory;
+
+  toSetting(): UserEventSetting {
+    return plainToClass(UserEventSetting, {
+      byEmail: this.byEmail,
+      byNotification: this.byNotification,
+      frequency: this.frequency,
+      type: this,
+    });
+  }
+
+  get frequencyLabel(): string {
+    return this.frequency ? UserEventTypeFrequencyEnum[UserEventTypeFrequencyEnum[this.frequency]] : null;
+  }
+}

package/projects/tt-core/src/lib/models/vehicle/index.ts

@@ -0,0 +1,4 @@
+export * from './vehicle';
+export * from './vehicle-claim';
+export * from './vehicle-claim-details';
+export * from './vehicle-logbook';

package/projects/tt-core/src/lib/models/vehicle/vehicle-claim-details.ts

@@ -0,0 +1,25 @@
+import { VehicleClaimDetails as VehicleClaimDetailsBase } from '../../db/Models/vehicle/vehicle-claim-details';
+import { Type } from 'class-transformer';
+import { User } from '../user';
+import { VehicleClaimDetailsMethodEnum } from '../../db/Enums/vehicle-claim-details-method.enum';
+import { FinancialYear } from '../financial-year';
+
+export class VehicleClaimDetails extends VehicleClaimDetailsBase {
+  /**
+   * Init default values for the new instances
+   */
+  isManual = true;
+  method: VehicleClaimDetailsMethodEnum;
+  financialYear: number = new FinancialYear().year;
+
+  @Type(() => User)
+  user: User;
+
+  isLogbookMethod(): boolean {
+    return this.method === VehicleClaimDetailsMethodEnum.LOGBOOK;
+  }
+
+  isKmsMethod(): boolean {
+    return this.method === VehicleClaimDetailsMethodEnum.KMS;
+  }
+}

package/projects/tt-core/src/lib/models/vehicle/vehicle-claim.ts

@@ -0,0 +1,68 @@
+import { VehicleClaim as VehicleClaimBase } from '../../db/Models/vehicle/vehicle-claim';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { Type } from 'class-transformer';
+import { TransactionCollection } from '../../collections';
+import { VehicleClaimDetails } from './vehicle-claim-details';
+import { SoleBusiness } from '../sole';
+import { FinancialYear } from '../financial-year';
+import round from 'lodash/round';
+
+export class VehicleClaim extends VehicleClaimBase {
+  /**
+   * limit for kms claim method
+   */
+  static totalKmsLimit = 5000;
+
+  /**
+   * limit for work usage claim method
+   */
+  static totalWorkUsagePercent = 100;
+
+  @Type(() => VehicleClaimDetails)
+  details: VehicleClaimDetails;
+
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  kilometers = 0;
+  workUsage = 0;
+
+  isWorkTank(): boolean {
+    return !this.business;
+  }
+
+  isSoleTank(): boolean {
+    return !!this.business;
+  }
+
+  get tankType(): TankTypeEnum {
+    return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
+  }
+
+  /**
+   * Claim amount for KMs method. Exists only for KMs method.
+   */
+  getKMSClaimAmount(vehicleClaimRate: number): number {
+    return round(this.kilometers * vehicleClaimRate, 2);
+  }
+
+  /**
+   * Get logbook claim amount. Exists only for logbook method.
+   * ClaimAmount = WorkUsage * transaction/depreciation amount
+   */
+  getLogbookClaimAmount(transactions: TransactionCollection): number {
+
+    const transactionsAmount: number = transactions
+      .getByVehicleClaim(this)
+      .getLogbookTransactions()
+      .getTaxable()
+      .sumBy('amount');
+
+    // Math.abs because amount will be negative (because we sum expenses), but we don't want negative percent value
+    return Math.abs(transactionsAmount) * (this.workUsage / 100);
+  }
+
+  getAverageWeeklyKMS(): number {
+    return this.kilometers / FinancialYear.weeksInYear;
+  }
+}

package/projects/tt-core/src/lib/models/vehicle/vehicle-logbook.ts

@@ -0,0 +1,29 @@
+import { VehicleLogbook as VehicleLogbookBase } from '../../db/Models/vehicle/vehicle-logbook';
+import { Type } from 'class-transformer';
+import { SoleBusiness } from '../sole';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { TransformDate } from '../../transformer/transformDate';
+
+export class VehicleLogbook extends VehicleLogbookBase {
+  @Type(() => Date)
+  @TransformDate()
+  date: Date;
+
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  get kilometers(): number {
+    return this.odometerEnd - this.odometerStart;
+  }
+
+  get tankType(): TankTypeEnum {
+    switch (true) {
+      case !!this.business:
+        return TankTypeEnum.SOLE;
+      case this.isPersonal:
+        return TankTypeEnum.PERSONAL;
+      default:
+        return TankTypeEnum.WORK;
+    }
+  }
+}

package/projects/tt-core/src/lib/models/vehicle/vehicle.ts

@@ -0,0 +1,8 @@
+import { Vehicle as VehicleBase } from '../../db/Models/vehicle/vehicle';
+import { VehicleLogbook } from './vehicle-logbook';
+import { Type } from 'class-transformer';
+
+export class Vehicle extends VehicleBase {
+  @Type(() => VehicleLogbook)
+    logbook: VehicleLogbook[];
+}

package/projects/tt-core/src/lib/pipes/app-currency.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+
+/**
+ * extended version of currency pipe
+ */
+@Pipe({
+  name: 'appCurrency',
+  standalone: true,
+})
+export class AppCurrencyPipe extends CurrencyPipe implements PipeTransform {
+  transform(value?: number | string | null, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): any {
+    // 2 non-zero decimals by default (43.43344 => 43.43, 0.0000114201553151 => $0.000011)
+    digitsInfo = digitsInfo ?? '1.0-' + (value.toString().match(/[1-9]/)?.index || 2);
+
+    return super.transform(value, currencyCode, display, digitsInfo, locale);
+  }
+}

package/projects/tt-core/src/lib/pipes/app-percent.pipe.ts

@@ -0,0 +1,14 @@
+import { Pipe, PipeTransform, inject } from '@angular/core';
+import { PercentagePipe as BasePercentagePipe } from 'ngx-pipes';
+
+@Pipe({
+  name: 'percentage',
+  standalone: true,
+})
+export class AppPercentPipe implements PipeTransform {
+  private percentagePipe = inject(BasePercentagePipe);
+
+  transform(value: number, total?: number, floor?: boolean): string {
+    return this.percentagePipe.transform(value, total, floor) + '%';
+  }
+}

package/projects/tt-core/src/lib/pipes/index.ts

@@ -0,0 +1,4 @@
+export * from './app-currency.pipe';
+export * from './app-percent.pipe';
+export * from './relative-date.pipe';
+export * from './safe-url.pipe';

package/projects/tt-core/src/lib/pipes/relative-date.pipe.ts

@@ -0,0 +1,30 @@
+import { Pipe, PipeTransform, inject } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import moment from 'moment';
+import { DateFormatsEnum } from '../db/Enums'
+
+@Pipe({
+  name: 'relativeDate',
+  standalone: true,
+})
+export class RelativeDatePipe implements PipeTransform {
+  private datePipe = inject(DatePipe);
+
+  transform(rawDate: Date): string {
+    if (!rawDate) {
+      return '';
+    }
+
+    const date = moment(rawDate).startOf('day');
+    const today = moment().startOf('day');
+
+    switch (date.diff(today, 'days')) {
+      case 0:
+        return 'Today';
+      case 1:
+        return 'Tomorrow';
+      default:
+        return this.datePipe.transform(date.toDate(), DateFormatsEnum.DATE_SLASH);
+    }
+  }
+}

package/projects/tt-core/src/lib/pipes/safe-url.pipe.ts

@@ -0,0 +1,14 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+
+@Pipe({
+  name: 'safeUrl',
+  standalone: true,
+})
+export class SafeUrlPipe implements PipeTransform {
+  constructor(private sanitizer: DomSanitizer) {}
+
+  transform(url: string): SafeResourceUrl {
+    return this.sanitizer.bypassSecurityTrustResourceUrl(url);
+  }
+}

package/projects/tt-core/src/lib/resolvers/business/business.resolver.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SoleDetails } from '../../models';
+import { SoleDetailsService } from '../../services';
+
+@Injectable({ providedIn: 'root' })
+export class BusinessResolver {
+  constructor(private soleDetailsService: SoleDetailsService) {}
+  resolve(): Observable<SoleDetails> {
+    return this.soleDetailsService.getFirst();
+  }
+}

package/projects/tt-core/src/lib/resolvers/business/sole-details.resolver.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SoleDetails } from '../../models';
+import { SoleDetailsService } from '../../services';
+import { Collection } from '../../collections';
+
+@Injectable({ providedIn: 'root' })
+export class SoleDetailsResolver {
+  constructor(private soleDetails: SoleDetailsService) {}
+  resolve(): Observable<SoleDetails> {
+    return this.soleDetails.getFirst();
+  }
+}

package/projects/tt-core/src/lib/resolvers/index.ts

@@ -0,0 +1,3 @@
+export * from './business/business.resolver';
+export * from './business/sole-details.resolver';
+

package/projects/tt-core/src/lib/services/account-setup/account-setup.service.spec.ts

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

package/projects/tt-core/src/lib/services/account-setup/account-setup.service.ts

@@ -0,0 +1,304 @@
+import { Injectable, inject } from '@angular/core';
+import {
+  AccountSetupItem,
+  AccountSetupItemStatusEnum,
+  AccountSetupItemsEnum,
+  BankAccount,
+  Depreciation,
+  Firm,
+  HomeOfficeClaim,
+  IncomeSource,
+  Property,
+  SharesightDetails,
+  SoleBusiness, TransactionAllocation, User, VehicleClaim
+} from '../../models';
+import {
+  AllocationRuleService,
+  BankAccountService,
+  BankConnectionService, BankTransactionService,
+  BudgetRuleService,
+  ClientInviteService,
+  ClientMovementService,
+  DepreciationService,
+  EmployeeInviteService,
+  EmployeeService,
+  FinancialGoalService,
+  FirmService,
+  HoldingTradeService,
+  HomeOfficeClaimService,
+  IncomeSourceService,
+  LoanService,
+  PropertyService,
+  PropertyShareService,
+  SharesightDetailsService,
+  SoleBusinessService,
+  TransactionAllocationService,
+  TransactionService,
+  UserService,
+  VehicleClaimService
+} from '../http';
+import {
+  AccountSetupItemCollection,
+  IncomeSourceCollection,
+  TransactionAllocationCollection,
+  TransactionCollection
+} from '../../collections';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { SetupItemService } from '../http/setup-item/setup-item.service';
+import { AbstractModel } from '../../db/Models';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import pick from 'lodash/pick';
+import { ChartAccountsListEnum } from '../../db/Enums';
+
+/**
+ * Service handling user's account setup process.
+ * Checks required steps and their completion
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class AccountSetupService {
+  items: AccountSetupItemCollection;
+  user: User;
+
+  private setupItemService = inject(SetupItemService);
+  private propertyService = inject(PropertyService);
+  private incomeSourceService = inject(IncomeSourceService);
+  private bankConnectionService = inject(BankConnectionService);
+  private bankAccountsService = inject(BankAccountService);
+  private bankTransactionService = inject(BankTransactionService);
+  private loanService = inject(LoanService);
+  private allocationRuleService = inject(AllocationRuleService);
+  private transactionAllocationService = inject(TransactionAllocationService);
+  private vehicleClaimService = inject(VehicleClaimService);
+  private homeOfficeClaimService = inject(HomeOfficeClaimService);
+  private transactionService = inject(TransactionService);
+  private depreciationService = inject(DepreciationService);
+  private businessService = inject(SoleBusinessService);
+  private holdingService = inject(HoldingTradeService);
+  private userService = inject(UserService);
+  private clientMovementService = inject(ClientMovementService);
+  private clientInviteService = inject(ClientInviteService);
+  private employeeService = inject(EmployeeService);
+  private employeeInviteService = inject(EmployeeInviteService);
+  private firmService = inject(FirmService);
+  private sharesightDetailsService = inject(SharesightDetailsService);
+  private propertyShareService = inject(PropertyShareService);
+  private budgetRuleService = inject(BudgetRuleService);
+  private financialGoalService= inject(FinancialGoalService);
+
+  /**
+   * Get list of account setup items for current user/firm
+   */
+  get(property?: Property, business?: SoleBusiness, bankAccount?: BankAccount): Observable<AccountSetupItemCollection> {
+    // @TODO it takes time for user to update, makes sense to subscribe to serviceSubscription instead
+    return combineLatest([this.setupItemService.get(), this.userService.getFirst()]).pipe(
+      switchMap(([items, user]) => {
+        this.user = user;
+        this.items = items.getByUser(user);
+
+        return this.setItemsStatus(property, business, bankAccount);
+      })
+    );
+  }
+
+  setItemsStatus(property?: Property, business?: SoleBusiness, bankAccount?: BankAccount): Observable<AccountSetupItemCollection> {
+    const itemsById = this.items.indexBy('id');
+    let requests = {
+      // firm
+      [AccountSetupItemsEnum.FIRM_DETAILS]: this.getFirms(),
+      [AccountSetupItemsEnum.FIRM_EMPLOYEES]: this.getEmployees(),
+      [AccountSetupItemsEnum.FIRM_CLIENTS]: this.getClients(),
+      // work
+      [AccountSetupItemsEnum.WORK_SALARY]: this.getIncomeSources(true),
+      [AccountSetupItemsEnum.WORK_OTHER_INCOME]: this.getIncomeSources(false),
+      [AccountSetupItemsEnum.WORK_VEHICLE_CLAIM]: this.getVehicleClaims(),
+      [AccountSetupItemsEnum.WORK_HOME_OFFICE]: this.getHomeOfficeClaims(),
+      [AccountSetupItemsEnum.WORK_BANK_ACCOUNT]: this.getBankAccounts(TankTypeEnum.WORK),
+      [AccountSetupItemsEnum.WORK_DEPRECIATION]: this.getDepreciations(TankTypeEnum.WORK),
+      // properties
+      [AccountSetupItemsEnum.PROPERTY]: this.propertyService.getArray(),
+      [AccountSetupItemsEnum.PROPERTIES]: this.propertyService.getArray().pipe(map(properties => properties.slice(1))),
+      [AccountSetupItemsEnum.PROPERTIES_BANK_ACCOUNT]: this.getBankAccounts(TankTypeEnum.PROPERTY),
+      // businesses
+      [AccountSetupItemsEnum.SOLE_BUSINESS]: this.businessService.getArray(),
+      [AccountSetupItemsEnum.SOLE_BANK_ACCOUNT]: this.getBankAccounts(TankTypeEnum.SOLE),
+      // holdings
+      [AccountSetupItemsEnum.HOLDING_TRADE]: this.holdingService.getArray(),
+      [AccountSetupItemsEnum.HOLDING_INTEGRATION]: this.getSharesightDetails(true),
+      // bankAccounts
+      [AccountSetupItemsEnum.BANK_CONNECTION]: this.bankConnectionService.getArray(),
+      [AccountSetupItemsEnum.BANK_ACCOUNT]: this.getBankAccounts(),
+      // money tank
+      [AccountSetupItemsEnum.MONEY_BANK_ACCOUNT]: this.getBankAccounts(),
+      [AccountSetupItemsEnum.MONEY_EXPENSE_BUDGETS]: this.budgetRuleService.get().pipe(map(
+        rules => rules.expenses
+      )),
+      [AccountSetupItemsEnum.MONEY_INCOME_BUDGETS]: this.budgetRuleService.get().pipe(map(
+        rules => rules.incomes
+      )),
+      [AccountSetupItemsEnum.MONEY_GOALS]: this.financialGoalService.get(),
+    };
+    // property
+    if (property) {
+      requests[AccountSetupItemsEnum.PROPERTY_CAPITAL_COST] = this.propertyService.getBy('id', property.id).pipe(map(
+        properties => properties.filter(property => !!property.capitalCosts)
+      ));
+      requests[AccountSetupItemsEnum.PROPERTY_RENT_INCOME] = this.getTransactions(property.id).pipe(map(
+        transactions => new TransactionCollection(transactions).filterBy('chartAccounts.id', ChartAccountsListEnum.RENTAL_INCOME)
+      ));
+      requests[AccountSetupItemsEnum.PROPERTY_DEPRECIATION] = this.getDepreciations(TankTypeEnum.PROPERTY, property.id);
+      requests[AccountSetupItemsEnum.PROPERTY_CO_OWNER] = this.getCoOwners(property.id);
+    }
+    // business
+    if (business) {
+      requests[AccountSetupItemsEnum.SOLE_VEHICLE_CLAIM] = this.getVehicleClaims(business.id);
+      requests[AccountSetupItemsEnum.SOLE_HOME_OFFICE] = this.getHomeOfficeClaims(business.id);
+      requests[AccountSetupItemsEnum.SOLE_DEPRECIATION] = this.getDepreciations(TankTypeEnum.SOLE, business.id);
+      requests[AccountSetupItemsEnum.SOLE_LOGO] = this.businessService.getBy('id', business.id).pipe(map(
+        businesses => businesses.filter(business => !!business.file)
+      ));
+    }
+    // bankAccount
+    if (bankAccount) {
+      requests[AccountSetupItemsEnum.BANK_TRANSACTION] = this.bankTransactionService.get().pipe(
+        map(transactions => transactions.filterBy('bankAccount.id', bankAccount.id))
+      );
+      requests[AccountSetupItemsEnum.BANK_ALLOCATION] = this.getAllocations(bankAccount.id);
+      requests[AccountSetupItemsEnum.BANK_RULE] = this.allocationRuleService.get().pipe(
+        map(rules => rules.filterBy('bankAccount.id', bankAccount.id))
+      );
+      if (bankAccount.loan) {
+        requests[AccountSetupItemsEnum.BANK_BORROWING_EXPENSE] = this.loanService.get().pipe(
+          map(loans => loans.filterBy('bankAccount.id', bankAccount.id).filter(loan => !!loan.borrowingExpenses.length))
+        );
+      }
+    }
+    requests = pick(requests, this.items.getIds());
+
+    const batch = Object.keys(requests).map(id => this.setItemStatus(itemsById.get(id), requests[id]));
+    if (!batch.length) {
+      return of(new AccountSetupItemCollection([]));
+    }
+
+    return combineLatest(batch).pipe(map((items: AccountSetupItem[]) => new AccountSetupItemCollection(items).sortBy('order', 'asc')));
+  }
+
+  /**
+   * Check and update isCompleted flag for passed item
+   */
+  private setItemStatus(item: AccountSetupItem, request: Observable<AbstractModel[]>): Observable<AccountSetupItem> {
+    return request.pipe(
+      map((result: object[]): AccountSetupItem => {
+        const isSkipped = !!this.user.blacklistSetupItems.find((skippedItem: AccountSetupItem) => skippedItem.id === item.id);
+        item.status = isSkipped ? AccountSetupItemStatusEnum.SKIPPED : result.length ? AccountSetupItemStatusEnum.ACHIEVED : AccountSetupItemStatusEnum.PENDING;
+
+        return item;
+      })
+    );
+  }
+
+  private getAllocations(bankAccountId: number): Observable<TransactionAllocation[]> {
+    return combineLatest([this.bankTransactionService.get(), this.transactionAllocationService.get()]).pipe(
+      map(([bankTransactions, allocations]) => {
+        const bankTransactionsIds = bankTransactions.filterBy('bankAccount.id', bankAccountId).getIds();
+        return new TransactionAllocationCollection(allocations).getByBankTransactionsIds(bankTransactionsIds).toArray();
+      }));
+  }
+
+  private getTransactions(propertyId: number) {
+    return this.transactionService.getByPropertyId(propertyId);
+  }
+
+  private getCoOwners(propertyId: number) {
+    return this.propertyShareService.getArrayBy('property.id', propertyId).pipe(map(
+      shares => shares.slice(1)
+    ));
+  }
+
+  /**
+   * AccountSetupItemsEnum.FIRM_CLIENTS completed when client invites sent or accepted
+   */
+  private getClients() {
+    return combineLatest([this.clientMovementService.getActive(), this.clientInviteService.get()]).pipe(
+      map(([movements, invites]) => [...movements, ...invites])
+    );
+  }
+
+  /**
+   * AccountSetupItemsEnum.FIRM_EMPLOYEES completed when employee invites sent or accepted
+   */
+  private getEmployees() {
+    return combineLatest([this.employeeService.getArray(), this.employeeInviteService.getArray()]).pipe(
+      map(([employees, invites]) => [...employees.slice(1), ...invites])
+    )
+  }
+
+  /**
+   * AccountSetupItemsEnum.FIRM_DETAILS when firm data filled
+   */
+  private getFirms() {
+    return this.firmService.get().pipe(map((firm: Firm) =>
+      [firm].filter(firm => firm.address || firm.phone || firm.file || firm.shortName)));
+  }
+
+  /**
+   * @TODO Alex: work with collection when services refactored
+   * @TODO Vik: waiting for income sources refactoring
+   */
+  private getIncomeSources(isSalary: boolean): Observable<IncomeSource[]> {
+    return this.incomeSourceService.get().pipe(
+      map((incomeSources: IncomeSource[]): IncomeSource[] => {
+        const collection: IncomeSourceCollection = new IncomeSourceCollection(incomeSources);
+        if (isSalary) {
+          return collection.getSalary();
+        }
+
+        return collection.items.filter((incomeSource: IncomeSource) => incomeSource.isOtherIncome());
+      })
+    )
+  }
+
+  private getVehicleClaims(businessId?: number): Observable<VehicleClaim[]> {
+    return this.vehicleClaimService.getArray().pipe(
+      map(claims => claims.filter(
+        claim => claim.business?.id === businessId
+      ))
+    );
+  }
+
+  private getHomeOfficeClaims(businessId?: number): Observable<HomeOfficeClaim[]> {
+    return this.homeOfficeClaimService.getArray().pipe(
+      map(claims => claims.filter(
+        claim => claim.business?.id === businessId
+      ))
+    );
+  }
+
+  private getBankAccounts(tankType?: TankTypeEnum): Observable<BankAccount[]> {
+    return this.bankAccountsService.get().pipe(map(
+      (bankAccounts => bankAccounts.getByTankType(tankType).toArray())
+    ));
+  }
+
+  private getDepreciations(tankType: TankTypeEnum, id?: number): Observable<Depreciation[]> {
+    return this.depreciationService.get().pipe(map(depreciations => {
+      depreciations = depreciations.getByTankType(tankType);
+      if (tankType === TankTypeEnum.PROPERTY && id) {
+        depreciations.filterBy('property.id', id);
+      }
+      if (tankType === TankTypeEnum.SOLE && id) {
+        depreciations.filterBy('business.id', id);
+      }
+
+      return depreciations.toArray();
+    }));
+  }
+
+  private getSharesightDetails(importEnabled: boolean): Observable<SharesightDetails[]> {
+    return this.sharesightDetailsService.getArray().pipe(map(
+      details => details.filter(detail => importEnabled ? detail.importEnabled : detail.exportEnabled)
+    ));
+  }
+}

package/projects/tt-core/src/lib/services/account-setup/index.ts

@@ -0,0 +1 @@
+export * from './account-setup.service';

package/projects/tt-core/src/lib/services/adblock-detector/adblock-detector.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { checkAdBlock } from 'adblock-checker';
+
+/**
+ * service that checks adblock once we started application and saves this information
+ * to unbound from promise of adblock-checker
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class AdblockDetectorService {
+  isDetected: boolean;
+
+  constructor() {
+    checkAdBlock().then((isDetected: boolean) => this.isDetected = isDetected);
+  }
+}

package/projects/tt-core/src/lib/services/adblock-detector/index.ts

@@ -0,0 +1 @@
+export * from './adblock-detector.service';

package/projects/tt-core/src/lib/services/asset/assets.service.spec.ts

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