Merge pull request #93 from xpack-ai/feature/resource_group

Resource group functionality complete
This commit is contained in:
Dot.L authored and GitHub committed 2025-12-22 11:08:57 +08:00
commit 8f340cb3d5
34 files changed
+1362 -98

No files matched your search

+1
View File
@@ -0,0 +1 @@
/mcp.json
+34
View File
@@ -0,0 +1,34 @@
SET FOREIGN_KEY_CHECKS=0;
CREATE TABLE `resource_group` (
`id` char(36) NOT NULL COMMENT 'Primary key, group UUID',
`name` varchar(255) NOT NULL COMMENT 'Group name',
`description` text NULL COMMENT 'Group description',
`enabled` tinyint NOT NULL DEFAULT 1 COMMENT 'Group status: 0=disabled, 1=enabled',
`created_at` timestamp NULL DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL,
PRIMARY KEY (`id`),
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='Resource group table';
CREATE TABLE `resource_group_service_map` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT 'Primary key',
`group_id` char(36) NOT NULL COMMENT 'Resource group UUID',
`service_id` char(36) NOT NULL COMMENT 'MCP service UUID',
`created_at` timestamp NULL DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `uq_group_service` (`group_id`, `service_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='Resource group to MCP service mapping';
ALTER TABLE `user` ADD `group_id` char(36) NULL COMMENT 'Resource group UUID';
UPDATE `user` SET `group_id` = 'allow-all' WHERE `group_id` IS NULL;
INSERT INTO `sys_config` (`id`,`key`, `value`,`description`,`created_at`,`updated_at`)
VALUES ('xpack-resource-group-version','default_resource_group', 'allow-all', 'Default resource group for new users', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `description` = VALUES(`description`), `updated_at` = CURRENT_TIMESTAMP;
INSERT INTO `sys_config` (`id`,`key`, `value`,`description`,`created_at`,`updated_at`)
VALUES ('xpack-version','version', '1.2.0', 'Add resource group tables', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `description` = VALUES(`description`), `updated_at` = CURRENT_TIMESTAMP;
SET FOREIGN_KEY_CHECKS=1;
+3 -3
View File
@@ -1,11 +1,11 @@
{
"version": "v1.1",
"releaseDate": "2025-12-07",
"version": "v1.2",
"releaseDate": "2025-12-22",
"description": "This is the latest release of the application.",
"downloads": {
"program": {
"xpack_mcp_market": {
"version": "v1.1.5",
"version": "v1.2.0",
"docker": "xpackai/xpack-mcp-market",
"tar": "xpack-mcp-market.tar.gz",
"url": "https://public.eolinker.com/xpack/images/xpack-mcp-market.${VERSION}.${ARCH}.tar.gz"
@@ -41,4 +41,6 @@ KEY_FACEBOOK_IMAGE_URL = "facebook_image_url"
KEY_SOCIAL_ACCOUNT_FACEBOOK_URL = "social_account_facebook_url"
KEY_SOCIAL_ACCOUNT_X_URL = "social_account_x_url"
KEY_CNAME_A_IP = "cname_a_ip"
KEY_CNAME_A_IP = "cname_a_ip"
KEY_DEFAULT_RESOURCE_GROUP = "default_resource_group"
+10 -4
View File
@@ -38,15 +38,21 @@ def email_login(
if not email or not password:
return ResponseUtils.error(message="email and password required", code=400)
token = auth_service.email_login_by_password(email=email, password=password)
if token:
return ResponseUtils.success({"user_token": token})
else:
return ResponseUtils.error(message="login failed, please enter the correct account or password", code=401)
case "captcha":
captcha = body.get("captcha")
if not email or not captcha:
return ResponseUtils.error(message="email and captcha required", code=400)
token = auth_service.email_login_by_captcha(email=email, captcha=captcha)
if token:
return ResponseUtils.success({"user_token": token})
else:
return ResponseUtils.error(message="login failed", code=401)
if token:
return ResponseUtils.success({"user_token": token})
else:
return ResponseUtils.error(message="login failed, please enter the correct captcha", code=401)
case _:
return ResponseUtils.error(message="email login mode not supported", code=400)
@router.post("/email/send_captcha", response_model=dict)
@@ -3,9 +3,7 @@
Includes endpoints to enable/disable services, update/delete services,
import OpenAPI definitions, and query service info and lists.
"""
import uuid
import logging
from annotated_types import Not
from fastapi import APIRouter, Depends, Request, Body, UploadFile, File, HTTPException, Form
from pydantic import BaseModel, HttpUrl
from typing import Optional
@@ -15,12 +13,10 @@ from services.common.utils.response_utils import ResponseUtils
from services.common.utils.validation_utils import ValidationUtils
from services.admin_service.services.openapi_manager import openapi_manager
from services.admin_service.services.mcp_manager_service import McpManagerService, parse_tags_to_array
from services.common.utils.cache_utils import CacheUtils
from services.common.redis_keys import RedisKeys
from services.admin_service.utils.user_utils import UserUtils
from services.common import error_msg
from services.common.models.mcp_service import ChargeType
from services.admin_service.services.resource_group_service import ResourceGroupService
logger = logging.getLogger(__name__)
@@ -35,6 +31,8 @@ class OpenApiRequest(BaseModel):
def get_mcp_manager(db: Session = Depends(get_db)) -> McpManagerService:
return McpManagerService(db)
def get_resource_group_service(db: Session = Depends(get_db)) -> ResourceGroupService:
return ResourceGroupService(db)
@router.put("/service/enabled", summary="On/Off MCP service")
def update_mcp_service_enabled(request: Request, body: dict = Body(...), mcp_manager_service: McpManagerService = Depends(get_mcp_manager)):
@@ -225,11 +223,7 @@ def get_mcp_service_list(
"slug_name": service.slug_name,
"short_description": service.short_description,
"long_description": service.long_description,
# "auth_method": service.auth_method.value if service.auth_method else None,
"base_url": service.base_url,
# "headers": json.loads(service.headers) if service.headers else [],
# "auth_header": service.auth_header,
# "auth_token": service.auth_token,
"charge_type": service.charge_type.value if service.charge_type else None,
"price": str(float(service.price)) if service.price and service.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(service.input_token_price)) if service.input_token_price and service.charge_type == ChargeType.PER_TOKEN else "0.00",
@@ -245,3 +239,125 @@ def get_mcp_service_list(
except Exception as e:
logger.error(f"Failed to get service list: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.get("/service/list/simple", summary="Get MCP service simple list")
def get_mcp_service_simple_list(
request: Request, mcp_manager_service: McpManagerService = Depends(get_mcp_manager)
):
"""Get paginated list of all MCP services."""
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
try:
# Fetch paginated data
services = mcp_manager_service.get_all()
service_list = [
{
"id": service.id,
"name": service.name,
"slug_name": service.slug_name,
"base_url": service.base_url,
"charge_type": service.charge_type.value if service.charge_type else None,
"price": str(float(service.price)) if service.price and service.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(service.input_token_price)) if service.input_token_price and service.charge_type == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(service.output_token_price)) if service.output_token_price and service.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": service.enabled,
}
for service in services
]
return ResponseUtils.success(data=service_list)
except Exception as e:
logger.error(f"Failed to get service simple list: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.get("/service/resource_group/list", summary="Get MCP service's resource group list")
def get_mcp_service_resource_group_list(
request: Request,
id: str,
page: int = 1,
page_size: int = 10,
keyword: Optional[str] = None,
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
"""Get paginated list of all MCP services' resource groups."""
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
try:
# Fetch paginated data
list,total = resource_group_service.get_bind_groups(id, page=page, page_size=page_size, keyword=keyword)
return ResponseUtils.success_page(data=list, page_num=page, page_size=page_size, total=total)
except Exception as e:
logger.error(f"Failed to get service simple list: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.get("/service/resource_group/list/unbind", summary="Get MCP service's unbind resource group list")
def get_mcp_service_unbind_resource_group_list(
request: Request,
id: str,
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
"""Get paginated list of all MCP services' unbind resource groups."""
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
try:
# Fetch paginated data
list = resource_group_service.get_unbind_groups(id)
return ResponseUtils.success(data=list)
except Exception as e:
logger.error(f"Failed to get unbind resource group list: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.put("/service/resource_group", summary="Bind resource groups to MCP service")
def bind_group(
request: Request,
id: str,
body: dict = Body(...),
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
"""Bind resource groups to MCP service."""
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
group_ids = body.get("resource_groups")
if not group_ids:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
try:
# Fetch paginated data
resource_group_service.bind_groups(id, group_ids)
return ResponseUtils.success()
except Exception as e:
logger.error(f"Failed to bind resource groups: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.delete("/service/resource_group", summary="Unbind resource groups from MCP service")
def unbind_group(
request: Request,
id: str,
body: dict = Body(...),
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
"""Unbind resource groups from MCP service."""
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
group_ids = body.get("resource_groups")
if not group_ids:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
try:
# Fetch paginated data
resource_group_service.unbind_groups(id, group_ids)
return ResponseUtils.success()
except Exception as e:
logger.error(f"Failed to unbind resource groups: {str(e)}")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@@ -0,0 +1,146 @@
import logging
import uuid
from fastapi import APIRouter, Depends, Request, Body
from sqlalchemy.orm import Session
from services.common.database import get_db
from services.common.utils.response_utils import ResponseUtils
from services.admin_service.utils.user_utils import UserUtils
from services.common import error_msg
from services.admin_service.services.resource_group_service import ResourceGroupService
from services.admin_service.services.sys_config_service import SysConfigService
logger = logging.getLogger(__name__)
router = APIRouter()
def get_sysconfig_service(db: Session = Depends(get_db)) -> SysConfigService:
return SysConfigService(db)
def get_resource_group_service(db: Session = Depends(get_db)) -> ResourceGroupService:
return ResourceGroupService(db)
@router.post("", summary="Create resource group")
def create_group(request: Request, body: dict = Body(...), svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
gid = body.get("id")
if not gid:
gid = str(uuid.uuid4())
name = body.get("name")
description = body.get("description")
if not name:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
is_default = body.get("is_default", False)
try:
gid = svc.create_group(gid=gid, name=name, description=description, is_default=is_default)
except ValueError as e:
return ResponseUtils.error(message=str(e))
return ResponseUtils.success(data={"id": gid})
@router.put("", summary="Update resource group")
def update_group(request: Request,id: str, body: dict = Body(...), svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
try:
svc.update_group(id, body)
return ResponseUtils.success()
except ValueError as e:
return ResponseUtils.error(message=str(e))
except Exception:
logger.exception("Failed to update group")
return ResponseUtils.error(error_msg=error_msg.INTERNAL_ERROR)
@router.delete("", summary="Delete resource group")
def delete_group(request: Request, id: str, migrate_id: str | None = None, svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
ok = svc.delete_group(id, migrate_id)
if not ok:
return ResponseUtils.error(error_msg=error_msg.NOT_FOUND)
return ResponseUtils.success()
@router.get("/info", summary="Get resource group info")
def get_group_info(request: Request, id: str, svc: ResourceGroupService = Depends(get_resource_group_service), sys_svc: SysConfigService = Depends(get_sysconfig_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
info = svc.get_info(id)
if not info:
return ResponseUtils.error(error_msg=error_msg.NOT_FOUND)
return ResponseUtils.success(data=info)
@router.get("/list", summary="Get resource group list")
def get_group_list(request: Request, page: int = 1, page_size: int = 10, keyword: str | None = None, svc: ResourceGroupService = Depends(get_resource_group_service), sys_svc: SysConfigService = Depends(get_sysconfig_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
groups, total = svc.list_groups(page=page, page_size=page_size, keyword=keyword)
return ResponseUtils.success_page(data=groups, page_num=page, page_size=page_size, total=total)
@router.get("/list/simple", summary="Get resource group simple list")
def get_simple_group_list(request: Request, svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
groups = svc.simple_list_groups()
data = [
{
"id": g.id,
"name": g.name,
"created_at": str(g.created_at) if g.created_at else None,
}
for g in groups
]
return ResponseUtils.success(data=data)
@router.put("/service", summary="Bind services to group")
def bind_services(request: Request,id:str, body: dict = Body(...), svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
if not id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
sids = body.get("services") or []
svc.bind_services(id, list(map(str, sids)))
return ResponseUtils.success()
@router.get("/service/list", summary="List services bound to group")
def list_bind_services(request: Request, id: str, page: int = 1, page_size: int = 10, keyword: str | None = None, svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
services,total = svc.get_bind_services(id, page=page, page_size=page_size, keyword=keyword)
return ResponseUtils.success_page(data=services, page_num=page, page_size=page_size, total=total)
@router.get("/service/list/unbind", summary="List services bound to group")
def list_unbind_services(request: Request, id: str, svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
services = svc.get_unbind_services(id)
return ResponseUtils.success(data=services)
@router.delete("/service", summary="Unbind one service from group")
def unbind_service(request: Request,id: str, body: dict = Body(...), svc: ResourceGroupService = Depends(get_resource_group_service)):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
sids = body.get("services")
if not id or not sids:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
svc.unbind_service(id, sids)
return ResponseUtils.success()
@@ -5,10 +5,6 @@ and to test email settings. All responses and comments are standardized in Engli
"""
from fastapi import APIRouter, Depends, Body
import json
import socket
import urllib.request
from typing import Optional
from sqlalchemy import false, table
from sqlalchemy.orm import Session
from services.common.database import get_db
from services.common.utils.response_utils import ResponseUtils
@@ -19,6 +15,10 @@ from services.admin_service.services.platform_report_service import PlatformRepo
from services.admin_service.constants import sys_config_key
from services.common.logging_config import get_logger
from services.admin_service.utils.ip import get_public_ip, get_local_ip
from services.common.utils.validation_utils import ValidationUtils
from services.common.exceptions import ValidationException
logger = get_logger(__name__)
@@ -241,7 +241,12 @@ def set_sysconfig(
email_smtp_password = email_config.get("smtp_password")
email_smtp_sender = email_config.get("smtp_sender")
if not domain:
# 正则检查domain格式
try:
domain = ValidationUtils.validate_domain(domain)
except ValidationException as e:
return ResponseUtils.error(message=str(e), code=400)
# Batch update configuration
configs = [
+14 -2
View File
@@ -9,6 +9,7 @@ from services.admin_service.utils.user_utils import UserUtils
from services.admin_service.services.user_wallet_service import UserWalletService
from services.admin_service.services.user_task_service import UserTaskService
from services.admin_service.services.auth_service import AuthService
from services.admin_service.services.resource_group_service import ResourceGroupService
router = APIRouter()
@@ -23,8 +24,11 @@ def get_auth_service(db: Session = Depends(get_db)) -> AuthService:
def get_user_task_service(db: Session = Depends(get_db)) -> UserTaskService:
return UserTaskService(db)
def get_resource_group_service(db: Session = Depends(get_db)) -> ResourceGroupService:
return ResourceGroupService(db)
@router.get("/info", response_model=dict)
def get_user(request: Request, user_wallet: UserWalletService = Depends(get_user_wallet), user_task: UserTaskService = Depends(get_user_task_service)):
def get_user(request: Request, user_wallet: UserWalletService = Depends(get_user_wallet), user_task: UserTaskService = Depends(get_user_task_service), resource_group_service: ResourceGroupService = Depends(get_resource_group_service)):
"""Get current user information and wallet balance."""
user_response = UserResponse()
user_wallet_resp = UserWalletResponse()
@@ -35,7 +39,15 @@ def get_user(request: Request, user_wallet: UserWalletService = Depends(get_user
user_wallet_info = user_wallet.get_by_user_id(user.id)
if user_wallet_info:
user_wallet_resp.balance = user_wallet_info.balance
if not user.group_id:
user.group_id = "allow-all"
if user.group_id == "allow-all":
user_response.allow_all = True
elif user.group_id == "deny-all":
user_response.allow_all = False
else:
service_ids = resource_group_service.get_bind_service_ids(user.group_id)
user_response.service_ids = service_ids
user_response.user_id = user.id
user_response.user_name = user.name
user_response.user_email = user.email
@@ -3,13 +3,18 @@ from sqlalchemy.orm import Session
from fastapi import Depends
from services.admin_service.services.user_service import UserService
from services.admin_service.services.user_wallet_service import UserWalletService
from services.admin_service.services.resource_group_service import ResourceGroupService
from services.common.database import get_db
from services.common.response.user_manager_response import UserManagerResponse
from services.common.utils.response_utils import ResponseUtils
from services.common.utils.validation_utils import ValidationUtils
from services.common.logging_config import get_logger
import json,hashlib
from services.common import error_msg
from services.admin_service.services.payment_service import PaymentService
from services.admin_service.utils.user_utils import UserUtils
logger = get_logger(__name__)
@@ -20,6 +25,10 @@ def get_user_wallet_service(db: Session = Depends(get_db)) -> UserWalletService:
return UserWalletService(db)
def get_resource_group_service(db: Session = Depends(get_db)) -> ResourceGroupService:
return ResourceGroupService(db)
def get_user_service(db: Session = Depends(get_db)) -> UserService:
return UserService(db)
@@ -27,6 +36,31 @@ def get_payment_service(db: Session = Depends(get_db)) -> PaymentService:
return PaymentService(db)
@router.put("/resource_group", summary="update user resource group")
async def update_user_resource_group(
request: Request,
body: dict = Body(...),
user_service: UserService = Depends(get_user_service),
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
if not UserUtils.is_admin(request):
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
"""Update user resource group."""
user_id = body.get("user_id")
group_id = body.get("resource_group")
if not user_id or not group_id:
return ResponseUtils.error(error_msg=error_msg.MISSING_PARAMETER)
group = resource_group_service.get_info(group_id)
if not group:
return ResponseUtils.error(error_msg=error_msg.RESOURCE_NOT_FOUND)
user = user_service.get_by_id(user_id)
if not user:
return ResponseUtils.error(error_msg=error_msg.USER_NOT_FOUND)
user_service.update_resource_group(user_id, group_id)
return ResponseUtils.success()
@router.delete("/account", summary="Delete user account")
async def delete_user(
id: str,
@@ -76,7 +110,13 @@ async def get_user_list(
user_list = []
for user in users:
wallet = user_wallet_service.get_by_user_id(user.id)
user_list.append({"id": user.id, "email": user.email, "created_at": user.created_at, "balance": wallet.balance if wallet else 0})
user_list.append(
{"id": user.id,
"email": user.email,
"created_at": user.created_at,
"balance": wallet.balance if wallet else 0,
"group_id": user.group_id if user.group_id else "allow-all",
})
return ResponseUtils.success_page(data=user_list, total=total, page_num=page, page_size=page_size)
@@ -92,7 +132,6 @@ async def recharge_balance(
# calculate md5 hash of the body and timestamp
md5_hash = hashlib.md5(f"{timestamp}{body_str}".encode('utf-8')).hexdigest()
calculated_sign = hashlib.sha256(md5_hash.encode('utf-8')).hexdigest()
print(f"sign: {sign}, calculated_sign: {calculated_sign},md5_hash: {md5_hash}")
if sign != calculated_sign:
return ResponseUtils.error(message="Invalid signature")
try:
@@ -107,7 +146,6 @@ async def recharge_balance(
transaction_id = hashlib.md5(f"{timestamp}{user_id}{balance}{typ}".encode('utf-8')).hexdigest()
if payment_service.check_transaction_id_exists(transaction_id):
return ResponseUtils.error(message="Transaction ID already exists")
print(f"user_id: {user_id}, amount: {balance}, typ: {typ}, transaction_id: {transaction_id}")
success = payment_service.platform_payment(user_id=user_id, amount=balance, typ=typ, transaction_id=transaction_id)
if not success:
return ResponseUtils.error(message="Failed to recharge wallet balance")
+14 -2
View File
@@ -1,4 +1,4 @@
from fastapi import APIRouter, Depends, Query
from fastapi import APIRouter, Depends, Query, Request
from sqlalchemy.orm import Session
from typing import Optional
from services.common.database import get_db
@@ -6,6 +6,11 @@ from services.common.utils.response_utils import ResponseUtils
from services.common.utils.validation_utils import ValidationUtils
from services.admin_service.services.mcp_manager_service import McpManagerService
from services.common.logging_config import get_logger
from services.admin_service.utils.user_utils import UserUtils
from services.admin_service.services.resource_group_service import ResourceGroupService
from services.common import error_msg
logger = get_logger(__name__)
@@ -15,6 +20,9 @@ router = APIRouter(tags=["front"])
def get_mcp_manager(db: Session = Depends(get_db)) -> McpManagerService:
return McpManagerService(db)
def get_resource_group_service(db: Session = Depends(get_db)) -> ResourceGroupService:
return ResourceGroupService(db)
@router.get("/mcp_services", summary="Get public MCP services list")
def get_public_mcp_services(
@@ -44,8 +52,10 @@ def get_public_mcp_services(
@router.get("/mcp_service_info", summary="Get public MCP service information")
def get_public_mcp_service_info(
request: Request,
id: str = Query(..., description="Service ID"),
mcp_manager_service: McpManagerService = Depends(get_mcp_manager),
resource_group_service: ResourceGroupService = Depends(get_resource_group_service),
):
"""Get detailed information of a public MCP service by ID."""
@@ -56,7 +66,9 @@ def get_public_mcp_service_info(
# Get service information - let any exception bubble up to middleware
service_info = mcp_manager_service.get_public_service_info(id)
if not service_info:
return ResponseUtils.error(error_msg=error_msg.RESOURCE_NOT_FOUND)
# Validate that service exists
ValidationUtils.require_resource_exists(service_info, "service")
+2
View File
@@ -25,6 +25,7 @@ from services.admin_service.controllers import user_stats
from services.admin_service.controllers import email_test
from services.admin_service.controllers import upload
from services.admin_service.controllers import user_task
from services.admin_service.controllers import resource_group
@@ -168,6 +169,7 @@ app.include_router(user_stats.router, prefix="/api/stats")
app.include_router(email_test.router, prefix="/api/email_test")
app.include_router(upload.router, prefix="/api/upload")
app.include_router(user_task.router, prefix="/api/onboarding")
app.include_router(resource_group.router, prefix="/api/resource_group")
+1 -1
View File
@@ -19,7 +19,7 @@ class AuthMiddleware:
def __init__(self, app):
self.app = app
logger.info(f"AuthMiddleware initialized, no-auth paths: {len(Config.NO_AUTH_PATHS)} paths configured")
async def __call__(self, scope, receive, send):
if scope["type"] == "http":
# Get request path
@@ -54,25 +54,41 @@ class McpServiceRepository:
def get_by_id(self, id: str) -> Optional[McpService]:
"""Get a service by primary ID."""
return self.db.query(McpService).filter(McpService.id == id).first()
def get_by_ids(self, ids: List[str]) -> List[McpService]:
"""Get services by primary IDs."""
return self.db.query(McpService).filter(McpService.id.in_(ids)).all()
def get_by_slug_name(self, slug_name: str) -> Optional[McpService]:
"""Get a service by unique slug name."""
return self.db.query(McpService).filter(McpService.slug_name == slug_name).first()
def get_all(self) -> List[McpService]:
def get_all(self, keyword: Optional[str] = None) -> List[McpService]:
"""List all services ordered by creation time descending."""
return self.db.query(McpService).order_by(McpService.created_at.desc()).all()
query = self.db.query(McpService).order_by(McpService.created_at.desc())
if keyword:
keyword = f"%{keyword}%"
query = query.filter((McpService.name.like(keyword)) | (McpService.short_description.like(keyword)))
return query.all()
def get_all_paginated(self, page: int = 1, page_size: int = 10) -> Tuple[List[McpService], int]:
def get_all_paginated(self, page: int = 1, page_size: int = 10, keyword: Optional[str] = None) -> Tuple[List[McpService], int]:
"""Get service list with pagination"""
offset = (page - 1) * page_size
total = self.db.query(McpService).count()
services = self.db.query(McpService).order_by(McpService.created_at.desc()).offset(offset).limit(page_size).all()
query = self.db.query(McpService).order_by(McpService.created_at.desc()).offset(offset).limit(page_size)
if keyword:
keyword = f"%{keyword}%"
query = query.filter((McpService.name.like(keyword)) | (McpService.short_description.like(keyword)))
services = query.all()
return services, total
def get_all_not_include(self, ids: List[str]) -> List[McpService]:
"""Get all services not include in ids"""
return self.db.query(McpService).order_by(McpService.created_at.desc()).filter(McpService.id.not_in(ids)).all()
def create(self, mcp_service: McpService) -> McpService:
"""Create a service; set timestamps if missing and persist."""
# Set timestamps explicitly if not already set
@@ -0,0 +1,69 @@
from datetime import datetime, timezone
from typing import List, Optional, Tuple
from sqlalchemy.orm import Session
from services.common.models.resource_group import ResourceGroup
class ResourceGroupRepository:
def __init__(self, db: Session):
self.db = db
def create(self, group: ResourceGroup, commit: bool = True) -> ResourceGroup:
now = datetime.now(timezone.utc)
if not getattr(group, "created_at", None):
group.created_at = now
if not getattr(group, "updated_at", None):
group.updated_at = now
self.db.add(group)
if commit:
self.db.commit()
self.db.refresh(group)
return group
def update(self, group: ResourceGroup, commit: bool = True) -> ResourceGroup:
existing = self.db.query(ResourceGroup).filter(ResourceGroup.id == group.id).first()
if not existing:
raise ValueError("Resource group not found")
if group.name is not None:
existing.name = group.name
if group.description is not None:
existing.description = group.description
if group.enabled is not None:
existing.enabled = group.enabled
if commit:
self.db.commit()
self.db.refresh(existing)
return existing
def delete(self, id: str, commit: bool = True) -> Optional[ResourceGroup]:
existing = self.db.query(ResourceGroup).filter(ResourceGroup.id == id).first()
if not existing:
return None
self.db.delete(existing)
if commit:
self.db.commit()
return existing
def get_by_id(self, id: str) -> Optional[ResourceGroup]:
return self.db.query(ResourceGroup).filter(ResourceGroup.id == id).first()
def get_all_not_include(self, ids: List[str]) -> List[ResourceGroup]:
"""Get all groups not include in ids"""
return self.db.query(ResourceGroup).filter(ResourceGroup.id.not_in(ids)).all()
def get_all_paginated(self, page: int = 1, page_size: int = 10, keyword: Optional[str] = None) -> Tuple[List[ResourceGroup], int]:
offset = (page - 1) * page_size
query = self.db.query(ResourceGroup)
if keyword:
query = query.filter(ResourceGroup.name.like(f"%{keyword}%"))
total = query.count()
groups = (
query.order_by(ResourceGroup.created_at.desc()).offset(offset).limit(page_size).all()
)
return groups, total
def get_all(self,keyword: Optional[str] = None) -> List[ResourceGroup]:
query = self.db.query(ResourceGroup)
if keyword:
query = query.filter(ResourceGroup.name.like(f"%{keyword}%"))
return query.order_by(ResourceGroup.created_at.desc()).all()
@@ -0,0 +1,127 @@
from typing import List, Tuple, Optional
from datetime import datetime
from sqlalchemy.orm import Session
from services.common.models.resource_group import ResourceGroupServiceMap
class ResourceGroupServiceMapRepository:
def __init__(self, db: Session):
self.db = db
def bind_group(self, service_id: str, group_ids: List[str], commit: bool = True) -> int:
created = 0
now = datetime.now()
for gid in group_ids:
exists = (
self.db.query(ResourceGroupServiceMap)
.filter(ResourceGroupServiceMap.group_id == gid, ResourceGroupServiceMap.service_id == service_id)
.first()
)
if exists:
continue
mapping = ResourceGroupServiceMap(group_id=gid, service_id=service_id, created_at=now)
self.db.add(mapping)
created += 1
if created and commit:
self.db.commit()
return created
def unbind_group(self, service_id: str, group_ids: List[str], commit: bool = True) -> int:
q = (
self.db.query(ResourceGroupServiceMap)
.filter(ResourceGroupServiceMap.group_id.in_(group_ids), ResourceGroupServiceMap.service_id == service_id)
)
count = q.count()
if count:
q.delete()
if commit:
self.db.commit()
return count
def bind_services(self, group_id: str, service_ids: List[str], commit: bool = True) -> int:
created = 0
now = datetime.now()
for sid in service_ids:
exists = (
self.db.query(ResourceGroupServiceMap)
.filter(ResourceGroupServiceMap.group_id == group_id, ResourceGroupServiceMap.service_id == sid)
.first()
)
if exists:
continue
mapping = ResourceGroupServiceMap(group_id=group_id, service_id=sid, created_at=now)
self.db.add(mapping)
created += 1
if created and commit:
self.db.commit()
return created
def unbind_service(self, group_id: str, service_id: str, commit: bool = True) -> int:
q = (
self.db.query(ResourceGroupServiceMap)
.filter(ResourceGroupServiceMap.group_id == group_id, ResourceGroupServiceMap.service_id == service_id)
)
count = q.count()
if count:
q.delete()
if commit:
self.db.commit()
return count
def list_group_ids_paginated(self, service_id: str, page: int = 1, page_size: int = 10, group_ids: Optional[List[str]] = None) -> Tuple[List[dict], int]:
offset = (page - 1) * page_size
query = self.db.query(ResourceGroupServiceMap).filter(ResourceGroupServiceMap.service_id == service_id)
if group_ids:
query = query.filter(ResourceGroupServiceMap.group_id.in_(group_ids))
total = query.count()
groups = (
query.order_by(ResourceGroupServiceMap.created_at.desc()).offset(offset).limit(page_size).all()
)
return [{"id": r.group_id, "join_at": r.created_at} for r in groups], total
def list_service_ids_paginated(self, group_id: str, page: int = 1, page_size: int = 10,service_ids: Optional[List[str]] = None) -> Tuple[List[str], int]:
offset = (page - 1) * page_size
query = self.db.query(ResourceGroupServiceMap).filter(ResourceGroupServiceMap.group_id == group_id)
if service_ids:
query = query.filter(ResourceGroupServiceMap.service_id.in_(service_ids))
total = query.count()
groups = (
query.order_by(ResourceGroupServiceMap.created_at.desc()).offset(offset).limit(page_size).all()
)
return [r.service_id for r in groups], total
def list_service_ids(self, group_id: str) -> List[str]:
return [r.service_id for r in self.db.query(ResourceGroupServiceMap.service_id).order_by(ResourceGroupServiceMap.created_at.desc()).filter(ResourceGroupServiceMap.group_id == group_id).all()]
def list_group_ids(self, service_id: str) -> List[str]:
return [r.group_id for r in self.db.query(ResourceGroupServiceMap.group_id).filter(ResourceGroupServiceMap.service_id == service_id).all()]
def migrate_services(self, from_group_id: str, to_group_id: str, commit: bool = True) -> int:
# 过滤已经在新分组的服务
existing_services = (
self.db.query(ResourceGroupServiceMap.service_id)
.filter(ResourceGroupServiceMap.group_id == to_group_id)
.all()
)
existing_service_ids = [item.service_id for item in existing_services]
q = (
self.db.query(ResourceGroupServiceMap)
.filter(ResourceGroupServiceMap.group_id == from_group_id, ~ResourceGroupServiceMap.service_id.in_(existing_service_ids))
)
count = q.count()
# 获取当前时间
now = datetime.now()
if count:
q.update({ResourceGroupServiceMap.group_id: to_group_id, ResourceGroupServiceMap.created_at: now})
if commit:
self.db.commit()
return count
def delete_by_group_id(self, group_id: str, commit: bool = True) -> int:
q = self.db.query(ResourceGroupServiceMap).filter(ResourceGroupServiceMap.group_id == group_id)
count = q.count()
if count:
q.delete()
if commit:
self.db.commit()
return count
@@ -24,14 +24,15 @@ class SysConfigRepository:
if sys_config:
return sys_config.value
return None
def set_value_by_key(self, key: str, value: str,description:str) -> Optional[SysConfig]:
def set_value_by_key(self, key: str, value: str, description: str, commit: bool = True) -> Optional[SysConfig]:
"""Set or create value and description for a key; returns entity."""
sys_config = self.get_by_key(key)
if sys_config:
sys_config.value = value
sys_config.description = description
self.db.commit()
self.db.refresh(sys_config)
if commit:
self.db.commit()
self.db.refresh(sys_config)
return sys_config
sys_config = SysConfig(
id=str(uuid.uuid4()),
@@ -42,13 +43,15 @@ class SysConfigRepository:
updated_at=datetime.now(timezone.utc),
)
self.db.add(sys_config)
self.db.commit()
if commit:
self.db.commit()
return sys_config
def delete_by_key(self, key: str) -> bool:
def delete_by_key(self, key: str, commit: bool = True) -> bool:
"""Delete config by key; returns True if deleted, else False."""
sys_config = self.get_by_key(key)
if sys_config:
self.db.delete(sys_config)
self.db.commit()
if commit:
self.db.commit()
return True
return False
return False
@@ -28,7 +28,7 @@ class UserRepository:
self.db.refresh(user)
return user
def create(self, email: str, register_type: str, role_id: int = 2, password: Optional[str] = None) -> Optional[User]:
def create(self, email: str, register_type: str, role_id: int = 2, group_id: str = "", password: Optional[str] = None) -> Optional[User]:
from uuid import uuid4
from services.common.models.user import RegisterType
@@ -44,6 +44,7 @@ class UserRepository:
is_deleted=0,
register_type=RegisterType(register_type),
role_id=role_id,
group_id=group_id,
created_at=now,
updated_at=now
)
@@ -84,7 +85,7 @@ class UserRepository:
def get_user_list(self, offset: int, limit: int) -> Tuple[int, List[User]]:
total = self.db.query(User).filter(User.is_deleted == 0, User.role_id == 2).count()
users = self.db.query(User).filter(User.is_deleted == 0, User.role_id == 2).offset(offset).limit(limit).all()
users = self.db.query(User).filter(User.is_deleted == 0, User.role_id == 2).order_by(User.created_at.desc()).offset(offset).limit(limit).all()
return total, users
def get_admin_user(self) -> Optional[User]:
@@ -187,4 +188,23 @@ class UserRepository:
result.append({"stats_day": current_day, "count": counts_by_day.get(current_day, 0)})
current_day += timedelta(days=1)
return result
def update_resource_group(self, user_id: str, group_id: str) -> Optional[User]:
"""Update user resource group"""
user = self.db.query(User).filter(User.id == user_id, User.is_deleted == 0).first()
if not user:
return None
user.group_id = group_id
self.db.commit()
self.db.refresh(user)
return user
def update_resource_group_by_group_id(self, group_id: str, new_group_id: str, commit: bool = True) -> List[User]:
"""Update user resource group"""
users = self.db.query(User).filter(User.group_id == group_id, User.is_deleted == 0).all()
if not users:
return []
for user in users:
user.group_id = new_group_id
if commit:
self.db.commit()
return users
@@ -13,6 +13,7 @@ from services.admin_service.services.sys_config_service import SysConfigService
from services.admin_service.constants.sys_config_key import (
KEY_LOGIN_GOOGLE_CLIENT,
KEY_LOGIN_GOOGLE_SECRET,
KEY_DEFAULT_RESOURCE_GROUP,
)
from services.common.utils.auth import delete_token
@@ -76,7 +77,8 @@ class AuthService:
# User doesn't exist, register first
if user is None:
user = self.user_repository.create(email=email, register_type="email", role_id=2)
group_id = self.sys_config_service.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
user = self.user_repository.create(email=email, register_type="email", role_id=2, group_id=group_id)
if user is None:
logger.warning(f"Failed to register user with email: {email}")
return None
@@ -94,7 +96,8 @@ class AuthService:
user = self.user_repository.get_by_email(email)
# User doesn't exist, register first
if user is None:
user = self.user_repository.create(email=email, register_type="email", role_id=2,password=password)
group_id = self.sys_config_service.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
user = self.user_repository.create(email=email, register_type="email", role_id=2, group_id=group_id, password=password)
if user is None:
logger.warning(f"Failed to register user with email: {email}")
@@ -472,7 +472,7 @@ class McpManagerService:
# 5. Build return data
apis_list = []
for temp_api in temp_apis:
api_dict = {"id": temp_api.id, "name": temp_api.name, "description": temp_api.description}
api_dict = {"id": temp_api.id, "name": temp_api.name,"url": temp_api.path, "description": temp_api.description}
apis_list.append(api_dict)
result = {
@@ -480,14 +480,6 @@ class McpManagerService:
"name": temp_service.name,
"short_description": temp_service.short_description,
"long_description": temp_service.long_description,
"base_url": temp_service.base_url,
"headers": json.loads(temp_service.headers) if temp_service.headers else [],
"charge_type": temp_service.charge_type.value if temp_service.charge_type else None,
"price": str(float(temp_service.price)) if temp_service.price and temp_service.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(temp_service.input_token_price)) if temp_service.input_token_price and temp_service.charge_type.value == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(temp_service.output_token_price)) if temp_service.output_token_price and temp_service.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": temp_service.enabled,
"tags": parse_tags_to_array(temp_service.tags),
"apis": apis_list,
}
return result
@@ -553,7 +545,7 @@ class McpManagerService:
# Build return data (according to API specification format)
service_info = {
"id": service.slug_name,
"id": service.id,
"name": service.name,
"short_description": service.short_description,
"long_description": service.long_description,
@@ -0,0 +1,388 @@
import uuid
from typing import Dict, List, Optional, Tuple
from sqlalchemy.orm import Session
from services.common.models.resource_group import ResourceGroup
from services.admin_service.repositories.resource_group_repository import ResourceGroupRepository
from services.admin_service.repositories.resource_group_service_map_repository import ResourceGroupServiceMapRepository
from services.admin_service.repositories.user_repository import UserRepository
from services.admin_service.repositories.mcp_service_repository import McpServiceRepository
from services.admin_service.repositories.sys_config_repository import SysConfigRepository
from services.admin_service.constants.sys_config_key import KEY_DEFAULT_RESOURCE_GROUP
from services.common.models.mcp_service import ChargeType
from services.common.redis import redis_client
class ResourceGroupService:
def __init__(self, db: Session):
self.db = db
self.redis = redis_client
self.group_repo = ResourceGroupRepository(db)
self.user_repo = UserRepository(db)
self.map_repo = ResourceGroupServiceMapRepository(db)
self.mcp_repo = McpServiceRepository(db)
self.sys_repo = SysConfigRepository(db)
def create_group(self, gid: str, name: str, description: Optional[str], is_default: bool = False) -> str:
try:
if gid != "deny-all" and gid != "allow-all":
group = ResourceGroup()
group.id = gid
group.name = name
group.description = description or ""
group.enabled = 1
result = self.group_repo.create(group, commit=False)
if result is None:
raise ValueError("Failed to create resource group")
if is_default:
self.sys_repo.set_value_by_key(key=KEY_DEFAULT_RESOURCE_GROUP, value=gid, description="Default resource group", commit=False)
self.db.commit()
return gid
except Exception:
self.db.rollback()
raise
def update_group(self, gid: str, body: dict) -> bool:
if not gid:
raise ValueError("Group ID is required")
existing = self.group_repo.get_by_id(gid)
if not existing:
raise ValueError("Resource group not found")
try:
if gid != "deny-all" and gid != "allow-all":
patch = ResourceGroup()
patch.id = gid
patch.name = body.get("name", existing.name)
patch.description = body.get("description", existing.description)
patch.enabled = body.get("enabled", existing.enabled)
self.group_repo.update(patch, commit=False)
is_default = body.get("is_default", False)
if is_default:
self.sys_repo.set_value_by_key(key=KEY_DEFAULT_RESOURCE_GROUP, value=gid, description="Default resource group", commit=False)
self.db.commit()
return True
except Exception:
self.db.rollback()
raise
def delete_group(self, gid: str, migrate_id: Optional[str] = None) -> bool:
try:
if migrate_id:
migrate_group = self.group_repo.get_by_id(migrate_id)
if not migrate_group:
raise ValueError("Migrate resource group not found")
self.map_repo.migrate_services(gid, migrate_id, commit=False)
current_default = self.sys_repo.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
if current_default == gid:
self.sys_repo.set_value_by_key(KEY_DEFAULT_RESOURCE_GROUP, migrate_id, "Default resource group", commit=False)
else:
self.map_repo.delete_by_group_id(gid, commit=False)
current_default = self.sys_repo.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
if current_default == gid:
self.sys_repo.set_value_by_key(KEY_DEFAULT_RESOURCE_GROUP, "", "Default resource group", commit=False)
deleted = self.group_repo.delete(gid, commit=False)
if deleted is None:
raise ValueError("Resource group not found")
users = self.user_repo.update_resource_group_by_group_id(gid, migrate_id or "deny-all", commit=False)
if not users:
raise ValueError("Failed to update user resource group")
for user in users:
cache_key = f"xpack:user:{user.id}"
self.redis.set(cache_key, user, 600)
cache_key = f"xpack:resource_group:id:{gid}"
self.redis.delete(cache_key)
self.db.commit()
return True
except Exception:
self.db.rollback()
raise
def get_info(self, gid: str) -> Optional[dict]:
default_group = self.sys_repo.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
if gid == "allow-all":
return {
"id":"allow-all",
"name":"Allow All",
"description":"Allow all services",
"enabled": 1,
"is_default": default_group == "allow-all" or default_group == "",
}
elif gid == "deny-all":
return {
"id":"deny-all",
"name":"Deny All",
"description":"Deny all services",
"enabled": 1,
"is_default": default_group == "deny-all",
}
g = self.group_repo.get_by_id(gid)
if not g:
return None
return {
"id": g.id,
"name": g.name,
"description": g.description,
"enabled": g.enabled,
"is_default": g.id == default_group,
}
def list_groups(self, page: int = 1, page_size: int = 10, keyword: Optional[str] = None) -> Tuple[List[dict], int]:
default_group = self.sys_repo.get_value_by_key(KEY_DEFAULT_RESOURCE_GROUP)
groups,total = self.group_repo.get_all_paginated(page=page, page_size=page_size, keyword=keyword)
if total == 0:
return [
{
"id":"allow-all",
"name":"Allow All",
"description":"Allow all services",
"enabled": 1,
"is_default": "allow-all" == default_group or default_group == "",
},
{
"id":"deny-all",
"name":"Deny All",
"description":"Deny all services",
"enabled": 1,
"is_default": "deny-all" == default_group,
},
],2
data = []
# data拼接
data.extend(
{
"id": g.id,
"name": g.name,
"description": g.description,
"enabled": bool(g.enabled), # 统一类型
"created_at": str(g.created_at) if g.created_at else None,
"updated_at": str(g.updated_at) if g.updated_at else None,
"is_default": g.id == default_group,
}
for g in groups
)
# 默认项(统一为 dict)
allow_all = {
"id": "allow-all",
"name": "Allow All",
"description": "Allow all services",
"enabled": True, # 统一为 bool
"is_default": "allow-all" == default_group or default_group == "",
}
deny_all = {
"id": "deny-all",
"name": "Deny All",
"description": "Deny all services",
"enabled": True, # 统一为 bool
"is_default": "deny-all" == default_group,
}
if len(data) < page_size:
data.append(allow_all)
if len(data) < page_size:
data.append(deny_all)
return data,total+2
def simple_list_groups(self) -> List[ResourceGroup]:
data = self.group_repo.get_all()
data.append(ResourceGroup(id="allow-all", name="Allow All", description="Allow all services", enabled=True))
data.append(ResourceGroup(id="deny-all", name="Deny All", description="Deny all services", enabled=True))
return data
def bind_groups(self, service_id: str, group_ids: List[str]) -> int:
created = self.map_repo.bind_group(service_id, group_ids, commit=False)
for gid in group_ids:
cache_key = f"xpack:resource_group:id:{gid}"
self.redis.delete(cache_key)
self.db.commit()
return created
def unbind_groups(self, service_id: str, group_ids: List[str]) -> int:
count = self.map_repo.unbind_group(service_id, group_ids, commit=False)
for gid in group_ids:
cache_key = f"xpack:resource_group:id:{gid}"
self.redis.delete(cache_key)
self.db.commit()
return count
def bind_services(self, gid: str, service_ids: List[str]) -> int:
valid_ids: List[str] = []
group = self.group_repo.get_by_id(gid)
if not group:
raise ValueError("Resource group not found")
for sid in service_ids:
if self.mcp_repo.get_by_id(sid):
valid_ids.append(sid)
try:
created = self.map_repo.bind_services(gid, valid_ids, commit=False)
cache_key = f"xpack:resource_group:id:{gid}"
self.redis.delete(cache_key)
self.db.commit()
return created
except Exception:
self.db.rollback()
raise
def unbind_service(self, gid: str, sids: List[str]) -> int:
try:
for sid in sids:
self.map_repo.unbind_service(gid, sid, commit=False)
cache_key = f"xpack:resource_group:id:{gid}"
self.redis.delete(cache_key)
self.db.commit()
return len(sids)
except Exception:
self.db.rollback()
raise
def get_bind_groups(self, sid: str, page: int = 1, page_size: int = 10, keyword: Optional[str] = None) -> Tuple[List[dict], int]:
groups = self.group_repo.get_all(keyword=keyword)
if not groups:
if keyword and keyword.lower() not in "allow-all".lower():
return [],0
return [
{
"id":"allow-all",
"name":"Allow All",
"join_at": "2025-12-16 00:00:00"
}
],1
group_map = {g.id: g for g in groups}
group_ids = None
if keyword:
group_ids = [g.id for g in groups]
groups,total = self.map_repo.list_group_ids_paginated(sid, page=page, page_size=page_size, group_ids=group_ids)
result = []
for group in groups:
result.append({
"id": group["id"],
"name": group_map[group["id"]].name if group["id"] in group_map else "",
"join_at": str(group["join_at"]) if group["join_at"] else None,
})
if len(result) < page_size:
if keyword and keyword.lower() not in "allow-all".lower():
return result,total
result.append({
"id":"allow-all",
"name":"Allow All",
"join_at": "2025-12-16 00:00:00"
})
total += 1
return result,total
def get_bind_service_ids(self, gid: str) -> List[str]:
if gid == "deny-all":
return []
elif gid == "allow-all":
return [s.id for s in self.mcp_repo.get_all()]
return self.map_repo.list_service_ids(gid)
def get_bind_services(self, gid: str, page: int = 1, page_size: int = 10, keyword: Optional[str] = None) -> Tuple[List[dict], int]:
if gid == "deny-all":
return [],0
elif gid == "allow-all":
services,total = self.mcp_repo.get_all_paginated(page=page, page_size=page_size, keyword=keyword)
return [
{
"id": s.id,
"name": s.name,
"base_url":s.base_url,
"slug_name": s.slug_name,
"short_description": s.short_description,
"long_description": s.long_description,
"base_url": s.base_url,
"charge_type": s.charge_type.value if s.charge_type else None,
"price": str(float(s.price)) if s.price and s.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(s.input_token_price)) if s.input_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(s.output_token_price)) if s.output_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": s.enabled,
"created_at": str(s.created_at) if s.created_at else None,
"updated_at": str(s.updated_at) if s.updated_at else None,
}
for s in services
],total
if keyword:
services = self.mcp_repo.get_all(keyword=keyword)
if not services:
return [],0
service_map = {s.id: s for s in services}
sids = [s.id for s in services]
sids,total = self.map_repo.list_service_ids_paginated(gid, page=page, page_size=page_size,service_ids=sids)
return [
{
"id": s.id,
"name": s.name,
"base_url":s.base_url,
"slug_name": s.slug_name,
"short_description": s.short_description,
"long_description": s.long_description,
"base_url": s.base_url,
"charge_type": s.charge_type.value if s.charge_type else None,
"price": str(float(s.price)) if s.price and s.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(s.input_token_price)) if s.input_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(s.output_token_price)) if s.output_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": s.enabled,
"created_at": str(s.created_at) if s.created_at else None,
"updated_at": str(s.updated_at) if s.updated_at else None,
}
for s in (service_map[sid] for sid in sids)
],total
else:
sids,total = self.map_repo.list_service_ids_paginated(gid, page=page, page_size=page_size)
services = self.mcp_repo.get_by_ids(ids=sids)
service_map = {s.id: s for s in services}
return [
{
"id": s.id,
"name": s.name,
"base_url":s.base_url,
"slug_name": s.slug_name,
"short_description": s.short_description,
"long_description": s.long_description,
"base_url": s.base_url,
"charge_type": s.charge_type.value if s.charge_type else None,
"price": str(float(s.price)) if s.price and s.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(s.input_token_price)) if s.input_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(s.output_token_price)) if s.output_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": s.enabled,
"created_at": str(s.created_at) if s.created_at else None,
"updated_at": str(s.updated_at) if s.updated_at else None,
}
for s in (service_map[sid] for sid in sids)
],total
def get_unbind_services(self, gid: str) -> List[dict]:
if gid == "deny-all" or gid == "allow-all":
return []
sids = self.map_repo.list_service_ids(gid)
services = self.mcp_repo.get_all_not_include(ids=sids)
return [
{
"id": s.id,
"name": s.name,
"base_url":s.base_url,
"charge_type": s.charge_type.value if s.charge_type else None,
"price": str(float(s.price)) if s.price and s.charge_type == ChargeType.PER_CALL else "0.00",
"input_token_price": str(float(s.input_token_price)) if s.input_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"output_token_price": str(float(s.output_token_price)) if s.output_token_price and s.charge_type == ChargeType.PER_TOKEN else "0.00",
"enabled": s.enabled,
}
for s in services
]
def get_unbind_groups(self, sid: str) -> List[dict]:
"""Get all groups not bind to service"""
gids = self.map_repo.list_group_ids(sid)
groups = self.group_repo.get_all_not_include(ids=gids)
return [
{
"id": g.id,
"name": g.name,
}
for g in groups
]
@@ -5,6 +5,11 @@ from services.common.database import SessionLocal
from services.admin_service.repositories.user_repository import UserRepository
from services.admin_service.repositories.user_wallet_repository import UserWalletRepository
from services.common.redis_keys import RedisKeys
from services.common.utils.cache import get_model_cache, set_model_cache, delete_cache
import logging
logger = logging.getLogger(__name__)
class UserService:
@@ -43,3 +48,15 @@ class UserService:
def update_admin(self, name: str, password: str) -> Optional[User]:
"""Update admin user info"""
return self.user_repository.update_admin_user(name=name, password=password)
def update_resource_group(self, user_id: str, group_id: str) -> Optional[User]:
"""Update user resource group"""
try:
user = self.user_repository.update_resource_group(user_id=user_id, group_id=group_id)
cache_key = RedisKeys.user_key(user_id)
set_model_cache(cache_key, user)
return self.get_by_id(user_id)
except Exception as e:
logger.error(f"Failed to update user resource group for user_id {user_id}: {e}", exc_info=True)
return None
+68 -1
View File
@@ -5,6 +5,7 @@ Supports both service_id (UUID) and slug_name service identifiers
from typing import Optional
from datetime import datetime, timezone
from sqlalchemy import false
from starlette.requests import Request
from starlette.responses import Response
import asyncio
@@ -17,6 +18,9 @@ from mcp.server.lowlevel import Server
from services.api_service.services.mcp_server_factory import McpServerFactory
from services.common.logging_config import get_logger
from services.api_service.repositories.user_apikey_repository import UserApiKeyRepository
from services.api_service.repositories.user_repository import UserRepository
from services.api_service.repositories.resource_group_repository import ResourceGroupMapRepository
from services.api_service.utils.connection_manager import connection_manager
from services.common.database import get_db
from services.common.config import Config
@@ -177,6 +181,20 @@ class McpController:
return
user_id, apikey_id = user_info
# Check invoke permission
if not self._check_invoke_permission(user_id, service_id):
response_body = b"Invoke permission denied"
await send({
'type': 'http.response.start',
'status': 403,
'headers': [
[b'content-type', b'text/plain'],
[b'content-length', str(len(response_body)).encode()],
],
})
await send({'type': 'http.response.body', 'body': response_body})
return
# Create MCP server instance (pass user_id and apikey_id for billing and logging)
mcp_server = await self.server_factory.create_server(service_id, user_id, apikey_id)
@@ -347,8 +365,19 @@ class McpController:
})
await send({'type': 'http.response.body', 'body': response_body})
return
user_id, apikey_id = user_info
if not self._check_invoke_permission(user_id, service_id):
response_body = b"Invoke permission denied"
await send({
'type': 'http.response.start',
'status': 403,
'headers': [
[b'content-type', b'text/plain'],
[b'content-length', str(len(response_body)).encode()],
],
})
await send({'type': 'http.response.body', 'body': response_body})
return
raw_client_id = req.headers.get('x-client-instance-id') or req.headers.get('x-client-id')
client_instance_id = (re.sub(r'[^a-zA-Z0-9._-]', '', raw_client_id)[:32]) if raw_client_id else None
ua = user_agent or ""
@@ -611,6 +640,43 @@ class McpController:
finally:
if db is not None:
db.close()
def _check_invoke_permission(self, user_id: str, service_id: str) -> bool:
db = None
try:
# Create database session
db = next(get_db())
user_repo = UserRepository(db)
# Query user info by apikey
user = user_repo.get_by_id(user_id)
if not user:
logger.warning(f"User not found in database: {user_id[:10]}...")
return False
logger.debug(f"Found user record - User ID: {user.id}, group id is: {user.group_id}")
if user.group_id == "allow-all":
return True
elif user.group_id == "deny-all":
return False
resource_group_map_repo = ResourceGroupMapRepository(db)
resource_groups = resource_group_map_repo.get_by_id(user.group_id)
if not resource_groups:
logger.warning(f"Resource group not found for user: {user_id[:10]}...")
return False
# Check if service_id is in resource_groups
if service_id not in resource_groups:
logger.warning(f"Service {service_id} not found in user's resource groups: {user_id[:10]}...")
return False
return True
except Exception as e:
logger.error(f"Error occurred while querying user apikey: {str(e)}", exc_info=True)
return False
finally:
if db is not None:
db.close()
def _extract_user_info(self, request: Request) -> Optional[tuple[str, str]]:
"""Extract user ID and apikey ID from request by validating apikey parameter."""
@@ -650,6 +716,7 @@ class McpController:
logger.warning(f"Apikey has expired: {apikey[:10]}..., expiry time: {user_apikey.expire_at}")
return None
logger.info(f"Apikey validation successful - User ID: {user_apikey.user_id}, API Key ID: {user_apikey.id}")
return (user_apikey.user_id, user_apikey.id)
@@ -0,0 +1,43 @@
"""
Resource group service map repository class - used in API service
"""
from typing import List
from sqlalchemy.orm import Session
from services.common.models.resource_group import ResourceGroupServiceMap
from services.common.utils.cache_utils import CacheUtils
class ResourceGroupMapRepository:
"""Resource group service map repository class"""
def __init__(self, db: Session):
self.db = db
def get_by_id(self, group_id: str, force_update: bool = False) -> List[str]:
"""
Get resource group service map by ID
Args:
group_id: Resource group ID
Returns:
List[str]: Resource group service map instance, returns None if not exists
"""
"""
Get resource group service map by ID
"""
cache_key = f"xpack:resource_group:id:{group_id}"
if not force_update:
# Try to get from cache using SQLAlchemy-specific method
cached_model = CacheUtils.get_sqlalchemy_cache(cache_key, List[str])
if cached_model:
return cached_model
# Query from database if not in cache
service_ids = [item.service_id for item in self.db.query(ResourceGroupServiceMap).filter(ResourceGroupServiceMap.group_id == group_id).all()]
if service_ids:
# Cache the result for 10 minutes
CacheUtils.set_sqlalchemy_cache(cache_key, service_ids, 600)
return service_ids
return []
@@ -0,0 +1,44 @@
"""
User repository class - used in API service
"""
from typing import Optional
from sqlalchemy.orm import Session
from services.common.models.user import User
from services.common.utils.cache_utils import CacheUtils
from services.common.redis_keys import RedisKeys
class UserRepository:
"""User repository class"""
def __init__(self, db: Session):
self.db = db
def get_by_id(self, user_id: str, force_update: bool = False) -> Optional[User]:
"""
Get user by ID
Args:
user_id: User ID
Returns:
User: User instance, returns None if not exists
"""
"""
Get user by ID
"""
cache_key = RedisKeys.user_key(user_id)
if not force_update:
# Try to get from cache using SQLAlchemy-specific method
cached_model = CacheUtils.get_sqlalchemy_cache(cache_key, User)
if cached_model:
return cached_model
# Query from database if not in cache
user = self.db.query(User).filter(User.id == user_id).first()
if user:
# Cache the result for 10 minutes
CacheUtils.set_sqlalchemy_cache(cache_key, user, 600)
return user
return None
@@ -206,16 +206,17 @@ class McpServerFactory:
logger.debug(f"Call params: {call_params}")
# Execute tool
result,response_data = await self.tool_service.execute_tool(tool_config, arguments, call_params)
validation_ok, validation_msg = self._validate_output_schema(tool_config, response_data)
if not validation_ok:
call_success = False
error_text = f"Response validation failed: {validation_msg}"
result = [types.TextContent(type="text", text=error_text)]
response_data = {}
else:
call_success = True
logger.info(f"Tool call successful - User ID: {user_id}, Tool: {name}")
result,response_data,call_success = await self.tool_service.execute_tool(tool_config, arguments, call_params)
if call_success:
validation_ok, validation_msg = self._validate_output_schema(tool_config, response_data)
if not validation_ok:
call_success = False
error_text = f"Response validation failed: {validation_msg}"
result = [types.TextContent(type="text", text=error_text)]
response_data = {}
if call_success:
logger.info(f"Tool call successful - User ID: {user_id}, Tool: {name}")
if pre_deduct_result.charge_type == "per_token" and result and call_success:
output_text = ""
+41 -27
View File
@@ -185,14 +185,20 @@ class McpService:
for param in query_params:
if isinstance(param, dict) and "name" in param:
# Handle both direct type and schema.type formats
extend_properties = {}
param_type = "string" # default
if "type" in param:
param_type = param["type"]
elif "schema" in param and isinstance(param["schema"], dict) and "type" in param["schema"]:
param_type = param["schema"]["type"]
if param_type == "array":
extend_properties["items"] = param["schema"]["items"]
elif param_type == "object":
extend_properties["properties"] = param["schema"]["properties"]
schema["properties"][param["name"]] = {
"type": param_type,
**extend_properties,
"description": param.get("description", f"Query parameter: {param['name']}")
}
if param.get("required", False):
@@ -202,34 +208,34 @@ class McpService:
if tool_api.request_body_schema:
# Try to parse as parameters list first, then as schema object
try:
# First try to parse as parameters list (similar to query/path parameters)
body_params = self._safe_parse_params(tool_api.request_body_schema, tool_api.name, 'body')
if body_params:
# If it's a list of parameters, process them like query parameters
for param in body_params:
if isinstance(param, dict) and "name" in param:
param_type = "string" # default
if "type" in param:
param_type = param["type"]
elif "schema" in param and isinstance(param["schema"], dict) and "type" in param["schema"]:
param_type = param["schema"]["type"]
# # First try to parse as parameters list (similar to query/path parameters)
# body_params = self._safe_parse_params(tool_api.request_body_schema, tool_api.name, 'body')
# if body_params:
# # If it's a list of parameters, process them like query parameters
# for param in body_params:
# if isinstance(param, dict) and "name" in param:
# param_type = "string" # default
# if "type" in param:
# param_type = param["type"]
# elif "schema" in param and isinstance(param["schema"], dict) and "type" in param["schema"]:
# param_type = param["schema"]["type"]
schema["properties"][param["name"]] = {
"type": param_type,
"description": param.get("description", f"Body parameter: {param['name']}")
}
if param.get("required", False):
schema["required"].append(param["name"])
else:
# schema["properties"][param["name"]] = {
# "type": param_type,
# "description": param.get("description", f"Body parameter: {param['name']}")
# }
# if param.get("required", False):
# schema["required"].append(param["name"])
# else:
# If not a parameters list, try to parse as JSON schema object
try:
body_schema = json.loads(tool_api.request_body_schema)
if isinstance(body_schema, dict) and "properties" in body_schema:
schema["properties"].update(body_schema["properties"])
if "required" in body_schema:
schema["required"].extend(body_schema["required"])
except json.JSONDecodeError:
pass # Already logged by _safe_parse_params
try:
body_schema = json.loads(tool_api.request_body_schema)
if isinstance(body_schema, dict) and "properties" in body_schema:
schema["properties"].update(body_schema["properties"])
if "required" in body_schema:
schema["required"].extend(body_schema["required"])
except json.JSONDecodeError:
pass # Already logged by _safe_parse_params
except Exception as e:
self.logger.warning(f"Failed to parse request body schema for {tool_api.name}: {e}")
@@ -291,7 +297,15 @@ class McpService:
if tool_api.response_schema:
parsed = json.loads(tool_api.response_schema)
if isinstance(parsed, dict):
return parsed
if parsed["type"] != "object":
return {
"type":"object",
"properties":{
"data":parsed
}
}
else:
return parsed
except Exception as e:
self.logger.warning(f"Failed to parse response_schema for {tool_api.name}: {e}")
@@ -17,7 +17,7 @@ class McpToolService:
def __init__(self):
self.http_builder = HttpRequestBuilder()
async def execute_tool(self, tool_config, arguments: dict, call_params: dict) -> tuple[List[types.Content],dict]:
async def execute_tool(self, tool_config, arguments: dict, call_params: dict) -> tuple[List[types.Content],dict,bool]:
"""
Execute tool call
@@ -42,12 +42,12 @@ class McpToolService:
else:
response_data = {}
logger.info("Tool execution completed successfully")
return [types.TextContent(type="text", text=response_text)],response_data
return [types.TextContent(type="text", text=response_text)],response_data,True
except Exception as e:
error_msg = f"Tool execution failed: {str(e)}"
logger.error(f"Tool execution failed: {error_msg}", exc_info=True)
return [types.TextContent(type="text", text=error_msg)],{}
return [types.TextContent(type="text", text=error_msg)],{},False
async def _send_http_request(self, request_info: Dict[str, Any]) -> str:
"""
+1 -1
View File
@@ -90,7 +90,7 @@ def init_db():
"""Initialize database and create all tables"""
try:
# Import all models to ensure they are registered
from .models import user, user_wallet, user_wallet_history, user_access_token, sys_config, mcp_service, mcp_tool_api, user_apikey
from .models import user, user_wallet, user_wallet_history, user_access_token, sys_config, mcp_service, mcp_tool_api, user_apikey, resource_group
# Create all tables
Base.metadata.create_all(bind=engine)
+2
View File
@@ -9,6 +9,8 @@ INVALID_INPUT_TOKEN = {"code": 400, "message": "Input token must be a non-negati
INVALID_OUTPUT_TOKEN = {"code": 400, "message": "Output token must be a non-negative number"}
INVALID_URL = {"code": 400, "message": "Invalid URL provided"}
INVALID_FORMAT = {"code": 400, "message": "Invalid data format"}
USER_NOT_FOUND = {"code": 400, "message": "User not found"}
RESOURCE_NOT_FOUND = {"code": 400, "message": "Resource Group not found"}
UNAUTHORIZED = {"code": 401, "message": "Authentication required"}
INVALID_TOKEN = {"code": 401, "message": "Invalid or expired token"}
+51
View File
@@ -0,0 +1,51 @@
from sqlalchemy import String, Integer, DateTime, UniqueConstraint
from sqlalchemy.sql import func
from sqlalchemy.orm import Mapped, mapped_column
from datetime import datetime
from services.common.models.base import Base
class ResourceGroup(Base):
__tablename__ = "resource_group"
id: Mapped[str] = mapped_column(
String(36),
primary_key=True,
autoincrement=False,
comment="Primary key, group UUID",
)
name: Mapped[str] = mapped_column(String(255), nullable=False, comment="Group name")
description: Mapped[str] = mapped_column(String, nullable=True, comment="Group description")
enabled: Mapped[int] = mapped_column(Integer, nullable=False, default=1, comment="Group status: 0=disabled, 1=enabled")
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=True,
server_default=func.current_timestamp(),
comment="Creation timestamp",
)
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=True,
server_default=func.current_timestamp(),
server_onupdate=func.current_timestamp(),
comment="Last update timestamp",
)
class ResourceGroupServiceMap(Base):
__tablename__ = "resource_group_service_map"
id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="Primary key")
group_id: Mapped[str] = mapped_column(String(36), nullable=False, comment="Resource group UUID")
service_id: Mapped[str] = mapped_column(String(36), nullable=False, comment="MCP service UUID")
created_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=True,
server_default=func.current_timestamp(),
comment="Creation timestamp",
)
__table_args__ = (
UniqueConstraint("group_id", "service_id", name="uq_group_service"),
)
+6
View File
@@ -48,6 +48,12 @@ class User(Base):
default=False,
comment="1: admin, 2: user",
)
group_id: Mapped[str] = mapped_column(
String(36),
nullable=True,
default="",
comment="Group ID",
)
last_login_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=True,
@@ -9,6 +9,8 @@ class UserResponse(BaseModel):
user_name: Optional[str] = None
user_email: Optional[str] = None
role_id: Optional[int] = None
allow_all: Optional[bool] = None
service_ids: Optional[list] = None
created_at: Optional[datetime.datetime] = None
wallet: Optional[UserWalletResponse] = None
register_type: Optional[str] = None
+25
View File
@@ -120,6 +120,31 @@ class ValidationUtils:
raise ValidationException(f"Parameter '{param_name}' must be a valid HTTP/HTTPS URL")
return url
@staticmethod
def validate_domain(domain: str, param_name: str = "domain") -> str:
"""
Validate domain format
Args:
domain: The domain to validate
param_name: Name of the parameter for error message
Returns:
The validated domain
Raises:
ValidationException: If domain format is invalid
"""
if not domain or not isinstance(domain, str):
raise ValidationException(f"Parameter '{param_name}' must be a valid domain name")
domain = domain.strip().lower()
domain_pattern = r'^(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,})$'
if not re.match(domain_pattern, domain):
raise ValidationException(f"Parameter '{param_name}' must be a valid domain name")
return domain
@staticmethod
def validate_pagination(page: Any, page_size: Any) -> Tuple[int, int]: