98 lines
2.8 KiB
Rust
98 lines
2.8 KiB
Rust
use loco_rs::{
|
|
app::AppContext,
|
|
model::{ModelError, ModelResult},
|
|
};
|
|
use sea_orm::{entity::prelude::*, ActiveValue, TransactionTrait};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
pub use super::entities::subscribers::*;
|
|
|
|
pub const ROOT_SUBSCRIBER: &str = "konobangu";
|
|
|
|
#[derive(Debug, Deserialize, Serialize)]
|
|
pub struct SubscriberIdParams {
|
|
pub id: String,
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl ActiveModelBehavior for ActiveModel {
|
|
async fn before_save<C>(self, _db: &C, insert: bool) -> Result<Self, DbErr>
|
|
where
|
|
C: ConnectionTrait,
|
|
{
|
|
if insert {
|
|
let mut this = self;
|
|
this.pid = ActiveValue::Set(Uuid::new_v4().to_string());
|
|
Ok(this)
|
|
} else {
|
|
Ok(self)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Model {
|
|
/// finds a user by the provided pid
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// When could not find user or DB query error
|
|
pub async fn find_by_pid(ctx: &AppContext, pid: &str) -> ModelResult<Self> {
|
|
let db = &ctx.db;
|
|
let parse_uuid = Uuid::parse_str(pid).map_err(|e| ModelError::Any(e.into()))?;
|
|
let subscriber = Entity::find()
|
|
.filter(Column::Pid.eq(parse_uuid))
|
|
.one(db)
|
|
.await?;
|
|
subscriber.ok_or_else(|| ModelError::EntityNotFound)
|
|
}
|
|
|
|
pub async fn find_by_id(ctx: &AppContext, id: i32) -> ModelResult<Self> {
|
|
let db = &ctx.db;
|
|
|
|
let subscriber = Entity::find_by_id(id).one(db).await?;
|
|
subscriber.ok_or_else(|| ModelError::EntityNotFound)
|
|
}
|
|
|
|
pub async fn find_pid_by_id_with_cache(ctx: &AppContext, id: i32) -> eyre::Result<String> {
|
|
let db = &ctx.db;
|
|
let cache = &ctx.cache;
|
|
let pid = cache
|
|
.get_or_insert(&format!("subscriber-id2pid::{}", id), async {
|
|
let subscriber = Entity::find_by_id(id)
|
|
.one(db)
|
|
.await?
|
|
.ok_or_else(|| loco_rs::Error::string(&format!("No such pid for id {}", id)))?;
|
|
Ok(subscriber.pid)
|
|
})
|
|
.await?;
|
|
Ok(pid)
|
|
}
|
|
|
|
pub async fn find_root(ctx: &AppContext) -> ModelResult<Self> {
|
|
Self::find_by_pid(ctx, ROOT_SUBSCRIBER).await
|
|
}
|
|
|
|
/// Asynchronously creates a user with a password and saves it to the
|
|
/// database.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// When could not save the user into the DB
|
|
pub async fn create_root(ctx: &AppContext) -> ModelResult<Self> {
|
|
let db = &ctx.db;
|
|
let txn = db.begin().await?;
|
|
|
|
let user = ActiveModel {
|
|
display_name: ActiveValue::set(ROOT_SUBSCRIBER.to_string()),
|
|
pid: ActiveValue::set(ROOT_SUBSCRIBER.to_string()),
|
|
..Default::default()
|
|
}
|
|
.insert(&txn)
|
|
.await?;
|
|
|
|
txn.commit().await?;
|
|
|
|
Ok(user)
|
|
}
|
|
}
|