diff options
Diffstat (limited to 'server/lemmy_db')
22 files changed, 6536 insertions, 0 deletions
diff --git a/server/lemmy_db/Cargo.toml b/server/lemmy_db/Cargo.toml new file mode 100644 index 00000000..d94cf5fc --- /dev/null +++ b/server/lemmy_db/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "lemmy_db" +version = "0.1.0" +edition = "2018" + +[dependencies] +diesel = { version = "1.4.4", features = ["postgres","chrono","r2d2","64-column-tables","serde_json"] } +chrono = { version = "0.4.7", features = ["serde"] } +serde = { version = "1.0.105", features = ["derive"] } +serde_json = { version = "1.0.52", features = ["preserve_order"]} +strum = "0.18.0" +strum_macros = "0.18.0" +log = "0.4.0" +sha2 = "0.9" +bcrypt = "0.8.0"
\ No newline at end of file diff --git a/server/lemmy_db/src/activity.rs b/server/lemmy_db/src/activity.rs new file mode 100644 index 00000000..83f85ca1 --- /dev/null +++ b/server/lemmy_db/src/activity.rs @@ -0,0 +1,165 @@ +use crate::{schema::activity, Crud}; +use diesel::{dsl::*, result::Error, *}; +use log::debug; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::{ + fmt::Debug, + io::{Error as IoError, ErrorKind}, +}; + +#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] +#[table_name = "activity"] +pub struct Activity { + pub id: i32, + pub user_id: i32, + pub data: Value, + pub local: bool, + pub published: chrono::NaiveDateTime, + pub updated: Option<chrono::NaiveDateTime>, +} + +#[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] +#[table_name = "activity"] +pub struct ActivityForm { + pub user_id: i32, + pub data: Value, + pub local: bool, + pub updated: Option<chrono::NaiveDateTime>, +} + +impl Crud<ActivityForm> for Activity { + fn read(conn: &PgConnection, activity_id: i32) -> Result<Self, Error> { + use crate::schema::activity::dsl::*; + activity.find(activity_id).first::<Self>(conn) + } + + fn delete(conn: &PgConnection, activity_id: i32) -> Result<usize, Error> { + use crate::schema::activity::dsl::*; + diesel::delete(activity.find(activity_id)).execute(conn) + } + + fn create(conn: &PgConnection, new_activity: &ActivityForm) -> Result<Self, Error> { + use crate::schema::activity::dsl::*; + insert_into(activity) + .values(new_activity) + .get_result::<Self>(conn) + } + + fn update( + conn: &PgConnection, + activity_id: i32, + new_activity: &ActivityForm, + ) -> Result<Self, Error> { + use crate::schema::activity::dsl::*; + diesel::update(activity.find(activity_id)) + .set(new_activity) + .get_result::<Self>(conn) + } +} + +pub fn do_insert_activity<T>( + conn: &PgConnection, + user_id: i32, + data: &T, + local: bool, +) -> Result<Activity, IoError> +where + T: Serialize + Debug, +{ + debug!("inserting activity for user {}, data {:?}", user_id, &data); + let activity_form = ActivityForm { + user_id, + data: serde_json::to_value(&data)?, + local, + updated: None, + }; + let result = Activity::create(&conn, &activity_form); + match result { + Ok(s) => Ok(s), + Err(e) => Err(IoError::new( + ErrorKind::Other, + format!("Failed to insert activity into database: {}", e), + )), + } +} + +#[cfg(test)] +mod tests { + use crate::{ + activity::{Activity, ActivityForm}, + tests::establish_unpooled_connection, + user::{UserForm, User_}, + Crud, + ListingType, + SortType, + }; + use serde_json::Value; + + #[test] + fn test_crud() { + let conn = establish_unpooled_connection(); + + let creator_form = UserForm { + name: "activity_creator_pm".into(), + preferred_username: None, + password_encrypted: "nope".into(), + email: None, + matrix_user_id: None, + avatar: None, + admin: false, + banned: false, + updated: None, + show_nsfw: false, + theme: "darkly".into(), + default_sort_type: SortType::Hot as i16, + default_listing_type: ListingType::Subscribed as i16, + lang: "browser".into(), + show_avatars: true, + send_notifications_to_email: false, + actor_id: "http://fake.com".into(), + bio: None, + local: true, + private_key: None, + public_key: None, + last_refreshed_at: None, + }; + + let inserted_creator = User_::create(&conn, &creator_form).unwrap(); + + let test_json: Value = serde_json::from_str( + r#"{ + "street": "Article Circle Expressway 1", + "city": "North Pole", + "postcode": "99705", + "state": "Alaska" +}"#, + ) + .unwrap(); + let activity_form = ActivityForm { + user_id: inserted_creator.id, + data: test_json.to_owned(), + local: true, + updated: None, + }; + + let inserted_activity = Activity::create(&conn, &activity_form).unwrap(); + + let expected_activity = Activity { + id: inserted_activity.id, + user_id: inserted_creator.id, + data: test_json, + local: true, + published: inserted_activity.published, + updated: None, + }; + + let read_activity = Activity::read(&conn, inserted_activity.id).unwrap(); + let num_deleted = Activity::delete(&conn, inserted_activity.id).unwrap(); + User_::delete(&conn, inserted_creator.id).unwrap(); + + assert_eq!(expected_activity, read_activity); + assert_eq!(expected_activity, inserted_activity); + assert_eq!(1, num_deleted); + } +} diff --git a/server/lemmy_db/src/category.rs b/server/lemmy_db/src/category.rs new file mode 100644 index 00000000..ec2efc7b --- /dev/null +++ b/server/lemmy_db/src/category.rs @@ -0,0 +1,69 @@ +use crate::{ + schema::{category, category::dsl::*}, + Crud, +}; +use diesel::{dsl::*, result::Error, *}; +use serde::{Deserialize, Serialize}; + +#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] +#[table_name = "category"] +pub struct Category { + pub id: i32, + pub name: String, +} + +#[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] +#[table_name = "category"] +pub struct CategoryForm { + pub name: String, +} + +impl Crud<CategoryForm> for Category { + fn read(conn: &PgConnection, category_id: i32) -> Result<Self, Error> { + category.find(category_id).first::<Self>(conn) + } + + fn delete(conn: &PgConnection, category_id: i32) -> Result<usize, Error> { + diesel::delete(category.find(category_id)).execute(conn) + } + + fn create(conn: &PgConnection, new_category: &CategoryForm) -> Result<Self, Error> { + insert_into(category) + .values(new_category) + .get_result::<Self>(conn) + } + + fn update( + conn: &PgConnection, + category_id: i32, + new_category: &CategoryForm, + ) -> Result<Self, Error> { + diesel::update(category.find(category_id)) + .set(new_category) + .get_result::<Self>(conn) + } +} + +impl Category { + pub fn list_all(conn: &PgConnection) -> Result<Vec<Self>, Error> { + category.load::<Self>(conn) + } +} + +#[cfg(test)] +mod tests { + use crate::{category::Category, tests::establish_unpooled_connection}; + + #[test] + fn test_crud() { + let conn = establish_unpooled_connection(); + + let categories = Category::list_all(&conn).unwrap(); + let expected_first_category = Category { + id: 1, + name: "Discussion".into(), + }; + + assert_eq!(expected_first_category, categories[0]); + } +} diff --git a/server/lemmy_db/src/comment.rs b/server/lemmy_db/src/comment.rs new file mode 100644 index 00000000..602070d5 --- /dev/null +++ b/server/lemmy_db/src/comment.rs @@ -0,0 +1,386 @@ +use super::{post::Post, *}; +use crate::schema::{comment, comment_like, comment_saved}; + +// WITH RECURSIVE MyTree AS ( +// SELECT * FROM comment WHERE parent_id IS NULL +// UNION ALL +// SELECT m.* FROM comment AS m JOIN MyTree AS t ON m.parent_id = t.id +// ) +// SELECT * FROM MyTree; + +#[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Deserialize)] +#[belongs_to(Post)] +#[table_name = "comment"] +pub struct Comment { + pub id: i32, + pub creator_id: i32, + pub post_id: i32, + pub parent_id: Option<i32>, + pub content: String, + pub removed: bool, + pub read: bool, // Whether the recipient has read the comment or not + pub published: chrono::NaiveDateTime, + pub updated: Option<chrono::NaiveDateTime>, + pub deleted: bool, + pub ap_id: String, + pub local: bool, +} + +#[derive(Insertable, AsChangeset, Clone)] +#[table_name = "comment"] +pub struct CommentForm { + pub creator_id: i32, + pub post_id: i32, + pub parent_id: Option<i32>, + pub content: String, + pub removed: Option<bool>, + pub read: Option<bool>, + pub published: Option<chrono::NaiveDateTime>, + pub updated: Option<chrono::NaiveDateTime>, + pub deleted: Option<bool>, + pub ap_id: String, + pub local: bool, +} + +impl Crud<CommentForm> for Comment { + fn read(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + comment.find(comment_id).first::<Self>(conn) + } + + fn delete(conn: &PgConnection, comment_id: i32) -> Result<usize, Error> { + use crate::schema::comment::dsl::*; + diesel::delete(comment.find(comment_id)).execute(conn) + } + + fn create(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + insert_into(comment) + .values(comment_form) + .get_result::<Self>(conn) + } + + fn update( + conn: &PgConnection, + comment_id: i32, + comment_form: &CommentForm, + ) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + diesel::update(comment.find(comment_id)) + .set(comment_form) + .get_result::<Self>(conn) + } +} + +impl Comment { + pub fn update_ap_id( + conn: &PgConnection, + comment_id: i32, + apub_id: String, + ) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + + diesel::update(comment.find(comment_id)) + .set(ap_id.eq(apub_id)) + .get_result::<Self>(conn) + } + + pub fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + comment.filter(ap_id.eq(object_id)).first::<Self>(conn) + } + + pub fn mark_as_read(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + + diesel::update(comment.find(comment_id)) + .set(read.eq(true)) + .get_result::<Self>(conn) + } + + pub fn permadelete(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> { + use crate::schema::comment::dsl::*; + + diesel::update(comment.find(comment_id)) + .set(( + content.eq("*Permananently Deleted*"), + deleted.eq(true), + updated.eq(naive_now()), + )) + .get_result::<Self>(conn) + } +} + +#[derive(Identifiable, Queryable, Associations, PartialEq, Debug, Clone)] +#[belongs_to(Comment)] +#[table_name = "comment_like"] +pub struct CommentLike { + pub id: i32, + pub user_id: i32, + pub comment_id: i32, + pub post_id: i32, + pub score: i16, + pub published: chrono::NaiveDateTime, +} + +#[derive(Insertable, AsChangeset, Clone)] +#[table_name = "comment_like"] +pub struct CommentLikeForm { + pub user_id: i32, + pub comment_id: i32, + pub post_id: i32, + pub score: i16, +} + +impl Likeable<CommentLikeForm> for CommentLike { + fn read(conn: &PgConnection, comment_id_from: i32) -> Result<Vec<Self>, Error> { + use crate::schema::comment_like::dsl::*; + comment_like + .filter(comment_id.eq(comment_id_from)) + .load::<Self>(conn) + } + + fn like(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result<Self, Error> { + use crate::schema::comment_like::dsl::*; + insert_into(comment_like) + .values(comment_like_form) + .get_result::<Self>(conn) + } + fn remove(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result<usize, Error> { + use crate::schema::comment_like::dsl::*; + diesel::delete( + comment_like + .filter(comment_id.eq(comment_like_form.comment_id)) + .filter(user_id.eq(comment_like_form.user_id)), + ) + .execute(conn) + } +} + +impl CommentLike { + pub fn from_post(conn: &PgConnection, post_id_from: i32) -> Result<Vec<Self>, Error> { + use crate::schema::comment_like::dsl::*; + comment_like + .filter(post_id.eq(post_id_from)) + .load::<Self>(conn) + } +} + +#[derive(Identifiable, Queryable, Associations, PartialEq, Debug)] +#[belongs_to(Comment)] +#[table_name = "comment_saved"] +pub struct CommentSaved { + pub id: i32, + pub comment_id: i32, + pub user_id: i32, + pub published: chrono::NaiveDateTime, +} + +#[derive(Insertable, AsChangeset, Clone)] +#[table_name = "comment_saved"] +pub struct CommentSavedForm { + pub comment_id: i32, + pub user_id: i32, +} + +impl Saveable<CommentSavedForm> for CommentSaved { + fn save(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> { + use crate::schema::comment_saved::dsl::*; + insert_into(comment_saved) + .values(comment_saved_form) + .get_result::<Self>(conn) + } + fn unsave(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<usize, Error> { + use crate::schema::comment_saved::dsl::*; + diesel::delete( + comment_saved + .filter(comment_id.eq(comment_saved_form.comment_id)) + .filter(user_id.eq(comment_saved_form.user_id)), + ) + .execute(conn) + } +} + +#[cfg(test)] +mod tests { + use crate::{comment::*, community::*, post::*, tests::establish_unpooled_connection, user::*}; + + #[test] + fn test_crud() { + let conn = establish_unpooled_connection(); + + let new_user = UserForm { + name: "terry".into(), + preferred_username: None, + password_encrypted: "nope".into(), + email: None, + matrix_user_id: None, + avatar: None, + admin: false, + banned: false, + updated: None, + show_nsfw: false, + theme: "darkly".into(), + default_sort_type: SortType::Hot as i16, + default_listing_type: ListingType::Subscribed as i16, + lang: "browser".into(), + show_avatars: true, + send_notifications_to_email: false, + actor_id: "http://fake.com".into(), + bio: None, + local: true, + private_key: None, + public_key: None, + last_refreshed_at: None, + }; + + let inserted_user = User_::create(&conn, &new_user).unwrap(); + + let new_community = CommunityForm { + name: "test community".to_string(), + title: "nada".to_owned(), + description: None, + category_id: 1, + creator_id: inserted_user.id, + removed: None, + deleted: None, + updated: None, + nsfw: false, + actor_id: "http://fake.com".into(), + local: true, + private_key: None, + public_key: None, + last_refreshed_at: None, + published: None, + }; + + let inserted_community = Community::create(&conn, &new_community).unwrap(); + + let new_post = PostForm { + name: "A test post".into(), + creator_id: inserted_user.id, + url: None, + body: None, + community_id: inserted_community.id, + removed: None, + deleted: None, + locked: None, + stickied: None, + updated: None, + nsfw: false, + embed_title: None, + embed_description: None, + embed_html: None, + thumbnail_url: None, + ap_id: "http://fake.com".into(), + local: true, + published: None, + }; + + let inserted_post = Post::create(&conn, &new_post).unwrap(); + + let comment_form = CommentForm { + content: "A test comment".into(), + creator_id: inserted_user.id, + post_id: inserted_post.id, + removed: None, + deleted: None, + read: None, + parent_id: None, + published: None, + updated: None, + ap_id: "http://fake.com".into(), + local: true, + }; + + let inserted_comment = Comment::create(&conn, &comment_form).unwrap(); + + let expected_comment = Comment { + id: inserted_comment.id, + content: "A test comment".into(), + creator_id: inserted_user.id, + post_id: inserted_post.id, + removed: false, + deleted: false, + read: false, + parent_id: None, + published: inserted_comment.published, + updated: None, + ap_id: "http://fake.com".into(), + local: true, + }; + + let child_comment_form = CommentForm { + content: "A child comment".into(), + creator_id: inserted_user.id, + post_id: inserted_post.id, + parent_id: Some(inserted_comment.id), + removed: None, + deleted: None, + read: None, + published: None, + updated: None, + ap_id: "http://fake.com".into(), + local: true, + }; + + let inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap(); + + // Comment Like + let comment_like_form = CommentLikeForm { + comment_id: inserted_comment.id, + post_id: inserted_post.id, + user_id: inserted_user.id, + score: 1, + }; + + let inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap(); + + let expected_comment_like = CommentLike { + id: inserted_comment_like.id, + comment_id: inserted_comment.id, + post_id: inserted_post.id, + user_id: inserted_user.id, + published: inserted_comment_like.published, + score: 1, + }; + + // Comment Saved + let comment_saved_form = CommentSavedForm { + comment_id: inserted_comment.id, + user_id: inserted_user.id, + }; + + let inserted_comment_saved = CommentSaved::save(&conn, &comment_saved_form).unwrap(); + + let expected_comment_saved = CommentSaved { + id: inserted_comment_saved.id, + comment_id: inserted_comment.id, + user_id: inserted_user.id, + published: inserted_comment_saved.published, + }; + + let read_comment = Comment::read(&conn, inserted_comment.id).unwrap(); + let updated_comment = Comment::update(&conn, inserted_comment.id, &comment_form).unwrap(); + let like_removed = CommentLike::remove(&conn, &comment_like_form).unwrap(); + let saved_removed = CommentSaved::unsave(&conn, &comment_saved_form).unwrap(); + let num_deleted = Comment::delete(&conn, inserted_comment.id).unwrap(); + Comment::delete(&conn, inserted_child_comment.id).unwrap(); + Post::delete(&conn, inserted_post.id).unwrap(); + Community::delete(&conn, inserted_community.id).unwrap(); + User_::delete(&conn, inserted_user.id).unwrap(); + + assert_eq!(expected_comment, read_comment); + assert_eq!(expected_comment, inserted_comment); + assert_eq!(expected_comment, updated_comment); + assert_eq!(expected_comment_like, inserted_comment_like); + assert_eq!(expected_comment_saved, inserted_comment_saved); + assert_eq!( + expected_comment.id, + inserted_child_comment.parent_id.unwrap() + ); + assert_eq!(1, like_removed); + assert_eq!(1, saved_removed); + assert_eq!(1, num_deleted); + } +} diff --git a/server/lemmy_db/src/comment_view.rs b/server/lemmy_db/src/comment_view.rs new file mode 100644 index 00000000..914e568c --- /dev/null +++ b/server/lemmy_db/src/comment_view.rs @@ -0,0 +1,669 @@ +// TODO, remove the cross join here, just join to user directly +use crate::{fuzzy_search, limit_and_offset, ListingType, MaybeOptional, SortType}; +use diesel::{dsl::*, pg::Pg, result::Error, *}; +use serde::{Deserialize, Serialize}; + +// The faked schema since diesel doesn't do views +table! { + comment_view (id) { + id -> Int4, + creator_id -> Int4, + post_id -> Int4, + parent_id -> Nullable<Int4>, + content -> Text, + removed -> Bool, + read -> Bool, + published -> Timestamp, + updated -> Nullable<Timestamp>, + deleted -> Bool, + ap_id -> Text, + local -> Bool, + community_id -> Int4, + community_actor_id -> Text, + community_local -> Bool, + community_name -> Varchar, + banned -> Bool, + banned_from_community -> Bool, + creator_actor_id -> Text, + creator_local -> Bool, + creator_name -> Varchar, + creator_published -> Timestamp, + creator_avatar -> Nullable<Text>, + score -> BigInt, + upvotes -> BigInt, + downvotes -> BigInt, + hot_rank -> Int4, + user_id -> Nullable<Int4>, + my_vote -> Nullable<Int4>, + subscribed -> Nullable<Bool>, + saved -> Nullable<Bool>, + } +} + +table! { + comment_fast_view (id) { + id -> Int4, + creator_id -> Int4, + post_id -> Int4, + parent_id -> Nullable<Int4>, + content -> Text, + removed -> Bool, + read -> Bool, + published -> Timestamp, + updated -> Nullable<Timestamp>, + deleted -> Bool, + ap_id -> Text, + local -> Bool, + community_id -> Int4, + community_actor_id -> Text, + community_local -> Bool, + community_name -> Varchar, + banned -> Bool, + banned_from_community -> Bool, + creator_actor_id -> Text, + creator_local -> Bool, + creator_name -> Varchar, + creator_published -> Timestamp, + creator_avatar -> Nullable<Text>, + score -> BigInt, + upvotes -> BigInt, + downvotes -> BigInt, + hot_rank -> Int4, + user_id -> Nullable<Int4>, + my_vote -> Nullable<Int4>, + subscribed -> Nullable<Bool>, + saved -> Nullable<Bool>, + } +} + +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "comment_fast_view"] +pub struct CommentView { + pub id: i32, + pub creator_id: i32, + pub post_id: i32, + pub parent_id: Option<i32>, + pub content: String, + pub removed: bool, + pub read: bool, + pub published: chrono::NaiveDateTime, + pub updated: Option<chrono::NaiveDateTime>, + pub deleted: bool, + pub ap_id: String, + pub local: bool, + pub community_id: i32, + pub community_actor_id: String, + pub community_local: bool, + pub community_name: String, + pub banned: bool, + pub banned_from_community: bool, + pub creator_actor_id: String, + pub creator_local: bool, + pub creator_name: String, + pub creator_published: chrono::NaiveDateTime, + pub creator_avatar: Option<String>, + pub score: i64, + pub upvotes: i64, + pub downvotes: i64, + pub hot_rank: i32, + pub user_id: Option<i32>, + pub my_vote: Option<i32>, + pub subscribed: Option<bool>, + pub saved: Option<bool>, +} + +pub struct CommentQueryBuilder<'a> { + conn: &'a PgConnection, + query: super::comment_view::comment_fast_view::BoxedQuery<'a, Pg>, + listing_type: ListingType, + sort: &'a SortType, + for_community_id: Option<i32>, + for_post_id: Option<i32>, + for_creator_id: Option<i32>, + search_term: Option<String>, + my_user_id: Option<i32>, + saved_only: bool, + page: Option<i64>, + limit: Option<i64>, +} + +impl<'a> CommentQueryBuilder<'a> { + pub fn create(conn: &'a PgConnection) -> Self { + use super::comment_view::comment_fast_view::dsl::*; + + let query = comment_fast_view.into_boxed(); + + CommentQueryBuilder { + conn, + query, + listing_type: ListingType::All, + sort: &SortType::New, + for_community_id: None, + for_post_id: None, + for_creator_id: None, + search_term: None, + my_user_id: None, + saved_only: false, + page: None, + limit: None, + } + } + + pub fn listing_type(mut self, listing_type: ListingType) -> Self { + self.listing_type = listing_type; + self + } + + pub fn sort(mut self, sort: &'a SortType) -> Self { + self.sort = sort; + self + } + + pub fn for_post_id<T: MaybeOptional<i32>>(mut self, for_post_id: T) -> Self { + self.for_post_id = for_post_id.get_optional(); + self + } + + pub fn for_creator_id<T: MaybeOptional<i32>>(mut self, for_creator_id: T) -> Self { + self.for_creator_id = for_creator_id.get_optional(); + self + } + + pub fn for_community_id<T: MaybeOptional<i32>>(mut self, for_community_id: T) -> Self { + self.for_community_id = for_community_id.get_optional(); + self + } + + pub fn search_term<T: MaybeOptional<String>>(mut self, search_term: T) -> Self { + self.search_term = search_term.get_optional(); + self + } + + pub fn my_user_id<T: MaybeOptional<i32>>(mut self, my_user_id: T) -> Self { + self.my_user_id = my_user_id.get_optional(); + self + } + + pub fn saved_only(mut self, saved_only: bool) -> Self { + self.saved_only = saved_only; + self + } + + pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self { + self.page = page.get_optional(); + self + } + + pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self { + self.limit = limit.get_optional(); + self + } + + pub fn list(self) -> Result<Vec<CommentView>, Error> { + use super::comment_view::comment_fast_view::dsl::*; + + let mut query = self.query; + + // The view lets you pass a null user_id, if you're not logged in + if let Some(my_user_id) = self.my_user_id { + query = query.filter(user_id.eq(my_user_id)); + } else { + query = query.filter(user_id.is_null()); + } + + if let Some(for_creator_id) = self.for_creator_id { + query = query.filter(creator_id.eq(for_creator_id)); + }; + + if let Some(for_community_id) = self.for_community_id { + query = query.filter(community_id.eq(for_community_id)); + } + + if let Some(for_post_id) = self.for_post_id { + query = query.filter(post_id.eq(for_post_id)); + }; + + if let Some(search_term) = self.search_term { + query = query.filter(content.ilike(fuzzy_search(&search_term))); + }; + + if let ListingType::Subscribed = self.listing_type { + query = query.filter(subscribed.eq(true)); + } + + if self.saved_only { + query = query.filter(saved.eq(true)); + } + + query = match self.sort { + SortType::Hot => query + .order_by(hot_rank.desc()) + .then_order_by(published.desc()), + SortType::New => query.order_by(published.desc()), + SortType::TopAll => query.order_by(score.desc()), + SortType::TopYear => query + .filter(published.gt(now - 1.years())) + .order_by(score.desc()), + SortType::TopMonth => query + .filter(published.gt(now - 1.months())) + .order_by(score.desc()), + SortType::TopWeek => query + .filter(published.gt(now - 1.weeks())) + .order_by(score.desc()), + SortType::TopDay => query + .filter(published.gt(now - 1.days())) + .order_by(score.desc()), + // _ => query.order_by(published.desc()), + }; + + let (limit, offset) = limit_and_offset(self.page, self.limit); + + // Note: deleted and removed comments are done on the front side + query + .limit(limit) + .offset(offset) + .load::<CommentView>(self.conn) + } +} + +impl CommentView { + pub fn read( + conn: &PgConnection, + from_comment_id: i32, + my_user_id: Option<i32>, + ) -> Result<Self, Error> { + use super::comment_view::comment_fast_view::dsl::*; + let mut query = comment_fast_view.into_boxed(); + + // 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()); + } + + query = query + .filter(id.eq(from_comment_id)) + .order_by(published.desc()); + + query.first::<Self>(conn) + } +} + +// The faked schema since diesel doesn't do views +table! { + reply_fast_view (id) { + id -> Int4, + creator_id -> Int4, + post_id -> Int4, + parent_id -> Nullable<Int4>, + content -> Text, + removed -> Bool, + read -> Bool, + published -> Timestamp, + updated -> Nullable<Timestamp>, + deleted -> Bool, + ap_id -> Text, + local -> Bool, + community_id -> Int4, + community_actor_id -> Text, + community_local -> Bool, + community_name -> Varchar, + banned -> Bool, + banned_from_community -> Bool, + creator_actor_id -> Text, + creator_local -> Bool, + creator_name -> Varchar, + creator_avatar -> Nullable<Text>, + creator_published -> Timestamp, + score -> BigInt, + upvotes -> BigInt, |