initial
This commit is contained in:
Oliver Walter
+43
@@ -0,0 +1,43 @@
|
||||
use crate::components::tool_list::ToolList;
|
||||
use leptos::prelude::*;
|
||||
use leptos_meta::{provide_meta_context, MetaTags, Stylesheet, Title};
|
||||
use leptos_router::{
|
||||
components::{Route, Router, Routes},
|
||||
StaticSegment,
|
||||
};
|
||||
|
||||
pub fn shell(options: LeptosOptions) -> impl IntoView {
|
||||
view! {
|
||||
<!DOCTYPE html>
|
||||
<html lang="de">
|
||||
<head>
|
||||
<meta charset="utf-8"/>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1"/>
|
||||
<AutoReload options=options.clone() />
|
||||
<HydrationScripts options/>
|
||||
<MetaTags/>
|
||||
</head>
|
||||
<body>
|
||||
<App/>
|
||||
</body>
|
||||
</html>
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
pub fn App() -> impl IntoView {
|
||||
provide_meta_context();
|
||||
|
||||
view! {
|
||||
<Stylesheet id="leptos" href="/pkg/toollist.css"/>
|
||||
<Title text="Werkzeugliste"/>
|
||||
|
||||
<Router>
|
||||
<main>
|
||||
<Routes fallback=|| "Seite nicht gefunden.".into_view()>
|
||||
<Route path=StaticSegment("") view=ToolList/>
|
||||
</Routes>
|
||||
</main>
|
||||
</Router>
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
use crate::models::tool::{BeschaffungsArt, Prioritaet, Status};
|
||||
use leptos::prelude::*;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
pub struct FilterZustand {
|
||||
pub suche: String,
|
||||
pub status: Option<Status>,
|
||||
pub prioritaet: Option<Prioritaet>,
|
||||
pub beschaffung: Option<BeschaffungsArt>,
|
||||
/// Nur Tools anzeigen, die mindestens einen dieser Tags haben
|
||||
pub tags_einschliessen: Vec<String>,
|
||||
/// Tools ausblenden, die irgendeinen dieser Tags haben
|
||||
pub tags_ausschliessen: Vec<String>,
|
||||
}
|
||||
|
||||
/// Tags werden als einfacher Vec übergeben – der FilterBar-Wrapper liegt
|
||||
/// bereits innerhalb des <Suspense>, daher brauchen wir kein Signal.
|
||||
#[component]
|
||||
pub fn FilterBar(filter: RwSignal<FilterZustand>, alle_tags: Vec<String>) -> impl IntoView {
|
||||
view! {
|
||||
<div class="filter-bar">
|
||||
// Freitextsuche
|
||||
<input
|
||||
type="text"
|
||||
placeholder="Suche..."
|
||||
class="filter-input"
|
||||
prop:value=move || filter.read().suche.clone()
|
||||
on:input=move |ev| {
|
||||
filter.update(|f| f.suche = event_target_value(&ev))
|
||||
}
|
||||
/>
|
||||
|
||||
// Status-Filter
|
||||
<select
|
||||
class="filter-select"
|
||||
on:change=move |ev| {
|
||||
let wert = event_target_value(&ev);
|
||||
filter.update(|f| {
|
||||
f.status = match wert.as_str() {
|
||||
"Offen" => Some(Status::Offen),
|
||||
"Organisiert" => Some(Status::Organisiert),
|
||||
"VorOrt" => Some(Status::VorOrt),
|
||||
_ => None,
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
<option value="">"Alle Status"</option>
|
||||
<option value="Offen">"Offen"</option>
|
||||
<option value="Organisiert">"Organisiert"</option>
|
||||
<option value="VorOrt">"Vor Ort"</option>
|
||||
</select>
|
||||
|
||||
// Priorität-Filter
|
||||
<select
|
||||
class="filter-select"
|
||||
on:change=move |ev| {
|
||||
let wert = event_target_value(&ev);
|
||||
filter.update(|f| {
|
||||
f.prioritaet = match wert.as_str() {
|
||||
"Hoch" => Some(Prioritaet::Hoch),
|
||||
"Mittel" => Some(Prioritaet::Mittel),
|
||||
"Niedrig" => Some(Prioritaet::Niedrig),
|
||||
_ => None,
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
<option value="">"Alle Prioritäten"</option>
|
||||
<option value="Hoch">"Hoch"</option>
|
||||
<option value="Mittel">"Mittel"</option>
|
||||
<option value="Niedrig">"Niedrig"</option>
|
||||
</select>
|
||||
|
||||
// Beschaffung-Filter
|
||||
<select
|
||||
class="filter-select"
|
||||
on:change=move |ev| {
|
||||
let wert = event_target_value(&ev);
|
||||
filter.update(|f| {
|
||||
f.beschaffung = match wert.as_str() {
|
||||
"Unbekannt" => Some(BeschaffungsArt::Unbekannt),
|
||||
"InBesitz" => Some(BeschaffungsArt::InBesitz),
|
||||
"Leihen" => Some(BeschaffungsArt::Leihen),
|
||||
"Mieten" => Some(BeschaffungsArt::Mieten),
|
||||
"Kaufen" => Some(BeschaffungsArt::Kaufen),
|
||||
_ => None,
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
<option value="">"Alle Beschaffungen"</option>
|
||||
<option value="Unbekannt">"Unbekannt"</option>
|
||||
<option value="InBesitz">"In Besitz"</option>
|
||||
<option value="Leihen">"Leihen"</option>
|
||||
<option value="Mieten">"Mieten"</option>
|
||||
<option value="Kaufen">"Kaufen"</option>
|
||||
</select>
|
||||
|
||||
// Reset
|
||||
<button
|
||||
class="btn btn-secondary"
|
||||
on:click=move |_| filter.set(FilterZustand::default())
|
||||
>
|
||||
"✕ Zurücksetzen"
|
||||
</button>
|
||||
|
||||
// Tag-Chips (nur wenn Tags vorhanden)
|
||||
{if !alle_tags.is_empty() {
|
||||
view! {
|
||||
<div class="tag-filter-bereich">
|
||||
<span class="tag-filter-label">"Tags:"</span>
|
||||
{alle_tags.into_iter().map(|tag| {
|
||||
let tag1 = tag.clone(); // für class
|
||||
let tag2 = tag.clone(); // für on:click
|
||||
let tag3 = tag.clone(); // für Textinhalt
|
||||
view! {
|
||||
<span
|
||||
class=move || {
|
||||
let f = filter.read();
|
||||
if f.tags_einschliessen.contains(&tag1) {
|
||||
"tag-chip tag-chip-ein"
|
||||
} else if f.tags_ausschliessen.contains(&tag1) {
|
||||
"tag-chip tag-chip-aus"
|
||||
} else {
|
||||
"tag-chip"
|
||||
}
|
||||
}
|
||||
style="cursor: pointer;"
|
||||
on:click=move |_| {
|
||||
let t = tag2.clone();
|
||||
filter.update(|f| {
|
||||
if f.tags_einschliessen.contains(&t) {
|
||||
// einschließen → ausschließen
|
||||
f.tags_einschliessen.retain(|x| x != &t);
|
||||
f.tags_ausschliessen.push(t);
|
||||
} else if f.tags_ausschliessen.contains(&t) {
|
||||
// ausschließen → neutral
|
||||
f.tags_ausschliessen.retain(|x| x != &t);
|
||||
} else {
|
||||
// neutral → einschließen
|
||||
f.tags_einschliessen.push(t);
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
{move || {
|
||||
let f = filter.read();
|
||||
if f.tags_einschliessen.contains(&tag3) {
|
||||
format!("✓ {tag3}")
|
||||
} else if f.tags_ausschliessen.contains(&tag3) {
|
||||
format!("✗ {tag3}")
|
||||
} else {
|
||||
tag3.clone()
|
||||
}
|
||||
}}
|
||||
</span>
|
||||
}
|
||||
}).collect::<Vec<_>>()}
|
||||
<span class="tag-filter-legende">"(1× einschließen · 2× ausschließen · 3× zurücksetzen)"</span>
|
||||
</div>
|
||||
}.into_any()
|
||||
} else {
|
||||
view! { <span></span> }.into_any()
|
||||
}}
|
||||
</div>
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
pub mod filter_bar;
|
||||
pub mod tool_form;
|
||||
pub mod tool_list;
|
||||
@@ -0,0 +1,366 @@
|
||||
use crate::models::tool::{
|
||||
Anzahl, Beschaffung, BeschaffungsArt, NewTool, Prioritaet, Status, Tool,
|
||||
};
|
||||
use crate::server::api::{tool_aktualisieren, tool_erstellen};
|
||||
use leptos::prelude::*;
|
||||
|
||||
/// Wird als Aktion-Typ für den Parent verwendet
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum FormModus {
|
||||
Neu,
|
||||
Bearbeiten(Tool),
|
||||
}
|
||||
|
||||
#[component]
|
||||
pub fn ToolForm(
|
||||
modus: FormModus,
|
||||
/// Wird aufgerufen wenn das Formular erfolgreich abgeschickt wurde
|
||||
on_fertig: Callback<()>,
|
||||
/// Wird aufgerufen wenn der Nutzer abbricht
|
||||
on_abbrechen: Callback<()>,
|
||||
) -> impl IntoView {
|
||||
// Vorbelegte Werte je nach Modus
|
||||
let (original_id, initial) = match &modus {
|
||||
FormModus::Neu => (None, NewTool::default()),
|
||||
FormModus::Bearbeiten(t) => (Some(t.id.clone()), NewTool::from(t)),
|
||||
};
|
||||
|
||||
// --- Signale für jedes Feld ---
|
||||
let name = RwSignal::new(initial.name.clone());
|
||||
let anzahl_mehrere = RwSignal::new(initial.anzahl.ist_mehrere());
|
||||
let anzahl_zahl = RwSignal::new(initial.anzahl.zahl.unwrap_or(1).to_string());
|
||||
|
||||
let beschaffung_art = RwSignal::new(format!("{}", initial.beschaffung.art));
|
||||
let beschaffung_von = RwSignal::new(initial.beschaffung.von.clone().unwrap_or_default());
|
||||
let beschaffung_wo = RwSignal::new(initial.beschaffung.wo.clone().unwrap_or_default());
|
||||
let beschaffung_preis = RwSignal::new(
|
||||
initial
|
||||
.beschaffung
|
||||
.preis
|
||||
.map(|p| p.to_string())
|
||||
.unwrap_or_default(),
|
||||
);
|
||||
|
||||
let verwendung_text = RwSignal::new(initial.verwendung.join("\n"));
|
||||
let tags_text = RwSignal::new(initial.tags.join(", "));
|
||||
|
||||
let status = RwSignal::new(format!("{}", initial.status));
|
||||
let prioritaet = RwSignal::new(format!("{}", initial.prioritaet));
|
||||
let notizen = RwSignal::new(initial.notizen.clone().unwrap_or_default());
|
||||
let verantwortlich = RwSignal::new(initial.verantwortlich.clone().unwrap_or_default());
|
||||
|
||||
let fehler = RwSignal::new(Option::<String>::None);
|
||||
|
||||
// --- Aktionen ---
|
||||
let erstellen_aktion = Action::new(|input: &NewTool| {
|
||||
let i = input.clone();
|
||||
async move { tool_erstellen(i).await }
|
||||
});
|
||||
|
||||
let aktualisieren_aktion = Action::new(|(id, input): &(String, NewTool)| {
|
||||
let (id, i) = (id.clone(), input.clone());
|
||||
async move { tool_aktualisieren(id, i).await }
|
||||
});
|
||||
|
||||
// Reaktion auf Aktion-Ergebnis
|
||||
let on_fertig_clone = on_fertig.clone();
|
||||
Effect::new(move |_| {
|
||||
if let Some(ergebnis) = erstellen_aktion.value().get() {
|
||||
match ergebnis {
|
||||
Ok(_) => on_fertig_clone.run(()),
|
||||
Err(e) => fehler.set(Some(e.to_string())),
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let on_fertig_clone2 = on_fertig.clone();
|
||||
Effect::new(move |_| {
|
||||
if let Some(ergebnis) = aktualisieren_aktion.value().get() {
|
||||
match ergebnis {
|
||||
Ok(_) => on_fertig_clone2.run(()),
|
||||
Err(e) => fehler.set(Some(e.to_string())),
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let abschicken = move |ev: leptos::ev::SubmitEvent| {
|
||||
ev.prevent_default();
|
||||
|
||||
// Validierung
|
||||
let n = name.get();
|
||||
if n.trim().is_empty() {
|
||||
fehler.set(Some("Name darf nicht leer sein.".into()));
|
||||
return;
|
||||
}
|
||||
|
||||
let anzahl = if anzahl_mehrere.get() {
|
||||
Anzahl::mehrere()
|
||||
} else {
|
||||
match anzahl_zahl.get().trim().parse::<u32>() {
|
||||
Ok(z) => Anzahl::zahl(z),
|
||||
Err(_) => {
|
||||
fehler.set(Some("Anzahl muss eine ganze Zahl sein.".into()));
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let art = match beschaffung_art.get().as_str() {
|
||||
"In Besitz" => BeschaffungsArt::InBesitz,
|
||||
"Leihen" => BeschaffungsArt::Leihen,
|
||||
"Mieten" => BeschaffungsArt::Mieten,
|
||||
"Kaufen" => BeschaffungsArt::Kaufen,
|
||||
_ => BeschaffungsArt::Unbekannt,
|
||||
};
|
||||
|
||||
let beschaffung = Beschaffung {
|
||||
art,
|
||||
von: Some(beschaffung_von.get()).filter(|s| !s.is_empty()),
|
||||
wo: Some(beschaffung_wo.get()).filter(|s| !s.is_empty()),
|
||||
preis: beschaffung_preis.get().trim().parse::<f64>().ok(),
|
||||
};
|
||||
|
||||
let verwendung: Vec<String> = verwendung_text
|
||||
.get()
|
||||
.lines()
|
||||
.map(|l| l.trim().to_string())
|
||||
.filter(|l| !l.is_empty())
|
||||
.collect();
|
||||
|
||||
let tags: Vec<String> = tags_text
|
||||
.get()
|
||||
.split(',')
|
||||
.map(|t| t.trim().to_string())
|
||||
.filter(|t| !t.is_empty())
|
||||
.collect();
|
||||
|
||||
let status_wert = match status.get().as_str() {
|
||||
"Organisiert" => Status::Organisiert,
|
||||
"Vor Ort" | "VorOrt" => Status::VorOrt,
|
||||
_ => Status::Offen,
|
||||
};
|
||||
|
||||
let prio_wert = match prioritaet.get().as_str() {
|
||||
"Hoch" => Prioritaet::Hoch,
|
||||
"Niedrig" => Prioritaet::Niedrig,
|
||||
_ => Prioritaet::Mittel,
|
||||
};
|
||||
|
||||
let input = NewTool {
|
||||
name: n.trim().to_string(),
|
||||
anzahl,
|
||||
beschaffung,
|
||||
verwendung,
|
||||
tags,
|
||||
status: status_wert,
|
||||
prioritaet: prio_wert,
|
||||
notizen: Some(notizen.get()).filter(|s| !s.is_empty()),
|
||||
verantwortlich: Some(verantwortlich.get()).filter(|s| !s.is_empty()),
|
||||
};
|
||||
|
||||
fehler.set(None);
|
||||
|
||||
if let Some(id) = &original_id {
|
||||
aktualisieren_aktion.dispatch((id.clone(), input));
|
||||
} else {
|
||||
erstellen_aktion.dispatch(input);
|
||||
}
|
||||
};
|
||||
|
||||
let titel = match &modus {
|
||||
FormModus::Neu => "Neues Werkzeug",
|
||||
FormModus::Bearbeiten(_) => "Werkzeug bearbeiten",
|
||||
};
|
||||
|
||||
view! {
|
||||
<div class="form-container">
|
||||
<h2>{titel}</h2>
|
||||
|
||||
{move || fehler.get().map(|e| view! {
|
||||
<div class="fehler-banner">{e}</div>
|
||||
})}
|
||||
|
||||
<form on:submit=abschicken>
|
||||
|
||||
// --- Name ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Name"</label>
|
||||
<input
|
||||
type="text"
|
||||
required
|
||||
prop:value=move || name.get()
|
||||
on:input=move |ev| name.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
|
||||
// --- Anzahl ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Anzahl"</label>
|
||||
<div class="anzahl-zeile">
|
||||
<label class="checkbox-label">
|
||||
<input
|
||||
type="checkbox"
|
||||
prop:checked=move || anzahl_mehrere.get()
|
||||
on:change=move |ev| {
|
||||
use wasm_bindgen::JsCast;
|
||||
let checked = ev.target().unwrap()
|
||||
.dyn_into::<web_sys::HtmlInputElement>().unwrap()
|
||||
.checked();
|
||||
anzahl_mehrere.set(checked);
|
||||
}
|
||||
/>
|
||||
" Mehrere"
|
||||
</label>
|
||||
<input
|
||||
type="number"
|
||||
min="1"
|
||||
class="anzahl-input"
|
||||
prop:value=move || anzahl_zahl.get()
|
||||
prop:disabled=move || anzahl_mehrere.get()
|
||||
on:input=move |ev| anzahl_zahl.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
// --- Beschaffung ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Beschaffung"</label>
|
||||
<select
|
||||
on:change=move |ev| beschaffung_art.set(event_target_value(&ev))
|
||||
>
|
||||
<option value="Unbekannt" selected=move || beschaffung_art.get() == "Unbekannt">"Unbekannt"</option>
|
||||
<option value="In Besitz" selected=move || beschaffung_art.get() == "In Besitz">"In Besitz"</option>
|
||||
<option value="Leihen" selected=move || beschaffung_art.get() == "Leihen">"Leihen"</option>
|
||||
<option value="Mieten" selected=move || beschaffung_art.get() == "Mieten">"Mieten"</option>
|
||||
<option value="Kaufen" selected=move || beschaffung_art.get() == "Kaufen">"Kaufen"</option>
|
||||
</select>
|
||||
</div>
|
||||
|
||||
// Dynamische Zusatzfelder je nach Beschaffungsart
|
||||
{move || {
|
||||
let art = beschaffung_art.get();
|
||||
match art.as_str() {
|
||||
"Leihen" => view! {
|
||||
<div class="form-gruppe">
|
||||
<label>"Von wem leihen"</label>
|
||||
<input
|
||||
type="text"
|
||||
placeholder="Name der Person"
|
||||
prop:value=move || beschaffung_von.get()
|
||||
on:input=move |ev| beschaffung_von.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
}.into_any(),
|
||||
"Mieten" | "Kaufen" => view! {
|
||||
<div>
|
||||
<div class="form-gruppe">
|
||||
<label>{if art == "Mieten" { "Wo mieten" } else { "Wo kaufen" }}</label>
|
||||
<input
|
||||
type="text"
|
||||
placeholder="Ort / Shop"
|
||||
prop:value=move || beschaffung_wo.get()
|
||||
on:input=move |ev| beschaffung_wo.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
<div class="form-gruppe">
|
||||
<label>"Preis (€)"</label>
|
||||
<input
|
||||
type="number"
|
||||
step="0.01"
|
||||
min="0"
|
||||
placeholder="optional"
|
||||
prop:value=move || beschaffung_preis.get()
|
||||
on:input=move |ev| beschaffung_preis.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
}.into_any(),
|
||||
_ => view! { <div></div> }.into_any(),
|
||||
}
|
||||
}}
|
||||
|
||||
// --- Verwendung ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Verwendung (je Zeile ein Punkt)"</label>
|
||||
<textarea
|
||||
rows="3"
|
||||
placeholder="z.B. Schutt abtransportieren"
|
||||
prop:value=move || verwendung_text.get()
|
||||
on:input=move |ev| verwendung_text.set(event_target_value(&ev))
|
||||
></textarea>
|
||||
</div>
|
||||
|
||||
// --- Tags ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Tags (kommagetrennt, optional)"</label>
|
||||
<input
|
||||
type="text"
|
||||
placeholder="z.B. garten, transport, schwer"
|
||||
prop:value=move || tags_text.get()
|
||||
on:input=move |ev| tags_text.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
|
||||
// --- Status ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Status"</label>
|
||||
<select on:change=move |ev| status.set(event_target_value(&ev))>
|
||||
<option value="Offen" selected=move || status.get() == "Offen">"Offen"</option>
|
||||
<option value="Organisiert" selected=move || status.get() == "Organisiert">"Organisiert"</option>
|
||||
<option value="VorOrt" selected=move || status.get() == "VorOrt" || status.get() == "Vor Ort">"Vor Ort"</option>
|
||||
</select>
|
||||
</div>
|
||||
|
||||
// --- Priorität ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Priorität"</label>
|
||||
<select on:change=move |ev| prioritaet.set(event_target_value(&ev))>
|
||||
<option value="Hoch" selected=move || prioritaet.get() == "Hoch">"Hoch"</option>
|
||||
<option value="Mittel" selected=move || prioritaet.get() == "Mittel">"Mittel"</option>
|
||||
<option value="Niedrig" selected=move || prioritaet.get() == "Niedrig">"Niedrig"</option>
|
||||
</select>
|
||||
</div>
|
||||
|
||||
// --- Notizen ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Notizen"</label>
|
||||
<textarea
|
||||
rows="2"
|
||||
placeholder="optional"
|
||||
prop:value=move || notizen.get()
|
||||
on:input=move |ev| notizen.set(event_target_value(&ev))
|
||||
></textarea>
|
||||
</div>
|
||||
|
||||
// --- Verantwortlich ---
|
||||
<div class="form-gruppe">
|
||||
<label>"Verantwortlich"</label>
|
||||
<input
|
||||
type="text"
|
||||
placeholder="optional"
|
||||
prop:value=move || verantwortlich.get()
|
||||
on:input=move |ev| verantwortlich.set(event_target_value(&ev))
|
||||
/>
|
||||
</div>
|
||||
|
||||
// --- Buttons ---
|
||||
<div class="form-aktionen">
|
||||
<button type="submit" class="btn btn-primary">
|
||||
{match &modus {
|
||||
FormModus::Neu => "Erstellen",
|
||||
FormModus::Bearbeiten(_) => "Speichern",
|
||||
}}
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
class="btn btn-secondary"
|
||||
on:click=move |_| on_abbrechen.run(())
|
||||
>
|
||||
"Abbrechen"
|
||||
</button>
|
||||
</div>
|
||||
|
||||
</form>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,533 @@
|
||||
use crate::components::filter_bar::{FilterBar, FilterZustand};
|
||||
use crate::components::tool_form::{FormModus, ToolForm};
|
||||
use crate::models::tool::{Prioritaet, Status, Tool};
|
||||
use crate::server::api::{csv_importieren, tool_loeschen, tools_laden};
|
||||
use leptos::html;
|
||||
use leptos::prelude::*;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Sortier-Zustand (rein UI-lokal, kein Serde nötig)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
enum SortSpalte {
|
||||
#[default]
|
||||
Keine,
|
||||
Status,
|
||||
Prioritaet,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
enum SortRichtung {
|
||||
#[default]
|
||||
Aufsteigend,
|
||||
Absteigend,
|
||||
}
|
||||
|
||||
impl SortRichtung {
|
||||
fn umkehren(&self) -> Self {
|
||||
match self {
|
||||
SortRichtung::Aufsteigend => SortRichtung::Absteigend,
|
||||
SortRichtung::Absteigend => SortRichtung::Aufsteigend,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
struct SortZustand {
|
||||
spalte: SortSpalte,
|
||||
richtung: SortRichtung,
|
||||
}
|
||||
|
||||
fn status_rang(s: &Status) -> u8 {
|
||||
match s {
|
||||
Status::Offen => 0,
|
||||
Status::Organisiert => 1,
|
||||
Status::VorOrt => 2,
|
||||
}
|
||||
}
|
||||
|
||||
fn prioritaet_rang(p: &Prioritaet) -> u8 {
|
||||
match p {
|
||||
Prioritaet::Hoch => 0,
|
||||
Prioritaet::Mittel => 1,
|
||||
Prioritaet::Niedrig => 2,
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
pub fn ToolList() -> impl IntoView {
|
||||
// Aktualisierungs-Zähler: hochzählen löst Resource-Reload aus
|
||||
let version = RwSignal::new(0u32);
|
||||
let neu_laden = move || version.update(|v| *v += 1);
|
||||
|
||||
// Daten vom Server – wird NUR innerhalb <Suspense> gelesen
|
||||
let tools_resource = Resource::new(move || version.get(), |_| tools_laden());
|
||||
|
||||
// Formular-Modus: None = Liste, Some(Neu/Bearbeiten)
|
||||
let bearbeitungs_modus = RwSignal::new(Option::<FormModus>::None);
|
||||
|
||||
// Filter-Zustand
|
||||
let filter = RwSignal::new(FilterZustand::default());
|
||||
|
||||
// Welche Zeile ist gerade aufgeklappt? (ID oder None)
|
||||
let aufgeklappt = RwSignal::new(Option::<String>::None);
|
||||
|
||||
// Sortier-Zustand
|
||||
let sortierung = RwSignal::new(SortZustand::default());
|
||||
|
||||
// NodeRef + Effect für den Modal-Dialog
|
||||
let dialog_ref = NodeRef::<html::Dialog>::new();
|
||||
Effect::new(move |_| {
|
||||
if let Some(el) = dialog_ref.get() {
|
||||
if bearbeitungs_modus.get().is_some() {
|
||||
let _ = el.show_modal();
|
||||
} else {
|
||||
el.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Tool-Cache: Tabelle rendert immer aus diesem Signal, nie direkt aus der Resource.
|
||||
// → Suspense-Fallback beim Reload lässt die Tabelle sichtbar (kein Scroll-Reset).
|
||||
let tools_cache = RwSignal::new(Vec::<Tool>::new());
|
||||
let ist_geladen = RwSignal::new(false);
|
||||
|
||||
// CSV-Import-Meldungen
|
||||
let csv_fehler = RwSignal::new(Option::<String>::None);
|
||||
let csv_erfolg = RwSignal::new(Option::<String>::None);
|
||||
|
||||
// Löschen-Aktion
|
||||
let loeschen_aktion = Action::new(|id: &String| {
|
||||
let id = id.clone();
|
||||
async move { tool_loeschen(id).await }
|
||||
});
|
||||
|
||||
let neu_laden_nach_loeschen = neu_laden.clone();
|
||||
Effect::new(move |_| {
|
||||
if let Some(ergebnis) = loeschen_aktion.value().get() {
|
||||
if ergebnis.is_ok() {
|
||||
neu_laden_nach_loeschen();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// CSV-Datei einlesen
|
||||
let csv_import = move |ev: leptos::ev::Event| {
|
||||
use wasm_bindgen::JsCast;
|
||||
|
||||
let input = ev
|
||||
.target()
|
||||
.unwrap()
|
||||
.dyn_into::<web_sys::HtmlInputElement>()
|
||||
.unwrap();
|
||||
let files = input.files().unwrap();
|
||||
if files.length() == 0 {
|
||||
return;
|
||||
}
|
||||
let file = files.get(0).unwrap();
|
||||
let reader = web_sys::FileReader::new().unwrap();
|
||||
let reader_clone = reader.clone();
|
||||
let neu_laden_csv = neu_laden.clone();
|
||||
|
||||
let onload = wasm_bindgen::closure::Closure::wrap(Box::new(move |_: web_sys::Event| {
|
||||
let inhalt = reader_clone
|
||||
.result()
|
||||
.unwrap()
|
||||
.as_string()
|
||||
.unwrap_or_default();
|
||||
let inhalt_clone = inhalt.clone();
|
||||
let neu_laden_inner = neu_laden_csv.clone();
|
||||
leptos::task::spawn_local(async move {
|
||||
match csv_importieren(inhalt_clone).await {
|
||||
Ok(n) => {
|
||||
csv_erfolg.set(Some(format!("{n} Werkzeuge importiert.")));
|
||||
csv_fehler.set(None);
|
||||
neu_laden_inner();
|
||||
}
|
||||
Err(e) => {
|
||||
csv_fehler.set(Some(e.to_string()));
|
||||
csv_erfolg.set(None);
|
||||
}
|
||||
}
|
||||
});
|
||||
}) as Box<dyn FnMut(_)>);
|
||||
|
||||
reader.set_onload(Some(onload.as_ref().unchecked_ref()));
|
||||
onload.forget();
|
||||
reader.read_as_text(&file).unwrap();
|
||||
};
|
||||
|
||||
view! {
|
||||
<div class="seite">
|
||||
|
||||
// ---- Kopfzeile ----
|
||||
<header class="kopfzeile">
|
||||
<h1>"🔧 Werkzeugliste"</h1>
|
||||
<div class="kopf-aktionen">
|
||||
<button
|
||||
class="btn btn-primary"
|
||||
on:click=move |_| bearbeitungs_modus.set(Some(FormModus::Neu))
|
||||
>
|
||||
"+ Neu"
|
||||
</button>
|
||||
<a href="/export/tools.csv" class="btn btn-secondary">
|
||||
"⬇ CSV Export"
|
||||
</a>
|
||||
<label class="btn btn-secondary csv-label">
|
||||
"⬆ CSV Import"
|
||||
<input
|
||||
type="file"
|
||||
accept=".csv,.txt"
|
||||
class="csv-input-versteckt"
|
||||
on:change=csv_import
|
||||
/>
|
||||
</label>
|
||||
</div>
|
||||
</header>
|
||||
|
||||
// ---- CSV-Meldungen ----
|
||||
{move || csv_erfolg.get().map(|m| view! {
|
||||
<div class="meldung meldung-erfolg">{m}</div>
|
||||
})}
|
||||
{move || csv_fehler.get().map(|e| view! {
|
||||
<div class="meldung meldung-fehler">{e}</div>
|
||||
})}
|
||||
|
||||
// ---- Suspense: nur zum Signal-Update beim (Re-)Laden ----
|
||||
// Die Tabelle selbst ist NICHT Teil des Suspense-Blocks.
|
||||
// Beim Reload bleibt sie sichtbar (alter Cache-Wert) → kein Scroll-Reset.
|
||||
<Suspense fallback=move || {
|
||||
// Nur beim ersten Laden sichtbar; beim Reload unsichtbar
|
||||
if ist_geladen.get() {
|
||||
view! { <span></span> }.into_any()
|
||||
} else {
|
||||
view! { <p class="lade-text">"Lade Werkzeuge…"</p> }.into_any()
|
||||
}
|
||||
}>
|
||||
{move || tools_resource.get().map(|result| {
|
||||
tools_cache.set(result.unwrap_or_default());
|
||||
ist_geladen.set(true);
|
||||
})}
|
||||
</Suspense>
|
||||
|
||||
// ---- Filter + Tabelle (rendert aus Cache, nie aus Resource direkt) ----
|
||||
{move || {
|
||||
if !ist_geladen.get() {
|
||||
return view! { <span></span> }.into_any();
|
||||
}
|
||||
|
||||
let alle_tools = tools_cache.get();
|
||||
let f = filter.get();
|
||||
|
||||
let mut alle_tags: Vec<String> = alle_tools
|
||||
.iter()
|
||||
.flat_map(|t| t.tags.iter().cloned())
|
||||
.collect();
|
||||
alle_tags.sort();
|
||||
alle_tags.dedup();
|
||||
|
||||
let tools: Vec<Tool> = alle_tools
|
||||
.into_iter()
|
||||
.filter(|t| {
|
||||
if !f.suche.is_empty() {
|
||||
let s = f.suche.to_lowercase();
|
||||
let treffer = t.name.to_lowercase().contains(&s)
|
||||
|| t.tags.iter().any(|tag| tag.to_lowercase().contains(&s))
|
||||
|| t.notizen
|
||||
.as_deref()
|
||||
.unwrap_or("")
|
||||
.to_lowercase()
|
||||
.contains(&s);
|
||||
if !treffer {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if let Some(ref st) = f.status {
|
||||
if &t.status != st {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if let Some(ref p) = f.prioritaet {
|
||||
if &t.prioritaet != p {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if let Some(ref b) = f.beschaffung {
|
||||
if &t.beschaffung.art != b {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if !f.tags_einschliessen.is_empty()
|
||||
&& !f.tags_einschliessen.iter().any(|tag| t.tags.contains(tag))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if f.tags_ausschliessen.iter().any(|tag| t.tags.contains(tag)) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
})
|
||||
.collect();
|
||||
|
||||
// Sortierung anwenden
|
||||
let sort = sortierung.get();
|
||||
let mut tools = tools;
|
||||
if sort.spalte != SortSpalte::Keine {
|
||||
tools.sort_by(|a, b| {
|
||||
let ord = match sort.spalte {
|
||||
SortSpalte::Status => status_rang(&a.status).cmp(&status_rang(&b.status)),
|
||||
SortSpalte::Prioritaet => prioritaet_rang(&a.prioritaet).cmp(&prioritaet_rang(&b.prioritaet)),
|
||||
SortSpalte::Keine => std::cmp::Ordering::Equal,
|
||||
};
|
||||
if sort.richtung == SortRichtung::Absteigend { ord.reverse() } else { ord }
|
||||
});
|
||||
}
|
||||
|
||||
view! {
|
||||
<FilterBar filter=filter alle_tags=alle_tags />
|
||||
|
||||
{if tools.is_empty() {
|
||||
view! {
|
||||
<p class="leer-text">"Keine Werkzeuge gefunden."</p>
|
||||
}.into_any()
|
||||
} else {
|
||||
view! {
|
||||
<div class="tabellen-wrapper">
|
||||
<table class="tool-tabelle">
|
||||
<thead>
|
||||
<tr>
|
||||
<th class="toggle-th"></th>
|
||||
<th>"Name"</th>
|
||||
<th>"Anzahl"</th>
|
||||
<th>"Beschaffung"</th>
|
||||
<th
|
||||
class="th-sortierbar"
|
||||
on:click=move |_| {
|
||||
sortierung.update(|s| {
|
||||
if s.spalte == SortSpalte::Status {
|
||||
s.richtung = s.richtung.umkehren();
|
||||
} else {
|
||||
s.spalte = SortSpalte::Status;
|
||||
s.richtung = SortRichtung::Aufsteigend;
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
"Status"
|
||||
{move || match sortierung.get() {
|
||||
SortZustand { spalte: SortSpalte::Status, richtung: SortRichtung::Aufsteigend } => " ↑",
|
||||
SortZustand { spalte: SortSpalte::Status, richtung: SortRichtung::Absteigend } => " ↓",
|
||||
_ => "",
|
||||
}}
|
||||
</th>
|
||||
<th
|
||||
class="th-sortierbar"
|
||||
on:click=move |_| {
|
||||
sortierung.update(|s| {
|
||||
if s.spalte == SortSpalte::Prioritaet {
|
||||
s.richtung = s.richtung.umkehren();
|
||||
} else {
|
||||
s.spalte = SortSpalte::Prioritaet;
|
||||
s.richtung = SortRichtung::Aufsteigend;
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
"Priorität"
|
||||
{move || match sortierung.get() {
|
||||
SortZustand { spalte: SortSpalte::Prioritaet, richtung: SortRichtung::Aufsteigend } => " ↑",
|
||||
SortZustand { spalte: SortSpalte::Prioritaet, richtung: SortRichtung::Absteigend } => " ↓",
|
||||
_ => "",
|
||||
}}
|
||||
</th>
|
||||
<th>"Tags"</th>
|
||||
<th>"Aktionen"</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{tools.into_iter().map(|tool| {
|
||||
// Drei separate ID-Klone für drei verschiedene Closures
|
||||
let id_toggle = tool.id.clone();
|
||||
let id_arrow = tool.id.clone();
|
||||
let id_style = tool.id.clone();
|
||||
let tool_id = tool.id.clone();
|
||||
let tool_edit = tool.clone();
|
||||
|
||||
// Daten für die Detail-Zeile (statisch geklont)
|
||||
let verwendung = tool.verwendung.clone();
|
||||
let notizen = tool.notizen.clone();
|
||||
let verantwortlich = tool.verantwortlich.clone();
|
||||
let erstellt_am = tool.erstellt_am.clone();
|
||||
|
||||
view! {
|
||||
<>
|
||||
// --- Hauptzeile ---
|
||||
<tr class="tool-zeile">
|
||||
<td class="toggle-zelle">
|
||||
<button
|
||||
class="btn-toggle"
|
||||
on:click=move |_| {
|
||||
let id = id_toggle.clone();
|
||||
aufgeklappt.update(|a| {
|
||||
if a.as_deref() == Some(&id) {
|
||||
*a = None;
|
||||
} else {
|
||||
*a = Some(id);
|
||||
}
|
||||
});
|
||||
}
|
||||
>
|
||||
{move || if aufgeklappt.get().as_deref() == Some(&id_arrow) { "▼" } else { "▶" }}
|
||||
</button>
|
||||
</td>
|
||||
<td class="tool-name">
|
||||
<strong>{tool.name.clone()}</strong>
|
||||
</td>
|
||||
<td>{tool.anzahl.to_string()}</td>
|
||||
<td>{tool.beschaffung.to_string()}</td>
|
||||
<td>
|
||||
<span class={format!("status-badge status-{}", tool.status.to_string().to_lowercase().replace(' ', "-"))}>
|
||||
{tool.status.to_string()}
|
||||
</span>
|
||||
</td>
|
||||
<td>
|
||||
<span class={format!("prio-badge prio-{}", tool.prioritaet.to_string().to_lowercase())}>
|
||||
{tool.prioritaet.to_string()}
|
||||
</span>
|
||||
</td>
|
||||
<td class="tag-zelle">
|
||||
{tool.tags.iter().map(|tag| view! {
|
||||
<span class="tag-chip">{tag.clone()}</span>
|
||||
}).collect::<Vec<_>>()}
|
||||
</td>
|
||||
<td class="aktionen-zelle">
|
||||
<button
|
||||
class="btn btn-klein btn-sekundaer"
|
||||
on:click=move |_| {
|
||||
bearbeitungs_modus.set(Some(
|
||||
FormModus::Bearbeiten(tool_edit.clone())
|
||||
));
|
||||
}
|
||||
>
|
||||
"✏"
|
||||
</button>
|
||||
<button
|
||||
class="btn btn-klein btn-gefahr"
|
||||
on:click=move |_| {
|
||||
if web_sys::window()
|
||||
.unwrap()
|
||||
.confirm_with_message(
|
||||
"Werkzeug wirklich löschen?"
|
||||
)
|
||||
.unwrap_or(false)
|
||||
{
|
||||
loeschen_aktion.dispatch(tool_id.clone());
|
||||
}
|
||||
}
|
||||
>
|
||||
"🗑"
|
||||
</button>
|
||||
</td>
|
||||
</tr>
|
||||
|
||||
// --- Detail-Zeile (immer im DOM, per style ein-/ausgeblendet) ---
|
||||
<tr
|
||||
class="detail-zeile"
|
||||
style=move || {
|
||||
if aufgeklappt.get().as_deref() == Some(&id_style) {
|
||||
"display: table-row;"
|
||||
} else {
|
||||
"display: none;"
|
||||
}
|
||||
}
|
||||
>
|
||||
<td colspan="8" class="detail-inhalt">
|
||||
<div class="detail-grid">
|
||||
|
||||
// Verwendung
|
||||
{if !verwendung.is_empty() {
|
||||
view! {
|
||||
<div class="detail-block">
|
||||
<span class="detail-label">"Verwendung"</span>
|
||||
<ul class="detail-verwendung">
|
||||
{verwendung.iter().map(|v| view! {
|
||||
<li>{v.clone()}</li>
|
||||
}).collect::<Vec<_>>()}
|
||||
</ul>
|
||||
</div>
|
||||
}.into_any()
|
||||
} else {
|
||||
view! { <span></span> }.into_any()
|
||||
}}
|
||||
|
||||
// Notizen
|
||||
{notizen.map(|n| view! {
|
||||
<div class="detail-block">
|
||||
<span class="detail-label">"Notizen"</span>
|
||||
<p class="detail-text">{n}</p>
|
||||
</div>
|
||||
})}
|
||||
|
||||
// Verantwortlich
|
||||
{verantwortlich.map(|v| view! {
|
||||
<div class="detail-block">
|
||||
<span class="detail-label">"Verantwortlich"</span>
|
||||
<p class="detail-text">{v}</p>
|
||||
</div>
|
||||
})}
|
||||
|
||||
// Erstellt am
|
||||
<div class="detail-block detail-meta">
|
||||
<span class="detail-label">"Erstellt am"</span>
|
||||
<p class="detail-text detail-datum">{erstellt_am}</p>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
</td>
|
||||
</tr>
|
||||
</>
|
||||
}
|
||||
}).collect::<Vec<_>>()}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
}.into_any()
|
||||
}}
|
||||
}.into_any()
|
||||
}}
|
||||
|
||||
// ---- Modal-Dialog ----
|
||||
<dialog
|
||||
node_ref=dialog_ref
|
||||
class="tool-dialog"
|
||||
on:close=move |_| bearbeitungs_modus.set(None)
|
||||
on:click=move |ev| {
|
||||
use wasm_bindgen::JsCast;
|
||||
// Klick direkt auf <dialog> = Klick auf den Backdrop
|
||||
let auf_backdrop = ev.target()
|
||||
.and_then(|t| t.dyn_into::<web_sys::HtmlDialogElement>().ok())
|
||||
.is_some();
|
||||
if auf_backdrop {
|
||||
bearbeitungs_modus.set(None);
|
||||
}
|
||||
}
|
||||
>
|
||||
{move || {
|
||||
bearbeitungs_modus.get().map(|modus| view! {
|
||||
<ToolForm
|
||||
modus=modus
|
||||
on_fertig=Callback::new(move |_| {
|
||||
bearbeitungs_modus.set(None);
|
||||
neu_laden();
|
||||
})
|
||||
on_abbrechen=Callback::new(move |_| {
|
||||
bearbeitungs_modus.set(None);
|
||||
})
|
||||
/>
|
||||
})
|
||||
}}
|
||||
</dialog>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
pub mod app;
|
||||
pub mod components;
|
||||
pub mod models;
|
||||
pub mod server;
|
||||
|
||||
#[cfg(feature = "hydrate")]
|
||||
#[wasm_bindgen::prelude::wasm_bindgen]
|
||||
pub fn hydrate() {
|
||||
use crate::app::*;
|
||||
console_error_panic_hook::set_once();
|
||||
leptos::mount::hydrate_body(App);
|
||||
}
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
#[cfg(feature = "ssr")]
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
use axum::Router;
|
||||
use leptos::logging::log;
|
||||
use leptos::prelude::*;
|
||||
use leptos_axum::{generate_route_list, LeptosRoutes};
|
||||
use toollist::app::*;
|
||||
|
||||
let conf = get_configuration(None).unwrap();
|
||||
let addr = conf.leptos_options.site_addr;
|
||||
let leptos_options = conf.leptos_options;
|
||||
// Generate the list of routes in your Leptos App
|
||||
let routes = generate_route_list(App);
|
||||
|
||||
let app = Router::new()
|
||||
.route(
|
||||
"/api/{*fn_name}",
|
||||
axum::routing::post(leptos_axum::handle_server_fns),
|
||||
)
|
||||
.route(
|
||||
"/export/tools.csv",
|
||||
axum::routing::get(toollist::server::export::handler::tools_csv),
|
||||
)
|
||||
.leptos_routes(&leptos_options, routes, {
|
||||
let leptos_options = leptos_options.clone();
|
||||
move || shell(leptos_options.clone())
|
||||
})
|
||||
.fallback(leptos_axum::file_and_error_handler(shell))
|
||||
.with_state(leptos_options);
|
||||
|
||||
// run our app with hyper
|
||||
// `axum::Server` is a re-export of `hyper::Server`
|
||||
log!("listening on http://{}", &addr);
|
||||
let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
|
||||
axum::serve(listener, app.into_make_service())
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "ssr"))]
|
||||
pub fn main() {
|
||||
// no client-side main function
|
||||
// unless we want this to work with e.g., Trunk for pure client-side testing
|
||||
// see lib.rs for hydration function instead
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod tool;
|
||||
@@ -0,0 +1,235 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::fmt;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tool – Hauptstruktur
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
pub struct Tool {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub anzahl: Anzahl,
|
||||
pub beschaffung: Beschaffung,
|
||||
pub verwendung: Vec<String>,
|
||||
pub tags: Vec<String>,
|
||||
pub status: Status,
|
||||
pub prioritaet: Prioritaet,
|
||||
pub notizen: Option<String>,
|
||||
pub verantwortlich: Option<String>,
|
||||
pub erstellt_am: String, // ISO-8601, wird nur serverseitig gesetzt
|
||||
}
|
||||
|
||||
#[cfg(feature = "ssr")]
|
||||
impl Tool {
|
||||
pub fn neu(input: NewTool) -> Self {
|
||||
Tool {
|
||||
id: uuid::Uuid::new_v4().to_string(),
|
||||
erstellt_am: chrono::Utc::now().to_rfc3339(),
|
||||
name: input.name,
|
||||
anzahl: input.anzahl,
|
||||
beschaffung: input.beschaffung,
|
||||
verwendung: input.verwendung,
|
||||
tags: input.tags,
|
||||
status: input.status,
|
||||
prioritaet: input.prioritaet,
|
||||
notizen: input.notizen,
|
||||
verantwortlich: input.verantwortlich,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Anzahl
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Entweder eine konkrete Zahl oder "Mehrere" (unbestimmt).
|
||||
/// Flache Struct-Darstellung für problemlose TOML-Serialisierung.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
pub struct Anzahl {
|
||||
/// None bedeutet "Mehrere"
|
||||
pub zahl: Option<u32>,
|
||||
}
|
||||
|
||||
impl Anzahl {
|
||||
pub fn zahl(n: u32) -> Self {
|
||||
Self { zahl: Some(n) }
|
||||
}
|
||||
pub fn mehrere() -> Self {
|
||||
Self { zahl: None }
|
||||
}
|
||||
pub fn ist_mehrere(&self) -> bool {
|
||||
self.zahl.is_none()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Anzahl {
|
||||
fn default() -> Self {
|
||||
Self::zahl(1)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Anzahl {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self.zahl {
|
||||
Some(n) => write!(f, "{}", n),
|
||||
None => write!(f, "Mehrere"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Beschaffung
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||||
pub enum BeschaffungsArt {
|
||||
#[default]
|
||||
Unbekannt,
|
||||
InBesitz,
|
||||
Leihen,
|
||||
Mieten,
|
||||
Kaufen,
|
||||
}
|
||||
|
||||
impl fmt::Display for BeschaffungsArt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
BeschaffungsArt::Unbekannt => write!(f, "Unbekannt"),
|
||||
BeschaffungsArt::InBesitz => write!(f, "In Besitz"),
|
||||
BeschaffungsArt::Leihen => write!(f, "Leihen"),
|
||||
BeschaffungsArt::Mieten => write!(f, "Mieten"),
|
||||
BeschaffungsArt::Kaufen => write!(f, "Kaufen"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Flache Struct-Darstellung damit TOML-Serialisierung einfach bleibt.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||||
pub struct Beschaffung {
|
||||
pub art: BeschaffungsArt,
|
||||
/// Für Leihen: von wem
|
||||
pub von: Option<String>,
|
||||
/// Für Mieten/Kaufen: wo
|
||||
pub wo: Option<String>,
|
||||
/// Für Mieten/Kaufen: Preis in €
|
||||
pub preis: Option<f64>,
|
||||
}
|
||||
|
||||
impl fmt::Display for Beschaffung {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self.art {
|
||||
BeschaffungsArt::Unbekannt => write!(f, "Unbekannt"),
|
||||
BeschaffungsArt::InBesitz => write!(f, "In Besitz"),
|
||||
BeschaffungsArt::Leihen => {
|
||||
if let Some(von) = &self.von {
|
||||
write!(f, "Leihen (von {})", von)
|
||||
} else {
|
||||
write!(f, "Leihen")
|
||||
}
|
||||
}
|
||||
BeschaffungsArt::Mieten => {
|
||||
let wo = self.wo.as_deref().unwrap_or("?");
|
||||
if let Some(p) = self.preis {
|
||||
write!(f, "Mieten bei {} ({:.2} €)", wo, p)
|
||||
} else {
|
||||
write!(f, "Mieten bei {}", wo)
|
||||
}
|
||||
}
|
||||
BeschaffungsArt::Kaufen => {
|
||||
let wo = self.wo.as_deref().unwrap_or("?");
|
||||
if let Some(p) = self.preis {
|
||||
write!(f, "Kaufen bei {} ({:.2} €)", wo, p)
|
||||
} else {
|
||||
write!(f, "Kaufen bei {}", wo)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Status
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||||
pub enum Status {
|
||||
#[default]
|
||||
Offen,
|
||||
Organisiert,
|
||||
VorOrt,
|
||||
}
|
||||
|
||||
impl fmt::Display for Status {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Status::Offen => write!(f, "Offen"),
|
||||
Status::Organisiert => write!(f, "Organisiert"),
|
||||
Status::VorOrt => write!(f, "Vor Ort"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Prioritaet
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||||
pub enum Prioritaet {
|
||||
Hoch,
|
||||
#[default]
|
||||
Mittel,
|
||||
Niedrig,
|
||||
}
|
||||
|
||||
impl fmt::Display for Prioritaet {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Prioritaet::Hoch => write!(f, "Hoch"),
|
||||
Prioritaet::Mittel => write!(f, "Mittel"),
|
||||
Prioritaet::Niedrig => write!(f, "Niedrig"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// NewTool – Eingabe-Struct für Erstellen und Bearbeiten
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Wird als serde-Default für NewTool::anzahl verwendet, damit ein leeres
|
||||
// Anzahl-Objekt (Mehrere = zahl: None, keine URL-Keys) korrekt deserialisiert.
|
||||
fn default_anzahl_mehrere() -> Anzahl {
|
||||
Anzahl::mehrere()
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||||
pub struct NewTool {
|
||||
pub name: String,
|
||||
#[serde(default = "default_anzahl_mehrere")]
|
||||
pub anzahl: Anzahl,
|
||||
pub beschaffung: Beschaffung,
|
||||
#[serde(default)]
|
||||
pub verwendung: Vec<String>,
|
||||
#[serde(default)]
|
||||
pub tags: Vec<String>,
|
||||
pub status: Status,
|
||||
pub prioritaet: Prioritaet,
|
||||
pub notizen: Option<String>,
|
||||
pub verantwortlich: Option<String>,
|
||||
}
|
||||
|
||||
impl From<&Tool> for NewTool {
|
||||
fn from(t: &Tool) -> Self {
|
||||
NewTool {
|
||||
name: t.name.clone(),
|
||||
anzahl: t.anzahl.clone(),
|
||||
beschaffung: t.beschaffung.clone(),
|
||||
verwendung: t.verwendung.clone(),
|
||||
tags: t.tags.clone(),
|
||||
status: t.status.clone(),
|
||||
prioritaet: t.prioritaet.clone(),
|
||||
notizen: t.notizen.clone(),
|
||||
verantwortlich: t.verantwortlich.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
use crate::models::tool::{NewTool, Tool};
|
||||
use leptos::prelude::*;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Lesen
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[server]
|
||||
pub async fn tools_laden() -> Result<Vec<Tool>, ServerFnError> {
|
||||
use crate::server::store;
|
||||
store::lade_tools().map_err(ServerFnError::new)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Erstellen
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[server]
|
||||
pub async fn tool_erstellen(input: NewTool) -> Result<Tool, ServerFnError> {
|
||||
use crate::server::store;
|
||||
let tool = Tool::neu(input);
|
||||
store::erstelle_tool(tool).map_err(ServerFnError::new)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Aktualisieren
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[server]
|
||||
pub async fn tool_aktualisieren(id: String, input: NewTool) -> Result<Tool, ServerFnError> {
|
||||
use crate::server::store;
|
||||
// bestehenden Eintrag laden um erstellt_am zu behalten
|
||||
let tools = store::lade_tools().map_err(ServerFnError::new)?;
|
||||
let original = tools
|
||||
.iter()
|
||||
.find(|t| t.id == id)
|
||||
.ok_or_else(|| ServerFnError::new(format!("Tool '{id}' nicht gefunden")))?;
|
||||
|
||||
let aktualisiert = Tool {
|
||||
id: id.clone(),
|
||||
erstellt_am: original.erstellt_am.clone(),
|
||||
name: input.name,
|
||||
anzahl: input.anzahl,
|
||||
beschaffung: input.beschaffung,
|
||||
verwendung: input.verwendung,
|
||||
tags: input.tags,
|
||||
status: input.status,
|
||||
prioritaet: input.prioritaet,
|
||||
notizen: input.notizen,
|
||||
verantwortlich: input.verantwortlich,
|
||||
};
|
||||
|
||||
store::aktualisiere_tool(&id, aktualisiert).map_err(ServerFnError::new)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Löschen
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[server]
|
||||
pub async fn tool_loeschen(id: String) -> Result<(), ServerFnError> {
|
||||
use crate::server::store;
|
||||
store::loesche_tool(&id).map_err(ServerFnError::new)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CSV-Import (nur Name + Anzahl)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[server]
|
||||
pub async fn csv_importieren(inhalt: String) -> Result<usize, ServerFnError> {
|
||||
use crate::models::tool::{Anzahl, Beschaffung, Prioritaet, Status};
|
||||
use crate::server::store;
|
||||
|
||||
let mut tools = store::lade_tools().map_err(ServerFnError::new)?;
|
||||
let mut importiert = 0usize;
|
||||
|
||||
for zeile in inhalt.lines() {
|
||||
let zeile = zeile.trim();
|
||||
// Kommentare und Kopfzeile überspringen
|
||||
if zeile.is_empty() || zeile.starts_with('#') || zeile.to_lowercase().starts_with("name") {
|
||||
continue;
|
||||
}
|
||||
|
||||
let teile: Vec<&str> = zeile.splitn(2, ',').collect();
|
||||
let name = teile[0].trim().to_string();
|
||||
if name.is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let anzahl = if teile.len() > 1 {
|
||||
let roh = teile[1].trim();
|
||||
if roh.to_lowercase() == "mehrere" || roh.is_empty() {
|
||||
Anzahl::mehrere()
|
||||
} else {
|
||||
match roh.parse::<u32>() {
|
||||
Ok(n) => Anzahl::zahl(n),
|
||||
Err(_) => Anzahl::mehrere(),
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Anzahl::zahl(1)
|
||||
};
|
||||
|
||||
let tool = Tool::neu(NewTool {
|
||||
name,
|
||||
anzahl,
|
||||
beschaffung: Beschaffung::default(),
|
||||
verwendung: vec![],
|
||||
tags: vec![],
|
||||
status: Status::Offen,
|
||||
prioritaet: Prioritaet::Mittel,
|
||||
notizen: None,
|
||||
verantwortlich: None,
|
||||
});
|
||||
|
||||
tools.push(tool);
|
||||
importiert += 1;
|
||||
}
|
||||
|
||||
store::speichere_tools(&tools).map_err(ServerFnError::new)?;
|
||||
Ok(importiert)
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
#[cfg(feature = "ssr")]
|
||||
pub mod handler {
|
||||
use axum::http::{header, StatusCode};
|
||||
use axum::response::Response;
|
||||
|
||||
use crate::server::store;
|
||||
|
||||
/// Escaped ein einzelnes CSV-Feld nach RFC 4180.
|
||||
fn feld(s: &str) -> String {
|
||||
if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
|
||||
format!("\"{}\"", s.replace('"', "\"\""))
|
||||
} else {
|
||||
s.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn tools_csv() -> Response {
|
||||
let tools = match store::lade_tools() {
|
||||
Ok(t) => t,
|
||||
Err(e) => {
|
||||
return Response::builder()
|
||||
.status(StatusCode::INTERNAL_SERVER_ERROR)
|
||||
.body(format!("Fehler: {e}").into())
|
||||
.unwrap();
|
||||
}
|
||||
};
|
||||
|
||||
let mut csv = String::from(
|
||||
"id,name,anzahl,beschaffung_art,beschaffung_von,beschaffung_wo,\
|
||||
beschaffung_preis,verwendung,tags,status,prioritaet,notizen,\
|
||||
verantwortlich,erstellt_am\n",
|
||||
);
|
||||
|
||||
for t in &tools {
|
||||
let zeile = [
|
||||
feld(&t.id),
|
||||
feld(&t.name),
|
||||
feld(&t.anzahl.to_string()),
|
||||
feld(&t.beschaffung.art.to_string()),
|
||||
feld(t.beschaffung.von.as_deref().unwrap_or("")),
|
||||
feld(t.beschaffung.wo.as_deref().unwrap_or("")),
|
||||
feld(
|
||||
&t.beschaffung
|
||||
.preis
|
||||
.map(|p| format!("{p:.2}"))
|
||||
.unwrap_or_default(),
|
||||
),
|
||||
feld(&t.verwendung.join("; ")),
|
||||
feld(&t.tags.join(", ")),
|
||||
feld(&t.status.to_string()),
|
||||
feld(&t.prioritaet.to_string()),
|
||||
feld(t.notizen.as_deref().unwrap_or("")),
|
||||
feld(t.verantwortlich.as_deref().unwrap_or("")),
|
||||
feld(&t.erstellt_am),
|
||||
]
|
||||
.join(",");
|
||||
|
||||
csv.push_str(&zeile);
|
||||
csv.push('\n');
|
||||
}
|
||||
|
||||
Response::builder()
|
||||
.status(StatusCode::OK)
|
||||
.header(header::CONTENT_TYPE, "text/csv; charset=utf-8")
|
||||
.header(
|
||||
header::CONTENT_DISPOSITION,
|
||||
"attachment; filename=\"werkzeuge.csv\"",
|
||||
)
|
||||
.body(csv.into())
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#[cfg(feature = "ssr")]
|
||||
pub mod store;
|
||||
|
||||
pub mod api;
|
||||
pub mod export;
|
||||
@@ -0,0 +1,67 @@
|
||||
use crate::models::tool::Tool;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::path::Path;
|
||||
|
||||
const STORE_PATH: &str = "data/tools.toml";
|
||||
|
||||
// TOML-Wrapper: die Datei enthält ein [[tools]]-Array
|
||||
#[derive(Serialize, Deserialize, Default)]
|
||||
struct ToolStore {
|
||||
tools: Vec<Tool>,
|
||||
}
|
||||
|
||||
pub fn lade_tools() -> Result<Vec<Tool>, String> {
|
||||
let path = Path::new(STORE_PATH);
|
||||
if !path.exists() {
|
||||
return Ok(vec![]);
|
||||
}
|
||||
let inhalt = std::fs::read_to_string(path).map_err(|e| format!("Lesefehler: {e}"))?;
|
||||
let store: ToolStore = toml::from_str(&inhalt).map_err(|e| format!("TOML-Fehler: {e}"))?;
|
||||
Ok(store.tools)
|
||||
}
|
||||
|
||||
pub fn speichere_tools(tools: &[Tool]) -> Result<(), String> {
|
||||
let store = ToolStore {
|
||||
tools: tools.to_vec(),
|
||||
};
|
||||
let inhalt =
|
||||
toml::to_string_pretty(&store).map_err(|e| format!("Serialisierungsfehler: {e}"))?;
|
||||
|
||||
// Verzeichnis anlegen falls nicht vorhanden
|
||||
if let Some(eltern) = Path::new(STORE_PATH).parent() {
|
||||
std::fs::create_dir_all(eltern).map_err(|e| format!("Verzeichnisfehler: {e}"))?;
|
||||
}
|
||||
|
||||
std::fs::write(STORE_PATH, inhalt).map_err(|e| format!("Schreibfehler: {e}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// --- Hilfsfunktionen --------------------------------------------------------
|
||||
|
||||
pub fn erstelle_tool(tool: Tool) -> Result<Tool, String> {
|
||||
let mut tools = lade_tools()?;
|
||||
tools.push(tool.clone());
|
||||
speichere_tools(&tools)?;
|
||||
Ok(tool)
|
||||
}
|
||||
|
||||
pub fn aktualisiere_tool(id: &str, neu: Tool) -> Result<Tool, String> {
|
||||
let mut tools = lade_tools()?;
|
||||
let pos = tools
|
||||
.iter()
|
||||
.position(|t| t.id == id)
|
||||
.ok_or_else(|| format!("Tool mit id '{id}' nicht gefunden"))?;
|
||||
tools[pos] = neu.clone();
|
||||
speichere_tools(&tools)?;
|
||||
Ok(neu)
|
||||
}
|
||||
|
||||
pub fn loesche_tool(id: &str) -> Result<(), String> {
|
||||
let mut tools = lade_tools()?;
|
||||
let vorher = tools.len();
|
||||
tools.retain(|t| t.id != id);
|
||||
if tools.len() == vorher {
|
||||
return Err(format!("Tool mit id '{id}' nicht gefunden"));
|
||||
}
|
||||
speichere_tools(&tools)
|
||||
}
|
||||
Reference in New Issue
Block a user