194c44c
use std::collections::HashMap;
use std::sync::Arc;
use config::AppConfig;
use export::AppState;
use export::database::AppDatabase;
use models::users::user;
use sandbox_rpc::SandboxRpcClient;
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
use space::services::spaces::UserDto;
use uuid::Uuid;
use crate::errors::AgentError;
#[derive(Clone)]
pub struct AgentsService {
pub state: AppState,
rpc: Option<SandboxRpcClient>,
}
impl AgentsService {
pub fn new(state: AppState) -> Self {
let rpc = match SandboxRpcClient::from_config(&state.config.sandbox_rpc) {
Ok(client) => client,
Err(error) => {
tracing::warn!(%error, "sandbox rpc disabled: invalid configuration");
None
}
};
Self { state, rpc }
}
pub fn config(&self) -> &AppConfig {
&self.state.config
}
pub fn db(&self) -> &Arc<AppDatabase> {
&self.state.database
}
pub fn rpc(&self) -> Result<&SandboxRpcClient, AgentError> {
self.rpc.as_ref().ok_or_else(|| {
AgentError::RuntimeUnavailable("sandbox runtime is not configured".to_string())
})
}
pub fn rpc_opt(&self) -> Option<&SandboxRpcClient> {
self.rpc.as_ref()
}
pub fn paginate(&self, limit: Option<u64>, offset: Option<u64>) -> (u64, u64) {
let max_pagination = self.config().agents.max_pagination.max(1);
let default_pagination = self.config().agents.default_pagination.max(1);
(
limit.unwrap_or(default_pagination).clamp(1, max_pagination),
offset.unwrap_or(0).clamp(0, 5000),
)
}
pub async fn load_user_briefs(
&self,
uids: &[i64],
) -> Result<HashMap<i64, UserDto>, AgentError> {
if uids.is_empty() {
return Ok(HashMap::new());
}
let mut set: Vec<i64> = uids.to_vec();
set.sort();
set.dedup();
let users = user::Entity::find()
.filter(user::Column::Uid.is_in(set))
.all(self.db().read())
.await?;
Ok(users
.into_iter()
.map(|u| (u.uid, UserDto::from(u)))
.collect())
}
}