crates/db_views/src/private_message_view.rs

   1 use crate::structs::PrivateMessageView;
   2 use diesel::{
   3   debug_query,
   4   pg::Pg,
   5   result::Error,
   6   BoolExpressionMethods,
   7   ExpressionMethods,
   8   JoinOnDsl,
   9   QueryDsl,
  10 };
  11 use diesel_async::RunQueryDsl;
  12 use lemmy_db_schema::{
  13   newtypes::{PersonId, PrivateMessageId},
  14   schema::{person, private_message},
  15   source::{person::Person, private_message::PrivateMessage},
  16   traits::JoinView,
  17   utils::{get_conn, limit_and_offset, DbPool},
  18 };
  19 use tracing::debug;
  20 use typed_builder::TypedBuilder;
  21
  22 type PrivateMessageViewTuple = (PrivateMessage, Person, Person);
  23
  24 impl PrivateMessageView {
  25   pub async fn read(
  26     pool: &mut DbPool<'_>,
  27     private_message_id: PrivateMessageId,
  28   ) -> Result<Self, Error> {
  29     let conn = &mut get_conn(pool).await?;
  30     let person_alias_1 = diesel::alias!(person as person1);
  31
  32     let (private_message, creator, recipient) = private_message::table
  33       .find(private_message_id)
  34       .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
  35       .inner_join(
  36         person_alias_1.on(private_message::recipient_id.eq(person_alias_1.field(person::id))),
  37       )
  38       .order_by(private_message::published.desc())
  39       .select((
  40         private_message::all_columns,
  41         person::all_columns,
  42         person_alias_1.fields(person::all_columns),
  43       ))
  44       .first::<PrivateMessageViewTuple>(conn)
  45       .await?;
  46
  47     Ok(PrivateMessageView {
  48       private_message,
  49       creator,
  50       recipient,
  51     })
  52   }
  53
  54   /// Gets the number of unread messages
  55   pub async fn get_unread_messages(
  56     pool: &mut DbPool<'_>,
  57     my_person_id: PersonId,
  58   ) -> Result<i64, Error> {
  59     use diesel::dsl::count;
  60     let conn = &mut get_conn(pool).await?;
  61     private_message::table
  62       .filter(private_message::read.eq(false))
  63       .filter(private_message::recipient_id.eq(my_person_id))
  64       .filter(private_message::deleted.eq(false))
  65       .select(count(private_message::id))
  66       .first::<i64>(conn)
  67       .await
  68   }
  69 }
  70
  71 #[derive(TypedBuilder)]
  72 #[builder(field_defaults(default))]
  73 pub struct PrivateMessageQuery<'a, 'b: 'a> {
  74   #[builder(!default)]
  75   pool: &'a mut DbPool<'b>,
  76   #[builder(!default)]
  77   recipient_id: PersonId,
  78   unread_only: Option<bool>,
  79   page: Option<i64>,
  80   limit: Option<i64>,
  81 }
  82
  83 impl<'a, 'b: 'a> PrivateMessageQuery<'a, 'b> {
  84   pub async fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
  85     let conn = &mut get_conn(self.pool).await?;
  86     let person_alias_1 = diesel::alias!(person as person1);
  87
  88     let mut query = private_message::table
  89       .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
  90       .inner_join(
  91         person_alias_1.on(private_message::recipient_id.eq(person_alias_1.field(person::id))),
  92       )
  93       .select((
  94         private_message::all_columns,
  95         person::all_columns,
  96         person_alias_1.fields(person::all_columns),
  97       ))
  98       .into_boxed();
  99
 100     // If its unread, I only want the ones to me
 101     if self.unread_only.unwrap_or(false) {
 102       query = query
 103         .filter(private_message::read.eq(false))
 104         .filter(private_message::recipient_id.eq(self.recipient_id));
 105     }
 106     // Otherwise, I want the ALL view to show both sent and received
 107     else {
 108       query = query.filter(
 109         private_message::recipient_id
 110           .eq(self.recipient_id)
 111           .or(private_message::creator_id.eq(self.recipient_id)),
 112       )
 113     }
 114
 115     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 116
 117     query = query
 118       .filter(private_message::deleted.eq(false))
 119       .limit(limit)
 120       .offset(offset)
 121       .order_by(private_message::published.desc());
 122
 123     debug!(
 124       "Private Message View Query: {:?}",
 125       debug_query::<Pg, _>(&query)
 126     );
 127
 128     let res = query.load::<PrivateMessageViewTuple>(conn).await?;
 129
 130     Ok(
 131       res
 132         .into_iter()
 133         .map(PrivateMessageView::from_tuple)
 134         .collect(),
 135     )
 136   }
 137 }
 138
 139 impl JoinView for PrivateMessageView {
 140   type JoinTuple = PrivateMessageViewTuple;
 141   fn from_tuple(a: Self::JoinTuple) -> Self {
 142     Self {
 143       private_message: a.0,
 144       creator: a.1,
 145       recipient: a.2,
 146     }
 147   }
 148 }