xmes-dingtalk-connectflow-sdk 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

DingtalkConnectflowSDk/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '1.0.1'
+__version__ = '1.0.3'
 
-from .complex_table import *  # noqa: F403
+from .complex_table import ComplexTable  # noqa: F401

DingtalkConnectflowSDk/_table/_types.py

@@ -0,0 +1,110 @@
+import json
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Literal
+
+from .._types import FilteredDataclass
+
+
+@dataclass
+class GetterFilter:
+    """记录筛选器"""
+
+    field: str
+    operator: Literal[
+        'equal', 'notEqual', 'incontain', 'notContain', 'empty', 'notEmpty'
+    ]
+    value: list[str] = None
+
+
+@dataclass
+class Updater:
+    """记录更新器"""
+
+    record_id: str
+    fields: dict[str, any]
+
+    def to_dict(self):
+        return self.__dict__
+
+
+@dataclass
+class GetterResult(metaclass=FilteredDataclass):
+    """获取器结果"""
+
+    nextCursor: str = None
+    records: list[dict] = None
+    hasMore: bool = False
+
+    def __post_init__(self):
+        if self.records and isinstance(self.records, list):
+            self.records = self.__records_handle()
+
+    def __records_handle(self):
+        records: list[dict] = []
+        for record in self.records:
+            record_temp = {'id': record.get('id'), 'fields': {}}
+            fields: dict = record.get('fields')
+
+            for field_name, field_value in fields.items():
+                _value = deepcopy(field_value)
+                if isinstance(field_value, dict):
+                    if 'link' in field_value:
+                        _value = field_value.get('link')
+                    elif 'name' in field_value:
+                        _value = field_value.get('name')
+
+                record_temp['fields'][field_name] = _value
+
+            records.append(record_temp)
+
+        return records
+
+    def to_file(self, file_path: str):
+        """
+        将数据写出到本地
+
+        Args:
+            file_path: 用于存储数据的文件路径
+        Returns:
+            格式化后的 json 字符串
+        """
+
+        if not self.records:
+            raise ValueError('数据记录为空, 无法写出')
+
+        json_str = json.dumps(self.records, ensure_ascii=False, indent=2)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(json_str)
+
+        return json_str
+
+
+@dataclass
+class AdderResult(metaclass=FilteredDataclass):
+    """新增器结果"""
+
+    result: list[str] = None
+    """新增的记录id列表"""
+    success: bool = None
+    errorMsg: str = None
+
+
+@dataclass
+class UpdaterResult(metaclass=FilteredDataclass):
+    """更新器结果"""
+
+    result: list[dict] = None
+    """更新的记录列表"""
+    success: bool = None
+    errorMsg: str = None
+
+
+@dataclass
+class DeletorResult(metaclass=FilteredDataclass):
+    """删除器结果"""
+
+    result: list[str] = None
+    """删除的记录id列表"""
+    success: bool = None
+    errorMsg: str = None

DingtalkConnectflowSDk/_table/table.py

@@ -0,0 +1,187 @@
+from typing import Any, Literal
+
+from requests import post
+
+from ._types import (
+    AdderResult,
+    DeletorResult,
+    GetterFilter,
+    GetterResult,
+    Updater,
+    UpdaterResult,
+)
+
+
+class Table:
+    __HEADERS = {
+        'Content-Type': 'application/json',
+    }
+
+    def __init__(self, flow_url: str, did: str, tid: str):
+        self.flow_url = flow_url
+        self.did = did
+        self.tid = tid
+        self.global_reqdata = {
+            'did': did,
+            'tid': tid,
+        }
+
+    def __verify_records(self, records: list[Any], record_type: object):
+        """
+        records 参数校验
+        - 校验失败, 抛出 ValueError 异常
+        - 校验成功, 返回清洗后的 records 列表
+
+        Args:
+            records: 记录列表
+            record_type: 记录类型
+        """
+
+        if not records or not isinstance(records, list):
+            raise ValueError('records 参数需要是列表类型且不能为空')
+
+        records_clean = [
+            record for record in records if record and isinstance(record, record_type)
+        ]
+        if not records_clean:
+            record_type_name = record_type.__qualname__
+            raise ValueError(
+                f'records 列表经过判断清洗后, 未在其中找到有效的 {record_type_name}'
+            )
+
+        return records_clean
+
+    def get(
+        self,
+        size=20,
+        cursor: str = '',
+        combination: Literal['and', 'or'] = 'and',
+        filters: list[GetterFilter] | None = None,
+    ):
+        """
+        获取表格数据
+        Args:
+            size: 每页数据条数, 默认为 20
+            cursor: 分页游标, 首次请求可不传, 后续需传入上一次返回的 nextCursor 值
+            combination: 组合方式
+            filters: 过滤条件
+        Returns:
+            GetterResult 对象
+        """
+
+        reqdata = {
+            **self.global_reqdata,
+            'handle': 'GET',
+            'handle_get': {
+                'size': size,
+                'cursor': cursor,
+            },
+        }
+
+        if combination and combination in ['and', 'or']:
+            filter_field = {}
+            filter_field['combination'] = combination
+            if filters and isinstance(filters, list):
+                conditions = [
+                    item.__dict__ for item in filters if isinstance(item, GetterFilter)
+                ]
+                filter_field['conditions'] = conditions
+            reqdata['handle_get']['filter'] = filter_field
+
+        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
+        resp_json: dict = resp.json()
+        result: dict = resp_json.get('GET_RESULT')
+        if not result or not isinstance(result, dict):
+            raise ValueError('返回的数据中未找到 GET_RESULT 字段或该字段非字典类型')
+
+        getter_result = GetterResult(**result)
+
+        return getter_result
+
+    def add(self, records: list[dict]):
+        """
+        新增记录
+        Args:
+            records: 用于新增的记录列表
+        Returns:
+            AdderResult 对象
+        """
+
+        records_clean = self.__verify_records(records, dict)
+
+        reqdata = {
+            **self.global_reqdata,
+            'handle': 'ADD',
+            'handle_add': {
+                'records': records_clean,
+            },
+        }
+
+        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
+        resp_json: dict = resp.json()
+        result: dict = resp_json.get('ADD_RESULT')
+        if not result or not isinstance(result, dict):
+            raise ValueError('返回的数据中未找到 ADD_RESULT 字段或该字段非字典类型')
+
+        adder_result = AdderResult(**result)
+
+        return adder_result
+
+    def update(self, records: list[Updater]):
+        """
+        更新记录
+        Args:
+            records: 更新记录列表
+        Returns:
+            UpdaterResult 对象
+        """
+
+        records_clean: list[Updater] = self.__verify_records(records, Updater)
+        records_clean = [record.to_dict() for record in records_clean]
+
+        reqdata = {
+            **self.global_reqdata,
+            'handle': 'UPDATE',
+            'handle_update': {
+                'records': records_clean,
+            },
+        }
+
+        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
+        resp_json: dict = resp.json()
+        result: dict = resp_json.get('UPDATE_RESULT')
+        if not result or not isinstance(result, dict):
+            raise ValueError('返回的数据中未找到 UPDATE_RESULT 字段或该字段非字典类型')
+
+        updater_result = UpdaterResult(**result)
+
+        return updater_result
+
+    def delete(self, record_ids: list[str]):
+        """
+        删除记录
+        Args:
+            record_ids: 记录 id 列表
+        Returns:
+            DeletorResult 对象
+        """
+
+        record_ids_clean = self.__verify_records(record_ids, str)
+
+        reqdata = {
+            **self.global_reqdata,
+            'handle': 'DELETE',
+            'handle_delete': {
+                'record_ids': record_ids_clean,
+            },
+        }
+
+        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
+        resp_json: dict = resp.json()
+        result: dict = resp_json.get('DELETE_RESULT')
+        if not result or not isinstance(result, dict):
+            raise ValueError('返回的数据中未找到 DELETE_RESULT 字段或该字段非字典类型')
+
+        deletor_result = DeletorResult(**result)
+
+        return deletor_result

DingtalkConnectflowSDk/complex_table.py

@@ -5,252 +5,78 @@ Author: LeslieLiang
 Description: 多维表连接流SDK
 """
 
-import json
-from copy import deepcopy
 from dataclasses import dataclass
-from typing import Literal
+from urllib.parse import parse_qs, urlparse
 
-from requests import post
-
-from ._types import FilteredDataclass
-
-
-@dataclass
-class GetterFilter:
-    """记录筛选器"""
-
-    field: str
-    operator: Literal[
-        'equal', 'notEqual', 'incontain', 'notContain', 'empty', 'notEmpty'
-    ]
-    value: list[str] = None
-
-
-@dataclass
-class Updater:
-    """记录更新器"""
-
-    record_id: str
-    fields: dict[str, any]
+from ._table.table import Table
 
 
 @dataclass
-class GetterResult(metaclass=FilteredDataclass):
-    """获取器结果"""
+class ViewUrl:
+    """视图链接对象"""
 
-    nextCursor: str = None
-    records: list[dict] = None
-    hasMore: bool = False
+    url: str = None
+    did: str = None
+    """文档id"""
+    tid: str = None
+    """数据表id"""
 
-    def __post_init__(self):
-        if self.records and isinstance(self.records, list):
-            self.records = self.__records_handle()
 
-    def __records_handle(self):
-        records: list[dict] = []
-        for record in self.records:
-            record_temp = {'id': record.get('id'), 'fields': {}}
-            fields: dict = record.get('fields')
-
-            for field_name, field_value in fields.items():
-                _value = deepcopy(field_value)
-                if isinstance(field_value, dict):
-                    if 'link' in field_value:
-                        _value = field_value.get('link')
-                    elif 'name' in field_value:
-                        _value = field_value.get('name')
-
-                record_temp['fields'][field_name] = _value
-
-            records.append(record_temp)
-
-        return records
-
-    def to_file(self, file_path: str):
+class ComplexTable:
+    def __init__(self, flow_url: str):
         """
-        将数据写出到本地
-
+        初始化 ComplexTable 类
         Args:
-            file_path: 用于存储数据的文件路径, 不需要文件后缀
-        Returns:
-            数据文件路径
+            flow_url: 连接流 url
         """
 
-        if not self.records:
-            raise ValueError('数据记录为空, 无法写出')
-
-        with open(f'{file_path}.json', 'w', encoding='utf-8') as f:
-            f.write(json.dumps(self.records, ensure_ascii=False, indent=2))
-
-        return file_path
-
-
-class Table:
-    __HEADERS = {
-        'Content-Type': 'application/json',
-    }
-
-    def __init__(self, flow_url: str, did: str, tid: str):
         self.flow_url = flow_url
-        self.did = did
-        self.tid = tid
-        self.global_reqdata = {
-            'did': did,
-            'tid': tid,
-        }
 
-    def get(
-        self,
-        size=20,
-        cursor: str = '',
-        combination: Literal['and', 'or'] = 'and',
-        filters: list[GetterFilter] | None = None,
-    ):
+    def _parse_view_url(self, view_url: str):
         """
-        获取表格数据
-        Args:
-            size: 每页数据条数, 默认为 20
-            cursor: 分页游标, 首次请求可不传, 后续需传入上一次返回的 nextCursor 值
-            combination: 组合方式
-            filters: 过滤条件
-        Returns:
-            表格数据
-        """
-
-        reqdata = {
-            **self.global_reqdata,
-            'handle': 'GET',
-            'handle_get': {
-                'size': size,
-                'cursor': cursor,
-            },
-        }
-
-        if combination and combination in ['and', 'or']:
-            filter_field = {}
-            filter_field['combination'] = combination
-            if filters and isinstance(filters, list):
-                conditions = [
-                    item.__dict__ for item in filters if isinstance(item, GetterFilter)
-                ]
-                filter_field['conditions'] = conditions
-            reqdata['handle_get']['filter'] = filter_field
+        解析视图链接
 
-        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
-        result: dict = resp.json().get('GET_RESULT')
-
-        getter_result = GetterResult(**result)
-
-        return getter_result
-
-    def add(self, records: list[dict]):
-        """
-        新增记录
         Args:
-            records: 新增记录列表
+            view_url: 视图链接
         Returns:
-            新增记录结果
+            ViewUrl 对象
         """
 
-        if not records or not isinstance(records, list):
-            raise ValueError('records must be a list')
+        if not view_url or not isinstance(view_url, str):
+            raise ValueError('view_url 参数不能为空或非字符串类型')
 
-        records_clean = [
-            record for record in records if record and isinstance(record, dict)
-        ]
-        if not records_clean:
-            raise ValueError('records must not be empty')
+        parsed_url = urlparse(view_url)
+        url_path_splited = parsed_url.path.split('/')
+        did = url_path_splited[-1]
 
-        reqdata = {
-            **self.global_reqdata,
-            'handle': 'ADD',
-            'handle_add': {
-                'records': records_clean,
-            },
-        }
+        query_dict = {k: v[0] for k, v in parse_qs(parsed_url.query).items()}
+        iframeQuery = query_dict.get('iframeQuery')
+        tid = parse_qs(iframeQuery).get('sheetId')[0]
 
-        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
-        return resp.json().get('ADD_RESULT')
+        return ViewUrl(url=view_url, did=did, tid=tid)
 
-    def update(self, records: list[Updater]):
-        """
-        更新记录
-        Args:
-            records: 更新记录列表
-        Returns:
-            更新记录结果
-        """
-
-        if not records or not isinstance(records, list):
-            raise ValueError('records must be a list')
-
-        records_clean = [
-            record.__dict__
-            for record in records
-            if record and isinstance(record, Updater)
-        ]
-        if not records_clean:
-            raise ValueError('records must not be empty')
-
-        reqdata = {
-            **self.global_reqdata,
-            'handle': 'UPDATE',
-            'handle_update': {
-                'records': records_clean,
-            },
-        }
-
-        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
-        return resp.json().get('UPDATE_RESULT')
-
-    def delete(self, record_ids: list[str]):
+    def get_table(self, did: str, tid: str) -> Table:
         """
-        删除记录
+        获取表格对象
         Args:
-            record_ids: 记录 id 列表
+            did: 文档 id
+            tid: 数据表 id
         Returns:
-            删除记录结果
+            Table 对象
         """
 
-        if not record_ids or not isinstance(record_ids, list):
-            raise ValueError('record_ids must be a list')
-
-        record_ids_clean = [
-            record_id
-            for record_id in record_ids
-            if record_id and isinstance(record_id, str)
-        ]
-
-        reqdata = {
-            **self.global_reqdata,
-            'handle': 'DELETE',
-            'handle_delete': {
-                'record_ids': record_ids_clean,
-            },
-        }
-
-        resp = post(self.flow_url, json=reqdata, headers=self.__HEADERS)
-        return resp.json().get('DELETE_RESULT')
-
+        return Table(self.flow_url, did, tid)
 
-class ComplexTable:
-    def __init__(self, flow_url: str):
-        """
-        初始化 ComplexTable 类
-        Args:
-            flow_url: 连接流 url
+    def get_table_by_view_url(self, url: str):
         """
+        通过视图链接获取表格对象
+        - 解析视图链接获取其中的文档id和视图id
 
-        self.flow_url = flow_url
-
-    def get_table(self, did: str, tid: str) -> Table:
-        """
-        获取表格对象
         Args:
-            did: 文档 id
-            tid: 数据表 id
+            url: 视图链接
         Returns:
             Table 对象
         """
 
-        return Table(self.flow_url, did, tid)
+        view_url = self._parse_view_url(view_url=url)
+        return self.get_table(did=view_url.did, tid=view_url.tid)

{xmes_dingtalk_connectflow_sdk-1.0.1.dist-info → xmes_dingtalk_connectflow_sdk-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xmes-dingtalk-connectflow-sdk
-Version: 1.0.1
+Version: 1.0.3
 Summary: DingTalk Connection Platform Connection Flow SDK
 License: MIT
 Author: leslieliang
@@ -16,7 +16,7 @@ Requires-Dist: requests (>=2.32.3,<3.0.0)
 Description-Content-Type: text/markdown
 
 ## 概述
-![Version](https://img.shields.io/badge/Version-v1.0.1-green)
+![Version](https://img.shields.io/badge/Version-v1.0.2-green)
 ![Python Version](https://img.shields.io/badge/Python-%E2%89%A53.9-blue)
 
 `xmes-dingtalk-connectflow-sdk` 是钉钉连接平台自建连接流SDK（向美而生），通过该工具可以方便快捷的调用钉钉的连接流。
@@ -33,35 +33,38 @@ pip install xmes-dingtalk-connectflow-sdk
 ### ComplexTable
 该工具提供了连接流 `多维表CURD_241217` 的操作调用工具。
 ```python
-from DingtalkConnectflowSDK import ComplexTable, GetterFilter, Updater
+from DingtalkConnectflowSDK import ComplexTable
+from DingtalkConnectflowSDk._table._types import GetterFilter, Updater
 
 # 初始化ComplexTable对象
 complextable = ComplexTable(flow_url='<连接流的同步协调URL>')
 
 # 获取 Table 对象
 table = complextable.get_table(did='<文档ID>', tid='<数据表ID>')
+# 或者直接传入视图链接
+# table = complextable.get_table_by_view_url(url='<视图链接>')
 
 # 查询数据
 filters = [
     GetterFilter(field='来源', operator='equal', value=['SDK', 'API'])
 ]
-resp = table.get(size=10, fillters=filters)
+result = table.get(size=10, fillters=filters)
 
 # 新增数据
 records = [
     {'标题': 'Test Record 1', '来源': 'SDK},
     {'标题': 'Test Record 2', '来源': 'SDK},
 ]
-resp = table.add(records)
+result = table.add(records)
 
 # 更新数据
 records = [
     Updater(record_id='<记录ID>', fields={'来源': 'API'}),
     Updater(record_id='<记录ID>', fields={'来源': 'API'}),
 ]
-resp = table.update(records)
+result = table.update(records)
 
 # 删除数据
 record_ids = ['<记录ID>', '<记录ID>']
-resp = table.delete(record_ids)
+result = table.delete(record_ids)
 ```

xmes_dingtalk_connectflow_sdk-1.0.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+DingtalkConnectflowSDk/__init__.py,sha256=VJs2MzhbqEwd2gdtyV17Bo4oVXhotWktGWB-J0Ic9GI,80
+DingtalkConnectflowSDk/_table/_types.py,sha256=DV-GVshNXdQTL0Ix53Z2Dd5G4fRi5hXEuUJxLzU_L6Y,2748
+DingtalkConnectflowSDk/_table/table.py,sha256=E2NCZRToTELaaJ4Q8oNgKEoA3HT14tsRNzeZjexTQeU,5755
+DingtalkConnectflowSDk/_types.py,sha256=TnJI3HHXVObasHWWdqBkX9n-N5E1IENmx7a4k0ehbdk,317
+DingtalkConnectflowSDk/complex_table.py,sha256=AVV5ALwmvDb73D8ZTQ-fXAPONn5tUmSPqvM9GbswsQg,2056
+xmes_dingtalk_connectflow_sdk-1.0.3.dist-info/LICENSE,sha256=pLVhl_GNSUPILCWP8DLtqZXytsqXr1lfPp4RwXXypZc,1090
+xmes_dingtalk_connectflow_sdk-1.0.3.dist-info/METADATA,sha256=rDyAPyG6CW6gf1DADDaHJ3mM3fft2IOHzSC-bnKUrvQ,2156
+xmes_dingtalk_connectflow_sdk-1.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+xmes_dingtalk_connectflow_sdk-1.0.3.dist-info/RECORD,,

xmes_dingtalk_connectflow_sdk-1.0.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-DingtalkConnectflowSDk/__init__.py,sha256=-hU6zkU0j1fC1i5ctzX9dvrooD_4Z9mJqjvz13yiqPc,69
-DingtalkConnectflowSDk/_types.py,sha256=TnJI3HHXVObasHWWdqBkX9n-N5E1IENmx7a4k0ehbdk,317
-DingtalkConnectflowSDk/complex_table.py,sha256=V4Az32gtsMlbjshrumuO_7dsx67I3EwK6-mceeZAurk,7000
-xmes_dingtalk_connectflow_sdk-1.0.1.dist-info/LICENSE,sha256=pLVhl_GNSUPILCWP8DLtqZXytsqXr1lfPp4RwXXypZc,1090
-xmes_dingtalk_connectflow_sdk-1.0.1.dist-info/METADATA,sha256=dMVvQ_UqRGy_1WRpFxOiJcvIZpxUcezwig0dRH4YLGc,2000
-xmes_dingtalk_connectflow_sdk-1.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-xmes_dingtalk_connectflow_sdk-1.0.1.dist-info/RECORD,,