mascarpone/src/web/contact/mod.rs

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 jiff::{Timestamp, Unit, tz::TimeZone};
use maud::{Markup, html};
use serde::Deserialize;
use serde_json::json;
use slug::slugify;
use sqlx::QueryBuilder;

use super::Layout;
use super::home::journal_section;
use crate::db::DbId;
use crate::models::user::AuthSession;
use crate::models::{HydratedContact, JournalEntry};
use crate::switchboard::{MentionHost, MentionHostType, Switchboard, insert_mentions};
use crate::{AppError, AppState};

pub mod fields;

#[derive(serde::Serialize, Debug)]
pub struct PhoneNumber {
    pub contact_id: DbId,
    pub label: Option<String>,
    pub phone_number: 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(span: &jiff::Span) -> String {
    let todate = Timestamp::now().to_zoned(TimeZone::UTC).date();
    let span = span
        .round(
            jiff::SpanRound::new()
                .largest(Unit::Year)
                .smallest(Unit::Day)
                .relative(todate),
        )
        .unwrap();

    if span.is_zero() {
        "today".to_string()
    } else {
        format!("in {:#}", span)
    }
}

mod get {
    use super::*;

    fn scroll_to(id: DbId) -> String {
        format!(
            "\
            const top = document\
                .getElementById('nav-link-{}')\
                ?.getBoundingClientRect()\
                ?.top;\
                console.log({{ top }});\
                top && document\
                    .getElementById('contacts-sidebar')\
                    .scrollTo({{top: top+window.innerHeight/2,left:0,behavior:'instant'}});",
            id
        )
    }

    pub async fn contact(
        auth_session: AuthSession,
        State(state): State<AppState>,
        Path(contact_id): Path<DbId>,
        layout: Layout,
    ) -> Result<Markup, AppError> {
        let user = auth_session.user.unwrap();
        let pool = &state.db(&user).pool;

        let contact = HydratedContact::load(contact_id, pool).await?;

        let entries: Vec<JournalEntry> = sqlx::query_as(
            "select distinct j.id, j.value, j.date from journal_entries j
            join mentions m on j.id = m.entity_id
            where m.entity_type = $1 and (m.url = '/contact/'||$2 or m.url in (
                select '/group/'||slug from groups
                where contact_id = $2
            ))
            order by j.date desc
            ",
        )
        .bind(MentionHostType::JournalEntry as DbId)
        .bind(contact_id)
        .fetch_all(pool)
        .await?;

        let freshened = std::cmp::max(
            contact
                .manually_freshened_at
                .map(|when| when.to_zoned(jiff::tz::TimeZone::UTC).date()),
            entries.get(0).map(|entry| entry.date),
        );

        let phone_numbers: Vec<PhoneNumber> = sqlx::query_as!(
            PhoneNumber,
            "select * from phone_numbers where contact_id = $1",
            contact_id
        )
        .fetch_all(pool)
        .await?;

        let lives_with = if contact.lives_with.len() > 1 {
            let mention_host = MentionHost {
                entity_id: contact_id,
                entity_type: MentionHostType::ContactLivesWith as DbId,
                input: &contact.lives_with,
            };
            Some(mention_host.format_pool(pool).await?)
        } else {
            None
        };

        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(
            contact.names.get(0).unwrap_or(&String::from("(unknown)")),
            Some(vec![asset!("contact.css"), asset!("journal.css")]),
            html! {
                a href=(format!("/contact/{}/edit", contact_id)) { "Edit" }

                div #fields x-init=(scroll_to(contact_id)) {
                    label { @if contact.names.len() > 1 { "names" } @else { "name" }}
                    div {
                        @for name in &contact.names {
                            div { (name) }
                        }
                    }
                    @if contact.status() != "normal" {
                        label { "status" }
                        div { (contact.status()) }
                    }
                    @if contact.status() == "normal" && contact.periodicity.is_positive() {
                        label { "periodicity" }
                        div { (format!("{:#}", contact.periodicity)) }
                    }
                    @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(freshened) = freshened {
                            (freshened.to_string())
                        } @else {
                            "(never)"
                        }
                    }

                    @if phone_numbers.len() > 0 {
                        label { "phone" }
                        #phone_numbers {
                            @for phone_number in phone_numbers {
                                @let lbl = phone_number.label.unwrap_or(String::new());
                                .label data-is-empty=(lbl.len() == 0) { (lbl) }
                                .phone_nunber {
                                    a href=(format!("tel:{}", phone_number.phone_number)) { (phone_number.phone_number) }
                                }
                            }
                        }
                    }

                    @if let Some(lives_with) = lives_with {
                        label { "lives with" }
                        div { (lives_with) }
                    }

                    (fields::addresses::get(pool, contact_id).await?)
                    (fields::groups::get(pool, contact_id).await?)
                }


                @if let Some(text_body) = text_body {
                    @if text_body.len() > 0 {
                        #text_body { (MentionHost {
                            entity_id: contact_id,
                            entity_type: MentionHostType::ContactTextBody as DbId,
                            input: &text_body
                        }.format_pool(pool).await?) }
                    }
                }

                (journal_section(pool, &entries).await?)
            },
        ))
    }

    pub async fn contact_edit(
        auth_session: AuthSession,
        State(state): State<AppState>,
        Path(contact_id): Path<DbId>,
        layout: Layout,
    ) -> Result<Markup, AppError> {
        let pool = &state.db(&auth_session.user.unwrap()).pool;
        let contact = HydratedContact::load(contact_id, pool).await?;

        let phone_numbers: Vec<PhoneNumber> = sqlx::query_as!(
            PhoneNumber,
            "select * from phone_numbers where contact_id = $1",
            contact_id
        )
        .fetch_all(pool)
        .await?;

        let cid_url = format!("/contact/{}", contact.id);
        let mfresh_on_str = contact
            .manually_freshened_at
            .clone()
            .map_or("".to_string(), |m| {
                m.to_zoned(TimeZone::UTC).date().to_string()
            });
        let mfresh_at_str = contact
            .manually_freshened_at
            .clone()
            .map_or("".to_string(), |m| m.to_zoned(TimeZone::UTC).to_string());

        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(
            format!("Edit: {}", contact.names.get(0).unwrap_or(&String::from("(unknown)"))),
            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;
            }

            #fields x-data=(json!({ "status": contact.status() })) x-init=(scroll_to(contact_id)) {
                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 for="status" { "status" }
                div {
                    select #status name="status" x-model=("status") {
                        option value="normal" { "Normal" }
                        option value="permanent" { "Cannot go stale" }
                        option value="inactive" { "Inactive" }
                    }
                }
                label x-show="status === 'normal'" for="periodicity" { "minimum stale time" }
                div x-show="status === 'normal'"{
                    input name="periodicity" id="periodicity" value=(format!("{:#}", contact.periodicity));
                    span .hint { code { "[0-9]+ (yr|mo|wk|day|h|m|s)" } "(" a href="https://docs.rs/jiff/latest/jiff/struct.Span.html#parsing-and-printing" { "details" } ")" }
                }
                label for="birthday" { "birthday" }
                div {
                    input name="birthday" id="birthday" value=(contact.birthday.clone().map_or("".to_string(), |b| format!("{b}")));
                    span .hint { code { "(yyyy-)?mm-dd" } " or free text" }
                }
                label for="manually_freshened_on" { "freshened" }
                div x-data=(json!({ "date": mfresh_on_str, "stamp": mfresh_at_str })) x-init="today = () => (new Date().toISOString().split('T')[0])" {
                    input
                      type="hidden"
                      name="manually_freshened_at"
                      x-model="stamp";
                    input
                      type="date"
                      name="manually_freshened_on"
                      id="manually_freshened_on"
                      x-model="date"
                      x-bind:max="today()"
                      x-on:input="stamp = new Date(date).toISOString()";

                    input type="button" value="Mark fresh now" x-on:click="date = today(); stamp = new Date().toISOString()";
                    span .hint x-text="`max ${today()}`";
                }
                label { "phone" }
                #phone_numbers x-data=(json!({ "phones": phone_numbers, "new_label": "", "new_number": "" })) {
                    template x-for="(phone, index) in phones" x-bind:key="index" {
                        .phone_input {
                            input name="phone_label" x-model="phone.label" placeholder="home/work/mobile";
                            input name="phone_number" x-model="phone.phone_number" placeholder="number";
                        }
                    }
                    .phone_input {
                        input name="phone_label" x-model="new_label" placeholder="home/work/mobile";
                        input name="phone_number" x-model="new_number" placeholder="number";
                    }
                    input type="button" value="Add" x-on:click="phones.push({ label: new_label, phone_number: new_number }); new_label=''; new_number = ''";
                }
                label { "lives with" }
                div {
                    input name="lives_with" value=(contact.lives_with);
                }
                (fields::addresses::edit(pool, contact_id).await?)
                (fields::groups::edit(pool, contact_id).await?)
            }
            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: (DbId,) =
            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>>,
        status: String,
        periodicity: Option<String>,
        birthday: String,
        manually_freshened_at: String,
        lives_with: String,
        phone_label: Option<Vec<String>>,
        phone_number: Option<Vec<String>>,
        address_label: Option<Vec<String>>,
        address_value: Option<Vec<String>>,
        group: Option<Vec<String>>,
        text_body: String,
    }

    pub async fn contact(
        auth_session: AuthSession,
        State(state): State<AppState>,
        Path(contact_id): Path<DbId>,
        Form(payload): Form<PutContact>,
    ) -> Result<impl IntoResponse, AppError> {
        let user = auth_session.user.unwrap();
        let pool = &state.db(&user).pool;
        let sw_lock = state.switchboard(&user);

        let birthday = if payload.birthday.is_empty() {
            None
        } else {
            Some(payload.birthday)
        };

        let manually_freshened_at: Option<String> = if payload.manually_freshened_at.is_empty() {
            None
        } else {
            Some(
                payload
                    .manually_freshened_at
                    .parse::<Timestamp>()
                    .map_err(|_| anyhow::Error::msg("Could not parse freshened-at string"))?
                    .to_string(),
            )
        };

        let active: bool = payload.status != "inactive";
        let can_stale: bool = payload.status != "permanent";
        let periodicity: String = payload.periodicity.unwrap_or("P0D".to_string());

        let text_body = if payload.text_body.is_empty() {
            None
        } else {
            Some(payload.text_body)
        };

        let old_contact = sqlx::query!("select * from contacts where id = $1", contact_id)
            .fetch_one(pool)
            .await?;

        sqlx::query!(
            "update contacts set
                (
                  birthday, manually_freshened_at, lives_with, text_body,
                  active, can_stale, periodicity
                ) =
                (?, ?, ?, ?, ?, ?, ?)
                where id = ?",
            birthday,
            manually_freshened_at,
            payload.lives_with,
            text_body,
            active,
            can_stale,
            periodicity,
            contact_id
        )
        .execute(pool)
        .await?;

        // these blocks are not in functions because payload gets progressively
        // partially moved as we handle each field and i don't want to deal with it

        {
            // update phone numbers
            let new_numbers = payload.phone_number.clone().map_or(vec![], |numbers| {
                let labels: Vec<String> = payload.phone_label.clone().unwrap();

                // TODO sanitize down to linkable on input
                labels
                    .into_iter()
                    .zip(numbers)
                    .filter(|(_, val)| val.len() > 0)
                    .collect::<Vec<(String, String)>>()
            });

            let old_numbers: Vec<(String, String)> = sqlx::query_as(
                "select label, phone_number from phone_numbers where contact_id = $1",
            )
            .bind(contact_id)
            .fetch_all(pool)
            .await?;

            if new_numbers != old_numbers {
                sqlx::query!(
                    "delete from phone_numbers where contact_id = $1",
                    contact_id
                )
                .execute(pool)
                .await?;

                // trailing space in query intentional
                QueryBuilder::new("insert into phone_numbers (contact_id, label, phone_number) ")
                    .push_values(new_numbers, |mut b, (label, phone_number)| {
                        b.push_bind(contact_id)
                            .push_bind(label)
                            .push_bind(phone_number);
                    })
                    .build()
                    .execute(pool)
                    .await?;
            }
        }

        {
            // update addresses
            let new_addresses = payload.address_value.clone().map(|values| {
                let labels: Vec<String> = if values.len() == 1 {
                    vec![String::new()]
                } else {
                    payload.address_label.clone().unwrap_or(vec![])
                };

                labels
                    .into_iter()
                    .zip(values)
                    .filter(|(_, val)| val.len() > 0)
                    .collect::<Vec<(String, String)>>()
            });
            let new_addresses = new_addresses.unwrap_or(vec![]);

            let old_addresses: Vec<(String, String)> =
                sqlx::query_as("select label, value from addresses where contact_id = $1")
                    .bind(contact_id)
                    .fetch_all(pool)
                    .await?;

            if new_addresses != old_addresses {
                sqlx::query!("delete from addresses where contact_id = $1", contact_id)
                    .execute(pool)
                    .await?;

                // trailing space in query intentional
                QueryBuilder::new("insert into addresses (contact_id, label, value) ")
                    .push_values(new_addresses, |mut b, (label, value)| {
                        b.push_bind(contact_id).push_bind(label).push_bind(value);
                    })
                    .build()
                    .persistent(false)
                    .execute(pool)
                    .await?;
            }
        }

        {
            let new_names: Vec<String> = payload
                .name
                .unwrap_or(vec![])
                .into_iter()
                .filter(|n| n.len() > 0)
                .collect();
            let old_names: Vec<(String,)> =
                sqlx::query_as("select name from names where contact_id = $1")
                    .bind(contact_id)
                    .fetch_all(pool)
                    .await?;
            let old_names: Vec<String> = old_names.into_iter().map(|(s,)| s).collect();

            if old_names != new_names {
                sqlx::query!("delete from names where contact_id = $1", contact_id)
                    .execute(pool)
                    .await?;

                if !new_names.is_empty() {
                    QueryBuilder::new("insert into names (contact_id, sort, name) ")
                        .push_values(new_names.iter().enumerate(), |mut b, (sort, name)| {
                            b.push_bind(contact_id)
                                .push_bind(DbId::try_from(sort).unwrap())
                                .push_bind(name);
                        })
                        .build()
                        .persistent(false)
                        .execute(pool)
                        .await?;
                }
            }

            let new_groups: Vec<String> = payload
                .group
                .unwrap_or(vec![])
                .into_iter()
                .filter(|n| n.len() > 0)
                .collect();
            let old_groups: Vec<(String,)> =
                sqlx::query_as("select name from groups where contact_id = $1")
                    .bind(contact_id)
                    .fetch_all(pool)
                    .await?;
            let old_groups: Vec<String> = old_groups.into_iter().map(|(s,)| s).collect();

            if new_groups != old_groups {
                sqlx::query!("delete from groups where contact_id = $1", contact_id)
                    .execute(pool)
                    .await?;

                if new_groups.len() > 0 {
                    QueryBuilder::new("insert into groups (contact_id, name, slug) ")
                        .push_values(&new_groups, |mut b, name| {
                            b.push_bind(contact_id)
                                .push_bind(name)
                                .push_bind(slugify(name));
                        })
                        .build()
                        .persistent(false)
                        .execute(pool)
                        .await?;
                }
            }
        }

        let regen_all_mentions = {
            let trie = Switchboard::gen_trie(pool).await?;
            let mut swb = sw_lock.write().unwrap();
            swb.check_and_assign(trie)
        };
        let regen_lives_with = old_contact.lives_with != payload.lives_with;
        let regen_text_body = old_contact.text_body != text_body;
        if regen_all_mentions {
            sqlx::query("delete from mentions").execute(pool).await?;
        } else {
            if regen_lives_with {
                sqlx::query!(
                    "delete from mentions where entity_id = $1 and entity_type = $2",
                    contact_id,
                    MentionHostType::ContactLivesWith as DbId
                )
                .execute(pool)
                .await?;
            }

            if regen_text_body {
                sqlx::query!(
                    "delete from mentions where entity_id = $1 and entity_type = $2",
                    contact_id,
                    MentionHostType::ContactTextBody as DbId
                )
                .execute(pool)
                .await?;
            }
        }

        if regen_all_mentions || regen_lives_with {
            let mention_host = MentionHost {
                entity_id: contact_id,
                entity_type: MentionHostType::ContactLivesWith as DbId,
                input: &payload.lives_with,
            };

            let mentions = {
                let switchboard = sw_lock.read().unwrap();
                switchboard.extract_mentions(mention_host)
            };
            insert_mentions(&mentions, pool).await?;
        }

        if regen_all_mentions || regen_text_body {
            if text_body.is_some() {
                let mention_host = MentionHost {
                    entity_id: contact_id,
                    entity_type: MentionHostType::ContactTextBody as DbId,
                    input: &text_body.unwrap(),
                };

                let mentions = {
                    let switchboard = sw_lock.read().unwrap();
                    switchboard.extract_mentions(mention_host)
                };
                insert_mentions(&mentions, pool).await?;
            }
        }

        if regen_all_mentions {
            let journal_entries: Vec<JournalEntry> =
                sqlx::query_as("select * from journal_entries")
                    .fetch_all(pool)
                    .await?;

            for entry in journal_entries {
                let mentions = {
                    let switchboard = sw_lock.read().unwrap();
                    switchboard.extract_mentions(&entry)
                };
                insert_mentions(&mentions, 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<DbId>,
    ) -> Result<impl IntoResponse, AppError> {
        let user = auth_session.user.unwrap();
        let pool = &state.db(&user).pool;

        sqlx::query!("delete from contacts where id = $1", contact_id)
            .execute(pool)
            .await?;

        let mut headers = HeaderMap::new();
        headers.insert("HX-Redirect", "/".parse()?);
        Ok((headers, "ok"))
    }
}