794 lines
29 KiB
Python
794 lines
29 KiB
Python
"""
|
|
API 模块 - 简道云API接口封装
|
|
支持失败重试机制，兼容现有代码
|
|
"""
|
|
import requests
|
|
import json
|
|
import time
|
|
import logging
|
|
from typing import Optional, List, Dict, Any
|
|
from decimal import Decimal
|
|
import numpy as np
|
|
from app.config import Config
|
|
|
|
# 获取日志记录器
|
|
logger = logging.getLogger('app')
|
|
error_logger = logging.getLogger('app.error') # 错误日志记录器
|
|
|
|
|
|
class NpEncoder(json.JSONEncoder):
|
|
"""NumPy数据类型JSON编码器"""
|
|
def default(self, obj):
|
|
if isinstance(obj, np.integer):
|
|
return int(obj)
|
|
elif isinstance(obj, np.floating):
|
|
return float(obj)
|
|
elif isinstance(obj, np.ndarray):
|
|
return obj.tolist()
|
|
else:
|
|
return super(NpEncoder, self).default(obj)
|
|
|
|
|
|
def replace_decimals(obj):
|
|
"""递归替换Decimal类型为float"""
|
|
if isinstance(obj, dict):
|
|
return {k: replace_decimals(v) for k, v in obj.items()}
|
|
elif isinstance(obj, list):
|
|
return [replace_decimals(item) for item in obj]
|
|
elif isinstance(obj, Decimal):
|
|
return float(obj)
|
|
return obj
|
|
|
|
|
|
class API:
|
|
def entry_data_get(self, data: dict, replace: bool = True, max_retries: int = 20) -> Dict:
|
|
"""
|
|
获取单条表单数据
|
|
:param replace: 是否替换字段，默认为True（保持向后兼容）
|
|
:param max_retries: 最大重试次数
|
|
:param data: 简道云插件发送过来的data，包含应用id、表单id、数据id等信息
|
|
:return: 表单数据
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/get'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_id": data['data_id']
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
print(data_get)
|
|
|
|
if replace:
|
|
data_get = self.field_replacement(data, data_get)
|
|
|
|
return data_get
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
if retries <= max_retries:
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data_id')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
raise Exception(f"获取单条表单数据失败，已重试{max_retries}次")
|
|
|
|
def entry_data_list(self, data: dict, replace: bool = True, max_retries: int = 20) -> Dict:
|
|
"""
|
|
获取多条表单数据
|
|
:param max_retries: 最大重试次数
|
|
:param replace: 是否替换字段，默认为True（保持向后兼容）
|
|
:param data: 简道云插件发送过来的data，包含应用id、表单id等信息
|
|
:return: 表单数据列表
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/list'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
all_data_batches = []
|
|
last_data_id = None
|
|
exit_flag = False
|
|
|
|
while True:
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"limit": 100,
|
|
"data_id": last_data_id
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
|
|
if data_get.get("data"):
|
|
all_data_batches.extend(data_get['data'])
|
|
last_data_id = data_get['data'][-1].get('_id')
|
|
print(f"已获取 {len(all_data_batches)} 条数据")
|
|
break
|
|
else:
|
|
if 'data' not in data_get or len(data_get['data']) == 0:
|
|
exit_flag = True
|
|
break
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(0.1)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {last_data_id}组 连续{max_retries}次请求失败，放弃此次请求。")
|
|
all_data_batches.append(None)
|
|
|
|
if exit_flag:
|
|
break
|
|
|
|
final_data = {
|
|
'data': all_data_batches
|
|
}
|
|
|
|
logger.info(f"获取了{len(all_data_batches)}条数据")
|
|
|
|
if replace:
|
|
print("进行了替换")
|
|
return self.field_replacement(data, final_data)
|
|
else:
|
|
return final_data
|
|
|
|
@staticmethod
|
|
def entry_widget_list(data: dict, max_retries: int = 20) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
获取表单字段
|
|
:param max_retries: 最大重试次数
|
|
:param data: 简道云插件发送过来的data，包含应用id、表单id等信息
|
|
:return: 表单字段信息
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/widget/list'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
return res.json()
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
if retries <= max_retries:
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"获取表单字段失败，已重试{max_retries}次")
|
|
return None
|
|
|
|
def field_replacement(self, data: dict, data_get: dict) -> dict:
|
|
"""
|
|
字段替换，将id替换为标签名，即唯一值替换为表单中显示字段的名字
|
|
:param data: 简道云插件发送过来的data，包含表单id、数据id、应用id
|
|
:param data_get: 简道云请求的数据，一般是根据数据id获取到表单的数据
|
|
:return: 替换后的数据
|
|
"""
|
|
widget_list = self.entry_widget_list(data)
|
|
|
|
if not widget_list or 'widgets' not in widget_list or not isinstance(widget_list['widgets'], list):
|
|
raise ValueError("映射表没有接受到数据")
|
|
|
|
name_to_label = {widget['name']: widget['label'] for widget in widget_list['widgets']}
|
|
|
|
def replace_keys(obj):
|
|
"""递归替换字典中的键名"""
|
|
if isinstance(obj, dict):
|
|
new_dict = {}
|
|
for key, value in obj.items():
|
|
new_key = name_to_label.get(key, key)
|
|
new_dict[new_key] = replace_keys(value)
|
|
return new_dict
|
|
elif isinstance(obj, list):
|
|
return [replace_keys(item) for item in obj]
|
|
else:
|
|
return obj
|
|
|
|
data_get_copy = json.loads(json.dumps(data_get))
|
|
|
|
if 'data' in data_get_copy:
|
|
data_get_copy['data'] = replace_keys(data_get_copy['data'])
|
|
|
|
return data_get_copy
|
|
|
|
@staticmethod
|
|
def data_batch_create(data: dict, max_retries: int = 20) -> Optional[Dict]:
|
|
"""
|
|
新建单条表单数据
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应该包含应用id、表单id，以及新建的数据data['data']
|
|
:return: 返回创建后简道云返回的信息
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/create'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data": data['data'],
|
|
"is_start_workflow": data.get('is_start_workflow', "false"),
|
|
"is_start_trigger": data.get('is_start_trigger', "false"),
|
|
"transaction_id": data.get('transaction_id', "")
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
if res.status_code == 200:
|
|
return data_get
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
return None
|
|
|
|
@staticmethod
|
|
def entry_data_batch_create(
|
|
data: dict,
|
|
chunk_size: int = 90,
|
|
max_retries: int = 20
|
|
) -> List[Optional[Dict]]:
|
|
"""
|
|
新建多条数据
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应包含数据id、表单id、以及需要新建的信息，新建信息应该是一个列表
|
|
:param chunk_size: 简道云限制批量新建一次最多100条，这里默认值设置为90条一次
|
|
:return: 返回请求后的结果
|
|
"""
|
|
data = replace_decimals(data)
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/batch_create'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
total_length = len(data['data_list'])
|
|
logger.info(f"多数据写入行数: {total_length}")
|
|
|
|
num_chunks = (total_length + chunk_size - 1) // chunk_size
|
|
data_get_list = []
|
|
|
|
for i in range(num_chunks):
|
|
start_index = i * chunk_size
|
|
end_index = min(start_index + chunk_size, total_length)
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_list": data['data_list'][start_index:end_index],
|
|
"is_start_workflow": data.get('is_start_workflow', "false"),
|
|
"is_start_trigger": data.get('is_start_trigger', "false"),
|
|
}, cls=NpEncoder)
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
if data_get.get("status") == "success":
|
|
data_get_list.append(data_get)
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常,将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(
|
|
f"任务 {data['data_list'][start_index:end_index]} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
data_get_list.append(None)
|
|
|
|
return data_get_list
|
|
|
|
@staticmethod
|
|
def entry_data_update(data: dict, max_retries: int = 20) -> dict:
|
|
"""
|
|
修改数据
|
|
:param max_retries: 最大重试次数
|
|
:param data: 简道云插件发送过来的data，包含应用id、表单id、数据id等信息
|
|
:return: 修改数据后简道云返回的结果
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/update'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_id": data['data_id'],
|
|
"data": data['data']
|
|
})
|
|
|
|
data_get = None
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
if res.status_code == 200:
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(10)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data_id')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
|
|
return data_get
|
|
|
|
@staticmethod
|
|
def entry_data_banch_update(data: dict, max_retries: int = 20, chunk_size: int = 90) -> List[dict]:
|
|
"""
|
|
批量修改数据
|
|
:param chunk_size: 批量修改块大小
|
|
:param max_retries: 最大重试次数
|
|
:param data: 简道云插件发送过来的data，包含应用id、表单id、数据id等信息
|
|
:return: 修改数据后简道云返回的结果列表
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/batch_update'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
total_length = len(data['data_ids'])
|
|
logger.info(f"多数据修改行数: {total_length}")
|
|
|
|
num_chunks = (total_length + chunk_size - 1) // chunk_size
|
|
data_get_list = []
|
|
|
|
for i in range(num_chunks):
|
|
start_index = i * chunk_size
|
|
end_index = min(start_index + chunk_size, total_length)
|
|
payload = {
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_ids": data['data_ids'][start_index:end_index],
|
|
"data": data['data']
|
|
}
|
|
|
|
if "transaction_id" in data:
|
|
payload["transaction_id"] = data["transaction_id"]
|
|
payload = json.dumps(payload, cls=NpEncoder)
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
if res.status_code == 200:
|
|
data_get_list.append(data_get)
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(10)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data_ids')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
continue
|
|
|
|
return data_get_list
|
|
|
|
@staticmethod
|
|
def entry_data_delete(data: dict, max_retries: int = 20) -> dict:
|
|
"""
|
|
删除单条数据
|
|
:param data: 应包含应用ID、表单ID、数据ID
|
|
:param max_retries: 最大重试次数，默认20
|
|
:return: 删除结果
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/delete'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_id": data['data_id'],
|
|
})
|
|
|
|
retries = 0
|
|
delete_status = None
|
|
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
delete_status = res.json()
|
|
|
|
# 手动处理状态码 4001（数据不存在）
|
|
if delete_status == {
|
|
"code": 4001,
|
|
"msg": "Data does not exist."
|
|
}:
|
|
logger.info(f"返回结果: {delete_status}")
|
|
break
|
|
|
|
res.raise_for_status()
|
|
|
|
if res.status_code == 200:
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(10)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data_id')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
continue
|
|
|
|
return delete_status
|
|
|
|
@staticmethod
|
|
def entry_data_batch_delete(
|
|
data: dict,
|
|
chunk_size: int = 90,
|
|
max_retries: int = 20
|
|
) -> List[Optional[Dict]]:
|
|
"""
|
|
批量删除数据
|
|
:param data: 应包含应用ID、表单ID、数据ID列表
|
|
:param chunk_size: 单次删除最大条数，默认90
|
|
:param max_retries: 重试次数，默认20
|
|
:return: 删除结果列表
|
|
"""
|
|
data = replace_decimals(data)
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/batch_delete'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
total_length = len(data['data_ids'])
|
|
logger.info(f"多数据删除行数: {total_length}")
|
|
|
|
num_chunks = (total_length + chunk_size - 1) // chunk_size
|
|
data_get_list = []
|
|
|
|
for i in range(num_chunks):
|
|
start_index = i * chunk_size
|
|
end_index = min(start_index + chunk_size, total_length)
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_ids": data['data_ids'][start_index:end_index],
|
|
}, cls=NpEncoder)
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
logger.info(f"{i}页 返回结果: {data_get}")
|
|
if data_get.get("status") == "success":
|
|
data_get_list.append(data_get)
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(
|
|
f"批量删除任务第{i+1}批 连续{max_retries}次请求失败，放弃此次请求。")
|
|
data_get_list.append(None)
|
|
|
|
return data_get_list
|
|
|
|
@staticmethod
|
|
def workflow_instance_get(data: dict, max_retries: int = 20) -> dict:
|
|
"""
|
|
查询实例流程信息
|
|
:param max_retries: 最大重试次数
|
|
:param data: 简道云插件发送过来的data，包含应用id
|
|
:return: 查询简道云流程实例信息返回的结果
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/workflow/instance/get'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"instance_id": data['data_id'],
|
|
"tasks_type": 1
|
|
})
|
|
|
|
data_get = None
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
if res.status_code == 200:
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(0.1)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('data_id')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
|
|
return data_get
|
|
|
|
@staticmethod
|
|
def workflow_task_approve(data: dict, max_retries: int = 20) -> dict:
|
|
"""
|
|
流程待办提交
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应包含username、instance_id(data_id)、task_id等信息
|
|
:return: 返回简道云流程待办提交的结果
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v1/workflow/task/approve'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"username": data["username"],
|
|
"instance_id": data["instance_id"],
|
|
"task_id": data['task_id'],
|
|
"comment": data.get("comment", "自动转交")
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
if res.status_code == 200:
|
|
return res.json()
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务 {data.get('task_id')} 连续{max_retries}次请求失败，放弃此次请求。")
|
|
return {}
|
|
|
|
@staticmethod
|
|
def workflow_task_hand_over(data: dict, max_retries: int = 10) -> Optional[dict]:
|
|
"""
|
|
流程待办转交
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应包含username、instance_id(data_id)、task_id、transfer_username等信息
|
|
:return: 返回简道云流程待办转交的结果
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v1/workflow/task/transfer'
|
|
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"username": data["username"],
|
|
"instance_id": data["instance_id"],
|
|
"task_id": data['task_id'],
|
|
"transfer_username": data['transfer_username'],
|
|
"comment": data.get("comment", "转交")
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
if res.status_code == 200:
|
|
return res.json()
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"任务转交失败，已重试{max_retries}次")
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_upload_token(data: dict, max_retries: int = 10) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
获取文件上传凭证
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应包含应用ID、表单ID、事务ID
|
|
:return: 返回upload_url、upload_token
|
|
"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/file/get_upload_token'
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"transaction_id": data['transaction_id'],
|
|
})
|
|
|
|
retries = 0
|
|
while retries <= max_retries:
|
|
try:
|
|
res = requests.post(url=url, data=payload, headers=headers, timeout=10)
|
|
res.raise_for_status()
|
|
res_j = res.json()
|
|
|
|
# 检查 token_and_url_list 是否存在且不为空
|
|
token_list = res_j.get('token_and_url_list', [])
|
|
if not token_list or len(token_list) == 0:
|
|
logger.warning(f"未获取到上传凭证列表，将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
continue
|
|
|
|
token_item = token_list[0]
|
|
upload_url = token_item.get('url')
|
|
upload_token = token_item.get('token')
|
|
|
|
if not upload_url or not upload_token:
|
|
logger.warning(f"上传凭证信息不完整，将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
continue
|
|
|
|
logger.info(f"返回结果: {upload_url}, {upload_token}")
|
|
if res.status_code == 200:
|
|
return {
|
|
'upload_url': upload_url,
|
|
'upload_token': upload_token
|
|
}
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except (requests.exceptions.RequestException, KeyError, IndexError, TypeError) as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"获取上传凭证失败，已重试{max_retries}次")
|
|
return None
|
|
|
|
@staticmethod
|
|
def upload_file(data: dict, max_retries: int = 10) -> Optional[Any]:
|
|
"""
|
|
上传文件
|
|
:param max_retries: 最大重试次数
|
|
:param data: 应包含上传文件路径、上传文件url、上传文件token
|
|
:return: 返回上传文件结果
|
|
"""
|
|
url = data['upload_url']
|
|
headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
}
|
|
file_path = data['file_path']
|
|
payload = {
|
|
"token": data['upload_token'],
|
|
}
|
|
|
|
retries = 0
|
|
result = None
|
|
|
|
while retries <= max_retries:
|
|
try:
|
|
with open(file_path, 'rb') as f:
|
|
files = {"file": f}
|
|
res = requests.post(url=url, data=payload, headers=headers, files=files, timeout=10)
|
|
res.raise_for_status()
|
|
data_get = res.json()
|
|
logger.info(f"返回结果: {data_get}")
|
|
if res.status_code == 200:
|
|
result = data_get
|
|
break
|
|
else:
|
|
logger.warning(f"请求异常, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"请求异常: {e}, 将重新请求")
|
|
retries += 1
|
|
time.sleep(3)
|
|
|
|
if retries > max_retries:
|
|
error_logger.error(f"上传文件失败，已重试{max_retries}次")
|
|
|
|
return result
|