1 use diesel::{result::Error, *};
2 use lemmy_db_queries::{limit_and_offset, MaybeOptional, ToSafe, ViewToVec};
4 schema::{community, post, post_report, person, person_alias_1, person_alias_2},
6 community::{Community, CommunitySafe},
8 post_report::PostReport,
9 person::{PersonAlias1, PersonAlias2, PersonSafe, PersonSafeAlias1, PersonSafeAlias2, Person},
14 #[derive(Debug, PartialEq, Serialize, Clone)]
15 pub struct PostReportView {
16 pub post_report: PostReport,
18 pub community: CommunitySafe,
19 pub creator: PersonSafe,
20 pub post_creator: PersonSafeAlias1,
21 pub resolver: Option<PersonSafeAlias2>,
24 type PostReportViewTuple = (
30 Option<PersonSafeAlias2>,
34 /// returns the PostReportView for the provided report_id
36 /// * `report_id` - the report id to obtain
37 pub fn read(conn: &PgConnection, report_id: i32) -> Result<Self, Error> {
38 let (post_report, post, community, creator, post_creator, resolver) = post_report::table
40 .inner_join(post::table)
41 .inner_join(community::table.on(post::community_id.eq(community::id)))
42 .inner_join(person::table.on(post_report::creator_id.eq(person::id)))
43 .inner_join(person_alias_1::table.on(post::creator_id.eq(person_alias_1::id)))
44 .left_join(person_alias_2::table.on(post_report::resolver_id.eq(person_alias_2::id.nullable())))
46 post_report::all_columns,
48 Community::safe_columns_tuple(),
49 Person::safe_columns_tuple(),
50 PersonAlias1::safe_columns_tuple(),
51 PersonAlias2::safe_columns_tuple().nullable(),
53 .first::<PostReportViewTuple>(conn)?;
65 /// returns the current unresolved post report count for the supplied community ids
67 /// * `community_ids` - a Vec<i32> of community_ids to get a count for
68 /// TODO this eq_any is a bad way to do this, would be better to join to communitymoderator
70 pub fn get_report_count(conn: &PgConnection, community_ids: &[i32]) -> Result<i64, Error> {
73 .inner_join(post::table)
77 .and(post::community_id.eq_any(community_ids)),
79 .select(count(post_report::id))
84 pub struct PostReportQueryBuilder<'a> {
85 conn: &'a PgConnection,
86 community_ids: Option<Vec<i32>>, // TODO bad way to do this
89 resolved: Option<bool>,
92 impl<'a> PostReportQueryBuilder<'a> {
93 pub fn create(conn: &'a PgConnection) -> Self {
94 PostReportQueryBuilder {
99 resolved: Some(false),
103 pub fn community_ids<T: MaybeOptional<Vec<i32>>>(mut self, community_ids: T) -> Self {
104 self.community_ids = community_ids.get_optional();
108 pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
109 self.page = page.get_optional();
113 pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
114 self.limit = limit.get_optional();
118 pub fn resolved<T: MaybeOptional<bool>>(mut self, resolved: T) -> Self {
119 self.resolved = resolved.get_optional();
123 pub fn list(self) -> Result<Vec<PostReportView>, Error> {
124 let mut query = post_report::table
125 .inner_join(post::table)
126 .inner_join(community::table.on(post::community_id.eq(community::id)))
127 .inner_join(person::table.on(post_report::creator_id.eq(person::id)))
128 .inner_join(person_alias_1::table.on(post::creator_id.eq(person_alias_1::id)))
129 .left_join(person_alias_2::table.on(post_report::resolver_id.eq(person_alias_2::id.nullable())))
131 post_report::all_columns,
133 Community::safe_columns_tuple(),
134 Person::safe_columns_tuple(),
135 PersonAlias1::safe_columns_tuple(),
136 PersonAlias2::safe_columns_tuple().nullable(),
140 if let Some(comm_ids) = self.community_ids {
141 query = query.filter(post::community_id.eq_any(comm_ids));
144 if let Some(resolved_flag) = self.resolved {
145 query = query.filter(post_report::resolved.eq(resolved_flag));
148 let (limit, offset) = limit_and_offset(self.page, self.limit);
151 .order_by(post_report::published.asc())
154 .load::<PostReportViewTuple>(self.conn)?;
156 Ok(PostReportView::from_tuple_to_vec(res))
160 impl ViewToVec for PostReportView {
161 type DbTuple = PostReportViewTuple;
162 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
166 post_report: a.0.to_owned(),
167 post: a.1.to_owned(),
168 community: a.2.to_owned(),
169 creator: a.3.to_owned(),
170 post_creator: a.4.to_owned(),
171 resolver: a.5.to_owned(),
173 .collect::<Vec<Self>>()