416 lines
12 KiB
Swift
416 lines
12 KiB
Swift
import DatabaseClientLive
|
|
import Dependencies
|
|
import Elementary
|
|
import SharedModels
|
|
import Vapor
|
|
|
|
private let viewProtectedMiddleware: [any Middleware] = [
|
|
UserPasswordAuthenticator(),
|
|
UserSessionAuthenticator(),
|
|
User.redirectMiddleware { req in
|
|
"/login?next=\(req.url)"
|
|
}
|
|
]
|
|
|
|
extension SharedModels.ViewRoute {
|
|
|
|
var middleware: [any Middleware]? {
|
|
switch self {
|
|
case let .employee(route): return route.middleware
|
|
case .login: return nil
|
|
case let .purchaseOrder(route): return route.middleware
|
|
case let .user(route): return route.middleware
|
|
case let .vendor(route): return route.middleware
|
|
case let .vendorBranch(route): return route.middleware
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
var middleware: [any Middleware]? { viewProtectedMiddleware }
|
|
|
|
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)
|
|
}
|
|
|
|
var middleware: [any Middleware]? { viewProtectedMiddleware }
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
var middleware: [any Middleware]? {
|
|
viewProtectedMiddleware
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
var middleware: [any Middleware]? { viewProtectedMiddleware }
|
|
|
|
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 {
|
|
|
|
var middleware: [any Middleware]? { viewProtectedMiddleware }
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|