Coverage / crates/hub/src/web/home.rs 94.1%

    fn star_count(&self, id: &i64) -> i64 {

        self.stars.get(id).copied().unwrap_or(0)

    }

fn sky_json(mine: &[db::repos::RepoRow], events: &[db::activity::SkyEvent], now: i64, live: &str) -> String {

    let slugs: Vec<String> = mine.iter().map(|r| format!("{}/{}", r.owner, r.name)).collect();

    let evs: Vec<serde_json::Value> = events

        .iter()

        .filter_map(|e| {

            let repo = mine.iter().position(|r| r.id == e.repo_id)?;

            Some(serde_json::json!([repo, e.kind, e.at_ms, e.n]))

        })

        .collect();

    serde_json::json!({ "now": now, "repos": slugs, "events": evs, "live": live }).to_string().replace('<', "\\u003c")

}

pub(crate) async fn repo_sky(app: &Shared, row: &db::repos::RepoRow) -> String {

    let now = db::now_ms();

    match db::activity::sky(&app.db, &[row.id], now - SKY_DAYS * 86_400_000, SKY_EVENTS).await {

        Ok(events) => sky_json(std::slice::from_ref(row), &events, now, ""),

}

async fn sky_repos(app: &Shared, shell: &Shell, viewer: &Viewer, scene: &str) -> Result<Vec<db::repos::RepoRow>, Error> {

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

    let seen = visible(app, shell, viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

    match (scene, viewer.account()) {

        ("mine", Some(account)) => {

            let member: Vec<i64> = db::accounts::visible_repo_ids(&app.db, account.id).await.map_err(db_err)?;

            Ok(seen.into_iter().filter(|r| member.contains(&r.id)).collect())

        ("hub", _) => {

            let mut public: Vec<db::repos::RepoRow> = seen.into_iter().filter(|r| r.visibility == "public").collect();

            public.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

            public.truncate(SKY_REPOS);

            Ok(public)

        _ => Ok(Vec::new()),

}

pub async fn arrivals(State(app): State<Shared>, viewer: Viewer, Query(q): Query<ArrivalsQuery>) -> Result<Response, Error> {

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

    let repos = sky_repos(&app, &shell, &viewer, &q.scene).await?;

    let now = db::now_ms();

    let since = q.since.clamp(now - 86_400_000, now);

    let ids: Vec<i64> = repos.iter().map(|r| r.id).collect();

    let events = if ids.is_empty() {

        Vec::new()

        db::activity::sky(&app.db, &ids, since + 1, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?

    let evs: Vec<serde_json::Value> = events

        .iter()

        .filter_map(|e| {

            let r = repos.iter().find(|r| r.id == e.repo_id)?;

            Some(serde_json::json!([format!("{}/{}", r.owner, r.name), e.kind, e.at_ms, e.n]))

        })

        .collect();

    let body = serde_json::json!({ "now": now, "events": evs });

    Ok(([(axum::http::header::CACHE_CONTROL, "private, no-store")], axum::Json(body)).into_response())

}

pub async fn index(State(app): State<Shared>, viewer: Viewer) -> Result<Response, Error> {

    let Some(account) = viewer.account().cloned() else {

        return Ok(explore(State(app), viewer, Query(ExploreQuery::default())).await?.into_response());

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

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

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

    let member: Vec<i64> = db::accounts::visible_repo_ids(&app.db, account.id).await.map_err(db_err)?;

    let seen = visible(&app, &shell, &viewer, all).await?;

    let seen_ids: Vec<i64> = seen.iter().map(|r| r.id).collect();

    let mut mine: Vec<db::repos::RepoRow> = seen.into_iter().filter(|r| member.contains(&r.id)).collect();

    mine.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

    let reviews = db::activity::awaiting_review(&app.db, account.id, &member).await.map_err(db_err)?;

    let authored = db::activity::authored(&app.db, account.id, &seen_ids).await.map_err(db_err)?;

    let assigned = db::activity::assigned(&app.db, account.id, &seen_ids).await.map_err(db_err)?;

    let feed = db::activity::feed(&app.db, &seen_ids, FEED_LIMIT).await.map_err(db_err)?;

    let mine_ids: Vec<i64> = mine.iter().map(|r| r.id).collect();

    let now = db::now_ms();

    let sky = db::activity::sky(&app.db, &mine_ids, now - SKY_DAYS * 86_400_000, SKY_EVENTS).await.map_err(db_err)?;

    let backdrop = sky_json(&mine, &sky, now, "mine");

    let live = std::iter::once(shell.live_user.clone())

        .chain(mine.iter().take(15).map(|r| crate::events::topic::repo(r.id)))

        .filter(|t| !t.is_empty())

        .collect::<Vec<_>>()

        .join(" ");

    Ok(Page(Dashboard { shell, mine, reviews, authored, assigned, feed, backdrop, live }).into_response())

}

pub async fn explore(State(app): State<Shared>, viewer: Viewer, Query(q): Query<ExploreQuery>) -> Result<Page<HomePage>, Error> {

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

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

    let mut repos = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

    let stars = db::repos::star_counts(&app.db).await.map_err(db_err)?;

    let needle = q.q.trim().to_lowercase();

    if !needle.is_empty() {

        repos.retain(|r| {

            r.slug().to_lowercase().contains(&needle)

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

                || r.topic_list().iter().any(|t| t.contains(&needle))

        });

    }

    let topic = q.topic.trim().to_lowercase();

    if !topic.is_empty() {

        repos.retain(|r| r.topic_list().contains(&topic.as_str()));

    }

    let sort = match q.sort.as_str() {

        "stars" | "name" => q.sort.clone(),

        _ => "activity".to_string(),

    match sort.as_str() {

        "stars" => repos.sort_by_key(|r| (std::cmp::Reverse(stars.get(&r.id).copied().unwrap_or(0)), std::cmp::Reverse(r.updated_ms))),

        "name" => repos.sort_by_key(|r| (r.name.to_lowercase(), r.owner.to_lowercase())),

        _ => repos.sort_by_key(|r| std::cmp::Reverse(r.updated_ms)),

    let public: Vec<db::repos::RepoRow> = repos.iter().filter(|r| r.visibility == "public").take(SKY_REPOS).cloned().collect();

    let ids: Vec<i64> = public.iter().map(|r| r.id).collect();

    let now = db::now_ms();

    let sky = db::activity::sky(&app.db, &ids, now - SKY_DAYS * 86_400_000, SKY_EVENTS).await.map_err(db_err)?;

    let backdrop = sky_json(&public, &sky, now, "hub");

    Ok(Page(HomePage { description: app.config.site.description.clone(), shell, repos, owner: None, q: q.q, sort, topic, stars, backdrop }))

}

    fn website_href(&self) -> Option<&str> {

        let w = self.account.website.trim();

        (w.starts_with("https://") || w.starts_with("http://")).then_some(w)

    }

async fn pulse_json(app: &Shared, account: &db::accounts::Account, seen: &[db::repos::RepoRow]) -> sqlx::Result<(String, i64)> {

    let today = db::now_ms() / DAY_MS;

    let ids: Vec<i64> = seen.iter().map(|r| r.id).collect();

    let rows = db::activity::pulse(&app.db, account.id, &ids, (today - 364) * DAY_MS).await?;

    let used = rows.first().map(|r| today - r.1 / DAY_MS + 1).unwrap_or(0);

    let (months, span) = [(3, 91), (6, 182), (9, 273), (12, 365)].into_iter().find(|(_, d)| used <= *d).unwrap_or((12, 365));

    let first = today - span + 1;

    let (pulse, total) = pulse_of(&rows, seen, first, span as usize);

    let mut value = pulse;

    let mut peaks = Vec::new();

    for (repo_id, tag, at) in db::activity::releases_by(&app.db, account.id, &ids, first * DAY_MS).await? {

        let name = seen.iter().find(|r| r.id == repo_id).map(|r| r.name.as_str()).unwrap_or("");

        peaks.push(serde_json::json!([at / DAY_MS - first, format!("{name} {tag}")]));

    value["peaks"] = serde_json::Value::Array(peaks);

    value["months"] = months.into();

    Ok((value.to_string().replace('<', "\\u003c"), total))

}

fn pulse_of(rows: &[(i64, i64, i64, String)], seen: &[db::repos::RepoRow], first: i64, span: usize) -> (serde_json::Value, i64) {

    let mut per_repo: std::collections::BTreeMap<i64, i64> = std::collections::BTreeMap::new();

    for (repo, _, n, _) in rows {

        *per_repo.entry(*repo).or_default() += n;

    }

    let mut order: Vec<(i64, i64)> = per_repo.into_iter().collect();

    order.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));

    let names: Vec<String> = order

        .iter()

        .map(|(id, _)| seen.iter().find(|r| r.id == *id).map(|r| format!("{}/{}", r.owner, r.name)).unwrap_or_default())

        .collect();

    let slot = |id: i64| order.iter().position(|(r, _)| *r == id).unwrap_or(0);

    let mut days: Vec<(i64, i64, std::collections::BTreeMap<usize, i64>)> = vec![(0, 0, Default::default()); span];

    let mut total = 0;

    for (repo, at, n, via) in rows {

        let d = at / DAY_MS - first;

        if d < 0 || d as usize >= span {

        }

        let day = &mut days[d as usize];

        day.0 += n;

        if !via.is_empty() {

            day.1 += n;

        }

        *day.2.entry(slot(*repo)).or_default() += n;

        total += n;

    let days: Vec<serde_json::Value> = days

        .into_iter()

        .map(|(t, v, by)| serde_json::json!([t, v, by.into_iter().map(|(r, n)| serde_json::json!([r, n])).collect::<Vec<_>>()]))

        .collect();

    (serde_json::json!({ "start": first * DAY_MS, "repos": names, "days": days }), total)

}

pub async fn owner(State(app): State<Shared>, viewer: Viewer, Path(owner): Path<String>) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}"), &viewer);

    if !crate::repos::names::valid_owner(&owner) {

    }

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

    let mut repos = visible(&app, &shell, &viewer, db::repos::list_by_owner(&app.db, &owner).await.map_err(db_err)?).await?;

    repos.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

    if let Some(account) = db::accounts::account_by_name(&app.db, &owner).await.map_err(db_err)? {

        let all = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

        let ids: Vec<i64> = all.iter().map(|r| r.id).collect();

        let feed = db::activity::feed_by(&app.db, &ids, Some(&account.username), OWNER_FEED).await.map_err(db_err)?;

        let keys = db::accounts::identities_of(&app.db, account.id).await.map_err(db_err)?;

        let orgs = db::accounts::orgs_of(&app.db, account.id).await.map_err(db_err)?;

        let is_me = viewer.account().is_some_and(|a| a.id == account.id);

        let (pulse, pulse_total) = pulse_json(&app, &account, &all).await.map_err(db_err)?;

        return Ok(Page(ProfilePage { shell, account, keys, orgs, repos, feed, is_me, pulse, pulse_total }).into_response());

    }

    if let Some(org) = db::accounts::org_by_name(&app.db, &owner).await.map_err(db_err)? {

        let members = db::accounts::org_members(&app.db, org.id).await.map_err(db_err)?;

        let mut teams = Vec::new();

        for t in db::accounts::teams(&app.db, org.id).await.map_err(db_err)? {

            let n = db::accounts::team_members(&app.db, t.id).await.map_err(db_err)?.len();

            teams.push((t, n));

        let ids: Vec<i64> = repos.iter().map(|r| r.id).collect();

        let feed = db::activity::feed(&app.db, &ids, OWNER_FEED).await.map_err(db_err)?;

        let can_admin =

            viewer.is_admin() || viewer.account().is_some_and(|a| members.iter().any(|(m, role)| m.id == a.id && role == "owner"));

        return Ok(Page(OrgPage { shell, org, members, teams, repos, feed, can_admin }).into_response());

    }

    if repos.is_empty() {

        return Err(Error::not_found(shell));

    }

    let stars = db::repos::star_counts(&app.db).await.unwrap_or_default();

    Ok(Page(HomePage {

        description: String::new(),

        shell,

        repos,

        owner: Some(owner),

        q: String::new(),

        sort: "activity".into(),

        topic: String::new(),

        stars,

        backdrop: String::new(),

    })

    .into_response())

}

pub(crate) async fn visible(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

    rows: Vec<db::repos::RepoRow>,

) -> Result<Vec<db::repos::RepoRow>, Error> {

    let mine: Vec<i64> = match viewer.account() {

        Some(a) if a.is_admin => rows.iter().map(|r| r.id).collect(),

        Some(a) => db::accounts::visible_repo_ids(&app.db, a.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,

        None => vec![],