1 use diesel::{result::Error, *};
2 use lemmy_db_queries::{limit_and_offset, MaybeOptional, ToSafe, ViewToVec};
4 schema::{comment, comment_report, community, person, person_alias_1, person_alias_2, post},
7 comment_report::CommentReport,
8 community::{Community, CommunitySafe},
9 person::{Person, PersonAlias1, PersonAlias2, PersonSafe, PersonSafeAlias1, PersonSafeAlias2},
16 #[derive(Debug, PartialEq, Serialize, Clone)]
17 pub struct CommentReportView {
18 pub comment_report: CommentReport,
21 pub community: CommunitySafe,
22 pub creator: PersonSafe,
23 pub comment_creator: PersonSafeAlias1,
24 pub resolver: Option<PersonSafeAlias2>,
27 type CommentReportViewTuple = (
34 Option<PersonSafeAlias2>,
37 impl CommentReportView {
38 /// returns the CommentReportView for the provided report_id
40 /// * `report_id` - the report id to obtain
41 pub fn read(conn: &PgConnection, report_id: i32) -> Result<Self, Error> {
42 let (comment_report, comment, post, community, creator, comment_creator, resolver) =
45 .inner_join(comment::table)
46 .inner_join(post::table.on(comment::post_id.eq(post::id)))
47 .inner_join(community::table.on(post::community_id.eq(community::id)))
48 .inner_join(person::table.on(comment_report::creator_id.eq(person::id)))
49 .inner_join(person_alias_1::table.on(post::creator_id.eq(person_alias_1::id)))
51 person_alias_2::table.on(comment_report::resolver_id.eq(person_alias_2::id.nullable())),
54 comment_report::all_columns,
57 Community::safe_columns_tuple(),
58 Person::safe_columns_tuple(),
59 PersonAlias1::safe_columns_tuple(),
60 PersonAlias2::safe_columns_tuple().nullable(),
62 .first::<CommentReportViewTuple>(conn)?;
75 /// returns the current unresolved post report count for the supplied community ids
77 /// * `community_ids` - a Vec<i32> of community_ids to get a count for
78 /// TODO this eq_any is a bad way to do this, would be better to join to communitymoderator
80 pub fn get_report_count(
82 community_ids: &[CommunityId],
83 ) -> Result<i64, Error> {
86 .inner_join(comment::table)
87 .inner_join(post::table.on(comment::post_id.eq(post::id)))
89 comment_report::resolved
91 .and(post::community_id.eq_any(community_ids)),
93 .select(count(comment_report::id))
98 pub struct CommentReportQueryBuilder<'a> {
99 conn: &'a PgConnection,
100 community_ids: Option<Vec<CommunityId>>, // TODO bad way to do this
103 resolved: Option<bool>,
106 impl<'a> CommentReportQueryBuilder<'a> {
107 pub fn create(conn: &'a PgConnection) -> Self {
108 CommentReportQueryBuilder {
113 resolved: Some(false),
117 pub fn community_ids<T: MaybeOptional<Vec<CommunityId>>>(mut self, community_ids: T) -> Self {
118 self.community_ids = community_ids.get_optional();
122 pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
123 self.page = page.get_optional();
127 pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
128 self.limit = limit.get_optional();
132 pub fn resolved<T: MaybeOptional<bool>>(mut self, resolved: T) -> Self {
133 self.resolved = resolved.get_optional();
137 pub fn list(self) -> Result<Vec<CommentReportView>, Error> {
138 let mut query = comment_report::table
139 .inner_join(comment::table)
140 .inner_join(post::table.on(comment::post_id.eq(post::id)))
141 .inner_join(community::table.on(post::community_id.eq(community::id)))
142 .inner_join(person::table.on(comment_report::creator_id.eq(person::id)))
143 .inner_join(person_alias_1::table.on(post::creator_id.eq(person_alias_1::id)))
145 person_alias_2::table.on(comment_report::resolver_id.eq(person_alias_2::id.nullable())),
148 comment_report::all_columns,
149 comment::all_columns,
151 Community::safe_columns_tuple(),
152 Person::safe_columns_tuple(),
153 PersonAlias1::safe_columns_tuple(),
154 PersonAlias2::safe_columns_tuple().nullable(),
158 if let Some(comm_ids) = self.community_ids {
159 query = query.filter(post::community_id.eq_any(comm_ids));
162 if let Some(resolved_flag) = self.resolved {
163 query = query.filter(comment_report::resolved.eq(resolved_flag));
166 let (limit, offset) = limit_and_offset(self.page, self.limit);
169 .order_by(comment_report::published.asc())
172 .load::<CommentReportViewTuple>(self.conn)?;
174 Ok(CommentReportView::from_tuple_to_vec(res))
178 impl ViewToVec for CommentReportView {
179 type DbTuple = CommentReportViewTuple;
180 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
184 comment_report: a.0.to_owned(),
185 comment: a.1.to_owned(),
186 post: a.2.to_owned(),
187 community: a.3.to_owned(),
188 creator: a.4.to_owned(),
189 comment_creator: a.5.to_owned(),
190 resolver: a.6.to_owned(),
192 .collect::<Vec<Self>>()