feat(decks): γ-1 bis γ-8 — AI/CSV-Import, Card-Edit, Pull-Update, Marketplace-Publish + Moderation + PDF

Vervollständigt die Cardecky-Web-Parität für Deck- und Card-Workflows.

γ-1+γ-2 (AI-Deck-Generierung)
- 4-Modi-Picker im DeckEditorView Create-Sheet: Leer/KI/Bild/CSV
- POST /api/v1/decks/generate für Text-Prompt + 10/min Rate-Limit-UI
- POST /api/v1/decks/from-image mit PhotosPicker + PDF-Importer
  (max 5 Files, 10 MiB/Bild, 30 MiB/PDF), Multipart-Body in
  CardsAPI+Generation
- Loading-Overlay mit Task-Cancellation, Error-Mapping für 429/413/502

γ-3 (Card-Edit)
- CardEditorView mit Mode .create(deckId:) / .edit(card:)
- Image-Occlusion + Audio-Front behalten bestehenden Media-Ref, solange
  User nicht ersetzt — MediaCache lädt Bild nach
- Type-Picker im Edit-Modus aus (Server-immutable)
- CardEditorPayload + CardEditorMediaFields als Sub-Views

γ-4 (Pull-Update + Duplicate + Archive)
- POST /marketplace/private/:id/pull-update mit Smart-Merge-Anzeige
- POST /decks/:id/duplicate
- Archive-Toggle im Edit-Modus, Server filtert Liste serverseitig
- DeckSecondaryActions als eigenes Sub-View

γ-6 (CSV-Import)
- RFC-4180-ish Parser (Quote-Escape, Header-Detect, BOM-strip)
- Preview-Liste + sequentielle Card-Inserts mit Live-Progress
- Image-Occlusion/Audio-Front werden geskipped (UI flaggt)

γ-7 (Marketplace-Publish) + Follow-up (Report + Block + Re-Publish)
- MarketplacePublishView mit lazy Author-Setup + Init + Publish 1.0.0
- Re-Publish-Modus: Picker für eigene Marketplace-Decks +
  Auto-Semver-Bump (Minor +1)
- MarketplaceCardConverter (typing → type-in, audio-front → skipped,
  image-occlusion → skipped — Server hat keinen MP-Media-Re-Upload)
- Toolbar-Menü auf PublicDeckView: „Deck melden …" + Author-Blockieren
  (App-Store-Guideline 5.1.1(v))
- ReportDeckSheet mit Reason-Picker (6 Kategorien) + optional Message
- BlockedAuthorsView in Settings mit Swipe-Entblocken

γ-8 (PDF-Export)
- DeckPrintView mit SFSafariViewController auf
  cardecky.mana.how/decks/:id/print — iOS Share-Sheet → PDF speichern

Side-Fixes (mid-stream)
- StudySessionView: Card-Aspect-Ratio springt nicht mehr beim Flip
  (Bottom-Bar in ZStack fixer Höhe)
- RootView: Glass-Pille für „Neues Deck"-Accessory + .guest- und
  .twoFactorRequired-Cases nachgezogen
- DeckListView: Account-Toolbar-Button entfernt (Account-Tab unten
  ist alleinige Anlaufstelle)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Till JS 2026-05-14 02:03:59 +02:00
parent 8ca7bd3636
commit 73f9081fa1
26 changed files with 3419 additions and 442 deletions

View file

@ -1,55 +1,126 @@
import ManaCore
import PhotosUI
import SwiftUI
#if canImport(UIKit)
import UIKit
import UIKit
#endif
/// Card-Create-View. Type-Picker oben, type-spezifische Felder unten.
/// Deckt alle 7 Card-Types ab.
// swiftlint:disable type_body_length
/// Card-Create und Card-Edit in einer View.
///
/// - `.create(deckId:)` zeigt Type-Picker + leere Felder.
/// - `.edit(card:)` blendet Type-Picker aus (Server-seitig immutable),
/// pre-fillt alle Felder, und PATCHt auf Submit.
///
/// Bei Image-Occlusion und Audio-Front im Edit-Modus bleibt der bestehende
/// Media-Ref erhalten, solange der User die Datei nicht explizit ersetzt.
struct CardEditorView: View {
let deckId: String
let onCreated: (Card) -> Void
enum Mode {
case create(deckId: String)
case edit(card: Card)
}
let mode: Mode
let onSaved: (Card) -> Void
@Environment(AuthClient.self) private var auth
@Environment(\.dismiss) private var dismiss
@State private var type: CardType = .basic
@State private var front: String = ""
@State private var back: String = ""
@State private var clozeText: String = ""
@State private var typingAnswer: String = ""
@State private var multipleChoiceAnswer: String = ""
@State private var type: CardType
@State private var front: String
@State private var back: String
@State private var clozeText: String
@State private var typingAnswer: String
@State private var multipleChoiceAnswer: String
@State private var isSubmitting = false
@State private var errorMessage: String?
// Image-Occlusion-State
@State private var imagePickerItem: PhotosPickerItem?
@State private var occlusionImage: PlatformImage?
@State private var occlusionImageData: Data?
@State private var occlusionMimeType: String = "image/jpeg"
@State private var occlusionRegions: [MaskRegion] = []
@State private var occlusionNote: String = ""
@State private var occlusionRegions: [MaskRegion]
@State private var occlusionNote: String
/// Bestehender `image_ref` aus der Card im Edit-Modus. Bleibt erhalten,
/// solange der User kein neues Bild wählt.
@State private var existingImageRef: String?
// Audio-Front-State
/// Audio-Front-State
@State private var audioFileURL: URL?
@State private var showAudioPicker = false
/// Bestehender `audio_ref` aus der Card im Edit-Modus.
@State private var existingAudioRef: String?
private static let supportedTypes: [CardType] = [
.basic, .basicReverse, .cloze, .typing, .multipleChoice,
.imageOcclusion, .audioFront,
.imageOcclusion, .audioFront
]
init(mode: Mode, onSaved: @escaping (Card) -> Void) {
self.mode = mode
self.onSaved = onSaved
let initialType: CardType
var initialFront = ""
var initialBack = ""
var initialCloze = ""
var initialTyping = ""
var initialMC = ""
var initialRegions: [MaskRegion] = []
var initialNote = ""
var initialImageRef: String?
var initialAudioRef: String?
switch mode {
case .create:
initialType = .basic
case let .edit(card):
initialType = card.type
switch card.type {
case .basic, .basicReverse:
initialFront = card.fields["front"] ?? ""
initialBack = card.fields["back"] ?? ""
case .cloze:
initialCloze = card.fields["text"] ?? ""
case .typing:
initialFront = card.fields["front"] ?? ""
initialTyping = card.fields["answer"] ?? ""
case .multipleChoice:
initialFront = card.fields["front"] ?? ""
initialMC = card.fields["answer"] ?? ""
case .imageOcclusion:
initialRegions = MaskRegions.parse(card.fields["mask_regions"] ?? "[]")
initialNote = card.fields["note"] ?? ""
initialImageRef = card.fields["image_ref"]
case .audioFront:
initialBack = card.fields["back"] ?? ""
initialAudioRef = card.fields["audio_ref"]
}
}
_type = State(initialValue: initialType)
_front = State(initialValue: initialFront)
_back = State(initialValue: initialBack)
_clozeText = State(initialValue: initialCloze)
_typingAnswer = State(initialValue: initialTyping)
_multipleChoiceAnswer = State(initialValue: initialMC)
_occlusionRegions = State(initialValue: initialRegions)
_occlusionNote = State(initialValue: initialNote)
_existingImageRef = State(initialValue: initialImageRef)
_existingAudioRef = State(initialValue: initialAudioRef)
}
var body: some View {
Form {
Section("Card-Type") {
Picker("Typ", selection: $type) {
ForEach(Self.supportedTypes, id: \.self) { t in
Text(label(for: t)).tag(t)
if isCreate {
Section("Card-Type") {
Picker("Typ", selection: $type) {
ForEach(Self.supportedTypes, id: \.self) { cardType in
Text(label(for: cardType)).tag(cardType)
}
}
.pickerStyle(.menu)
}
.pickerStyle(.menu)
}
typeFields
@ -62,7 +133,8 @@ struct CardEditorView: View {
}
}
}
.navigationTitle("Neue Karte")
.disabled(isSubmitting)
.navigationTitle(isCreate ? "Neue Karte" : "Karte bearbeiten")
#if os(iOS)
.navigationBarTitleDisplayMode(.inline)
#endif
@ -71,8 +143,10 @@ struct CardEditorView: View {
Button("Abbrechen") { dismiss() }
}
ToolbarItem(placement: .confirmationAction) {
Button("Erstellen") { Task { await submit() } }
.disabled(!canSubmit || isSubmitting)
Button(isCreate ? "Erstellen" : "Speichern") {
Task { await submit() }
}
.disabled(!canSubmit || isSubmitting)
}
}
}
@ -99,12 +173,15 @@ struct CardEditorView: View {
case .cloze:
Section("Cloze-Text") {
TextField("Beispiel: Die Hauptstadt von {{c1::Frankreich}} ist {{c2::Paris}}.",
text: $clozeText, axis: .vertical)
.lineLimit(3 ... 8)
.autocorrectionDisabled()
.textInputAutocapitalization(.sentences)
.monospaced()
TextField(
"Beispiel: Die Hauptstadt von {{c1::Frankreich}} ist {{c2::Paris}}.",
text: $clozeText,
axis: .vertical
)
.lineLimit(3 ... 8)
.autocorrectionDisabled()
.textInputAutocapitalization(.sentences)
.monospaced()
}
Section {
let count = Cloze.subIndexCount(clozeText)
@ -146,119 +223,40 @@ struct CardEditorView: View {
}
case .imageOcclusion:
imageOcclusionFields
ImageOcclusionFields(
image: $occlusionImage,
imageData: $occlusionImageData,
mimeType: $occlusionMimeType,
regions: $occlusionRegions,
note: $occlusionNote,
existingImageRef: $existingImageRef,
onLoadError: { errorMessage = $0 }
)
case .audioFront:
audioFrontFields
AudioFrontFields(
audioFileURL: $audioFileURL,
back: $back,
existingAudioRef: existingAudioRef
)
}
}
@ViewBuilder
private var imageOcclusionFields: some View {
Section("Bild") {
PhotosPicker(selection: $imagePickerItem, matching: .images) {
ImagePickerLabel(hasImage: occlusionImage != nil)
}
.onChange(of: imagePickerItem) { _, newItem in
Task { await loadPickedImage(newItem) }
}
}
private var isCreate: Bool {
if case .create = mode { return true }
return false
}
if let image = occlusionImage {
Section("Masken") {
MaskEditorView(image: image, regions: $occlusionRegions)
}
}
Section("Hinweis (optional)") {
TextField("z.B. Kurz-Erklärung", text: $occlusionNote, axis: .vertical)
.lineLimit(1 ... 3)
}
Section {
if occlusionImage == nil {
Label("Erst Bild wählen", systemImage: "info.circle")
.font(.caption)
.foregroundStyle(CardsTheme.mutedForeground)
} else if occlusionRegions.isEmpty {
Label("Mindestens eine Maske nötig", systemImage: "exclamationmark.circle")
.font(.caption)
.foregroundStyle(CardsTheme.warning)
} else {
Label("\(occlusionRegions.count) Masken → \(occlusionRegions.count) Reviews",
systemImage: "checkmark.circle.fill")
.font(.caption)
.foregroundStyle(CardsTheme.success)
}
private var deckId: String {
switch mode {
case let .create(deckId): deckId
case let .edit(card): card.deckId
}
}
@ViewBuilder
private var audioFrontFields: some View {
Section("Audio-Datei") {
Button {
showAudioPicker = true
} label: {
if let audioFileURL {
Label(audioFileURL.lastPathComponent, systemImage: "waveform")
} else {
Label("Audio auswählen", systemImage: "waveform.badge.plus")
}
}
.fileImporter(
isPresented: $showAudioPicker,
allowedContentTypes: [.audio, .mp3, .wav, .mpeg4Audio],
allowsMultipleSelection: false
) { result in
if case let .success(urls) = result, let first = urls.first {
audioFileURL = first
}
}
}
Section("Antwort") {
TextField("Was zu hören ist", text: $back, axis: .vertical)
.lineLimit(2 ... 4)
}
}
private func loadPickedImage(_ item: PhotosPickerItem?) async {
guard let item else { return }
do {
guard let data = try await item.loadTransferable(type: Data.self) else { return }
occlusionImageData = data
occlusionMimeType = inferMimeType(from: data)
if let img = PlatformImage(data: data) {
occlusionImage = img
occlusionRegions = [] // neue Bildauswahl resetet Masken
}
} catch {
errorMessage = "Bild konnte nicht geladen werden: \(error.localizedDescription)"
}
}
private func inferMimeType(from data: Data) -> String {
// Schneller Magic-Byte-Check für die häufigsten Formate
guard data.count > 4 else { return "image/jpeg" }
let bytes = Array(data.prefix(8))
if bytes.starts(with: [0xFF, 0xD8, 0xFF]) { return "image/jpeg" }
if bytes.starts(with: [0x89, 0x50, 0x4E, 0x47]) { return "image/png" }
if bytes.starts(with: [0x47, 0x49, 0x46, 0x38]) { return "image/gif" }
// WebP: starts with "RIFF" + 4 bytes size + "WEBP"
if bytes.count >= 8,
bytes[0 ... 3] == [0x52, 0x49, 0x46, 0x46] {
return "image/webp"
}
return "image/jpeg"
}
private func audioMimeType(for url: URL) -> String {
switch url.pathExtension.lowercased() {
case "mp3": "audio/mpeg"
case "wav": "audio/wav"
case "m4a", "mp4": "audio/mp4"
case "ogg", "oga": "audio/ogg"
default: "audio/mpeg"
}
private var existingMediaRefs: [String] {
if case let .edit(card) = mode { return card.mediaRefs }
return []
}
private var canSubmit: Bool {
@ -272,12 +270,14 @@ struct CardEditorView: View {
case .multipleChoice:
!front.trimmed.isEmpty && !multipleChoiceAnswer.trimmed.isEmpty
case .imageOcclusion:
occlusionImageData != nil && !occlusionRegions.isEmpty
(occlusionImageData != nil || existingImageRef != nil) && !occlusionRegions.isEmpty
case .audioFront:
audioFileURL != nil && !back.trimmed.isEmpty
(audioFileURL != nil || existingAudioRef != nil) && !back.trimmed.isEmpty
}
}
// MARK: - Submit
private func submit() async {
isSubmitting = true
errorMessage = nil
@ -285,53 +285,47 @@ struct CardEditorView: View {
let api = CardsAPI(auth: auth)
do {
let fields: [String: String]
var mediaRefs: [String]? = nil
switch type {
case .basic, .basicReverse:
fields = CardFieldsBuilder.basic(front: front.trimmed, back: back.trimmed)
case .cloze:
fields = CardFieldsBuilder.cloze(text: clozeText.trimmed)
case .typing:
fields = CardFieldsBuilder.typing(front: front.trimmed, answer: typingAnswer.trimmed)
case .multipleChoice:
fields = CardFieldsBuilder.multipleChoice(front: front.trimmed, answer: multipleChoiceAnswer.trimmed)
case .imageOcclusion:
guard let data = occlusionImageData else { return }
let media = try await api.uploadMedia(
data: data,
filename: "occlusion.\(occlusionMimeType.contains("png") ? "png" : "jpg")",
mimeType: occlusionMimeType
)
fields = CardFieldsBuilder.imageOcclusion(
imageRef: media.id,
regions: occlusionRegions,
note: occlusionNote.trimmed.isEmpty ? nil : occlusionNote.trimmed
)
mediaRefs = [media.id]
case .audioFront:
guard let url = audioFileURL else { return }
let didStart = url.startAccessingSecurityScopedResource()
defer { if didStart { url.stopAccessingSecurityScopedResource() } }
let data = try Data(contentsOf: url)
let media = try await api.uploadMedia(
data: data,
filename: url.lastPathComponent,
mimeType: audioMimeType(for: url)
)
fields = CardFieldsBuilder.audioFront(audioRef: media.id, back: back.trimmed)
mediaRefs = [media.id]
let payload = try await CardEditorPayloadBuilder.build(inputs: payloadInputs, api: api)
let card: Card = switch mode {
case let .create(deckId):
try await api.createCard(CardCreateBody(
deckId: deckId,
type: type,
fields: payload.fields,
mediaRefs: payload.mediaRefs
))
case let .edit(existing):
try await api.updateCard(id: existing.id, body: CardUpdateBody(
fields: payload.fields,
mediaRefs: payload.mediaRefs
))
}
let body = CardCreateBody(deckId: deckId, type: type, fields: fields, mediaRefs: mediaRefs)
let card = try await api.createCard(body)
onCreated(card)
onSaved(card)
dismiss()
} catch {
errorMessage = (error as? LocalizedError)?.errorDescription ?? String(describing: error)
}
}
private var payloadInputs: CardEditorPayloadInputs {
CardEditorPayloadInputs(
type: type,
front: front.trimmed,
back: back.trimmed,
clozeText: clozeText.trimmed,
typingAnswer: typingAnswer.trimmed,
multipleChoiceAnswer: multipleChoiceAnswer.trimmed,
occlusionImageData: occlusionImageData,
occlusionMimeType: occlusionMimeType,
occlusionRegions: occlusionRegions,
occlusionNote: occlusionNote.trimmed,
existingImageRef: existingImageRef,
audioFileURL: audioFileURL,
existingAudioRef: existingAudioRef,
existingMediaRefs: existingMediaRefs
)
}
private func label(for type: CardType) -> String {
switch type {
case .basic: "Einfach (Vorder/Rück)"
@ -345,25 +339,10 @@ struct CardEditorView: View {
}
}
// swiftlint:enable type_body_length
private extension String {
var trimmed: String {
trimmingCharacters(in: .whitespacesAndNewlines)
}
}
/// Wird als Sub-View aus dem PhotosPicker-Label-Closure aufgerufen.
/// Eigene `View`-Struct vermeidet die Swift-6-Strict-Concurrency-
/// Warning: SwiftUIs `PhotosPicker(label:)`-Closure ist `@Sendable`,
/// aber View-Konstruktor-Calls werden zur Build-Zeit MainActor-isoliert
/// evaluiert (im Gegensatz zu direktem @State-Zugriff im Closure-Body).
private struct ImagePickerLabel: View {
let hasImage: Bool
var body: some View {
if hasImage {
Label("Bild ersetzen", systemImage: "arrow.triangle.2.circlepath")
} else {
Label("Bild auswählen", systemImage: "photo")
}
}
}