diesel_option_overwrite,
naive_now,
post_report::PostReportView,
- private_message_view::*,
source::{
comment::*,
community::*,
community_moderator_view::CommunityModeratorView,
},
post_view::PostQueryBuilder,
+ private_message_view::{PrivateMessageQueryBuilder, PrivateMessageView},
site_view::SiteView,
user_mention_view::{UserMentionQueryBuilder, UserMentionView},
user_view::{UserViewDangerous, UserViewSafe},
PrivateMessageView::read(conn, edit_id)
})
.await??;
- let recipient_id = message.recipient_id;
+ let recipient_id = message.recipient.id;
let res = PrivateMessageResponse { message };
PrivateMessageView::read(conn, edit_id)
})
.await??;
- let recipient_id = message.recipient_id;
+ let recipient_id = message.recipient.id;
let res = PrivateMessageResponse { message };
PrivateMessageView::read(conn, edit_id)
})
.await??;
- let recipient_id = message.recipient_id;
+ let recipient_id = message.recipient.id;
let res = PrivateMessageResponse { message };
public,
};
use anyhow::{anyhow, Context};
-use lemmy_db::{private_message_view::PrivateMessageView, source::private_message::PrivateMessage};
+use lemmy_db::{
+ source::private_message::PrivateMessage,
+ views::private_message_view::PrivateMessageView,
+};
use lemmy_structs::{blocking, user::PrivateMessageResponse};
use lemmy_utils::{location_info, LemmyError};
use lemmy_websocket::{messages::SendUserRoomMessage, LemmyContext, UserOperation};
let res = PrivateMessageResponse { message };
- let recipient_id = res.message.recipient_id;
+ let recipient_id = res.message.recipient.id;
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::CreatePrivateMessage,
let res = PrivateMessageResponse { message };
- let recipient_id = res.message.recipient_id;
+ let recipient_id = res.message.recipient.id;
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::EditPrivateMessage,
.await??;
let res = PrivateMessageResponse { message };
- let recipient_id = res.message.recipient_id;
+ let recipient_id = res.message.recipient.id;
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::EditPrivateMessage,
response: res,
.await??;
let res = PrivateMessageResponse { message };
- let recipient_id = res.message.recipient_id;
+ let recipient_id = res.message.recipient.id;
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::EditPrivateMessage,
response: res,
pub mod comment_report;
pub mod post_report;
-pub mod private_message_view;
pub mod aggregates;
pub mod schema;
+++ /dev/null
-use crate::{limit_and_offset, MaybeOptional};
-use diesel::{pg::Pg, result::Error, *};
-use serde::Serialize;
-
-// The faked schema since diesel doesn't do views
-table! {
- private_message_view (id) {
- id -> Int4,
- creator_id -> Int4,
- recipient_id -> Int4,
- content -> Text,
- deleted -> Bool,
- read -> Bool,
- published -> Timestamp,
- updated -> Nullable<Timestamp>,
- ap_id -> Text,
- local -> Bool,
- creator_name -> Varchar,
- creator_preferred_username -> Nullable<Varchar>,
- creator_avatar -> Nullable<Text>,
- creator_actor_id -> Text,
- creator_local -> Bool,
- recipient_name -> Varchar,
- recipient_preferred_username -> Nullable<Varchar>,
- recipient_avatar -> Nullable<Text>,
- recipient_actor_id -> Text,
- recipient_local -> Bool,
- }
-}
-
-#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, QueryableByName, Clone)]
-#[table_name = "private_message_view"]
-pub struct PrivateMessageView {
- pub id: i32,
- pub creator_id: i32,
- pub recipient_id: i32,
- pub content: String,
- pub deleted: bool,
- pub read: bool,
- pub published: chrono::NaiveDateTime,
- pub updated: Option<chrono::NaiveDateTime>,
- pub ap_id: String,
- pub local: bool,
- pub creator_name: String,
- pub creator_preferred_username: Option<String>,
- pub creator_avatar: Option<String>,
- pub creator_actor_id: String,
- pub creator_local: bool,
- pub recipient_name: String,
- pub recipient_preferred_username: Option<String>,
- pub recipient_avatar: Option<String>,
- pub recipient_actor_id: String,
- pub recipient_local: bool,
-}
-
-pub struct PrivateMessageQueryBuilder<'a> {
- conn: &'a PgConnection,
- query: super::private_message_view::private_message_view::BoxedQuery<'a, Pg>,
- for_recipient_id: i32,
- unread_only: bool,
- page: Option<i64>,
- limit: Option<i64>,
-}
-
-impl<'a> PrivateMessageQueryBuilder<'a> {
- pub fn create(conn: &'a PgConnection, for_recipient_id: i32) -> Self {
- use super::private_message_view::private_message_view::dsl::*;
-
- let query = private_message_view.into_boxed();
-
- PrivateMessageQueryBuilder {
- conn,
- query,
- for_recipient_id,
- unread_only: false,
- page: None,
- limit: None,
- }
- }
-
- pub fn unread_only(mut self, unread_only: bool) -> Self {
- self.unread_only = unread_only;
- 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
- }
-
- pub fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
- use super::private_message_view::private_message_view::dsl::*;
-
- let mut query = self.query.filter(deleted.eq(false));
-
- // If its unread, I only want the ones to me
- if self.unread_only {
- query = query
- .filter(read.eq(false))
- .filter(recipient_id.eq(self.for_recipient_id));
- }
- // Otherwise, I want the ALL view to show both sent and received
- else {
- query = query.filter(
- recipient_id
- .eq(self.for_recipient_id)
- .or(creator_id.eq(self.for_recipient_id)),
- )
- }
-
- let (limit, offset) = limit_and_offset(self.page, self.limit);
-
- query
- .limit(limit)
- .offset(offset)
- .order_by(published.desc())
- .load::<PrivateMessageView>(self.conn)
- }
-}
-
-impl PrivateMessageView {
- pub fn read(conn: &PgConnection, from_private_message_id: i32) -> Result<Self, Error> {
- use super::private_message_view::private_message_view::dsl::*;
-
- let mut query = private_message_view.into_boxed();
-
- query = query
- .filter(id.eq(from_private_message_id))
- .order_by(published.desc());
-
- query.first::<Self>(conn)
- }
-}
use crate::{naive_now, schema::private_message, ApubObject, Crud};
use diesel::{dsl::*, result::Error, *};
+use serde::Serialize;
-#[derive(Queryable, Identifiable, PartialEq, Debug)]
+#[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)]
#[table_name = "private_message"]
pub struct PrivateMessage {
pub id: i32,
pub mod community;
pub mod moderator;
pub mod post_view;
+pub mod private_message_view;
pub mod site_view;
pub mod user_mention_view;
pub mod user_view;
--- /dev/null
+use crate::{
+ limit_and_offset,
+ schema::{private_message, user_, user_alias_1},
+ source::{
+ private_message::PrivateMessage,
+ user::{UserAlias1, UserSafe, UserSafeAlias1, User_},
+ },
+ views::ViewToVec,
+ MaybeOptional,
+ ToSafe,
+};
+use diesel::{result::Error, *};
+use serde::Serialize;
+
+#[derive(Debug, PartialEq, Serialize, Clone)]
+pub struct PrivateMessageView {
+ pub private_message: PrivateMessage,
+ pub creator: UserSafe,
+ pub recipient: UserSafeAlias1,
+}
+
+type PrivateMessageViewTuple = (PrivateMessage, UserSafe, UserSafeAlias1);
+
+impl PrivateMessageView {
+ pub fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
+ let (private_message, creator, recipient) = private_message::table
+ .find(private_message_id)
+ .inner_join(user_::table.on(private_message::creator_id.eq(user_::id)))
+ .inner_join(user_alias_1::table.on(private_message::recipient_id.eq(user_alias_1::id)))
+ .order_by(private_message::published.desc())
+ .select((
+ private_message::all_columns,
+ User_::safe_columns_tuple(),
+ UserAlias1::safe_columns_tuple(),
+ ))
+ .first::<PrivateMessageViewTuple>(conn)?;
+
+ Ok(PrivateMessageView {
+ private_message,
+ creator,
+ recipient,
+ })
+ }
+}
+
+pub struct PrivateMessageQueryBuilder<'a> {
+ conn: &'a PgConnection,
+ recipient_id: i32,
+ unread_only: bool,
+ page: Option<i64>,
+ limit: Option<i64>,
+}
+
+impl<'a> PrivateMessageQueryBuilder<'a> {
+ pub fn create(conn: &'a PgConnection, recipient_id: i32) -> Self {
+ PrivateMessageQueryBuilder {
+ conn,
+ recipient_id,
+ unread_only: false,
+ page: None,
+ limit: None,
+ }
+ }
+
+ pub fn unread_only(mut self, unread_only: bool) -> Self {
+ self.unread_only = unread_only;
+ 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
+ }
+
+ pub fn list(self) -> Result<Vec<PrivateMessageView>, Error> {
+ let mut query = private_message::table
+ .inner_join(user_::table.on(private_message::creator_id.eq(user_::id)))
+ .inner_join(user_alias_1::table.on(private_message::recipient_id.eq(user_alias_1::id)))
+ .select((
+ private_message::all_columns,
+ User_::safe_columns_tuple(),
+ UserAlias1::safe_columns_tuple(),
+ ))
+ .into_boxed();
+
+ // If its unread, I only want the ones to me
+ if self.unread_only {
+ query = query
+ .filter(private_message::read.eq(false))
+ .filter(private_message::recipient_id.eq(self.recipient_id));
+ }
+ // Otherwise, I want the ALL view to show both sent and received
+ else {
+ query = query.filter(
+ private_message::recipient_id
+ .eq(self.recipient_id)
+ .or(private_message::creator_id.eq(self.recipient_id)),
+ )
+ }
+
+ let (limit, offset) = limit_and_offset(self.page, self.limit);
+
+ let res = query
+ .filter(private_message::deleted.eq(false))
+ .limit(limit)
+ .offset(offset)
+ .order_by(private_message::published.desc())
+ .load::<PrivateMessageViewTuple>(self.conn)?;
+
+ Ok(PrivateMessageView::to_vec(res))
+ }
+}
+
+impl ViewToVec for PrivateMessageView {
+ type DbTuple = PrivateMessageViewTuple;
+ fn to_vec(pm: Vec<Self::DbTuple>) -> Vec<Self> {
+ pm.iter()
+ .map(|a| Self {
+ private_message: a.0.to_owned(),
+ creator: a.1.to_owned(),
+ recipient: a.2.to_owned(),
+ })
+ .collect::<Vec<Self>>()
+ }
+}
-use lemmy_db::{
- private_message_view::PrivateMessageView,
- views::{
- comment_view::CommentView,
- community::{
- community_follower_view::CommunityFollowerView,
- community_moderator_view::CommunityModeratorView,
- },
- post_view::PostView,
- user_mention_view::UserMentionView,
- user_view::{UserViewDangerous, UserViewSafe},
+use lemmy_db::views::{
+ comment_view::CommentView,
+ community::{
+ community_follower_view::CommunityFollowerView,
+ community_moderator_view::CommunityModeratorView,
},
+ post_view::PostView,
+ private_message_view::PrivateMessageView,
+ user_mention_view::UserMentionView,
+ user_view::{UserViewDangerous, UserViewSafe},
};
use serde::{Deserialize, Serialize};
projects / lemmy.git / commitdiff