4 newtypes::{DbUrl, PersonId},
5 schema::person::dsl::*,
6 source::person::{Person, PersonForm, PersonSafe},
9 use diesel::{dsl::*, result::Error, ExpressionMethods, PgConnection, QueryDsl, RunQueryDsl};
13 use crate::{schema::person::columns::*, source::person::Person, traits::ToSafe};
36 impl ToSafe for Person {
37 type SafeColumns = Columns;
38 fn safe_columns_tuple() -> Self::SafeColumns {
63 mod safe_type_alias_1 {
64 use crate::{schema::person_alias_1::columns::*, source::person::PersonAlias1, traits::ToSafe};
87 impl ToSafe for PersonAlias1 {
88 type SafeColumns = Columns;
89 fn safe_columns_tuple() -> Self::SafeColumns {
114 mod safe_type_alias_2 {
115 use crate::{schema::person_alias_2::columns::*, source::person::PersonAlias2, traits::ToSafe};
138 impl ToSafe for PersonAlias2 {
139 type SafeColumns = Columns;
140 fn safe_columns_tuple() -> Self::SafeColumns {
165 impl Crud for Person {
166 type Form = PersonForm;
167 type IdType = PersonId;
168 fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
170 .filter(deleted.eq(false))
174 fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
175 diesel::delete(person.find(person_id)).execute(conn)
177 fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
178 insert_into(person).values(form).get_result::<Self>(conn)
180 fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
181 diesel::update(person.find(person_id))
183 .get_result::<Self>(conn)
192 expires: Option<chrono::NaiveDateTime>,
193 ) -> Result<Self, Error> {
194 diesel::update(person.find(person_id))
195 .set((banned.eq(ban), ban_expires.eq(expires)))
196 .get_result::<Self>(conn)
199 pub fn add_admin(conn: &PgConnection, person_id: PersonId, added: bool) -> Result<Self, Error> {
200 diesel::update(person.find(person_id))
201 .set(admin.eq(added))
202 .get_result::<Self>(conn)
205 pub fn find_by_name(conn: &PgConnection, from_name: &str) -> Result<Person, Error> {
207 .filter(deleted.eq(false))
208 .filter(local.eq(true))
209 .filter(lower(name).eq(lower(from_name)))
210 .first::<Person>(conn)
213 pub fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
214 diesel::update(person.find(person_id))
215 .set((last_refreshed_at.eq(naive_now()),))
216 .get_result::<Self>(conn)
219 pub fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
220 use crate::schema::local_user;
222 // Set the local user info to none
223 diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
225 local_user::email.eq::<Option<String>>(None),
226 local_user::validator_time.eq(naive_now()),
230 diesel::update(person.find(person_id))
232 display_name.eq::<Option<String>>(None),
233 bio.eq::<Option<String>>(None),
234 matrix_user_id.eq::<Option<String>>(None),
236 updated.eq(naive_now()),
238 .get_result::<Self>(conn)
241 pub fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
244 .on_conflict(actor_id)
247 .get_result::<Self>(conn)
250 pub fn read_from_apub_id(conn: &PgConnection, object_id: Url) -> Result<Option<Self>, Error> {
251 use crate::schema::person::dsl::*;
252 let object_id: DbUrl = object_id.into();
255 .filter(deleted.eq(false))
256 .filter(actor_id.eq(object_id))
257 .first::<Person>(conn)
263 pub fn update_deleted(
267 ) -> Result<Person, Error> {
268 use crate::schema::person::dsl::*;
269 diesel::update(person.find(person_id))
270 .set(deleted.eq(new_deleted))
271 .get_result::<Self>(conn)
274 pub fn is_banned(&self) -> bool {
275 is_banned(self.banned, self.ban_expires)
280 pub fn is_banned(&self) -> bool {
281 is_banned(self.banned, self.ban_expires)
285 fn is_banned(banned_: bool, expires: Option<chrono::NaiveDateTime>) -> bool {
286 if let Some(expires) = expires {
287 banned_ && expires.gt(&naive_now())
295 use crate::{establish_unpooled_connection, source::person::*, traits::Crud};
299 let conn = establish_unpooled_connection();
301 let new_person = PersonForm {
302 name: "holly".into(),
303 public_key: "nada".to_owned(),
304 ..PersonForm::default()
307 let inserted_person = Person::create(&conn, &new_person).unwrap();
309 let expected_person = Person {
310 id: inserted_person.id,
311 name: "holly".into(),
317 published: inserted_person.published,
319 actor_id: inserted_person.actor_id.to_owned(),
325 public_key: "nada".to_owned(),
326 last_refreshed_at: inserted_person.published,
327 inbox_url: inserted_person.inbox_url.to_owned(),
328 shared_inbox_url: None,
329 matrix_user_id: None,
333 let read_person = Person::read(&conn, inserted_person.id).unwrap();
334 let updated_person = Person::update(&conn, inserted_person.id, &new_person).unwrap();
335 let num_deleted = Person::delete(&conn, inserted_person.id).unwrap();
337 assert_eq!(expected_person, read_person);
338 assert_eq!(expected_person, inserted_person);
339 assert_eq!(expected_person, updated_person);
340 assert_eq!(1, num_deleted);