Merge pull request #93 from xpack-ai/feature/resource_group
Resource group functionality complete
This commit is contained in:
34 files changed
+1362
-98
No files matched your search
@@ -0,0 +1 @@
|
||||
/mcp.json
|
||||
@@ -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;
|
||||
@@ -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"
|
||||
@@ -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 = [
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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")
|
||||
|
||||
|
||||
@@ -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")
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 = ""
|
||||
|
||||
@@ -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:
|
||||
"""
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"}
|
||||
|
||||
@@ -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"),
|
||||
)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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]:
|
||||
|
||||
Reference in new issue
Block a user