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 = PostViewQuery::create(&conn, ListingType::All, &sort, true, false, false)
+ .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(
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 = PostViewQuery::create(&conn, ListingType::All, &sort, true, false, false)
+ .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,
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 = PostViewQuery::create(&conn, ListingType::All, &sort, true, false, false)
+ .for_community_id_optional(data.community_id)
+ .url_search(data.q.to_owned())
+ .page_optional(data.page)
+ .limit_optional(data.limit)
+ .list()?;
}
};
+use super::post_view::post_view::BoxedQuery;
use super::*;
+use diesel::pg::Pg;
// The faked schema since diesel doesn't do views
table! {
pub saved: Option<bool>,
}
-impl PostView {
- pub fn list(
- conn: &PgConnection,
- type_: ListingType,
- sort: &SortType,
- for_community_id: Option<i32>,
- for_creator_id: Option<i32>,
- search_term: Option<String>,
- url_search: Option<String>,
- my_user_id: Option<i32>,
+pub struct PostViewQuery<'a> {
+ conn: &'a PgConnection,
+ query: BoxedQuery<'a, Pg>,
+ my_user_id: Option<i32>,
+ page: Option<i64>,
+ limit: Option<i64>,
+}
+
+impl<'a> PostViewQuery<'a> {
+ pub fn create(
+ conn: &'a PgConnection,
+ r#type: ListingType,
+ sort: &'a SortType,
show_nsfw: bool,
saved_only: bool,
unread_only: bool,
- page: Option<i64>,
- limit: Option<i64>,
- ) -> Result<Vec<Self>, Error> {
+ ) -> Self {
use super::post_view::post_view::dsl::*;
- let (limit, offset) = limit_and_offset(page, limit);
-
let mut query = post_view.into_boxed();
- if let Some(for_creator_id) = for_creator_id {
- query = query.filter(creator_id.eq(for_creator_id));
- };
-
- if let Some(search_term) = search_term {
- query = query.filter(name.ilike(fuzzy_search(&search_term)));
- };
-
- if let Some(url_search) = url_search {
- query = query.filter(url.eq(url_search));
- };
-
- 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());
- };
-
- // 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));
- };
-
- if unread_only {
- query = query.filter(read.eq(false));
- };
-
- match type_ {
+ match r#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 {
SortType::Hot => query
.then_order_by(hot_rank.desc())
.then_order_by(score.desc()),
};
- query = query
+ if !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 saved_only {
+ query = query.filter(saved.eq(true));
+ };
+
+ if unread_only {
+ query = query.filter(read.eq(false));
+ };
+
+ PostViewQuery {
+ conn,
+ query,
+ my_user_id: None,
+ page: None,
+ limit: None,
+ }
+ }
+
+ 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
+ }
+
+ pub fn for_community_id_optional(self, for_community_id: Option<i32>) -> Self {
+ match for_community_id {
+ Some(for_community_id) => self.for_community_id(for_community_id),
+ None => self,
+ }
+ }
+
+ pub fn for_creator_id(mut self, for_creator_id: i32) -> Self {
+ use super::post_view::post_view::dsl::*;
+ self.query = self.query.filter(creator_id.eq(for_creator_id));
+ self
+ }
+
+ pub fn for_creator_id_optional(self, for_creator_id: Option<i32>) -> Self {
+ match for_creator_id {
+ Some(for_creator_id) => self.for_creator_id(for_creator_id),
+ None => self,
+ }
+ }
+
+ 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<String>) -> 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<String>) -> 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<i32>) -> Self {
+ self.my_user_id = my_user_id;
+ self
+ }
+
+ pub fn page(mut self, page: i64) -> Self {
+ self.page = Some(page);
+ self
+ }
+
+ pub fn page_optional(mut self, page: Option<i64>) -> 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<i64>) -> Self {
+ self.limit = limit;
+ self
+ }
+
+ pub fn list(mut self) -> Result<Vec<PostView>, Error> {
+ use super::post_view::post_view::dsl::*;
+ // The view lets you pass a null user_id, if you're not logged in
+ self.query = if let Some(my_user_id) = self.my_user_id {
+ self.query.filter(user_id.eq(my_user_id))
+ } else {
+ self.query.filter(user_id.is_null())
+ };
+
+ let (limit, offset) = limit_and_offset(self.page, self.limit);
+ let query = self
+ .query
.limit(limit)
.offset(offset)
.filter(removed.eq(false))
.filter(community_removed.eq(false))
.filter(community_deleted.eq(false));
- query.load::<Self>(conn)
+ query.load::<PostView>(self.conn)
}
+}
+impl PostView {
pub fn read(
conn: &PgConnection,
from_post_id: i32,
nsfw: false,
};
- let read_post_listings_with_user = PostView::list(
+ let read_post_listings_with_user = PostViewQuery::create(
&conn,
ListingType::Community,
&SortType::New,
- Some(inserted_community.id),
- None,
- None,
- None,
- Some(inserted_user.id),
false,
false,
false,
- None,
- None,
)
+ .for_community_id(inserted_community.id)
+ .my_user_id(inserted_user.id)
+ .list()
.unwrap();
- let read_post_listings_no_user = PostView::list(
+
+ let read_post_listings_no_user = PostViewQuery::create(
&conn,
ListingType::Community,
&SortType::New,
- Some(inserted_community.id),
- None,
- None,
- None,
- None,
false,
false,
false,
- None,
- None,
)
+ .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();
projects / lemmy.git / commitdiff