4 newtypes::{DbUrl, PersonId},
5 schema::person::dsl::*,
6 source::person::{Person, PersonForm},
9 use diesel::{dsl::*, result::Error, ExpressionMethods, PgConnection, QueryDsl, RunQueryDsl};
13 use crate::{schema::person::columns::*, source::person::Person, traits::ToSafe};
35 impl ToSafe for Person {
36 type SafeColumns = Columns;
37 fn safe_columns_tuple() -> Self::SafeColumns {
61 mod safe_type_alias_1 {
62 use crate::{schema::person_alias_1::columns::*, source::person::PersonAlias1, traits::ToSafe};
84 impl ToSafe for PersonAlias1 {
85 type SafeColumns = Columns;
86 fn safe_columns_tuple() -> Self::SafeColumns {
110 mod safe_type_alias_2 {
111 use crate::{schema::person_alias_2::columns::*, source::person::PersonAlias2, traits::ToSafe};
133 impl ToSafe for PersonAlias2 {
134 type SafeColumns = Columns;
135 fn safe_columns_tuple() -> Self::SafeColumns {
159 impl Crud for Person {
160 type Form = PersonForm;
161 type IdType = PersonId;
162 fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
164 .filter(deleted.eq(false))
168 fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
169 diesel::delete(person.find(person_id)).execute(conn)
171 fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
172 insert_into(person).values(form).get_result::<Self>(conn)
174 fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
175 diesel::update(person.find(person_id))
177 .get_result::<Self>(conn)
182 pub fn ban_person(conn: &PgConnection, person_id: PersonId, ban: bool) -> Result<Self, Error> {
183 diesel::update(person.find(person_id))
185 .get_result::<Self>(conn)
188 pub fn add_admin(conn: &PgConnection, person_id: PersonId, added: bool) -> Result<Self, Error> {
189 diesel::update(person.find(person_id))
190 .set(admin.eq(added))
191 .get_result::<Self>(conn)
194 pub fn find_by_name(conn: &PgConnection, from_name: &str) -> Result<Person, Error> {
196 .filter(deleted.eq(false))
197 .filter(local.eq(true))
198 .filter(lower(name).eq(lower(from_name)))
199 .first::<Person>(conn)
202 pub fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
203 diesel::update(person.find(person_id))
204 .set((last_refreshed_at.eq(naive_now()),))
205 .get_result::<Self>(conn)
208 pub fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
209 use crate::schema::local_user;
211 // Set the local user info to none
212 diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
214 local_user::email.eq::<Option<String>>(None),
215 local_user::validator_time.eq(naive_now()),
219 diesel::update(person.find(person_id))
221 display_name.eq::<Option<String>>(None),
222 bio.eq::<Option<String>>(None),
223 matrix_user_id.eq::<Option<String>>(None),
225 updated.eq(naive_now()),
227 .get_result::<Self>(conn)
230 pub fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
233 .on_conflict(actor_id)
236 .get_result::<Self>(conn)
239 pub fn read_from_apub_id(conn: &PgConnection, object_id: Url) -> Result<Option<Self>, Error> {
240 use crate::schema::person::dsl::*;
241 let object_id: DbUrl = object_id.into();
244 .filter(deleted.eq(false))
245 .filter(actor_id.eq(object_id))
246 .first::<Person>(conn)
252 pub fn update_deleted(
256 ) -> Result<Person, Error> {
257 use crate::schema::person::dsl::*;
258 diesel::update(person.find(person_id))
259 .set(deleted.eq(new_deleted))
260 .get_result::<Self>(conn)
266 use crate::{establish_unpooled_connection, source::person::*, traits::Crud};
270 let conn = establish_unpooled_connection();
272 let new_person = PersonForm {
273 name: "holly".into(),
274 public_key: "nada".to_owned(),
275 ..PersonForm::default()
278 let inserted_person = Person::create(&conn, &new_person).unwrap();
280 let expected_person = Person {
281 id: inserted_person.id,
282 name: "holly".into(),
288 published: inserted_person.published,
290 actor_id: inserted_person.actor_id.to_owned(),
296 public_key: "nada".to_owned(),
297 last_refreshed_at: inserted_person.published,
298 inbox_url: inserted_person.inbox_url.to_owned(),
299 shared_inbox_url: None,
300 matrix_user_id: None,
303 let read_person = Person::read(&conn, inserted_person.id).unwrap();
304 let updated_person = Person::update(&conn, inserted_person.id, &new_person).unwrap();
305 let num_deleted = Person::delete(&conn, inserted_person.id).unwrap();
307 assert_eq!(expected_person, read_person);
308 assert_eq!(expected_person, inserted_person);
309 assert_eq!(expected_person, updated_person);
310 assert_eq!(1, num_deleted);