feat: Cleans up routes.

2025-01-19 13:33:01 -05:00
parent 1c8748211c
commit b23dc6bf07
32 changed files with 958 additions and 1786 deletions
--- a/Sources/App/Controllers/ViewController.swift
+++ b/Sources/App/Controllers/ViewController.swift
@@ -0,0 +1,383 @@
+import DatabaseClient
+import Dependencies
+import Elementary
+import SharedModels
+import Vapor
+
+extension SharedModels.ViewRoute {
+  func handle(request: Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database.users) var users
+    switch self {
+    case let .employee(route):
+      return try await route.handle(request: request)
+
+    case let .login(route):
+      switch route {
+      case let .index(next: next):
+        return await request.render {
+          MainPage(displayNav: false, route: .login) {
+            UserForm(context: .login(next: next))
+          }
+        }
+      case let .post(login):
+        let token = try await users.login(.init(username: login.username, password: login.password))
+        let user = try await users.get(token.userID)!
+        request.session.authenticate(user)
+        return await request.render {
+          MainPage(displayNav: true, route: .purchaseOrders) {
+            div(
+              .hx.get(login.next ?? "/purchase-orders"),
+              .hx.pushURL(true),
+              .hx.target("body"),
+              .hx.trigger(.event(.revealed)),
+              .hx.indicator(".hx-indicator")
+            ) {
+              Img.spinner().attributes(.class("hx-indicator"))
+            }
+          }
+        }
+      }
+
+    case let .purchaseOrder(route):
+      return try await route.handle(request: request)
+
+    case let .user(route):
+      return try await route.handle(request: request)
+
+    case let .vendor(route):
+      return try await route.handle(request: request)
+
+    case let .vendorBranch(route):
+      return try await route.handle(request: request)
+    }
+  }
+}
+
+extension SharedModels.ViewRoute.EmployeeRoute {
+
+  private func mainPage<C: HTML>(
+    _ html: C
+  ) async throws -> some SendableHTMLDocument where C: Sendable {
+    @Dependency(\.database) var database
+    let employees = try await database.employees.fetchAll()
+    return MainPage(displayNav: true, route: .employees) {
+      div(.class("container")) {
+        html
+        EmployeeTable(employees: employees)
+      }
+    }
+  }
+
+  func handle(request: Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database.employees) var employees
+
+    switch self {
+    case .form:
+      return try await request.render(mainPage: mainPage) {
+        EmployeeForm(shouldShow: true)
+      }
+
+    case let .select(context: context):
+      return try await request.render {
+        try await context.toHTML(employees: employees.fetchAll())
+      }
+
+    case .index:
+      return try await request.render { try await mainPage(EmployeeForm()) }
+
+    case let .get(id: id):
+      guard let employee = try await employees.get(id) else {
+        throw Abort(.badRequest, reason: "Employee id not found.")
+      }
+      return try await request.render(mainPage: mainPage) {
+        EmployeeForm(employee: employee)
+      }
+
+    case let .create(employee):
+      return try await request.render {
+        try await EmployeeTable.Row(employee: employees.create(employee))
+      }
+
+    case let .delete(id: id):
+      try await employees.delete(id)
+      return HTTPStatus.ok
+
+    case let .update(id: id, updates: updates):
+      return try await request.render {
+        try await EmployeeTable.Row(employee: employees.update(id, updates))
+      }
+    }
+  }
+
+}
+
+extension SharedModels.ViewRoute.PurchaseOrderRoute {
+  private func mainPage<C: HTML>(
+    _ html: C,
+    page: Int,
+    limit: Int
+  ) async throws -> some SendableHTMLDocument where C: Sendable {
+    @Dependency(\.database.purchaseOrders) var purchaseOrders
+    let page = try await purchaseOrders.fetchPage(.init(page: page, per: limit))
+    return MainPage(displayNav: true, route: .purchaseOrders) {
+      div(.class("container"), .id("purchase-order-content")) {
+        html
+        PurchaseOrderTable(page: page)
+      }
+    }
+  }
+
+  private func mainPage<C: HTML>(
+    _ html: C
+  ) async throws -> some SendableHTMLDocument where C: Sendable {
+    try await mainPage(html, page: 1, limit: 25)
+  }
+
+  func handle(request: Vapor.Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database.purchaseOrders) var purchaseOrders
+    switch self {
+    case .form:
+      return try await request.render(mainPage: mainPage) {
+        PurchaseOrderForm(shouldShow: true)
+      }
+
+    case let .search(route):
+      return try await route.handle(request: request)
+
+    case let .create(purchaseOrder):
+      return try await request.render {
+        try await PurchaseOrderTable.Row(purchaseOrder: purchaseOrders.create(purchaseOrder))
+      }
+
+    case let .delete(id: id):
+      try await purchaseOrders.delete(id)
+      return HTTPStatus.ok
+
+    case .index:
+      return try await request.render {
+        try await mainPage(PurchaseOrderForm())
+      }
+
+    case let .get(id: id):
+      guard let purchaseOrder = try await purchaseOrders.get(id) else {
+        throw Abort(.badRequest, reason: "Purchase order not found.")
+      }
+      return try await request.render(mainPage: mainPage) {
+        PurchaseOrderForm(purchaseOrder: purchaseOrder, shouldShow: true)
+      }
+
+    case let .page(page: page, limit: limit):
+      return try await request.render {
+        try await PurchaseOrderTable.Rows(
+          page: purchaseOrders.fetchPage(.init(page: page, per: limit))
+        )
+      }
+    }
+  }
+
+}
+
+extension SharedModels.ViewRoute.PurchaseOrderRoute.Search {
+
+  func mainPage(search: PurchaseOrderSearch = .init()) -> some SendableHTMLDocument {
+    MainPage(displayNav: true, route: .purchaseOrders) {
+      div(.class("container"), .id("purchase-order-content")) {
+        search
+        PurchaseOrderTable(page: .init(items: [], metadata: .init(page: 0, per: 50, total: 0)))
+      }
+    }
+  }
+
+  func handle(request: Vapor.Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database) var database
+    switch self {
+    case let .index(context: context, table: table):
+      let html = PurchaseOrderSearch(context: context)
+      if table == true || !request.isHtmxRequest {
+        return await request.render { mainPage(search: html) }
+      }
+      return await request.render { html }
+
+    case let .search(context):
+      let results = try await database.purchaseOrders.search(context.toDatabaseQuery(), .init(page: 1, per: 25))
+      return await request.render {
+        PurchaseOrderTable(page: results, context: .search)
+      }
+    }
+  }
+}
+
+extension SharedModels.ViewRoute.UserRoute {
+
+  private func mainPage<C: HTML>(_ html: C) async throws -> some SendableHTMLDocument where C: Sendable {
+    @Dependency(\.database) var database
+    let users = try await database.users.fetchAll()
+    return MainPage(displayNav: true, route: .users) {
+      div(.class("container")) {
+        html
+        UserTable(users: users)
+      }
+    }
+  }
+
+  func handle(request: Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database.users) var users
+    switch self {
+    case .form:
+      return try await request.render(mainPage: mainPage) {
+        UserForm(context: .create)
+      }
+
+    case let .create(user):
+      return try await request.render {
+        try await UserTable.Row(user: users.create(user))
+      }
+
+    case let .delete(id: id):
+      try await users.delete(id)
+      return HTTPStatus.ok
+
+    case .index:
+      return try await request.render {
+        try await mainPage(UserDetail(user: nil))
+      }
+
+    case let .get(id: id):
+      guard let user = try await users.get(id) else {
+        throw Abort(.badRequest, reason: "User not found.")
+      }
+      return try await request.render(mainPage: mainPage) {
+        UserDetail(user: user)
+      }
+
+    case let .update(id: id, updates: updates):
+      return try await request.render {
+        try await UserTable.Row(user: users.update(id, updates))
+      }
+    }
+  }
+
+}
+
+extension SharedModels.ViewRoute.VendorRoute {
+  private func mainPage<C: HTML>(_ html: C) async throws -> some SendableHTMLDocument where C: Sendable {
+    @Dependency(\.database) var database
+    let vendors = try await database.vendors.fetchAll(.withBranches)
+    return MainPage(displayNav: true, route: .vendors) {
+      div(.class("container"), .id("content")) {
+        html
+        VendorTable(vendors: vendors)
+      }
+    }
+  }
+
+  func handle(request: Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .form:
+      return try await request.render(mainPage: mainPage) {
+        VendorForm(.float(shouldShow: true))
+      }
+
+    case .index:
+      return try await request.render {
+        try await mainPage(VendorForm())
+      }
+
+    case let .create(vendor):
+      let vendor = try await database.vendors.create(vendor)
+      return await request.render {
+        div(.class("container"), .id("content")) {
+          VendorDetail(vendor: vendor)
+          try await VendorTable(vendors: database.vendors.fetchAll(.withBranches))
+        }
+      }
+
+    case let .delete(id: id):
+      try await database.vendors.delete(id)
+      return HTTPStatus.ok
+
+    case let .get(id: id):
+      guard let vendor = try await database.vendors.get(id, .withBranches) else {
+        throw Abort(.badRequest, reason: "Vendor not found.")
+      }
+      return try await request.render(mainPage: mainPage) {
+        VendorDetail(vendor: vendor)
+      }
+
+    case let .update(id: id, updates: updates):
+      return try await request.render {
+        try await VendorDetail(
+          vendor: database.vendors.update(id, with: updates, returnWithBranches: true)
+        )
+      }
+    }
+  }
+}
+
+extension SharedModels.ViewRoute.VendorBranchRoute {
+
+  func handle(request: Request) async throws -> any AsyncResponseEncodable {
+    @Dependency(\.database) var database
+
+    switch self {
+    case let .select(context: context):
+      return try await request.render {
+        try await context.toHTML(branches: database.vendorBranches.fetchAllWithDetail())
+      }
+
+    case let .create(branch):
+      return try await request.render {
+        try await VendorDetail.BranchRow(branch: database.vendorBranches.create(branch))
+      }
+
+    case let .delete(id: id):
+      try await database.vendorBranches.delete(id)
+      return HTTPStatus.ok
+    }
+  }
+}
+
+extension SharedModels.ViewRoute.PurchaseOrderRoute.Search.Request {
+
+  func toDatabaseQuery() throws -> PurchaseOrder.SearchContext {
+    switch context {
+    case .employee:
+      guard let createdForID else {
+        throw Abort(.badRequest, reason: "Employee id not provided")
+      }
+      return .employee(createdForID)
+    case .customer:
+      guard let customerSearch, !customerSearch.isEmpty else {
+        throw Abort(.badRequest, reason: "Customer search string is empty.")
+      }
+      return .customer(customerSearch)
+    case .vendor:
+      guard let vendorBranchID else {
+        throw Abort(.badRequest, reason: "Vendor branch id not provided.")
+      }
+      return .vendor(vendorBranchID)
+    }
+  }
+}
+
+extension SharedModels.ViewRoute.SelectContext {
+  func toHTML(employees: [Employee]) -> EmployeeSelect {
+    switch self {
+    case .purchaseOrderForm:
+      return .purchaseOrderForm(employees: employees)
+    case .purchaseOrderSearch:
+      return .purchaseOrderSearch(employees: employees)
+    }
+  }
+
+  func toHTML(branches: [VendorBranch.Detail]) -> VendorBranchSelect {
+    switch self {
+    case .purchaseOrderForm:
+      return .purchaseOrderForm(branches: branches)
+    case .purchaseOrderSearch:
+      return .purchaseOrderSearch(branches: branches)
+    }
+  }
+}