376 lines
12 KiB
Swift
376 lines
12 KiB
Swift
import DatabaseClient
|
|
import Dependencies
|
|
import Elementary
|
|
import ElementaryHTMX
|
|
import Logging
|
|
import ManualDClient
|
|
import ManualDCore
|
|
import Styleguide
|
|
|
|
enum ProjectViewValue {
|
|
@TaskLocal static var projectID = Project.ID(0)
|
|
}
|
|
|
|
struct ProjectView: HTML, Sendable {
|
|
@Dependency(\.database) var database
|
|
@Dependency(\.manualD) var manualD
|
|
|
|
let projectID: Project.ID
|
|
let activeTab: SiteRoute.View.ProjectRoute.DetailRoute.Tab
|
|
let logger: Logger?
|
|
|
|
init(
|
|
projectID: Project.ID,
|
|
activeTab: SiteRoute.View.ProjectRoute.DetailRoute.Tab,
|
|
logger: Logger? = nil
|
|
) {
|
|
self.projectID = projectID
|
|
self.activeTab = activeTab
|
|
self.logger = logger
|
|
}
|
|
|
|
var body: some HTML {
|
|
div(.class("h-screen w-full")) {
|
|
|
|
div(.class("drawer lg:drawer-open")) {
|
|
input(.id("my-drawer-1"), .type(.checkbox), .class("drawer-toggle"))
|
|
|
|
div(.class("drawer-content p-4")) {
|
|
label(
|
|
.for("my-drawer-1"),
|
|
.class("btn btn-square btn-ghost drawer-button size-7 pb-6")
|
|
) {
|
|
SVG(.sidebarToggle)
|
|
}
|
|
switch self.activeTab {
|
|
case .project:
|
|
await resultView(projectID) {
|
|
guard let project = try await database.projects.get(projectID) else {
|
|
throw NotFoundError()
|
|
}
|
|
return project
|
|
} onSuccess: { project in
|
|
ProjectDetail(project: project)
|
|
}
|
|
case .rooms:
|
|
await resultView(projectID) {
|
|
try await (
|
|
database.rooms.fetch(projectID),
|
|
database.projects.getSensibleHeatRatio(projectID)
|
|
)
|
|
} onSuccess: { (rooms, shr) in
|
|
RoomsView(rooms: rooms, sensibleHeatRatio: shr)
|
|
}
|
|
|
|
case .equivalentLength:
|
|
await resultView(projectID) {
|
|
try await database.effectiveLength.fetch(projectID)
|
|
} onSuccess: {
|
|
EffectiveLengthsView(effectiveLengths: $0)
|
|
}
|
|
case .frictionRate:
|
|
|
|
await resultView(projectID) {
|
|
|
|
let equipmentInfo = try await database.equipment.fetch(projectID)
|
|
let componentLosses = try await database.componentLoss.fetch(projectID)
|
|
let equivalentLengths = try await database.effectiveLength.fetchMax(projectID)
|
|
let frictionRateResponse = try await manualD.frictionRate(
|
|
equipmentInfo: equipmentInfo,
|
|
componentLosses: componentLosses,
|
|
effectiveLength: equivalentLengths
|
|
)
|
|
return (
|
|
equipmentInfo, componentLosses, equivalentLengths, frictionRateResponse
|
|
)
|
|
} onSuccess: {
|
|
FrictionRateView(
|
|
equipmentInfo: $0.0,
|
|
componentLosses: $0.1,
|
|
equivalentLengths: $0.2,
|
|
frictionRateResponse: $0.3
|
|
)
|
|
}
|
|
case .ductSizing:
|
|
await resultView(projectID) {
|
|
try await database.calculateDuctSizes(projectID: projectID)
|
|
} onSuccess: {
|
|
DuctSizingView(rooms: $0)
|
|
}
|
|
}
|
|
}
|
|
|
|
try await Sidebar(
|
|
active: activeTab,
|
|
projectID: projectID,
|
|
completedSteps: database.projects.getCompletedSteps(projectID)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func resultView<V: Sendable, E: Error, ValueView: HTML>(
|
|
_ projectID: Project.ID,
|
|
catching: @escaping @Sendable () async throws(E) -> V,
|
|
onSuccess: @escaping @Sendable (V) -> ValueView
|
|
) async -> ResultView<V, E, _ModifiedTaskLocal<Project.ID, ValueView>, ErrorView<E>>
|
|
where
|
|
ValueView: Sendable, E: Sendable
|
|
{
|
|
await .init(
|
|
result: .init(catching: catching),
|
|
onSuccess: { result in
|
|
onSuccess(result)
|
|
.environment(ProjectViewValue.$projectID, projectID)
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
// extension SiteRoute.View.ProjectRoute.DetailRoute.Tab {
|
|
//
|
|
// func view(projectID: Project.ID) async throws -> AnySendableHTML {
|
|
// @Dependency(\.database) var database
|
|
// @Dependency(\.manualD) var manualD
|
|
//
|
|
// switch self {
|
|
// case .project:
|
|
// if let project = try await database.projects.get(projectID) {
|
|
// return ProjectDetail(project: project)
|
|
// } else {
|
|
// return div {
|
|
// "FIX ME!"
|
|
// }
|
|
// }
|
|
// case .rooms:
|
|
// return try await RoomsView(
|
|
// projectID: projectID,
|
|
// rooms: database.rooms.fetch(projectID),
|
|
// sensibleHeatRatio: database.projects.getSensibleHeatRatio(projectID)
|
|
// )
|
|
//
|
|
// case .equivalentLength:
|
|
// return try await EffectiveLengthsView(
|
|
// projectID: projectID,
|
|
// effectiveLengths: database.effectiveLength.fetch(projectID)
|
|
// )
|
|
// case .frictionRate:
|
|
// let equipmentInfo = try await database.equipment.fetch(projectID)
|
|
// let componentLosses = try await database.componentLoss.fetch(projectID)
|
|
// let equivalentLengths = try await database.effectiveLength.fetchMax(projectID)
|
|
//
|
|
// return try await FrictionRateView(
|
|
// equipmentInfo: equipmentInfo,
|
|
// componentLosses: componentLosses,
|
|
// equivalentLengths: equivalentLengths,
|
|
// projectID: projectID,
|
|
// frictionRateResponse: manualD.frictionRate(
|
|
// equipmentInfo: equipmentInfo,
|
|
// componentLosses: componentLosses,
|
|
// effectiveLength: equivalentLengths
|
|
// )
|
|
// )
|
|
// case .ductSizing:
|
|
// return try await DuctSizingView(
|
|
// projectID: projectID,
|
|
// rooms: database.calculateDuctSizes(projectID: projectID)
|
|
// )
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
extension ProjectView {
|
|
|
|
struct Sidebar: HTML {
|
|
|
|
let active: SiteRoute.View.ProjectRoute.DetailRoute.Tab
|
|
let projectID: Project.ID
|
|
let completedSteps: Project.CompletedSteps
|
|
|
|
var body: some HTML {
|
|
|
|
div(.class("drawer-side is-drawer-close:overflow-visible")) {
|
|
label(
|
|
.for("my-drawer-1"), .init(name: "aria-label", value: "close sidebar"),
|
|
.class("drawer-overlay")
|
|
) {}
|
|
|
|
div(
|
|
.class(
|
|
"""
|
|
flex min-h-full flex-col items-start bg-base-200
|
|
is-drawer-close:min-w-[80px] is-drawer-open:min-w-[340px]
|
|
"""
|
|
)
|
|
) {
|
|
|
|
ul(.class("w-full")) {
|
|
|
|
li(.class("w-full")) {
|
|
div(
|
|
.class("w-full is-drawer-close:tooltip is-drawer-close:tooltip-right"),
|
|
.data("tip", value: "All Projects")
|
|
) {
|
|
a(
|
|
.class(
|
|
"""
|
|
flex btn btn-secondary btn-square btn-block
|
|
is-drawer-close:items-center
|
|
"""
|
|
),
|
|
.hx.get(route: .project(.index)),
|
|
.hx.target("body"),
|
|
.hx.pushURL(true),
|
|
.hx.swap(.outerHTML),
|
|
) {
|
|
div(.class("flex is-drawer-open:space-x-4")) {
|
|
span { "<" }
|
|
span(.class("is-drawer-close:hidden")) { "All Projects" }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIX: Move to user profile / settings page.
|
|
li(.class("w-full is-drawer-close:hidden")) {
|
|
div(.class("flex justify-between p-4")) {
|
|
Label("Theme")
|
|
input(.type(.checkbox), .class("toggle theme-controller"), .value("light"))
|
|
}
|
|
}
|
|
|
|
li(.class("w-full")) {
|
|
row(
|
|
title: "Project",
|
|
icon: .mapPin,
|
|
route: .project(.detail(projectID, .index(tab: .project))),
|
|
isComplete: true
|
|
)
|
|
.attributes(.class("btn-active"), when: active == .project)
|
|
}
|
|
|
|
li(.class("w-full")) {
|
|
row(
|
|
title: "Rooms",
|
|
icon: .doorClosed,
|
|
route: .project(.detail(projectID, .rooms(.index))),
|
|
isComplete: completedSteps.rooms
|
|
)
|
|
.attributes(.class("btn-active"), when: active == .rooms)
|
|
}
|
|
|
|
li(.class("w-full")) {
|
|
row(
|
|
title: "Equivalent Lengths",
|
|
icon: .rulerDimensionLine,
|
|
route: .project(.detail(projectID, .equivalentLength(.index))),
|
|
isComplete: completedSteps.equivalentLength
|
|
)
|
|
.attributes(.class("btn-active"), when: active == .equivalentLength)
|
|
|
|
}
|
|
li(.class("w-full")) {
|
|
row(
|
|
title: "Friction Rate",
|
|
icon: .squareFunction,
|
|
route: .project(.detail(projectID, .frictionRate(.index))),
|
|
isComplete: completedSteps.frictionRate
|
|
)
|
|
.attributes(.class("btn-active"), when: active == .frictionRate)
|
|
|
|
}
|
|
li(.class("w-full")) {
|
|
row(
|
|
title: "Duct Sizes",
|
|
icon: .wind,
|
|
route: .project(.detail(projectID, .ductSizing(.index))),
|
|
isComplete: false,
|
|
hideIsComplete: true
|
|
)
|
|
.attributes(.class("btn-active"), when: active == .ductSizing)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: Use SiteRoute.View routes as href.
|
|
private func row(
|
|
title: String,
|
|
icon: SVG.Key,
|
|
href: String,
|
|
isComplete: Bool,
|
|
hideIsComplete: Bool = false
|
|
) -> some HTML<HTMLTag.a> {
|
|
a(
|
|
.class(
|
|
"""
|
|
flex w-full btn btn-soft btn-square btn-block
|
|
is-drawer-open:justify-between is-drawer-close:items-center
|
|
is-drawer-close:tooltip is-drawer-close:tooltip-right
|
|
"""
|
|
),
|
|
.href(href),
|
|
.data("tip", value: title)
|
|
) {
|
|
div(.class("flex is-drawer-open:space-x-4")) {
|
|
SVG(icon)
|
|
span(.class("text-xl is-drawer-close:hidden")) {
|
|
title
|
|
}
|
|
}
|
|
if !hideIsComplete {
|
|
div(.class("is-drawer-close:hidden")) {
|
|
if isComplete {
|
|
SVG(.badgeCheck)
|
|
} else {
|
|
SVG(.ban)
|
|
}
|
|
}
|
|
.attributes(.class("text-green-400"), when: isComplete)
|
|
.attributes(.class("text-error"), when: !isComplete)
|
|
}
|
|
}
|
|
.attributes(.class("is-drawer-close:text-green-400"), when: isComplete)
|
|
.attributes(.class("is-drawer-close:text-error"), when: !isComplete && !hideIsComplete)
|
|
}
|
|
|
|
private func row(
|
|
title: String,
|
|
icon: SVG.Key,
|
|
route: SiteRoute.View,
|
|
isComplete: Bool,
|
|
hideIsComplete: Bool = false
|
|
) -> some HTML<HTMLTag.a> {
|
|
row(
|
|
title: title, icon: icon, href: SiteRoute.View.router.path(for: route),
|
|
isComplete: isComplete, hideIsComplete: hideIsComplete
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ManualDClient {
|
|
|
|
func frictionRate(
|
|
equipmentInfo: EquipmentInfo?,
|
|
componentLosses: [ComponentPressureLoss],
|
|
effectiveLength: EffectiveLength.MaxContainer
|
|
) async throws -> FrictionRateResponse? {
|
|
guard let staticPressure = equipmentInfo?.staticPressure else {
|
|
return nil
|
|
}
|
|
guard let totalEquivalentLength = effectiveLength.total else {
|
|
return nil
|
|
}
|
|
return try await self.frictionRate(
|
|
.init(
|
|
externalStaticPressure: staticPressure,
|
|
componentPressureLosses: componentLosses,
|
|
totalEffectiveLength: Int(totalEquivalentLength)
|
|
)
|
|
)
|
|
}
|
|
|
|
}
|