X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views_actor%2Fsrc%2Fcomment_reply_view.rs;h=97d5b31ebc8d5a3e94b34bc941e9372a55ef7062;hb=c8063f3267cf2b3622f1fdc69128c6b55feefbbc;hp=611f890644d5ca46ea0471e955b4ae24ae0df61d;hpb=9c3efe32e7b2ef7978b7957eac10691beb551dde;p=lemmy.git

diff --git a/crates/db_views_actor/src/comment_reply_view.rs b/crates/db_views_actor/src/comment_reply_view.rs
index 611f8906..97d5b31e 100644
--- a/crates/db_views_actor/src/comment_reply_view.rs
+++ b/crates/db_views_actor/src/comment_reply_view.rs
@@ -1,7 +1,17 @@
 use crate::structs::CommentReplyView;
-use diesel::{dsl::*, result::Error, *};
+use diesel::{
+  pg::Pg,
+  result::Error,
+  BoolExpressionMethods,
+  ExpressionMethods,
+  JoinOnDsl,
+  NullableExpressionMethods,
+  QueryDsl,
+};
+use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::CommentAggregates,
+  aliases,
   newtypes::{CommentReplyId, PersonId},
   schema::{
     comment,
@@ -13,78 +23,57 @@ use lemmy_db_schema::{
     community_follower,
     community_person_ban,
     person,
-    person_alias_1,
     person_block,
     post,
   },
   source::{
-    comment::{Comment, CommentSaved},
+    comment::Comment,
     comment_reply::CommentReply,
-    community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe},
-    person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
-    person_block::PersonBlock,
+    community::{Community, CommunityFollower},
+    person::Person,
     post::Post,
   },
-  traits::{MaybeOptional, ToSafe, ViewToVec},
-  utils::{functions::hot_rank, limit_and_offset},
+  traits::JoinView,
+  utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
   CommentSortType,
+  SubscribedType,
 };
 
 type CommentReplyViewTuple = (
   CommentReply,
   Comment,
-  PersonSafe,
+  Person,
   Post,
-  CommunitySafe,
-  PersonSafeAlias1,
+  Community,
+  Person,
   CommentAggregates,
-  Option<CommunityPersonBan>,
-  Option<CommunityFollower>,
-  Option<CommentSaved>,
-  Option<PersonBlock>,
+  bool,
+  SubscribedType,
+  bool,
+  bool,
   Option<i16>,
 );
 
-impl CommentReplyView {
-  pub fn read(
-    conn: &PgConnection,
-    comment_reply_id: CommentReplyId,
-    my_person_id: Option<PersonId>,
-  ) -> Result<Self, Error> {
+fn queries<'a>() -> Queries<
+  impl ReadFn<'a, CommentReplyView, (CommentReplyId, Option<PersonId>)>,
+  impl ListFn<'a, CommentReplyView, CommentReplyQuery>,
+> {
+  let all_joins = |query: comment_reply::BoxedQuery<'a, Pg>, my_person_id: Option<PersonId>| {
     // The left join below will return None in this case
     let person_id_join = my_person_id.unwrap_or(PersonId(-1));
 
-    let (
-      comment_reply,
-      comment,
-      creator,
-      post,
-      community,
-      recipient,
-      counts,
-      creator_banned_from_community,
-      follower,
-      saved,
-      creator_blocked,
-      my_vote,
-    ) = comment_reply::table
-      .find(comment_reply_id)
+    query
       .inner_join(comment::table)
       .inner_join(person::table.on(comment::creator_id.eq(person::id)))
       .inner_join(post::table.on(comment::post_id.eq(post::id)))
       .inner_join(community::table.on(post::community_id.eq(community::id)))
-      .inner_join(person_alias_1::table)
+      .inner_join(aliases::person1)
       .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
       .left_join(
         community_person_ban::table.on(
           community::id
             .eq(community_person_ban::community_id)
-            .and(community_person_ban::person_id.eq(comment::creator_id))
-            .and(
-              community_person_ban::expires
-                .is_null()
-                .or(community_person_ban::expires.gt(now)),
-            ),
+            .and(community_person_ban::person_id.eq(comment::creator_id)),
         ),
       )
       .left_join(
@@ -118,227 +107,130 @@ impl CommentReplyView {
       .select((
         comment_reply::all_columns,
         comment::all_columns,
-        Person::safe_columns_tuple(),
+        person::all_columns,
         post::all_columns,
-        Community::safe_columns_tuple(),
-        PersonAlias1::safe_columns_tuple(),
+        community::all_columns,
+        aliases::person1.fields(person::all_columns),
         comment_aggregates::all_columns,
-        community_person_ban::all_columns.nullable(),
-        community_follower::all_columns.nullable(),
-        comment_saved::all_columns.nullable(),
-        person_block::all_columns.nullable(),
+        community_person_ban::id.nullable().is_not_null(),
+        CommunityFollower::select_subscribed_type(),
+        comment_saved::id.nullable().is_not_null(),
+        person_block::id.nullable().is_not_null(),
         comment_like::score.nullable(),
       ))
-      .first::<CommentReplyViewTuple>(conn)?;
-
-    Ok(CommentReplyView {
-      comment_reply,
-      comment,
-      creator,
-      post,
-      community,
-      recipient,
-      counts,
-      creator_banned_from_community: creator_banned_from_community.is_some(),
-      subscribed: CommunityFollower::to_subscribed_type(&follower),
-      saved: saved.is_some(),
-      creator_blocked: creator_blocked.is_some(),
-      my_vote,
-    })
-  }
-
-  /// Gets the number of unread replies
-  pub fn get_unread_replies(conn: &PgConnection, my_person_id: PersonId) -> Result<i64, Error> {
-    use diesel::dsl::*;
-
-    comment_reply::table
-      .filter(comment_reply::recipient_id.eq(my_person_id))
-      .filter(comment_reply::read.eq(false))
-      .select(count(comment_reply::id))
-      .first::<i64>(conn)
-  }
-}
-
-pub struct CommentReplyQueryBuilder<'a> {
-  conn: &'a PgConnection,
-  my_person_id: Option<PersonId>,
-  recipient_id: Option<PersonId>,
-  sort: Option<CommentSortType>,
-  unread_only: Option<bool>,
-  show_bot_accounts: Option<bool>,
-  page: Option<i64>,
-  limit: Option<i64>,
-}
-
-impl<'a> CommentReplyQueryBuilder<'a> {
-  pub fn create(conn: &'a PgConnection) -> Self {
-    CommentReplyQueryBuilder {
-      conn,
-      my_person_id: None,
-      recipient_id: None,
-      sort: None,
-      unread_only: None,
-      show_bot_accounts: None,
-      page: None,
-      limit: None,
-    }
-  }
-
-  pub fn sort<T: MaybeOptional<CommentSortType>>(mut self, sort: T) -> Self {
-    self.sort = sort.get_optional();
-    self
-  }
-
-  pub fn unread_only<T: MaybeOptional<bool>>(mut self, unread_only: T) -> Self {
-    self.unread_only = unread_only.get_optional();
-    self
-  }
-
-  pub fn show_bot_accounts<T: MaybeOptional<bool>>(mut self, show_bot_accounts: T) -> Self {
-    self.show_bot_accounts = show_bot_accounts.get_optional();
-    self
-  }
-
-  pub fn recipient_id<T: MaybeOptional<PersonId>>(mut self, recipient_id: T) -> Self {
-    self.recipient_id = recipient_id.get_optional();
-    self
-  }
-
-  pub fn my_person_id<T: MaybeOptional<PersonId>>(mut self, my_person_id: T) -> Self {
-    self.my_person_id = my_person_id.get_optional();
-    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<CommentReplyView>, Error> {
-    use diesel::dsl::*;
-
-    // The left join below will return None in this case
-    let person_id_join = self.my_person_id.unwrap_or(PersonId(-1));
-
-    let mut query = comment_reply::table
-      .inner_join(comment::table)
-      .inner_join(person::table.on(comment::creator_id.eq(person::id)))
-      .inner_join(post::table.on(comment::post_id.eq(post::id)))
-      .inner_join(community::table.on(post::community_id.eq(community::id)))
-      .inner_join(person_alias_1::table)
-      .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
-      .left_join(
-        community_person_ban::table.on(
-          community::id
-            .eq(community_person_ban::community_id)
-            .and(community_person_ban::person_id.eq(comment::creator_id))
-            .and(
-              community_person_ban::expires
-                .is_null()
-                .or(community_person_ban::expires.gt(now)),
-            ),
-        ),
-      )
-      .left_join(
-        community_follower::table.on(
-          post::community_id
-            .eq(community_follower::community_id)
-            .and(community_follower::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        comment_saved::table.on(
-          comment::id
-            .eq(comment_saved::comment_id)
-            .and(comment_saved::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        person_block::table.on(
-          comment::creator_id
-            .eq(person_block::target_id)
-            .and(person_block::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        comment_like::table.on(
-          comment::id
-            .eq(comment_like::comment_id)
-            .and(comment_like::person_id.eq(person_id_join)),
-        ),
+  };
+
+  let read =
+    move |mut conn: DbConn<'a>,
+          (comment_reply_id, my_person_id): (CommentReplyId, Option<PersonId>)| async move {
+      all_joins(
+        comment_reply::table.find(comment_reply_id).into_boxed(),
+        my_person_id,
       )
-      .select((
-        comment_reply::all_columns,
-        comment::all_columns,
-        Person::safe_columns_tuple(),
-        post::all_columns,
-        Community::safe_columns_tuple(),
-        PersonAlias1::safe_columns_tuple(),
-        comment_aggregates::all_columns,
-        community_person_ban::all_columns.nullable(),
-        community_follower::all_columns.nullable(),
-        comment_saved::all_columns.nullable(),
-        person_block::all_columns.nullable(),
-        comment_like::score.nullable(),
-      ))
-      .into_boxed();
+      .first::<CommentReplyViewTuple>(&mut conn)
+      .await
+    };
+
+  let list = move |mut conn: DbConn<'a>, options: CommentReplyQuery| async move {
+    let mut query = all_joins(comment_reply::table.into_boxed(), options.my_person_id);
 
-    if let Some(recipient_id) = self.recipient_id {
+    if let Some(recipient_id) = options.recipient_id {
       query = query.filter(comment_reply::recipient_id.eq(recipient_id));
     }
 
-    if self.unread_only.unwrap_or(false) {
+    if options.unread_only {
       query = query.filter(comment_reply::read.eq(false));
     }
 
-    if !self.show_bot_accounts.unwrap_or(true) {
+    if !options.show_bot_accounts {
       query = query.filter(person::bot_account.eq(false));
     };
 
-    query = match self.sort.unwrap_or(CommentSortType::Hot) {
-      CommentSortType::Hot => query
-        .then_order_by(hot_rank(comment_aggregates::score, comment_aggregates::published).desc())
-        .then_order_by(comment_aggregates::published.desc()),
-      CommentSortType::New => query.then_order_by(comment::published.desc()),
-      CommentSortType::Old => query.then_order_by(comment::published.asc()),
+    query = match options.sort.unwrap_or(CommentSortType::New) {
+      CommentSortType::Hot => query.then_order_by(comment_aggregates::hot_rank.desc()),
+      CommentSortType::Controversial => {
+        query.then_order_by(comment_aggregates::controversy_rank.desc())
+      }
+      CommentSortType::New => query.then_order_by(comment_reply::published.desc()),
+      CommentSortType::Old => query.then_order_by(comment_reply::published.asc()),
       CommentSortType::Top => query.order_by(comment_aggregates::score.desc()),
     };
 
-    let (limit, offset) = limit_and_offset(self.page, self.limit)?;
+    let (limit, offset) = limit_and_offset(options.page, options.limit)?;
 
-    let res = query
+    query
       .limit(limit)
       .offset(offset)
-      .load::<CommentReplyViewTuple>(self.conn)?;
+      .load::<CommentReplyViewTuple>(&mut conn)
+      .await
+  };
 
-    Ok(CommentReplyView::from_tuple_to_vec(res))
+  Queries::new(read, list)
+}
+
+impl CommentReplyView {
+  pub async fn read(
+    pool: &mut DbPool<'_>,
+    comment_reply_id: CommentReplyId,
+    my_person_id: Option<PersonId>,
+  ) -> Result<Self, Error> {
+    queries().read(pool, (comment_reply_id, my_person_id)).await
+  }
+
+  /// Gets the number of unread replies
+  pub async fn get_unread_replies(
+    pool: &mut DbPool<'_>,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
+    use diesel::dsl::count;
+
+    let conn = &mut get_conn(pool).await?;
+
+    comment_reply::table
+      .inner_join(comment::table)
+      .filter(comment_reply::recipient_id.eq(my_person_id))
+      .filter(comment_reply::read.eq(false))
+      .filter(comment::deleted.eq(false))
+      .filter(comment::removed.eq(false))
+      .select(count(comment_reply::id))
+      .first::<i64>(conn)
+      .await
   }
 }
 
-impl ViewToVec for CommentReplyView {
-  type DbTuple = CommentReplyViewTuple;
-  fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
-    items
-      .into_iter()
-      .map(|a| Self {
-        comment_reply: a.0,
-        comment: a.1,
-        creator: a.2,
-        post: a.3,
-        community: a.4,
-        recipient: a.5,
-        counts: a.6,
-        creator_banned_from_community: a.7.is_some(),
-        subscribed: CommunityFollower::to_subscribed_type(&a.8),
-        saved: a.9.is_some(),
-        creator_blocked: a.10.is_some(),
-        my_vote: a.11,
-      })
-      .collect::<Vec<Self>>()
+#[derive(Default)]
+pub struct CommentReplyQuery {
+  pub my_person_id: Option<PersonId>,
+  pub recipient_id: Option<PersonId>,
+  pub sort: Option<CommentSortType>,
+  pub unread_only: bool,
+  pub show_bot_accounts: bool,
+  pub page: Option<i64>,
+  pub limit: Option<i64>,
+}
+
+impl CommentReplyQuery {
+  pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<CommentReplyView>, Error> {
+    queries().list(pool, self).await
+  }
+}
+
+impl JoinView for CommentReplyView {
+  type JoinTuple = CommentReplyViewTuple;
+  fn from_tuple(a: Self::JoinTuple) -> Self {
+    Self {
+      comment_reply: a.0,
+      comment: a.1,
+      creator: a.2,
+      post: a.3,
+      community: a.4,
+      recipient: a.5,
+      counts: a.6,
+      creator_banned_from_community: a.7,
+      subscribed: a.8,
+      saved: a.9,
+      creator_blocked: a.10,
+      my_vote: a.11,
+    }
   }
 }