miniweb/rear_auth/src/user_admin_repository.rs

use async_trait::async_trait;
use log::debug;
use rear::admin::domain::*;
use rear::admin::state::AdminRegistry;
use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait, ModelTrait, Set};
use serde_json::Value;

use crate::models::UserRepository;

#[async_trait]
impl AdminRepository for UserRepository {
    type Key = i64;

    fn key_from_string(&self, s: String) -> Option<Self::Key> {
        if let Ok(i) = s.parse::<i64>() {
            Some(i)
        } else {
            None
        }
    }

    async fn info(&self, _: &RepositoryContext) -> RepositoryInfo {
        RepoInfo {
            name: "User",
            lookup_key: "id",
            display_list: &["id", "username"],
            fields: &[
                "username",
                "password",
                "first_name",
                "last_name",
                "email",
                "is_staff",
                "is_active",
                "is_superuser",
            ],
            // fields_readonly: &["last_login", "date_joined"]
        }
        .build()
        .set_widget("password", Widget::default().as_password())
    }

    async fn get(&self, model: &RepositoryContext, id: &Self::Key) -> Option<RepositoryItem> {
        let id: i32 = *id as i32; // use try_into() instead.
        let get_user = entity::User::find_by_id(id).one(&self.connection).await;
        match get_user {
            Ok(get_user) => {
                if let Some(user) = get_user {
                    let id = user.id.to_string();
                    match serde_json::to_value(&user) {
                        Ok(item) => {
                            return Some(model.build_item(&*id, item));
                        }
                        Err(_) => return None,
                    }
                }
            }
            Err(_) => return None,
        }

        None
    }

    async fn list(&self, model: &RepositoryContext) -> RepositoryList {
        let results = if let Ok(results) = entity::User::find().all(&self.connection).await {
            results
        } else {
            return RepositoryList::Empty;
        };
        let repository_items: Vec<RepositoryItem> = results
            .into_iter()
            .filter_map(|item| match serde_json::to_value(&item) {
                Ok(fields) => {
                    let id = item.id.to_string();
                    Some(model.build_item(&*id, fields))
                }
                Err(_) => None,
            })
            .collect();
        RepositoryList::List {
            values: repository_items,
        }
    }

    async fn create(&mut self, model: &RepositoryContext, data: Value) -> Option<RepositoryItem> {
        if let Value::Object(data) = data {
            let username = data.get("username").unwrap().as_str().unwrap();
            let password = data.get("password").unwrap().as_str().unwrap();

            let mut user = UserRepository::new_user(username, password);

            let keys = [
                "first_name",
                "last_name",
                "email",
                "is_staff",
                "is_active",
                "is_superuser",
            ];

            for key in &keys {
                if let Some(value) = data.get(*key) {
                    match *key {
                        "first_name" => user.first_name = Set(value.as_str().map(|s| s.to_owned())),
                        "last_name" => user.last_name = Set(value.as_str().map(|s| s.to_owned())),
                        "email" => user.email = Set(value.as_str().map(|s| s.to_owned())),
                        "is_staff" => user.is_staff = Set(value.as_bool().unwrap_or(false)),
                        "is_active" => user.is_active = Set(value.as_bool().unwrap_or(true)),
                        "is_superuser" => user.is_superuser = Set(value.as_bool().unwrap_or(false)),
                        _ => (),
                    }
                }
            }

            if let Ok(user) = user.insert(&self.connection).await {
                let id = user.id.to_string();
                return Some(model.build_item(&*id, serde_json::to_value(&user).unwrap()));
            }
        }
        None
    }

    async fn update(
        &mut self,
        model: &RepositoryContext,
        id: &Self::Key,
        data: Value,
    ) -> Option<RepositoryItem> {
        let id: i32 = *id as i32;
        let user: Option<entity::user::Model> = entity::User::find_by_id(id)
            .one(&self.connection)
            .await
            .unwrap();
        let mut user: entity::user::ActiveModel = user.unwrap().into();

        // change values
        if let Some(value) = data.get("username") {
            if let Some(value) = value.as_str() {
                user.username = Set(value.to_owned());
            }
        }

        if let Some(value) = data.get("password") {
            user.password = Set(value.as_str().unwrap().to_owned());
        }

        // update
        if let Ok(user) = user.update(&self.connection).await {
            let id = user.id.to_string();
            return Some(model.build_item(&*id, serde_json::to_value(&user).unwrap()));
        }

        None
    }

    async fn replace(
        &mut self,
        model: &RepositoryContext,
        id: &Self::Key,
        data: Value,
    ) -> Option<RepositoryItem> {
        self.update(model, id, data).await
    }

    async fn delete(&mut self, _: &RepositoryContext, id: &Self::Key) -> Option<Value> {
        let id: i32 = *id as i32;
        let user: Option<entity::user::Model> = entity::User::find_by_id(id)
            .one(&self.connection)
            .await
            .unwrap();
        if let Some(user) = user {
            let delete_result = user.delete(&self.connection).await.unwrap();
            debug!("deleted rows: {}", delete_result.rows_affected);
        }

        None
    }
}

pub fn register(registry: &mut AdminRegistry, db: DatabaseConnection) -> UserRepository {
    let app_key = registry.register_app("Auth");
    let repo = UserRepository::new(db);
    let model_config = AdminModelConfig {
        app_key: app_key,
        name: "User".to_owned(),
    };
    let model_result = registry.register_model(model_config, repo.clone());
    match model_result {
        Err(err) => panic!("{}", err),
        _ => repo,
    }
}