484 lines
17 KiB
Rust
484 lines
17 KiB
Rust
use axum::{
|
||
Router,
|
||
extract::{State, path::Path},
|
||
http::HeaderMap,
|
||
response::IntoResponse,
|
||
routing::{delete, get, post, put},
|
||
};
|
||
use axum_extra::extract::Form;
|
||
use cache_bust::asset;
|
||
use chrono::DateTime;
|
||
use maud::{Markup, PreEscaped, html};
|
||
use serde::Deserialize;
|
||
use serde_json::json;
|
||
use sqlx::{QueryBuilder, Sqlite};
|
||
|
||
use super::Layout;
|
||
use super::home::journal_section;
|
||
use crate::db::DbId;
|
||
use crate::models::user::AuthSession;
|
||
use crate::models::{HydratedContact, JournalEntry};
|
||
use crate::{AppError, AppState};
|
||
|
||
#[derive(serde::Serialize, Debug)]
|
||
pub struct Address {
|
||
pub id: DbId,
|
||
pub contact_id: DbId,
|
||
pub label: Option<String>,
|
||
pub value: String,
|
||
}
|
||
|
||
pub fn router() -> Router<AppState> {
|
||
Router::new()
|
||
.route("/contact/new", post(self::post::contact))
|
||
.route("/contact/{contact_id}", get(self::get::contact))
|
||
.route("/contact/{contact_id}", put(self::put::contact))
|
||
.route("/contact/{contact_id}", delete(self::delete::contact))
|
||
.route("/contact/{contact_id}/edit", get(self::get::contact_edit))
|
||
}
|
||
|
||
fn human_delta(delta: &chrono::TimeDelta) -> String {
|
||
if delta.num_days() == 0 {
|
||
return "today".to_string();
|
||
}
|
||
|
||
let mut result = "in ".to_string();
|
||
let mut rem = delta.clone();
|
||
if rem.num_days().abs() >= 7 {
|
||
let weeks = rem.num_days() / 7;
|
||
rem -= chrono::TimeDelta::days(weeks * 7);
|
||
result.push_str(&format!("{}w ", weeks));
|
||
}
|
||
if rem.num_days().abs() > 0 {
|
||
result.push_str(&format!("{}d ", rem.num_days()));
|
||
}
|
||
result.trim().to_string()
|
||
}
|
||
|
||
mod get {
|
||
use super::*;
|
||
|
||
pub async fn contact(
|
||
auth_session: AuthSession,
|
||
State(state): State<AppState>,
|
||
Path(contact_id): Path<u32>,
|
||
layout: Layout,
|
||
) -> Result<Markup, AppError> {
|
||
let pool = &state.db(&auth_session.user.unwrap()).pool;
|
||
let contact: HydratedContact = sqlx::query_as(
|
||
"select id, birthday, manually_freshened_at, (
|
||
select string_agg(name,'\x1c' order by sort)
|
||
from names where contact_id = c.id
|
||
) as names
|
||
from contacts c
|
||
where c.id = $1",
|
||
)
|
||
.bind(contact_id)
|
||
.fetch_one(pool)
|
||
.await?;
|
||
|
||
let entries: Vec<JournalEntry> = sqlx::query_as(
|
||
"select j.id, j.value, j.date from journal_entries j
|
||
join contact_mentions cm on j.id = cm.entry_id
|
||
where cm.contact_id = $1",
|
||
)
|
||
.bind(contact_id)
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
let addresses: Vec<Address> = sqlx::query_as!(
|
||
Address,
|
||
"select * from addresses where contact_id = $1",
|
||
contact_id
|
||
)
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
let text_body: Option<String> =
|
||
sqlx::query!("select text_body from contacts where id = $1", contact_id)
|
||
.fetch_one(pool)
|
||
.await?
|
||
.text_body;
|
||
|
||
Ok(layout.render(
|
||
Some(vec![asset!("contact.css"), asset!("journal.css")]),
|
||
html! {
|
||
a href=(format!("/contact/{}/edit", contact_id)) { "Edit" }
|
||
|
||
div id="fields" {
|
||
label { @if contact.names.len() > 1 { "names" } @else { "name" }}
|
||
div {
|
||
@for name in &contact.names {
|
||
div { (name) }
|
||
}
|
||
}
|
||
@if let Some(bday) = &contact.birthday {
|
||
label { "birthday" }
|
||
div {
|
||
(bday.to_string())
|
||
@if let Some(delta) = &bday.until_next() {
|
||
" ("
|
||
(human_delta(delta))
|
||
@if let Some(age) = &bday.age() {
|
||
", turning " (age + 1)
|
||
}
|
||
")"
|
||
}
|
||
|
||
}
|
||
}
|
||
label { "freshened" }
|
||
div {
|
||
@if let Some(when) = &contact.manually_freshened_at {
|
||
(when.date_naive().to_string())
|
||
} @else {
|
||
"(never)"
|
||
}
|
||
}
|
||
@if addresses.len() == 1 {
|
||
label { "address" }
|
||
#addresses {
|
||
.label {}
|
||
.value { (addresses[0].value) }
|
||
}
|
||
} @else if addresses.len() > 0 {
|
||
label { "addresses" }
|
||
#addresses {
|
||
@for address in addresses {
|
||
@let lbl = address.label.unwrap_or(String::new());
|
||
.label data-is-empty=(lbl.len() == 0) {
|
||
(lbl)
|
||
}
|
||
.value { (address.value) }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
@if let Some(text_body) = text_body {
|
||
@if text_body.len() > 0 {
|
||
#text_body { (PreEscaped(markdown::to_html(&text_body))) }
|
||
}
|
||
}
|
||
|
||
(journal_section(pool, &entries).await?)
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn contact_edit(
|
||
auth_session: AuthSession,
|
||
State(state): State<AppState>,
|
||
Path(contact_id): Path<u32>,
|
||
layout: Layout,
|
||
) -> Result<Markup, AppError> {
|
||
let pool = &state.db(&auth_session.user.unwrap()).pool;
|
||
let contact: HydratedContact = sqlx::query_as(
|
||
"select id, birthday, manually_freshened_at, (
|
||
select string_agg(name,'\x1c' order by sort)
|
||
from names where contact_id = c.id
|
||
) as names, (
|
||
select jes.date from journal_entries jes
|
||
join contact_mentions cms on cms.entry_id = jes.id
|
||
where cms.contact_id = c.id
|
||
order by jes.date desc limit 1
|
||
) as last_mention_date from contacts c
|
||
where c.id = $1",
|
||
)
|
||
.bind(contact_id)
|
||
.fetch_one(pool)
|
||
.await?;
|
||
|
||
let addresses: Vec<Address> = sqlx::query_as!(
|
||
Address,
|
||
"select * from addresses where contact_id = $1",
|
||
contact_id
|
||
)
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
let cid_url = format!("/contact/{}", contact.id);
|
||
let mfresh_str = contact
|
||
.manually_freshened_at
|
||
.clone()
|
||
.map_or("".to_string(), |m| m.to_rfc3339());
|
||
|
||
let text_body: String =
|
||
sqlx::query!("select text_body from contacts where id = $1", contact_id)
|
||
.fetch_one(pool)
|
||
.await?
|
||
.text_body
|
||
.unwrap_or(String::new());
|
||
|
||
Ok(layout.render(Some(vec![asset!("contact.css")]), html! {
|
||
form hx-ext="response-targets" {
|
||
div {
|
||
input type="button" value="Save" hx-put=(cid_url) hx-target-error="#error";
|
||
input type="button" value="Delete" hx-delete=(cid_url) hx-target-error="#error";
|
||
div #error;
|
||
}
|
||
|
||
div #fields {
|
||
label { @if contact.names.len() > 1 { "names" } @else { "name" }}
|
||
div #names x-data=(format!("{{ names: {:?}, new_name: '' }}", &contact.names)) {
|
||
template x-for="(name, idx) in names" {
|
||
div {
|
||
input name="name" x-model="name";
|
||
input type="button" value="×" x-bind:disabled="idx == 0" x-on:click="names.splice(idx, 1)";
|
||
input type="button" value="↑" x-bind:disabled="idx == 0" x-on:click="[names[idx-1], names[idx]] = [names[idx], names[idx-1]]";
|
||
input type="button" value="↓" x-bind:disabled="idx == names.length - 1" x-on:click="[names[idx+1], names[idx]] = [names[idx], names[idx+1]]";
|
||
}
|
||
}
|
||
div {
|
||
input name="name" x-model="new_name" placeholder="New name";
|
||
input type="button" value="Add" x-on:click="names.push(new_name); new_name = ''";
|
||
}
|
||
}
|
||
label { "birthday" }
|
||
div {
|
||
input name="birthday" value=(contact.birthday.clone().map_or("".to_string(), |b| b.serialize()));
|
||
span .hint { code { "(yyyy|--)mmdd" } " or free text" }
|
||
}
|
||
label { "freshened" }
|
||
div x-data=(json!({ "date": mfresh_str })) {
|
||
input type="hidden" name="manually_freshened_at" x-model="date";
|
||
span x-text="date.length ? date.split('T')[0] : '(never)'" {}
|
||
input type="button" value="Mark fresh now" x-on:click="date = new Date().toISOString()";
|
||
}
|
||
label { "addresses" }
|
||
div x-data=(json!({ "addresses": addresses, "new_label": "", "new_address": "" })) {
|
||
template x-for="(address, index) in addresses" x-bind:key="index" {
|
||
.address-input {
|
||
input name="address_label" x-show="addresses.length" x-model="address.label" placeholder="label";
|
||
.grow-wrap x-bind:data-replicated-value="address.value" {
|
||
textarea name="address_value" x-model="address.value" placeholder="address" {}
|
||
}
|
||
}
|
||
}
|
||
.address-input {
|
||
input x-show="addresses.length" name="address_label" x-model="new_label" placeholder="label";
|
||
.grow-wrap x-bind:data-replicated-value="new_address" {
|
||
textarea name="address_value" x-model="new_address" placeholder="new address" {}
|
||
}
|
||
}
|
||
input type="button" value="Add" x-on:click="addresses.push({ label: new_label, value: new_address }); new_label = ''; new_address = ''";
|
||
}
|
||
}
|
||
div #text_body {
|
||
div { "Free text (supports markdown)" }
|
||
.grow-wrap data-replicated-value=(text_body) {
|
||
textarea name="text_body"
|
||
onInput="this.parentNode.dataset.replicatedValue = this.value"
|
||
{ (text_body) }
|
||
}
|
||
}
|
||
}
|
||
}))
|
||
}
|
||
}
|
||
|
||
mod post {
|
||
use super::*;
|
||
|
||
pub async fn contact(
|
||
auth_session: AuthSession,
|
||
State(state): State<AppState>,
|
||
) -> Result<impl IntoResponse, AppError> {
|
||
let user = auth_session.user.unwrap();
|
||
let pool = &state.db(&user).pool;
|
||
|
||
let contact_id: (u32,) =
|
||
sqlx::query_as("insert into contacts (birthday) values (null) returning id")
|
||
.fetch_one(pool)
|
||
.await?;
|
||
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert(
|
||
"HX-Redirect",
|
||
format!("/contact/{}/edit", contact_id.0).parse()?,
|
||
);
|
||
Ok((headers, "ok"))
|
||
}
|
||
}
|
||
|
||
mod put {
|
||
use super::*;
|
||
|
||
#[derive(Deserialize)]
|
||
pub struct PutContact {
|
||
name: Option<Vec<String>>,
|
||
birthday: String,
|
||
manually_freshened_at: String,
|
||
address_label: Option<Vec<String>>,
|
||
address_value: Option<Vec<String>>,
|
||
text_body: String,
|
||
}
|
||
|
||
pub async fn contact(
|
||
auth_session: AuthSession,
|
||
State(state): State<AppState>,
|
||
Path(contact_id): Path<u32>,
|
||
Form(payload): Form<PutContact>,
|
||
) -> Result<impl IntoResponse, AppError> {
|
||
let user = auth_session.user.unwrap();
|
||
let pool = &state.db(&user).pool;
|
||
|
||
let birthday = if payload.birthday.is_empty() {
|
||
None
|
||
} else {
|
||
Some(payload.birthday)
|
||
};
|
||
|
||
let manually_freshened_at = if payload.manually_freshened_at.is_empty() {
|
||
None
|
||
} else {
|
||
Some(
|
||
DateTime::parse_from_str(&payload.manually_freshened_at, "%+")
|
||
.map_err(|_| anyhow::Error::msg("Could not parse freshened-at string"))?
|
||
.to_utc()
|
||
.to_rfc3339(),
|
||
)
|
||
};
|
||
|
||
let text_body = if payload.text_body.is_empty() {
|
||
None
|
||
} else {
|
||
Some(payload.text_body)
|
||
};
|
||
|
||
sqlx::query!(
|
||
"update contacts set (birthday, manually_freshened_at, text_body) = ($1, $2, $3) where id = $4",
|
||
birthday,
|
||
manually_freshened_at,
|
||
text_body,
|
||
contact_id
|
||
)
|
||
.execute(pool)
|
||
.await?;
|
||
|
||
{
|
||
// update addresses
|
||
sqlx::query!("delete from addresses where contact_id = $1", contact_id)
|
||
.execute(pool)
|
||
.await?;
|
||
|
||
if let Some(values) = payload.address_value {
|
||
let labels = if values.len() == 1 {
|
||
Some(vec![String::new()])
|
||
} else {
|
||
payload.address_label
|
||
};
|
||
if let Some(labels) = labels {
|
||
let new_addresses = labels
|
||
.into_iter()
|
||
.zip(values)
|
||
.filter(|(_, val)| val.len() > 0);
|
||
for (label, value) in new_addresses {
|
||
sqlx::query!(
|
||
"insert into addresses (contact_id, label, value) values ($1, $2, $3)",
|
||
contact_id,
|
||
label,
|
||
value
|
||
)
|
||
.execute(pool)
|
||
.await?;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
let old_names: Vec<(String,)> = sqlx::query_as(
|
||
"delete from contact_mentions;
|
||
delete from names where contact_id = $1 returning name;",
|
||
)
|
||
.bind(contact_id)
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
let mut recalc_counts: QueryBuilder<Sqlite> = QueryBuilder::new(
|
||
"select name, contact_id from (
|
||
select name, contact_id, count(name) as ct from names where name in (",
|
||
);
|
||
let mut name_list = recalc_counts.separated(", ");
|
||
for (name,) in &old_names {
|
||
name_list.push_bind(name);
|
||
}
|
||
|
||
if let Some(names) = payload.name {
|
||
let names: Vec<String> = names.into_iter().filter(|n| n.len() > 0).collect();
|
||
if !names.is_empty() {
|
||
for name in &names {
|
||
name_list.push_bind(name.clone());
|
||
}
|
||
|
||
let mut name_insert: QueryBuilder<Sqlite> =
|
||
QueryBuilder::new("insert into names (contact_id, sort, name) ");
|
||
name_insert.push_values(names.iter().enumerate(), |mut builder, (sort, name)| {
|
||
builder
|
||
.push_bind(contact_id)
|
||
.push_bind(DbId::try_from(sort).unwrap())
|
||
.push_bind(name);
|
||
});
|
||
name_insert.build().persistent(false).execute(pool).await?;
|
||
}
|
||
}
|
||
|
||
name_list.push_unseparated(") group by name) where ct = 1");
|
||
let recalc_names: Vec<(String, DbId)> = recalc_counts
|
||
.build_query_as()
|
||
.persistent(false)
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
{
|
||
let trie_mutex = state.contact_search(&user);
|
||
let mut trie = trie_mutex.write().unwrap();
|
||
for name in &old_names {
|
||
trie.remove(&name.0);
|
||
}
|
||
|
||
for name in recalc_names {
|
||
trie.insert(name.0, name.1);
|
||
}
|
||
}
|
||
|
||
let journal_entries: Vec<JournalEntry> = sqlx::query_as("select * from journal_entries")
|
||
.fetch_all(pool)
|
||
.await?;
|
||
|
||
for entry in journal_entries {
|
||
entry
|
||
.insert_mentions(state.contact_search(&user), pool)
|
||
.await?;
|
||
}
|
||
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("HX-Redirect", format!("/contact/{}", contact_id).parse()?);
|
||
Ok((headers, "ok"))
|
||
}
|
||
}
|
||
mod delete {
|
||
use super::*;
|
||
pub async fn contact(
|
||
auth_session: AuthSession,
|
||
State(state): State<AppState>,
|
||
Path(contact_id): Path<u32>,
|
||
) -> Result<impl IntoResponse, AppError> {
|
||
let user = auth_session.user.unwrap();
|
||
let pool = &state.db(&user).pool;
|
||
|
||
sqlx::query(
|
||
"delete from contact_mentions where contact_id = $1;
|
||
delete from names where contact_id = $1;
|
||
delete from contacts where id = $1;",
|
||
)
|
||
.bind(contact_id)
|
||
.execute(pool)
|
||
.await?;
|
||
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("HX-Redirect", "/".parse()?);
|
||
Ok((headers, "ok"))
|
||
}
|
||
}
|