feat(stats): add endpoint implementation for sources ans categories

back/src/money/application/Statistician.ts

@@ -1,18 +1,24 @@
 import { Injectable } from '@nestjs/common'
+import { groupBy } from 'lodash'
+import { Assign, Intersection } from 'utility-types'
 
+import { CategoryGroupOutcomeModel } from '@shared/models/money/CategoryGroupOutcomeModel'
+import { SourceGroupIncomeModel } from '@shared/models/money/SourceGroupIncomeModel'
 import { createGroups } from '@back/utils/infrastructure/dateGroups/createGroups'
 import { DateRange } from '@back/utils/infrastructure/dto/DateRange'
 import { Currency } from '@shared/enum/Currency'
 import { GroupBy } from '@shared/enum/GroupBy'
 
-import { AbstractTransaction } from '../domain/dto/AbstarctTransaction'
-import { Transaction } from '../domain/dto/Transaction'
-import { IncomeRepository } from '../domain/IncomeRepository'
+import { TransactionRepository } from '../domain/interfaces/TransactionRepository'
+import { AbstractTransaction } from '../domain/interfaces/AbstarctTransaction'
 import { OutcomeRepository } from '../domain/OutcomeRepository'
+import { IncomeRepository } from '../domain/IncomeRepository'
 import { CurrencyConverter } from './CurrencyConverter'
+import { Transaction } from '../domain/dto/Transaction'
 import { amountMapper } from './helpers/amountMapper'
 import { rangeFilter } from './helpers/rangeFilter'
 import { sumReducer } from './helpers/sumReducer'
+import { SummedGroup } from './types/SummedGroup'
 
 @Injectable()
 export class Statistician {
@@ -25,21 +31,21 @@ export class Statistician {
   public async showDateRangeStats(
     userLogin: string,
     dateRange: DateRange,
-    groupBy: GroupBy,
+    statsGroupBy: GroupBy,
     currency: Currency,
   ) {
     const [incomes, outcomes] = await Promise.all([
       this.incomeRepo.findByRangeForUser(userLogin, dateRange),
       this.outcomeRepo.findByRangeForUser(userLogin, dateRange),
     ])
 
-    const groups = createGroups(groupBy)(dateRange)
-
     const [convertedIncomes, convertedOutcomes] = await Promise.all([
-      Promise.all(incomes.map(this.convertItem(currency))),
-      Promise.all(outcomes.map(this.convertItem(currency))),
+      this.convertItems(currency)(incomes),
+      this.convertItems(currency)(outcomes),
     ])
 
+    const groups = createGroups(statsGroupBy)(dateRange)
+
     return groups.map(group => ({
       currency,
       start: group.from,
@@ -55,16 +61,85 @@ export class Statistician {
     }))
   }
 
-  private convertItem(targetCurrency: Currency) {
-    return async (item: AbstractTransaction): Promise<Transaction> => {
-      const newAmount = await this.converter.convert(
-        item.currency,
-        targetCurrency,
-        item.amount,
-        item.date,
-      )
+  public async showCategories(
+    userLogin: string,
+    dateRange: DateRange,
+    currency: Currency,
+  ): Promise<CategoryGroupOutcomeModel[]> {
+    return this.showGrouped(
+      userLogin,
+      dateRange,
+      currency,
+      this.outcomeRepo,
+      'category',
+      'outcome',
+    )
+  }
 
-      return new Transaction(newAmount, targetCurrency, item.date)
-    }
+  public async showSources(
+    userLogin: string,
+    dateRange: DateRange,
+    currency: Currency,
+  ): Promise<SourceGroupIncomeModel[]> {
+    return this.showGrouped(
+      userLogin,
+      dateRange,
+      currency,
+      this.incomeRepo,
+      'source',
+      'income',
+    )
+  }
+
+  private async showGrouped<T extends string, K extends string>(
+    userLogin: string,
+    dateRange: DateRange,
+    currency: Currency,
+    repo: TransactionRepository,
+    groupKey: T,
+    sumKey: K,
+  ): Promise<SummedGroup<T, K>[]> {
+    const rawTransactions = await repo.findByRangeForUser(userLogin, dateRange)
+
+    const groups = Object.entries(groupBy(rawTransactions, groupKey)).map(
+      ([key, transactions]) => ({
+        key,
+        transactions,
+      }),
+    )
+
+    const convertedGroups = await Promise.all(
+      groups.map(async ({ key, transactions }) => ({
+        key,
+        transactions: await this.convertItems(currency)(transactions),
+      })),
+    )
+
+    const summedGroups = convertedGroups.map(
+      ({ key, transactions }) =>
+        ({
+          [groupKey]: key,
+          [sumKey]: transactions.map(amountMapper).reduce(sumReducer, 0),
+          currency,
+        } as SummedGroup<T, K>),
+    )
+
+    return summedGroups
+  }
+
+  private convertItems(targetCurrency: Currency) {
+    return (items: AbstractTransaction[]): Promise<Transaction[]> =>
+      Promise.all(
+        items.map(async item => {
+          const newAmount = await this.converter.convert(
+            item.currency,
+            targetCurrency,
+            item.amount,
+            item.date,
+          )
+
+          return new Transaction(newAmount, targetCurrency, item.date)
+        }),
+      )
   }
 }

back/src/money/application/helpers/amountMapper.ts

@@ -1,3 +1,3 @@
-import { AbstractTransaction } from '@back/money/domain/dto/AbstarctTransaction'
+import { AbstractTransaction } from '@back/money/domain/interfaces/AbstarctTransaction'
 
 export const amountMapper = (item: AbstractTransaction) => item.amount

back/src/money/application/helpers/rangeFilter.ts

@@ -1,4 +1,4 @@
-import { AbstractTransaction } from '@back/money/domain/dto/AbstarctTransaction'
+import { AbstractTransaction } from '@back/money/domain/interfaces/AbstarctTransaction'
 import { DateGroup } from '@back/utils/infrastructure/dateGroups/DateGroup'
 
 export const rangeFilter = ({ from, to }: DateGroup) => ({

back/src/money/application/types/SummedGroup.ts

@@ -0,0 +1,11 @@
+import { Intersection } from 'utility-types'
+
+import { CategoryGroupOutcomeModel } from '@shared/models/money/CategoryGroupOutcomeModel'
+import { SourceGroupIncomeModel } from '@shared/models/money/SourceGroupIncomeModel'
+
+export type SummedGroup<T extends string, K extends string> = Intersection<
+  CategoryGroupOutcomeModel,
+  SourceGroupIncomeModel
+> &
+  { [key in T]: string } &
+  { [key in K]: number }

back/src/money/domain/Income.entity.ts

@@ -3,7 +3,7 @@ import { Column, Entity, ManyToOne, PrimaryColumn } from 'typeorm'
 import { Currency } from '@shared/enum/Currency'
 
 import { User } from '@back/user/domain/User.entity'
-import { AbstractTransaction } from './dto/AbstarctTransaction'
+import { AbstractTransaction } from './interfaces/AbstarctTransaction'
 
 @Entity()
 export class Income implements AbstractTransaction {

back/src/money/domain/IncomeRepository.ts

@@ -7,9 +7,10 @@ import { Repository } from 'typeorm'
 import { DateRange } from '@back/utils/infrastructure/dto/DateRange'
 
 import { Income } from './Income.entity'
+import { TransactionRepository } from './interfaces/TransactionRepository'
 
 @Injectable()
-class IncomeRepo {
+class IncomeRepo implements TransactionRepository {
   public constructor(
     @InjectRepository(Income)
     private readonly incomeRepo: Repository<Income>,

back/src/money/domain/Outcome.entity.ts

@@ -3,7 +3,7 @@ import { Column, Entity, ManyToOne, PrimaryColumn } from 'typeorm'
 import { Currency } from '@shared/enum/Currency'
 
 import { User } from '@back/user/domain/User.entity'
-import { AbstractTransaction } from './dto/AbstarctTransaction'
+import { AbstractTransaction } from './interfaces/AbstarctTransaction'
 
 @Entity()
 export class Outcome implements AbstractTransaction {

back/src/money/domain/OutcomeRepository.ts

@@ -7,9 +7,10 @@ import { Repository } from 'typeorm'
 import { DateRange } from '@back/utils/infrastructure/dto/DateRange'
 
 import { Outcome } from './Outcome.entity'
+import { TransactionRepository } from './interfaces/TransactionRepository'
 
 @Injectable()
-class OutomeRepo {
+class OutomeRepo implements TransactionRepository {
   public constructor(
     @InjectRepository(Outcome)
     private readonly outcomeRepo: Repository<Outcome>,

back/src/money/domain/dto/Transaction.ts

@@ -1,6 +1,6 @@
 import { Currency } from '@shared/enum/Currency'
 
-import { AbstractTransaction } from './AbstarctTransaction'
+import { AbstractTransaction } from '../interfaces/AbstarctTransaction'
 
 export class Transaction implements AbstractTransaction {
   public constructor(

back/src/money/domain/interfaces/TransactionRepository.ts

@@ -0,0 +1,19 @@
+import { Option } from 'tsoption'
+
+import { DateRange } from '@back/utils/infrastructure/dto/DateRange'
+
+import { AbstractTransaction } from './AbstarctTransaction'
+
+export interface TransactionRepository {
+  findForUser(
+    id: string,
+    userLogin: string,
+  ): Promise<Option<AbstractTransaction>>
+
+  findEarliest(userLogin: string): Promise<Option<AbstractTransaction>>
+
+  findByRangeForUser(
+    userLogin: string,
+    range: DateRange,
+  ): Promise<AbstractTransaction[]>
+}

back/src/money/presentation/http/controller/HistoryController.ts

@@ -8,7 +8,7 @@ import {
 import { reverse, sortBy } from 'lodash'
 
 import { Historian } from '@back/money/application/Historian'
-import { AbstractTransaction } from '@back/money/domain/dto/AbstarctTransaction'
+import { AbstractTransaction } from '@back/money/domain/interfaces/AbstarctTransaction'
 import { TokenPayload } from '@back/user/application/dto/TokenPayload'
 import { CurrentUser } from '@back/user/presentation/http/decorator/CurrentUser'
 import { OnlyForUsers } from '@back/user/presentation/http/security/OnlyForUsers'

back/src/money/presentation/http/controller/StatisticsController.ts

@@ -64,8 +64,13 @@ export class StatisticsController {
   @ApiQueryDateRange()
   public async showIncomeSourcesStats(
     @Query(ParseDateRangePipe) range: DateRange,
+    @Query('currency', createEnumValidationPipe(Currency))
+    currency: Currency = Currency.USD,
+    @CurrentUser() { login }: TokenPayload,
   ): Promise<SourceGroupIncomeResponse[]> {
-    throw Error('Not implemented')
+    const sources = await this.statistician.showSources(login, range, currency)
+
+    return sources
   }
 
   @Get('outcome-categories')
@@ -78,7 +83,16 @@ export class StatisticsController {
   @ApiQueryDateRange()
   public async showOutcomeCategoriesStats(
     @Query(ParseDateRangePipe) range: DateRange,
+    @Query('currency', createEnumValidationPipe(Currency))
+    currency: Currency = Currency.USD,
+    @CurrentUser() { login }: TokenPayload,
   ): Promise<CategoryGroupOutcomeResponse[]> {
-    throw Error('Not implemented')
+    const categories = await this.statistician.showCategories(
+      login,
+      range,
+      currency,
+    )
+
+    return categories
   }
 }