diff --git a/server/src/api/post.rs b/server/src/api/post.rs index 5df42990..e1c9b778 100644 --- a/server/src/api/post.rs +++ b/server/src/api/post.rs @@ -238,21 +238,16 @@ impl Perform for Oper { let type_ = ListingType::from_str(&data.type_)?; let sort = SortType::from_str(&data.sort)?; - let posts = match PostView::list( - &conn, - type_, - &sort, - data.community_id, - None, - None, - None, - user_id, - show_nsfw, - false, - false, - data.page, - data.limit, - ) { + let posts = match PostQueryBuilder::create(&conn) + .listing_type(type_) + .sort(&sort) + .show_nsfw(show_nsfw) + .for_community_id_optional(data.community_id) + .my_user_id_optional(user_id) + .page_optional(data.page) + .limit_optional(data.limit) + .list() + { Ok(posts) => posts, Err(_e) => return Err(APIError::err(&self.op, "couldnt_get_posts"))?, }; diff --git a/server/src/api/site.rs b/server/src/api/site.rs index 618295fc..0e780b38 100644 --- a/server/src/api/site.rs +++ b/server/src/api/site.rs @@ -319,21 +319,14 @@ impl Perform for Oper { match type_ { SearchType::Posts => { - posts = PostView::list( - &conn, - ListingType::All, - &sort, - data.community_id, - None, - Some(data.q.to_owned()), - None, - None, - true, - false, - false, - data.page, - data.limit, - )?; + posts = PostQueryBuilder::create(&conn) + .sort(&sort) + .show_nsfw(true) + .for_community_id_optional(data.community_id) + .search_term(data.q.to_owned()) + .page_optional(data.page) + .limit_optional(data.limit) + .list()?; } SearchType::Comments => { comments = CommentView::list( @@ -363,21 +356,15 @@ impl Perform for Oper { users = UserView::list(&conn, &sort, Some(data.q.to_owned()), data.page, data.limit)?; } SearchType::All => { - posts = PostView::list( - &conn, - ListingType::All, - &sort, - data.community_id, - None, - Some(data.q.to_owned()), - None, - None, - true, - false, - false, - data.page, - data.limit, - )?; + posts = PostQueryBuilder::create(&conn) + .sort(&sort) + .show_nsfw(true) + .for_community_id_optional(data.community_id) + .search_term(data.q.to_owned()) + .page_optional(data.page) + .limit_optional(data.limit) + .list()?; + comments = CommentView::list( &conn, &sort, @@ -401,21 +388,14 @@ impl Perform for Oper { users = UserView::list(&conn, &sort, Some(data.q.to_owned()), data.page, data.limit)?; } SearchType::Url => { - posts = PostView::list( - &conn, - ListingType::All, - &sort, - data.community_id, - None, - None, - Some(data.q.to_owned()), - None, - true, - false, - false, - data.page, - data.limit, - )?; + posts = PostQueryBuilder::create(&conn) + .sort(&sort) + .show_nsfw(true) + .for_community_id_optional(data.community_id) + .url_search(data.q.to_owned()) + .page_optional(data.page) + .limit_optional(data.limit) + .list()?; } }; diff --git a/server/src/api/user.rs b/server/src/api/user.rs index e15563b0..8a508e2a 100644 --- a/server/src/api/user.rs +++ b/server/src/api/user.rs @@ -366,40 +366,22 @@ impl Perform for Oper { let user_view = UserView::read(&conn, user_details_id)?; + let mut posts_query = PostQueryBuilder::create(&conn) + .sort(&sort) + .show_nsfw(show_nsfw) + .saved_only(data.saved_only) + .for_community_id_optional(data.community_id) + .my_user_id_optional(user_id) + .page_optional(data.page) + .limit_optional(data.limit); + // If its saved only, you don't care what creator it was - let posts = if data.saved_only { - PostView::list( - &conn, - ListingType::All, - &sort, - data.community_id, - None, - None, - None, - Some(user_details_id), - show_nsfw, - data.saved_only, - false, - data.page, - data.limit, - )? - } else { - PostView::list( - &conn, - ListingType::All, - &sort, - data.community_id, - Some(user_details_id), - None, - None, - user_id, - show_nsfw, - data.saved_only, - false, - data.page, - data.limit, - )? - }; + if !data.saved_only { + posts_query = posts_query.for_creator_id(user_details_id); + } + + let posts = posts_query.list()?; + let comments = if data.saved_only { CommentView::list( &conn, @@ -777,21 +759,12 @@ impl Perform for Oper { } // Posts - let posts = PostView::list( - &conn, - ListingType::All, - &SortType::New, - None, - Some(user_id), - None, - None, - None, - true, - false, - false, - None, - Some(std::i64::MAX), - )?; + let posts = PostQueryBuilder::create(&conn) + .sort(&SortType::New) + .show_nsfw(true) + .for_creator_id(user_id) + .limit(std::i64::MAX) + .list()?; for post in &posts { let post_form = PostForm { diff --git a/server/src/db/post_view.rs b/server/src/db/post_view.rs index e4e3c16d..7a589738 100644 --- a/server/src/db/post_view.rs +++ b/server/src/db/post_view.rs @@ -1,4 +1,6 @@ +use super::post_view::post_view::BoxedQuery; use super::*; +use diesel::pg::Pg; // The faked schema since diesel doesn't do views table! { @@ -73,82 +75,161 @@ pub struct PostView { pub saved: Option, } -impl PostView { - pub fn list( - conn: &PgConnection, - type_: ListingType, - sort: &SortType, - for_community_id: Option, - for_creator_id: Option, - search_term: Option, - url_search: Option, - my_user_id: Option, - show_nsfw: bool, - saved_only: bool, - unread_only: bool, - page: Option, - limit: Option, - ) -> Result, Error> { +pub struct PostQueryBuilder<'a> { + conn: &'a PgConnection, + query: BoxedQuery<'a, Pg>, + listing_type: ListingType, + sort: &'a SortType, + my_user_id: Option, + for_creator_id: Option, + show_nsfw: bool, + saved_only: bool, + unread_only: bool, + page: Option, + limit: Option, +} + +impl<'a> PostQueryBuilder<'a> { + pub fn create(conn: &'a PgConnection) -> Self { use super::post_view::post_view::dsl::*; - let (limit, offset) = limit_and_offset(page, limit); + let query = post_view.into_boxed(); - let mut query = post_view.into_boxed(); + PostQueryBuilder { + conn, + query, + my_user_id: None, + for_creator_id: None, + listing_type: ListingType::All, + sort: &SortType::Hot, + show_nsfw: true, + saved_only: false, + unread_only: false, + page: None, + limit: None, + } + } - // If its for a specific user, show the removed / deleted - if let Some(for_creator_id) = for_creator_id { - query = query.filter(creator_id.eq(for_creator_id)); - } else { - query = query - .filter(removed.eq(false)) - .filter(deleted.eq(false)) - .filter(community_removed.eq(false)) - .filter(community_deleted.eq(false)); - }; + pub fn listing_type(mut self, listing_type: ListingType) -> Self { + self.listing_type = listing_type; + self + } - if let Some(search_term) = search_term { - query = query.filter(name.ilike(fuzzy_search(&search_term))); - }; + pub fn sort(mut self, sort: &'a SortType) -> Self { + self.sort = sort; + self + } - if let Some(url_search) = url_search { - query = query.filter(url.eq(url_search)); - }; + pub fn for_community_id(mut self, for_community_id: i32) -> Self { + use super::post_view::post_view::dsl::*; + self.query = self.query.filter(community_id.eq(for_community_id)); + self.query = self.query.then_order_by(stickied.desc()); + self + } - if let Some(for_community_id) = for_community_id { - query = query.filter(community_id.eq(for_community_id)); - query = query.then_order_by(stickied.desc()); - }; + pub fn for_community_id_optional(self, for_community_id: Option) -> Self { + match for_community_id { + Some(for_community_id) => self.for_community_id(for_community_id), + None => self, + } + } - // TODO these are wrong, bc they'll only show saved for your logged in user, not theirs - if saved_only { - query = query.filter(saved.eq(true)); - }; + pub fn for_creator_id(mut self, for_creator_id: i32) -> Self { + self.for_creator_id = Some(for_creator_id); + self + } - if unread_only { - query = query.filter(read.eq(false)); - }; + pub fn for_creator_id_optional(self, for_creator_id: Option) -> Self { + match for_creator_id { + Some(for_creator_id) => self.for_creator_id(for_creator_id), + None => self, + } + } - match type_ { + pub fn search_term(mut self, search_term: String) -> Self { + use super::post_view::post_view::dsl::*; + self.query = self.query.filter(name.ilike(fuzzy_search(&search_term))); + self + } + + pub fn search_term_optional(self, search_term: Option) -> Self { + match search_term { + Some(search_term) => self.search_term(search_term), + None => self, + } + } + + pub fn url_search(mut self, url_search: String) -> Self { + use super::post_view::post_view::dsl::*; + self.query = self.query.filter(url.eq(url_search)); + self + } + + pub fn url_search_optional(self, url_search: Option) -> Self { + match url_search { + Some(url_search) => self.url_search(url_search), + None => self, + } + } + + pub fn my_user_id(mut self, my_user_id: i32) -> Self { + self.my_user_id = Some(my_user_id); + self + } + + pub fn my_user_id_optional(mut self, my_user_id: Option) -> Self { + self.my_user_id = my_user_id; + self + } + + pub fn show_nsfw(mut self, show_nsfw: bool) -> Self { + self.show_nsfw = show_nsfw; + self + } + + pub fn saved_only(mut self, saved_only: bool) -> Self { + self.saved_only = saved_only; + self + } + + pub fn unread_only(mut self, unread_only: bool) -> Self { + self.unread_only = unread_only; + self + } + + pub fn page(mut self, page: i64) -> Self { + self.page = Some(page); + self + } + + pub fn page_optional(mut self, page: Option) -> Self { + self.page = page; + self + } + + pub fn limit(mut self, limit: i64) -> Self { + self.limit = Some(limit); + self + } + + pub fn limit_optional(mut self, limit: Option) -> Self { + self.limit = limit; + self + } + + pub fn list(self) -> Result, Error> { + use super::post_view::post_view::dsl::*; + + let mut query = self.query; + + match self.listing_type { ListingType::Subscribed => { query = query.filter(subscribed.eq(true)); } _ => {} }; - // The view lets you pass a null user_id, if you're not logged in - if let Some(my_user_id) = my_user_id { - query = query.filter(user_id.eq(my_user_id)); - } else { - query = query.filter(user_id.is_null()); - } - - if !show_nsfw { - query = query - .filter(nsfw.eq(false)) - .filter(community_nsfw.eq(false)); - }; - - query = match sort { + query = match self.sort { SortType::Hot => query .then_order_by(hot_rank.desc()) .then_order_by(published.desc()), @@ -168,11 +249,53 @@ impl PostView { .then_order_by(score.desc()), }; - query = query.limit(limit).offset(offset); + // The view lets you pass a null user_id, if you're not logged in + query = if let Some(my_user_id) = self.my_user_id { + query.filter(user_id.eq(my_user_id)) + } else { + query.filter(user_id.is_null()) + }; - query.load::(conn) + // If its for a specific user, show the removed / deleted + if let Some(for_creator_id) = self.for_creator_id { + query = query.filter(creator_id.eq(for_creator_id)); + } else { + query = query + .filter(removed.eq(false)) + .filter(deleted.eq(false)) + .filter(community_removed.eq(false)) + .filter(community_deleted.eq(false)); + } + + if !self.show_nsfw { + query = query + .filter(nsfw.eq(false)) + .filter(community_nsfw.eq(false)); + }; + + // TODO these are wrong, bc they'll only show saved for your logged in user, not theirs + if self.saved_only { + query = query.filter(saved.eq(true)); + }; + + if self.unread_only { + query = query.filter(read.eq(false)); + }; + + let (limit, offset) = limit_and_offset(self.page, self.limit); + query = query + .limit(limit) + .offset(offset) + .filter(removed.eq(false)) + .filter(deleted.eq(false)) + .filter(community_removed.eq(false)) + .filter(community_deleted.eq(false)); + + query.load::(self.conn) } +} +impl PostView { pub fn read( conn: &PgConnection, from_post_id: i32, @@ -345,38 +468,21 @@ mod tests { nsfw: false, }; - let read_post_listings_with_user = PostView::list( - &conn, - ListingType::Community, - &SortType::New, - Some(inserted_community.id), - None, - None, - None, - Some(inserted_user.id), - false, - false, - false, - None, - None, - ) - .unwrap(); - let read_post_listings_no_user = PostView::list( - &conn, - ListingType::Community, - &SortType::New, - Some(inserted_community.id), - None, - None, - None, - None, - false, - false, - false, - None, - None, - ) - .unwrap(); + let read_post_listings_with_user = PostQueryBuilder::create(&conn) + .listing_type(ListingType::Community) + .sort(&SortType::New) + .for_community_id(inserted_community.id) + .my_user_id(inserted_user.id) + .list() + .unwrap(); + + let read_post_listings_no_user = PostQueryBuilder::create(&conn) + .listing_type(ListingType::Community) + .sort(&SortType::New) + .for_community_id(inserted_community.id) + .list() + .unwrap(); + let read_post_listing_no_user = PostView::read(&conn, inserted_post.id, None).unwrap(); let read_post_listing_with_user = PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap(); diff --git a/server/src/feeds.rs b/server/src/feeds.rs index 737207fa..66c1b02a 100644 --- a/server/src/feeds.rs +++ b/server/src/feeds.rs @@ -4,7 +4,7 @@ use super::*; use crate::db::comment_view::ReplyView; use crate::db::community::Community; use crate::db::community_view::SiteView; -use crate::db::post_view::PostView; +use crate::db::post_view::{PostView, PostQueryBuilder}; use crate::db::user::User_; use crate::db::user_mention_view::UserMentionView; use crate::db::{establish_connection, ListingType, SortType}; @@ -86,21 +86,10 @@ fn get_feed_all_data(sort_type: &SortType) -> Result { let site_view = SiteView::read(&conn)?; - let posts = PostView::list( - &conn, - ListingType::All, - sort_type, - None, - None, - None, - None, - None, - true, - false, - false, - None, - None, - )?; + let posts = PostQueryBuilder::create(&conn) + .listing_type(ListingType::All) + .sort(sort_type) + .list()?; let items = create_post_items(posts); @@ -124,21 +113,11 @@ fn get_feed_user(sort_type: &SortType, user_name: String) -> Result Result Result { let site_view = SiteView::read(&conn)?; let user_id = db::user::Claims::decode(&jwt)?.claims.id; - let posts = PostView::list( - &conn, - ListingType::Subscribed, - sort_type, - None, - None, - None, - None, - Some(user_id), - true, - false, - false, - None, - None, - )?; + let posts = PostQueryBuilder::create(&conn) + .listing_type(ListingType::Subscribed) + .sort(sort_type) + .my_user_id(user_id) + .list()?; let items = create_post_items(posts); diff --git a/server/src/feeds.rs.orig b/server/src/feeds.rs.orig new file mode 100644 index 00000000..e304665c --- /dev/null +++ b/server/src/feeds.rs.orig @@ -0,0 +1,413 @@ +extern crate rss; + +use super::*; +use crate::db::comment_view::ReplyView; +use crate::db::community::Community; +use crate::db::community_view::SiteView; +use crate::db::post_view::PostQueryBuilder; +use crate::db::user::User_; +<<<<<<< HEAD +use crate::db::user_mention_view::UserMentionView; +use crate::db::{establish_connection, ListingType, SortType}; +======= +use crate::db::{establish_connection, SortType}; +>>>>>>> teromene-config_dif_addr +use crate::Settings; +use actix_web::body::Body; +use actix_web::{web, HttpResponse, Result}; +use failure::Error; +use rss::{CategoryBuilder, ChannelBuilder, GuidBuilder, Item, ItemBuilder}; +use serde::Deserialize; +use std::str::FromStr; +use strum::ParseError; + +#[derive(Deserialize)] +pub struct Params { + sort: Option, +} + +enum RequestType { + Community, + User, + Front, + Inbox, +} + +pub fn get_all_feed(info: web::Query) -> HttpResponse { + let sort_type = match get_sort_type(info) { + Ok(sort_type) => sort_type, + Err(_) => return HttpResponse::BadRequest().finish(), + }; + + let feed_result = get_feed_all_data(&sort_type); + + match feed_result { + Ok(rss) => HttpResponse::Ok() + .content_type("application/rss+xml") + .body(rss), + Err(_) => HttpResponse::NotFound().finish(), + } +} + +pub fn get_feed(path: web::Path<(String, String)>, info: web::Query) -> HttpResponse { + let sort_type = match get_sort_type(info) { + Ok(sort_type) => sort_type, + Err(_) => return HttpResponse::BadRequest().finish(), + }; + + let request_type = match path.0.as_ref() { + "u" => RequestType::User, + "c" => RequestType::Community, + "front" => RequestType::Front, + "inbox" => RequestType::Inbox, + _ => return HttpResponse::NotFound().finish(), + }; + + let param = path.1.to_owned(); + + let feed_result = match request_type { + RequestType::User => get_feed_user(&sort_type, param), + RequestType::Community => get_feed_community(&sort_type, param), + RequestType::Front => get_feed_front(&sort_type, param), + RequestType::Inbox => get_feed_inbox(param), + }; + + match feed_result { + Ok(rss) => HttpResponse::Ok() + .content_type("application/rss+xml") + .body(rss), + Err(_) => HttpResponse::NotFound().finish(), + } +} + +fn get_sort_type(info: web::Query) -> Result { + let sort_query = info.sort.to_owned().unwrap_or(SortType::Hot.to_string()); + SortType::from_str(&sort_query) +} + +fn get_feed_all_data(sort_type: &SortType) -> Result { + let conn = establish_connection(); + + let site_view = SiteView::read(&conn)?; + + let posts = PostView::list( + &conn, + ListingType::All, + sort_type, + None, + None, + None, + None, + None, + true, + false, + false, + None, + None, + )?; + + let items = create_post_items(posts); + + let mut channel_builder = ChannelBuilder::default(); + channel_builder + .title(&format!("{} - All", site_view.name)) + .link(format!("https://{}", Settings::get().hostname)) + .items(items); + + if let Some(site_desc) = site_view.description { + channel_builder.description(&site_desc); + } + + Ok(channel_builder.build().unwrap().to_string()) +} + +fn get_feed_user(sort_type: &SortType, user_name: String) -> Result { + let conn = establish_connection(); + + let site_view = SiteView::read(&conn)?; + let user = User_::find_by_email_or_username(&conn, &user_name)?; + let user_url = format!("https://{}/u/{}", Settings::get().hostname, user.name); + + let posts = PostView::list( + &conn, + ListingType::All, + sort_type, + None, + Some(user.id), + None, + None, + None, + true, + false, + false, + None, + None, + )?; + + let items = create_post_items(posts); + + let mut channel_builder = ChannelBuilder::default(); + channel_builder + .title(&format!("{} - {}", site_view.name, user.name)) + .link(user_url) + .items(items); + + Ok(channel_builder.build().unwrap().to_string()) +} + +fn get_feed_community(sort_type: &SortType, community_name: String) -> Result { + let conn = establish_connection(); + + let site_view = SiteView::read(&conn)?; + let community = Community::read_from_name(&conn, community_name)?; + let community_url = format!("https://{}/c/{}", Settings::get().hostname, community.name); + +<<<<<<< HEAD + let posts = PostView::list( + &conn, + ListingType::All, + sort_type, + Some(community.id), + None, + None, + None, + None, + true, + false, + false, + None, + None, + )?; +======= + let posts = PostQueryBuilder::create(&conn) + .sort(sort_type) + .show_nsfw(true) + .for_community_id_optional(community_id) + .for_creator_id_optional(creator_id) + .list()?; +>>>>>>> teromene-config_dif_addr + + let items = create_post_items(posts); + + let mut channel_builder = ChannelBuilder::default(); + channel_builder + .title(&format!("{} - {}", site_view.name, community.name)) + .link(community_url) + .items(items); + + if let Some(community_desc) = community.description { + channel_builder.description(&community_desc); + } + + Ok(channel_builder.build().unwrap().to_string()) +} + +fn get_feed_front(sort_type: &SortType, jwt: String) -> Result { + let conn = establish_connection(); + + let site_view = SiteView::read(&conn)?; + let user_id = db::user::Claims::decode(&jwt)?.claims.id; + + let posts = PostView::list( + &conn, + ListingType::Subscribed, + sort_type, + None, + None, + None, + None, + Some(user_id), + true, + false, + false, + None, + None, + )?; + + let items = create_post_items(posts); + + let mut channel_builder = ChannelBuilder::default(); + channel_builder + .title(&format!("{} - Subscribed", site_view.name)) + .link(format!("https://{}", Settings::get().hostname)) + .items(items); + + if let Some(site_desc) = site_view.description { + channel_builder.description(&site_desc); + } + + Ok(channel_builder.build().unwrap().to_string()) +} + +fn get_feed_inbox(jwt: String) -> Result { + let conn = establish_connection(); + + let site_view = SiteView::read(&conn)?; + let user_id = db::user::Claims::decode(&jwt)?.claims.id; + + let sort = SortType::New; + + let replies = ReplyView::get_replies(&conn, user_id, &sort, false, None, None)?; + + let mentions = UserMentionView::get_mentions(&conn, user_id, &sort, false, None, None)?; + + let items = create_reply_and_mention_items(replies, mentions); + + let mut channel_builder = ChannelBuilder::default(); + channel_builder + .title(&format!("{} - Inbox", site_view.name)) + .link(format!("https://{}/inbox", Settings::get().hostname)) + .items(items); + + if let Some(site_desc) = site_view.description { + channel_builder.description(&site_desc); + } + + Ok(channel_builder.build().unwrap().to_string()) +} + +fn create_reply_and_mention_items( + replies: Vec, + mentions: Vec, +) -> Vec { + let mut items: Vec = Vec::new(); + + for r in replies { + let mut i = ItemBuilder::default(); + + i.title(format!("Reply from {}", r.creator_name)); + + let author_url = format!("https://{}/u/{}", Settings::get().hostname, r.creator_name); + i.author(format!( + "/u/{} (link)", + r.creator_name, author_url + )); + + let dt = DateTime::::from_utc(r.published, Utc); + i.pub_date(dt.to_rfc2822()); + + let reply_url = format!( + "https://{}/post/{}/comment/{}", + Settings::get().hostname, + r.post_id, + r.id + ); + i.comments(reply_url.to_owned()); + let guid = GuidBuilder::default() + .permalink(true) + .value(&reply_url) + .build(); + i.guid(guid.unwrap()); + + i.link(reply_url); + + // TODO find a markdown to html parser here, do images, etc + i.description(r.content); + + items.push(i.build().unwrap()); + } + + for m in mentions { + let mut i = ItemBuilder::default(); + + i.title(format!("Mention from {}", m.creator_name)); + + let author_url = format!("https://{}/u/{}", Settings::get().hostname, m.creator_name); + i.author(format!( + "/u/{} (link)", + m.creator_name, author_url + )); + + let dt = DateTime::::from_utc(m.published, Utc); + i.pub_date(dt.to_rfc2822()); + + let mention_url = format!( + "https://{}/post/{}/comment/{}", + Settings::get().hostname, + m.post_id, + m.id + ); + i.comments(mention_url.to_owned()); + let guid = GuidBuilder::default() + .permalink(true) + .value(&mention_url) + .build(); + i.guid(guid.unwrap()); + + i.link(mention_url); + + // TODO find a markdown to html parser here, do images, etc + i.description(m.content); + + items.push(i.build().unwrap()); + } + + items +} + +fn create_post_items(posts: Vec) -> Vec { + let mut items: Vec = Vec::new(); + + for p in posts { + let mut i = ItemBuilder::default(); + + i.title(p.name); + + let author_url = format!("https://{}/u/{}", Settings::get().hostname, p.creator_name); + i.author(format!( + "/u/{} (link)", + p.creator_name, author_url + )); + + let dt = DateTime::::from_utc(p.published, Utc); + i.pub_date(dt.to_rfc2822()); + + let post_url = format!("https://{}/post/{}", Settings::get().hostname, p.id); + i.comments(post_url.to_owned()); + let guid = GuidBuilder::default() + .permalink(true) + .value(&post_url) + .build(); + i.guid(guid.unwrap()); + + let community_url = format!( + "https://{}/c/{}", + Settings::get().hostname, + p.community_name + ); + + let category = CategoryBuilder::default() + .name(format!( + "/c/{} (link)", + p.community_name, community_url + )) + .domain(Settings::get().hostname) + .build(); + i.categories(vec![category.unwrap()]); + + if let Some(url) = p.url { + i.link(url); + } + + // TODO find a markdown to html parser here, do images, etc + let mut description = format!(" + submitted by {} to {}
{} points | {} comments", + author_url, + p.creator_name, + community_url, + p.community_name, + p.score, + post_url, + p.number_of_comments); + + if let Some(body) = p.body { + description.push_str(&format!("

{}", body)); + } + + i.description(description); + + items.push(i.build().unwrap()); + } + + items +} diff --git a/server/src/websocket/server.rs b/server/src/websocket/server.rs index 5bcca297..86a929c9 100644 --- a/server/src/websocket/server.rs +++ b/server/src/websocket/server.rs @@ -134,21 +134,14 @@ impl ChatServer { use crate::db::post_view::*; use crate::db::*; let conn = establish_connection(); - let posts = PostView::list( - &conn, - ListingType::Community, - &SortType::New, - Some(*community_id), - None, - None, - None, - None, - false, - false, - false, - None, - Some(9999), - )?; + + let posts = PostQueryBuilder::create(&conn) + .listing_type(ListingType::Community) + .sort(&SortType::New) + .for_community_id(*community_id) + .limit(9999) + .list()?; + for post in posts { self.send_room_message(&post.id, message, skip_id); }