Make functions work with both connection and pool (#3420)

[lemmy.git] / crates / db_views / src / private_message_view.rs

diff --git a/crates/db_views/src/private_message_view.rs b/crates/db_views/src/private_message_view.rs
index 185bd30224d747a3cd069b8ae1b54bfdc1ac7fe9..3d8fd42d0305028e2632fab65fe677e2fe5077d3 100644 (file)
--- a/crates/db_views/src/private_message_view.rs
+++ b/crates/db_views/src/private_message_view.rs
@@ -1,32 +1,48 @@
 use crate::structs::PrivateMessageView;
-use diesel::{pg::Pg, result::Error, *};
+use diesel::{
+  debug_query,
+  pg::Pg,
+  result::Error,
+  BoolExpressionMethods,
+  ExpressionMethods,
+  JoinOnDsl,
+  QueryDsl,
+};
+use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{PersonId, PrivateMessageId},
-  schema::{person, person_alias_1, private_message},
-  source::{
-    person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
-    private_message::PrivateMessage,
-  },
-  traits::{MaybeOptional, ToSafe, ViewToVec},
-  utils::limit_and_offset,
+  schema::{person, private_message},
+  source::{person::Person, private_message::PrivateMessage},
+  traits::JoinView,
+  utils::{get_conn, limit_and_offset, DbPool},
 };
 use tracing::debug;
+use typed_builder::TypedBuilder;
 
-type PrivateMessageViewTuple = (PrivateMessage, PersonSafe, PersonSafeAlias1);
+type PrivateMessageViewTuple = (PrivateMessage, Person, Person);
 
 impl PrivateMessageView {
-  pub fn read(conn: &PgConnection, private_message_id: PrivateMessageId) -> Result<Self, Error> {
+  pub async fn read(
+    pool: &mut DbPool<'_>,
+    private_message_id: PrivateMessageId,
+  ) -> Result<Self, Error> {
+    let conn = &mut get_conn(pool).await?;
+    let person_alias_1 = diesel::alias!(person as person1);
+
     let (private_message, creator, recipient) = private_message::table
       .find(private_message_id)
       .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
-      .inner_join(person_alias_1::table.on(private_message::recipient_id.eq(person_alias_1::id)))
+      .inner_join(
+        person_alias_1.on(private_message::recipient_id.eq(person_alias_1.field(person::id))),
+      )
       .order_by(private_message::published.desc())
       .select((
         private_message::all_columns,
-        Person::safe_columns_tuple(),
-        PersonAlias1::safe_columns_tuple(),
+        person::all_columns,
+        person_alias_1.fields(person::all_columns),
       ))
-      .first::<PrivateMessageViewTuple>(conn)?;
+      .first::<PrivateMessageViewTuple>(conn)
+      .await?;
 
     Ok(PrivateMessageView {
       private_message,
@@ -36,59 +52,48 @@ impl PrivateMessageView {
   }
 
   /// Gets the number of unread messages
-  pub fn get_unread_messages(conn: &PgConnection, my_person_id: PersonId) -> Result<i64, Error> {
-    use diesel::dsl::*;
+  pub async fn get_unread_messages(
+    pool: &mut DbPool<'_>,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
+    use diesel::dsl::count;
+    let conn = &mut get_conn(pool).await?;
     private_message::table
       .filter(private_message::read.eq(false))
       .filter(private_message::recipient_id.eq(my_person_id))
       .filter(private_message::deleted.eq(false))
       .select(count(private_message::id))
       .first::<i64>(conn)
+      .await
   }
 }
 
-pub struct PrivateMessageQueryBuilder<'a> {
-  conn: &'a PgConnection,
+#[derive(TypedBuilder)]
+#[builder(field_defaults(default))]
+pub struct PrivateMessageQuery<'a, 'b: 'a> {
+  #[builder(!default)]
+  pool: &'a mut DbPool<'b>,
+  #[builder(!default)]
   recipient_id: PersonId,
   unread_only: Option<bool>,
   page: Option<i64>,
   limit: Option<i64>,
 }
 
-impl<'a> PrivateMessageQueryBuilder<'a> {
-  pub fn create(conn: &'a PgConnection, recipient_id: PersonId) -> Self {
-    PrivateMessageQueryBuilder {
-      conn,
-      recipient_id,
-      unread_only: None,
-      page: None,
-      limit: None,
-    }
-  }
-
-  pub fn unread_only<T: MaybeOptional<bool>>(mut self, unread_only: T) -> Self {
-    self.unread_only = unread_only.get_optional();
-    self
-  }
+impl<'a, 'b: 'a> PrivateMessageQuery<'a, 'b> {
+  pub async fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
+    let conn = &mut get_conn(self.pool).await?;
+    let person_alias_1 = diesel::alias!(person as person1);
 
-  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<PrivateMessageView>, Error> {
     let mut query = private_message::table
       .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
-      .inner_join(person_alias_1::table.on(private_message::recipient_id.eq(person_alias_1::id)))
+      .inner_join(
+        person_alias_1.on(private_message::recipient_id.eq(person_alias_1.field(person::id))),
+      )
       .select((
         private_message::all_columns,
-        Person::safe_columns_tuple(),
-        PersonAlias1::safe_columns_tuple(),
+        person::all_columns,
+        person_alias_1.fields(person::all_columns),
       ))
       .into_boxed();
 
@@ -120,22 +125,24 @@ impl<'a> PrivateMessageQueryBuilder<'a> {
       debug_query::<Pg, _>(&query)
     );
 
-    let res = query.load::<PrivateMessageViewTuple>(self.conn)?;
+    let res = query.load::<PrivateMessageViewTuple>(conn).await?;
 
-    Ok(PrivateMessageView::from_tuple_to_vec(res))
+    Ok(
+      res
+        .into_iter()
+        .map(PrivateMessageView::from_tuple)
+        .collect(),
+    )
   }
 }
 
-impl ViewToVec for PrivateMessageView {
-  type DbTuple = PrivateMessageViewTuple;
-  fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
-    items
-      .iter()
-      .map(|a| Self {
-        private_message: a.0.to_owned(),
-        creator: a.1.to_owned(),
-        recipient: a.2.to_owned(),
-      })
-      .collect::<Vec<Self>>()
+impl JoinView for PrivateMessageView {
+  type JoinTuple = PrivateMessageViewTuple;
+  fn from_tuple(a: Self::JoinTuple) -> Self {
+    Self {
+      private_message: a.0,
+      creator: a.1,
+      recipient: a.2,
+    }
   }
 }