hhe/vapor-po
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Cleans up routes.

Browse Source
This commit is contained in:
Michael Housh
2025-01-19 13:33:01 -05:00
parent 1c8748211c
commit b23dc6bf07
32 changed files with 958 additions and 1786 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
Sources/App/Controllers/Api/EmployeeApiController.swift
View File

@@ -1,70 +0,0 @@
import DatabaseClient
import Dependencies
import SharedModels
import Vapor
struct EmployeeApiController: RouteCollection {
@Dependency(\.database.employees) var employees
func boot(routes: any RoutesBuilder) throws {
let protected = routes.apiProtected(route: "employees")
protected.get(use: index(req:))
protected.post(use: create(req:))
protected.group(":id") {
$0.get(use: get(req:))
$0.put(use: update(req:))
$0.delete(use: delete(req:))
}
}
@Sendable
func index(req: Request) async throws -> [Employee] {
let params = try req.query.decode(EmployeesIndexQuery.self)
return try await employees.fetchAll(params.request)
}
@Sendable
func create(req: Request) async throws -> Employee {
try await employees.create(
req.content.decode(Employee.Create.self)
)
}
@Sendable
func get(req: Request) async throws -> Employee {
guard let employee = try await employees.get(req.ensureIDPathComponent()) else {
throw Abort(.notFound)
}
return employee
}
@Sendable
func update(req: Request) async throws -> Employee {
return try await employees.update(
req.ensureIDPathComponent(),
req.content.decode(Employee.Update.self)
)
}
@Sendable
func delete(req: Request) async throws -> HTTPStatus {
try await employees.delete(req.ensureIDPathComponent())
return .ok
}
}
struct EmployeesIndexQuery: Content {
let active: Bool?
var request: DatabaseClient.Employees.FetchRequest {
switch active {
case .none:
return .all
case .some(true):
return .active
case .some(false):
return .inactive
}
}
}

59
Sources/App/Controllers/Api/PurchaseOrderApiController.swift
View File

@@ -1,59 +0,0 @@
import DatabaseClient
import Dependencies
import Fluent
import SharedModels
import Vapor
// TODO: Add update route.
struct PurchaseOrderApiController: RouteCollection {
@Dependency(\.database.purchaseOrders) var purchaseOrders
func boot(routes: any RoutesBuilder) throws {
let protected = routes.apiProtected(route: "purchase-orders")
protected.get(use: index(req:))
protected.post(use: create(req:))
protected.group(":id") {
$0.get(use: get(req:))
$0.delete(use: delete(req:))
}
}
@Sendable
func index(req: Request) async throws -> [PurchaseOrder] {
try await purchaseOrders.fetchAll()
}
@Sendable
func create(req: Request) async throws -> PurchaseOrder {
try await purchaseOrders.create(
req.content.decode(PurchaseOrder.CreateIntermediate.self)
.toCreate(createdByID: req.auth.require(User.self).id)
)
}
@Sendable
func get(req: Request) async throws -> PurchaseOrder {
guard let purchaseOrder = try await purchaseOrders.get(req.ensureIDPathComponent(as: Int.self))
else {
throw Abort(.notFound)
}
return purchaseOrder
}
@Sendable
func delete(req: Request) async throws -> HTTPStatus {
try await purchaseOrders.delete(req.ensureIDPathComponent(as: Int.self))
return .ok
}
// @Sendable
// func update(req: Request) async throws -> PurchaseOrder.DTO {
// guard let id = req.parameters.get("id", as: PurchaseOrder.ID.self) else {
// throw Abort(.badRequest, reason: "Purchase order id not provided.")
// }
// try await purchaseOrders.delete(id: id, on: req.db)
// return .ok
// }
}

52
Sources/App/Controllers/Api/UserApiController.swift
View File

@@ -1,52 +0,0 @@
import DatabaseClient
import Dependencies
import Fluent
import SharedModels
import Vapor
// TODO: Add update and get by id.
struct UserApiController: RouteCollection {
@Dependency(\.database.users) var users
func boot(routes: any RoutesBuilder) throws {
let unProtected = routes.apiUnprotected(route: "users")
let protected = routes.apiProtected(route: "users")
unProtected.post(use: create(req:))
protected.get(use: index(req:))
protected.get("login", use: login(req:))
protected.group(":id") {
$0.delete(use: delete(req:))
}
}
@Sendable
func index(req: Request) async throws -> [User] {
try await users.fetchAll()
}
@Sendable
func create(req: Request) async throws -> User {
// Allow the first user to be created without authentication.
let count = try await users.count()
if count > 0 {
guard req.auth.get(User.self) != nil else {
throw Abort(.unauthorized)
}
}
return try await users.create(req.content.decode(User.Create.self))
}
@Sendable
func login(req: Request) async throws -> User.Token {
let user = try req.auth.require(User.self)
return try await users.token(user.id)
}
@Sendable
func delete(req: Request) async throws -> HTTPStatus {
try await users.delete(req.ensureIDPathComponent())
return .ok
}
}

51
Sources/App/Controllers/Api/VendorApiController.swift
View File

@@ -1,51 +0,0 @@
import DatabaseClient
import Dependencies
import Fluent
import SharedModels
import Vapor
struct VendorApiController: RouteCollection {
@Dependency(\.database.vendors) var vendors
func boot(routes: any RoutesBuilder) throws {
let protected = routes.apiProtected(route: "vendors")
protected.get(use: index(req:))
protected.post(use: create(req:))
protected.group(":id") {
$0.put(use: update(req:))
$0.delete(use: delete(req:))
}
}
@Sendable
func index(req: Request) async throws -> [Vendor] {
let params = try req.query.decode(VendorsIndexQuery.self)
return try await vendors.fetchAll(params.request)
}
@Sendable
func create(req: Request) async throws -> Vendor {
try await vendors.create(req.content.decode(Vendor.Create.self))
}
@Sendable
func update(req: Request) async throws -> Vendor {
return try await vendors.update(req.ensureIDPathComponent(), with: req.content.decode(Vendor.Update.self))
}
@Sendable
func delete(req: Request) async throws -> HTTPStatus {
try await vendors.delete(req.ensureIDPathComponent())
return .ok
}
}
struct VendorsIndexQuery: Content {
let branches: Bool?
var request: DatabaseClient.Vendors.FetchRequest {
if branches == true { return .withBranches }
return .all
}
}

65
Sources/App/Controllers/Api/VendorBranchApiController.swift
View File

@@ -1,65 +0,0 @@
import DatabaseClient
import Dependencies
import Fluent
import SharedModels
import Vapor
struct VendorBranchApiController: RouteCollection {
@Dependency(\.database.vendorBranches) var vendorBranches
func boot(routes: any RoutesBuilder) throws {
let prefix = routes.apiProtected(route: "vendors")
let root = prefix.grouped("branches")
root.get(use: index(req:))
root.group(":id") {
$0.put(use: update(req:))
$0.delete(use: delete(req:))
}
prefix.group(":vendorID", "branches") {
$0.get(use: indexForVendor(req:))
$0.post(use: create(req:))
}
}
@Sendable
func index(req: Request) async throws -> [VendorBranch] {
try await vendorBranches.fetchAll()
}
@Sendable
func indexForVendor(req: Request) async throws -> [VendorBranch] {
guard let id = req.parameters.get("vendorID", as: Vendor.ID.self) else {
throw Abort(.badRequest, reason: "Vendor id not provided.")
}
return try await vendorBranches.fetchAll(.for(vendorID: id))
}
@Sendable
func create(req: Request) async throws -> VendorBranch {
let id = try req.ensureIDPathComponent(key: "vendorID")
let content = try req.content.decode(BranchCreateRequest.self)
return try await vendorBranches.create(
.init(name: content.name, vendorID: id)
)
}
@Sendable
func update(req: Request) async throws -> VendorBranch {
return try await vendorBranches.update(
req.ensureIDPathComponent(),
req.content.decode(VendorBranch.Update.self)
)
}
@Sendable
func delete(req: Request) async throws -> HTTPStatus {
try await vendorBranches.delete(req.ensureIDPathComponent())
return .ok
}
}
private struct BranchCreateRequest: Content {
let name: String
}

141
Sources/App/Controllers/ApiController.swift
View File

@@ -1,14 +1,141 @@
import DatabaseClient
import Dependencies
import Fluent
import SharedModels
import Vapor
struct ApiController: RouteCollection {
func boot(routes: any RoutesBuilder) throws {
try routes.register(collection: EmployeeApiController())
try routes.register(collection: PurchaseOrderApiController())
try routes.register(collection: UserApiController())
try routes.register(collection: VendorApiController())
try routes.register(collection: VendorBranchApiController())
extension ApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
switch self {
case let .employee(route):
return try await route.handle(request: request)
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 ApiRoute.EmployeeApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
@Dependency(\.database) var database
switch self {
case let .create(employee):
return try await database.employees.create(employee)
case let .delete(id: id):
try await database.employees.delete(id)
return HTTPStatus.ok
case .index:
return try await database.employees.fetchAll()
case let .get(id: id):
guard let employee = try await database.employees.get(id) else {
throw Abort(.badRequest, reason: "Employee not found")
}
return employee
case let .update(id: id, updates: updates):
return try await database.employees.update(id, updates)
}
}
}
extension ApiRoute.PurchaseOrderApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
@Dependency(\.database.purchaseOrders) var purchaseOrders
switch self {
case .index:
return try await purchaseOrders.fetchAll()
case let .create(purchaseOrder):
return try await purchaseOrders.create(purchaseOrder)
case let .delete(id: id):
try await purchaseOrders.delete(id)
return HTTPStatus.ok
case let .get(id: id):
guard let output = try await purchaseOrders.get(id) else {
throw Abort(.badRequest, reason: "Purchase order not found.")
}
return output
case let .page(page: page, limit: limit):
return try await purchaseOrders.fetchPage(.init(page: page, per: limit))
}
}
}
// TODO: Add Login.
extension ApiRoute.UserApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
@Dependency(\.database.users) var users
switch self {
case let .create(user):
return try await users.create(user)
case let .delete(id: id):
try await users.delete(id)
return HTTPStatus.ok
case .index:
return try await users.fetchAll()
case let .get(id: id):
guard let user = try await users.get(id) else {
throw Abort(.badRequest, reason: "Employee not found")
}
return user
// case let .login(user):
// return try await users.login(user)
case let .update(id: id, updates: updates):
return try await users.update(id, updates)
}
}
}
extension ApiRoute.VendorApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
@Dependency(\.database.vendors) var vendors
switch self {
case let .create(vendor):
return try await vendors.create(vendor)
case let .delete(id: id):
try await vendors.delete(id)
return HTTPStatus.ok
case let .get(id: id):
guard let vendor = try await vendors.get(id) else {
throw Abort(.badRequest, reason: "Employee not found")
}
return vendor
case let .update(id: id, updates: updates):
return try await vendors.update(id, with: updates)
case let .index(withBranches: withBranches):
guard withBranches == true else {
return try await vendors.fetchAll()
}
return try await vendors.fetchAll(.withBranches)
}
}
}
extension ApiRoute.VendorBranchApiRoute {
func handle(request: Request) async throws -> any AsyncResponseEncodable {
@Dependency(\.database.vendorBranches) var vendorBranches
switch self {
case let .create(branch):
return try await vendorBranches.create(branch)
case let .delete(id: id):
try await vendorBranches.delete(id)
return HTTPStatus.ok
case let .index(for: optionalVendorID):
guard let vendorID = optionalVendorID else {
return try await vendorBranches.fetchAll()
}
return try await vendorBranches.fetchAll(.for(vendorID: vendorID))
case let .get(id: id):
guard let branch = try await vendorBranches.get(id) else {
throw Abort(.badRequest, reason: "Employee not found")
}
return branch
case let .update(id: id, updates: updates):
return try await vendorBranches.update(id, updates)
}
}
}

65
Sources/App/Controllers/View/EmployeeViewController.swift
View File

@@ -1,65 +0,0 @@
import DatabaseClient
import Dependencies
import Elementary
import SharedModels
import Vapor
import VaporElementary
struct EmployeeViewController: RouteCollection {
@Dependency(\.database.employees) var employees
func boot(routes: any RoutesBuilder) throws {
let route = routes.protected.grouped("employees")
route.get(use: index)
route.get("create", use: form)
route.post(use: create)
route.group(":id") {
$0.get(use: get)
$0.put(use: update)
}
}
@Sendable
func index(req: Request) async throws -> HTMLResponse {
try await req.render { try await mainPage(EmployeeForm()) }
}
@Sendable
func form(req: Request) async throws -> HTMLResponse {
await req.render { EmployeeForm(shouldShow: true) }
}
@Sendable
func create(req: Request) async throws -> HTMLResponse {
let employee = try await employees.create(req.content.decode(Employee.Create.self))
return await req.render { EmployeeTable.Row(employee: employee) }
}
@Sendable
func get(req: Request) async throws -> HTMLResponse {
guard let employee = try await employees.get(req.ensureIDPathComponent()) else {
throw Abort(.badRequest, reason: "Employee not found.")
}
guard req.isHtmxRequest else {
return try await req.render { try await mainPage(EmployeeForm(employee: employee)) }
}
return await req.render { EmployeeForm(employee: employee) }
}
@Sendable
func update(req: Request) async throws -> HTMLResponse {
let employee = try await employees.update(req.ensureIDPathComponent(), req.content.decode(Employee.Update.self))
return await req.render { EmployeeTable.Row(employee: employee) }
}
private func mainPage<C: HTML>(_ html: C) async throws -> some SendableHTMLDocument where C: Sendable {
let employees = try await self.employees.fetchAll()
return MainPage(displayNav: true, route: .employees) {
div(.class("container")) {
html
EmployeeTable(employees: employees)
}
}
}
}

73
Sources/App/Controllers/View/PurchaseOrderSearchViewController.swift
View File

@@ -1,73 +0,0 @@
// import Dependencies
// import Elementary
// import Fluent
// import SharedModels
// import Vapor
// import VaporElementary
//
// struct PurchaseOrderSearchViewController: RouteCollection {
// @Dependency(\.database.employees) var employees
// @Dependency(\.database.vendorBranches) var vendorBranches
// @Dependency(\.database.purchaseOrders) var purchaseOrders
//
// func boot(routes: any RoutesBuilder) throws {
// let route = routes.protected.grouped("purchase-orders", "search")
// route.get(use: index)
// route.post(use: post)
// }
//
// @Sendable
// func index(req: Request) async throws -> HTMLResponse {
// let query = try? req.query.decode(FormQuery.self)
// let html = PurchaseOrderSearch(context: query?.context)
// if query?.table == true || !req.isHtmxRequest {
// return await req.render { mainPage(search: html) }
// }
// return await req.render { html }
// }
//
// @Sendable
// func post(req: Request) async throws -> HTMLResponse {
// let context = try req.content.decode(PurchaseOrderSearchContent.self)
// let results = try await purchaseOrders.search(context.toDatabaseQuery(), .init(page: 1, per: 25))
// return await req.render { PurchaseOrderTable(page: results, context: .search, searchContext: nil) }
// }
//
// 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)))
// }
// }
// }
//
// }
//
// extension PurchaseOrderSearchContent {
//
// 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 search, !search.isEmpty else {
// throw Abort(.badRequest, reason: "Customer search string is empty.")
// }
// return .customer(search)
// case .vendor:
// guard let vendorBranchID else {
// throw Abort(.badRequest, reason: "Vendor branch id not provided.")
// }
// return .vendor(vendorBranchID)
// }
// }
// }
//
// private struct FormQuery: Content {
// let context: PurchaseOrderSearchContext
// let table: Bool?
// }

133
Sources/App/Controllers/View/PurchaseOrderViewController.swift
View File

@@ -1,133 +0,0 @@
import Dependencies
import Elementary
import Fluent
import SharedModels
import Vapor
import VaporElementary
struct PurchaseOrderViewController: RouteCollection {
@Dependency(\.database.employees) var employees
@Dependency(\.database.vendorBranches) var vendorBranches
@Dependency(\.database.purchaseOrders) var purchaseOrders
func boot(routes: any RoutesBuilder) throws {
let route = routes.protected.grouped("purchase-orders")
route.get(use: index)
route.get("next", use: nextPage)
route.post(use: create(req:))
route.group("create") {
$0.get(use: form)
}
route.group(":id") {
$0.get(use: get)
}
}
@Sendable
func index(req: Request) async throws -> HTMLResponse {
let page = try? req.query.decode(IndexQuery.self)
return try await req.render { try await mainPage(PurchaseOrderForm(), page: page ?? .default) }
}
@Sendable
func nextPage(req: Request) async throws -> HTMLResponse {
let query = try req.query.decode(IndexQuery.self)
let page = try await purchaseOrders.fetchPage(.init(page: query.page, per: query.limit))
return await req.render { PurchaseOrderTable.Rows(page: page) }
}
@Sendable
func form(req: Request) async throws -> HTMLResponse {
guard req.isHtmxRequest else {
return try await req.render {
try await mainPage(PurchaseOrderForm(shouldShow: true), page: .default)
}
}
return await req.render { PurchaseOrderForm(shouldShow: true) }
}
@Sendable
func get(req: Request) async throws -> HTMLResponse {
let purchaseOrder = try await purchaseOrders.get(req.ensureIDPathComponent(as: Int.self))
let form = PurchaseOrderForm(purchaseOrder: purchaseOrder, shouldShow: true)
guard req.isHtmxRequest else {
return try await req.render {
try await mainPage(form, page: .default)
}
}
return await req.render { form }
}
@Sendable
func create(req: Request) async throws -> HTMLResponse {
let create = try req.content.decode(CreateContext.self).toIntermediate()
let user = try req.auth.require(User.self)
let purchaseOrder = try await purchaseOrders.create(create.toCreate(createdByID: user.id))
return await req.render { PurchaseOrderTable.Row(purchaseOrder: purchaseOrder) }
}
// @Sendable
// func postSearch(req: Request) async throws -> HTMLResponse {
// let context = try req.content.decode(PurchaseOrderSearchContent.self)
// let results = try await purchaseOrders.search(context.toDatabaseQuery(), .init(page: 1, per: 25))
// return await req.render { PurchaseOrderTable(page: results, context: .search, searchContext: nil) }
// }
// Show the form to generate a search query.
// @Sendable
// func getSearch(req: Request) async throws -> HTMLResponse {
// // TODO: Need to handle updating the form.
// return await req.render {
// MainPage(displayNav: true, route: .purchaseOrders) {
// div(.class("container"), .id("purchase-order-content")) {
// PurchaseOrderSearch()
// PurchaseOrderTable(page: .init(items: [], metadata: .init(page: 0, per: 50, total: 0)))
// }
// }
// }
// }
private func mainPage<C: HTML>(
_ html: C,
page: IndexQuery
) async throws -> some SendableHTMLDocument where C: Sendable {
let page = try await purchaseOrders.fetchPage(.init(page: page.page, per: page.limit))
return MainPage(displayNav: true, route: .purchaseOrders) {
div(.class("container"), .id("purchase-order-content")) {
html
PurchaseOrderTable(page: page)
}
}
}
}
struct IndexQuery: Content {
let page: Int
let limit: Int
static var `default`: Self {
.init(page: 1, limit: 25)
}
}
private struct CreateContext: Content {
let id: Int?
let workOrder: String
let materials: String
let customer: String
let truckStock: Bool?
let createdForID: Employee.ID
let vendorBranchID: VendorBranch.ID
func toIntermediate() -> PurchaseOrder.CreateIntermediate {
.init(
id: id,
workOrder: workOrder.isEmpty ? nil : Int(workOrder),
materials: materials,
customer: customer,
truckStock: truckStock,
createdForID: createdForID,
vendorBranchID: vendorBranchID
)
}
}

79
Sources/App/Controllers/View/UsersViewController.swift
View File

@@ -1,79 +0,0 @@
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)
}
}
}
}

54
Sources/App/Controllers/View/UtilsViewController.swift
View File

@@ -1,54 +0,0 @@
import DatabaseClient
import Dependencies
import SharedModels
import Vapor
import VaporElementary
struct UtilsViewController: RouteCollection {
@Dependency(\.database) var database
func boot(routes: any RoutesBuilder) throws {
let route = routes.protected
route.group("select") {
$0.get("employee", use: employeeSelect(req:))
$0.get("vendor-branches", use: vendorBranchSelect(req:))
}
}
@Sendable
func employeeSelect(req: Request) async throws -> HTMLResponse {
let context = try req.query.decode(SelectQueryContext.self)
let employees = try await database.employees.fetchAll()
return await req.render { context.toHTML(employees: employees) }
}
@Sendable
func vendorBranchSelect(req: Request) async throws -> HTMLResponse {
let context = try req.query.decode(SelectQueryContext.self)
let branches = try await database.vendorBranches.fetchAllWithDetail()
return await req.render { context.toHTML(branches: branches) }
}
}
private struct SelectQueryContext: Content {
let context: SelectContext
func toHTML(employees: [Employee]) -> EmployeeSelect {
switch context {
case .purchaseOrderForm:
return .purchaseOrderForm(employees: employees)
case .purchaseOrderSearch:
return .purchaseOrderSearch(employees: employees)
}
}
func toHTML(branches: [VendorBranch.Detail]) -> VendorBranchSelect {
switch context {
case .purchaseOrderForm:
return .purchaseOrderForm(branches: branches)
case .purchaseOrderSearch:
return .purchaseOrderSearch(branches: branches)
}
}
}

98
Sources/App/Controllers/View/VendorViewController.swift
View File

@@ -1,98 +0,0 @@
import DatabaseClient
import Dependencies
import Elementary
import SharedModels
import Vapor
import VaporElementary
struct VendorViewController: RouteCollection {
@Dependency(\.database.vendors) var vendors
@Dependency(\.database.vendorBranches) var vendorBranches
func boot(routes: any RoutesBuilder) throws {
let route = routes.protected.grouped("vendors")
route.get(use: index)
route.post(use: create)
route.get("create", use: form)
route.group(":id") {
$0.get(use: detail)
$0.put(use: update)
$0.post("branches", use: createBranch(req:))
}
}
@Sendable
func index(req: Request) async throws -> HTMLResponse {
try await req.render {
try await mainPage(VendorForm())
}
}
@Sendable
func create(req: Request) async throws -> HTMLResponse {
let vendor = try await vendors.create(req.content.decode(Vendor.Create.self))
let vendors = try await vendors.fetchAll(.withBranches)
return await req.render {
div(.class("container"), .id("content")) {
VendorDetail(vendor: vendor)
VendorTable(vendors: vendors)
}
}
}
@Sendable
func form(req: Request) async throws -> HTMLResponse {
await req.render { VendorForm(.float(shouldShow: true)) }
}
@Sendable
func detail(req: Request) async throws -> HTMLResponse {
guard let vendor = try await vendors.get(req.ensureIDPathComponent(), .withBranches) else {
throw Abort(.badRequest, reason: "Vendor does not exist.")
}
let html = VendorDetail(vendor: vendor)
guard req.isHtmxRequest else {
return try await req.render { try await mainPage(html) }
}
return await req.render { html }
}
@Sendable
func update(req: Request) async throws -> HTMLResponse {
let vendor = try await vendors.update(
req.ensureIDPathComponent(),
with: req.content.decode(Vendor.Update.self),
returnWithBranches: true
)
return await req.render { VendorDetail(vendor: vendor) }
}
@Sendable
func createBranch(req: Request) async throws -> HTMLResponse {
let vendorID = try req.ensureIDPathComponent()
let create = try req.content.decode(CreateBranch.self)
let branch = try await vendorBranches.create(.init(name: create.name, vendorID: vendorID))
return await req.render { VendorDetail.BranchRow(branch: branch) }
}
@Sendable
func deleteBranch(req: Request) async throws -> HTTPStatus {
try await vendorBranches.delete(req.ensureIDPathComponent(key: "branchID"))
return .ok
}
private func mainPage<C: HTML>(_ html: C) async throws -> some SendableHTMLDocument where C: Sendable {
let vendors = try await vendors.fetchAll(.withBranches)
return MainPage(displayNav: true, route: .vendors) {
div(.class("container"), .id("content")) {
html
VendorTable(vendors: vendors)
}
}
}
}
struct CreateBranch: Content {
let name: String
}

383
Sources/App/Controllers/ViewController.swift Normal file
View File

@@ -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)
}
}
}