6b597313d5
Die iOS-Stammdaten hatten keinen Punkt fuer Shops – die "gekauft bei"-Liste war nur im Web pflegbar. Jetzt gibt es unter Verwaltung > Stammdaten "Shops" mit Anlegen, Bearbeiten (Name + optionale Website) und Loeschen, analog zum Web. Client um createShop/updateShop/deleteShop samt Request-Models ergaenzt. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
653 lines
23 KiB
Swift
653 lines
23 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
|
||
}
|
||
}
|
||
}
|
||
|
||
struct CategoriesView: View {
|
||
var body: some View {
|
||
MasterDataListView(
|
||
title: "Kategorien",
|
||
singular: "Die Kategorie",
|
||
load: {
|
||
let alle = try await APIClient.shared.categories()
|
||
// Baumreihenfolge mit Einrueckung, damit die Verschachtelung
|
||
// sichtbar bleibt (wie in der Produktliste).
|
||
return CategoriesView.tree(alle).map {
|
||
MasterDataItem(id: $0.item.id,
|
||
title: String(repeating: " ", count: $0.depth) + $0.item.name,
|
||
subtitle: "", isBuiltin: false)
|
||
}
|
||
},
|
||
delete: { try await APIClient.shared.deleteCategory(id: $0) }
|
||
) { item, done in
|
||
NameEditor(
|
||
title: item == nil ? "Kategorie anlegen" : "Kategorie umbenennen",
|
||
initial: item?.title.trimmingCharacters(in: .whitespaces) ?? "",
|
||
save: { name in
|
||
if let item {
|
||
_ = try await APIClient.shared.renameCategory(id: item.id, name: name)
|
||
} else {
|
||
_ = try await APIClient.shared.createCategory(
|
||
NewCategoryRequest(name: name, parentId: nil))
|
||
}
|
||
},
|
||
done: done
|
||
)
|
||
}
|
||
}
|
||
|
||
private struct Node {
|
||
let item: CategoryItem
|
||
let depth: Int
|
||
}
|
||
|
||
private static func tree(_ categories: [CategoryItem]) -> [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)
|
||
}
|
||
}
|
||
// Waisen (Oberkategorie geloescht) gelten als oberste Ebene.
|
||
for root in categories.filter({ $0.parentId == nil || !ids.contains($0.parentId!) }) {
|
||
walk(root, 0)
|
||
}
|
||
return result
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|
||
}
|
||
}
|