vapor-po/Sources/App/Controllers/View/UsersViewController.swift

import DatabaseClient
import Dependencies
import Elementary
import SharedModels
import Vapor
import VaporElementary

struct UserViewController: RouteCollection {

  @Dependency(\.database.users) var users

  func boot(routes: any RoutesBuilder) throws {
    // let users = routes.protected.grouped("users")
    let users = routes.grouped("users")
    users.get(use: index)
    users.post(use: create)
    users.get("create", use: form)
    users.group(":id") {
      $0.post(use: update)
      $0.get(use: get)
      $0.delete(use: delete)
    }
  }

  @Sendable
  func index(req: Request) async throws -> HTMLResponse {
    try await req.render {
      try await mainPage(UserDetail(user: nil))
    }
  }

  @Sendable
  func get(req: Request) async throws -> HTMLResponse {
    let user = try await users.get(req.ensureIDPathComponent())
    let detail = UserDetail(user: user)

    guard req.isHtmxRequest else {
      return try await req.render { try await mainPage(detail) }
    }
    return await req.render { UserDetail(user: user) }
  }

  @Sendable
  func create(req: Request) async throws -> HTMLResponse {
    _ = try await users.create(req.content.decode(User.Create.self))
    let users = try await users.fetchAll()
    // return req.redirect(to: "/users")
    return await req.render { UserTable(users: users) }
  }

  @Sendable
  func delete(req: Request) async throws -> HTTPStatus {
    try await users.delete(req.ensureIDPathComponent())
    return .ok
  }

  @Sendable
  func form(req: Request) async throws -> HTMLResponse {
    await req.render { UserForm(context: .create) }
  }

  @Sendable
  func update(req: Request) async throws -> HTMLResponse {
    let updates = try req.content.decode(User.Update.self)
    req.logger.info("\(updates)")
    let user = try await users.update(req.ensureIDPathComponent(), updates)
    return await req.render { UserTable.Row(user: user) }
  }

  private func mainPage<C: HTML>(_ html: C) async throws -> some SendableHTMLDocument where C: Sendable {
    let users = try await users.fetchAll()
    return MainPage(displayNav: true, route: .users) {
      div(.class("container")) {
        html
        UserTable(users: users)
      }
    }
  }
}

// import Dependencies
// import Fluent
// import Vapor
//
// struct UserViewController: RouteCollection {
//
//   @Dependency(\.users) var users
//
//   private let api = UserApiController()
//
//   func boot(routes: any RoutesBuilder) throws {
//     let users = routes.protected.grouped("users")
//     users.get(use: index(req:))
//     users.post(use: create(req:))
//     users.group(":id") {
//       $0.get(use: details(req:))
//       $0.delete(use: delete(req:))
//     }
//   }
//
//   @Sendable
//   func index(req: Request) async throws -> View {
//     try await renderIndex(req)
//   }
//
//   @Sendable
//   private func renderIndex(_ req: Request, _ user: User.DTO? = nil) async throws -> View {
//     let users = try await api.getSortedUsers(req: req)
//     return try await req.view.render("users/index", UsersCTX(user: user, users: users))
//   }
//
//   @Sendable
//   func create(req: Request) async throws -> View {
//     let user = try await api.create(req: req)
//     return try await req.view.render("users/table-row", user)
//   }
//
//   @Sendable
//   func details(req: Request) async throws -> View {
//     let user = try await users.get(req.ensureIDPathComponent())
//     // Check if the page has been rendered before.
//     guard req.isHtmxRequest else {
//       // Not an htmx-request, so render the whole page with the details.
//       return try await renderIndex(req, user)
//     }
//     // An htmx-request header was present, so just return the details,
//     return try await req.view.render("users/detail", ["user": user])
//   }
//
//   @Sendable
//   func delete(req: Request) async throws -> View {
//     _ = try await api.delete(req: req)
//     return try await req.view.render("users/table", ["users": api.getSortedUsers(req: req)])
//   }
// }
//
// struct UserFormCTX: Content {
//   let htmxForm: HtmxFormCTX<Context>
//
//   struct Context: Content {
//     let showConfirmPassword: Bool
//     let showEmailInput: Bool
//     let buttonLabel: String
//   }
//
//   static func signIn(next: String?) -> Self {
//     .init(
//       htmxForm: .init(
//         formClass: "user-form",
//         formId: "user-form",
//         htmxTargetUrl: .post("/login\((next != nil && next != "/") ? "?next=\(next!)" : "")"),
//         htmxTarget: "user-table",
//         htmxPushUrl: true,
//         htmxResetAfterRequest: true,
//         htmxSwapOob: nil,
//         htmxSwap: .afterbegin,
//         context: .init(showConfirmPassword: false, showEmailInput: false, buttonLabel: "Sign In")
//       )
//     )
//   }
//
//   static func create() -> Self {
//     .init(
//       htmxForm: .init(
//         formClass: "user-form",
//         formId: "user-form",
//         htmxTargetUrl: .post("/users"),
//         htmxTarget: "#user-table",
//         htmxPushUrl: false,
//         htmxResetAfterRequest: true,
//         htmxSwapOob: nil,
//         htmxSwap: nil,
//         context: .init(showConfirmPassword: true, showEmailInput: true, buttonLabel: "Create")
//       )
//     )
//   }
// }
//
// private struct UsersCTX: Content {
//   let user: User.DTO?
//   let users: [User.DTO]
//   let form: UserFormCTX
//
//   init(
//     user: User.DTO? = nil,
//     users: [User.DTO],
//     form: UserFormCTX? = nil
//   ) {
//     self.user = user
//     self.users = users
//     self.form = form ?? .create()
//   }
// }
//
// private extension UserApiController {
//
//   func getSortedUsers(req: Request) async throws -> [User.DTO] {
//     try await index(req: req)
//       .sorted { ($0.username ?? "") < ($1.username ?? "") }
//   }
// }