@bangdao-ai/zentao-mcp 1.1.0 → 1.1.1

package/README.md

@@ -141,6 +141,7 @@ pip3 install -r requirements.txt
       "env": {
         "ZENTAO_PRODUCT_ID": "365",
         "ZENTAO_OPENED_BY": "69610",
+        "KEY": "643f0f490d1ea0d47520dd270989c99a",
         "ZENTAO_KEYWORDS": "AI",
         "ZENTAO_TITLE_PREFIX": ""
       }
@@ -151,7 +152,8 @@ pip3 install -r requirements.txt
 
 **配置说明**：
 - `ZENTAO_PRODUCT_ID`（必需）：产品ID
-- `ZENTAO_OPENED_BY`（必需）：创建人和指派人ID（同一个人）
+- `ZENTAO_OPENED_BY`（必需）：创建人和指派人ID（同一个人），作为API认证的code参数
+- `KEY`（必需）：API认证密钥，作为API认证的key参数
 - `ZENTAO_KEYWORDS`（可选）：关键词，默认为空
 - `ZENTAO_TITLE_PREFIX`（可选）：标题前缀，默认为空
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bangdao-ai/zentao-mcp",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "禅道Bug管理系统MCP工具",
   "main": "index.js",
   "bin": {

package/requirements.txt

@@ -3,4 +3,5 @@ requests>=2.31.0
 python-dotenv>=1.0.0
 fastapi>=0.104.0
 uvicorn[standard]>=0.24.0
+pytest>=7.0.0
 

package/src/mcp_server.py

@@ -203,10 +203,22 @@ class ZenTaoMCPServer:
                                 "enum": ["fixed", "bydesign", "reqchange", "duplicate", "external", "notrepro", "postponed", "willnotfix", "tostory", "history", "configchange"]
                             },
                             "resolved_by": {"type": "string", "description": "解决人（姓名或工号）"},
-                            "resolved_build": {"type": "string", "description": "解决版本ID（如果解决方案是fixed时，解决版本必传）"}
+                            "resolved_build": {"type": "string", "description": "解决版本ID（可选，如果未提供则默认使用trunk）"}
                         },
                         "required": ["product_id", "bug_ids", "resolution", "resolved_by"]
                     }
+                ),
+                Tool(
+                    name="close_bug",
+                    description="关闭BUG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "bug_id": {"type": "string", "description": "BUG ID"},
+                            "comment": {"type": "string", "description": "关闭备注（可选，默认AI关闭）"}
+                        },
+                        "required": ["bug_id"]
+                    }
                 )
             ]
         
@@ -230,7 +242,8 @@ class ZenTaoMCPServer:
                             "product_id": product_id,
                             "opened_by": opened_by,
                             "keywords": os.getenv("ZENTAO_KEYWORDS", ""),
-                            "title_prefix": os.getenv("ZENTAO_TITLE_PREFIX", "")
+                            "title_prefix": os.getenv("ZENTAO_TITLE_PREFIX", ""),
+                            "role_type": os.getenv("ZENTAO_ROLE_TYPE", "")
                         }
                         temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False)
                         json.dump(temp_config, temp_file, ensure_ascii=False)
@@ -435,6 +448,13 @@ class ZenTaoMCPServer:
                     result = self.nexus.resolve_bug(product_id, bug_ids, resolution, resolved_by, resolved_build)
                     return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
                 
+                elif name == "close_bug":
+                    bug_id = arguments["bug_id"]
+                    comment = arguments.get("comment", "AI关闭")
+                    
+                    result = self.nexus.close_bug(bug_id, comment)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
                 else:
                     raise ValueError(f"未知的工具: {name}")
             

package/src/zentao_nexus.py

@@ -104,13 +104,6 @@ class ZenTaoAPIClient:
     # 写死的配置
     BASE_URL = "https://zentao.bangdao-tech.com"
     TEST_BASE_URL = "https://test-zendao.bangdao-tech.com"
-    ACCOUNT = "KUBETEST"
-    SECRET_KEY = "aa287b7b5a4ef5d051f82fb1825ca1ac"
-    CASE_SECRET_KEY = "db1d522a190f1135c6e7c324bd337fda"
-    CASE_ACCOUNT = "AUTOTEST"
-    # 新API的配置
-    API_KEY = "1acca81c8a4d131cf7c86e772fa64351"
-    API_CODE = "test"
     
     def __init__(self, silent=True, use_test_env=False):
         """
@@ -121,34 +114,26 @@ class ZenTaoAPIClient:
             use_test_env (bool): 是否使用测试环境
         """
         self.base_url = self.TEST_BASE_URL if use_test_env else self.BASE_URL
-        self.account = self.ACCOUNT
-        self.secret_key = self.SECRET_KEY
-        self.case_secret_key = self.CASE_SECRET_KEY
         self.silent = silent
         self.use_test_env = use_test_env
-    
-    def generate_bdtoken(self, timestamp):
-        """生成BDTOKEN（用于BUG创建）"""
-        token_string = f"accountfmtamp{timestamp}{self.secret_key}"
-        md5_hash = hashlib.md5()
-        md5_hash.update(token_string.encode('utf-8'))
-        return md5_hash.hexdigest()
-    
-    def generate_case_bdtoken(self, timestamp):
-        """生成用例创建用的BDTOKEN"""
-        token_string = f"accountfmtamp{timestamp}{self.case_secret_key}"
-        md5_hash = hashlib.md5()
-        md5_hash.update(token_string.encode('utf-8'))
-        return md5_hash.hexdigest()
+        
+        # 从环境变量读取 code 和 key
+        self.code = os.getenv("ZENTAO_OPENED_BY") or os.getenv("OPENED_BY")
+        self.key = os.getenv("ZENTAO_KEY") or os.getenv("KEY")
+        
+        if not self.code:
+            raise ValueError("未设置环境变量 ZENTAO_OPENED_BY 或 OPENED_BY（用于 code）")
+        if not self.key:
+            raise ValueError("未设置环境变量 ZENTAO_KEY 或 KEY（用于 key）")
     
     def generate_api_token(self, timestamp):
-        """生成新API的token（md5(code + key + time)，32位小写）"""
-        token_string = f"{self.API_CODE}{self.API_KEY}{timestamp}"
+        """生成统一API的token（md5(code + key + time)，32位小写）"""
+        token_string = f"{self.code}{self.key}{timestamp}"
         md5_hash = hashlib.md5()
         md5_hash.update(token_string.encode('utf-8'))
         return md5_hash.hexdigest().lower()
     
-    def _call_new_api(self, function_name, params=None, form_data=None):
+    def _call_new_api(self, function_name, params=None, form_data=None, files=None, m_param='allneedlist'):
         """
         调用新的API接口（使用code、time、token认证）
         
@@ -156,6 +141,8 @@ class ZenTaoAPIClient:
             function_name: API函数名（f参数）
             params: URL参数（字典）
             form_data: POST form-data数据（字典或列表，列表格式用于数组参数）
+            files: 文件上传（字典，用于文件上传接口）
+            m_param: m参数值（默认allneedlist，某些接口可能需要其他值如bug）
         
         Returns:
             dict: API响应结果
@@ -165,10 +152,10 @@ class ZenTaoAPIClient:
         
         api_url = f"{self.base_url}/zentaopms/www/api.php"
         url_params = {
-            'code': self.API_CODE,
+            'code': self.code,
             'time': current_timestamp,
             'token': token,
-            'm': 'allneedlist',
+            'm': m_param,
             'f': function_name
         }
         
@@ -180,8 +167,73 @@ class ZenTaoAPIClient:
             'User-Agent': 'Python-ZenTao-Client/1.0'
         }
         
+        # 打印请求信息
+        print("\n" + "=" * 80)
+        print("【禅道API请求信息】")
+        print("=" * 80)
+        print(f"API URL: {api_url}")
+        print(f"\n【Headers】")
+        for key, value in headers.items():
+            print(f"  {key}: {value}")
+        
+        print(f"\n【Token生成信息】")
+        print(f"  code: {self.code}")
+        print(f"  key: {self.key[:10]}...{self.key[-10:] if len(self.key) > 20 else self.key}")  # 只显示部分key，保护隐私
+        print(f"  time: {current_timestamp}")
+        print(f"  token生成公式: md5(code + key + time)")
+        print(f"  token生成字符串: {self.code}{self.key}{current_timestamp}")
+        print(f"  token: {token}")
+        
+        print(f"\n【URL参数】")
+        for key, value in url_params.items():
+            print(f"  {key}: {value}")
+        
+        # 处理form_data用于显示
+        display_form_data = form_data
+        if isinstance(form_data, dict):
+            # 检查是否有数组类型的值
+            processed_data = []
+            for key, value in form_data.items():
+                if isinstance(value, (list, tuple)):
+                    for item in value:
+                        processed_data.append((key, str(item)))
+                else:
+                    processed_data.append((key, str(value)))
+            display_form_data = processed_data
+        
+        if display_form_data:
+            print(f"\n【Body (form-data)】")
+            if isinstance(display_form_data, list):
+                for item in display_form_data:
+                    if isinstance(item, tuple):
+                        key, value = item
+                        # 如果是文件，只显示文件名
+                        if hasattr(value, 'read'):
+                            print(f"  {key}: <文件对象>")
+                        else:
+                            print(f"  {key}: {value}")
+                    else:
+                        print(f"  {item}")
+            elif isinstance(display_form_data, dict):
+                for key, value in display_form_data.items():
+                    print(f"  {key}: {value}")
+        
+        if files:
+            print(f"\n【Files】")
+            for key, file_info in files.items():
+                if isinstance(file_info, tuple):
+                    filename = file_info[0] if len(file_info) > 0 else "unknown"
+                    print(f"  {key}: {filename}")
+                else:
+                    print(f"  {key}: {file_info}")
+        
+        print("=" * 80)
+        
         try:
-            if form_data:
+            if files:
+                # 文件上传
+                response = requests.post(api_url, params=url_params, headers=headers, data=form_data, files=files, timeout=30)
+            elif form_data:
                 # 如果form_data是列表，直接使用（用于数组参数）
                 # 如果是字典，需要检查是否有数组类型的值
                 if isinstance(form_data, dict):
@@ -200,9 +252,24 @@ class ZenTaoAPIClient:
             else:
                 response = requests.post(api_url, params=url_params, headers=headers, timeout=30)
             
+            # 打印响应信息
+            print("\n【禅道API响应信息】")
+            print("=" * 80)
+            print(f"状态码: {response.status_code}")
+            print(f"响应Headers:")
+            for key, value in response.headers.items():
+                print(f"  {key}: {value}")
+            
             try:
-                return response.json()
+                response_json = response.json()
+                print(f"\n响应Body (JSON):")
+                print(json.dumps(response_json, ensure_ascii=False, indent=2))
+                print("=" * 80 + "\n")
+                return response_json
             except json.JSONDecodeError:
+                print(f"\n响应Body (非JSON):")
+                print(response.text[:1000])  # 只显示前1000个字符
+                print("=" * 80 + "\n")
                 return {
                     "status": 0,
                     "message": "fail",
@@ -211,6 +278,9 @@ class ZenTaoAPIClient:
                     "raw_response": response.text
                 }
         except requests.exceptions.RequestException as e:
+            print(f"\n【请求异常】")
+            print(f"错误信息: {str(e)}")
+            print("=" * 80 + "\n")
             return {
                 "status": 0,
                 "message": "fail",
@@ -299,14 +369,14 @@ class ZenTaoAPIClient:
         
         return self._call_new_api('getBugList', params=params, form_data=form_data if form_data else None)
     
-    def resolve_bug(self, product_id, bug_ids, resolution, resolved_by, resolved_build=None):
+    def resolve_bug(self, product_id, bug_ids, resolution="fixed", resolved_by=None, resolved_build=None):
         """
         批量解决BUG
         
         Args:
             product_id: 产品ID（必传）
             bug_ids: BUG ID列表（必传），可以是单个ID或ID列表
-            resolution: 解决方案（必传），可选值：
+            resolution: 解决方案（可选，默认fixed），可选值：
                 fixed: 修复解决
                 bydesign: 设计如此
                 reqchange: 修改需求
@@ -319,18 +389,14 @@ class ZenTaoAPIClient:
                 history: 历史遗留
                 configchange: 调整配置
             resolved_by: 解决人（必传，姓名或工号）
-            resolved_build: 解决版本ID（如果解决方案是fixed时，解决版本必传）
+            resolved_build: 解决版本ID（可选，如果未提供则默认使用"trunk"）
         
         Returns:
             dict: 解决结果
         """
-        if resolution == 'fixed' and not resolved_build:
-            return {
-                "status": 0,
-                "message": "fail",
-                "info": "解决方案为fixed时，解决版本(resolvedBuild)必传",
-                "data": {}
-            }
+        # 如果没有提供 resolved_build，使用默认值 "trunk"
+        if not resolved_build:
+            resolved_build = "trunk"
         
         params = {'productID': product_id}
         form_data = {
@@ -349,83 +415,38 @@ class ZenTaoAPIClient:
         
         return self._call_new_api('resolveBug', params=params, form_data=form_data)
     
-    def create_bug_by_api(self, bug_data, use_form_data=True):
-        """通过API创建bug"""
-        current_timestamp = int(time.time())
-        bdtoken = self.generate_bdtoken(current_timestamp)
-        
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'createbugbyapi',
-            'account': self.account,
-            'tamp': current_timestamp
-        }
+    def close_bug(self, bug_id, comment="AI关闭"):
+        """
+        关闭BUG
         
-        headers = {
-            'BDTOKEN': bdtoken,
-            'User-Agent': 'Python-ZenTao-Client/1.0'
-        }
+        Args:
+            bug_id: BUG ID（必传）
+            comment: 关闭备注（可选，默认"AI关闭"）
         
-        try:
-            if use_form_data:
-                response = requests.post(url, params=params, headers=headers, data=bug_data, timeout=30)
-            else:
-                headers['Content-Type'] = 'application/json'
-                response = requests.post(url, params=params, headers=headers, json=bug_data, timeout=30)
-            
-            try:
-                return response.json()
-            except json.JSONDecodeError:
-                return {
-                    "status": -1,
-                    "message": "响应不是有效的JSON格式",
-                    "raw_response": response.text
-                }
-        except requests.exceptions.RequestException as e:
+        Returns:
+            dict: 关闭结果
+        """
+        params = {'bugID': bug_id}
+        form_data = {'comment': comment}
+        result = self._call_new_api('close', params=params, form_data=form_data, m_param='bug')
+        
+        # 如果返回的是"Array"字符串，表示操作成功（禅道某些接口的特殊返回格式）
+        if isinstance(result, dict) and result.get("raw_response") == "Array":
             return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
+                "status": 1,
+                "message": "success",
+                "info": "success"
             }
+        
+        return result
+    
+    def create_bug_by_api(self, bug_data, use_form_data=True):
+        """通过API创建bug"""
+        return self._call_new_api('createbugbyapi', form_data=bug_data)
     
     def create_case_by_api(self, case_data, use_form_data=True):
         """通过API创建测试用例"""
-        current_timestamp = int(time.time())
-        bdtoken = self.generate_case_bdtoken(current_timestamp)
-        
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'createcasebyapi',
-            'account': self.CASE_ACCOUNT,
-            'tamp': current_timestamp
-        }
-        
-        headers = {
-            'BDTOKEN': bdtoken,
-            'User-Agent': 'Python-ZenTao-Client/1.0'
-        }
-        
-        try:
-            if use_form_data:
-                response = requests.post(url, params=params, headers=headers, data=case_data, timeout=30)
-            else:
-                headers['Content-Type'] = 'application/json'
-                response = requests.post(url, params=params, headers=headers, json=case_data, timeout=30)
-            
-            try:
-                return response.json()
-            except json.JSONDecodeError:
-                return {
-                    "status": -1,
-                    "message": "响应不是有效的JSON格式",
-                    "raw_response": response.text
-                }
-        except requests.exceptions.RequestException as e:
-            return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
-            }
+        return self._call_new_api('createcasebyapi', form_data=case_data)
     
     def upload_image_to_bug(self, bug_id, image_path, custom_filename=None):
         """上传图片到BUG附件"""
@@ -435,25 +456,6 @@ class ZenTaoAPIClient:
                 "message": f"图片文件不存在: {image_path}"
             }
         
-        current_timestamp = int(datetime.now().timestamp())
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'uploadbyapi',
-            'account': self.CASE_ACCOUNT,
-            'tamp': current_timestamp
-        }
-        
-        token_string = f"accountfmtamp{current_timestamp}{self.case_secret_key}"
-        md5_hash = hashlib.md5()
-        md5_hash.update(token_string.encode('utf-8'))
-        bdtoken = md5_hash.hexdigest()
-        
-        headers = {
-            'BDTOKEN': bdtoken,
-            'User-Agent': 'Python-ZenTao-Client/1.0'
-        }
-        
         filename = custom_filename or os.path.basename(image_path)
         
         try:
@@ -461,22 +463,8 @@ class ZenTaoAPIClient:
                 files = {
                     'files[]': (filename, f, 'application/octet-stream')
                 }
-                data = {'id': bug_id}
-                response = requests.post(url, params=params, headers=headers, files=files, data=data, timeout=30)
-                
-                try:
-                    return response.json()
-                except json.JSONDecodeError:
-                    return {
-                        "status": -1,
-                        "message": "响应不是有效的JSON格式",
-                        "raw_response": response.text
-                    }
-        except requests.exceptions.RequestException as e:
-            return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
-            }
+                form_data = {'id': bug_id}
+                return self._call_new_api('uploadbyapi', form_data=form_data, files=files)
         except Exception as e:
             return {
                 "status": -1,
@@ -681,6 +669,15 @@ class ZenTaoNexus:
     LOWER_BUG = "0"
     REGRESSION = "0"
     
+    # 职位类型到任务类型的映射
+    ROLE_TO_TASK_TYPE = {
+        "测试": "4",      # 测试
+        "前端": "8",      # 前端开发
+        "后端": "3",      # 后端开发
+        "其它": "20",     # 其他
+        "其他": "20"      # 其他（兼容两种写法）
+    }
+    
     def __init__(self, config_path: str = None):
         """
         初始化ZenTao Nexus工具
@@ -719,6 +716,10 @@ class ZenTaoNexus:
         env_title_prefix = os.getenv("ZENTAO_TITLE_PREFIX") or os.getenv("TITLE_PREFIX")
         self.title_prefix = env_title_prefix or self.config_loader.get("title_prefix", "")
         
+        # 职位类型（用于创建任务时自动设置任务类型）
+        env_role_type = os.getenv("ZENTAO_ROLE_TYPE") or os.getenv("ROLE_TYPE")
+        self.role_type = env_role_type or self.config_loader.get("role_type", "")
+        
         # 创建API客户端
         self.client = ZenTaoAPIClient(silent=True)
     
@@ -835,7 +836,8 @@ class ZenTaoNexus:
             "product_id": self.product_id,
             "opened_by": self.opened_by,
             "keywords": self.keywords,
-            "title_prefix": self.title_prefix
+            "title_prefix": self.title_prefix,
+            "role_type": self.role_type
         }
     
     def upload_image_to_bug(self, bug_id, image_path, custom_filename=None):
@@ -855,7 +857,43 @@ class ZenTaoNexus:
         return self.client.get_story_detail(story_id)
     
     def create_task_by_api(self, task_data):
-        """创建任务"""
+        """
+        创建任务
+        
+        Args:
+            task_data: 任务数据（字典，form-data格式）
+                如果 task_data 中没有 'mold' 字段，且配置了职位类型(role_type)，
+                则根据职位类型自动设置任务类型
+                自动设置字段：
+                - estStarted: 当前日期（如果未指定）
+                - deadline: 当前日期+3天（如果未指定）
+                - pri: 2（如果未指定）
+                - openedBy: 配置的创建人（如果未指定）
+        
+        Returns:
+            dict: 创建结果，包含taskID
+        """
+        # 如果 task_data 中没有指定 mold，且配置了职位类型，则自动设置
+        if 'mold' not in task_data or (task_data.get('mold') == '' or task_data.get('mold') is None):
+            if self.role_type and self.role_type in self.ROLE_TO_TASK_TYPE:
+                task_data['mold'] = self.ROLE_TO_TASK_TYPE[self.role_type]
+        
+        # 自动设置预计开始时间（当前日期）
+        if 'estStarted' not in task_data or (task_data.get('estStarted') == '' or task_data.get('estStarted') is None):
+            task_data['estStarted'] = datetime.now().strftime("%Y-%m-%d")
+        
+        # 自动设置预计结束时间（当前日期+3天）
+        if 'deadline' not in task_data or (task_data.get('deadline') == '' or task_data.get('deadline') is None):
+            task_data['deadline'] = (datetime.now() + timedelta(days=3)).strftime("%Y-%m-%d")
+        
+        # 自动设置优先级为2
+        if 'pri' not in task_data or (task_data.get('pri') == '' or task_data.get('pri') is None):
+            task_data['pri'] = '2'
+        
+        # 自动设置创建人
+        if 'openedBy' not in task_data or (task_data.get('openedBy') == '' or task_data.get('openedBy') is None):
+            task_data['openedBy'] = self.opened_by
+        
         return self.client.create_task_by_api(task_data)
     
     def assign_task(self, task_id, assigned_to, comment=None):
@@ -868,9 +906,13 @@ class ZenTaoNexus:
         return self.client.get_bug_list(product_id, assigned_to, opened_by, resolved_by,
                                        confirmed, status, start_date, end_date)
     
-    def resolve_bug(self, product_id, bug_ids, resolution, resolved_by, resolved_build=None):
+    def resolve_bug(self, product_id, bug_ids, resolution="fixed", resolved_by=None, resolved_build=None):
         """批量解决BUG"""
         return self.client.resolve_bug(product_id, bug_ids, resolution, resolved_by, resolved_build)
+    
+    def close_bug(self, bug_id, comment="AI关闭"):
+        """关闭BUG"""
+        return self.client.close_bug(bug_id, comment)
 
 
 # 便捷函数