web3-proxy/web3_proxy/src/admin_queries.rs

128 lines
4.3 KiB
Rust
Raw Normal View History

2023-02-19 23:27:53 +03:00
use crate::app::Web3ProxyApp;
use crate::frontend::errors::FrontendErrorResponse;
use crate::user_queries::get_user_id_from_params;
use anyhow::Context;
2023-03-01 22:23:59 +03:00
use axum::response::{IntoResponse, Response};
2023-02-19 23:27:53 +03:00
use axum::{
headers::{authorization::Bearer, Authorization},
2023-03-01 22:23:59 +03:00
Json, TypedHeader,
2023-02-19 23:27:53 +03:00
};
2023-02-10 20:48:51 +03:00
use entities::{admin, login, user, user_tier};
2023-02-19 23:27:53 +03:00
use ethers::prelude::Address;
use hashbrown::HashMap;
2023-03-01 22:23:59 +03:00
use log::{debug, info};
use migration::sea_orm::{
self, ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter,
};
2023-02-19 23:27:53 +03:00
2023-02-19 23:34:39 +03:00
// TODO: Add some logic to check if the operating user is an admin
// If he is, return true
// If he is not, return false
// This function is used to give permission to certain users
2023-02-19 23:27:53 +03:00
pub async fn query_admin_modify_usertier<'a>(
app: &'a Web3ProxyApp,
bearer: Option<TypedHeader<Authorization<Bearer>>>,
2023-03-01 22:23:59 +03:00
params: &'a HashMap<String, String>,
2023-02-19 23:27:53 +03:00
) -> Result<Response, FrontendErrorResponse> {
// Quickly return if any of the input tokens are bad
let user_address: Vec<u8> = params
.get("user_address")
2023-03-01 22:23:59 +03:00
.ok_or_else(|| {
FrontendErrorResponse::BadRequest(
"Unable to find user_address key in request".to_string(),
)
})?
2023-02-19 23:27:53 +03:00
.parse::<Address>()
2023-03-01 22:23:59 +03:00
.map_err(|_| {
FrontendErrorResponse::BadRequest(
"Unable to parse user_address as an Address".to_string(),
)
})?
.to_fixed_bytes()
.into();
let user_tier_title = params.get("user_tier_title").ok_or_else(|| {
FrontendErrorResponse::BadRequest(
"Unable to get the user_tier_title key from the request".to_string(),
)
})?;
2023-02-19 23:27:53 +03:00
// Prepare output body
let mut response_body = HashMap::new();
// Establish connections
2023-03-01 22:23:59 +03:00
let db_conn = app
.db_conn()
.context("query_admin_modify_user needs a db")?;
2023-02-19 23:27:53 +03:00
let db_replica = app
.db_replica()
.context("query_user_stats needs a db replica")?;
let mut redis_conn = app
.redis_conn()
.await
.context("query_admin_modify_user had a redis connection error")?
.context("query_admin_modify_user needs a redis")?;
// Will modify logic here
2023-02-19 23:27:53 +03:00
// Try to get the user who is calling from redis (if existent) / else from the database
// TODO: Make a single query, where you retrieve the user, and directly from it the secondary user (otherwise we do two jumpy, which is unnecessary)
// get the user id first. if it is 0, we should use a cache on the app
2023-03-01 22:23:59 +03:00
let caller_id =
get_user_id_from_params(&mut redis_conn, &db_conn, &db_replica, bearer, params).await?;
2023-02-19 23:27:53 +03:00
debug!("Caller id is: {:?}", caller_id);
2023-02-19 23:27:53 +03:00
// Check if the caller is an admin (i.e. if he is in an admin table)
2023-03-01 22:23:59 +03:00
let _admin: admin::Model = admin::Entity::find()
.filter(admin::Column::UserId.eq(caller_id))
.one(&db_conn)
2023-02-19 23:27:53 +03:00
.await?
.ok_or(FrontendErrorResponse::AccessDenied)?;
2023-02-19 23:27:53 +03:00
// If we are here, that means an admin was found, and we can safely proceed
// Fetch the admin, and the user
let user: user::Model = user::Entity::find()
.filter(user::Column::Address.eq(user_address))
.one(&db_conn)
2023-02-19 23:27:53 +03:00
.await?
2023-03-01 22:23:59 +03:00
.ok_or(FrontendErrorResponse::BadRequest(
"No user with this id found".to_string(),
))?;
2023-02-19 23:27:53 +03:00
// Return early if the target user_tier_id is the same as the original user_tier_id
response_body.insert(
"user_tier_title",
serde_json::Value::Number(user.user_tier_id.into()),
2023-02-19 23:27:53 +03:00
);
// Now we can modify the user's tier
2023-02-10 20:48:51 +03:00
let new_user_tier: user_tier::Model = user_tier::Entity::find()
2023-02-19 23:27:53 +03:00
.filter(user_tier::Column::Title.eq(user_tier_title.clone()))
.one(&db_conn)
2023-02-19 23:27:53 +03:00
.await?
2023-03-01 22:23:59 +03:00
.ok_or(FrontendErrorResponse::BadRequest(
"User Tier name was not found".to_string(),
))?;
2023-02-19 23:27:53 +03:00
if user.user_tier_id == new_user_tier.id {
info!("user already has that tier");
} else {
2023-02-10 20:48:51 +03:00
let mut user = user.clone().into_active_model();
2023-02-19 23:27:53 +03:00
user.user_tier_id = sea_orm::Set(new_user_tier.id);
user.save(&db_conn).await?;
info!("user's tier changed");
}
2023-03-01 22:23:59 +03:00
// Now delete all bearer tokens of this user
2023-02-10 20:48:51 +03:00
login::Entity::delete_many()
.filter(login::Column::UserId.eq(user.id))
.exec(&db_conn)
.await?;
2023-02-19 23:27:53 +03:00
Ok(Json(&response_body).into_response())
}