simple-web-app

feed.rs (4993B)

---

 use askama::Template;
 use axum::{
     extract::{Query, State},
     response::Html,
 };
 use axum_extra::extract::cookie::CookieJar;
 use serde::Deserialize;
 
 use crate::database::{Category, StoryWithMeta};
 use crate::database::{self, TARGET_TYPE_STORY};
 use crate::error::AppError;
 use crate::state::AppState;
 use crate::templates::{ApplicationTemplate, FeedTemplate};
 
 const PAGE_LIMIT: usize = 30;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FeedSort {
     Hot,
     New,
     Top,
 }
 
 impl Default for FeedSort {
     fn default() -> Self {
         FeedSort::Hot
     }
 }
 
 #[derive(Debug, Deserialize)]
 pub struct FeedQuery {
     #[serde(default)]
     pub page: usize,
     pub tag: Option<i64>,
 }
 
 async fn fetch_feed(
     state: &AppState,
     jar: &CookieJar,
     query: &FeedQuery,
     sort: FeedSort,
 ) -> Result<(Vec<StoryWithMeta>, Vec<Category>, bool), AppError> {
     let offset = query.page * PAGE_LIMIT;
     let user_id = state.get_user_id(&jar).await;
     let tag_id = query.tag;
     let page = query.page;
 
     let db = state.db();
     let categories = db.get_categories(20).await?;
 
     let all_stories = match tag_id {
         Some(tid) => db.get_stories_by_tag(tid, PAGE_LIMIT + 1, offset).await?,
         None => match sort {
             FeedSort::Hot => db.get_stories_hot(PAGE_LIMIT + 1, offset).await?,
             FeedSort::New => db.get_stories_new(PAGE_LIMIT + 1, offset).await?,
             FeedSort::Top => db.get_stories_top(PAGE_LIMIT + 1, offset).await?,
         },
     };
 
     let stories: Vec<_> = all_stories.into_iter().take(PAGE_LIMIT).collect();
     let story_ids: Vec<i64> = stories.iter().map(|s| s.id).collect();
 
     let voted_ids = if let Some(uid) = user_id {
         db.get_user_votes(uid, TARGET_TYPE_STORY, &story_ids)
             .await
             .unwrap_or_default()
     } else {
         vec![]
     };
 
     let meta = db.enrich_stories(&story_ids).await.unwrap_or_default();
 
     let reached_end = stories.len() <= PAGE_LIMIT;
 
     // O(1) lookups instead of O(n) scans
     let meta_map: std::collections::HashMap<i64, &database::StoryMeta> =
         meta.iter().map(|m| (m.story_id, m)).collect();
     let voted_set: std::collections::HashSet<i64> =
         voted_ids.into_iter().collect();
 
     let mut enriched_stories = Vec::with_capacity(stories.len());
     let base_rank = page * PAGE_LIMIT;
 
     for (idx, story) in stories.into_iter().enumerate() {
         let story_meta = meta_map.get(&story.id);
         let tags: Vec<Category> = story_meta
             .map(|m| m.tags.iter().map(|name| Category { id: 0, name: Some(name.clone()) }).collect())
             .unwrap_or_default();
         let author_username = story_meta.and_then(|m| m.author_username.clone());
 
         let time_ago = database::time_ago(story.published);
         let user_voted = voted_set.contains(&story.id);
         let rank = base_rank + idx + 1;
 
         enriched_stories.push(StoryWithMeta::from_story(
             story,
             tags,
             author_username,
             time_ago,
             user_voted,
             rank,
         ));
     }
 
     Ok((enriched_stories, categories, reached_end))
 }
 
 pub async fn show_feed(
     State(state): State<AppState>,
     jar: CookieJar,
     Query(query): Query<FeedQuery>,
 ) -> Result<Html<String>, AppError> {
     let (stories, tags, reached_end) = fetch_feed(&state, &jar, &query, FeedSort::Hot).await?;
     let is_logged_in = state.get_user_id(&jar).await.is_some();
 
     let feed = FeedTemplate {
         stories,
         tags,
         page: query.page,
         tag_id: query.tag,
         reached_end,
         sort: "hot".to_string(),
         is_logged_in,
     };
 
     let app = ApplicationTemplate {
         content: feed.render()?,
     };
     Ok(Html(app.render()?))
 }
 
 pub async fn show_new(
     State(state): State<AppState>,
     jar: CookieJar,
     Query(query): Query<FeedQuery>,
 ) -> Result<Html<String>, AppError> {
     let (stories, tags, reached_end) = fetch_feed(&state, &jar, &query, FeedSort::New).await?;
     let is_logged_in = state.get_user_id(&jar).await.is_some();
 
     let feed = FeedTemplate {
         stories,
         tags,
         page: query.page,
         tag_id: query.tag,
         reached_end,
         sort: "new".to_string(),
         is_logged_in,
     };
 
     let app = ApplicationTemplate {
         content: feed.render()?,
     };
     Ok(Html(app.render()?))
 }
 
 pub async fn show_top(
     State(state): State<AppState>,
     jar: CookieJar,
     Query(query): Query<FeedQuery>,
 ) -> Result<Html<String>, AppError> {
     let (stories, tags, reached_end) = fetch_feed(&state, &jar, &query, FeedSort::Top).await?;
     let is_logged_in = state.get_user_id(&jar).await.is_some();
 
     let feed = FeedTemplate {
         stories,
         tags,
         page: query.page,
         tag_id: query.tag,
         reached_end,
         sort: "top".to_string(),
         is_logged_in,
     };
 
     let app = ApplicationTemplate {
         content: feed.render()?,
     };
     Ok(Html(app.render()?))
 }