first commit
This commit is contained in:
commit
dd6a740645
37 files changed
+5424
No files matched your search
@@ -0,0 +1,620 @@
|
||||
//! Server-rendered pages and the htmx fragments they swap in.
|
||||
|
||||
use askama::Template;
|
||||
use axum::Form;
|
||||
use axum::Router;
|
||||
use axum::extract::{Path, Query, State};
|
||||
use axum::http::StatusCode;
|
||||
use axum::response::{AppendHeaders, Html, IntoResponse, Redirect, Response};
|
||||
use axum::routing::{get, post};
|
||||
use chrono::{Duration, NaiveDate};
|
||||
use serde::Deserialize;
|
||||
use sqlx::SqlitePool;
|
||||
|
||||
use crate::clock;
|
||||
use crate::error::AppError;
|
||||
use crate::models::{
|
||||
Client, Entry, EntryFilter, GroupBy, NewEntry, Project, Report, ReportQuery, UpdateEntry,
|
||||
UpdateInput, empty_as_none,
|
||||
};
|
||||
use crate::repo::{clients, entries, projects, reports};
|
||||
|
||||
pub fn router() -> Router<SqlitePool> {
|
||||
Router::new()
|
||||
.route("/", get(dashboard))
|
||||
.route("/clients", get(clients_page))
|
||||
.route("/entries", get(entries_page))
|
||||
.route("/reports", get(reports_page))
|
||||
.route("/ui/today", get(today_fragment))
|
||||
.route("/ui/timer/start", post(start_timer))
|
||||
.route("/ui/timer/stop", post(stop_timer))
|
||||
.route("/ui/clients", post(create_client))
|
||||
.route("/ui/clients/{id}", post(save_client))
|
||||
.route("/ui/clients/{id}/archive", post(archive_client))
|
||||
.route("/ui/clients/{id}/delete", post(delete_client))
|
||||
.route("/ui/clients/{id}/projects", post(create_project))
|
||||
.route("/ui/projects/{id}", post(save_project))
|
||||
.route("/ui/projects/{id}/archive", post(archive_project))
|
||||
.route("/ui/projects/{id}/delete", post(delete_project))
|
||||
.route("/ui/entries", post(create_entry))
|
||||
.route(
|
||||
"/ui/entries/{id}",
|
||||
get(entry_row).put(update_entry).delete(delete_entry),
|
||||
)
|
||||
.route("/ui/entries/{id}/edit", get(entry_edit))
|
||||
}
|
||||
|
||||
// --- Plumbing ---------------------------------------------------------------
|
||||
|
||||
/// Renders errors as an HTML page; `app.js` extracts the message for htmx requests.
|
||||
pub struct PageError(AppError);
|
||||
|
||||
impl From<AppError> for PageError {
|
||||
fn from(e: AppError) -> Self {
|
||||
Self(e)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<askama::Error> for PageError {
|
||||
fn from(e: askama::Error) -> Self {
|
||||
Self(e.into())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "error.html")]
|
||||
struct ErrorTpl {
|
||||
nav: &'static str,
|
||||
message: String,
|
||||
}
|
||||
|
||||
impl IntoResponse for PageError {
|
||||
fn into_response(self) -> Response {
|
||||
self.0.log();
|
||||
let tpl = ErrorTpl {
|
||||
nav: "",
|
||||
message: self.0.to_string(),
|
||||
};
|
||||
let body = tpl.render().unwrap_or_else(|_| self.0.to_string());
|
||||
(self.0.status(), Html(body)).into_response()
|
||||
}
|
||||
}
|
||||
|
||||
type PageResult<T = Response> = Result<T, PageError>;
|
||||
|
||||
fn render(tpl: impl Template) -> PageResult {
|
||||
Ok(Html(tpl.render()?).into_response())
|
||||
}
|
||||
|
||||
/// Tells listeners on the page (e.g. today's list) that entries changed.
|
||||
fn with_entries_changed(resp: Response) -> Response {
|
||||
(AppendHeaders([("HX-Trigger", "entries-changed")]), resp).into_response()
|
||||
}
|
||||
|
||||
struct ProjectOption {
|
||||
id: i64,
|
||||
name: String,
|
||||
selected: bool,
|
||||
}
|
||||
|
||||
struct ProjectGroup {
|
||||
name: String,
|
||||
projects: Vec<ProjectOption>,
|
||||
}
|
||||
|
||||
/// Groups projects (already sorted by client) for `<optgroup>`s.
|
||||
fn group_projects(list: Vec<Project>, selected: Option<i64>) -> Vec<ProjectGroup> {
|
||||
let mut groups: Vec<ProjectGroup> = Vec::new();
|
||||
for p in list {
|
||||
if groups.last().is_none_or(|g| g.name != p.client_name) {
|
||||
groups.push(ProjectGroup {
|
||||
name: p.client_name.clone(),
|
||||
projects: Vec::new(),
|
||||
});
|
||||
}
|
||||
let name = if p.archived {
|
||||
format!("{} (archivé)", p.name)
|
||||
} else {
|
||||
p.name
|
||||
};
|
||||
groups
|
||||
.last_mut()
|
||||
.expect("just pushed")
|
||||
.projects
|
||||
.push(ProjectOption {
|
||||
id: p.id,
|
||||
name,
|
||||
selected: Some(p.id) == selected,
|
||||
});
|
||||
}
|
||||
groups
|
||||
}
|
||||
|
||||
struct ClientOption {
|
||||
id: i64,
|
||||
name: String,
|
||||
selected: bool,
|
||||
}
|
||||
|
||||
fn client_options(list: Vec<Client>, selected: Option<i64>) -> Vec<ClientOption> {
|
||||
list.into_iter()
|
||||
.map(|c| ClientOption {
|
||||
selected: Some(c.id) == selected,
|
||||
id: c.id,
|
||||
name: c.name,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct Preset {
|
||||
label: &'static str,
|
||||
from: NaiveDate,
|
||||
to: NaiveDate,
|
||||
active: bool,
|
||||
}
|
||||
|
||||
fn presets(from: NaiveDate, to: NaiveDate) -> Vec<Preset> {
|
||||
let today = clock::today();
|
||||
let last_month = clock::month_start(today) - Duration::days(1);
|
||||
[
|
||||
("Aujourd'hui", today, today),
|
||||
("Cette semaine", clock::week_start(today), today),
|
||||
(
|
||||
"Semaine dernière",
|
||||
clock::week_start(today) - Duration::days(7),
|
||||
clock::week_start(today) - Duration::days(1),
|
||||
),
|
||||
("Ce mois", clock::month_start(today), today),
|
||||
("Mois dernier", clock::month_start(last_month), last_month),
|
||||
]
|
||||
.into_iter()
|
||||
.map(|(label, f, t)| Preset {
|
||||
label,
|
||||
from: f,
|
||||
to: t,
|
||||
active: f == from && t == to,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Query-string suffix that keeps the current filters when switching period.
|
||||
fn id_params(client_id: Option<i64>, project_id: Option<i64>) -> String {
|
||||
let mut s = String::new();
|
||||
if let Some(id) = client_id {
|
||||
s.push_str(&format!("&client_id={id}"));
|
||||
}
|
||||
if let Some(id) = project_id {
|
||||
s.push_str(&format!("&project_id={id}"));
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Resolves an optional period, defaulting to the current week.
|
||||
fn period(from: Option<NaiveDate>, to: Option<NaiveDate>) -> (NaiveDate, NaiveDate) {
|
||||
let today = clock::today();
|
||||
let from = from.unwrap_or_else(|| clock::week_start(today));
|
||||
(from, to.unwrap_or(today.max(from)))
|
||||
}
|
||||
|
||||
// --- Dashboard & timer ------------------------------------------------------
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "dashboard.html")]
|
||||
struct DashboardTpl {
|
||||
nav: &'static str,
|
||||
running: Option<Entry>,
|
||||
groups: Vec<ProjectGroup>,
|
||||
today_entries: Vec<Entry>,
|
||||
today_total: String,
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "_timer.html")]
|
||||
struct TimerTpl {
|
||||
running: Option<Entry>,
|
||||
groups: Vec<ProjectGroup>,
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "_today.html")]
|
||||
struct TodayTpl {
|
||||
today_entries: Vec<Entry>,
|
||||
today_total: String,
|
||||
}
|
||||
|
||||
async fn timer_state(pool: &SqlitePool) -> PageResult<TimerTpl> {
|
||||
let running = entries::running(pool).await?;
|
||||
// Preselect the running project, else the most recently tracked one.
|
||||
let selected = match &running {
|
||||
Some(e) => Some(e.project_id),
|
||||
None => entries::last_project_id(pool).await?,
|
||||
};
|
||||
let groups = group_projects(projects::list(pool, None, false).await?, selected);
|
||||
Ok(TimerTpl { running, groups })
|
||||
}
|
||||
|
||||
async fn today_state(pool: &SqlitePool) -> PageResult<TodayTpl> {
|
||||
let today = clock::today();
|
||||
let now = clock::now();
|
||||
let filter = EntryFilter {
|
||||
from: Some(today),
|
||||
to: Some(today),
|
||||
..Default::default()
|
||||
};
|
||||
let today_entries = entries::list(pool, &filter, now).await?;
|
||||
let total = reports::aggregate(&today_entries, today, today, GroupBy::Client, now);
|
||||
Ok(TodayTpl {
|
||||
today_entries,
|
||||
today_total: total.total(),
|
||||
})
|
||||
}
|
||||
|
||||
async fn dashboard(State(pool): State<SqlitePool>) -> PageResult {
|
||||
let TimerTpl { running, groups } = timer_state(&pool).await?;
|
||||
let TodayTpl {
|
||||
today_entries,
|
||||
today_total,
|
||||
} = today_state(&pool).await?;
|
||||
render(DashboardTpl {
|
||||
nav: "dashboard",
|
||||
running,
|
||||
groups,
|
||||
today_entries,
|
||||
today_total,
|
||||
})
|
||||
}
|
||||
|
||||
async fn today_fragment(State(pool): State<SqlitePool>) -> PageResult {
|
||||
render(today_state(&pool).await?)
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct StartForm {
|
||||
project_id: i64,
|
||||
#[serde(default)]
|
||||
note: String,
|
||||
}
|
||||
|
||||
async fn start_timer(State(pool): State<SqlitePool>, Form(form): Form<StartForm>) -> PageResult {
|
||||
entries::start(&pool, form.project_id, &form.note).await?;
|
||||
Ok(with_entries_changed(render(timer_state(&pool).await?)?))
|
||||
}
|
||||
|
||||
async fn stop_timer(State(pool): State<SqlitePool>) -> PageResult {
|
||||
match entries::stop(&pool).await {
|
||||
// Already stopped (e.g. from another tab): just refresh the widget.
|
||||
Ok(_) | Err(AppError::Conflict(_)) => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
Ok(with_entries_changed(render(timer_state(&pool).await?)?))
|
||||
}
|
||||
|
||||
// --- Clients & projects -----------------------------------------------------
|
||||
|
||||
struct ClientCard {
|
||||
client: Client,
|
||||
projects: Vec<Project>,
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "clients.html")]
|
||||
struct ClientsTpl {
|
||||
nav: &'static str,
|
||||
clients: Vec<ClientCard>,
|
||||
next_color: String,
|
||||
}
|
||||
|
||||
async fn clients_page(State(pool): State<SqlitePool>) -> PageResult {
|
||||
let all_projects = projects::list(&pool, None, true).await?;
|
||||
let clients = clients::list(&pool, true)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|client| {
|
||||
let projects = all_projects
|
||||
.iter()
|
||||
.filter(|p| p.client_id == client.id)
|
||||
.cloned()
|
||||
.collect();
|
||||
ClientCard { client, projects }
|
||||
})
|
||||
.collect();
|
||||
render(ClientsTpl {
|
||||
nav: "clients",
|
||||
clients,
|
||||
next_color: clients::next_color(&pool).await?,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct ItemForm {
|
||||
name: String,
|
||||
#[serde(default, deserialize_with = "empty_as_none")]
|
||||
color: Option<String>,
|
||||
/// Projects only: go back to the client's color.
|
||||
#[serde(default)]
|
||||
inherit: bool,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct ArchiveForm {
|
||||
archived: bool,
|
||||
}
|
||||
|
||||
fn back_to_clients() -> PageResult {
|
||||
Ok(Redirect::to("/clients").into_response())
|
||||
}
|
||||
|
||||
fn archive_input(archived: bool) -> UpdateInput {
|
||||
UpdateInput {
|
||||
archived: Some(archived),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
async fn create_client(State(pool): State<SqlitePool>, Form(f): Form<ItemForm>) -> PageResult {
|
||||
clients::create(&pool, &f.name, f.color.as_deref()).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn save_client(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(id): Path<i64>,
|
||||
Form(f): Form<ItemForm>,
|
||||
) -> PageResult {
|
||||
let input = UpdateInput {
|
||||
name: Some(f.name),
|
||||
color: f.color.map(Some),
|
||||
..Default::default()
|
||||
};
|
||||
clients::update(&pool, id, &input).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn archive_client(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(id): Path<i64>,
|
||||
Form(f): Form<ArchiveForm>,
|
||||
) -> PageResult {
|
||||
clients::update(&pool, id, &archive_input(f.archived)).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn delete_client(State(pool): State<SqlitePool>, Path(id): Path<i64>) -> PageResult {
|
||||
clients::delete(&pool, id).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn create_project(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(client_id): Path<i64>,
|
||||
Form(f): Form<ItemForm>,
|
||||
) -> PageResult {
|
||||
// The color picker is prefilled with the client's color: keeping it means inheriting.
|
||||
let client = clients::get(&pool, client_id).await?;
|
||||
let color = f.color.filter(|c| !c.eq_ignore_ascii_case(&client.color));
|
||||
projects::create(&pool, client_id, &f.name, color.as_deref()).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn save_project(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(id): Path<i64>,
|
||||
Form(f): Form<ItemForm>,
|
||||
) -> PageResult {
|
||||
let current = projects::get(&pool, id).await?;
|
||||
let color = if f.inherit {
|
||||
Some(None)
|
||||
} else {
|
||||
// Untouched picker: leave the color (own or inherited) as it is.
|
||||
f.color
|
||||
.filter(|c| !c.eq_ignore_ascii_case(¤t.effective_color))
|
||||
.map(Some)
|
||||
};
|
||||
let input = UpdateInput {
|
||||
name: Some(f.name),
|
||||
color,
|
||||
..Default::default()
|
||||
};
|
||||
projects::update(&pool, id, &input).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn archive_project(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(id): Path<i64>,
|
||||
Form(f): Form<ArchiveForm>,
|
||||
) -> PageResult {
|
||||
projects::update(&pool, id, &archive_input(f.archived)).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
async fn delete_project(State(pool): State<SqlitePool>, Path(id): Path<i64>) -> PageResult {
|
||||
projects::delete(&pool, id).await?;
|
||||
back_to_clients()
|
||||
}
|
||||
|
||||
// --- Entries ----------------------------------------------------------------
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "entries.html")]
|
||||
struct EntriesTpl {
|
||||
nav: &'static str,
|
||||
from: NaiveDate,
|
||||
to: NaiveDate,
|
||||
presets: Vec<Preset>,
|
||||
extra_query: String,
|
||||
clients: Vec<ClientOption>,
|
||||
filter_groups: Vec<ProjectGroup>,
|
||||
groups: Vec<ProjectGroup>,
|
||||
entries: Vec<Entry>,
|
||||
total: String,
|
||||
default_start: String,
|
||||
default_end: String,
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "_entry_row.html")]
|
||||
struct EntryRowTpl {
|
||||
e: Entry,
|
||||
}
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "_entry_edit.html")]
|
||||
struct EntryEditTpl {
|
||||
e: Entry,
|
||||
groups: Vec<ProjectGroup>,
|
||||
}
|
||||
|
||||
async fn entries_page(
|
||||
State(pool): State<SqlitePool>,
|
||||
Query(filter): Query<EntryFilter>,
|
||||
) -> PageResult {
|
||||
let (from, to) = period(filter.from, filter.to);
|
||||
let filter = EntryFilter {
|
||||
from: Some(from),
|
||||
to: Some(to),
|
||||
..filter
|
||||
};
|
||||
let now = clock::now();
|
||||
let list = entries::list(&pool, &filter, now).await?;
|
||||
let total = reports::aggregate(&list, from, to, GroupBy::Client, now).total();
|
||||
|
||||
let last_project = list.first().map(|e| e.project_id);
|
||||
let today = clock::today();
|
||||
render(EntriesTpl {
|
||||
nav: "entries",
|
||||
from,
|
||||
to,
|
||||
presets: presets(from, to),
|
||||
extra_query: id_params(filter.client_id, filter.project_id),
|
||||
clients: client_options(clients::list(&pool, true).await?, filter.client_id),
|
||||
filter_groups: group_projects(projects::list(&pool, None, true).await?, filter.project_id),
|
||||
groups: group_projects(projects::list(&pool, None, false).await?, last_project),
|
||||
entries: list,
|
||||
total,
|
||||
default_start: format!("{today}T09:00"),
|
||||
default_end: format!("{today}T10:00"),
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct EntryForm {
|
||||
project_id: i64,
|
||||
started_at: String,
|
||||
#[serde(default)]
|
||||
ended_at: String,
|
||||
#[serde(default)]
|
||||
note: String,
|
||||
}
|
||||
|
||||
fn parse_datetime(value: &str, field: &str) -> Result<chrono::DateTime<chrono::Utc>, AppError> {
|
||||
clock::parse_input(value).ok_or_else(|| AppError::Validation(format!("{field} invalide")))
|
||||
}
|
||||
|
||||
async fn create_entry(State(pool): State<SqlitePool>, Form(f): Form<EntryForm>) -> PageResult {
|
||||
let started = parse_datetime(&f.started_at, "début")?;
|
||||
let ended = parse_datetime(&f.ended_at, "fin")?;
|
||||
let entry = entries::create(
|
||||
&pool,
|
||||
&NewEntry {
|
||||
project_id: f.project_id,
|
||||
started_at: started.fixed_offset(),
|
||||
ended_at: ended.fixed_offset(),
|
||||
note: f.note,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
// Land on the week containing the new entry so it is visible.
|
||||
let day = clock::local_date(&entry.started_at);
|
||||
let from = clock::week_start(day);
|
||||
Ok(Redirect::to(&format!(
|
||||
"/entries?from={from}&to={}",
|
||||
from + Duration::days(6)
|
||||
))
|
||||
.into_response())
|
||||
}
|
||||
|
||||
async fn entry_row(State(pool): State<SqlitePool>, Path(id): Path<i64>) -> PageResult {
|
||||
render(EntryRowTpl {
|
||||
e: entries::get(&pool, id).await?,
|
||||
})
|
||||
}
|
||||
|
||||
async fn entry_edit(State(pool): State<SqlitePool>, Path(id): Path<i64>) -> PageResult {
|
||||
let e = entries::get(&pool, id).await?;
|
||||
let groups = group_projects(projects::list(&pool, None, true).await?, Some(e.project_id));
|
||||
render(EntryEditTpl { e, groups })
|
||||
}
|
||||
|
||||
async fn update_entry(
|
||||
State(pool): State<SqlitePool>,
|
||||
Path(id): Path<i64>,
|
||||
Form(f): Form<EntryForm>,
|
||||
) -> PageResult {
|
||||
let started = parse_datetime(&f.started_at, "début")?;
|
||||
let ended = match f.ended_at.trim() {
|
||||
"" => None,
|
||||
v => Some(parse_datetime(v, "fin")?),
|
||||
};
|
||||
let e = entries::update(
|
||||
&pool,
|
||||
id,
|
||||
&UpdateEntry {
|
||||
project_id: Some(f.project_id),
|
||||
started_at: Some(started.fixed_offset()),
|
||||
ended_at: ended.map(|d| d.fixed_offset()),
|
||||
note: Some(f.note),
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
Ok(with_entries_changed(render(EntryRowTpl { e })?))
|
||||
}
|
||||
|
||||
async fn delete_entry(State(pool): State<SqlitePool>, Path(id): Path<i64>) -> PageResult {
|
||||
entries::delete(&pool, id).await?;
|
||||
// htmx swaps the row with this empty body, removing it.
|
||||
Ok(with_entries_changed((StatusCode::OK, "").into_response()))
|
||||
}
|
||||
|
||||
// --- Reports ----------------------------------------------------------------
|
||||
|
||||
#[derive(Template)]
|
||||
#[template(path = "reports.html")]
|
||||
struct ReportsTpl {
|
||||
nav: &'static str,
|
||||
report: Report,
|
||||
presets: Vec<Preset>,
|
||||
extra_query: String,
|
||||
clients: Vec<ClientOption>,
|
||||
group_by: &'static str,
|
||||
}
|
||||
|
||||
async fn reports_page(State(pool): State<SqlitePool>, Query(q): Query<ReportQuery>) -> PageResult {
|
||||
let (from, to) = period(q.from, q.to);
|
||||
let report = reports::build(
|
||||
&pool,
|
||||
from,
|
||||
to,
|
||||
q.group_by,
|
||||
q.client_id,
|
||||
q.project_id,
|
||||
clock::now(),
|
||||
)
|
||||
.await?;
|
||||
let group_by = match q.group_by {
|
||||
GroupBy::Client => "client",
|
||||
GroupBy::Project => "project",
|
||||
GroupBy::Day => "day",
|
||||
};
|
||||
render(ReportsTpl {
|
||||
nav: "reports",
|
||||
presets: presets(from, to),
|
||||
extra_query: format!(
|
||||
"&group_by={group_by}{}",
|
||||
id_params(q.client_id, q.project_id)
|
||||
),
|
||||
clients: client_options(clients::list(&pool, true).await?, q.client_id),
|
||||
group_by,
|
||||
report,
|
||||
})
|
||||
}
|
||||
Reference in new issue
Block a user