crates/db_schema/src/impls/instance.rs

   1 use crate::{
   2   newtypes::InstanceId,
   3   schema::{federation_allowlist, federation_blocklist, instance},
   4   source::instance::{Instance, InstanceForm},
   5   utils::{get_conn, naive_now, DbPool},
   6 };
   7 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
   8 use diesel_async::{AsyncPgConnection, RunQueryDsl};
   9 use lemmy_utils::utils::generate_domain_url;
  10 use url::Url;
  11
  12 impl Instance {
  13   async fn create_from_form_conn(
  14     conn: &mut AsyncPgConnection,
  15     form: &InstanceForm,
  16   ) -> Result<Self, Error> {
  17     // Do upsert on domain name conflict
  18     insert_into(instance::table)
  19       .values(form)
  20       .on_conflict(instance::domain)
  21       .do_update()
  22       .set(form)
  23       .get_result::<Self>(conn)
  24       .await
  25   }
  26   pub async fn create(pool: &DbPool, domain: &str) -> Result<Self, Error> {
  27     let conn = &mut get_conn(pool).await?;
  28     Self::create_conn(conn, domain).await
  29   }
  30   pub async fn create_from_actor_id(pool: &DbPool, actor_id: &Url) -> Result<Self, Error> {
  31     let domain = &generate_domain_url(actor_id).expect("actor id missing a domain");
  32     Self::create(pool, domain).await
  33   }
  34   pub async fn create_conn(conn: &mut AsyncPgConnection, domain: &str) -> Result<Self, Error> {
  35     let form = InstanceForm {
  36       domain: domain.to_string(),
  37       updated: Some(naive_now()),
  38     };
  39     Self::create_from_form_conn(conn, &form).await
  40   }
  41   pub async fn delete(pool: &DbPool, instance_id: InstanceId) -> Result<usize, Error> {
  42     let conn = &mut get_conn(pool).await?;
  43     diesel::delete(instance::table.find(instance_id))
  44       .execute(conn)
  45       .await
  46   }
  47   pub async fn delete_all(pool: &DbPool) -> Result<usize, Error> {
  48     let conn = &mut get_conn(pool).await?;
  49     diesel::delete(instance::table).execute(conn).await
  50   }
  51   pub async fn allowlist(pool: &DbPool) -> Result<Vec<String>, Error> {
  52     let conn = &mut get_conn(pool).await?;
  53     instance::table
  54       .inner_join(federation_allowlist::table)
  55       .select(instance::domain)
  56       .load::<String>(conn)
  57       .await
  58   }
  59
  60   pub async fn blocklist(pool: &DbPool) -> Result<Vec<String>, Error> {
  61     let conn = &mut get_conn(pool).await?;
  62     instance::table
  63       .inner_join(federation_blocklist::table)
  64       .select(instance::domain)
  65       .load::<String>(conn)
  66       .await
  67   }
  68
  69   pub async fn linked(pool: &DbPool) -> Result<Vec<String>, Error> {
  70     let conn = &mut get_conn(pool).await?;
  71     instance::table
  72       .left_join(federation_blocklist::table)
  73       .filter(federation_blocklist::id.is_null())
  74       .select(instance::domain)
  75       .load::<String>(conn)
  76       .await
  77   }
  78 }