Rezept-App mit Online-API (Teil 3)

struct CategoryResponse: Decodable {
    let categories: [Category]
}

struct Category: Decodable, Identifiable, Hashable {
    let id: String
    let name: String
    let thumbnail: String?

    enum CodingKeys: String, CodingKey {
        case id = "idCategory"
        case name = "strCategory"
        case thumbnail = "strCategoryThumb"
    }
}

func categories() async throws -> [Category] {
    let response: CategoryResponse = try await fetch("categories.php")
    return response.categories
}

var categories: [Category] = []

func loadCategories() async {
    guard categories.isEmpty else { return }
    categories = (try? await api.categories()) ?? []
}

.toolbar {
    Menu("Kategorie", systemImage: "line.3.horizontal.decrease.circle") {
        Picker("Kategorie", selection: $viewModel.category) {
            ForEach(viewModel.categories) { category in
                Text(category.name).tag(category.name)
            }
        }
    }
}
.task {
    await viewModel.loadCategories()
}
.task(id: viewModel.category) {
    await viewModel.load()
}

func search(_ query: String) async throws -> [Meal] {
    let response: MealResponse = try await fetch("search.php", query: ["s": query])
    return response.meals ?? []
}

var searchText = ""

struct Query: Equatable {
    let category: String
    let search: String
}

var query: Query {
    Query(category: category, search: searchText.trimmingCharacters(in: .whitespaces))
}

var title: String {
    query.search.isEmpty ? category : "Suche"
}

func refresh() async {
    do {
        let meals = if query.search.isEmpty {
            try await api.meals(in: category)
        } else {
            try await api.search(query.search)
        }
        state = .loaded(meals)
    } catch is CancellationError {
        return
    } catch let error as URLError where error.code == .cancelled {
        return
    } catch {
        print(error)
        state = .failed(message(for: error))
    }
}

func load() async {
    state = .loading
    await refresh()
}

content
    .navigationTitle(viewModel.title)
    .searchable(text: $viewModel.searchText, prompt: "Alle Rezepte durchsuchen")
    .task(id: viewModel.query) {
        if !viewModel.query.search.isEmpty {
            try? await Task.sleep(for: .milliseconds(400))
            guard !Task.isCancelled else { return }
        }
        await viewModel.load()
    }

case .loaded(let meals) where meals.isEmpty:
    if viewModel.query.search.isEmpty {
        ContentUnavailableView("Keine Rezepte", systemImage: "fork.knife")
    } else {
        ContentUnavailableView.search(text: viewModel.query.search)
    }

case .loaded(let meals):
    List(meals) { meal in
        NavigationLink(value: meal) {
            MealRow(meal: meal)
        }
    }
    .listStyle(.plain)
    .refreshable {
        await viewModel.refresh()
    }

import Observation

@Observable
class FavoritesStore {
    private(set) var ids: Set<String> = []

    func contains(id: String) -> Bool {
        ids.contains(id)
    }

    func toggle(id: String) {
        if ids.contains(id) {
            ids.remove(id)
        } else {
            ids.insert(id)
        }
    }
}

@main
struct RezepteApp: App {
    @State private var favorites = FavoritesStore()

    var body: some Scene {
        WindowGroup {
            MealListView()
                .environment(favorites)
        }
    }
}

@Environment(FavoritesStore.self) private var favorites

// im HStack, nach dem Namen:
Spacer()
if favorites.contains(id: meal.id) {
    Image(systemName: "heart.fill")
        .foregroundStyle(.pink)
}

@Environment(FavoritesStore.self) private var favorites

.toolbar {
    let isFavorite = favorites.contains(id: meal.id)
    Button(isFavorite ? "Favorit entfernen" : "Als Favorit merken",
           systemImage: isFavorite ? "heart.fill" : "heart") {
        favorites.toggle(id: meal.id)
    }
    .tint(.pink)
    .sensoryFeedback(.success, trigger: isFavorite)
}

private func message(for error: Error) -> String {
    switch error {
    case let urlError as URLError where urlError.code == .notConnectedToInternet:
        "Keine Internetverbindung. Prüfe WLAN oder mobile Daten."
    case let urlError as URLError where urlError.code == .timedOut:
        "Der Server antwortet gerade nicht. Versuch es gleich noch einmal."
    case APIError.badStatus:
        "Beim Rezept-Server ist ein Problem aufgetreten. Versuch es später erneut."
    case is DecodingError:
        "Die Rezepte konnten nicht gelesen werden."
    default:
        "Die Rezepte konnten nicht geladen werden."
    }
}

@State private var path: [Meal] = []

var body: some View {
    NavigationStack(path: $path) {
        content
            // … wie bisher …
            .toolbar {
                ToolbarItem(placement: .topBarLeading) {
                    Button("Zufallsrezept", systemImage: "dice") {
                        Task {
                            if let meal = try? await MealAPI().random() {
                                path.append(meal)
                            }
                        }
                    }
                }
            }
    }
}