Coverage / crates/hub/src/web/inbox.rs 93.8%

    pub fn with(&self, key: &str, value: &str) -> String {

        let mut q = self.clone();

        match key {

            "view" => q.view = value.into(),

            "reason" => q.reason = value.into(),

            "kind" => q.kind = value.into(),

            "repo" => q.repo = value.into(),

            _ => {}

        let parts: Vec<String> = [("view", &q.view), ("reason", &q.reason), ("kind", &q.kind), ("repo", &q.repo)]

            .iter()

            .filter(|(_, v)| !v.is_empty())

            .map(|(k, v)| format!("{k}={}", super::settings::urlencode(v)))

            .collect();

        if parts.is_empty() {

            "/notifications".into()

            format!("/notifications?{}", parts.join("&"))

    }

    pub fn here(&self) -> String {

        self.with("", "")

    }

fn family(kind: &str) -> &str {

    kind.split('.').next().unwrap_or(kind)

}

async fn inbox_page(

    app: &Shared,

    shell: Shell,

    me: &accounts::Account,

    q: InboxQuery,

    notice: Option<String>,

) -> Result<Page<InboxPage>, Error> {

    let e = |e| Error::from_db(shell.clone(), e);

    let repo_id = match q.repo.split_once('/') {

        Some((o, n)) => db::repos::get(&app.db, o, n).await.map_err(e)?.map(|r| r.id).or(Some(-1)),

        None => None,

    let filter = ndb::Filter {

        done: q.view == "done",

        unread_only: q.view == "unread",

        reason: (!q.reason.is_empty()).then(|| q.reason.clone()),

        kind: (!q.kind.is_empty()).then(|| q.kind.clone()),

        repo_id,

    let threads = ndb::threads(&app.db, me.id, &filter, 200).await.map_err(e)?;

    let all = ndb::threads(&app.db, me.id, &ndb::Filter { done: filter.done, ..Default::default() }, 1000).await.map_err(e)?;

    let mut kinds: std::collections::BTreeMap<String, usize> = Default::default();

    let mut repos: std::collections::BTreeMap<String, usize> = Default::default();

    for t in &all {

        *kinds.entry(family(&t.kind).to_string()).or_default() += 1;

        if let Some(r) = &t.repo {

            *repos.entry(r.clone()).or_default() += 1;

        }

    let unread = ndb::unread(&app.db, me.id).await.map_err(e)?;

    let fresh = accounts::account_by_id(&app.db, me.id).await.ok().flatten();

        shell,

        threads,

        unread,

        email_on: fresh.map(|a| a.email_notifications).unwrap_or(false),

        notice,

        q,

        kinds: kinds.into_iter().collect(),

        repos: repos.into_iter().collect(),

}

pub async fn inbox(State(app): State<Shared>, viewer: Viewer, Query(q): Query<InboxQuery>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

    let me = require(&viewer, &shell)?;

    inbox_page(&app, shell, &me.account, q, None).await

}

pub async fn mark_read(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ReadForm>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    ndb::mark_read(&app.db, me.account.id, f.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    inbox_page(&app, shell, &me.account, InboxQuery::default(), None).await

}

pub async fn thread(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ThreadForm>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let (read, done) = match f.action.as_str() {

        "read" => (Some(true), None),

        "unread" => (Some(false), None),

        "done" => (None, Some(true)),

    ndb::set_thread(&app.db, me.account.id, &f.thread, read, done).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let back = if f.back.starts_with("/notifications") { f.back } else { "/notifications".into() };

    Ok(Redirect::to(&back).into_response())

}

pub async fn open(State(app): State<Shared>, viewer: Viewer, axum::extract::Path(id): axum::extract::Path<i64>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

    let me = require(&viewer, &shell)?;

    let n = ndb::get(&app.db, me.account.id, id)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    ndb::set_thread(&app.db, me.account.id, &n.thread, Some(true), None).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let to = if n.url.starts_with('/') && !n.url.starts_with("//") { n.url } else { "/notifications".into() };

    Ok(Redirect::to(&to).into_response())

}

pub async fn prefs(State(app): State<Shared>, viewer: Viewer, Form(f): Form<PrefsForm>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let key = if me.account.unsubscribe_key.is_empty() { crate::auth::random_hex(16) } else { me.account.unsubscribe_key.clone() };

    sqlx::query("UPDATE accounts SET email_notifications = $1, unsubscribe_key = $2 WHERE id = $3")

        .bind(f.email.is_some())

        .bind(&key)

        .bind(me.account.id)

        .execute(&app.db)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?;

    inbox_page(

        &app,

        shell,

        &me.account,

        InboxQuery::default(),

        Some(if f.email.is_some() { "Email notifications are on.".into() } else { "Email notifications are off.".into() }),

    .await

}

pub async fn unsubscribe(State(app): State<Shared>, Query(q): Query<UnsubQuery>) -> Response {

    if let Some(key) = q.unsubscribe.filter(|k| k.len() >= 16) {

        sqlx::query("UPDATE accounts SET email_notifications = FALSE WHERE unsubscribe_key = $1").bind(key).execute(&app.db).await.ok();

        return (axum::http::StatusCode::OK, "Email notifications are off for that account.").into_response();

}

pub async fn search(State(app): State<Shared>, viewer: Viewer, Query(q): Query<SearchQuery>) -> Result<Page<SearchPage>, Error> {

    let shell = Shell::new(&app, "/search", &viewer);

    let query = q.q.unwrap_or_default().trim().to_string();

    if query.is_empty() {

    }

    let e = |e| Error::from_db(shell.clone(), e);

    let all = db::repos::list(&app.db).await.map_err(e)?;

    let mut visible = Vec::new();

    for r in all {

        let role = crate::auth::roles::role_for(&app.db, viewer.account(), &r).await.map_err(e)?;

        if crate::auth::roles::allows(role, crate::auth::Access::Read) {

            visible.push(r);

        }

    let lower = query.to_lowercase();

    let repos: Vec<db::repos::RepoRow> = visible

        .iter()

        .filter(|r| {

            r.name.to_lowercase().contains(&lower)

                || r.description.to_lowercase().contains(&lower)

                || r.owner.to_lowercase().contains(&lower)

        })

        .cloned()

        .collect();

    let accounts: Vec<String> = accounts::accounts(&app.db)

        .await

        .map_err(e)?

        .into_iter()

        .filter(|a| a.username.to_lowercase().contains(&lower) || a.display_name.to_lowercase().contains(&lower))

        .map(|a| a.username)

        .collect();

    let mut hits = Vec::new();

    for h in ndb::search(&app.db, &query, None, 100).await.map_err(e)? {

        let Some(r) = visible.iter().find(|r| r.id == h.repo_id) else { continue };

        let url = format!("/{}/{}/{}", r.slug(), if h.kind == "proposal" { "proposal" } else { "issue" }, h.number);

        hits.push(HitView {

            kind: h.kind,

            slug: r.slug(),

            number: h.number,

            title: h.title,

            snippet: crate::render::escape(&h.snippet).replace("&lt;mark&gt;", "<mark>").replace("&lt;/mark&gt;", "</mark>"),

            url,

        });

    let _ = Visibility::Public;

    Ok(Page(SearchPage { shell, q: query, repos, accounts, hits }))

}