Diesel 2.0.0 upgrade (#2452)

[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 7e322bbc71f5380c9b9d4a63a5c1a5b05c90da3a..281df8ba6b358d95f54e6842648d5e6304819499 100644 (file)
--- a/crates/db_views/src/private_message_view.rs
+++ b/crates/db_views/src/private_message_view.rs
@@ -1,37 +1,38 @@
+use crate::structs::PrivateMessageView;
 use diesel::{pg::Pg, result::Error, *};
-use lemmy_db_queries::{limit_and_offset, MaybeOptional, ToSafe, ViewToVec};
 use lemmy_db_schema::{
-  schema::{person, person_alias_1, private_message},
+  newtypes::{PersonId, PrivateMessageId},
+  schema::{person, private_message},
   source::{
-    person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
+    person::{Person, PersonSafe},
     private_message::PrivateMessage,
   },
-  PersonId,
-  PrivateMessageId,
+  traits::{ToSafe, ViewToVec},
+  utils::limit_and_offset,
 };
-use log::debug;
-use serde::{Deserialize, Serialize};
+use tracing::debug;
+use typed_builder::TypedBuilder;
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
-pub struct PrivateMessageView {
-  pub private_message: PrivateMessage,
-  pub creator: PersonSafe,
-  pub recipient: PersonSafeAlias1,
-}
-
-type PrivateMessageViewTuple = (PrivateMessage, PersonSafe, PersonSafeAlias1);
+type PrivateMessageViewTuple = (PrivateMessage, PersonSafe, PersonSafe);
 
 impl PrivateMessageView {
-  pub fn read(conn: &PgConnection, private_message_id: PrivateMessageId) -> Result<Self, Error> {
+  pub fn read(
+    conn: &mut PgConnection,
+    private_message_id: PrivateMessageId,
+  ) -> Result<Self, Error> {
+    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_alias_1.fields(Person::safe_columns_tuple()),
       ))
       .first::<PrivateMessageViewTuple>(conn)?;
 
@@ -43,7 +44,10 @@ impl PrivateMessageView {
   }
 
   /// Gets the number of unread messages
-  pub fn get_unread_messages(conn: &PgConnection, my_person_id: PersonId) -> Result<i64, Error> {
+  pub fn get_unread_messages(
+    conn: &mut PgConnection,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
     use diesel::dsl::*;
     private_message::table
       .filter(private_message::read.eq(false))
@@ -54,48 +58,31 @@ impl PrivateMessageView {
   }
 }
 
-pub struct PrivateMessageQueryBuilder<'a> {
-  conn: &'a PgConnection,
+#[derive(TypedBuilder)]
+#[builder(field_defaults(default))]
+pub struct PrivateMessageQuery<'a> {
+  #[builder(!default)]
+  conn: &'a mut PgConnection,
+  #[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
-  }
-
-  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
-  }
-
+impl<'a> PrivateMessageQuery<'a> {
   pub fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
+    let person_alias_1 = diesel::alias!(person as person1);
+
     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_alias_1.fields(Person::safe_columns_tuple()),
       ))
       .into_boxed();
 
@@ -114,7 +101,7 @@ impl<'a> PrivateMessageQueryBuilder<'a> {
       )
     }
 
-    let (limit, offset) = limit_and_offset(self.page, self.limit);
+    let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 
     query = query
       .filter(private_message::deleted.eq(false))
@@ -137,11 +124,11 @@ impl ViewToVec for PrivateMessageView {
   type DbTuple = PrivateMessageViewTuple;
   fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
     items
-      .iter()
+      .into_iter()
       .map(|a| Self {
-        private_message: a.0.to_owned(),
-        creator: a.1.to_owned(),
-        recipient: a.2.to_owned(),
+        private_message: a.0,
+        creator: a.1,
+        recipient: a.2,
       })
       .collect::<Vec<Self>>()
   }