Compute investments

Author: adborbas

Sources/Grodt/Application/routes.swift

@@ -9,11 +9,15 @@ func routes(_ app: Application) async throws {
     let tickerDTOMapper = TickerDTOMapper()
     let loginResponseDTOMapper = LoginResponseDTOMapper()
     let transactionDTOMapper = TransactionDTOMapper(currencyDTOMapper: currencyDTOMapper)
+    let tickerRepository = PostgresTickerRepository(database: app.db)
     let livePriceService = LivePriceService(alphavantage: alphavantage)
     let quoteCache = PostgresQuoteRepository(database: app.db)
     let priceService = CachedPriceService(priceService: livePriceService, cache: quoteCache)
+    let investmentDTOMapper = InvestmentDTOMapper(currencyDTOMapper: currencyDTOMapper,
+                                                  tickerRepository: tickerRepository,
+                                                  priceService: priceService)
     let portfolioPerformanceCalculator = PortfolioPerformanceCalculator(priceService: priceService)
-    let portfolioDTOMapper = PortfolioDTOMapper(transactionDTOMapper: transactionDTOMapper,
+    let portfolioDTOMapper = PortfolioDTOMapper(investmentDTOMapper: investmentDTOMapper,
                                                 currencyDTOMapper: currencyDTOMapper,
                                                 performanceCalculator: portfolioPerformanceCalculator)
     let portfolioPerformanceUpdater = PortfolioPerformanceUpdater(
@@ -26,7 +30,7 @@ func routes(_ app: Application) async throws {
     let transactionChangedHandler = TransactionChangedHandler(portfolioRepository: PostgresPortfolioRepository(database: app.db),
                                                               historicalPerformanceUpdater: portfolioPerformanceUpdater)
 
-    var tickersController = TickersController(tickerRepository: PostgresTickerRepository(database: app.db),
+    var tickersController = TickersController(tickerRepository: tickerRepository,
                                               dataMapper: tickerDTOMapper,
                                               tickerService: alphavantage)
     let tickerChangeHandler = TickerChangeHandler(priceService: priceService)

Sources/Grodt/DTOs/DTOMappers/InvestmentDTOMapper.swift

@@ -0,0 +1,49 @@
+import Foundation
+import CollectionConcurrencyKit
+
+class InvestmentDTOMapper {
+    private let currencyDTOMapper: CurrencyDTOMapper
+    private let tickerRepository: TickerRepository
+    private let priceService: PriceService
+    
+    init(currencyDTOMapper: CurrencyDTOMapper,
+         tickerRepository: TickerRepository,
+         priceService: PriceService) {
+        self.currencyDTOMapper = currencyDTOMapper
+        self.priceService = priceService
+        self.tickerRepository = tickerRepository
+    }
+    
+    func investments(from transactions: [Transaction]) async throws -> [InvestmentDTO] {
+        let investments: [InvestmentDTO] = try await transactions
+            .grouped { $0.ticker }
+            .asyncCompactMap { (ticker, transactions) in
+                let name = try await tickerRepository.tickers(for: ticker)?.name ?? ""
+                let latestPrice = try await priceService.price(for: ticker)
+                var pricePerPurchase: [Decimal: Decimal] = [:]
+                var numberOfShares: Decimal = 0
+                var totalCost: Decimal = 0
+                transactions.forEach { transaction in
+                    pricePerPurchase[transaction.pricePerShareAtPurchase] = transaction.numberOfShares
+                    numberOfShares += transaction.numberOfShares
+                    totalCost += (transaction.pricePerShareAtPurchase * transaction.numberOfShares) + transaction.fees
+                }
+                let currentValue = numberOfShares * latestPrice
+                let avgBuyPrice = pricePerPurchase.keys.reduce(0) { $0 + $1 } / Decimal(pricePerPurchase.count)
+                let profit = currentValue - totalCost
+                let totalReturn = (totalCost == 0 ? 0 : profit / totalCost).ro
+                
+                return InvestmentDTO(name: name,
+                                     shortName: ticker,
+                                     avgBuyPrice: avgBuyPrice,
+                                     latestPrice: latestPrice,
+                                     totalReturn: totalReturn,
+                                     profit: profit,
+                                     value: currentValue,
+                                     numberOfShares: numberOfShares,
+                                     currency: currencyDTOMapper.currency(from: transactions.first!.currency))
+            }
+        
+        return investments
+    }
+}

Sources/Grodt/DTOs/DTOMappers/PortfolioDTOMapper.swift

@@ -2,39 +2,34 @@ import Foundation
 import CollectionConcurrencyKit
 
 class PortfolioDTOMapper {
-    private let transactionDTOMapper: TransactionDTOMapper
+    private let investmentDTOMapper: InvestmentDTOMapper
     private let currencyDTOMapper: CurrencyDTOMapper
     private let performanceCalculator: PortfolioPerformanceCalculating
 
-    init(transactionDTOMapper: TransactionDTOMapper,
+    init(investmentDTOMapper: InvestmentDTOMapper,
          currencyDTOMapper: CurrencyDTOMapper,
          performanceCalculator: PortfolioPerformanceCalculating) {
-        self.transactionDTOMapper = transactionDTOMapper
+        self.investmentDTOMapper = investmentDTOMapper
         self.currencyDTOMapper = currencyDTOMapper
         self.performanceCalculator = performanceCalculator
     }
 
     func portfolio(from portfolio: Portfolio) async throws -> PortfolioDTO {
 
+        let investments = try await investmentDTOMapper.investments(from: portfolio.transactions)
         return try await  PortfolioDTO(id: portfolio.id?.uuidString ?? "",
                                        name: portfolio.name,
                                        currency: currencyDTOMapper.currency(from: portfolio.currency),
                                        performance: performance(for: portfolio),
-                                       transactions: portfolio.transactions
-            .sorted(by: { lhs, rhs in
-                return lhs.purchaseDate > rhs.purchaseDate
-            })
-                .compactMap { transactionDTOMapper.transaction(from: $0) }
-        )
+                                       investments: investments)
     }
 
     func portfolioInfo(from portfolio: Portfolio) async throws -> PortfolioInfoDTO {
 
         return try await PortfolioInfoDTO(id: portfolio.id?.uuidString ?? "",
                                           name: portfolio.name,
                                           currency: currencyDTOMapper.currency(from: portfolio.currency),
-                                          performance: performance(for: portfolio),
-                                          transactions: portfolio.transactions.compactMap { $0.id?.uuidString }
+                                          performance: performance(for: portfolio)
         )
     }
 

Sources/Grodt/DTOs/InvestmentDTO.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+struct InvestmentDTO: Codable, Equatable {
+    let name: String
+    let shortName: String
+    let avgBuyPrice: Decimal
+    let latestPrice: Decimal
+    let totalReturn: Decimal
+    let profit: Decimal
+    let value: Decimal
+    let numberOfShares: Decimal
+    let currency: CurrencyDTO
+}

Sources/Grodt/DTOs/PortfolioDTO.swift

@@ -5,5 +5,5 @@ struct PortfolioDTO: Codable, Equatable {
     let name: String
     let currency: CurrencyDTO
     let performance: PortfolioPerformanceDTO
-    let transactions: [TransactionDTO]
+    let investments: [InvestmentDTO]
 }

Sources/Grodt/DTOs/PortfolioInfoDTO.swift

@@ -5,5 +5,4 @@ struct PortfolioInfoDTO: Codable, Equatable {
     let name: String
     let currency: CurrencyDTO
     let performance: PortfolioPerformanceDTO
-    let transactions: [String]
 }

Sources/Grodt/Persistency/Repositories/TickerRepository.swift

@@ -2,6 +2,7 @@ import Fluent
 
 protocol TickerRepository {
     func allTickers() async throws -> [Ticker]
+    func tickers(for symbol: String) async throws -> Ticker?
 }
 
 class PostgresTickerRepository: TickerRepository {
@@ -15,4 +16,10 @@ class PostgresTickerRepository: TickerRepository {
         return try await Ticker.query(on: database)
             .all()
     }
+    
+    func tickers(for symbol: String) async throws -> Ticker? {
+        return try await Ticker.query(on: database)
+            .filter(\Ticker.$symbol == symbol)
+            .first()
+    }
 }