crates/db_views_actor/src/comment_reply_view.rs

   1 use crate::structs::CommentReplyView;
   2 use diesel::{
   3   result::Error,
   4   BoolExpressionMethods,
   5   ExpressionMethods,
   6   JoinOnDsl,
   7   NullableExpressionMethods,
   8   QueryDsl,
   9 };
  10 use diesel_async::RunQueryDsl;
  11 use lemmy_db_schema::{
  12   aggregates::structs::CommentAggregates,
  13   newtypes::{CommentReplyId, PersonId},
  14   schema::{
  15     comment,
  16     comment_aggregates,
  17     comment_like,
  18     comment_reply,
  19     comment_saved,
  20     community,
  21     community_follower,
  22     community_person_ban,
  23     person,
  24     person_block,
  25     post,
  26   },
  27   source::{
  28     comment::{Comment, CommentSaved},
  29     comment_reply::CommentReply,
  30     community::{Community, CommunityFollower, CommunityPersonBan},
  31     person::Person,
  32     person_block::PersonBlock,
  33     post::Post,
  34   },
  35   traits::JoinView,
  36   utils::{get_conn, limit_and_offset, DbPool},
  37   CommentSortType,
  38 };
  39 use typed_builder::TypedBuilder;
  40
  41 type CommentReplyViewTuple = (
  42   CommentReply,
  43   Comment,
  44   Person,
  45   Post,
  46   Community,
  47   Person,
  48   CommentAggregates,
  49   Option<CommunityPersonBan>,
  50   Option<CommunityFollower>,
  51   Option<CommentSaved>,
  52   Option<PersonBlock>,
  53   Option<i16>,
  54 );
  55
  56 impl CommentReplyView {
  57   pub async fn read(
  58     pool: &DbPool,
  59     comment_reply_id: CommentReplyId,
  60     my_person_id: Option<PersonId>,
  61   ) -> Result<Self, Error> {
  62     let conn = &mut get_conn(pool).await?;
  63     let person_alias_1 = diesel::alias!(person as person1);
  64
  65     // The left join below will return None in this case
  66     let person_id_join = my_person_id.unwrap_or(PersonId(-1));
  67
  68     let (
  69       comment_reply,
  70       comment,
  71       creator,
  72       post,
  73       community,
  74       recipient,
  75       counts,
  76       creator_banned_from_community,
  77       follower,
  78       saved,
  79       creator_blocked,
  80       my_vote,
  81     ) = comment_reply::table
  82       .find(comment_reply_id)
  83       .inner_join(comment::table)
  84       .inner_join(person::table.on(comment::creator_id.eq(person::id)))
  85       .inner_join(post::table.on(comment::post_id.eq(post::id)))
  86       .inner_join(community::table.on(post::community_id.eq(community::id)))
  87       .inner_join(person_alias_1)
  88       .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
  89       .left_join(
  90         community_person_ban::table.on(
  91           community::id
  92             .eq(community_person_ban::community_id)
  93             .and(community_person_ban::person_id.eq(comment::creator_id)),
  94         ),
  95       )
  96       .left_join(
  97         community_follower::table.on(
  98           post::community_id
  99             .eq(community_follower::community_id)
 100             .and(community_follower::person_id.eq(person_id_join)),
 101         ),
 102       )
 103       .left_join(
 104         comment_saved::table.on(
 105           comment::id
 106             .eq(comment_saved::comment_id)
 107             .and(comment_saved::person_id.eq(person_id_join)),
 108         ),
 109       )
 110       .left_join(
 111         person_block::table.on(
 112           comment::creator_id
 113             .eq(person_block::target_id)
 114             .and(person_block::person_id.eq(person_id_join)),
 115         ),
 116       )
 117       .left_join(
 118         comment_like::table.on(
 119           comment::id
 120             .eq(comment_like::comment_id)
 121             .and(comment_like::person_id.eq(person_id_join)),
 122         ),
 123       )
 124       .select((
 125         comment_reply::all_columns,
 126         comment::all_columns,
 127         person::all_columns,
 128         post::all_columns,
 129         community::all_columns,
 130         person_alias_1.fields(person::all_columns),
 131         comment_aggregates::all_columns,
 132         community_person_ban::all_columns.nullable(),
 133         community_follower::all_columns.nullable(),
 134         comment_saved::all_columns.nullable(),
 135         person_block::all_columns.nullable(),
 136         comment_like::score.nullable(),
 137       ))
 138       .first::<CommentReplyViewTuple>(conn)
 139       .await?;
 140
 141     Ok(CommentReplyView {
 142       comment_reply,
 143       comment,
 144       creator,
 145       post,
 146       community,
 147       recipient,
 148       counts,
 149       creator_banned_from_community: creator_banned_from_community.is_some(),
 150       subscribed: CommunityFollower::to_subscribed_type(&follower),
 151       saved: saved.is_some(),
 152       creator_blocked: creator_blocked.is_some(),
 153       my_vote,
 154     })
 155   }
 156
 157   /// Gets the number of unread replies
 158   pub async fn get_unread_replies(pool: &DbPool, my_person_id: PersonId) -> Result<i64, Error> {
 159     use diesel::dsl::count;
 160
 161     let conn = &mut get_conn(pool).await?;
 162
 163     comment_reply::table
 164       .inner_join(comment::table)
 165       .filter(comment_reply::recipient_id.eq(my_person_id))
 166       .filter(comment_reply::read.eq(false))
 167       .filter(comment::deleted.eq(false))
 168       .filter(comment::removed.eq(false))
 169       .select(count(comment_reply::id))
 170       .first::<i64>(conn)
 171       .await
 172   }
 173 }
 174
 175 #[derive(TypedBuilder)]
 176 #[builder(field_defaults(default))]
 177 pub struct CommentReplyQuery<'a> {
 178   #[builder(!default)]
 179   pool: &'a DbPool,
 180   my_person_id: Option<PersonId>,
 181   recipient_id: Option<PersonId>,
 182   sort: Option<CommentSortType>,
 183   unread_only: Option<bool>,
 184   show_bot_accounts: Option<bool>,
 185   page: Option<i64>,
 186   limit: Option<i64>,
 187 }
 188
 189 impl<'a> CommentReplyQuery<'a> {
 190   pub async fn list(self) -> Result<Vec<CommentReplyView>, Error> {
 191     let conn = &mut get_conn(self.pool).await?;
 192
 193     let person_alias_1 = diesel::alias!(person as person1);
 194
 195     // The left join below will return None in this case
 196     let person_id_join = self.my_person_id.unwrap_or(PersonId(-1));
 197
 198     let mut query = comment_reply::table
 199       .inner_join(comment::table)
 200       .inner_join(person::table.on(comment::creator_id.eq(person::id)))
 201       .inner_join(post::table.on(comment::post_id.eq(post::id)))
 202       .inner_join(community::table.on(post::community_id.eq(community::id)))
 203       .inner_join(person_alias_1)
 204       .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
 205       .left_join(
 206         community_person_ban::table.on(
 207           community::id
 208             .eq(community_person_ban::community_id)
 209             .and(community_person_ban::person_id.eq(comment::creator_id)),
 210         ),
 211       )
 212       .left_join(
 213         community_follower::table.on(
 214           post::community_id
 215             .eq(community_follower::community_id)
 216             .and(community_follower::person_id.eq(person_id_join)),
 217         ),
 218       )
 219       .left_join(
 220         comment_saved::table.on(
 221           comment::id
 222             .eq(comment_saved::comment_id)
 223             .and(comment_saved::person_id.eq(person_id_join)),
 224         ),
 225       )
 226       .left_join(
 227         person_block::table.on(
 228           comment::creator_id
 229             .eq(person_block::target_id)
 230             .and(person_block::person_id.eq(person_id_join)),
 231         ),
 232       )
 233       .left_join(
 234         comment_like::table.on(
 235           comment::id
 236             .eq(comment_like::comment_id)
 237             .and(comment_like::person_id.eq(person_id_join)),
 238         ),
 239       )
 240       .select((
 241         comment_reply::all_columns,
 242         comment::all_columns,
 243         person::all_columns,
 244         post::all_columns,
 245         community::all_columns,
 246         person_alias_1.fields(person::all_columns),
 247         comment_aggregates::all_columns,
 248         community_person_ban::all_columns.nullable(),
 249         community_follower::all_columns.nullable(),
 250         comment_saved::all_columns.nullable(),
 251         person_block::all_columns.nullable(),
 252         comment_like::score.nullable(),
 253       ))
 254       .into_boxed();
 255
 256     if let Some(recipient_id) = self.recipient_id {
 257       query = query.filter(comment_reply::recipient_id.eq(recipient_id));
 258     }
 259
 260     if self.unread_only.unwrap_or(false) {
 261       query = query.filter(comment_reply::read.eq(false));
 262     }
 263
 264     if !self.show_bot_accounts.unwrap_or(true) {
 265       query = query.filter(person::bot_account.eq(false));
 266     };
 267
 268     query = match self.sort.unwrap_or(CommentSortType::New) {
 269       CommentSortType::Hot => query.then_order_by(comment_aggregates::hot_rank.desc()),
 270       CommentSortType::New => query.then_order_by(comment_reply::published.desc()),
 271       CommentSortType::Old => query.then_order_by(comment_reply::published.asc()),
 272       CommentSortType::Top => query.order_by(comment_aggregates::score.desc()),
 273     };
 274
 275     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 276
 277     let res = query
 278       .limit(limit)
 279       .offset(offset)
 280       .load::<CommentReplyViewTuple>(conn)
 281       .await?;
 282
 283     Ok(res.into_iter().map(CommentReplyView::from_tuple).collect())
 284   }
 285 }
 286
 287 impl JoinView for CommentReplyView {
 288   type JoinTuple = CommentReplyViewTuple;
 289   fn from_tuple(a: Self::JoinTuple) -> Self {
 290     Self {
 291       comment_reply: a.0,
 292       comment: a.1,
 293       creator: a.2,
 294       post: a.3,
 295       community: a.4,
 296       recipient: a.5,
 297       counts: a.6,
 298       creator_banned_from_community: a.7.is_some(),
 299       subscribed: CommunityFollower::to_subscribed_type(&a.8),
 300       saved: a.9.is_some(),
 301       creator_blocked: a.10.is_some(),
 302       my_vote: a.11,
 303     }
 304   }
 305 }