server/lemmy_db/src/private_message_view.rs

   1 use crate::{limit_and_offset, MaybeOptional};
   2 use diesel::{pg::Pg, result::Error, *};
   3 use serde::{Deserialize, Serialize};
   4
   5 // The faked schema since diesel doesn't do views
   6 table! {
   7   private_message_view (id) {
   8     id -> Int4,
   9     creator_id -> Int4,
  10     recipient_id -> Int4,
  11     content -> Text,
  12     deleted -> Bool,
  13     read -> Bool,
  14     published -> Timestamp,
  15     updated -> Nullable<Timestamp>,
  16     ap_id -> Text,
  17     local -> Bool,
  18     creator_name -> Varchar,
  19     creator_avatar -> Nullable<Text>,
  20     creator_actor_id -> Text,
  21     creator_local -> Bool,
  22     recipient_name -> Varchar,
  23     recipient_avatar -> Nullable<Text>,
  24     recipient_actor_id -> Text,
  25     recipient_local -> Bool,
  26   }
  27 }
  28
  29 #[derive(
  30   Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone,
  31 )]
  32 #[table_name = "private_message_view"]
  33 pub struct PrivateMessageView {
  34   pub id: i32,
  35   pub creator_id: i32,
  36   pub recipient_id: i32,
  37   pub content: String,
  38   pub deleted: bool,
  39   pub read: bool,
  40   pub published: chrono::NaiveDateTime,
  41   pub updated: Option<chrono::NaiveDateTime>,
  42   pub ap_id: String,
  43   pub local: bool,
  44   pub creator_name: String,
  45   pub creator_avatar: Option<String>,
  46   pub creator_actor_id: String,
  47   pub creator_local: bool,
  48   pub recipient_name: String,
  49   pub recipient_avatar: Option<String>,
  50   pub recipient_actor_id: String,
  51   pub recipient_local: bool,
  52 }
  53
  54 pub struct PrivateMessageQueryBuilder<'a> {
  55   conn: &'a PgConnection,
  56   query: super::private_message_view::private_message_view::BoxedQuery<'a, Pg>,
  57   for_recipient_id: i32,
  58   unread_only: bool,
  59   page: Option<i64>,
  60   limit: Option<i64>,
  61 }
  62
  63 impl<'a> PrivateMessageQueryBuilder<'a> {
  64   pub fn create(conn: &'a PgConnection, for_recipient_id: i32) -> Self {
  65     use super::private_message_view::private_message_view::dsl::*;
  66
  67     let query = private_message_view.into_boxed();
  68
  69     PrivateMessageQueryBuilder {
  70       conn,
  71       query,
  72       for_recipient_id,
  73       unread_only: false,
  74       page: None,
  75       limit: None,
  76     }
  77   }
  78
  79   pub fn unread_only(mut self, unread_only: bool) -> Self {
  80     self.unread_only = unread_only;
  81     self
  82   }
  83
  84   pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
  85     self.page = page.get_optional();
  86     self
  87   }
  88
  89   pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
  90     self.limit = limit.get_optional();
  91     self
  92   }
  93
  94   pub fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
  95     use super::private_message_view::private_message_view::dsl::*;
  96
  97     let mut query = self.query.filter(deleted.eq(false));
  98
  99     // If its unread, I only want the ones to me
 100     if self.unread_only {
 101       query = query
 102         .filter(read.eq(false))
 103         .filter(recipient_id.eq(self.for_recipient_id));
 104     }
 105     // Otherwise, I want the ALL view to show both sent and received
 106     else {
 107       query = query.filter(
 108         recipient_id
 109           .eq(self.for_recipient_id)
 110           .or(creator_id.eq(self.for_recipient_id)),
 111       )
 112     }
 113
 114     let (limit, offset) = limit_and_offset(self.page, self.limit);
 115
 116     query
 117       .limit(limit)
 118       .offset(offset)
 119       .order_by(published.desc())
 120       .load::<PrivateMessageView>(self.conn)
 121   }
 122 }
 123
 124 impl PrivateMessageView {
 125   pub fn read(conn: &PgConnection, from_private_message_id: i32) -> Result<Self, Error> {
 126     use super::private_message_view::private_message_view::dsl::*;
 127
 128     let mut query = private_message_view.into_boxed();
 129
 130     query = query
 131       .filter(id.eq(from_private_message_id))
 132       .order_by(published.desc());
 133
 134     query.first::<Self>(conn)
 135   }
 136 }