crates/db_schema/src/impls/local_site.rs

   1 use crate::{
   2   schema::local_site::dsl::local_site,
   3   source::local_site::{
   4     LocalSite,
   5     LocalSiteInsertForm,
   6     LocalSiteUpdateForm,
   7     RegistrationMode,
   8     RegistrationModeType,
   9   },
  10   utils::{get_conn, DbPool},
  11 };
  12 use diesel::{
  13   deserialize,
  14   deserialize::FromSql,
  15   dsl::insert_into,
  16   pg::{Pg, PgValue},
  17   result::Error,
  18   serialize,
  19   serialize::{IsNull, Output, ToSql},
  20 };
  21 use diesel_async::RunQueryDsl;
  22 use std::io::Write;
  23
  24 impl LocalSite {
  25   pub async fn create(pool: &DbPool, form: &LocalSiteInsertForm) -> Result<Self, Error> {
  26     let conn = &mut get_conn(pool).await?;
  27     insert_into(local_site)
  28       .values(form)
  29       .get_result::<Self>(conn)
  30       .await
  31   }
  32   pub async fn read(pool: &DbPool) -> Result<Self, Error> {
  33     let conn = &mut get_conn(pool).await?;
  34     local_site.first::<Self>(conn).await
  35   }
  36   pub async fn update(pool: &DbPool, form: &LocalSiteUpdateForm) -> Result<Self, Error> {
  37     let conn = &mut get_conn(pool).await?;
  38     diesel::update(local_site)
  39       .set(form)
  40       .get_result::<Self>(conn)
  41       .await
  42   }
  43   pub async fn delete(pool: &DbPool) -> Result<usize, Error> {
  44     let conn = &mut get_conn(pool).await?;
  45     diesel::delete(local_site).execute(conn).await
  46   }
  47 }
  48
  49 impl ToSql<RegistrationModeType, Pg> for RegistrationMode {
  50   fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
  51     match *self {
  52       RegistrationMode::Closed => out.write_all(b"closed")?,
  53       RegistrationMode::RequireApplication => out.write_all(b"require_application")?,
  54       RegistrationMode::Open => out.write_all(b"open")?,
  55     }
  56     Ok(IsNull::No)
  57   }
  58 }
  59
  60 impl FromSql<RegistrationModeType, Pg> for RegistrationMode {
  61   fn from_sql(bytes: PgValue<'_>) -> deserialize::Result<Self> {
  62     match bytes.as_bytes() {
  63       b"closed" => Ok(RegistrationMode::Closed),
  64       b"require_application" => Ok(RegistrationMode::RequireApplication),
  65       b"open" => Ok(RegistrationMode::Open),
  66       _ => Err("Unrecognized enum variant".into()),
  67     }
  68   }
  69 }