1 use crate::structs::PrivateMessageView;
11 use diesel_async::RunQueryDsl;
12 use lemmy_db_schema::{
14 newtypes::{PersonId, PrivateMessageId},
15 schema::{person, private_message},
16 source::{person::Person, private_message::PrivateMessage},
18 utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
22 type PrivateMessageViewTuple = (PrivateMessage, Person, Person);
24 fn queries<'a>() -> Queries<
25 impl ReadFn<'a, PrivateMessageView, PrivateMessageId>,
26 impl ListFn<'a, PrivateMessageView, (PrivateMessageQuery, PersonId)>,
28 let all_joins = |query: private_message::BoxedQuery<'a, Pg>| {
30 .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
32 aliases::person1.on(private_message::recipient_id.eq(aliases::person1.field(person::id))),
37 private_message::all_columns,
39 aliases::person1.fields(person::all_columns),
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())
46 .first::<PrivateMessageViewTuple>(&mut conn)
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);
54 // If its unread, I only want the ones to me
55 if options.unread_only.unwrap_or(false) {
57 .filter(private_message::read.eq(false))
58 .filter(private_message::recipient_id.eq(recipient_id));
60 // Otherwise, I want the ALL view to show both sent and received
63 private_message::recipient_id
65 .or(private_message::creator_id.eq(recipient_id)),
69 let (limit, offset) = limit_and_offset(options.page, options.limit)?;
72 .filter(private_message::deleted.eq(false))
75 .order_by(private_message::published.desc());
78 "Private Message View Query: {:?}",
79 debug_query::<Pg, _>(&query)
82 query.load::<PrivateMessageViewTuple>(&mut conn).await
85 Queries::new(read, list)
88 impl PrivateMessageView {
90 pool: &mut DbPool<'_>,
91 private_message_id: PrivateMessageId,
92 ) -> Result<Self, Error> {
93 queries().read(pool, private_message_id).await
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))
114 pub struct PrivateMessageQuery {
115 pub unread_only: Option<bool>,
116 pub page: Option<i64>,
117 pub limit: Option<i64>,
120 impl PrivateMessageQuery {
123 pool: &mut DbPool<'_>,
124 recipient_id: PersonId,
125 ) -> Result<Vec<PrivateMessageView>, Error> {
126 queries().list(pool, (self, recipient_id)).await
130 impl JoinView for PrivateMessageView {
131 type JoinTuple = PrivateMessageViewTuple;
132 fn from_tuple(a: Self::JoinTuple) -> Self {
134 private_message: a.0,