use diesel::{result::Error, *};
use lemmy_db_schema::{
newtypes::PrivateMessageReportId,
- schema::{person, person_alias_1, person_alias_2, private_message, private_message_report},
+ schema::{person, private_message, private_message_report},
source::{
- person::{Person, PersonAlias1, PersonAlias2, PersonSafe, PersonSafeAlias1, PersonSafeAlias2},
+ person::{Person, PersonSafe},
private_message::PrivateMessage,
private_message_report::PrivateMessageReport,
},
PrivateMessageReport,
PrivateMessage,
PersonSafe,
- PersonSafeAlias1,
- Option<PersonSafeAlias2>,
+ PersonSafe,
+ Option<PersonSafe>,
);
impl PrivateMessageReportView {
/// returns the PrivateMessageReportView for the provided report_id
///
/// * `report_id` - the report id to obtain
- pub fn read(conn: &PgConnection, report_id: PrivateMessageReportId) -> Result<Self, Error> {
+ pub fn read(conn: &mut PgConnection, report_id: PrivateMessageReportId) -> Result<Self, Error> {
+ let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
+
let (private_message_report, private_message, private_message_creator, creator, resolver) =
private_message_report::table
.find(report_id)
.inner_join(private_message::table)
.inner_join(person::table.on(private_message::creator_id.eq(person::id)))
.inner_join(
- person_alias_1::table.on(private_message_report::creator_id.eq(person_alias_1::id)),
+ person_alias_1
+ .on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
)
.left_join(
- person_alias_2::table
- .on(private_message_report::resolver_id.eq(person_alias_2::id.nullable())),
+ person_alias_2.on(
+ private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable()),
+ ),
)
.select((
private_message_report::all_columns,
private_message::all_columns,
Person::safe_columns_tuple(),
- PersonAlias1::safe_columns_tuple(),
- PersonAlias2::safe_columns_tuple().nullable(),
+ person_alias_1.fields(Person::safe_columns_tuple()),
+ person_alias_2
+ .fields(Person::safe_columns_tuple())
+ .nullable(),
))
.first::<PrivateMessageReportViewTuple>(conn)?;
}
/// Returns the current unresolved post report count for the communities you mod
- pub fn get_report_count(conn: &PgConnection) -> Result<i64, Error> {
+ pub fn get_report_count(conn: &mut PgConnection) -> Result<i64, Error> {
use diesel::dsl::*;
private_message_report::table
#[builder(field_defaults(default))]
pub struct PrivateMessageReportQuery<'a> {
#[builder(!default)]
- conn: &'a PgConnection,
+ conn: &'a mut PgConnection,
page: Option<i64>,
limit: Option<i64>,
unresolved_only: Option<bool>,
impl<'a> PrivateMessageReportQuery<'a> {
pub fn list(self) -> Result<Vec<PrivateMessageReportView>, Error> {
+ let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
+
let mut query = private_message_report::table
.inner_join(private_message::table)
.inner_join(person::table.on(private_message::creator_id.eq(person::id)))
.inner_join(
- person_alias_1::table.on(private_message_report::creator_id.eq(person_alias_1::id)),
+ person_alias_1.on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
)
.left_join(
- person_alias_2::table
- .on(private_message_report::resolver_id.eq(person_alias_2::id.nullable())),
+ person_alias_2
+ .on(private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable())),
)
.select((
private_message_report::all_columns,
private_message::all_columns,
Person::safe_columns_tuple(),
- PersonAlias1::safe_columns_tuple(),
- PersonAlias2::safe_columns_tuple().nullable(),
+ person_alias_1.fields(Person::safe_columns_tuple()),
+ person_alias_2
+ .fields(Person::safe_columns_tuple())
+ .nullable(),
))
.into_boxed();
use crate::private_message_report_view::PrivateMessageReportQuery;
use lemmy_db_schema::{
source::{
- person::{Person, PersonForm},
- private_message::{PrivateMessage, PrivateMessageForm},
+ instance::Instance,
+ person::{Person, PersonInsertForm},
+ private_message::{PrivateMessage, PrivateMessageInsertForm},
private_message_report::{PrivateMessageReport, PrivateMessageReportForm},
},
traits::{Crud, Reportable},
#[test]
#[serial]
fn test_crud() {
- let conn = establish_unpooled_connection();
+ let conn = &mut establish_unpooled_connection();
- let new_person_1 = PersonForm {
- name: "timmy_mrv".into(),
- public_key: Some("pubkey".to_string()),
- ..PersonForm::default()
- };
- let inserted_timmy = Person::create(&conn, &new_person_1).unwrap();
+ let inserted_instance = Instance::create(conn, "my_domain.tld").unwrap();
- let new_person_2 = PersonForm {
- name: "jessica_mrv".into(),
- public_key: Some("pubkey".to_string()),
- ..PersonForm::default()
- };
- let inserted_jessica = Person::create(&conn, &new_person_2).unwrap();
+ let new_person_1 = PersonInsertForm::builder()
+ .name("timmy_mrv".into())
+ .public_key("pubkey".to_string())
+ .instance_id(inserted_instance.id)
+ .build();
+ let inserted_timmy = Person::create(conn, &new_person_1).unwrap();
+
+ let new_person_2 = PersonInsertForm::builder()
+ .name("jessica_mrv".into())
+ .public_key("pubkey".to_string())
+ .instance_id(inserted_instance.id)
+ .build();
+ let inserted_jessica = Person::create(conn, &new_person_2).unwrap();
// timmy sends private message to jessica
- let pm_form = PrivateMessageForm {
- creator_id: inserted_timmy.id,
- recipient_id: inserted_jessica.id,
- content: "something offensive".to_string(),
- ..Default::default()
- };
- let pm = PrivateMessage::create(&conn, &pm_form).unwrap();
+ let pm_form = PrivateMessageInsertForm::builder()
+ .creator_id(inserted_timmy.id)
+ .recipient_id(inserted_jessica.id)
+ .content("something offensive".to_string())
+ .build();
+ let pm = PrivateMessage::create(conn, &pm_form).unwrap();
// jessica reports private message
let pm_report_form = PrivateMessageReportForm {
private_message_id: pm.id,
reason: "its offensive".to_string(),
};
- let pm_report = PrivateMessageReport::report(&conn, &pm_report_form).unwrap();
+ let pm_report = PrivateMessageReport::report(conn, &pm_report_form).unwrap();
let reports = PrivateMessageReportQuery::builder()
- .conn(&conn)
+ .conn(conn)
.build()
.list()
.unwrap();
assert_eq!(pm_report.reason, reports[0].private_message_report.reason);
assert_eq!(pm.content, reports[0].private_message.content);
- let new_person_3 = PersonForm {
- name: "admin_mrv".into(),
- public_key: Some("pubkey".to_string()),
- ..PersonForm::default()
- };
- let inserted_admin = Person::create(&conn, &new_person_3).unwrap();
+ let new_person_3 = PersonInsertForm::builder()
+ .name("admin_mrv".into())
+ .public_key("pubkey".to_string())
+ .instance_id(inserted_instance.id)
+ .build();
+ let inserted_admin = Person::create(conn, &new_person_3).unwrap();
// admin resolves the report (after taking appropriate action)
- PrivateMessageReport::resolve(&conn, pm_report.id, inserted_admin.id).unwrap();
+ PrivateMessageReport::resolve(conn, pm_report.id, inserted_admin.id).unwrap();
let reports = PrivateMessageReportQuery::builder()
- .conn(&conn)
+ .conn(conn)
.unresolved_only(Some(false))
.build()
.list()
inserted_admin.name,
reports[0].resolver.as_ref().unwrap().name
);
+
+ Instance::delete(conn, inserted_instance.id).unwrap();
}
}
projects / lemmy.git / blobdiff