949c395fbf
Die Stammdaten-Kategorien waren nur eingerueckt und immer komplett offen. Jetzt lassen sich Unterkategorien per Pfeil ein- und ausklappen (wie im Web): zugeklappt zeigt die Zeile "N ausgeblendet". Anlegen, Umbenennen (Antippen) und Loeschen (wischen) bleiben unveraendert. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
769 lines
27 KiB
Swift
769 lines
27 KiB
Swift
import SwiftUI
|
||
|
||
/// Verwaltungs-Tab: alles, was Stammdaten sind, plus die Serverliste.
|
||
struct AdminTabView: View {
|
||
@EnvironmentObject private var session: Session
|
||
@State private var manageShown = false
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
List {
|
||
Section("Stammdaten") {
|
||
NavigationLink { LocationsView() } label: {
|
||
Label("Lagerorte", systemImage: "mappin.and.ellipse")
|
||
}
|
||
NavigationLink { UnitsView() } label: {
|
||
Label("Einheiten", systemImage: "ruler")
|
||
}
|
||
NavigationLink { PackageTypesView() } label: {
|
||
Label("Gebinde", systemImage: "shippingbox")
|
||
}
|
||
NavigationLink { CategoriesView() } label: {
|
||
Label("Kategorien", systemImage: "folder")
|
||
}
|
||
NavigationLink { GroupsView() } label: {
|
||
Label("Gruppen", systemImage: "square.stack.3d.up")
|
||
}
|
||
NavigationLink { ShopsView() } label: {
|
||
Label("Shops", systemImage: "cart")
|
||
}
|
||
}
|
||
|
||
Section("App") {
|
||
Button {
|
||
manageShown = true
|
||
} label: {
|
||
Label("Server verwalten", systemImage: "server.rack")
|
||
}
|
||
}
|
||
|
||
Section {
|
||
Button("Abmelden", role: .destructive) { session.logout() }
|
||
} footer: {
|
||
Text("Benutzer, Einstellungen und Sicherungen bleiben der Web-Oberfläche vorbehalten.")
|
||
}
|
||
}
|
||
.navigationTitle("Verwaltung")
|
||
.sheet(isPresented: $manageShown) { ServerListView() }
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Gemeinsamer Bauplan
|
||
|
||
/// Ein Eintrag, wie ihn die Stammdatenliste braucht - unabhaengig davon, ob
|
||
/// dahinter ein Lagerort, eine Einheit oder ein Gebinde steckt.
|
||
struct MasterDataItem: Identifiable, Equatable {
|
||
let id: Int
|
||
let title: String
|
||
let subtitle: String
|
||
/// Eingebautes laesst sich umbenennen, aber nicht loeschen.
|
||
let isBuiltin: Bool
|
||
}
|
||
|
||
/// Liste mit Anlegen, Umbenennen und Loeschen.
|
||
///
|
||
/// Alle fuenf Stammdatenbereiche sehen gleich aus und unterscheiden sich nur
|
||
/// darin, *wie* geladen und geschrieben wird. Genau das wird hier
|
||
/// hereingereicht, statt die Ansicht fuenfmal zu schreiben.
|
||
struct MasterDataListView<Editor: View>: View {
|
||
let title: String
|
||
/// Einzahl fuer Meldungen ("Lagerort").
|
||
let singular: String
|
||
let load: () async throws -> [MasterDataItem]
|
||
let delete: ((Int) async throws -> Void)?
|
||
/// Baut den Editor zum Anlegen (`nil`) oder Bearbeiten eines Eintrags.
|
||
@ViewBuilder let editor: (MasterDataItem?, @escaping () -> Void) -> Editor
|
||
|
||
@State private var items: [MasterDataItem] = []
|
||
@State private var busy = true
|
||
@State private var error: String?
|
||
@State private var editing: MasterDataItem?
|
||
@State private var addShown = false
|
||
@State private var pendingDeletion: MasterDataItem?
|
||
|
||
var body: some View {
|
||
List {
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
ForEach(items) { item in
|
||
Button {
|
||
editing = item
|
||
} label: {
|
||
HStack {
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
Text(item.title).foregroundStyle(.primary)
|
||
if !item.subtitle.isEmpty {
|
||
Text(item.subtitle).font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
Spacer()
|
||
if item.isBuiltin {
|
||
Text("eingebaut").font(.caption2).foregroundStyle(.tertiary)
|
||
}
|
||
}
|
||
}
|
||
.swipeActions(edge: .trailing) {
|
||
// Eingebautes bekommt gar nicht erst einen Loeschknopf.
|
||
if delete != nil && !item.isBuiltin {
|
||
Button("Löschen", role: .destructive) { pendingDeletion = item }
|
||
}
|
||
}
|
||
}
|
||
if items.isEmpty && !busy {
|
||
Text("Noch nichts angelegt.").foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
.navigationTitle(title)
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("Hinzufügen", systemImage: "plus") { addShown = true }
|
||
}
|
||
}
|
||
.sheet(isPresented: $addShown) {
|
||
editor(nil) { Task { await reload() } }
|
||
}
|
||
.sheet(item: $editing) { item in
|
||
editor(item) { Task { await reload() } }
|
||
}
|
||
.confirmationDialog(
|
||
pendingDeletion.map { "„\($0.title)“ löschen?" } ?? "",
|
||
isPresented: Binding(get: { pendingDeletion != nil },
|
||
set: { if !$0 { pendingDeletion = nil } }),
|
||
titleVisibility: .visible
|
||
) {
|
||
Button("Löschen", role: .destructive) {
|
||
if let item = pendingDeletion { Task { await remove(item) } }
|
||
pendingDeletion = nil
|
||
}
|
||
Button("Abbrechen", role: .cancel) { pendingDeletion = nil }
|
||
} message: {
|
||
Text("Wird \(singular.lowercased()) noch verwendet, lehnt der Server das Löschen ab.")
|
||
}
|
||
.refreshable { await reload() }
|
||
.task { await reload() }
|
||
}
|
||
|
||
private func reload() async {
|
||
busy = true
|
||
defer { busy = false }
|
||
do {
|
||
items = try await load()
|
||
error = nil
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
private func remove(_ item: MasterDataItem) async {
|
||
guard let delete else { return }
|
||
do {
|
||
try await delete(item.id)
|
||
error = nil
|
||
await reload()
|
||
} catch {
|
||
// Der Server begruendet die Ablehnung ("wird noch verwendet") -
|
||
// die Meldung unveraendert zeigen.
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Kleiner Editor fuer alles, was nur einen Namen hat.
|
||
struct NameEditor: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
|
||
let title: String
|
||
let label: String
|
||
let initial: String
|
||
let save: (String) async throws -> Void
|
||
let done: () -> Void
|
||
|
||
@State private var name: String
|
||
@State private var error: String?
|
||
@State private var busy = false
|
||
|
||
init(title: String, label: String = "Name", initial: String = "",
|
||
save: @escaping (String) async throws -> Void, done: @escaping () -> Void) {
|
||
self.title = title
|
||
self.label = label
|
||
self.initial = initial
|
||
self.save = save
|
||
self.done = done
|
||
_name = State(initialValue: initial)
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section(label) {
|
||
TextField(label, text: $name)
|
||
}
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
}
|
||
.navigationTitle(title)
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Abbrechen") { dismiss() }
|
||
}
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button(busy ? "Sichern…" : "Sichern") { Task { await submit() } }
|
||
.disabled(busy || name.trimmingCharacters(in: .whitespaces).isEmpty)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func submit() async {
|
||
busy = true
|
||
defer { busy = false }
|
||
do {
|
||
try await save(name.trimmingCharacters(in: .whitespaces))
|
||
done()
|
||
dismiss()
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Die fuenf Bereiche
|
||
|
||
struct LocationsView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Lagerorte",
|
||
singular: "Der Lagerort",
|
||
load: {
|
||
try await APIClient.shared.locations().map {
|
||
MasterDataItem(id: $0.id, title: $0.name, subtitle: "", isBuiltin: false)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deleteLocation(id: $0) }
|
||
) { item, done in
|
||
NameEditor(
|
||
title: item == nil ? "Lagerort anlegen" : "Lagerort umbenennen",
|
||
initial: item?.title ?? "",
|
||
save: { name in
|
||
if let item {
|
||
_ = try await APIClient.shared.renameLocation(id: item.id, name: name)
|
||
} else {
|
||
_ = try await APIClient.shared.createLocation(
|
||
NewLocationRequest(name: name, parentId: nil))
|
||
}
|
||
},
|
||
done: done
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct UnitsView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Einheiten",
|
||
singular: "Die Einheit",
|
||
load: {
|
||
try await APIClient.shared.units().map {
|
||
MasterDataItem(id: $0.id, title: $0.name,
|
||
subtitle: "\(UnitsView.artText($0.kind)) · Faktor \(formatAmount($0.factor))",
|
||
isBuiltin: $0.isBuiltin)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deleteUnit(id: $0) }
|
||
) { item, done in
|
||
if let item {
|
||
NameEditor(
|
||
title: "Einheit umbenennen",
|
||
initial: item.title,
|
||
save: { _ = try await APIClient.shared.renameUnit(id: item.id, name: $0) },
|
||
done: done
|
||
)
|
||
} else {
|
||
NewUnitEditor(done: done)
|
||
}
|
||
}
|
||
}
|
||
|
||
private static func artText(_ kind: String) -> String {
|
||
switch kind {
|
||
case "count": return "Anzahl"
|
||
case "weight": return "Gewicht"
|
||
case "volume": return "Volumen"
|
||
default: return kind
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Einheiten brauchen beim Anlegen Art und Faktor - danach stehen beide fest,
|
||
/// weil sie in bereits umgerechneten Bestaenden stecken.
|
||
struct NewUnitEditor: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
let done: () -> Void
|
||
|
||
@State private var name = ""
|
||
@State private var kind = "weight"
|
||
@State private var factor = "1"
|
||
@State private var error: String?
|
||
@State private var busy = false
|
||
|
||
private var faktorWert: Double? {
|
||
Double(factor.replacingOccurrences(of: ",", with: "."))
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section("Name") {
|
||
TextField("z. B. Beutel", text: $name)
|
||
}
|
||
Section("Art") {
|
||
Picker("Art", selection: $kind) {
|
||
Text("Anzahl").tag("count")
|
||
Text("Gewicht").tag("weight")
|
||
Text("Volumen").tag("volume")
|
||
}
|
||
.pickerStyle(.segmented)
|
||
}
|
||
Section {
|
||
TextField("1", text: $factor).keyboardType(.decimalPad)
|
||
} header: {
|
||
Text("Faktor")
|
||
} footer: {
|
||
Text("Wie viele Basiseinheiten ergibt eine Einheit? Ein Kilogramm hat den Faktor 1000, weil die Basiseinheit Gramm ist.")
|
||
}
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
}
|
||
.navigationTitle("Einheit anlegen")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Abbrechen") { dismiss() }
|
||
}
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("Sichern") { Task { await submit() } }
|
||
.disabled(busy || name.isEmpty || (faktorWert ?? 0) <= 0)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func submit() async {
|
||
guard let wert = faktorWert else { return }
|
||
busy = true
|
||
defer { busy = false }
|
||
do {
|
||
_ = try await APIClient.shared.createUnit(
|
||
NewUnitRequest(name: name.trimmingCharacters(in: .whitespaces),
|
||
kind: kind, factor: wert))
|
||
done()
|
||
dismiss()
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|
||
|
||
struct PackageTypesView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Gebinde",
|
||
singular: "Das Gebinde",
|
||
load: {
|
||
try await APIClient.shared.packageTypes().map {
|
||
MasterDataItem(id: $0.id, title: $0.singular,
|
||
subtitle: "Mehrzahl: \($0.plural)", isBuiltin: $0.isBuiltin)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deletePackageType(id: $0) }
|
||
) { item, done in
|
||
PackageTypeEditor(id: item?.id,
|
||
singular: item?.title ?? "",
|
||
plural: item.map { PackageTypesView.plural(from: $0.subtitle) } ?? "",
|
||
done: done)
|
||
}
|
||
}
|
||
|
||
/// Der Untertitel traegt die Mehrzahl - hier wieder heraus.
|
||
private static func plural(from subtitle: String) -> String {
|
||
subtitle.replacingOccurrences(of: "Mehrzahl: ", with: "")
|
||
}
|
||
}
|
||
|
||
/// Gebinde haben Einzahl **und** Mehrzahl (siehe Commit "Gebinde verwalten").
|
||
struct PackageTypeEditor: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
|
||
let id: Int?
|
||
let done: () -> Void
|
||
|
||
@State private var singular: String
|
||
@State private var plural: String
|
||
@State private var error: String?
|
||
@State private var busy = false
|
||
|
||
init(id: Int?, singular: String, plural: String, done: @escaping () -> Void) {
|
||
self.id = id
|
||
self.done = done
|
||
_singular = State(initialValue: singular)
|
||
_plural = State(initialValue: plural)
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section("Einzahl") {
|
||
TextField("z. B. Glas", text: $singular)
|
||
}
|
||
Section {
|
||
TextField(singular.isEmpty ? "z. B. Gläser" : singular, text: $plural)
|
||
} header: {
|
||
Text("Mehrzahl")
|
||
} footer: {
|
||
Text("Ohne Angabe wird die Einzahl verwendet.")
|
||
}
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
}
|
||
.navigationTitle(id == nil ? "Gebinde anlegen" : "Gebinde bearbeiten")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Abbrechen") { dismiss() }
|
||
}
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("Sichern") { Task { await submit() } }
|
||
.disabled(busy || singular.trimmingCharacters(in: .whitespaces).isEmpty)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func submit() async {
|
||
busy = true
|
||
defer { busy = false }
|
||
let einzahl = singular.trimmingCharacters(in: .whitespaces)
|
||
let mehrzahl = plural.trimmingCharacters(in: .whitespaces).isEmpty
|
||
? einzahl : plural.trimmingCharacters(in: .whitespaces)
|
||
do {
|
||
if let id {
|
||
_ = try await APIClient.shared.updatePackageType(
|
||
id: id, PackageTypeUpdateRequest(singular: einzahl, plural: mehrzahl))
|
||
} else {
|
||
_ = try await APIClient.shared.createPackageType(
|
||
NewPackageTypeRequest(singular: einzahl, plural: mehrzahl))
|
||
}
|
||
done()
|
||
dismiss()
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Kategorien als ein-/ausklappbarer Baum (wie im Web). Ein Pfeil klappt die
|
||
/// Unterkategorien auf und zu; Anlegen, Umbenennen und Löschen bleiben.
|
||
struct CategoriesView: View {
|
||
@State private var categories: [CategoryItem] = []
|
||
@State private var collapsed: Set<Int> = []
|
||
@State private var busy = true
|
||
@State private var error: String?
|
||
@State private var editing: CategoryItem?
|
||
@State private var addShown = false
|
||
@State private var pendingDeletion: CategoryItem?
|
||
|
||
private struct Node: Identifiable {
|
||
let item: CategoryItem
|
||
let depth: Int
|
||
var id: Int { item.id }
|
||
}
|
||
|
||
/// Baumreihenfolge mit Tiefe. Waisen (Oberkategorie gelöscht) gelten als
|
||
/// oberste Ebene, damit nichts verschwindet.
|
||
private var nodes: [Node] {
|
||
let ids = Set(categories.map(\.id))
|
||
var result: [Node] = []
|
||
func walk(_ node: CategoryItem, _ depth: Int) {
|
||
result.append(Node(item: node, depth: depth))
|
||
for child in categories.filter({ $0.parentId == node.id }) {
|
||
walk(child, depth + 1)
|
||
}
|
||
}
|
||
for root in categories.filter({ $0.parentId == nil || !ids.contains($0.parentId!) }) {
|
||
walk(root, 0)
|
||
}
|
||
return result
|
||
}
|
||
|
||
private func childCount(_ id: Int) -> Int {
|
||
categories.filter { $0.parentId == id }.count
|
||
}
|
||
|
||
/// Sichtbar ist ein Knoten, solange keiner seiner Vorfahren zugeklappt ist.
|
||
private var visible: [Node] {
|
||
let parent = Dictionary(uniqueKeysWithValues: categories.map { ($0.id, $0.parentId) })
|
||
func verborgen(_ id: Int) -> Bool {
|
||
var p = parent[id] ?? nil
|
||
while let cur = p {
|
||
if collapsed.contains(cur) { return true }
|
||
p = parent[cur] ?? nil
|
||
}
|
||
return false
|
||
}
|
||
return nodes.filter { !verborgen($0.item.id) }
|
||
}
|
||
|
||
var body: some View {
|
||
List {
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
ForEach(visible) { node in
|
||
row(node)
|
||
.swipeActions(edge: .trailing) {
|
||
Button("Löschen", role: .destructive) { pendingDeletion = node.item }
|
||
}
|
||
}
|
||
if categories.isEmpty && !busy {
|
||
Text("Noch keine Kategorien.").foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
.navigationTitle("Kategorien")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("Hinzufügen", systemImage: "plus") { addShown = true }
|
||
}
|
||
}
|
||
.sheet(isPresented: $addShown) {
|
||
NameEditor(
|
||
title: "Kategorie anlegen",
|
||
save: { _ = try await APIClient.shared.createCategory(
|
||
NewCategoryRequest(name: $0, parentId: nil)) },
|
||
done: { Task { await reload() } }
|
||
)
|
||
}
|
||
.sheet(item: $editing) { item in
|
||
NameEditor(
|
||
title: "Kategorie umbenennen",
|
||
initial: item.name,
|
||
save: { _ = try await APIClient.shared.renameCategory(id: item.id, name: $0) },
|
||
done: { Task { await reload() } }
|
||
)
|
||
}
|
||
.confirmationDialog(
|
||
pendingDeletion.map { "„\($0.name)“ löschen?" } ?? "",
|
||
isPresented: Binding(get: { pendingDeletion != nil },
|
||
set: { if !$0 { pendingDeletion = nil } }),
|
||
titleVisibility: .visible
|
||
) {
|
||
Button("Löschen", role: .destructive) {
|
||
if let item = pendingDeletion { Task { await remove(item) } }
|
||
pendingDeletion = nil
|
||
}
|
||
Button("Abbrechen", role: .cancel) { pendingDeletion = nil }
|
||
} message: {
|
||
Text("Unterkategorien rücken eine Ebene nach oben. Eigene Felder dieser Kategorie werden entfernt.")
|
||
}
|
||
.refreshable { await reload() }
|
||
.task { await reload() }
|
||
}
|
||
|
||
@ViewBuilder
|
||
private func row(_ node: Node) -> some View {
|
||
let kinder = childCount(node.item.id)
|
||
let zu = collapsed.contains(node.item.id)
|
||
HStack(spacing: 8) {
|
||
if kinder > 0 {
|
||
Button {
|
||
withAnimation(.easeInOut(duration: 0.15)) { toggle(node.item.id) }
|
||
} label: {
|
||
Image(systemName: "chevron.right")
|
||
.font(.caption.weight(.semibold))
|
||
.foregroundStyle(.secondary)
|
||
.rotationEffect(.degrees(zu ? 0 : 90))
|
||
.frame(width: 18)
|
||
}
|
||
.buttonStyle(.plain)
|
||
} else {
|
||
Color.clear.frame(width: 18, height: 1)
|
||
}
|
||
Button {
|
||
editing = node.item
|
||
} label: {
|
||
HStack(spacing: 8) {
|
||
Text(node.item.name).foregroundStyle(.primary)
|
||
if zu && kinder > 0 {
|
||
Text("\(kinder) ausgeblendet")
|
||
.font(.caption2).foregroundStyle(.tertiary)
|
||
}
|
||
Spacer()
|
||
}
|
||
.contentShape(Rectangle())
|
||
}
|
||
.buttonStyle(.plain)
|
||
}
|
||
.padding(.leading, CGFloat(node.depth) * 16)
|
||
}
|
||
|
||
private func toggle(_ id: Int) {
|
||
if collapsed.contains(id) { collapsed.remove(id) } else { collapsed.insert(id) }
|
||
}
|
||
|
||
private func reload() async {
|
||
busy = true
|
||
defer { busy = false }
|
||
do {
|
||
categories = try await APIClient.shared.categories()
|
||
error = nil
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
private func remove(_ item: CategoryItem) async {
|
||
do {
|
||
try await APIClient.shared.deleteCategory(id: item.id)
|
||
error = nil
|
||
await reload()
|
||
} catch {
|
||
// Der Server begründet die Ablehnung – die Meldung unverändert zeigen.
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|
||
|
||
struct GroupsView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Gruppen",
|
||
singular: "Die Gruppe",
|
||
load: {
|
||
try await APIClient.shared.groups().map {
|
||
MasterDataItem(id: $0.id, title: $0.name, subtitle: "", isBuiltin: false)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deleteGroup(id: $0) }
|
||
) { item, done in
|
||
NameEditor(
|
||
title: item == nil ? "Gruppe anlegen" : "Gruppe umbenennen",
|
||
initial: item?.title ?? "",
|
||
save: { name in
|
||
if let item {
|
||
_ = try await APIClient.shared.renameGroup(id: item.id, name: name)
|
||
} else {
|
||
_ = try await APIClient.shared.createGroup(
|
||
NewGroupRequest(name: name, minStock: nil, minStockUnitId: nil))
|
||
}
|
||
},
|
||
done: done
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Bezugsquellen für „gekauft bei" (nur Gegenstände). Wie im Web pflegbar –
|
||
/// Name plus optionale Website.
|
||
struct ShopsView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Shops",
|
||
singular: "Der Shop",
|
||
load: {
|
||
try await APIClient.shared.shops().map {
|
||
// Die Website steht im Untertitel und wird beim Bearbeiten
|
||
// wieder daraus gelesen (wie bei den Gebinden die Mehrzahl).
|
||
MasterDataItem(id: $0.id, title: $0.name,
|
||
subtitle: $0.website ?? "", isBuiltin: false)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deleteShop(id: $0) }
|
||
) { item, done in
|
||
ShopEditor(id: item?.id,
|
||
name: item?.title ?? "",
|
||
website: item?.subtitle ?? "",
|
||
done: done)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Shops haben Name und optionale Website.
|
||
struct ShopEditor: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
|
||
let id: Int?
|
||
let done: () -> Void
|
||
|
||
@State private var name: String
|
||
@State private var website: String
|
||
@State private var error: String?
|
||
@State private var busy = false
|
||
|
||
init(id: Int?, name: String, website: String, done: @escaping () -> Void) {
|
||
self.id = id
|
||
self.done = done
|
||
_name = State(initialValue: name)
|
||
_website = State(initialValue: website)
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section("Name") {
|
||
TextField("z. B. Digitec", text: $name)
|
||
}
|
||
Section {
|
||
TextField("https://…", text: $website)
|
||
.keyboardType(.URL)
|
||
.textInputAutocapitalization(.never)
|
||
.autocorrectionDisabled()
|
||
} header: {
|
||
Text("Website (optional)")
|
||
}
|
||
if let error {
|
||
Section { Text(error).foregroundStyle(.red).font(.callout) }
|
||
}
|
||
}
|
||
.navigationTitle(id == nil ? "Shop anlegen" : "Shop bearbeiten")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Abbrechen") { dismiss() }
|
||
}
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button(busy ? "Sichern…" : "Sichern") { Task { await submit() } }
|
||
.disabled(busy || name.trimmingCharacters(in: .whitespaces).isEmpty)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func submit() async {
|
||
busy = true
|
||
defer { busy = false }
|
||
let n = name.trimmingCharacters(in: .whitespaces)
|
||
// Leeres Feld bewusst als "" senden (nicht nil): der Server setzt die
|
||
// Website damit auf leer – so lässt sie sich auch wieder entfernen.
|
||
let w = website.trimmingCharacters(in: .whitespaces)
|
||
do {
|
||
if let id {
|
||
_ = try await APIClient.shared.updateShop(id: id, ShopUpdateRequest(name: n, website: w))
|
||
} else {
|
||
_ = try await APIClient.shared.createShop(NewShopRequest(name: n, website: w))
|
||
}
|
||
done()
|
||
dismiss()
|
||
} catch {
|
||
self.error = error.localizedDescription
|
||
}
|
||
}
|
||
}
|