pytbox 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

pytbox/base.py

@@ -16,6 +16,8 @@ from pytbox.mail.client import MailClient
 from pytbox.mail.alimail import AliMail
 from pytbox.alicloud.sls import AliCloudSls
 from pytbox.utils.cronjob import cronjob_counter
+from pytbox.notion import Notion
+from pytbox.mingdao import Mingdao
 
 
 config = load_config_by_file(path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=os.environ.get('oc_vault_id'))
@@ -96,6 +98,7 @@ vmware_test = VMwareClient(
 
 pyjira = PyJira(
     base_url=config['jira']['base_url'],
+    username=config['jira']['username'],
     token=config['jira']['token']
 )
 
@@ -111,4 +114,8 @@ sls = AliCloudSls(
 )
 
 def get_cronjob_counter(app_type='', app='', comment=None, schedule_interval=None, schedule_cron=None):
-    return cronjob_counter(vm=vm, log=get_logger('cronjob_counter'), app_type=app_type, app=app, comment=comment, schedule_interval=schedule_interval, schedule_cron=schedule_cron)
+    return cronjob_counter(vm=vm, log=get_logger('cronjob_counter'), app_type=app_type, app=app, comment=comment, schedule_interval=schedule_interval, schedule_cron=schedule_cron)
+
+
+notion = Notion(token=config['notion']['api_secrets'], proxy=config['notion']['proxy'])
+mingdao = Mingdao(app_key=config['mingdao']['app_key'], sign=config['mingdao']['sign'])

pytbox/database/victoriametrics.py

@@ -168,41 +168,19 @@ class VictoriaMetrics:
             ReturnResponse: 
                 code = 0 正常, code = 1 异常, code = 2 没有查询到数据, 建议将其判断为正常
         '''
-        if target:
-            # 这里需要在字符串中保留 {}，同时插入 target，可以用双大括号转义
-            query = f"ping_result_code{{target='{target}'}}"
-        else:
-            query = "ping_result_code"
-        
-        if last_minute:
-            query = query + f"[{last_minute}m]"
-        
-        if env == 'dev':
+        query = f'avg_over_time((ping_result_code{{target="{target}"}})[{last_minute}m])'
+        if self.env == 'dev':
             r = load_dev_file(dev_file)
         else:
             r = self.query(query=query)
- 
         if r.code == 0:
-            values = r.data[0]['values']
-            if len(values) == 2 and values[1] == "0":
-                code = 0
-                msg = f"已检查 {target} 最近 {last_minute} 分钟是正常的!"
+            value = r.data[0]['value'][1]
+            if value == '0':
+                return ReturnResponse(code=0, msg=f"已检查 {target} 最近 {last_minute} 分钟是正常的!", data=r.data)
             else:
-                if all(str(item[1]) == "1" for item in values):
-                    code = 1
-                    msg = f"已检查 {target} 最近 {last_minute} 分钟是异常的!"
-                else:
-                    code = 0
-                    msg = f"已检查 {target} 最近 {last_minute} 分钟是正常的!"
-        elif r.code == 2:
-            code = 2
-            msg = f"没有查询到 {target} 最近 {last_minute} 分钟的ping结果!"
-        try:
-            data = r.data[0]
-        except KeyError:
-            data = r.data
-        
-        return ReturnResponse(code=code, msg=msg, data=data)
+                return ReturnResponse(code=1, msg=f"已检查 {target} 最近 {last_minute} 分钟是异常的!", data=r.data)
+        else:
+            return r
 
     def check_unreachable_ping_result(self, dev_file: str='') -> ReturnResponse:
         '''
@@ -396,4 +374,30 @@ class VictoriaMetrics:
             labels['schedule_type'] = 'cron'
             labels['schedule_cron'] = schedule_cron
         r = self.insert(metric_name="cronjob_run_duration_seconds", labels=labels, value=duration_seconds)
-        return r
+        return r
+    
+    def get_vmware_esxhostnames(self, vcenter: str=None) -> list:
+        '''
+        _summary_
+        '''
+        esxhostnames = []
+        query = f'vsphere_host_sys_uptime_latest{{vcenter="{vcenter}"}}'
+        metrics = self.query(query=query).data
+        for metric in metrics:
+            esxhostname = metric['metric']['esxhostname']
+            esxhostnames.append(esxhostname)
+        return esxhostnames
+    
+    def get_vmware_cpu_usage(self, vcenter: str=None, esxhostname: str=None) -> float:
+        '''
+        _summary_
+        '''
+        query = f'vsphere_host_cpu_usage_average{{vcenter="{vcenter}", esxhostname="{esxhostname}"}}'
+        return self.query(query=query).data[0]['value'][1]
+    
+    def get_vmware_memory_usage(self, vcenter: str=None, esxhostname: str=None) -> float:
+        '''
+        _summary_
+        '''
+        query = f'vsphere_host_mem_usage_average{{vcenter="{vcenter}", esxhostname="{esxhostname}"}}'
+        return self.query(query=query).data[0]['value'][1]

pytbox/mingdao.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+
+from typing import Literal, Type
+
+import requests
+
+from .utils.response import ReturnResponse
+
+
+class Mingdao:
+    '''
+    _summary_
+    '''
+    def __init__(self, app_key: str=None, sign: str=None, timeout: int=5):
+        self.base_url = "https://api.mingdao.com"
+        self.headers = {
+            'Content-Type': 'application/json;charset=UTF-8',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36'
+        }
+        self.timeout = timeout
+        self.app_key = app_key
+        self.sign = sign
+
+    def _build_api_request(self, api_url: str, method: Literal['GET', 'POST'], params: dict=None, body: dict=None, api_version: Literal['v1', 'v2']='v2'):
+        body['appKey'] = self.app_key
+        body['sign'] = self.sign
+        if not api_url.startswith('/'):
+            url = f'{self.base_url}/{api_version}/{api_url}'
+        else:
+            url = f'{self.base_url}/{api_version}{api_url}'
+        params = {
+            "appKey": self.app_key,
+            "sign": self.sign,
+        }
+        return requests.request(method, url, params=params, headers=self.headers, json=body, timeout=self.timeout)
+    
+    def get_app_info(self) -> ReturnResponse:
+        '''
+        _summary_
+
+        Returns:
+            ReturnResponse: _description_
+        '''
+        r = self._build_api_request(api_url='/open/app/get', method='GET', body={}, api_version='v1')
+        return ReturnResponse(code=0, msg='获取应用信息成功', data=r.json())
+    
+    def get_work_sheet_info(self, worksheet_id: str=None, table_name: str=None, worksheet_name: str=None):
+        if worksheet_name:
+            worksheet_id = self.get_work_sheet_id_by_name(table_name=table_name, worksheet_name=worksheet_name)
+        
+        r = self._build_api_request(
+            api_url='open/worksheet/getWorksheetInfo',
+            method='POST',
+            body={
+                "worksheetId": worksheet_id,
+            }
+        )
+        return r.json()
+    
+    def get_project_info(self, worksheet_id: str, keywords: str):
+        r = self._build_api_request(
+            api_url='open/worksheet/getFilterRows',
+            method='POST',
+            body={
+                "pageIndex": 1,
+                "pageSize": 100,
+                "worksheetId": worksheet_id,
+                "keyWords": keywords,
+            }
+        )
+        return r.json()
+    
+    def get_work_sheet_id_by_name(self, table_name: str, worksheet_name: str, child_section: bool=False):
+        r = self.get_app_info()        
+        for i in r.data['data']['sections']:
+            if table_name == i['name']:
+                if child_section:
+                    for child in i['childSections'][0]['items']:
+                        if child['name'] == worksheet_name:
+                            return child['id']
+                else:
+                    for item in i['items']:
+                        if item['name'] == worksheet_name:
+                            return item['id']
+
+    def get_control_id(self, table_name: str=None, worksheet_name: str=None, control_name: str=None):
+        r = self.get_work_sheet_info(table_name=table_name, worksheet_name=worksheet_name)
+        for control in r['data']['controls']:
+            if control['controlName'] == control_name:
+                return control['controlId']
+        return None
+    
+    def get_value(self, table_name: str=None, worksheet_name: str=None, control_name: str=None, value_name: str=None):
+        control_id = self.get_control_id(table_name=table_name, worksheet_name=worksheet_name, control_name=control_name)
+  
+        r = self._build_api_request(
+            api_url='open/worksheet/getFilterRows',
+            method='POST',
+            body={
+                "pageIndex": 1,
+                "pageSize": 100,
+                "worksheetId": self.get_work_sheet_id_by_name(table_name=table_name, worksheet_name=worksheet_name),
+                # "filters": filters
+            }
+        )
+        for row in r.json()['data']['rows']:
+            if row[control_id] == value_name:
+                return row['rowid']
+
+    def get_work_record(self, 
+                        worksheet_id: str=None,
+                        project_control_id: str=None,
+                        project_value: str=None,
+                        complete_date_control_id: str=None,
+                        complete_date: Literal['Today', '上个月', 'Last7Day', 'Last30Day']=None,
+                        parse_control_id: bool=False,
+                        page_size: int=100,
+                    ):
+        
+        filters = []
+        if project_value:
+            filters.append({
+                "controlId": project_control_id,
+                "dataType": 29,
+                "spliceType": 1,
+                "filterType": 24,
+                "dateRange": 0,
+                "dateRangeType": 0,
+                "value": "",
+                "values": [
+                    project_value
+                ],
+                "minValue": "",
+                "maxValue": ""
+            })
+        
+        if complete_date:
+            if complete_date == '上个月':
+                data_range = 8
+            elif complete_date == 'Today':
+                data_range = 1
+            elif complete_date == 'Last7Day':
+                data_range = 21
+            else:
+                data_range = 1
+            
+            filters.append({
+                "controlId": complete_date_control_id,
+                "dataType": 15,
+                "spliceType": 1,
+                "filterType": 17,
+                "dateRange": data_range,
+            })
+        r = self._build_api_request(
+            api_url='open/worksheet/getFilterRows',
+            method='POST',
+            body={
+                "pageIndex": 1,
+                "pageSize": page_size,
+                "worksheetId": worksheet_id,
+                "filters": filters
+            }
+        )
+        return r.json()

pytbox/notion.py

@@ -0,0 +1,731 @@
+#!/usr/bin/env python3
+
+import requests
+from .utils.response import ReturnResponse
+
+
+class Notion:
+    '''
+    Notion API 简单封装类
+    '''
+    def __init__(self, token: str, proxy: str = None, timeout: int=10):
+        self.token = token
+        self.headers = {
+            "accept": "application/json",
+            "Notion-Version": "2022-06-28",
+            "content-type": "application/json",
+            "Authorization": f"Bearer {self.token}"
+        }
+        self.timeout = timeout
+        self.proxy = proxy
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update({"http": self.proxy, "https": self.proxy})
+        self.base_url = "https://api.notion.com/v1"
+    
+    def database_create(self, page_id: str, name: str = "test databse") -> ReturnResponse:
+        """
+        在指定的 page 下创建一个简单的数据库
+        
+        Args:
+            page_id: 父页面的 ID（不需要带横杠）
+            database_name: 数据库名称
+            
+        Returns:
+            dict: API 响应结果
+        """
+        url = f"{self.base_url}/databases"
+
+        payload = {
+            "parent": {
+                "type": "page_id",
+                "page_id": page_id
+            },
+            "title": [
+                {
+                    "type": "text",
+                    "text": {
+                        "content": name
+                    }
+                }
+            ],
+            "properties": {
+                "名称": {
+                    "title": {}
+                }
+            }
+        }
+        
+        response = self.session.post(url, json=payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            return ReturnResponse(code=0, msg=f"数据库创建成功: {name}", data=response.json())
+        else:
+            return ReturnResponse(code=1, msg=f"数据库创建失败: {response.status_code}", data=response.text)
+
+    def database_update(self, db_id: str, title: str = None, description: str = None, icon: dict = None, cover: dict = None) -> ReturnResponse:
+        """
+        更新数据库属性
+        
+        Args:
+            db_id: 数据库 ID
+            title: 数据库标题
+            description: 数据库描述
+            icon: 数据库图标
+            cover: 数据库封面
+            
+        Returns:
+            ReturnResponse: 更新结果
+        """
+        url = f"{self.base_url}/databases/{db_id}"
+        
+        payload = {}
+        
+        # 构建更新字段
+        if title is not None:
+            payload["title"] = [
+                {
+                    "type": "text",
+                    "text": {
+                        "content": title
+                    }
+                }
+            ]
+        
+        if description is not None:
+            payload["description"] = [
+                {
+                    "type": "text", 
+                    "text": {
+                        "content": description
+                    }
+                }
+            ]
+            
+        if icon is not None:
+            payload["icon"] = icon
+            
+        if cover is not None:
+            payload["cover"] = cover
+        
+        # 如果没有提供任何更新字段，返回错误
+        if not payload:
+            return ReturnResponse(code=1, msg="至少需要提供一个更新字段", data=None)
+        
+        response = self.session.patch(url, json=payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            return ReturnResponse(code=0, msg="数据库更新成功", data=response.json())
+        else:
+            return ReturnResponse(code=1, msg=f"数据库更新失败: {response.status_code}", data=response.text)
+
+    def page_create(self, db_id: str, properties: dict = None) -> ReturnResponse:
+        """
+        在数据库中创建新页面（添加数据）
+        
+        Args:
+            db_id: 数据库 ID
+            properties: 页面属性字典，键为属性名，值为属性值
+            
+        Returns:
+            ReturnResponse: 创建结果
+        """
+        url = f"{self.base_url}/pages"
+        
+        # 默认属性
+        if properties is None:
+            properties = {}
+        
+        # 构建请求体
+        payload = {
+            "parent": {
+                "type": "database_id",
+                "database_id": db_id
+            },
+            "properties": {}
+        }
+        
+        # 处理属性
+        for key, value in properties.items():
+            payload["properties"][key] = self._format_property_value(key, value)
+        
+        response = self.session.post(url, json=payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            return ReturnResponse(code=0, msg="页面创建成功", data=response.json())
+        else:
+            return ReturnResponse(code=1, msg=f"页面创建失败: {response.status_code}", data=response.text)
+
+    def page_update(self, page_id: str, properties: dict = None) -> ReturnResponse:
+        """
+        更新页面属性
+        
+        Args:
+            page_id: 页面 ID
+            properties: 页面属性字典
+            
+        Returns:
+            ReturnResponse: 更新结果
+        """
+        url = f"{self.base_url}/pages/{page_id}"
+        
+        if properties is None:
+            properties = {}
+        
+        # 构建请求体
+        payload = {"properties": {}}
+        
+        # 处理属性
+        for key, value in properties.items():
+            payload["properties"][key] = self._format_property_value(key, value)
+        
+        response = self.session.patch(url, json=payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            return ReturnResponse(code=0, msg="页面更新成功", data=response.json())
+        else:
+            return ReturnResponse(code=1, msg=f"页面更新失败: {response.status_code}", data=response.text)
+
+    def page_upsert(self, db_id: str, unique_field: str, unique_value: str, properties: dict = None, content: list = None) -> ReturnResponse:
+        """
+        智能创建或更新页面（Upsert操作）
+        
+        根据唯一字段查找页面：
+        - 如果找到匹配的页面，则更新该页面的属性
+        - 如果未找到匹配的页面，则创建新页面
+        
+        支持的属性类型：
+        - 标题属性 (title): 字段名包含 name/title/名称/标题
+        - 文本属性 (rich_text): 普通文本字段
+        - 复选框属性 (checkbox): 布尔值
+        - 数字属性 (number): 数字值
+        - 多选属性 (multi_select): 字符串列表
+        - 单选属性 (select): 字典格式 {"name": "选项名"}
+        - 日期属性 (date): 字典格式 {"start": "2024-01-01"}
+        - URL属性 (url): 字典格式 {"url": "https://example.com"}
+        - 邮箱属性 (email): 字典格式 {"email": "test@example.com"}
+        - 电话号码属性 (phone_number): 字典格式 {"phone_number": "123-456-7890"}
+        - 状态属性 (status): 字典格式 {"name": "状态名"}
+        - 关系属性 (relation): 支持多种格式
+          * 直接ID: [{"id": "页面ID"}]
+          * 便捷格式: [{"title": "页面标题", "database_id": "数据库ID"}]
+          * 混合格式: [{"id": "页面ID1"}, {"title": "页面标题", "database_id": "数据库ID"}]
+        - 人员属性 (people): 列表格式 [{"id": "用户ID"}] 或 [{"email": "邮箱"}]
+        
+        Args:
+            db_id: 数据库 ID
+            unique_field: 用于查找的唯一字段名（如"名称"、"Name"等）
+            unique_value: 唯一字段的值，用于查找匹配的页面
+            properties: 页面属性字典，包含要设置或更新的属性
+            content: 页面内容列表，包含要添加的内容块
+            
+        Returns:
+            ReturnResponse: 创建或更新结果
+            - code=0: 操作成功
+            - code=1: 操作失败，查看 msg 和 data 获取错误信息
+            
+        Example:
+            # 第一次调用会创建新页面
+            result = notion.page_upsert(
+                db_id="database_id",
+                unique_field="Name",
+                unique_value="项目A",
+                properties={
+                    "Name": "项目A",
+                    "Status": {"name": "进行中"},
+                    "Priority": 1,
+                    "Tags": ["重要", "紧急"],
+                    # 关系字段便捷用法
+                    "RelatedPages": [
+                        {"title": "相关项目1", "database_id": "related_db_id"},
+                        {"title": "相关项目2", "database_id": "related_db_id"}
+                    ]
+                },
+                # 页面内容
+                content=[
+                    {"type": "heading_1", "text": "项目概述"},
+                    {"type": "paragraph", "text": "这是项目的详细描述"},
+                    {"type": "to_do", "text": "完成需求分析", "checked": True},
+                    {"type": "to_do", "text": "设计系统架构", "checked": False}
+                ]
+            )
+            
+            # 第二次调用会更新现有页面
+            result = notion.page_upsert(
+                db_id="database_id",
+                unique_field="Name", 
+                unique_value="项目A",  # 相同的唯一值
+                properties={
+                    "Name": "项目A",
+                    "Status": {"name": "已完成"},  # 更新状态
+                    "Priority": 2,  # 更新优先级
+                    # 混合关系字段格式
+                    "RelatedPages": [
+                        {"id": "existing_page_id"},  # 直接ID
+                        {"title": "新相关项目", "database_id": "related_db_id"}  # 便捷格式
+                    ]
+                },
+                # 更新页面内容
+                content=[
+                    {"type": "heading_2", "text": "更新内容"},
+                    {"type": "paragraph", "text": "项目状态已更新"},
+                    {"type": "quote", "text": "项目进展顺利"}
+                ]
+            )
+        """
+        if properties is None:
+            properties = {}
+        if content is None:
+            content = []
+        
+        # 1. 先查询数据库，看是否存在相同记录
+        query_url = f"{self.base_url}/databases/{db_id}/query"
+        query_payload = {
+            "filter": {
+                "property": unique_field,
+                "title": {
+                    "equals": unique_value
+                }
+            }
+        }
+        
+        query_response = self.session.post(query_url, json=query_payload, timeout=self.timeout)
+        
+        if query_response.status_code == 200:
+            results = query_response.json().get("results", [])
+            
+            if results:
+                # 找到记录，执行更新
+                page_id = results[0]["id"]
+                
+                # 更新页面属性
+                update_result = self.page_update(page_id, properties)
+                
+                # 如果有内容需要添加，则添加内容
+                if content and update_result.code == 0:
+                    content_result = self.page_add_content(page_id, content)
+                    if content_result.code == 0:
+                        return content_result
+                    else:
+                        return update_result
+                else:
+                    return update_result
+            else:
+                # 未找到记录，执行创建
+                # 确保唯一字段包含在属性中
+                if unique_field not in properties:
+                    properties[unique_field] = unique_value
+                
+                # 创建页面
+                create_result = self.page_create(db_id, properties)
+                
+                # 如果有内容需要添加，则添加内容
+                if content and create_result.code == 0:
+                    page_id = create_result.data["id"]
+                    content_result = self.page_add_content(page_id, content)
+                    if content_result.code == 0:
+                        return content_result
+                    else:
+                        return create_result
+                else:
+                    return create_result
+        else:
+            # 查询失败，直接尝试创建
+            if unique_field not in properties:
+                properties[unique_field] = unique_value
+            
+            # 创建页面
+            create_result = self.page_create(db_id, properties)
+            
+            # 如果有内容需要添加，则添加内容
+            if content and create_result.code == 0:
+                page_id = create_result.data["id"]
+                content_result = self.page_add_content(page_id, content)
+                if content_result.code == 0:
+                    return content_result
+                else:
+                    return create_result
+            else:
+                return create_result
+
+    def _find_page_by_title(self, db_id: str, title: str) -> str:
+        """
+        根据标题在数据库中查找页面ID
+        
+        Args:
+            db_id: 数据库ID
+            title: 页面标题
+            
+        Returns:
+            str: 页面ID，如果未找到返回None
+        """
+        query_url = f"{self.base_url}/databases/{db_id}/query"
+        query_payload = {
+            "filter": {
+                "property": "Name",  # 假设标题字段名为"Name"
+                "title": {
+                    "equals": title
+                }
+            }
+        }
+        
+        response = self.session.post(query_url, json=query_payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            results = response.json().get("results", [])
+            if results:
+                return results[0]["id"]
+        
+        return None
+
+    def _format_relation_value(self, value) -> list:
+        """
+        格式化关系属性值，支持多种输入格式
+        
+        Args:
+            value: 关系值，支持以下格式：
+                - 字符串: 页面标题，需要指定database_id
+                - 字典: {"title": "页面标题", "database_id": "数据库ID"}
+                - 列表: [{"title": "标题1", "database_id": "数据库ID1"}, ...]
+                - 列表: [{"id": "页面ID1"}, {"id": "页面ID2"}]
+                
+        Returns:
+            list: 格式化后的关系值列表
+        """
+        if isinstance(value, str):
+            # 字符串格式，需要database_id
+            raise ValueError("字符串格式需要同时提供database_id，请使用字典格式：{'title': '页面标题', 'database_id': '数据库ID'}")
+        
+        elif isinstance(value, dict):
+            if "id" in value:
+                # 直接提供页面ID
+                return [{"id": value["id"]}]
+            elif "title" in value and "database_id" in value:
+                # 提供标题和数据库ID，需要查找页面ID
+                page_id = self._find_page_by_title(value["database_id"], value["title"])
+                if page_id:
+                    return [{"id": page_id}]
+                else:
+                    raise ValueError(f"未找到标题为 '{value['title']}' 的页面")
+            else:
+                raise ValueError("字典格式必须包含 'id' 或 ('title' 和 'database_id')")
+        
+        elif isinstance(value, list):
+            relation_result = []
+            for item in value:
+                if isinstance(item, str):
+                    raise ValueError("列表中的字符串需要提供database_id")
+                elif isinstance(item, dict):
+                    if "id" in item:
+                        relation_result.append({"id": item["id"]})
+                    elif "title" in item and "database_id" in item:
+                        page_id = self._find_page_by_title(item["database_id"], item["title"])
+                        if page_id:
+                            relation_result.append({"id": page_id})
+                        else:
+                            raise ValueError(f"未找到标题为 '{item['title']}' 的页面")
+                    else:
+                        raise ValueError("列表项必须包含 'id' 或 ('title' 和 'database_id')")
+                else:
+                    raise ValueError("列表项必须是字典格式")
+            return relation_result
+        
+        else:
+            raise ValueError("不支持的关系值格式")
+
+    def _format_property_value(self, key: str, value) -> dict:
+        """
+        根据属性类型格式化属性值
+        
+        Args:
+            key: 属性名
+            value: 属性值
+            
+        Returns:
+            dict: 格式化后的属性值
+        """
+        if isinstance(value, str):
+            # 根据字段名判断属性类型
+            if key.lower() in ['name', 'title', '名称', '标题']:
+                # 标题属性
+                return {
+                    "title": [
+                        {
+                            "type": "text",
+                            "text": {
+                                "content": value
+                            }
+                        }
+                    ]
+                }
+            else:
+                # 文本属性 (rich_text)
+                return {
+                    "rich_text": [
+                        {
+                            "type": "text",
+                            "text": {
+                                "content": value
+                            }
+                        }
+                    ]
+                }
+        elif isinstance(value, bool):
+            # 复选框属性
+            return {"checkbox": value}
+        elif isinstance(value, (int, float)):
+            # 数字属性
+            return {"number": value}
+        elif isinstance(value, list):
+            # 列表类型，需要进一步判断
+            if not value:
+                # 空列表，默认作为多选处理
+                return {"multi_select": []}
+            
+            # 根据第一个元素的类型判断
+            first_item = value[0]
+            if isinstance(first_item, str):
+                # 多选属性
+                return {
+                    "multi_select": [
+                        {"name": item} for item in value
+                    ]
+                }
+            elif isinstance(first_item, dict):
+                # 复杂对象列表
+                if "name" in first_item:
+                    # 多选属性
+                    return {"multi_select": value}
+                elif "id" in first_item or "title" in first_item:
+                    # 关系属性
+                    try:
+                        return {"relation": self._format_relation_value(value)}
+                    except ValueError:
+                        return {"relation": value}  # 回退到原始值
+                elif "email" in first_item:
+                    # 人员属性
+                    return {"people": value}
+                elif "object" in first_item and first_item["object"] == "user":
+                    # 人员属性（用户对象格式）
+                    return {"people": value}
+            return {"multi_select": [{"name": str(item)} for item in value]}
+        elif isinstance(value, dict):
+            # 字典类型
+            if "start" in value:
+                # 日期属性
+                return {"date": value}
+            elif "name" in value:
+                # 单选属性
+                return {"select": value}
+            elif "url" in value:
+                # URL属性
+                return {"url": value["url"]}
+            elif "email" in value:
+                # 邮箱属性
+                return {"email": value["email"]}
+            elif "phone_number" in value:
+                # 电话号码属性
+                return {"phone_number": value["phone_number"]}
+            elif "status" in value:
+                # 状态属性
+                return {"status": value}
+            elif "id" in value or "title" in value:
+                # 关系属性
+                try:
+                    return {"relation": self._format_relation_value(value)}
+                except ValueError:
+                    return {"relation": value}  # 回退到原始值
+            else:
+                # 默认作为单选处理
+                return {"select": value}
+        else:
+            # 其他类型，转换为字符串处理
+            return {
+                "rich_text": [
+                    {
+                        "type": "text",
+                        "text": {
+                            "content": str(value)
+                        }
+                    }
+                ]
+            }
+
+    def page_add_content(self, page_id: str, content: list) -> ReturnResponse:
+        """
+        向页面添加内容块
+        
+        Args:
+            page_id: 页面 ID
+            content: 内容块列表，每个元素是一个内容块
+            
+        Returns:
+            ReturnResponse: 添加结果
+        """
+        url = f"{self.base_url}/blocks/{page_id}/children"
+        
+        # 格式化内容块
+        formatted_blocks = []
+        for block in content:
+            formatted_blocks.append(self._format_content_block(block))
+        
+        payload = {"children": formatted_blocks}
+        
+        response = self.session.patch(url, json=payload, timeout=self.timeout)
+        
+        if response.status_code == 200:
+            return ReturnResponse(code=0, msg="页面内容添加成功", data=response.json())
+        else:
+            return ReturnResponse(code=1, msg=f"页面内容添加失败: {response.status_code}", data=response.text)
+
+    def _format_content_block(self, block: dict) -> dict:
+        """
+        格式化内容块
+        
+        Args:
+            block: 内容块字典，格式如：
+                {
+                    "type": "paragraph",
+                    "text": "这是段落文本"
+                }
+                或
+                {
+                    "type": "heading_1",
+                    "text": "这是一级标题"
+                }
+                
+        Returns:
+            dict: 格式化后的内容块
+        """
+        block_type = block.get("type", "paragraph")
+        text = block.get("text", "")
+        
+        # 基础文本内容
+        text_content = {
+            "type": "text",
+            "text": {
+                "content": text
+            }
+        }
+        
+        # 根据类型返回不同的块结构
+        if block_type == "paragraph":
+            return {
+                "type": "paragraph",
+                "paragraph": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "heading_1":
+            return {
+                "type": "heading_1",
+                "heading_1": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "heading_2":
+            return {
+                "type": "heading_2",
+                "heading_2": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "heading_3":
+            return {
+                "type": "heading_3",
+                "heading_3": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "bulleted_list_item":
+            return {
+                "type": "bulleted_list_item",
+                "bulleted_list_item": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "numbered_list_item":
+            return {
+                "type": "numbered_list_item",
+                "numbered_list_item": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "to_do":
+            checked = block.get("checked", False)
+            return {
+                "type": "to_do",
+                "to_do": {
+                    "rich_text": [text_content],
+                    "checked": checked
+                }
+            }
+        elif block_type == "quote":
+            return {
+                "type": "quote",
+                "quote": {
+                    "rich_text": [text_content]
+                }
+            }
+        elif block_type == "code":
+            language = block.get("language", "plain text")
+            return {
+                "type": "code",
+                "code": {
+                    "rich_text": [text_content],
+                    "language": language
+                }
+            }
+        else:
+            # 默认作为段落处理
+            return {
+                "type": "paragraph",
+                "paragraph": {
+                    "rich_text": [text_content]
+                }
+            }
+
+if __name__ == "__main__":
+    # 使用示例
+    notion = Notion(token="your_integration_token_here")
+    database_id = "your_database_id_here"
+    
+    # 使用智能创建/更新方法
+    # 第一次调用会创建新记录
+    result = notion.page_upsert(
+        db_id=database_id,
+        unique_field="名称",  # 用于查找的唯一字段
+        unique_value="测试记录",  # 唯一字段的值
+        properties={
+            "名称": "测试记录",
+            "状态": ["进行中"],
+            "完成": False,
+            "优先级": 1
+        }
+    )
+    
+    # 第二次调用会更新现有记录
+    result = notion.page_upsert(
+        db_id=database_id,
+        unique_field="名称",
+        unique_value="测试记录",  # 相同的唯一值
+        properties={
+            "名称": "测试记录",
+            "状态": ["已完成"],  # 更新状态
+            "完成": True,        # 更新完成状态
+            "优先级": 2          # 更新优先级
+        }
+    )
+    
+    # 使用不同的唯一值会创建新记录
+    result = notion.page_upsert(
+        db_id=database_id,
+        unique_field="名称",
+        unique_value="新记录",
+        properties={
+            "名称": "新记录",
+            "状态": ["待处理"],
+            "完成": False,
+            "优先级": 3
+        }
+    )

pytbox/pyjira.py

@@ -89,8 +89,11 @@ class PyJira:
             dict: 任务信息或账户ID
         """
         url = f"{self.base_url}/rest/api/{self.rest_version}/issue/{issue_id_or_key}"
+        print(url)
         r = self.session.get(url, headers=self.headers, timeout=self.timeout)
         
+        print(r.text)
+        
         # 移除所有 key 以 customfield_ 开头且后面跟数字的字段
         fields = r.json()['fields']
         keys_to_remove = [k for k in fields if k.startswith('customfield_') and k[12:].isdigit()]
@@ -313,6 +316,7 @@ class PyJira:
     
     def issue_search(self, jql: str, max_results: int = 50, fields: Optional[List[str]] = None) -> ReturnResponse:
         """使用JQL搜索JIRA任务
+        https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-search/#api-rest-api-3-search-jql-get
         
         Args:
             jql: JQL查询字符串
@@ -322,26 +326,29 @@ class PyJira:
         Returns:
             ReturnResponse: 包含任务列表的响应数据
         """
-        url = f"{self.base_url}/rest/api/3/search"
+        url = f"{self.base_url}/rest/api/3/search/jql"
         
-        # 构建请求体
-        payload = {
+        # 构建查询参数
+        params = {
             "jql": jql,
             "maxResults": max_results,
             "startAt": 0
         }
         
-        # 如果指定了字段，添加到请求体中
-        if fields:
-            payload["fields"] = fields
+        # 如果指定了字段，添加到查询参数中
+        if isinstance(fields, list):
+            params["fields"] = ",".join(fields)
+        else:
+            params["fields"] = fields
         
-        r = self.session.post(url, headers=self.headers, json=payload, timeout=self.timeout)
+        r = self.session.get(url, headers=self.headers, params=params, timeout=self.timeout)
         
         if r.status_code == 200:
             return ReturnResponse(code=0, msg='', data=r.json())
         else:
             return ReturnResponse(code=1, msg=f'获取 issue 失败, status code: {r.status_code}, 报错: {r.text}')
 
+
     def get_boards(self) -> ReturnResponse:
         """获取所有看板信息并打印
         

{pytbox-0.2.4.dist-info → pytbox-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytbox
-Version: 0.2.4
+Version: 0.2.6
 Summary: A collection of Python integrations and utilities (Feishu, Dida365, VictoriaMetrics, ...)
 Author-email: mingming hou <houm01@foxmail.com>
 License-Expression: MIT

{pytbox-0.2.4.dist-info → pytbox-0.2.6.dist-info}/RECORD

@@ -1,10 +1,12 @@
-pytbox/base.py,sha256=VAAaf081rTih9_FjOvAvcihbXp-zwmbGvASnoB2mNZo,4254
+pytbox/base.py,sha256=WC_p_PYMMpNq-5JRLyZoD74k-d2EQVmO4VjTvnI7VqE,4541
 pytbox/cli.py,sha256=N775a0GK80IT2lQC2KRYtkZpIiu9UjavZmaxgNUgJhQ,160
 pytbox/dida365.py,sha256=pUMPB9AyLZpTTbaz2LbtzdEpyjvuGf4YlRrCvM5sbJo,10545
 pytbox/excel.py,sha256=f5XBLCeJbGgxytoSwVhbk03WLTzz8Q3IJ_RZ2-r_w6A,2334
+pytbox/mingdao.py,sha256=afEFJ9NKPdsmAZ4trBEJKl66fMj3Z8TWfaOcomNGhzw,6042
+pytbox/notion.py,sha256=GRPdZAtyG2I6M6pCFbdrTWDACaPsp1RAXrY_RpWYKus,26572
 pytbox/onepassword_connect.py,sha256=nD3xTl1ykQ4ct_dCRRF138gXCtk-phPfKYXuOn-P7Z8,3064
 pytbox/onepassword_sa.py,sha256=08iUcYud3aEHuQcUsem9bWNxdXKgaxFbMy9yvtr-DZQ,6995
-pytbox/pyjira.py,sha256=TMy34Rtu7OXRA8wpUuLsFeyIQfRNUn2ed2no00L8YSE,22470
+pytbox/pyjira.py,sha256=7yWfu_qsQNoEoQWagnriD9QWrMyTC3OCAvGfvjLZP74,22731
 pytbox/vmware.py,sha256=WiH67_3-VCBjXJuh3UueOc31BdZDItiZhkeuPzoRhw4,3975
 pytbox/alert/alert_handler.py,sha256=WCn4cKahv5G5BFGgmc7dX7BQ38h2kxTgxfRVTwc1O2M,6579
 pytbox/alert/ping.py,sha256=KEnnXdIRJHvR_rEHPWLBt0wz4cGwmA29Lenlak3Z_1Y,778
@@ -43,7 +45,7 @@ pytbox/cli/formatters/__init__.py,sha256=4o85w4j-A-O1oBLvuE9q8AFiJ2C9rvB3MIKsy5V
 pytbox/cli/formatters/output.py,sha256=h5WhZlQk1rjmxEj88Jy5ODLcv6L5zfGUhks_3AWIkKU,5455
 pytbox/common/__init__.py,sha256=3JWfgCQZKZuSH5NCE7OCzKwq82pkyop9l7sH5YSNyfU,122
 pytbox/database/mongo.py,sha256=AhJ9nCAQHKrrcL-ujeonOwEf3x2QkmT2VhoCdglqJmU,3478
-pytbox/database/victoriametrics.py,sha256=EqKJag3s-E0V4Xb3vQNc82w6tOth2Q0_0dC15AKOgRs,15344
+pytbox/database/victoriametrics.py,sha256=vUv2sRTvtdIRiZWrbLmAp6mrey8bJKVZc3bRFBpFnok,15660
 pytbox/feishu/client.py,sha256=kwGLseGT_iQUFmSqpuS2_77WmxtHstD64nXvktuQ3B4,5865
 pytbox/feishu/endpoints.py,sha256=z3nPOZPC2JGDJlO7SusWBpRA33hZZ4Z-GBhI6F8L_u4,40240
 pytbox/feishu/errors.py,sha256=79qFAHZw7jDj3gnWAjI1-W4tB0q1_aSfdjee4xzXeuI,1179
@@ -63,8 +65,8 @@ pytbox/utils/response.py,sha256=kXjlwt0WVmLRam2eu1shzX2cQ7ux4cCQryaPGYwle5g,1247
 pytbox/utils/richutils.py,sha256=OT9_q2Q1bthzB0g1GlhZVvM4ZAepJRKL6a_Vsr6vEqo,487
 pytbox/utils/timeutils.py,sha256=uSKgwt20mVcgIGKLsH2tNum8v3rcpzgmBibPvyPQFgM,20433
 pytbox/win/ad.py,sha256=-3pWfL3dElz-XoO4j4M9lrgu3KJtlhrS9gCWJBpafAU,1147
-pytbox-0.2.4.dist-info/METADATA,sha256=29ykO-NI1Kbh7ceqr8--Lzx7_2hz-Cu-croz2RhdHOU,6319
-pytbox-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytbox-0.2.4.dist-info/entry_points.txt,sha256=YaTOJ2oPjOiv2SZwY0UC-UA9QS2phRH1oMvxGnxO0Js,43
-pytbox-0.2.4.dist-info/top_level.txt,sha256=YADgWue-Oe128ptN3J2hS3GB0Ncc5uZaSUM3e1rwswE,7
-pytbox-0.2.4.dist-info/RECORD,,
+pytbox-0.2.6.dist-info/METADATA,sha256=imFjJeLVrjd09kC9dBKWYtVIGXH4hphvPh7mTAQTw9A,6319
+pytbox-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytbox-0.2.6.dist-info/entry_points.txt,sha256=YaTOJ2oPjOiv2SZwY0UC-UA9QS2phRH1oMvxGnxO0Js,43
+pytbox-0.2.6.dist-info/top_level.txt,sha256=YADgWue-Oe128ptN3J2hS3GB0Ncc5uZaSUM3e1rwswE,7
+pytbox-0.2.6.dist-info/RECORD,,