diff --git a/.roo/.gitignore b/.roo/.gitignore new file mode 100644 index 0000000..57fd04d --- /dev/null +++ b/.roo/.gitignore @@ -0,0 +1 @@ +/mcp.json diff --git a/scripts/resource/sql/version-1.2.0.sql b/scripts/resource/sql/version-1.2.0.sql new file mode 100644 index 0000000..87db564 --- /dev/null +++ b/scripts/resource/sql/version-1.2.0.sql @@ -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; diff --git a/scripts/version.json b/scripts/version.json index 841d413..3c79649 100644 --- a/scripts/version.json +++ b/scripts/version.json @@ -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" diff --git a/services/admin_service/constants/sys_config_key.py b/services/admin_service/constants/sys_config_key.py index 22911dc..4e0205e 100644 --- a/services/admin_service/constants/sys_config_key.py +++ b/services/admin_service/constants/sys_config_key.py @@ -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" \ No newline at end of file +KEY_CNAME_A_IP = "cname_a_ip" + +KEY_DEFAULT_RESOURCE_GROUP = "default_resource_group" \ No newline at end of file diff --git a/services/admin_service/controllers/auth.py b/services/admin_service/controllers/auth.py index d715864..dacb905 100644 --- a/services/admin_service/controllers/auth.py +++ b/services/admin_service/controllers/auth.py @@ -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) diff --git a/services/admin_service/controllers/mcp_manager.py b/services/admin_service/controllers/mcp_manager.py index 5038370..fff8d1b 100644 --- a/services/admin_service/controllers/mcp_manager.py +++ b/services/admin_service/controllers/mcp_manager.py @@ -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) \ No newline at end of file diff --git a/services/admin_service/controllers/resource_group.py b/services/admin_service/controllers/resource_group.py new file mode 100644 index 0000000..65237a2 --- /dev/null +++ b/services/admin_service/controllers/resource_group.py @@ -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() + + diff --git a/services/admin_service/controllers/sys_config.py b/services/admin_service/controllers/sys_config.py index 137bac6..bf3b0c4 100644 --- a/services/admin_service/controllers/sys_config.py +++ b/services/admin_service/controllers/sys_config.py @@ -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 = [ diff --git a/services/admin_service/controllers/user.py b/services/admin_service/controllers/user.py index 4214398..12a1004 100644 --- a/services/admin_service/controllers/user.py +++ b/services/admin_service/controllers/user.py @@ -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 diff --git a/services/admin_service/controllers/user_manager.py b/services/admin_service/controllers/user_manager.py index daf7044..24bc0c6 100644 --- a/services/admin_service/controllers/user_manager.py +++ b/services/admin_service/controllers/user_manager.py @@ -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") diff --git a/services/admin_service/controllers/web.py b/services/admin_service/controllers/web.py index a352b57..a5f8b47 100644 --- a/services/admin_service/controllers/web.py +++ b/services/admin_service/controllers/web.py @@ -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") diff --git a/services/admin_service/main.py b/services/admin_service/main.py index 9905ade..c8b1cec 100644 --- a/services/admin_service/main.py +++ b/services/admin_service/main.py @@ -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") diff --git a/services/admin_service/middleware.py b/services/admin_service/middleware.py index 049f587..fbf92e8 100644 --- a/services/admin_service/middleware.py +++ b/services/admin_service/middleware.py @@ -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 diff --git a/services/admin_service/repositories/mcp_service_repository.py b/services/admin_service/repositories/mcp_service_repository.py index b4e6815..98c33eb 100644 --- a/services/admin_service/repositories/mcp_service_repository.py +++ b/services/admin_service/repositories/mcp_service_repository.py @@ -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 diff --git a/services/admin_service/repositories/resource_group_repository.py b/services/admin_service/repositories/resource_group_repository.py new file mode 100644 index 0000000..ed60424 --- /dev/null +++ b/services/admin_service/repositories/resource_group_repository.py @@ -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() diff --git a/services/admin_service/repositories/resource_group_service_map_repository.py b/services/admin_service/repositories/resource_group_service_map_repository.py new file mode 100644 index 0000000..e0b4ddc --- /dev/null +++ b/services/admin_service/repositories/resource_group_service_map_repository.py @@ -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 diff --git a/services/admin_service/repositories/sys_config_repository.py b/services/admin_service/repositories/sys_config_repository.py index b834e17..a428993 100644 --- a/services/admin_service/repositories/sys_config_repository.py +++ b/services/admin_service/repositories/sys_config_repository.py @@ -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 \ No newline at end of file + return False diff --git a/services/admin_service/repositories/user_repository.py b/services/admin_service/repositories/user_repository.py index d13b3f9..fbc3994 100644 --- a/services/admin_service/repositories/user_repository.py +++ b/services/admin_service/repositories/user_repository.py @@ -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 - \ No newline at end of file + + 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 \ No newline at end of file diff --git a/services/admin_service/services/auth_service.py b/services/admin_service/services/auth_service.py index 214d1fa..638dbb8 100644 --- a/services/admin_service/services/auth_service.py +++ b/services/admin_service/services/auth_service.py @@ -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}") diff --git a/services/admin_service/services/mcp_manager_service.py b/services/admin_service/services/mcp_manager_service.py index 70aa967..67655ff 100644 --- a/services/admin_service/services/mcp_manager_service.py +++ b/services/admin_service/services/mcp_manager_service.py @@ -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, diff --git a/services/admin_service/services/resource_group_service.py b/services/admin_service/services/resource_group_service.py new file mode 100644 index 0000000..323e4bc --- /dev/null +++ b/services/admin_service/services/resource_group_service.py @@ -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 + ] + diff --git a/services/admin_service/services/user_service.py b/services/admin_service/services/user_service.py index fb60a8b..cddfce7 100644 --- a/services/admin_service/services/user_service.py +++ b/services/admin_service/services/user_service.py @@ -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 + diff --git a/services/api_service/controllers/mcp.py b/services/api_service/controllers/mcp.py index 2836462..e1f6e79 100644 --- a/services/api_service/controllers/mcp.py +++ b/services/api_service/controllers/mcp.py @@ -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) diff --git a/services/api_service/repositories/resource_group_repository.py b/services/api_service/repositories/resource_group_repository.py new file mode 100644 index 0000000..f203f04 --- /dev/null +++ b/services/api_service/repositories/resource_group_repository.py @@ -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 [] diff --git a/services/api_service/repositories/user_repository.py b/services/api_service/repositories/user_repository.py new file mode 100644 index 0000000..c4a9e8a --- /dev/null +++ b/services/api_service/repositories/user_repository.py @@ -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 diff --git a/services/api_service/services/mcp_server_factory.py b/services/api_service/services/mcp_server_factory.py index 8afe5c2..ddbad51 100644 --- a/services/api_service/services/mcp_server_factory.py +++ b/services/api_service/services/mcp_server_factory.py @@ -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 = "" diff --git a/services/api_service/services/mcp_service.py b/services/api_service/services/mcp_service.py index e56310d..d8644a4 100644 --- a/services/api_service/services/mcp_service.py +++ b/services/api_service/services/mcp_service.py @@ -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}") diff --git a/services/api_service/services/mcp_tool_service.py b/services/api_service/services/mcp_tool_service.py index c84a447..562cb9b 100644 --- a/services/api_service/services/mcp_tool_service.py +++ b/services/api_service/services/mcp_tool_service.py @@ -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: """ diff --git a/services/common/database.py b/services/common/database.py index 77c1f8e..156644f 100644 --- a/services/common/database.py +++ b/services/common/database.py @@ -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) diff --git a/services/common/error_msg.py b/services/common/error_msg.py index c7510f1..40cbdcb 100644 --- a/services/common/error_msg.py +++ b/services/common/error_msg.py @@ -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"} diff --git a/services/common/models/resource_group.py b/services/common/models/resource_group.py new file mode 100644 index 0000000..1b86b45 --- /dev/null +++ b/services/common/models/resource_group.py @@ -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"), + ) + diff --git a/services/common/models/user.py b/services/common/models/user.py index 699e6b3..d979295 100644 --- a/services/common/models/user.py +++ b/services/common/models/user.py @@ -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, diff --git a/services/common/response/user_response.py b/services/common/response/user_response.py index 677ea4d..56a7518 100644 --- a/services/common/response/user_response.py +++ b/services/common/response/user_response.py @@ -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 diff --git a/services/common/utils/validation_utils.py b/services/common/utils/validation_utils.py index 41f724c..20e7246 100644 --- a/services/common/utils/validation_utils.py +++ b/services/common/utils/validation_utils.py @@ -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]: