906 lines
34 KiB
Python
906 lines
34 KiB
Python
"""
|
||
组件配置模块
|
||
包含组件类型、详细配置、注册和常用参数等相关配置信息
|
||
"""
|
||
from typing import Dict, List, Any, Optional
|
||
from enum import Enum
|
||
from core.component import ComponentFactory
|
||
import importlib
|
||
from config.settings import COMPONENT_PACKAGES
|
||
from utils.logger import get_logger
|
||
|
||
# 获取日志记录器
|
||
logger = get_logger(__name__)
|
||
|
||
#################################################
|
||
# 组件初始化配置
|
||
#################################################
|
||
|
||
# 组件类别配置
|
||
COMPONENT_CATEGORIES = [
|
||
{"name": "基础组件", "code": "basic", "description": "基础功能组件", "sort_order": 1},
|
||
{"name": "流程组件", "code": "flow", "description": "流程控制组件", "sort_order": 2},
|
||
{"name": "机器人组件", "code": "robot", "description": "机器人控制组件", "sort_order": 3},
|
||
{"name": "库位组件", "code": "storage", "description": "库位管理组件", "sort_order": 4},
|
||
{"name": "设备组件", "code": "device", "description": "设备控制组件", "sort_order": 5},
|
||
{"name": "HTTP组件", "code": "http", "description": "HTTP请求组件", "sort_order": 6},
|
||
{"name": "脚本组件", "code": "script", "description": "脚本执行组件", "sort_order": 7},
|
||
{"name": "子任务组件", "code": "subtask", "description": "子任务组件", "sort_order": 8},
|
||
{"name": "任务组件", "code": "task", "description": "任务管理组件", "sort_order": 9}
|
||
]
|
||
|
||
# 组件类型配置
|
||
def get_component_types(categories):
|
||
"""
|
||
获取组件类型配置
|
||
|
||
Args:
|
||
categories: 类别ID映射字典 {类别代码: 类别ID}
|
||
|
||
Returns:
|
||
list: 组件类型配置列表
|
||
"""
|
||
return [
|
||
# 基础组件
|
||
{"name": "变量赋值", "code": "variable_assign", "category_id": categories["basic"], "description": "为变量赋值", "icon": "variable", "sort_order": 1},
|
||
{"name": "条件判断", "code": "condition", "category_id": categories["basic"], "description": "条件判断", "icon": "condition", "sort_order": 2},
|
||
{"name": "延时等待", "code": "delay", "category_id": categories["basic"], "description": "延时等待", "icon": "delay", "sort_order": 3},
|
||
|
||
# 流程组件
|
||
{"name": "If条件", "code": "if", "category_id": categories["flow"], "description": "If条件判断", "icon": "if", "sort_order": 1},
|
||
{"name": "If-Else条件", "code": "if_else", "category_id": categories["flow"], "description": "If-Else条件判断", "icon": "if_else", "sort_order": 2},
|
||
{"name": "循环", "code": "loop", "category_id": categories["flow"], "description": "循环执行", "icon": "loop", "sort_order": 3},
|
||
{"name": "并行执行", "code": "parallel", "category_id": categories["flow"], "description": "并行执行多个分支", "icon": "parallel", "sort_order": 4},
|
||
|
||
# 机器人组件
|
||
{"name": "选择机器人", "code": "select_robot", "category_id": categories["robot"], "description": "选择执行机器人", "icon": "robot", "sort_order": 1},
|
||
{"name": "机器人移动", "code": "robot_move", "category_id": categories["robot"], "description": "控制机器人移动", "icon": "move", "sort_order": 2},
|
||
{"name": "获取机器人状态", "code": "robot_status", "category_id": categories["robot"], "description": "获取机器人状态", "icon": "status", "sort_order": 3},
|
||
|
||
# HTTP组件
|
||
{"name": "HTTP请求", "code": "http_request", "category_id": categories["http"], "description": "发送HTTP请求", "icon": "http", "sort_order": 1},
|
||
{"name": "API调用", "code": "api_call", "category_id": categories["http"], "description": "调用系统API", "icon": "api", "sort_order": 2},
|
||
|
||
# 脚本组件
|
||
{"name": "JavaScript脚本", "code": "javascript", "category_id": categories["script"], "description": "执行JavaScript脚本", "icon": "script", "sort_order": 1},
|
||
|
||
# 子任务组件
|
||
{"name": "执行子任务", "code": "execute_subtask", "category_id": categories["subtask"], "description": "执行子任务", "icon": "subtask", "sort_order": 1}
|
||
]
|
||
|
||
# 系统组件配置
|
||
def get_system_components(types):
|
||
"""
|
||
获取系统组件配置
|
||
|
||
Args:
|
||
types: 组件类型ID映射字典 {类型代码: 类型ID}
|
||
|
||
Returns:
|
||
list: 系统组件配置列表
|
||
"""
|
||
return [
|
||
{
|
||
"name": "变量赋值",
|
||
"code": "variable_assign",
|
||
"type_id": types["variable_assign"],
|
||
"description": "为变量赋值",
|
||
"is_system": True,
|
||
"config_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"variable_name": {"type": "string", "title": "变量名"},
|
||
"value_type": {"type": "string", "enum": ["string", "number", "boolean", "object"], "title": "值类型"},
|
||
"value": {"type": "string", "title": "值"}
|
||
},
|
||
"required": ["variable_name", "value_type", "value"]
|
||
},
|
||
"input_schema": {},
|
||
"output_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"result": {"type": "boolean", "title": "执行结果"}
|
||
}
|
||
}
|
||
},
|
||
{
|
||
"name": "条件判断",
|
||
"code": "condition",
|
||
"type_id": types["condition"],
|
||
"description": "条件判断",
|
||
"is_system": True,
|
||
"config_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"condition": {"type": "string", "title": "条件表达式"}
|
||
},
|
||
"required": ["condition"]
|
||
},
|
||
"input_schema": {},
|
||
"output_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"result": {"type": "boolean", "title": "判断结果"}
|
||
}
|
||
}
|
||
},
|
||
{
|
||
"name": "If条件",
|
||
"code": "if",
|
||
"type_id": types["if"],
|
||
"description": "If条件判断",
|
||
"is_system": True,
|
||
"config_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"condition": {"type": "string", "title": "条件表达式"}
|
||
},
|
||
"required": ["condition"]
|
||
},
|
||
"input_schema": {},
|
||
"output_schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"result": {"type": "boolean", "title": "判断结果"}
|
||
}
|
||
}
|
||
}
|
||
]
|
||
|
||
# 缓存配置
|
||
CACHE_EXPIRE_TIME = 86400 # 缓存过期时间，单位：秒（24小时）
|
||
CACHE_KEYS = {
|
||
"COMPONENT_CATEGORIES": "component_categories",
|
||
"COMPONENT_TYPES": "component_types",
|
||
"SYSTEM_COMPONENTS": "system_components"
|
||
}
|
||
|
||
#################################################
|
||
# 组件自动发现与注册
|
||
#################################################
|
||
|
||
class ComponentDiscovery:
|
||
"""组件自动发现配置"""
|
||
DEFAULT_PACKAGE = "components" # 默认组件包名
|
||
AUTO_REGISTER = True # 是否在启动时自动注册所有组件
|
||
|
||
def register_all_components():
|
||
"""注册所有组件"""
|
||
|
||
for package_name in COMPONENT_PACKAGES:
|
||
try:
|
||
ComponentFactory.auto_discover(package_name)
|
||
logger.info(f"自动注册组件包: {package_name}")
|
||
except ImportError:
|
||
logger.error(f"导入组件包失败: {package_name}")
|
||
except Exception as e:
|
||
logger.error(f"注册组件包失败: {package_name}, 错误: {str(e)}")
|
||
|
||
#################################################
|
||
# 组件分类配置
|
||
#################################################
|
||
|
||
class ComponentCategory:
|
||
"""组件类别配置"""
|
||
# 组件类别定义
|
||
HTTP_REQUEST = "HTTP请求"
|
||
SCRIPT = "脚本"
|
||
FLOW = "流程"
|
||
ROBOT = "机器人调度"
|
||
SITE = "库位"
|
||
DEVICE = "设备"
|
||
SUBTASK = "子任务"
|
||
TASK = "任务"
|
||
BASE = "基础"
|
||
|
||
# 组件类别映射配置
|
||
# 用于将组件类型映射到对应的类别，便于前端展示
|
||
@classmethod
|
||
def get_mapping(cls) -> Dict[str, str]:
|
||
"""获取组件类型到类别的映射"""
|
||
return {
|
||
# HTTP请求组件
|
||
"http": cls.HTTP_REQUEST,
|
||
|
||
# 脚本组件
|
||
"script": cls.SCRIPT,
|
||
|
||
# 流程控制组件
|
||
"if": cls.FLOW,
|
||
"if_else": cls.FLOW,
|
||
"if_else_if": cls.FLOW,
|
||
"for_each": cls.FLOW,
|
||
"while": cls.FLOW,
|
||
"break": cls.FLOW,
|
||
"return": cls.FLOW,
|
||
"delay": cls.FLOW,
|
||
|
||
# 机器人调度组件
|
||
"robot": cls.ROBOT,
|
||
|
||
# 库位组件
|
||
"site": cls.SITE,
|
||
|
||
# 设备组件
|
||
"modbus": cls.DEVICE,
|
||
|
||
# 子任务组件
|
||
"subtask": cls.SUBTASK,
|
||
}
|
||
|
||
# 组件分类优先级
|
||
# 控制前端组件面板中各分类的显示顺序
|
||
@classmethod
|
||
def get_priority(cls) -> List[str]:
|
||
"""获取组件类别优先级列表"""
|
||
return [
|
||
cls.SUBTASK,
|
||
cls.SCRIPT,
|
||
cls.HTTP_REQUEST,
|
||
cls.TASK,
|
||
cls.FLOW,
|
||
cls.BASE,
|
||
cls.SITE,
|
||
cls.ROBOT,
|
||
cls.DEVICE
|
||
]
|
||
|
||
class ComponentCategoryConfig:
|
||
"""组件分类配置"""
|
||
|
||
@classmethod
|
||
def get_category_name(cls, category_enum):
|
||
"""获取分类名称"""
|
||
from data.models.component import ComponentCategoryEnum
|
||
|
||
names = {
|
||
ComponentCategoryEnum.SUBTASK: "子任务",
|
||
ComponentCategoryEnum.SCRIPT: "脚本",
|
||
ComponentCategoryEnum.HTTP: "HTTP请求",
|
||
ComponentCategoryEnum.TASK: "任务",
|
||
ComponentCategoryEnum.FLOW: "流程",
|
||
ComponentCategoryEnum.BASIC: "基础",
|
||
ComponentCategoryEnum.STORAGE: "库位",
|
||
ComponentCategoryEnum.ROBOT: "机器人调度",
|
||
ComponentCategoryEnum.DEVICE: "设备"
|
||
}
|
||
return names.get(category_enum, category_enum.value)
|
||
|
||
@classmethod
|
||
def get_category_description(cls, category_enum):
|
||
"""获取分类描述"""
|
||
from data.models.component import ComponentCategoryEnum
|
||
|
||
descriptions = {
|
||
ComponentCategoryEnum.SUBTASK: "可重用的子任务组件",
|
||
ComponentCategoryEnum.SCRIPT: "执行脚本代码的组件",
|
||
ComponentCategoryEnum.HTTP: "发送HTTP请求的组件",
|
||
ComponentCategoryEnum.TASK: "任务管理相关组件",
|
||
ComponentCategoryEnum.FLOW: "流程控制相关组件",
|
||
ComponentCategoryEnum.BASIC: "基础功能组件",
|
||
ComponentCategoryEnum.STORAGE: "库位管理相关组件",
|
||
ComponentCategoryEnum.ROBOT: "机器人调度相关组件",
|
||
ComponentCategoryEnum.DEVICE: "设备控制相关组件"
|
||
}
|
||
return descriptions.get(category_enum, f"{category_enum.value}类组件")
|
||
|
||
@classmethod
|
||
def get_category_order(cls, category_enum):
|
||
"""获取分类排序"""
|
||
from data.models.component import ComponentCategoryEnum
|
||
|
||
orders = {
|
||
ComponentCategoryEnum.BASIC: 1,
|
||
ComponentCategoryEnum.FLOW: 2,
|
||
ComponentCategoryEnum.TASK: 3,
|
||
ComponentCategoryEnum.SUBTASK: 4,
|
||
ComponentCategoryEnum.SCRIPT: 5,
|
||
ComponentCategoryEnum.HTTP: 6,
|
||
ComponentCategoryEnum.ROBOT: 7,
|
||
ComponentCategoryEnum.STORAGE: 8,
|
||
ComponentCategoryEnum.DEVICE: 9
|
||
}
|
||
return orders.get(category_enum, 99)
|
||
|
||
#################################################
|
||
# 组件详细配置
|
||
#################################################
|
||
|
||
class ScriptComponentConfig:
|
||
"""脚本组件配置"""
|
||
|
||
# 脚本组件类型
|
||
RUN_SCRIPT = "run_script" # 运行脚本
|
||
SET_VARIABLES = "set_variables" # 设置task.variables
|
||
|
||
# 脚本组件详细配置
|
||
@classmethod
|
||
def get_components(cls) -> List[Dict[str, Any]]:
|
||
"""获取脚本组件列表"""
|
||
return [
|
||
{
|
||
"type": "script",
|
||
"sub_type": cls.RUN_SCRIPT,
|
||
"name": "运行脚本",
|
||
"description": "执行JavaScript代码并返回结果",
|
||
"icon": "code", # 图标名称，前端可用
|
||
"params": [
|
||
{
|
||
"name": "function_name",
|
||
"label": "函数名",
|
||
"type": "string",
|
||
"required": False,
|
||
"description": "定义脚本中的主函数名称",
|
||
"value_types": [
|
||
{
|
||
"type": "simple",
|
||
"label": "简单值",
|
||
"default": True
|
||
},
|
||
{
|
||
"type": "expression",
|
||
"label": "表达式",
|
||
"default": False
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"name": "params",
|
||
"label": "函数参数",
|
||
"type": "array",
|
||
"required": False,
|
||
"description": "传递给脚本的参数",
|
||
"value_types": [
|
||
{
|
||
"type": "simple",
|
||
"label": "简单值",
|
||
"default": True
|
||
},
|
||
{
|
||
"type": "expression",
|
||
"label": "表达式",
|
||
"default": False
|
||
}
|
||
]
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"type": "script",
|
||
"sub_type": cls.SET_VARIABLES,
|
||
"name": "设置task.variables",
|
||
"description": "设置和管理任务变量",
|
||
"icon": "variable",
|
||
"params": [
|
||
{
|
||
"name": "function_name",
|
||
"label": "函数名",
|
||
"type": "string",
|
||
"required": False,
|
||
"description": "定义脚本中的主函数名称",
|
||
"value_types": [
|
||
{
|
||
"type": "simple",
|
||
"label": "简单值",
|
||
"default": True
|
||
},
|
||
{
|
||
"type": "expression",
|
||
"label": "表达式",
|
||
"default": False
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"name": "params",
|
||
"label": "函数参数",
|
||
"type": "array",
|
||
"required": False,
|
||
"description": "传递给脚本的参数",
|
||
"value_types": [
|
||
{
|
||
"type": "simple",
|
||
"label": "简单值",
|
||
"default": True
|
||
},
|
||
{
|
||
"type": "expression",
|
||
"label": "表达式",
|
||
"default": False
|
||
}
|
||
]
|
||
}
|
||
]
|
||
}
|
||
]
|
||
|
||
class HttpComponentConfig:
|
||
"""HTTP请求组件配置"""
|
||
|
||
# HTTP请求组件类型
|
||
HTTP_REQUEST = "http_request" # HTTP请求
|
||
|
||
# HTTP请求组件详细配置
|
||
@classmethod
|
||
def get_components(cls) -> List[Dict[str, Any]]:
|
||
"""获取HTTP请求组件列表"""
|
||
return [
|
||
{
|
||
"type": "http",
|
||
"sub_type": cls.HTTP_REQUEST,
|
||
"name": "HTTP请求",
|
||
"description": "发送HTTP请求并处理响应",
|
||
"icon": "http",
|
||
"params": [
|
||
{
|
||
"name": "method",
|
||
"label": "请求方法",
|
||
"type": "select",
|
||
"options": ["GET", "POST", "PUT", "DELETE", "PATCH"],
|
||
"required": True,
|
||
"description": "HTTP请求方法"
|
||
},
|
||
{
|
||
"name": "url",
|
||
"label": "请求URL",
|
||
"type": "string",
|
||
"required": True,
|
||
"description": "请求的目标URL"
|
||
},
|
||
{
|
||
"name": "headers",
|
||
"label": "请求头",
|
||
"type": "object",
|
||
"required": False,
|
||
"description": "HTTP请求头"
|
||
},
|
||
{
|
||
"name": "body",
|
||
"label": "请求体",
|
||
"type": "object",
|
||
"required": False,
|
||
"description": "HTTP请求体"
|
||
},
|
||
{
|
||
"name": "timeout",
|
||
"label": "超时时间",
|
||
"type": "number",
|
||
"required": False,
|
||
"description": "请求超时时间（毫秒）"
|
||
}
|
||
]
|
||
}
|
||
]
|
||
|
||
class FlowComponentConfig:
|
||
"""流程控制组件配置"""
|
||
|
||
# 流程控制组件类型
|
||
IF = "if" # 条件判断
|
||
IF_ELSE = "if_else" # 条件分支
|
||
FOR_EACH = "for_each" # 循环遍历
|
||
WHILE = "while" # 条件循环
|
||
|
||
# 流程控制组件详细配置
|
||
@classmethod
|
||
def get_components(cls) -> List[Dict[str, Any]]:
|
||
"""获取流程控制组件列表"""
|
||
return [
|
||
{
|
||
"type": "flow",
|
||
"sub_type": cls.IF,
|
||
"name": "条件判断",
|
||
"description": "根据条件执行不同的操作",
|
||
"icon": "branch",
|
||
"params": [
|
||
{
|
||
"name": "condition",
|
||
"label": "条件表达式",
|
||
"type": "expression",
|
||
"required": True,
|
||
"description": "条件判断表达式"
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"type": "flow",
|
||
"sub_type": cls.IF_ELSE,
|
||
"name": "条件分支",
|
||
"description": "根据条件执行不同的分支",
|
||
"icon": "branch-multiple",
|
||
"params": [
|
||
{
|
||
"name": "condition",
|
||
"label": "条件表达式",
|
||
"type": "expression",
|
||
"required": True,
|
||
"description": "条件判断表达式"
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"type": "flow",
|
||
"sub_type": cls.FOR_EACH,
|
||
"name": "循环遍历",
|
||
"description": "遍历数组或对象的每个元素",
|
||
"icon": "loop",
|
||
"params": [
|
||
{
|
||
"name": "collection",
|
||
"label": "集合表达式",
|
||
"type": "expression",
|
||
"required": True,
|
||
"description": "要遍历的数组或对象"
|
||
},
|
||
{
|
||
"name": "item_name",
|
||
"label": "元素变量名",
|
||
"type": "string",
|
||
"required": True,
|
||
"description": "当前元素的变量名"
|
||
},
|
||
{
|
||
"name": "index_name",
|
||
"label": "索引变量名",
|
||
"type": "string",
|
||
"required": False,
|
||
"description": "当前索引的变量名"
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"type": "flow",
|
||
"sub_type": cls.WHILE,
|
||
"name": "条件循环",
|
||
"description": "当条件为真时重复执行",
|
||
"icon": "loop-circular",
|
||
"params": [
|
||
{
|
||
"name": "condition",
|
||
"label": "条件表达式",
|
||
"type": "expression",
|
||
"required": True,
|
||
"description": "循环条件表达式"
|
||
}
|
||
]
|
||
}
|
||
]
|
||
|
||
class SubtaskComponentConfig:
|
||
"""子任务组件配置"""
|
||
|
||
# 子任务组件类型
|
||
SUBTASK = "subtask" # 子任务
|
||
|
||
# 子任务组件详细配置
|
||
@classmethod
|
||
def get_components(cls) -> List[Dict[str, Any]]:
|
||
"""获取子任务组件列表"""
|
||
return [
|
||
{
|
||
"type": "subtask",
|
||
"sub_type": cls.SUBTASK,
|
||
"name": "子任务",
|
||
"description": "执行已定义的任务作为子任务",
|
||
"icon": "subtask",
|
||
"params": [
|
||
{
|
||
"name": "task_id",
|
||
"label": "选择子任务",
|
||
"type": "select",
|
||
"required": True,
|
||
"description": "选择要执行的子任务（从已创建的任务中选择）",
|
||
"data_source": "available_subtasks", # 指示前端从API返回的available_subtasks字段获取数据
|
||
"display_field": "name", # 显示任务名称
|
||
"value_field": "task_id" # 使用任务ID作为值
|
||
},
|
||
{
|
||
"name": "params",
|
||
"label": "任务参数",
|
||
"type": "object",
|
||
"required": False,
|
||
"description": "传递给子任务的参数"
|
||
},
|
||
{
|
||
"name": "wait_complete",
|
||
"label": "等待完成",
|
||
"type": "boolean",
|
||
"required": False,
|
||
"default": True,
|
||
"description": "是否等待子任务完成后再继续执行"
|
||
}
|
||
]
|
||
}
|
||
]
|
||
|
||
class ComponentDetailConfig:
|
||
"""组件详细配置管理"""
|
||
|
||
# 组件类型中文名称映射
|
||
@classmethod
|
||
def get_component_type_names(cls) -> Dict[str, str]:
|
||
"""获取组件类型的中文名称映射"""
|
||
return {
|
||
# 基础类型
|
||
"script": "脚本",
|
||
"http": "HTTP请求",
|
||
"flow": "流程",
|
||
"robot": "机器人调度",
|
||
"site": "库位",
|
||
"device": "设备",
|
||
"subtask": "子任务",
|
||
"task": "任务",
|
||
"basic": "基础",
|
||
|
||
# 脚本组件
|
||
"run_script": "运行脚本",
|
||
"set_task_variables": "设置任务变量",
|
||
"runscript": "运行脚本",
|
||
"settaskvariables": "设置任务变量",
|
||
|
||
# HTTP请求组件
|
||
"http_get_request": "GET请求",
|
||
"http_post_request": "POST请求",
|
||
"httpgetrequest": "GET请求",
|
||
"httppostrequest": "POST请求",
|
||
|
||
# 流程控制组件
|
||
"if": "条件判断",
|
||
"if_else": "条件分支",
|
||
"if_else_if": "多条件分支",
|
||
"for_each": "循环遍历",
|
||
"while": "条件循环",
|
||
"break": "跳出循环",
|
||
"return": "返回",
|
||
"delay": "延时",
|
||
"parallel_execute": "并行执行",
|
||
"serial_execute": "串行执行",
|
||
"throw_exception": "抛出异常",
|
||
"foreach": "循环遍历",
|
||
"ifelse": "条件分支",
|
||
"ifelseif": "多条件分支",
|
||
"parallelexecute": "并行执行",
|
||
"serialexecute": "串行执行",
|
||
"throwexception": "抛出异常",
|
||
|
||
# 机器人调度组件
|
||
"select_robot": "选择机器人",
|
||
"get_robot_position": "获取机器人位置",
|
||
"robot_action": "机器人动作",
|
||
"change_robot_destination": "更改机器人目的地",
|
||
"get_robot_battery": "获取机器人电量",
|
||
"get_robot_pgv_code": "获取机器人PGV码",
|
||
"changerobotdestination": "更改机器人目的地",
|
||
"getrobotbattery": "获取机器人电量",
|
||
"getrobotpgvcode": "获取机器人PGV码",
|
||
"getrobotposition": "获取机器人位置",
|
||
"robotaction": "机器人动作",
|
||
"selectrobot": "选择机器人",
|
||
|
||
# 库位组件
|
||
"batch_set_site": "批量设置库位",
|
||
"get_dense_site": "获取密集库位",
|
||
"query_site": "查询库位",
|
||
"lock_site": "锁定库位",
|
||
"unlock_site": "解锁库位",
|
||
"get_locked_sites_by_task": "获取任务锁定的库位",
|
||
"get_site_extension_property": "获取库位扩展属性",
|
||
"set_site_extension_property": "设置库位扩展属性",
|
||
"set_site_goods": "设置库位货物",
|
||
"set_site_empty": "设置库位为空",
|
||
"set_site_occupied": "设置库位为占用",
|
||
"set_site_tag": "设置库位标签",
|
||
"batchsetsite": "批量设置库位",
|
||
"getdensesite": "获取密集库位",
|
||
"getlockedsitesbytask": "获取任务锁定的库位",
|
||
"getsiteextensionproperty": "获取库位扩展属性",
|
||
"locksite": "锁定库位",
|
||
"querysite": "查询库位",
|
||
"setsiteempty": "设置库位为空",
|
||
"setsiteextensionproperty": "设置库位扩展属性",
|
||
"setsitegoods": "设置库位货物",
|
||
"setsiteoccupied": "设置库位为占用",
|
||
"setsitetag": "设置库位标签",
|
||
"unlocksite": "解锁库位",
|
||
|
||
# 任务组件
|
||
"cache_data": "缓存数据",
|
||
"clear_cache_data": "清除缓存数据",
|
||
"get_cache_data": "获取缓存数据",
|
||
"set_task_status": "设置任务状态",
|
||
"jump_to_block": "跳转到块",
|
||
"get_task_input_param": "获取任务输入参数",
|
||
"cachedata": "缓存数据",
|
||
"clearcachedata": "清除缓存数据",
|
||
"getcachedata": "获取缓存数据",
|
||
"gettaskinputparam": "获取任务输入参数",
|
||
"jumptoblock": "跳转到块",
|
||
"settaskstatus": "设置任务状态",
|
||
|
||
# 基础组件
|
||
"check_task_instance_id_exists": "检查任务实例ID是否存在",
|
||
"create_unique_id": "创建唯一ID",
|
||
"current_timestamp": "当前时间戳",
|
||
"current_time": "当前时间",
|
||
"execute_sql": "执行SQL",
|
||
"query_sql": "查询SQL",
|
||
"string_md5_encrypt": "字符串MD5加密",
|
||
"string_to_json_array": "字符串转JSON数组",
|
||
"string_to_json_object": "字符串转JSON对象",
|
||
"print": "打印",
|
||
"checktaskinstanceidexists": "检查任务实例ID是否存在",
|
||
"createuniqueid": "创建唯一ID",
|
||
"currenttime": "当前时间",
|
||
"currenttimestamp": "当前时间戳",
|
||
"executesql": "执行SQL",
|
||
"querysql": "查询SQL",
|
||
"stringmd5encrypt": "字符串MD5加密",
|
||
"stringtojsonarray": "字符串转JSON数组",
|
||
"stringtojsonobject": "字符串转JSON对象",
|
||
|
||
# 设备组件
|
||
"wait_modbus_value": "等待Modbus值",
|
||
"write_modbus_value": "写入Modbus值",
|
||
"waitmodbusvalue": "等待Modbus值",
|
||
"writemodbusvalue": "写入Modbus值"
|
||
}
|
||
|
||
@classmethod
|
||
def get_all_components(cls) -> List[Dict[str, Any]]:
|
||
"""获取所有组件详细配置"""
|
||
all_components = []
|
||
|
||
# 添加子任务组件（放在第一位）
|
||
all_components.extend(SubtaskComponentConfig.get_components())
|
||
|
||
# 添加脚本组件
|
||
all_components.extend(ScriptComponentConfig.get_components())
|
||
|
||
# 添加HTTP请求组件
|
||
all_components.extend(HttpComponentConfig.get_components())
|
||
|
||
# 添加流程控制组件
|
||
all_components.extend(FlowComponentConfig.get_components())
|
||
|
||
# 可以继续添加其他类型的组件...
|
||
|
||
return all_components
|
||
|
||
@classmethod
|
||
def get_components_by_type(cls, component_type: str) -> List[Dict[str, Any]]:
|
||
"""根据组件类型获取组件列表"""
|
||
all_components = cls.get_all_components()
|
||
return [comp for comp in all_components if comp["type"] == component_type]
|
||
|
||
#################################################
|
||
# 常用参数配置
|
||
#################################################
|
||
|
||
class CommonParamType(str, Enum):
|
||
"""常用参数类型枚举"""
|
||
ROBOT_ID = "robot_id" # 机器人ID
|
||
ROBOT_GROUP = "robot_group" # 机器人组
|
||
ROBOT_TAG = "robot_tag" # 机器人标签
|
||
STORAGE_AREA_ID = "storage_area_id" # 库区ID
|
||
STORAGE_AREA = "storage_area" # 库区
|
||
SITE = "site" # 站点
|
||
BIN_TASK = "bin_task" # binTask
|
||
WORKSTATION = "workstation" # 工位
|
||
POST = "post" # 岗位
|
||
USER = "user" # 用户
|
||
CACHE = "cache" # 缓存
|
||
BUILT_IN_FUNCTION = "built_in_function" # 内置函数
|
||
|
||
class CommonParamsConfig:
|
||
"""常用参数配置类"""
|
||
|
||
@classmethod
|
||
def get_param_types(cls) -> List[Dict[str, Any]]:
|
||
"""获取所有常用参数类型"""
|
||
return [
|
||
{
|
||
"type": CommonParamType.ROBOT_ID,
|
||
"name": "机器人ID",
|
||
"description": "选择机器人ID",
|
||
"api_path": "/api/robots/ids", # 获取数据的API路径
|
||
"value_field": "id", # 值字段
|
||
"display_field": "name" # 显示字段
|
||
},
|
||
{
|
||
"type": CommonParamType.ROBOT_GROUP,
|
||
"name": "机器人组",
|
||
"description": "选择机器人组",
|
||
"api_path": "/api/robots/groups",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.ROBOT_TAG,
|
||
"name": "机器人标签",
|
||
"description": "选择机器人标签",
|
||
"api_path": "/api/robots/tags",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.STORAGE_AREA_ID,
|
||
"name": "库区ID",
|
||
"description": "选择库区ID",
|
||
"api_path": "/api/storage/areas/ids",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.STORAGE_AREA,
|
||
"name": "库区",
|
||
"description": "选择库区",
|
||
"api_path": "/api/storage/areas",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.SITE,
|
||
"name": "站点",
|
||
"description": "选择站点",
|
||
"api_path": "/api/sites",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.BIN_TASK,
|
||
"name": "binTask",
|
||
"description": "选择binTask",
|
||
"api_path": "/api/bin-tasks",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.WORKSTATION,
|
||
"name": "工位",
|
||
"description": "选择工位",
|
||
"api_path": "/api/workstations",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.POST,
|
||
"name": "岗位",
|
||
"description": "选择岗位",
|
||
"api_path": "/api/posts",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.USER,
|
||
"name": "用户",
|
||
"description": "选择用户",
|
||
"api_path": "/api/users",
|
||
"value_field": "id",
|
||
"display_field": "name"
|
||
},
|
||
{
|
||
"type": CommonParamType.CACHE,
|
||
"name": "缓存",
|
||
"description": "选择缓存",
|
||
"api_path": "/api/caches",
|
||
"value_field": "key",
|
||
"display_field": "key"
|
||
},
|
||
{
|
||
"type": CommonParamType.BUILT_IN_FUNCTION,
|
||
"name": "内置函数",
|
||
"description": "选择内置函数",
|
||
"api_path": "/api/built-in-functions",
|
||
"value_field": "name",
|
||
"display_field": "name"
|
||
}
|
||
]
|
||
|
||
@classmethod
|
||
def get_param_type_by_type(cls, param_type: str) -> Optional[Dict[str, Any]]:
|
||
"""根据类型获取参数类型配置"""
|
||
param_types = cls.get_param_types()
|
||
for pt in param_types:
|
||
if pt["type"] == param_type:
|
||
return pt
|
||
return None |