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