i/Aether
1
0
Fork 0
mirror of https://github.com/fawney19/Aether.git synced 2026-10-11 19:59:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: 大规模模块拆分与重组，新增 aether-admin crate

Browse Source 
- 新建独立 aether-admin crate 承载 admin 相关共享契约与纯辅助函数
- 拆分 ai_pipeline 下 kiro/private_envelope/conversion/planner 等大文件为子模块目录
- 重组 admin handlers 各业务域（billing/oauth/provider/system/users 等）为目录结构，移除 shared.rs/builders.rs 等反模式
- 移除 ai_pipeline runtime adapters 旧实现（claude/openai/gemini/kiro/vertex/antigravity 等），改由 provider transport 统一承载
- 移除 control_facade/execution_facade/auth_snapshot_facade 等冗余 facade 层
- 拆分 query/billing 与 query/monitoring 模块、state/runtime/payments 与 security 模块
- 扩展架构测试覆盖 admin_billing/admin_model/admin_users 等新模块
- 删除 docs/architecture/refactor-execution-plan.md 已完成的执行计划文档
This commit is contained in:
fawney19
2026-04-09 00:10:38 +08:00
parent 4fb9882b54
commit 4fc95adfb9
663 changed files with 48471 additions and 40232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/aether-gateway/src/handlers/admin/provider/oauth/duplicates.rs
+223
View File
@@ -0,0 +1,223 @@
use crate::handlers::admin::request::AdminAppState;
use aether_data_contracts::repository::provider_catalog::StoredProviderCatalogKey;
fn normalize_codex_plan_group_for_provider_oauth(
plan_type: Option<&serde_json::Value>,
) -> Option<String> {
let normalized = plan_type
.and_then(serde_json::Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty())?
.to_ascii_lowercase();
match normalized.as_str() {
"free" => Some("free".to_string()),
"team" | "plus" | "enterprise" => Some("team_plus_enterprise".to_string()),
_ => None,
}
}
fn normalize_provider_oauth_identity_value(value: Option<&serde_json::Value>) -> Option<String> {
value
.and_then(serde_json::Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty())
.map(ToOwned::to_owned)
}
fn is_codex_provider_oauth_provider_type(value: Option<&serde_json::Value>) -> bool {
value
.and_then(serde_json::Value::as_str)
.map(str::trim)
.is_some_and(|provider_type| provider_type.eq_ignore_ascii_case("codex"))
}
fn match_codex_provider_oauth_identity(
new_auth_config: &serde_json::Map<String, serde_json::Value>,
existing_auth_config: &serde_json::Map<String, serde_json::Value>,
) -> Option<bool> {
let new_provider_type = new_auth_config.get("provider_type");
let existing_provider_type = existing_auth_config.get("provider_type");
if !is_codex_provider_oauth_provider_type(new_provider_type)
&& !is_codex_provider_oauth_provider_type(existing_provider_type)
{
return None;
}
let new_account_user_id =
normalize_provider_oauth_identity_value(new_auth_config.get("account_user_id"));
let existing_account_user_id =
normalize_provider_oauth_identity_value(existing_auth_config.get("account_user_id"));
if let (Some(new_account_user_id), Some(existing_account_user_id)) =
(new_account_user_id, existing_account_user_id)
{
return Some(new_account_user_id == existing_account_user_id);
}
let new_account_id = normalize_provider_oauth_identity_value(new_auth_config.get("account_id"));
let existing_account_id =
normalize_provider_oauth_identity_value(existing_auth_config.get("account_id"));
let new_user_id = normalize_provider_oauth_identity_value(new_auth_config.get("user_id"));
let existing_user_id =
normalize_provider_oauth_identity_value(existing_auth_config.get("user_id"));
let new_email = normalize_provider_oauth_identity_value(new_auth_config.get("email"));
let existing_email = normalize_provider_oauth_identity_value(existing_auth_config.get("email"));
if let (Some(new_account_id), Some(existing_account_id)) =
(new_account_id.as_deref(), existing_account_id.as_deref())
{
if new_account_id != existing_account_id {
return Some(false);
}
}
if let (
Some(new_account_id),
Some(existing_account_id),
Some(new_user_id),
Some(existing_user_id),
) = (
new_account_id.as_deref(),
existing_account_id.as_deref(),
new_user_id.as_deref(),
existing_user_id.as_deref(),
) {
return Some(new_account_id == existing_account_id && new_user_id == existing_user_id);
}
if let (
Some(new_account_id),
Some(existing_account_id),
Some(new_email),
Some(existing_email),
) = (
new_account_id.as_deref(),
existing_account_id.as_deref(),
new_email.as_deref(),
existing_email.as_deref(),
) {
return Some(new_account_id == existing_account_id && new_email == existing_email);
}
None
}
fn is_codex_cross_plan_group_non_duplicate(
new_auth_config: &serde_json::Map<String, serde_json::Value>,
existing_auth_config: &serde_json::Map<String, serde_json::Value>,
) -> bool {
let new_provider_type = new_auth_config.get("provider_type");
let existing_provider_type = existing_auth_config.get("provider_type");
if !is_codex_provider_oauth_provider_type(new_provider_type)
&& !is_codex_provider_oauth_provider_type(existing_provider_type)
{
return false;
}
let new_group = normalize_codex_plan_group_for_provider_oauth(new_auth_config.get("plan_type"));
let existing_group =
normalize_codex_plan_group_for_provider_oauth(existing_auth_config.get("plan_type"));
matches!(
(new_group.as_deref(), existing_group.as_deref()),
(Some(left), Some(right)) if left != right
)
}
pub(crate) async fn find_duplicate_provider_oauth_key(
state: &AdminAppState<'_>,
provider_id: &str,
auth_config: &serde_json::Map<String, serde_json::Value>,
exclude_key_id: Option<&str>,
) -> Result<Option<StoredProviderCatalogKey>, String> {
let new_email = normalize_provider_oauth_identity_value(auth_config.get("email"));
let new_user_id = normalize_provider_oauth_identity_value(auth_config.get("user_id"));
let new_auth_method = normalize_provider_oauth_identity_value(auth_config.get("auth_method"));
if new_email.is_none() && new_user_id.is_none() {
return Ok(None);
}
let existing_keys = state
.list_provider_catalog_keys_by_provider_ids(&[provider_id.to_string()])
.await
.map_err(|err| format!("{err:?}"))?;
for existing_key in existing_keys.into_iter().filter(|key| {
key.auth_type.trim().eq_ignore_ascii_case("oauth")
&& exclude_key_id.is_none_or(|exclude| key.id != exclude)
}) {
let Some(existing_auth_config) = state.parse_catalog_auth_config_json(&existing_key) else {
continue;
};
let existing_email =
normalize_provider_oauth_identity_value(existing_auth_config.get("email"));
let existing_user_id =
normalize_provider_oauth_identity_value(existing_auth_config.get("user_id"));
let existing_auth_method =
normalize_provider_oauth_identity_value(existing_auth_config.get("auth_method"));
let mut is_duplicate = false;
let codex_identity_match =
match_codex_provider_oauth_identity(auth_config, &existing_auth_config);
if let Some(codex_identity_match) = codex_identity_match {
is_duplicate = codex_identity_match;
}
if codex_identity_match.is_none()
&& !is_duplicate
&& new_user_id.is_some()
&& existing_user_id.is_some()
&& new_user_id == existing_user_id
&& !is_codex_cross_plan_group_non_duplicate(auth_config, &existing_auth_config)
{
is_duplicate = true;
}
if codex_identity_match.is_none()
&& !is_duplicate
&& new_email.is_some()
&& existing_email.is_some()
&& new_email == existing_email
{
let is_kiro = auth_config
.get("provider_type")
.and_then(serde_json::Value::as_str)
.is_some_and(|value| value.eq_ignore_ascii_case("kiro"))
|| existing_auth_config
.get("provider_type")
.and_then(serde_json::Value::as_str)
.is_some_and(|value| value.eq_ignore_ascii_case("kiro"));
if is_kiro {
if new_auth_method.is_some()
&& existing_auth_method.is_some()
&& new_auth_method
.as_deref()
.zip(existing_auth_method.as_deref())
.is_some_and(|(left, right)| left.eq_ignore_ascii_case(right))
{
is_duplicate = true;
}
} else if !is_codex_cross_plan_group_non_duplicate(auth_config, &existing_auth_config) {
is_duplicate = true;
}
}
if !is_duplicate {
continue;
}
if !existing_key.is_active {
return Ok(Some(existing_key));
}
let identifier =
normalize_provider_oauth_identity_value(auth_config.get("account_user_id"))
.or_else(|| normalize_provider_oauth_identity_value(auth_config.get("account_id")))
.or_else(|| new_email.clone())
.or_else(|| new_user_id.clone())
.unwrap_or_default();
return Err(format!(
"该 OAuth 账号 ({identifier}) 已存在于当前 Provider 中（名称: {}）",
existing_key.name
));
}
Ok(None)
}