Made switch to ski

Author: adborbas

Sources/Grodt/Application/routes.swift

@@ -5,7 +5,6 @@ func routes(_ app: Application) async throws {
     let container = try await buildAppContainer(app)
     installGlobalMiddleware(app)
     try registerLoginRoutes(app, container)
-    try registerApiRoutes(app, container)
     try registerSkiRoutes(app, container)
     try scheduleNightlyJobs(app, container)
 }

Sources/Grodt/Application/routes/routes+Dependencies.swift

@@ -37,6 +37,9 @@ struct AppContainer {
     let accountService: AccountService
     let brokerageService: BrokerageService
     let investmentService: InvestmentService
+    let transactionService: TransactionService
+    let tickersService: TickersService
+    let brokerageAccountsService: BrokerageAccountsService
 }
 
 func buildAppContainer(_ app: Application) async throws -> AppContainer {
@@ -114,12 +117,12 @@ func buildAppContainer(_ app: Application) async throws -> AppContainer {
                 currencyMapper: currencyDTOMapper,
                 database: app.db
             ),
+            performanceRepository: brokerageDailyPerformanceRepository,
+            performanceDTOMapper: performanceDTOMapper,
             database: app.db
         ),
         accounts: brokerageAccountRepository,
-        currencyMapper: currencyDTOMapper,
-        performanceRepository: brokerageDailyPerformanceRepository,
-        performanceDTOMapper: performanceDTOMapper
+        currencyMapper: currencyDTOMapper
     )
 
     let investmentService = InvestmentService(
@@ -131,6 +134,29 @@ func buildAppContainer(_ app: Application) async throws -> AppContainer {
             priceService: priceService
         )
     )
+    
+    let transactionService = TransactionService(transactionsRepository: transactionRepository,
+                                                currencyRepository: currencyRepository,
+                                                dataMapper: transactionDTOMapper)
+    
+    let tickersService = TickersService(
+        tickerRepository: tickerRepository,
+        dataMapper: tickerDTOMapper,
+        tickerService: alphavantage
+    )
+    
+    let tickerChangeHandler = TickerChangeHandler(priceService: priceService)
+    tickersService.delegate = tickerChangeHandler
+    
+    let brokerageAccountsService = BrokerageAccountsService(
+        brokerageRepository: brokerageRepository,
+        brokerageAccountRepository: brokerageAccountRepository,
+        performanceRepository: brokerageAccountDailyPerformanceRepository,
+        performanceDTOMapper: performanceDTOMapper,
+        currencyMapper: currencyDTOMapper,
+        transactionDTOMapper: transactionDTOMapper,
+        currencyRepository: currencyRepository
+    )
 
 
     return AppContainer(
@@ -158,7 +184,10 @@ func buildAppContainer(_ app: Application) async throws -> AppContainer {
         portfolioService: portfolioService,
         accountService: accountService,
         brokerageService: brokerageService,
-        investmentService: investmentService
+        investmentService: investmentService,
+        transactionService: transactionService,
+        tickersService: tickersService,
+        brokerageAccountsService: brokerageAccountsService
     )
 }
 

Sources/Grodt/Application/routes/routes+login.swift

@@ -4,5 +4,5 @@ func registerLoginRoutes(_ app: Application, _ container: AppContainer) throws {
     let loginRateLimiter = RateLimiterMiddleware(maxRequests: 3, perSeconds: 60)
     try app
         .grouped(loginRateLimiter)
-        .register(collection: UserController(dtoMapper: container.loginResponseDTOMapper))
+        .register(collection: LoginRoute(dtoMapper: container.loginResponseDTOMapper))
 }

Sources/Grodt/DTOs/CreateTransactionRequestDTO.swift

@@ -1,7 +1,6 @@
 import Foundation
 
 struct CreateTransactionRequestDTO: Decodable {
-    let portfolio: String
     let brokerageAccountID: String?
     let purchaseDate: Date
     let ticker: String
@@ -11,12 +10,11 @@ struct CreateTransactionRequestDTO: Decodable {
     let pricePerShare: Decimal
 
     enum CodingKeys: String, CodingKey {
-        case portfolio, brokerageAccountID, platform, account, purchaseDate, ticker, currency, fees, numberOfShares, pricePerShare
+        case brokerageAccountID, purchaseDate, ticker, currency, fees, numberOfShares, pricePerShare
     }
 
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
-        portfolio = try container.decode(String.self, forKey: .portfolio)
         brokerageAccountID = try container.decodeIfPresent(String.self, forKey: .brokerageAccountID)
         ticker = try container.decode(String.self, forKey: .ticker)
         currency = try container.decode(String.self, forKey: .currency)

Sources/Grodt/Endpoints/Routes/api/brokerages/DTO/BrokerageAccountDTO.swift renamed to Sources/Grodt/DTOs/brokerages/BrokerageAccountDTO.swift

@@ -8,4 +8,5 @@ struct BrokerageAccountDTO: Codable {
     let baseCurrency: CurrencyDTO
     let performance: PerformanceDTO
     let transactions: [TransactionDTO]
+    let historicalPerformance: PerformanceTimeSeriesDTO
 }

Sources/Grodt/Endpoints/Routes/api/brokerages/DTO/BrokerageAccountDTOMapper.swift renamed to Sources/Grodt/DTOs/brokerages/BrokerageAccountDTOMapper.swift

@@ -5,4 +5,5 @@ struct BrokerageDTO: Codable {
     let name: String
     let accounts: [BrokerageAccountInfoDTO]
     let performance: PerformanceDTO
+    let historicalPerformance: PerformanceTimeSeriesDTO
 }

Sources/Grodt/Endpoints/Routes/api/brokerages/DTO/BrokerageAccountInfoDTO.swift renamed to Sources/Grodt/DTOs/brokerages/BrokerageAccountInfoDTO.swift

@@ -3,14 +3,20 @@ import Fluent
 struct BrokerageDTOMapper {
     private let brokerageRepository: BrokerageRepository
     private let accountDTOMapper: BrokerageAccountDTOMapper
+    private let performanceRepository: PostgresBrokerageDailyPerformanceRepository
+    private let performanceDTOMapper: DatedPerformanceDTOMapper
     private let database: Database
 
     init(brokerageRepository: BrokerageRepository,
          accountDTOMapper: BrokerageAccountDTOMapper,
+         performanceRepository: PostgresBrokerageDailyPerformanceRepository,
+         performanceDTOMapper: DatedPerformanceDTOMapper,
          database: Database) {
         self.brokerageRepository = brokerageRepository
         self.accountDTOMapper = accountDTOMapper
         self.database = database
+        self.performanceRepository = performanceRepository
+        self.performanceDTOMapper = performanceDTOMapper
     }
 
     func brokerage(from brokerage: Brokerage) async throws -> BrokerageDTO {
@@ -19,11 +25,17 @@ struct BrokerageDTOMapper {
             try await accountDTOMapper.brokerageAccountInfo(from: $0)
         }
         let performance = try await brokerageRepository.performance(for: brokerage.requireID())
+        
+        let rows = try await performanceRepository.readSeries(for: brokerage.requireID(), from: nil, to: nil)
+        let values =  rows.map { performanceDTOMapper.performancePoint(from: $0)  }
+            .sorted { $0.date < $1.date }
+        
         return try BrokerageDTO(
             id: brokerage.requireID(),
             name: brokerage.name,
             accounts: accountDTOs,
-            performance: performance
+            performance: performance,
+            historicalPerformance: PerformanceTimeSeriesDTO(values: values)
         )
     }
 }