mod: first

.gitignore

@@ -0,0 +1,2 @@
+/logs/*
+/rasa_files/*

api/__init__.py

@@ -0,0 +1,4 @@
+from api.main import app
+from api.schemas import GenerateFilesRequest
+
+__all__ = ['app', 'GenerateFilesRequest']

api/main.py

@@ -0,0 +1,149 @@
+import logging
+from fastapi import FastAPI, Depends, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+from typing import Optional, List, Dict, Any
+
+# 导入服务和模型
+from db import get_db, db, SystemConfig
+from services import RasaFileGenerator, RasaManager
+from api.schemas import GenerateFilesRequest
+from config import config
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+# 初始化FastAPI
+app = FastAPI(
+    title="Rasa流程管理系统API",
+    description="支持版本管理、文件生成和服务重启的Rasa系统API",
+    version="1.0.0"
+)
+
+# 配置CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 生产环境中应指定具体的源
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 初始化服务
+try:
+    # 创建数据库表（如果不存在）
+    db.create_tables()
+    
+    # 初始化文件生成器和Rasa管理器
+    file_generator = RasaFileGenerator()
+    rasa_manager = RasaManager()
+    
+    logger.info("服务初始化成功")
+except Exception as e:
+    logger.error(f"服务初始化失败: {str(e)}", exc_info=True)
+    raise
+
+# API接口
+@app.post("/generate-files", response_model=Dict[str, Any], tags=["文件生成"])
+def generate_rasa_files(request: GenerateFilesRequest, db: Session = Depends(get_db)):
+    """生成Rasa配置文件"""
+    try:
+        logger.info(f"生成Rasa文件请求: {request.dict()}")
+        result = file_generator.generate_all_files(
+            session=db,
+        )
+        if result["success"]:
+            return result
+        else:
+            raise HTTPException(status_code=500, detail=result["message"])
+    except Exception as e:
+        logger.error(f"生成Rasa文件失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"生成Rasa文件失败: {str(e)}")
+
+@app.post("/rasa/restart", response_model=Dict[str, Any], tags=["服务管理"])
+def restart_rasa_services(
+    model_path: Optional[str] = None,
+    actions_dir: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """重启Rasa服务"""
+    try:
+        logger.info(f"重启Rasa服务请求: model_path={model_path}, actions_dir={actions_dir}")
+        # 如果未指定路径，使用生成的默认路径
+        if not actions_dir:
+            actions_dir = f"{file_generator.output_dir}/actions"
+        
+        result = rasa_manager.restart_rasa_services(
+            session=db,
+            model_path=model_path,
+            actions_dir=actions_dir
+        )
+        
+        if result["success"]:
+            return result
+        else:
+            raise HTTPException(status_code=500, detail=result["message"])
+    except Exception as e:
+        logger.error(f"重启Rasa服务失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"重启Rasa服务失败: {str(e)}")
+
+@app.post("/rasa/stop", response_model=Dict[str, Any], tags=["服务管理"])
+def stop_rasa_services():
+    """停止Rasa服务"""
+    try:
+        logger.info("停止Rasa服务请求")
+        success = rasa_manager.stop_all_services()
+        if success:
+            return {
+                "success": True,
+                "message": "所有Rasa服务已停止"
+            }
+        else:
+            raise HTTPException(status_code=500, detail="停止Rasa服务失败")
+    except Exception as e:
+        logger.error(f"停止Rasa服务失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"停止Rasa服务失败: {str(e)}")
+
+@app.get("/rasa/status", response_model=Dict[str, Any], tags=["服务管理"])
+def get_rasa_status(db: Session = Depends(get_db)):
+    """获取Rasa服务状态"""
+    try:
+        logger.info("获取Rasa服务状态请求")
+        rasa_url = SystemConfig.get_value(db, "rasa_server_url", "http://localhost:5005")
+        action_url = SystemConfig.get_value(db, "rasa_actions_url", "http://localhost:5055")
+        
+        rasa_healthy = rasa_manager._check_rasa_health(rasa_url)
+        action_healthy = rasa_manager._check_action_health(action_url)
+        
+        return {
+            "success": True,
+            "rasa_server": {
+                "url": rasa_url,
+                "healthy": rasa_healthy,
+                "pid": rasa_manager.rasa_process.pid if (rasa_manager.rasa_process and not rasa_manager.rasa_process.poll()) else None
+            },
+            "action_server": {
+                "url": action_url,
+                "healthy": action_healthy,
+                "pid": rasa_manager.action_process.pid if (rasa_manager.action_process and not rasa_manager.action_process.poll()) else None
+            }
+        }
+    except Exception as e:
+        logger.error(f"获取Rasa服务状态失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"获取Rasa服务状态失败: {str(e)}")
+
+# 启动服务
+if __name__ == "__main__":
+    import uvicorn
+    host = config.get("api.host", "0.0.0.0")
+    port = config.get("api.port", 8000)
+    debug = config.get("api.debug", False)
+    
+    logger.info(f"启动API服务: http://{host}:{port}")
+    uvicorn.run(
+        "api.main:app", 
+        host=host, 
+        port=port, 
+        debug=debug,
+        reload=debug
+    )

api/schemas.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+
+class GenerateFilesRequest(BaseModel):
+    version_id: Optional[int] = None

config/__init__.py

@@ -0,0 +1,155 @@
+import yaml
+import os
+import logging
+from typing import Dict, Any, Optional
+
+class Config:
+    """配置管理类，用于加载和访问配置文件"""
+    
+    def __init__(self, config_path: str = "config/config.yaml"):
+        """
+        初始化配置管理类
+        
+        Args:
+            config_path: 配置文件路径
+        """
+        self.config_path = config_path
+        self.config_data: Dict[str, Any] = {}
+        self._load_config()
+        self._setup_logging()
+    
+    def _load_config(self) -> None:
+        """加载配置文件"""
+        try:
+            if not os.path.exists(self.config_path):
+                raise FileNotFoundError(f"配置文件 {self.config_path} 不存在")
+            
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                self.config_data = yaml.safe_load(f)
+                
+            if not self.config_data:
+                raise ValueError(f"配置文件 {self.config_path} 内容为空")
+                
+            # 创建必要的目录
+            self._create_directories()
+            
+        except FileNotFoundError as e:
+            raise Exception(f"配置文件加载失败: {str(e)}")
+        except yaml.YAMLError as e:
+            raise Exception(f"配置文件解析错误: {str(e)}")
+        except Exception as e:
+            raise Exception(f"加载配置时发生错误: {str(e)}")
+    
+    def _create_directories(self) -> None:
+        """创建配置中指定的目录"""
+        try:
+            # 创建Rasa文件目录
+            rasa_files_dir = self.get("file_storage.rasa_files_dir")
+            if rasa_files_dir:
+                os.makedirs(rasa_files_dir, exist_ok=True)
+                os.makedirs(os.path.join(rasa_files_dir, "nlu"), exist_ok=True)
+                os.makedirs(os.path.join(rasa_files_dir, "stories"), exist_ok=True)
+                os.makedirs(os.path.join(rasa_files_dir, "actions"), exist_ok=True)
+            
+            # 创建日志目录
+            log_dir = self.get("file_storage.log_dir")
+            if log_dir:
+                os.makedirs(log_dir, exist_ok=True)
+                
+        except Exception as e:
+            raise Exception(f"创建目录时发生错误: {str(e)}")
+    
+    def _setup_logging(self) -> None:
+        """配置日志系统"""
+        try:
+            log_dir = self.get("file_storage.log_dir", "./logs")
+            max_log_size = self.get("file_storage.max_log_size", 10)
+            log_retention_days = self.get("file_storage.log_retention_days", 30)
+            
+            # 确保日志目录存在
+            os.makedirs(log_dir, exist_ok=True)
+            
+            # 配置日志格式
+            log_format = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            
+            # 配置根日志器
+            root_logger = logging.getLogger()
+            root_logger.setLevel(logging.INFO)
+            
+            # 控制台日志处理器
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(log_format)
+            root_logger.addHandler(console_handler)
+            
+            # 文件日志处理器
+            from logging.handlers import RotatingFileHandler
+            
+            # 按大小切割日志
+            file_handler = RotatingFileHandler(
+                os.path.join(log_dir, "rasa_manager.log"),
+                maxBytes=max_log_size * 1024 * 1024,  # 转换为字节
+                backupCount=log_retention_days,
+                encoding='utf-8'
+            )
+            file_handler.setFormatter(log_format)
+            root_logger.addHandler(file_handler)
+            
+        except Exception as e:
+            raise Exception(f"配置日志系统时发生错误: {str(e)}")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        获取配置值
+        
+        Args:
+            key: 配置键，支持点符号嵌套，如 "database.connection_string"
+            default: 默认值，如果配置不存在则返回此值
+            
+        Returns:
+            配置值或默认值
+        """
+        try:
+            parts = key.split('.')
+            value = self.config_data
+            
+            for part in parts:
+                if isinstance(value, dict) and part in value:
+                    value = value[part]
+                else:
+                    return default
+                    
+            return value
+        except Exception as e:
+            logging.warning(f"获取配置项 {key} 时发生错误: {str(e)}，使用默认值 {default}")
+            return default
+    
+    def set(self, key: str, value: Any) -> None:
+        """
+        设置配置值
+        
+        Args:
+            key: 配置键，支持点符号嵌套
+            value: 要设置的值
+        """
+        try:
+            parts = key.split('.')
+            config = self.config_data
+            
+            for i, part in enumerate(parts[:-1]):
+                if part not in config or not isinstance(config[part], dict):
+                    config[part] = {}
+                config = config[part]
+                
+            config[parts[-1]] = value
+            
+            # 保存配置到文件
+            with open(self.config_path, 'w', encoding='utf-8') as f:
+                yaml.safe_dump(self.config_data, f, allow_unicode=True, sort_keys=False)
+                
+        except Exception as e:
+            raise Exception(f"设置配置项 {key} 时发生错误: {str(e)}")
+
+# 全局配置实例
+config = Config()

config/config.yaml

@@ -0,0 +1,41 @@
+# 数据库配置
+database:
+  # 数据库连接字符串
+  connection_string: "mysql+pymysql://root:800100@192.168.1.8/rasa_db?charset=utf8mb4"
+  # 连接池大小
+  pool_size: 10
+  # 连接超时时间(秒)
+  timeout: 30
+
+# 文件存储配置
+file_storage:
+  # Rasa配置文件生成目录
+  rasa_files_dir: "./rasa_files"
+  # 日志文件目录
+  log_dir: "./logs"
+  # 最大日志文件大小(MB)
+  max_log_size: 10
+  # 日志保留天数
+  log_retention_days: 30
+
+# Rasa服务配置
+rasa:
+  # Rasa服务器默认地址
+  server_url: "http://127.0.0.1:5005"
+  # 动作服务器默认地址
+  action_server_url: "http://127.0.0.1:5055"
+  # Rasa模型默认路径
+  default_model_path: "./models"
+  # 启动超时时间(秒)
+  startup_timeout: 60
+
+# API服务配置
+api:
+  # 服务绑定的主机地址
+  host: "0.0.0.0"
+  # 服务监听的端口
+  port: 8000
+  # 是否开启调试模式
+  debug: true
+  # API请求超时时间(秒)
+  request_timeout: 30

db/__init__.py

@@ -0,0 +1,8 @@
+from db.connection import db, get_db
+from db.models import Base, Intent, IntentExample, Story, StoryStep, CustomAction, SystemConfig
+
+__all__ = [
+    'db', 'get_db', 'Base', 'Intent', 
+    'IntentExample', 'Story', 'StoryStep', 
+    'CustomAction', 'SystemConfig'
+]

db/connection.py

@@ -0,0 +1,86 @@
+import logging
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.exc import SQLAlchemyError
+from db.models import Base
+from config import config
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+class Database:
+    """数据库连接管理类"""
+    
+    def __init__(self):
+        """初始化数据库连接"""
+        self.connection_string = config.get("database.connection_string")
+        self.pool_size = config.get("database.pool_size", 10)
+        self.timeout = config.get("database.timeout", 30)
+        
+        if not self.connection_string:
+            raise ValueError("数据库连接字符串未配置")
+            
+        try:
+            # 创建数据库引擎
+            self.engine = create_engine(
+                self.connection_string,
+                pool_size=self.pool_size,
+                pool_recycle=3600,  # 1小时后回收连接
+                connect_args={"connect_timeout": self.timeout}
+            )
+            
+            # 创建会话工厂
+            self.SessionLocal = sessionmaker(
+                autocommit=False,
+                autoflush=False,
+                bind=self.engine
+            )
+            
+            # 验证数据库连接
+            self._test_connection()
+            
+            logger.info("数据库连接初始化成功")
+            
+        except SQLAlchemyError as e:
+            logger.error(f"数据库连接初始化失败: {str(e)}")
+            raise Exception(f"数据库连接初始化失败: {str(e)}")
+        except Exception as e:
+            logger.error(f"初始化数据库时发生错误: {str(e)}")
+            raise Exception(f"初始化数据库时发生错误: {str(e)}")
+    
+    def _test_connection(self) -> None:
+        """测试数据库连接是否有效"""
+        try:
+            with self.engine.connect():
+                pass  # 连接成功
+        except SQLAlchemyError as e:
+            raise Exception(f"数据库连接测试失败: {str(e)}")
+    
+    def create_tables(self) -> None:
+        """创建数据库表"""
+        try:
+            Base.metadata.create_all(bind=self.engine)
+            logger.info("数据库表创建/验证成功")
+        except SQLAlchemyError as e:
+            logger.error(f"创建数据库表失败: {str(e)}")
+            raise Exception(f"创建数据库表失败: {str(e)}")
+    
+    def get_session(self) -> Session:
+        """获取数据库会话"""
+        session = self.SessionLocal()
+        try:
+            yield session
+        except SQLAlchemyError as e:
+            logger.error(f"数据库会话操作失败: {str(e)}")
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+# 全局数据库实例
+db = Database()
+
+# 用于FastAPI依赖的会话获取函数
+def get_db():
+    """FastAPI依赖项：获取数据库会话"""
+    yield from db.get_session()

db/models.py

@@ -0,0 +1,197 @@
+import logging
+import json
+from datetime import datetime
+from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey, Boolean, UniqueConstraint, Index
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from sqlalchemy.exc import SQLAlchemyError
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+Base = declarative_base()
+
+class Intent(Base):
+    """意图表模型"""
+    __tablename__ = 'intent'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='意图ID')
+    name = Column(String(100), nullable=False, unique=True, comment='意图名称')
+    description = Column(String(500), comment='意图描述')
+    created_time = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+    
+    examples = relationship('IntentExample', backref='intent', cascade='all, delete-orphan')
+    
+    __table_args__ = {'comment': '存储Rasa意图定义'}
+
+class IntentExample(Base):
+    """意图样本表模型"""
+    __tablename__ = 'intent_example'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='样本ID')
+    intent_id = Column(Integer, ForeignKey('intent.id'), nullable=False, comment='意图ID')
+    text = Column(String(1000), nullable=False, comment='样本文本')
+    created_time = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+
+    
+    __table_args__ = {'comment': '存储意图对应的用户输入示例'}
+
+class Story(Base):
+    """故事表模型"""
+    __tablename__ = 'story'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='故事ID')
+    name = Column(String(200), nullable=False, unique=True, comment='故事名称')
+    description = Column(String(500), comment='故事描述')
+    created_time = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+    
+    # 关联关系
+    steps = relationship('StoryStep', backref='story', cascade='all, delete-orphan')
+    
+    __table_args__ = {'comment': '存储Rasa对话流程定义'}
+
+class StoryStep(Base):
+    """故事步骤表模型"""
+    __tablename__ = 'story_step'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='步骤ID')
+    story_id = Column(Integer, ForeignKey('story.id'), nullable=False, comment='故事ID')
+    step_order = Column(Integer, nullable=False, comment='步骤顺序')
+    step_type = Column(String(20), nullable=False, comment='步骤类型')
+    content = Column(Text, nullable=False, comment='步骤内容(JSON)')
+    created_time = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+
+    
+    @property
+    def content_dict(self):
+        """将JSON字符串转换为字典"""
+        try:
+            if not self.content:
+                return {}
+            return json.loads(self.content)
+        except json.JSONDecodeError as e:
+            logger.error(f"解析StoryStep内容失败: {str(e)}, 内容: {self.content}")
+            return {}
+    
+    __table_args__ = {'comment': '存储故事的具体步骤'}
+
+class CustomAction(Base):
+    """自定义动作表模型"""
+    __tablename__ = 'custom_action'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='动作ID')
+    name = Column(String(100), nullable=False, unique=True, comment='动作名称')
+    description = Column(String(500), comment='动作描述')
+    http_method = Column(String(10), nullable=False, comment='HTTP方法')
+    api_url = Column(String(500), nullable=False, comment='API地址')
+    token = Column(String(500), comment='鉴权Token')
+    headers = Column(Text, comment='请求头(JSON)')
+    request_body = Column(Text, comment='请求体(JSON)')
+    response_mapping = Column(Text, comment='响应映射规则(JSON)')
+    created_time = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+    
+    @property
+    def headers_dict(self):
+        """将请求头JSON转换为字典"""
+        try:
+            if not self.headers:
+                return {}
+            return json.loads(self.headers)
+        except json.JSONDecodeError as e:
+            logger.error(f"解析CustomAction请求头失败: {str(e)}, 内容: {self.headers}")
+            return {}
+    
+    @property
+    def request_body_dict(self):
+        """将请求体JSON转换为字典"""
+        try:
+            if not self.request_body:
+                return {}
+            return json.loads(self.request_body)
+        except json.JSONDecodeError as e:
+            logger.error(f"解析CustomAction请求体失败: {str(e)}, 内容: {self.request_body}")
+            return {}
+    
+    @property
+    def response_mapping_dict(self):
+        """将响应映射JSON转换为字典"""
+        try:
+            if not self.response_mapping:
+                return {}
+            return json.loads(self.response_mapping)
+        except json.JSONDecodeError as e:
+            logger.error(f"解析CustomAction响应映射失败: {str(e)}, 内容: {self.response_mapping}")
+            return {}
+    
+    __table_args__ = {'comment': '存储对接第三方API的自定义动作配置'}
+
+class SystemConfig(Base):
+    """系统配置表模型"""
+    __tablename__ = 'system_config'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True, comment='配置ID')
+    config_key = Column(String(100), nullable=False, unique=True, comment='配置键')
+    config_value = Column(String(500), nullable=False, comment='配置值')
+    description = Column(String(500), comment='配置描述')
+    updated_by = Column(String(100), comment='更新人')
+    updated_time = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment='更新时间')
+    
+    __table_args__ = {'comment': '存储系统配置信息'}
+    
+    @classmethod
+    def get_value(cls, session, key, default=None):
+        """
+        获取配置值
+        
+        Args:
+            session: 数据库会话
+            key: 配置键
+            default: 默认值
+            
+        Returns:
+            配置值或默认值
+        """
+        try:
+            config = session.query(cls).filter_by(config_key=key).first()
+            return config.config_value if config else default
+        except SQLAlchemyError as e:
+            logger.error(f"获取系统配置 {key} 失败: {str(e)}")
+            return default
+    
+    @classmethod
+    def set_value(cls, session, key, value, user=None):
+        """
+        设置配置值
+        
+        Args:
+            session: 数据库会话
+            key: 配置键
+            value: 配置值
+            user: 操作人
+            
+        Returns:
+            配置对象
+        """
+        try:
+            config = session.query(cls).filter_by(config_key=key).first()
+            if config:
+                config.config_value = value
+                config.updated_by = user
+            else:
+                config = cls(
+                    config_key=key,
+                    config_value=value,
+                    updated_by=user
+                )
+                session.add(config)
+            session.commit()
+            return config
+        except SQLAlchemyError as e:
+            session.rollback()
+            logger.error(f"设置系统配置 {key} 失败: {str(e)}")
+            raise Exception(f"设置系统配置失败: {str(e)}")

redme.md

@@ -0,0 +1,33 @@
+# 安装依赖
+```
+pip install -r requirements.txt
+```
+
+# 初始化数据库
+```
+# 从项目根目录执行
+python -m scripts.init_db
+```
+
+# 启动服务命令
+```
+uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+# 启动 Rasa 相关服务
+```
+# 启动Rasa核心服务（使用生成的配置文件）
+rasa run --enable-api --cors "*" --model ./rasa_files/models --config ./rasa_files/config.yml
+
+# 启动Rasa动作服务器（使用生成的自定义动作）
+rasa run actions --actions actions --actions-dir ./rasa_files/actions
+```
+
+# 生产环境启动建议
+```
+# 安装进程管理工具
+pip install gunicorn
+
+# 启动命令（4个工作进程，绑定8000端口）
+gunicorn api.main:app -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000
+```

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.95.0
+uvicorn==0.21.1
+sqlalchemy==2.0.9
+pymysql==1.0.2
+pyyaml==6.0
+requests==2.28.2
+python-dotenv==1.0.0

scripts/__init__.py

@@ -0,0 +1 @@
+"""辅助脚本模块"""

scripts/init_db.py

@@ -0,0 +1,63 @@
+import logging
+import os
+import sys
+from sqlalchemy import create_engine
+from sqlalchemy.exc import SQLAlchemyError
+
+# 添加项目根目录到Python路径
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from config import config
+from db import Base
+
+# 初始化日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def init_database():
+    """初始化数据库：创建表结构并执行初始SQL脚本"""
+    try:
+        # 获取数据库连接字符串
+        connection_string = config.get("database.connection_string")
+        if not connection_string:
+            raise ValueError("数据库连接字符串未配置")
+        
+        # 创建数据库引擎
+        engine = create_engine(connection_string)
+        
+        # 创建所有表
+        logger.info("开始创建数据库表结构...")
+        Base.metadata.create_all(engine)
+        logger.info("数据库表结构创建成功")
+        
+        # 执行SQL初始化脚本
+        sql_script_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "sql", "schema.sql")
+        if os.path.exists(sql_script_path):
+            logger.info(f"开始执行初始化SQL脚本: {sql_script_path}")
+            
+            with engine.connect() as connection:
+                with open(sql_script_path, 'r', encoding='utf-8') as f:
+                    # 读取并执行SQL脚本
+                    sql = f.read()
+                    # 分割SQL语句（简单处理，适用于大多数情况）
+                    statements = sql.split(';')
+                    for stmt in statements:
+                        stmt = stmt.strip()
+                        if stmt and not stmt.startswith('--'):
+                            connection.execute(stmt)
+                connection.commit()
+            logger.info("SQL初始化脚本执行成功")
+        else:
+            logger.warning(f"未找到SQL初始化脚本: {sql_script_path}")
+        
+        logger.info("数据库初始化完成")
+        
+    except SQLAlchemyError as e:
+        logger.error(f"数据库操作错误: {str(e)}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"初始化数据库失败: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    init_database()

services/__init__.py

@@ -0,0 +1,4 @@
+from services.rasa_generator import RasaFileGenerator
+from services.rasa_manager import RasaManager
+
+__all__ = ['RasaFileGenerator', 'RasaManager']

services/flow.json

@@ -0,0 +1,576 @@
+{
+    "flowName": "测试",
+    "flowId": "1",
+    "flowJson": {
+        "nodes": [
+            {
+                "id": "1755743973598277318",
+                "type": "start",
+                "x": 340,
+                "y": 600,
+                "properties": {
+                    "name": "开始",
+                    "desc": "酒店预订流程开始",
+                    "frontend_status": "1"
+                }
+            },
+            {
+                "id": "1755744073948164528",
+                "type": "intention",
+                "x": 340,
+                "y": 780,
+                "properties": {
+                    "name": "用户预定酒店",
+                    "desc": "用户发起预定酒店",
+                    "frontend_status": "1",
+                    "code": "book_hotel",
+                    "samples": [
+                        {
+                            "text": "我想订酒店",
+                            "entities": []
+                        },
+                        {
+                            "text": "我想定明天的酒店",
+                            "entities": [
+                                {
+                                    "text": "明天",
+                                    "label": "check_in_out",
+                                    "start": 3,
+                                    "end": 4
+                                }
+                            ]
+                        },
+                        {
+                            "text": "帮我订一间房",
+                            "entities": []
+                        }
+                    ]
+                }
+            },
+            {
+                "id": "1755744170948999578",
+                "type": "action",
+                "x": 340,
+                "y": 960,
+                "properties": {
+                    "name": "确定开始预定回复",
+                    "desc": "回复预定动作",
+                    "frontend_status": "1",
+                    "code": "confirm_booking",
+                    "configText": "好的，我将为您办理酒店预定，请提供一下信息："
+                }
+            },
+            {
+                "id": "1755744259460386308",
+                "type": "collection",
+                "x": 340,
+                "y": 1140,
+                "properties": {
+                    "name": "酒店预定表单",
+                    "desc": "酒店预定表单信息采集",
+                    "frontend_status": "1",
+                    "code": "hotel",
+                    "formFields": [
+                        {
+                            "slotName": "",
+                            "entityType": "check_in_out",
+                            "question": "请问您的入住日期是？",
+                            "validation": "date",
+                            "customRegex": "",
+                            "required": true,
+                            "retryMessage": "请输入正确的时间格式"
+                        }
+                    ],
+                    "submitIntent": "",
+                    "cancelIntent": "",
+                    "completionMessage": ""
+                }
+            },
+            {
+                "id": "1755744367061997285",
+                "type": "form",
+                "x": 340,
+                "y": 1320,
+                "properties": {
+                    "name": "获取会员信息",
+                    "desc": "调用接口获取会员信息",
+                    "frontend_status": "0",
+                    "anchors": [
+                        {
+                            "id": "1755744368596992170",
+                            "text": "成功",
+                            "checked": true,
+                            "isDefault": true
+                        },
+                        {
+                            "id": "1755744368596493642",
+                            "text": "失败",
+                            "checked": true,
+                            "isDefault": true
+                        }
+                    ],
+                    "code": "get_vipinfo",
+                    "requestMethod": "GET",
+                    "requestUrl": "http://localhost:3400",
+                    "headers": [
+                        {
+                            "key": "token",
+                            "value": "123"
+                        }
+                    ],
+                    "params": [
+                        {
+                            "name": "phone",
+                            "remark": "手机号",
+                            "type": "string",
+                            "entity": "event",
+                            "required": true,
+                            "placeholder": ""
+                        }
+                    ],
+                    "responseMappings": [
+                        {
+                            "responseField": "data[0].vip",
+                            "targetVar": "is_vip",
+                            "defaultValue": "false"
+                        }
+                    ]
+                }
+            },
+            {
+                "id": "1755744802261201276",
+                "type": "condition",
+                "x": 240,
+                "y": 1540,
+                "properties": {
+                    "name": "判断是否是会员",
+                    "desc": "",
+                    "frontend_status": "1",
+                    "code": "condition_ismember",
+                    "configText": "",
+                    "entities": [],
+                    "conditionGroups": [
+                        {
+                            "name": "是会员",
+                            "operator": "and",
+                            "conditions": [
+                                {
+                                    "type": "slot",
+                                    "slotName": "is_vip",
+                                    "intentName": "",
+                                    "operator": "==",
+                                    "value": "true"
+                                }
+                            ]
+                        }
+                    ],
+                    "anchors": [
+                        {
+                            "id": "1755744870669973945",
+                            "text": "A",
+                            "tooltip": "是会员",
+                            "checked": true,
+                            "isDefault": true
+                        },
+                        {
+                            "id": "1755744870669360142",
+                            "text": "其他",
+                            "tooltip": "未匹配到规则",
+                            "checked": true,
+                            "isDefault": true
+                        }
+                    ]
+                }
+            },
+            {
+                "id": "1755745052943625022",
+                "type": "action",
+                "x": 190,
+                "y": 1740,
+                "properties": {
+                    "name": "会员确定预定提醒",
+                    "desc": "",
+                    "frontend_status": "1",
+                    "code": "submit_comfirm_vip",
+                    "configText": "尊敬的会员您好，已成功为您预定<date|日期>的房间"
+                }
+            },
+            {
+                "id": "1755745287568590291",
+                "type": "action",
+                "x": 560,
+                "y": 1710,
+                "properties": {
+                    "name": "普通用户确定预定回复",
+                    "desc": "",
+                    "frontend_status": "1",
+                    "code": "submit_confirm_novip",
+                    "configText": "好的，已经为您预定成功，感谢您的支持，祝您生活愉快！"
+                }
+            },
+            {
+                "id": "1755745352034663098",
+                "type": "end",
+                "x": 400,
+                "y": 1980,
+                "properties": {
+                    "name": "结束",
+                    "desc": "",
+                    "frontend_status": "0"
+                }
+            }
+        ],
+        "edges": [
+            {
+                "id": "1755744156551690020",
+                "type": "myBezier",
+                "sourceNodeId": "1755743973598277318",
+                "targetNodeId": "1755744073948164528",
+                "startPoint": {
+                    "x": 340,
+                    "y": 650
+                },
+                "endPoint": {
+                    "x": 340,
+                    "y": 730
+                },
+                "properties": {
+                    "edgeType": "start"
+                },
+                "pointsList": [
+                    {
+                        "x": 340,
+                        "y": 650
+                    },
+                    {
+                        "x": 340,
+                        "y": 750
+                    },
+                    {
+                        "x": 340,
+                        "y": 630
+                    },
+                    {
+                        "x": 340,
+                        "y": 730
+                    }
+                ]
+            },
+            {
+                "id": "1755744175271745566",
+                "type": "myBezier",
+                "sourceNodeId": "1755744073948164528",
+                "targetNodeId": "1755744170948999578",
+                "startPoint": {
+                    "x": 340,
+                    "y": 830
+                },
+                "endPoint": {
+                    "x": 340,
+                    "y": 910
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 340,
+                        "y": 830
+                    },
+                    {
+                        "x": 340,
+                        "y": 930
+                    },
+                    {
+                        "x": 340,
+                        "y": 810
+                    },
+                    {
+                        "x": 340,
+                        "y": 910
+                    }
+                ]
+            },
+            {
+                "id": "1755744264519257586",
+                "type": "myBezier",
+                "sourceNodeId": "1755744170948999578",
+                "targetNodeId": "1755744259460386308",
+                "startPoint": {
+                    "x": 340,
+                    "y": 1010
+                },
+                "endPoint": {
+                    "x": 340,
+                    "y": 1090
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 340,
+                        "y": 1010
+                    },
+                    {
+                        "x": 340,
+                        "y": 1110
+                    },
+                    {
+                        "x": 340,
+                        "y": 990
+                    },
+                    {
+                        "x": 340,
+                        "y": 1090
+                    }
+                ]
+            },
+            {
+                "id": "1755744373342277013",
+                "type": "myBezier",
+                "sourceNodeId": "1755744259460386308",
+                "targetNodeId": "1755744367061997285",
+                "startPoint": {
+                    "x": 340,
+                    "y": 1190
+                },
+                "endPoint": {
+                    "x": 340,
+                    "y": 1270
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 340,
+                        "y": 1190
+                    },
+                    {
+                        "x": 340,
+                        "y": 1290
+                    },
+                    {
+                        "x": 340,
+                        "y": 1170
+                    },
+                    {
+                        "x": 340,
+                        "y": 1270
+                    }
+                ]
+            },
+            {
+                "id": "1755744805233383108",
+                "type": "myBezier",
+                "sourceNodeId": "1755744367061997285",
+                "targetNodeId": "1755744802261201276",
+                "startPoint": {
+                    "x": 234,
+                    "y": 1370
+                },
+                "endPoint": {
+                    "x": 240,
+                    "y": 1490
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 234,
+                        "y": 1370
+                    },
+                    {
+                        "x": 234,
+                        "y": 1470
+                    },
+                    {
+                        "x": 240,
+                        "y": 1390
+                    },
+                    {
+                        "x": 240,
+                        "y": 1490
+                    }
+                ]
+            },
+            {
+                "id": "1755745059414490384",
+                "type": "myBezier",
+                "sourceNodeId": "1755744802261201276",
+                "targetNodeId": "1755745052943625022",
+                "startPoint": {
+                    "x": 126.5,
+                    "y": 1590
+                },
+                "endPoint": {
+                    "x": 190,
+                    "y": 1690
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 126.5,
+                        "y": 1590
+                    },
+                    {
+                        "x": 126.5,
+                        "y": 1690
+                    },
+                    {
+                        "x": 190,
+                        "y": 1590
+                    },
+                    {
+                        "x": 190,
+                        "y": 1690
+                    }
+                ]
+            },
+            {
+                "id": "1755745293386979251",
+                "type": "myBezier",
+                "sourceNodeId": "1755744802261201276",
+                "targetNodeId": "1755745287568590291",
+                "startPoint": {
+                    "x": 157,
+                    "y": 1590
+                },
+                "endPoint": {
+                    "x": 560,
+                    "y": 1660
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 157,
+                        "y": 1590
+                    },
+                    {
+                        "x": 157,
+                        "y": 1690
+                    },
+                    {
+                        "x": 560,
+                        "y": 1560
+                    },
+                    {
+                        "x": 560,
+                        "y": 1660
+                    }
+                ]
+            },
+            {
+                "id": "1755745297779860170",
+                "type": "myBezier",
+                "sourceNodeId": "1755744367061997285",
+                "targetNodeId": "1755745287568590291",
+                "startPoint": {
+                    "x": 272,
+                    "y": 1370
+                },
+                "endPoint": {
+                    "x": 560,
+                    "y": 1660
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 272,
+                        "y": 1370
+                    },
+                    {
+                        "x": 272,
+                        "y": 1470
+                    },
+                    {
+                        "x": 560,
+                        "y": 1560
+                    },
+                    {
+                        "x": 560,
+                        "y": 1660
+                    }
+                ]
+            },
+            {
+                "id": "1755745356697455012",
+                "type": "myBezier",
+                "sourceNodeId": "1755745052943625022",
+                "targetNodeId": "1755745352034663098",
+                "startPoint": {
+                    "x": 190,
+                    "y": 1790
+                },
+                "endPoint": {
+                    "x": 400,
+                    "y": 1930
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 190,
+                        "y": 1790
+                    },
+                    {
+                        "x": 190,
+                        "y": 1890
+                    },
+                    {
+                        "x": 400,
+                        "y": 1830
+                    },
+                    {
+                        "x": 400,
+                        "y": 1930
+                    }
+                ]
+            },
+            {
+                "id": "1755745359943951336",
+                "type": "myBezier",
+                "sourceNodeId": "1755745287568590291",
+                "targetNodeId": "1755745352034663098",
+                "startPoint": {
+                    "x": 560,
+                    "y": 1760
+                },
+                "endPoint": {
+                    "x": 400,
+                    "y": 1930
+                },
+                "properties": {
+                    "edgeType": "nextStep"
+                },
+                "pointsList": [
+                    {
+                        "x": 560,
+                        "y": 1760
+                    },
+                    {
+                        "x": 560,
+                        "y": 1860
+                    },
+                    {
+                        "x": 400,
+                        "y": 1830
+                    },
+                    {
+                        "x": 400,
+                        "y": 1930
+                    }
+                ]
+            }
+        ]
+    }
+}

services/rasa_generator.py

@@ -0,0 +1,414 @@
+import os
+import json
+import logging
+from pathlib import Path
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from db import (
+    Intent, IntentExample, Story, StoryStep, CustomAction,
+    SystemConfig
+)
+
+from config import config
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+class RasaFileGenerator:
+    """Rasa配置文件生成服务，带完整异常处理"""
+    
+    def __init__(self):
+        """初始化生成器，从配置获取输出目录"""
+        try:
+            self.output_dir = config.get("file_storage.rasa_files_dir", "./rasa_files")
+            
+            # 创建输出目录
+            self._create_directories()
+            
+            logger.info(f"Rasa文件生成器初始化成功，输出目录: {self.output_dir}")
+            
+        except Exception as e:
+            logger.error(f"初始化Rasa文件生成器失败: {str(e)}")
+            raise Exception(f"初始化Rasa文件生成器失败: {str(e)}")
+    
+    def _create_directories(self) -> None:
+        """创建必要的目录结构"""
+        try:
+            Path(self.output_dir).mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/nlu").mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/stories").mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/actions").mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise Exception(f"创建目录失败: {str(e)}")
+    
+    def generate_all_files(self, session: Session) -> dict:
+        """
+        生成所有Rasa配置文件
+        
+        Args:
+            session: 数据库会话
+            
+        Returns:
+            生成结果，包含文件路径和状态
+        """
+        try:
+            
+            # 生成各文件
+            domain_path = self.generate_domain_file(session)
+            nlu_path = self.generate_nlu_file(session)
+            story_paths = self.generate_stories_files(session)
+            action_path = self.generate_actions_file(session)
+            
+            
+            return {
+                "success": True,
+                "message": "所有文件生成成功",
+                "output_dir": self.output_dir,
+                "files": {
+                    "domain": domain_path,
+                    "nlu": nlu_path,
+                    "stories": story_paths,
+                    "actions": action_path
+                }
+            }
+        except SQLAlchemyError as e:
+            logger.error(f"数据库错误导致文件生成失败: {str(e)}")
+            return {
+                "success": False,
+                "message": f"数据库错误: {str(e)}",
+            }
+        except OSError as e:
+            logger.error(f"文件系统错误导致文件生成失败: {str(e)}")
+            return {
+                "success": False,
+                "message": f"文件系统错误: {str(e)}",
+            }
+        except Exception as e:
+            logger.error(f"文件生成失败: {str(e)}")
+            return {
+                "success": False,
+                "message": f"生成文件时发生错误: {str(e)}",
+            }
+    
+    def generate_domain_file(self, session: Session) -> str:
+        """生成domain.yml文件"""
+        try:
+            domain_data = {
+                "version": "3.1",
+                "intents": [],
+                "slots": {},
+                "forms": {},
+                "responses": {},
+                "actions": []
+            }
+            
+            # 获取指定版本的意图
+            intents = session.query(Intent).all()
+            
+            if not intents:
+                logger.warning(f"未找到任何意图")
+            
+            # 添加意图
+            domain_data["intents"] = [intent.name for intent in intents]
+            
+            # 获取指定版本的自定义动作
+            actions = session.query(CustomAction).all()
+            
+            # 添加动作
+            domain_data["actions"] = [action.name for action in actions]
+            
+            # 实际应用中还需要添加槽位、表单和响应
+            
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/domain.yml"
+            with open(file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, domain_data)
+            
+            logger.info(f"生成domain文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成domain文件失败: {str(e)}")
+            raise Exception(f"生成domain文件失败: {str(e)}")
+    
+    def generate_nlu_file(self, session: Session) -> str:
+        """生成nlu.yml文件"""
+        try:
+            nlu_data = {
+                "version": "3.1",
+                "nlu": []
+            }
+            
+            # 获取指定版本的意图及样本
+            intents = session.query(Intent).all()
+            
+            for intent in intents:
+                # 获取该意图指定版本的样本
+                examples = session.query(IntentExample).filter(
+                    IntentExample.intent_id == intent.id,
+                ).all()
+                
+                # 构建examples字符串，使用正确的YAML多行文本格式
+                examples_str = "\n".join([f"      - {ex.text}" for ex in examples])
+                
+
+                intent_entry = {
+                    "intent": intent.name,
+                    "examples": examples_str
+                }
+                
+                if intent.description:
+                    intent_entry["intent"] = f"{intent.name} # {intent.description}"
+
+                nlu_data["nlu"].append(intent_entry)
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/nlu/nlu.yml"
+            with open(file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, nlu_data)
+            
+            logger.info(f"生成nlu文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成nlu文件失败: {str(e)}")
+            raise Exception(f"生成nlu文件失败: {str(e)}")
+    
+    def generate_stories_files(self, session: Session) -> list[str]:
+        """生成stories文件"""
+        try:
+            files = []
+            
+            # 获取指定版本的故事
+            stories = session.query(Story).all()
+            
+            if not stories:
+                logger.warning(f"未找到任何故事")
+            
+            # 生成合并的stories.yml
+            all_stories = {
+                "version": "3.1",
+                "stories": []
+            }
+            
+            for story in stories:
+                # 获取故事步骤
+                steps = session.query(StoryStep).filter(
+                    StoryStep.story_id == story.id
+                ).order_by(StoryStep.step_order).all()
+                
+                # 构建故事内容
+                story_entry = {
+                    "story": story.name,
+                    "steps": []
+                }
+                
+                if story.description:
+                    story_entry["story"] = f"{story.name} # {story.description}"
+                    
+                # 处理步骤
+                for step in steps:
+                    content = step.content_dict
+                    step_type = step.step_type
+                    
+                    if step_type == "intent":
+                        story_entry["steps"].append({"intent": content.get("name")})
+                    elif step_type == "action":
+                        story_entry["steps"].append({"action": content.get("name")})
+                    elif step_type == "form":
+                        if content.get("activate", True):
+                            story_entry["steps"].append({"action": content.get("name")})
+                        else:
+                            story_entry["steps"].append({"action": f"form_deactivate_{content.get('name')}"})
+                    # 处理其他类型的步骤...
+                    
+                all_stories["stories"].append(story_entry)
+                
+                # 生成单个故事文件
+                story_file_name = story.name.lower().replace(" ", "_") + ".yml"
+                story_file_path = f"{self.output_dir}/stories/{story_file_name}"
+                
+                with open(story_file_path, "w", encoding="utf-8") as f:
+                    self._write_yaml(f, {
+                        "version": "3.1",
+                        "stories": [story_entry]
+                    })
+                
+                files.append(story_file_path)
+            
+            # 写入合并的stories.yml
+            merged_file_path = f"{self.output_dir}/stories/stories.yml"
+            with open(merged_file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, all_stories)
+            
+            files.append(merged_file_path)
+            logger.info(f"生成stories文件: {len(files)} 个文件")
+            return files
+            
+        except Exception as e:
+            logger.error(f"生成stories文件失败: {str(e)}")
+            raise Exception(f"生成stories文件失败: {str(e)}")
+    
+    def generate_actions_file(self, session: Session) -> str:
+        """生成自定义动作Python文件"""
+        try:
+            actions = session.query(CustomAction).all()
+            
+            if not actions:
+                logger.warning(f"未找到任何自定义动作")
+            
+            # 生成actions.py内容
+            code = [
+                "from rasa_sdk import Action, Tracker",
+                "from rasa_sdk.executor import CollectingDispatcher",
+                "from rasa_sdk.events import SlotSet",
+                "import requests",
+                "import json\n"
+            ]
+            
+            for action in actions:
+                class_name = f"Action{''.join(word.capitalize() for word in action.name.split('_'))}"
+                
+                # 生成类定义
+                code.append(f"class {class_name}(Action):")
+                code.append(f"    def name(self) -> str:")
+                code.append(f"        return \"{action.name}\"\n")
+                
+                # 生成run方法
+                code.append(f"    def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: dict) -> list:")
+                code.append("        # 构建请求头")
+                code.append("        headers = {}")
+                
+                # 添加Token
+                if action.token:
+                    code.append(f"        headers[\"Authorization\"] = \"Bearer {action.token}\"")
+                
+                # 添加自定义请求头
+                headers = action.headers_dict
+                for key, value in headers.items():
+                    code.append(f"        headers[\"{key}\"] = \"{value}\"")
+                
+                # 添加内容类型
+                code.append("        headers[\"Content-Type\"] = \"application/json\"\n")
+                
+                # 构建请求体
+                if action.http_method in ["POST", "PUT"] and action.request_body:
+                    code.append("        # 构建请求体")
+                    code.append(f"        payload = {action.request_body}")
+                    
+                    # 替换模板变量
+                    code.append("        # 替换模板变量")
+                    code.append("        from jinja2 import Template")
+                    code.append("        payload_str = json.dumps(payload)")
+                    code.append("        template = Template(payload_str)")
+                    code.append("        payload = json.loads(template.render(tracker.slots))\n")
+                
+                # 发送请求
+                code.append("        # 发送请求")
+                code.append("        try:")
+                
+                if action.http_method == "GET":
+                    code.append(f"            response = requests.get(\"{action.api_url}\", headers=headers)")
+                elif action.http_method == "POST":
+                    code.append(f"            response = requests.post(\"{action.api_url}\", json=payload, headers=headers)")
+                elif action.http_method == "PUT":
+                    code.append(f"            response = requests.put(\"{action.api_url}\", json=payload, headers=headers)")
+                elif action.http_method == "DELETE":
+                    code.append(f"            response = requests.delete(\"{action.api_url}\", headers=headers)")
+                else:
+                    code.append(f"            dispatcher.utter_message(text=f\"不支持的HTTP方法: {action.http_method}\")")
+                    code.append("            return []")
+                
+                # 处理响应
+                code.append("            if response.status_code == 200:")
+                code.append("                result = response.json()")
+                
+                # 处理响应映射
+                if action.response_mapping:
+                    code.append("                # 处理响应映射")
+                    code.append(f"                mappings = {action.response_mapping}")
+                    code.append("                slot_events = []")
+                    code.append("                for slot, path in mappings.items():")
+                    code.append("                    # 简化的路径解析")
+                    code.append("                    value = result")
+                    code.append("                    for part in path.split('.'):")
+                    code.append("                        if isinstance(value, dict) and part in value:")
+                    code.append("                            value = value[part]")
+                    code.append("                        else:")
+                    code.append("                            value = None")
+                    code.append("                            break")
+                    code.append("                    if value is not None:")
+                    code.append("                        slot_events.append(SlotSet(slot, value))")
+                    code.append("                dispatcher.utter_message(text=str(result))")
+                    code.append("                return slot_events")
+                else:
+                    code.append("                dispatcher.utter_message(text=str(result))")
+                
+                code.append("            else:")
+                code.append("                dispatcher.utter_message(text=f\"API调用失败，状态码: {response.status_code}\")")
+                code.append("        except Exception as e:")
+                code.append("            dispatcher.utter_message(text=f\"调用API时发生错误: {str(e)}\")\n")
+                code.append("        return []\n")
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/actions/actions.py"
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write("\n".join(code))
+            
+            logger.info(f"生成actions文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成actions文件失败: {str(e)}")
+            raise Exception(f"生成actions文件失败: {str(e)}")
+    
+    def _write_yaml(self, file, data, indent: int = 0, reset: bool = False) -> None:
+        """
+        简单的YAML写入函数
+        
+        Args:
+            file: 文件对象
+            data: 要写入的数据
+            indent: 当前缩进
+        """
+        try:
+            indent_str = ""
+            if (indent != 0):
+                indent_str = "  " * indent
+            
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    if isinstance(value, (dict, list)):
+                        file.write(f"{indent_str}{key}:\n")
+                        self._write_yaml(file, value, indent + 1)
+                    else:
+                        if (key != 'examples'): 
+                            file.write(f"{key}: {self._format_yaml_value(value)}\n")
+                        else:
+                            file.write(f"{indent_str}{key}: {self._format_yaml_value(value)}\n")
+                            
+            elif isinstance(data, list):
+                for item in data:
+                    if isinstance(item, (dict, list)):
+                        file.write(f"{indent_str}- ")
+                        self._write_yaml(file, item, indent + 1, True)
+                    else:
+                        file.write(f"{indent_str}- {self._format_yaml_value(item)}\n")
+            else:
+                file.write(f"{self._format_yaml_value(data)}\n")
+        except Exception as e:
+            raise Exception(f"写入YAML数据失败: {str(e)}")
+    
+    def _format_yaml_value(self, value) -> str:
+        """格式化YAML值"""
+        if isinstance(value, str) and (":" in value or "\n" in value):
+            return f"|{chr(10)}{value}"
+        elif isinstance(value, str):
+            return f'{value}'
+        elif isinstance(value, bool):
+            return "true" if value else "false"
+        elif value is None:
+            return "null"
+        else:
+            return str(value)

services/rasa_generator_by_json.py

@@ -0,0 +1,544 @@
+import os
+import sys
+import json
+import logging
+from pathlib import Path
+
+# 添加项目根目录到Python搜索路径
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from config import Config
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+class RasaFileGenerator:
+    """Rasa配置文件生成服务，带完整异常处理"""
+    
+    def __init__(self):
+        """初始化生成器，从配置获取输出目录"""
+        try:
+            # 创建配置实例
+            self.config = Config()
+            self.output_dir = self.config.get("file_storage.rasa_files_dir", "./rasa_files")
+            
+            # 创建输出目录
+            self._create_directories()
+            
+            logger.info(f"Rasa文件生成器初始化成功，输出目录: {self.output_dir}")
+            
+        except Exception as e:
+            logger.error(f"初始化Rasa文件生成器失败: {str(e)}")
+            raise Exception(f"初始化Rasa文件生成器失败: {str(e)}")
+    
+    def _load_flow_json(self, flow_json_path: str) -> dict:
+        """加载并解析flow.json文件"""
+        try:
+            with open(flow_json_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except FileNotFoundError:
+            raise Exception(f"flow.json文件未找到: {flow_json_path}")
+        except json.JSONDecodeError:
+            raise Exception(f"flow.json文件格式无效")
+        except Exception as e:
+            raise Exception(f"加载flow.json文件失败: {str(e)}")
+    
+    def _create_directories(self) -> None:
+        """创建必要的目录结构"""
+        try:
+            Path(self.output_dir).mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/nlu").mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/stories").mkdir(parents=True, exist_ok=True)
+            Path(f"{self.output_dir}/actions").mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise Exception(f"创建目录失败: {str(e)}")
+    
+    def generate_all_files(self, flow_json_str: str, flow_name: str) -> dict:
+        """
+        生成所有Rasa配置文件
+        
+        Args:
+            flow_json_str: flow数据的JSON字符串
+            
+        Returns:
+            生成结果，包含文件路径和状态
+        """
+        try:
+            # 解析flow JSON字符串
+            flow_data = json.loads(flow_json_str)
+            
+            # 生成各文件
+            domain_path = self.generate_domain_file(flow_data)
+            nlu_path = self.generate_nlu_file(flow_data)
+            story_paths = self.generate_stories_files(flow_data, flow_name)
+            action_path = self.generate_actions_file(flow_data)
+            
+            return {
+                "success": True,
+                "message": "所有文件生成成功",
+                "output_dir": self.output_dir,
+                "files": {
+                    "domain": domain_path,
+                    "nlu": nlu_path,
+                    "stories": story_paths,
+                    "actions": action_path
+                }
+            }
+        except OSError as e:
+            logger.error(f"文件系统错误导致文件生成失败: {str(e)}")
+            return {
+                "success": False,
+                "message": f"文件系统错误: {str(e)}",
+            }
+        except Exception as e:
+            logger.error(f"文件生成失败: {str(e)}")
+            return {
+                "success": False,
+                "message": f"生成文件时发生错误: {str(e)}",
+            }
+    
+    def generate_domain_file(self, flow_data: dict) -> str:
+        """生成domain.yml文件"""
+        try:
+            domain_data = {
+                "version": "3.1",
+                "intents": [],
+                "slots": {},
+                "forms": {},
+                "responses": {},
+                "actions": []
+            }
+            
+            # 从flow_data中提取意图和动作
+            nodes = flow_data.get("flowJson", {}).get("nodes", [])
+            intents = []
+            actions = []
+            forms = []
+            
+            for node in nodes:
+                node_type = node.get("type")
+                properties = node.get("properties", {})
+                code = properties.get("code")
+                
+                if node_type == "intention" and code:
+                    intents.append(code)
+                elif node_type == "action" and code:
+                    actions.append(code)
+                elif node_type == "form" and code:
+                    actions.append(code)
+                elif node_type == "collection" and code:
+                    forms.append(code)
+                    actions.append(f"form_{code}")
+            
+            # 添加意图
+            domain_data["intents"] = intents
+            
+            # 添加动作
+            domain_data["actions"] = actions
+            
+            # 添加表单
+            for form_code in forms:
+                domain_data["forms"][form_code] = {}
+            
+            # 添加槽位 - 从表单节点提取
+            for node in nodes:
+                if node.get("type") == "collection":
+                    form_code = node.get("properties", {}).get("code")
+                    form_fields = node.get("properties", {}).get("formFields", [])
+                    for field in form_fields:
+                        slot_name = field.get("slotName") or f"{form_code}_{field.get('entityType')}"
+                        domain_data["slots"][slot_name] = {
+                            "type": "text"  # 默认为text类型，可根据需要调整
+                        }
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/domain.yml"
+            with open(file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, domain_data)
+            
+            logger.info(f"生成domain文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成domain文件失败: {str(e)}")
+            raise Exception(f"生成domain文件失败: {str(e)}")
+    
+    def generate_nlu_file(self, flow_data: dict) -> str:
+        """生成nlu.yml文件"""
+        try:
+            nlu_data = {
+                "version": "3.1",
+                "nlu": []
+            }
+            
+            # 从flow_data中提取意图及样本
+            nodes = flow_data.get("flowJson", {}).get("nodes", [])
+            
+            for node in nodes:
+                if node.get("type") == "intention":
+                    properties = node.get("properties", {})
+                    intent_name = properties.get("code")
+                    intent_desc = properties.get("desc")
+                    samples = properties.get("samples", [])
+                    
+                    if not intent_name:
+                        continue
+                    # {
+                    #         "text": "我想定明天的酒店",
+                    #         "entities": [
+                    #             {
+                    #                 "text": "明天",
+                    #                 "label": "DATE",
+                    #                 "start": 3,
+                    #                 "end": 4
+                    #             }
+                    #         ]
+                    #     },
+
+                    # entities = samples.get("entities", [])
+                    # 如果entities存在说明需要在样本中标记实体
+
+
+                    # 处理实体并构建examples字符串
+                    def format_sample_with_entities(sample):
+                        text = sample.get('text', '')
+                        entities = sample.get('entities', [])
+                        
+                        # 没有实体，直接返回文本
+                        if not entities:
+                            return text
+                        
+                        # 按start位置降序排列实体，确保从后向前处理，避免替换位置偏移
+                        sorted_entities = sorted(entities, key=lambda e: e.get('start', 0), reverse=True)
+                        
+                        for entity in sorted_entities:
+                            start = entity.get('start', 0)
+                            end = entity.get('end', 0) + 1  # 因为end是 exclusive 的
+                            entity_text = text[start:end]
+                            label = entity.get('label', 'UNKNOWN')
+                            
+                            # 替换文本中的实体部分
+                            text = text[:start] + f"[{entity_text}]({label})" + text[end:]
+                        
+                        return text
+                    
+                    examples_str = "\n".join([f"      - {format_sample_with_entities(sample)}" for sample in samples])
+                    
+                    intent_entry = {
+                        "intent": intent_name,
+                        "examples": examples_str
+                    }
+                    
+                    if intent_desc:
+                        intent_entry["intent"] = f"{intent_name} # {intent_desc}"
+                    
+                    nlu_data["nlu"].append(intent_entry)
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/nlu/nlu.yml"
+            with open(file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, nlu_data)
+            
+            logger.info(f"生成nlu文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成nlu文件失败: {str(e)}")
+            raise Exception(f"生成nlu文件失败: {str(e)}")
+    
+    def generate_stories_files(self, flow_data: dict, flow_name: str) -> list[str]:
+        """生成stories文件"""
+        try:
+            files = []
+            
+            # 从flow_data中提取故事信息
+            # flow_name = flow_data.get("flowName", "default_flow")
+            nodes = flow_data.get("flowJson", {}).get("nodes", [])
+            edges = flow_data.get("flowJson", {}).get("edges", [])
+            
+            # 构建节点ID到节点的映射
+            node_map = {node.get("id"): node for node in nodes}
+            
+            # 构建边的映射 (source -> target)
+            edge_map = {}
+            for edge in edges:
+                source = edge.get("sourceNodeId")
+                target = edge.get("targetNodeId")
+                if source not in edge_map:
+                    edge_map[source] = []
+                edge_map[source].append(target)
+            
+            # 找到开始节点
+            start_node = None
+            for node in nodes:
+                if node.get("type") == "start":
+                    start_node = node
+                    break
+            
+            if not start_node:
+                logger.warning("未找到开始节点")
+                return files
+            
+            # 构建故事步骤
+            story_steps = []
+            current_node = start_node
+            
+            while current_node:
+                node_type = current_node.get("type")
+                properties = current_node.get("properties", {})
+                code = properties.get("code")
+                
+                if node_type == "intention" and code:
+                    story_steps.append({"intent": code})
+                elif node_type == "action" and code:
+                    story_steps.append({"action": code})
+                elif node_type == "collection" and code:
+                    story_steps.append({"action": f"form_{code}"})
+                    # 添加表单激活后的槽位填充
+                    story_steps.append({"active_loop": {"name": code}})
+                    story_steps.append({"active_loop": None})
+                elif node_type == "form" and code:
+                    story_steps.append({"action": code})
+                elif node_type == "condition" and code:
+                    # 简化处理条件节点
+                    story_steps.append({"action": code})
+                    # 这里应该根据条件分支生成不同的故事路径，但为简化起见，我们只取第一条路径
+                
+                # 找到下一个节点
+                current_node_id = current_node.get("id")
+                next_nodes = edge_map.get(current_node_id, [])
+                
+                if not next_nodes or node_type == "end":
+                    break
+                
+                # 简单处理，只取第一个下一个节点
+                current_node = node_map.get(next_nodes[0])
+            
+            # 构建故事内容
+            story_entry = {
+                "story": flow_name,
+                "steps": story_steps
+            }
+            
+            # 生成合并的stories.yml
+            all_stories = {
+                "version": "3.1",
+                "stories": [story_entry]
+            }
+            
+            # 写入合并的stories.yml
+            merged_file_path = f"{self.output_dir}/stories/stories.yml"
+            with open(merged_file_path, "w", encoding="utf-8") as f:
+                self._write_yaml(f, all_stories)
+            
+            files.append(merged_file_path)
+            logger.info(f"生成stories文件: {len(files)} 个文件")
+            return files
+            
+        except Exception as e:
+            logger.error(f"生成stories文件失败: {str(e)}")
+            raise Exception(f"生成stories文件失败: {str(e)}")
+    
+    def generate_actions_file(self, flow_data: dict) -> str:
+        """生成自定义动作Python文件"""
+        try:
+            # 从flow_data中提取动作信息
+            nodes = flow_data.get("flowJson", {}).get("nodes", [])
+            actions = []
+            
+            for node in nodes:
+                node_type = node.get("type")
+                if node_type == "action" or node_type == "form" or node_type == "condition":
+                    properties = node.get("properties", {})
+                    if properties.get("code"):
+                        actions.append({
+                            "type": node_type,
+                            "properties": properties
+                        })
+            
+            if not actions:
+                logger.warning(f"未找到任何自定义动作")
+            
+            # 生成actions.py内容
+            code = [
+                "from rasa_sdk import Action, Tracker",
+                "from rasa_sdk.executor import CollectingDispatcher",
+                "from rasa_sdk.events import SlotSet, ActiveLoop",
+                "import requests",
+                "import json\n"
+            ]
+            
+            for action in actions:
+                properties = action.get("properties", {})
+                action_name = properties.get("code")
+                action_type = action.get("type")
+                
+                if not action_name:
+                    continue
+                
+                class_name = f"Action{''.join(word.capitalize() for word in action_name.split('_'))}"
+                
+                # 生成类定义
+                code.append(f"class {class_name}(Action):")
+                code.append(f"    def name(self) -> str:")
+                code.append(f"        return \"{action_name}\"\n")
+                
+                # 生成run方法
+                code.append(f"    def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: dict) -> list:")
+                
+                if action_type == "action":
+                    # 普通动作节点
+                    config_text = properties.get("configText", "")
+                    code.append(f"        dispatcher.utter_message(text=\"{config_text}\")")
+                    code.append("        return []\n")
+                elif action_type == "form":
+                    # 表单节点（API调用）
+                    code.append("        # 构建请求头")
+                    code.append("        headers = {}")
+                    
+                    # 添加自定义请求头
+                    headers = properties.get("headers", [])
+                    for header in headers:
+                        code.append(f"        headers[\"{header.get('key')}\"] = \"{header.get('value')}\"")
+                    
+                    # 添加内容类型
+                    code.append("        headers[\"Content-Type\"] = \"application/json\"\n")
+                    
+                    # 构建请求参数
+                    params = properties.get("params", [])
+                    if params:
+                        code.append("        # 构建请求参数")
+                        code.append("        params = {}")
+                        for param in params:
+                            entity = param.get("entity")
+                            param_name = param.get("name")
+                            code.append(f"        params[\"{param_name}\"] = tracker.get_slot(\"{entity}\")")
+                        code.append("")
+                    
+                    # 发送请求
+                    code.append("        # 发送请求")
+                    code.append("        try:")
+                    
+                    method = properties.get("requestMethod")
+                    url = properties.get("requestUrl")
+                    
+                    if method == "GET":
+                        code.append(f"            response = requests.get(\"{url}\", headers=headers, params=params)")
+                    elif method == "POST":
+                        code.append(f"            response = requests.post(\"{url}\", headers=headers, params=params)")
+                    elif method == "PUT":
+                        code.append(f"            response = requests.put(\"{url}\", headers=headers, params=params)")
+                    elif method == "DELETE":
+                        code.append(f"            response = requests.delete(\"{url}\", headers=headers, params=params)")
+                    else:
+                        code.append(f"            dispatcher.utter_message(text=f\"不支持的HTTP方法: {method}\")")
+                        code.append("            return []")
+                    
+                    # 处理响应
+                    code.append("            if response.status_code == 200:")
+                    code.append("                result = response.json()")
+                    
+                    # 处理响应映射
+                    response_mappings = properties.get("responseMappings", [])
+                    if response_mappings:
+                        code.append("                # 处理响应映射")
+                        code.append("                slot_events = []")
+                        for mapping in response_mappings:
+                            field = mapping.get("responseField")
+                            target = mapping.get("targetVar")
+                            default = mapping.get("defaultValue")
+                            
+                            code.append(f"                # 提取 {field}")
+                            code.append(f"                value = {default}")
+                            code.append(f"                try:")
+                            code.append(f"                    # 简化的路径解析")
+                            code.append(f"                    parts = \"{field}\".split('.')")
+                            code.append(f"                    temp = result")
+                            code.append(f"                    for part in parts:")
+                            code.append(f"                        if isinstance(temp, dict) and part in temp:")
+                            code.append(f"                            temp = temp[part]")
+                            code.append(f"                        elif isinstance(temp, list) and part.isdigit() and int(part) < len(temp):")
+                            code.append(f"                            temp = temp[int(part)]")
+                            code.append(f"                        else:")
+                            code.append(f"                            raise Exception(\"路径无效\")")
+                            code.append(f"                    value = temp")
+                            code.append(f"                except:")
+                            code.append(f"                    pass")
+                            code.append(f"                slot_events.append(SlotSet(\"{target}\", value))")
+                        
+                        code.append("                dispatcher.utter_message(text=str(result))")
+                        code.append("                return slot_events")
+                    else:
+                        code.append("                dispatcher.utter_message(text=str(result))")
+                    
+                    code.append("            else:")
+                    code.append("                dispatcher.utter_message(text=f\"API调用失败，状态码: {response.status_code}\")")
+                    code.append("        except Exception as e:")
+                    code.append("            dispatcher.utter_message(text=f\"调用API时发生错误: {str(e)}\")\n")
+                    code.append("        return []\n")
+                elif action_type == "condition":
+                    # 条件节点
+                    code.append("        # 处理条件逻辑")
+                    code.append("        # 这里简化处理，实际应用中应根据条件执行不同的逻辑")
+                    code.append("        return []\n")
+            
+            # 写入文件
+            file_path = f"{self.output_dir}/actions/actions.py"
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write("\n".join(code))
+            
+            logger.info(f"生成actions文件: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"生成actions文件失败: {str(e)}")
+            raise Exception(f"生成actions文件失败: {str(e)}")
+    
+    def _write_yaml(self, file, data, indent: int = 0, reset: bool = False) -> None:
+        """
+        简单的YAML写入函数
+        
+        Args:
+            file: 文件对象
+            data: 要写入的数据
+            indent: 当前缩进
+        """
+        try:
+            indent_str = ""
+            if (indent != 0):
+                indent_str = "  " * indent
+            
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    if isinstance(value, (dict, list)):
+                        file.write(f"{indent_str}{key}:\n")
+                        self._write_yaml(file, value, indent + 1)
+                    else:
+                        if (key != 'examples'): 
+                            file.write(f"{key}: {self._format_yaml_value(value)}\n")
+                        else:
+                            file.write(f"{indent_str}{key}: {self._format_yaml_value(value)}\n")
+                            
+            elif isinstance(data, list):
+                for item in data:
+                    if isinstance(item, (dict, list)):
+                        file.write(f"{indent_str}- ")
+                        self._write_yaml(file, item, indent + 1, True)
+                    else:
+                        file.write(f"{indent_str}- {self._format_yaml_value(item)}\n")
+            else:
+                file.write(f"{self._format_yaml_value(data)}\n")
+        except Exception as e:
+            raise Exception(f"写入YAML数据失败: {str(e)}")
+    
+    def _format_yaml_value(self, value) -> str:
+        """格式化YAML值"""
+        if isinstance(value, str) and (":" in value or "\n" in value):
+            return f"|{chr(10)}{value}"
+        elif isinstance(value, str):
+            return f'{value}'
+        elif isinstance(value, bool):
+            return "true" if value else "false"
+        elif value is None:
+            return "null"
+        else:
+            return str(value)

services/rasa_manager.py

@@ -0,0 +1,354 @@
+import os
+import time
+import signal
+import logging
+import subprocess
+import requests
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from db import SystemConfig
+from config import config
+
+# 初始化日志
+logger = logging.getLogger(__name__)
+
+class RasaManager:
+    """Rasa服务管理器，带完整异常处理"""
+    
+    def __init__(self):
+        """初始化管理器"""
+        self.rasa_process = None
+        self.action_process = None
+        self.startup_timeout = config.get("rasa.startup_timeout", 60)
+        
+        logger.info("Rasa服务管理器初始化成功")
+    
+    def start_rasa_server(self, session: Session, model_path: str = None) -> dict:
+        """
+        启动Rasa服务器
+        
+        Args:
+            session: 数据库会话
+            model_path: 模型路径，None表示使用默认模型
+            
+        Returns:
+            启动结果
+        """
+        try:
+            # 停止已运行的服务
+            if self.rasa_process:
+                logger.info("检测到已运行的Rasa服务器，正在停止...")
+                self.stop_rasa_server()
+            
+            # 获取配置的Rasa服务器地址
+            rasa_url = SystemConfig.get_value(session, "rasa_server_url", "http://localhost:5005")
+            host, port = self._parse_url(rasa_url)
+            
+            # 构建启动命令
+            cmd = ["rasa", "run", "--enable-api", "--cors", "*", "--host", host, "--port", str(port)]
+            
+            # 如果指定了模型路径
+            if model_path and os.path.exists(model_path):
+                if not os.path.isfile(model_path) and not os.path.isdir(model_path):
+                    raise ValueError(f"模型路径不存在: {model_path}")
+                cmd.extend(["--model", model_path])
+                logger.info(f"使用指定模型路径: {model_path}")
+            else:
+                default_model = config.get("rasa.default_model_path")
+                if default_model and os.path.exists(default_model):
+                    cmd.extend(["--model", default_model])
+                    logger.info(f"使用默认模型路径: {default_model}")
+            
+            logger.info(f"启动Rasa服务器命令: {' '.join(cmd)}")
+            
+            # 启动Rasa服务器
+            self.rasa_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            logger.info(f"Rasa服务器已启动，PID: {self.rasa_process.pid}")
+            
+            # 等待服务启动
+            start_time = time.time()
+            health_check_interval = 2  # 每2秒检查一次
+            max_attempts = self.startup_timeout // health_check_interval
+            
+            for attempt in range(max_attempts):
+                if self._check_rasa_health(rasa_url):
+                    logger.info(f"Rasa服务器启动成功，耗时 {time.time() - start_time:.2f} 秒")
+                    return {
+                        "success": True,
+                        "message": "Rasa服务器启动成功",
+                        "url": rasa_url,
+                        "pid": self.rasa_process.pid
+                    }
+                
+                # 检查进程是否已退出
+                if self.rasa_process.poll() is not None:
+                    stderr = self.rasa_process.stderr.read()
+                    raise Exception(f"Rasa服务器启动后意外退出，错误输出: {stderr}")
+                
+                time.sleep(health_check_interval)
+            
+            # 超时未成功启动
+            stderr = self.rasa_process.stderr.read()
+            self.stop_rasa_server()  # 清理进程
+            raise Exception(f"Rasa服务器启动超时({self.startup_timeout}秒)，错误输出: {stderr}")
+                
+        except ValueError as e:
+            logger.warning(f"启动Rasa服务器参数错误: {str(e)}")
+            return {
+                "success": False,
+                "message": str(e)
+            }
+        except subprocess.SubprocessError as e:
+            logger.error(f"启动Rasa服务器进程错误: {str(e)}")
+            return {
+                "success": False,
+                "message": f"进程错误: {str(e)}"
+            }
+        except Exception as e:
+            logger.error(f"启动Rasa服务器失败: {str(e)}")
+            return {
+                "success": False,
+                "message": str(e)
+            }
+    
+    def start_action_server(self, session: Session, actions_dir: str = None) -> dict:
+        """启动Rasa动作服务器"""
+        try:
+            # 停止已运行的服务
+            if self.action_process:
+                logger.info("检测到已运行的动作服务器，正在停止...")
+                self.stop_action_server()
+            
+            # 获取配置的动作服务器地址
+            action_url = SystemConfig.get_value(session, "rasa_actions_url", "http://localhost:5055")
+            host, port = self._parse_url(action_url)
+            
+            # 构建启动命令
+            cmd = ["rasa", "run", "actions", "--host", host, "--port", str(port)]
+            
+            # 如果指定了动作目录
+            if actions_dir and os.path.exists(actions_dir):
+                if not os.path.isdir(actions_dir):
+                    raise ValueError(f"动作目录不是有效的文件夹: {actions_dir}")
+                cmd.extend(["--actions", "actions", "--actions-dir", actions_dir])
+                logger.info(f"使用指定动作目录: {actions_dir}")
+            else:
+                default_actions = os.path.join(config.get("file_storage.rasa_files_dir", "./rasa_files"), "actions")
+                if os.path.exists(default_actions):
+                    cmd.extend(["--actions", "actions", "--actions-dir", default_actions])
+                    logger.info(f"使用默认动作目录: {default_actions}")
+            
+            logger.info(f"启动动作服务器命令: {' '.join(cmd)}")
+            
+            # 启动动作服务器
+            self.action_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            logger.info(f"动作服务器已启动，PID: {self.action_process.pid}")
+            
+            # 等待服务启动
+            start_time = time.time()
+            health_check_interval = 2  # 每2秒检查一次
+            max_attempts = self.startup_timeout // health_check_interval
+            
+            for attempt in range(max_attempts):
+                if self._check_action_health(action_url):
+                    logger.info(f"动作服务器启动成功，耗时 {time.time() - start_time:.2f} 秒")
+                    return {
+                        "success": True,
+                        "message": "Rasa动作服务器启动成功",
+                        "url": action_url,
+                        "pid": self.action_process.pid
+                    }
+                
+                # 检查进程是否已退出
+                if self.action_process.poll() is not None:
+                    stderr = self.action_process.stderr.read()
+                    raise Exception(f"动作服务器启动后意外退出，错误输出: {stderr}")
+                
+                time.sleep(health_check_interval)
+            
+            # 超时未成功启动
+            stderr = self.action_process.stderr.read()
+            self.stop_action_server()  # 清理进程
+            raise Exception(f"动作服务器启动超时({self.startup_timeout}秒)，错误输出: {stderr}")
+                
+        except ValueError as e:
+            logger.warning(f"启动动作服务器参数错误: {str(e)}")
+            return {
+                "success": False,
+                "message": str(e)
+            }
+        except subprocess.SubprocessError as e:
+            logger.error(f"启动动作服务器进程错误: {str(e)}")
+            return {
+                "success": False,
+                "message": f"进程错误: {str(e)}"
+            }
+        except Exception as e:
+            logger.error(f"启动动作服务器失败: {str(e)}")
+            return {
+                "success": False,
+                "message": str(e)
+            }
+    
+    def restart_rasa_services(self, session: Session, model_path: str = None, actions_dir: str = None) -> dict:
+        """重启所有Rasa服务"""
+        try:
+            logger.info("开始重启所有Rasa服务")
+            
+            # 先停止所有服务
+            self.stop_all_services()
+            
+            # 启动Rasa服务器
+            rasa_result = self.start_rasa_server(session, model_path)
+            if not rasa_result["success"]:
+                return {
+                    "success": False,
+                    "message": f"Rasa服务器启动失败: {rasa_result['message']}",
+                    "rasa": rasa_result
+                }
+            
+            # 启动动作服务器
+            action_result = self.start_action_server(session, actions_dir)
+            if not action_result["success"]:
+                # 如果动作服务器启动失败，停止已启动的Rasa服务器
+                self.stop_rasa_server()
+                return {
+                    "success": False,
+                    "message": f"动作服务器启动失败: {action_result['message']}",
+                    "rasa": rasa_result,
+                    "action": action_result
+                }
+            
+            logger.info("所有Rasa服务重启成功")
+            return {
+                "success": True,
+                "message": "所有Rasa服务重启成功",
+                "rasa": rasa_result,
+                "action": action_result
+            }
+        except Exception as e:
+            logger.error(f"重启Rasa服务时发生错误: {str(e)}")
+            return {
+                "success": False,
+                "message": f"重启Rasa服务失败: {str(e)}"
+            }
+    
+    def stop_rasa_server(self) -> bool:
+        """停止Rasa服务器"""
+        result = self._stop_process(self.rasa_process, "Rasa服务器")
+        self.rasa_process = None
+        return result
+    
+    def stop_action_server(self) -> bool:
+        """停止Rasa动作服务器"""
+        result = self._stop_process(self.action_process, "动作服务器")
+        self.action_process = None
+        return result
+    
+    def stop_all_services(self) -> bool:
+        """停止所有Rasa服务"""
+        logger.info("停止所有Rasa服务")
+        rasa_stopped = self.stop_rasa_server()
+        action_stopped = self.stop_action_server()
+        return rasa_stopped and action_stopped
+    
+    def _stop_process(self, process, process_name: str) -> bool:
+        """
+        停止进程
+        
+        Args:
+            process: 要停止的进程对象
+            process_name: 进程名称，用于日志
+            
+        Returns:
+            是否成功停止
+        """
+        if not process or process.poll() is not None:
+            logger.info(f"{process_name}未在运行")
+            return True
+            
+        try:
+            pid = process.pid
+            logger.info(f"正在停止{process_name}，PID: {pid}")
+            
+            # 尝试优雅关闭
+            process.terminate()
+            
+            # 等待进程退出
+            for _ in range(10):  # 最多等待10秒
+                if process.poll() is not None:
+                    logger.info(f"{process_name}已成功停止，PID: {pid}")
+                    return True
+                time.sleep(1)
+            
+            # 强制关闭
+            logger.warning(f"{process_name}未能优雅关闭，尝试强制终止，PID: {pid}")
+            os.kill(pid, signal.SIGKILL)
+            
+            # 再次检查
+            time.sleep(2)
+            if process.poll() is not None:
+                logger.info(f"{process_name}已强制终止，PID: {pid}")
+                return True
+            else:
+                logger.error(f"{process_name}强制终止失败，PID: {pid}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"停止{process_name}时发生错误: {str(e)}")
+            return False
+    
+    def _check_rasa_health(self, url: str) -> bool:
+        """检查Rasa服务器健康状态"""
+        try:
+            health_url = f"{url}/health"
+            response = requests.get(health_url, timeout=5)
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+    
+    def _check_action_health(self, url: str) -> bool:
+        """检查动作服务器健康状态"""
+        try:
+            health_url = f"{url}/health"
+            response = requests.get(health_url, timeout=5)
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+    
+    def _parse_url(self, url: str) -> tuple:
+        """
+        解析URL获取主机和端口
+        
+        Args:
+            url: 要解析的URL
+            
+        Returns:
+            (主机, 端口) 元组
+        """
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse(url)
+            host = parsed.hostname or "localhost"
+            port = parsed.port 
+            
+            # 如果没有指定端口，使用默认端口
+            if not port:
+                port = 443 if parsed.scheme == "https" else 5005
+                
+            return (host, port)
+        except Exception as e:
+            logger.warning(f"解析URL {url} 失败，使用默认值: {str(e)}")
+            return ("localhost", 5005)

services/test_rasa_generator.py

@@ -0,0 +1,39 @@
+import logging
+import os
+from rasa_generator_by_json import RasaFileGenerator
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    try:
+        # 创建生成器实例
+        generator = RasaFileGenerator()
+        
+        # 定义flow.json文件路径
+        flow_json_path = '/home/rasa_manager/services/flow.json'
+        
+        # 检查文件是否存在
+        if not os.path.exists(flow_json_path):
+            raise Exception(f"flow.json文件不存在: {flow_json_path}")
+        
+        # 读取flow.json文件内容
+        with open(flow_json_path, 'r', encoding='utf-8') as f:
+            flow_json_str = f.read()
+        
+        logger.info(f"开始从JSON字符串生成Rasa文件...")
+        
+        # 生成所有文件
+        result = generator.generate_all_files(flow_json_str, "酒店预定")
+        
+        if result['success']:
+            logger.info(f"文件生成成功！输出目录: {result['output_dir']}")
+            logger.info(f"生成的文件:")
+            for file_type, file_path in result['files'].items():
+                logger.info(f"  - {file_type}: {file_path}")
+        else:
+            logger.error(f"文件生成失败: {result['message']}")
+            
+    except Exception as e:
+        logger.error(f"测试过程中发生错误: {str(e)}")

sql/schema.sql

@@ -0,0 +1,244 @@
+-- ----------------------------
+-- 数据库表结构和示例数据
+-- 特性：无外键约束、无版本管理
+-- 所有关联关系由应用代码控制
+-- ----------------------------
+
+-- ----------------------------
+-- 1. 意图与实体相关表
+-- ----------------------------
+
+-- 意图表：存储Rasa意图定义
+CREATE TABLE `intent` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '意图ID，自增主键',
+  `name` varchar(100) NOT NULL COMMENT '意图名称，如greet、query_bill',
+  `description` varchar(500) DEFAULT NULL COMMENT '意图描述',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_intent_name` (`name`) COMMENT '确保意图名称唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储Rasa意图定义';
+
+-- 意图样本表：存储意图对应的用户输入示例
+CREATE TABLE `intent_example` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '样本ID，自增主键',
+  `intent_id` bigint NOT NULL COMMENT '关联的意图ID（代码控制关联）',
+  `text` varchar(1000) NOT NULL COMMENT '用户输入示例文本',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_intent_id` (`intent_id`) COMMENT '意图ID索引，加速查询'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储意图对应的用户输入示例';
+
+-- 实体表：存储Rasa实体定义
+CREATE TABLE `entity` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '实体ID，自增主键',
+  `name` varchar(100) NOT NULL COMMENT '实体名称，如account_number、date',
+  `description` varchar(500) DEFAULT NULL COMMENT '实体描述',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_entity_name` (`name`) COMMENT '确保实体名称唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储Rasa实体定义';
+
+-- ----------------------------
+-- 2. 对话流程相关表
+-- ----------------------------
+
+-- 故事表：存储Rasa对话流程定义
+CREATE TABLE `story` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '故事ID，自增主键',
+  `name` varchar(200) NOT NULL COMMENT '故事名称',
+  `description` varchar(500) DEFAULT NULL COMMENT '故事描述',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_story_name` (`name`) COMMENT '确保故事名称唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储Rasa对话流程定义';
+
+-- 故事步骤表：存储故事的具体步骤
+CREATE TABLE `story_step` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '步骤ID，自增主键',
+  `story_id` bigint NOT NULL COMMENT '关联的故事ID（代码控制关联）',
+  `step_order` int NOT NULL COMMENT '步骤顺序',
+  `step_type` varchar(20) NOT NULL COMMENT '步骤类型（intent/action等）',
+  `content` text NOT NULL COMMENT '步骤内容，JSON格式',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_story_id` (`story_id`) COMMENT '故事ID索引，加速查询'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储故事的具体步骤';
+
+-- ----------------------------
+-- 3. 动作与响应相关表
+-- ----------------------------
+
+-- 自定义动作表：存储对接第三方API的自定义动作配置
+CREATE TABLE `custom_action` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '动作ID，自增主键',
+  `name` varchar(100) NOT NULL COMMENT '动作名称',
+  `description` varchar(500) DEFAULT NULL COMMENT '动作描述',
+  `http_method` varchar(10) NOT NULL COMMENT 'HTTP方法',
+  `api_url` varchar(500) NOT NULL COMMENT 'API地址',
+  `token` varchar(500) DEFAULT NULL COMMENT '鉴权Token',
+  `headers` text COMMENT '请求头配置，JSON格式',
+  `request_body` text COMMENT '请求体，JSON格式',
+  `response_mapping` text COMMENT '响应映射规则，JSON格式',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_action_name` (`name`) COMMENT '确保动作名称唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储对接第三方API的自定义动作配置';
+
+-- 响应模板表：存储Rasa响应模板
+CREATE TABLE `response` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '响应ID，自增主键',
+  `name` varchar(100) NOT NULL COMMENT '响应名称，如utter_greet',
+  `description` varchar(500) DEFAULT NULL COMMENT '响应描述',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_response_name` (`name`) COMMENT '确保响应名称唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储Rasa响应模板';
+
+-- 响应内容表：存储响应的具体内容
+CREATE TABLE `response_content` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '响应内容ID，自增主键',
+  `response_id` bigint NOT NULL COMMENT '关联的响应ID（代码控制关联）',
+  `content_type` varchar(20) NOT NULL COMMENT '内容类型，如text、image',
+  `text_content` varchar(2000) DEFAULT NULL COMMENT '文本内容',
+  `media_url` varchar(500) DEFAULT NULL COMMENT '媒体URL',
+  `content_order` int NOT NULL COMMENT '内容顺序',
+  `created_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_response_id` (`response_id`) COMMENT '响应ID索引，加速查询'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储响应的具体内容';
+
+-- ----------------------------
+-- 4. 系统配置表
+-- ----------------------------
+
+-- 系统配置表：存储系统基础配置
+CREATE TABLE `system_config` (
+  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '配置ID，自增主键',
+  `config_key` varchar(100) NOT NULL COMMENT '配置键，如rasa_server_url',
+  `config_value` varchar(500) NOT NULL COMMENT '配置值',
+  `description` varchar(500) DEFAULT NULL COMMENT '配置描述',
+  `updated_by` varchar(100) DEFAULT NULL COMMENT '更新人',
+  `updated_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_config_key` (`config_key`) COMMENT '确保配置键唯一'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='存储系统配置信息';
+
+-- ----------------------------
+-- 示例数据插入
+-- ----------------------------
+
+-- 插入系统配置
+INSERT INTO `system_config` (`config_key`, `config_value`, `description`, `updated_by`) VALUES
+('rasa_server_url', 'http://localhost:5005', 'Rasa服务器地址', 'system'),
+('rasa_actions_url', 'http://localhost:5055', 'Rasa动作服务器地址', 'system'),
+('log_level', 'INFO', '系统日志级别', 'system'),
+('api_timeout', '30', 'API请求超时时间(秒)', 'system');
+
+-- 插入意图数据
+INSERT INTO `intent` (`name`, `description`) VALUES
+('greet', '用户打招呼或问候'),
+('goodbye', '用户告别或结束对话'),
+('query_bill', '用户查询账单信息'),
+('query_balance', '用户查询账户余额'),
+('complain', '用户投诉或反馈问题');
+
+-- 插入意图样本数据
+INSERT INTO `intent_example` (`intent_id`, `text`) VALUES
+(1, '你好'),
+(1, '早上好'),
+(1, '嗨，在吗'),
+(1, '您好，请问有人吗'),
+(2, '再见'),
+(2, '拜拜'),
+(2, '下次见'),
+(2, '退出对话'),
+(3, '我的账单是多少'),
+(3, '查询一下我的消费记录'),
+(3, '看看我这个月花了多少钱'),
+(3, '上个月的账单明细'),
+(4, '我的账户还有多少余额'),
+(4, '查询余额'),
+(4, '我的卡里还有钱吗'),
+(5, '我要投诉'),
+(5, '这个服务太差了'),
+(5, '我有问题要反馈');
+
+-- 插入实体数据
+INSERT INTO `entity` (`name`, `description`) VALUES
+('account_number', '银行账号'),
+('date', '日期'),
+('amount', '金额'),
+('product', '产品名称'),
+('user_id', '用户ID'),
+('complaint_type', '投诉类型');
+
+-- 插入故事数据
+INSERT INTO `story` (`name`, `description`) VALUES
+('greet_and_respond', '问候与回应的对话流程'),
+('bill_inquiry', '账单查询的对话流程'),
+('balance_inquiry', '余额查询的对话流程');
+
+-- 插入故事步骤数据
+INSERT INTO `story_step` (`story_id`, `step_order`, `step_type`, `content`) VALUES
+-- 问候对话流程
+(1, 1, 'intent', '{"name": "greet"}'),
+(1, 2, 'action', '{"name": "utter_greet"}'),
+(1, 3, 'intent', '{"name": "goodbye"}'),
+(1, 4, 'action', '{"name": "utter_goodbye"}'),
+
+-- 账单查询流程
+(2, 1, 'intent', '{"name": "query_bill"}'),
+(2, 2, 'action', '{"name": "utter_ask_account_number"}'),
+(2, 3, 'action', '{"name": "action_query_bill"}'),
+(2, 4, 'action', '{"name": "utter_bill_result"}'),
+
+-- 余额查询流程
+(3, 1, 'intent', '{"name": "query_balance"}'),
+(3, 2, 'action', '{"name": "utter_ask_account_number"}'),
+(3, 3, 'action', '{"name": "action_query_balance"}'),
+(3, 4, 'action', '{"name": "utter_balance_result"}');
+
+-- 插入自定义动作数据
+INSERT INTO `custom_action` (`name`, `description`, `http_method`, `api_url`, `token`, `headers`, `request_body`, `response_mapping`) VALUES
+('action_query_bill', '查询账单信息', 'POST', 'https://api.example.com/bill/query', 'secret_token_123', '{"Content-Type": "application/json"}', '{"account": "{{account_number}}", "month": "{{bill_month}}"}', '{"total_amount": "data.total", "due_date": "data.due_date", "details": "data.details"}'),
+('action_query_balance', '查询账户余额', 'GET', 'https://api.example.com/account/{{account_number}}/balance', 'secret_token_123', '{"Authorization": "Bearer {{token}}"}', NULL, '{"balance": "data.balance", "available": "data.available", "currency": "data.currency"}');
+
+-- 插入响应模板数据
+INSERT INTO `response` (`name`, `description`) VALUES
+('utter_greet', '问候用户的响应'),
+('utter_goodbye', '告别用户的响应'),
+('utter_ask_account_number', '询问用户账号的响应'),
+('utter_bill_result', '展示账单查询结果的响应'),
+('utter_balance_result', '展示余额查询结果的响应');
+
+-- 插入响应内容数据
+INSERT INTO `response_content` (`response_id`, `content_type`, `text_content`, `media_url`, `content_order`) VALUES
+-- 问候响应
+(1, 'text', '你好！有什么可以帮助您的吗？', NULL, 1),
+(1, 'text', '您好！很高兴为您服务。', NULL, 2),
+(1, 'text', '欢迎咨询，我能为您做些什么？', NULL, 3),
+
+-- 告别响应
+(2, 'text', '再见！祝您生活愉快。', NULL, 1),
+(2, 'text', '感谢您的咨询，再见！', NULL, 2),
+(2, 'text', '有任何问题随时联系我们，再见！', NULL, 3),
+
+-- 询问账号
+(3, 'text', '请提供您的账号，以便我为您查询。', NULL, 1),
+(3, 'text', '麻烦告诉我您的账号信息，我会尽快为您处理。', NULL, 2),
+
+-- 账单结果
+(4, 'text', '您{{bill_month}}的账单总金额为{{total_amount}}元，到期日为{{due_date}}。', NULL, 1),
+(4, 'text', '查询到您的账单信息：总额{{total_amount}}元，需在{{due_date}}前支付。', NULL, 2),
+
+-- 余额结果
+(5, 'text', '您的账户当前余额为{{balance}}{{currency}}，可用余额{{available}}{{currency}}。', NULL, 1),
+(5, 'text', '查询到您的账户余额：{{balance}}{{currency}}（可用：{{available}}{{currency}}）。', NULL, 2);