您好 {name}，这是一封自定义邮件。
+ + +""".format(name="张三") + +success = EmailService.send_email( + recipient_email="user@example.com", + subject="自定义邮件", + html_content=custom_html +) +``` + +### 扩展响应格式 + +```python +from hertz_studio_django_utils.responses import HertzResponse + +# 扩展自定义响应 +class CustomResponse(HertzResponse): + @staticmethod + def paginated(data, total, page, page_size, message="查询成功"): + """分页响应""" + pagination = { + "total": total, + "page": page, + "page_size": page_size, + "total_pages": (total + page_size - 1) // page_size + } + return HertzResponse.success( + data={"items": data, "pagination": pagination}, + message=message + ) + +# 使用扩展响应 +return CustomResponse.paginated( + data=users, + total=100, + page=1, + page_size=20, + message="用户列表查询成功" +) +``` + +## 测试 + +### 单元测试示例 + +```python +from django.test import TestCase +from hertz_studio_django_utils.validators import EmailValidator + +class EmailValidatorTest(TestCase): + def test_valid_email(self): + """测试有效邮箱地址""" + is_valid, message = EmailValidator.validate_email("test@example.com") + self.assertTrue(is_valid) + self.assertEqual(message, "邮箱地址格式正确") + + def test_invalid_email(self): + """测试无效邮箱地址""" + is_valid, message = EmailValidator.validate_email("invalid-email") + self.assertFalse(is_valid) + self.assertEqual(message, "邮箱地址格式不正确") +``` + +### 运行测试 + +```bash +python manage.py test hertz_studio_django_utils.tests +``` + +## 安全考虑 + +1. **密码安全**: 使用强密码哈希算法，避免明文存储密码 +2. **加密安全**: 使用安全的加密算法和随机盐值 +3. **输入验证**: 对所有输入数据进行严格验证 +4. **错误处理**: 避免泄露敏感错误信息 +5. **邮件安全**: 使用TLS加密邮件传输 + +## 常见问题 + +### Q: 邮件发送失败怎么办？ +A: 检查邮件配置是否正确，包括SMTP服务器、端口、用户名和密码。 + +### Q: MD5密码哈希是否安全？ +A: MD5被认为是不安全的哈希算法，仅用于兼容旧系统。新系统应使用更安全的算法如bcrypt或Argon2。 + +### Q: 如何自定义响应格式？ +A: 可以继承 `HertzResponse` 类并添加自定义方法。 + +### Q: 验证器是否支持国际手机号？ +A: 目前主要支持中国大陆手机号验证，国际手机号验证功能有限。 + +## 更新日志 + +### v1.0.0 (2024-01-01) +- 初始版本发布 +- 包含加密工具、邮件服务、响应格式、验证器等核心功能 + +## 🔗 相关链接 + +- [🏠 返回主项目](../README.md) - Hertz Server Django 主项目 +- [🔐 认证授权模块](../hertz_studio_django_auth/README.md) - 用户管理和权限控制 +- [🖼️ 验证码模块](../hertz_studio_django_captcha/README.md) - 图片和邮箱验证码功能 +- [📋 代码风格指南](../CODING_STYLE_GUIDE.md) - 开发规范和最佳实践 +- [Django 官方文档](https://docs.djangoproject.com/) +- [Django REST Framework 文档](https://www.django-rest-framework.org/) + +## 贡献指南 + +1. Fork 本项目 +2. 创建特性分支 (`git checkout -b feature/AmazingFeature`) +3. 提交更改 (`git commit -m 'Add some AmazingFeature'`) +4. 推送到分支 (`git push origin feature/AmazingFeature`) +5. 打开 Pull Request + +## 许可证 + +本项目采用 MIT 许可证 - 查看 [LICENSE](LICENSE) 文件了解详情。 + +## 支持 + +如有问题或建议，请提交 [Issue](https://github.com/your-org/hertz-server-django/issues) 或联系开发团队。 \ No newline at end of file diff --git a/hertz_studio_django_utils/__init__.py b/hertz_studio_django_utils/__init__.py new file mode 100644 index 0000000..e5b8fd2 --- /dev/null +++ b/hertz_studio_django_utils/__init__.py @@ -0,0 +1 @@ +# Hertz Server Django Utils Package \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/__init__.py b/hertz_studio_django_utils/code_generator/__init__.py new file mode 100644 index 0000000..7021b65 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/__init__.py @@ -0,0 +1,39 @@ +""" +Django代码生成器模块 + +该模块提供了Django应用代码自动生成功能，包括： +- 模型(ORM)代码生成 +- 序列化器代码生成 +- 视图(CRUD)代码生成 +- URL路由代码生成 + +使用示例: + from hertz_studio_django_utils.code_generator import DjangoCodeGenerator + + generator = DjangoCodeGenerator() + generator.generate_full_module( + model_name='User', + fields=[ + {'name': 'username', 'type': 'CharField', 'max_length': 150}, + {'name': 'email', 'type': 'EmailField'} + ] + ) +""" + +from .base_generator import BaseGenerator +from .django_code_generator import DjangoCodeGenerator +from .model_generator import ModelGenerator +from .serializer_generator import SerializerGenerator +from .view_generator import ViewGenerator +from .url_generator import URLGenerator +from .menu_generator import MenuGenerator + +__all__ = [ + 'BaseGenerator', + 'DjangoCodeGenerator', + 'ModelGenerator', + 'SerializerGenerator', + 'ViewGenerator', + 'URLGenerator', + 'MenuGenerator' +] \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/app_generator.py b/hertz_studio_django_utils/code_generator/app_generator.py new file mode 100644 index 0000000..d5edb84 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/app_generator.py @@ -0,0 +1,286 @@ +""" +Django应用代码生成器 + +该模块负责根据配置生成完整的Django应用代码 +""" + +import os +from typing import Dict, List, Any, Optional +from .base_generator import BaseGenerator +from .model_generator import ModelGenerator +from .serializer_generator import SerializerGenerator +from .view_generator import ViewGenerator +from .url_generator import URLGenerator + + +class AppGenerator(BaseGenerator): + """Django应用代码生成器""" + + def __init__(self): + """初始化应用生成器""" + super().__init__() + self.model_generator = ModelGenerator() + self.serializer_generator = SerializerGenerator() + self.view_generator = ViewGenerator() + self.url_generator = URLGenerator() + + def generate(self, app_name: str = None, models: List[Dict[str, Any]] = None, **kwargs) -> Dict[str, str]: + """ + 生成完整的Django应用代码 + + Args: + app_name: 应用名称 + models: 模型配置列表 + **kwargs: 其他参数 + + Returns: + Dict[str, str]: 生成的文件代码映射 + """ + # 处理参数 + if app_name is None: + app_name = kwargs.get('app_name', 'default_app') + if models is None: + models = kwargs.get('models', []) + + api_version = kwargs.get('api_version', 'v1') + include_admin = kwargs.get('include_admin', True) + include_tests = kwargs.get('include_tests', True) + + generated_files = {} + + # 生成应用配置文件 + generated_files['apps.py'] = self.generate_apps_config(app_name) + + # 生成__init__.py文件 + generated_files['__init__.py'] = self.generate_init_file(app_name) + + # 生成模型、序列化器、视图和URL + all_models = [] + for model_config in models: + model_name = model_config.get('name', 'DefaultModel') + fields = model_config.get('fields', []) + operations = model_config.get('operations', ['list', 'create', 'retrieve', 'update', 'delete']) + + # 生成模型代码 + model_code = self.model_generator.generate( + model_name=model_name, + fields=fields, + **model_config + ) + + # 生成序列化器代码 + serializer_code = self.serializer_generator.generate( + model_name=model_name, + fields=fields + ) + + # 生成视图代码 + view_code = self.view_generator.generate( + model_name=model_name, + operations=operations + ) + + # 生成URL代码 + url_code = self.url_generator.generate( + model_name=model_name, + operations=operations, + app_name=app_name + ) + + # 添加到生成的文件中 + generated_files[f'models/{model_name.lower()}_models.py'] = model_code + generated_files[f'serializers/{model_name.lower()}_serializers.py'] = serializer_code + generated_files[f'views/{model_name.lower()}_views.py'] = view_code + generated_files[f'urls/{model_name.lower()}_urls.py'] = url_code + + all_models.append(model_name) + + # 生成主要文件 + generated_files['models.py'] = self.generate_models_init(all_models) + generated_files['serializers/__init__.py'] = self.generate_serializers_init(all_models) + generated_files['views/__init__.py'] = self.generate_views_init(all_models) + generated_files['urls.py'] = self.generate_main_urls(app_name, all_models, api_version) + + # 生成管理后台文件 + if include_admin: + generated_files['admin.py'] = self.generate_admin_config(all_models) + + # 生成测试文件 + if include_tests: + generated_files['tests.py'] = self.generate_tests(all_models) + + return generated_files + + def generate_apps_config(self, app_name: str) -> str: + """生成应用配置文件""" + context = { + 'app_name': app_name, + 'app_label': app_name.replace('hertz_studio_django_', ''), + 'verbose_name': app_name.replace('_', ' ').title() + } + return self.render_template('django/apps.mako', context) + + def generate_init_file(self, app_name: str) -> str: + """生成__init__.py文件""" + return f'"""\n{app_name} Django应用\n"""\n\ndefault_app_config = \'{app_name}.apps.{app_name.title().replace("_", "")}Config\'\n' + + def generate_models_init(self, models: List[str]) -> str: + """生成models.py主文件""" + imports = [] + for model in models: + imports.append(f'from .models.{model.lower()}_models import {model}') + + context = { + 'imports': imports, + 'models': models + } + return self.render_template('django/models_init.mako', context) + + def generate_serializers_init(self, models: List[str]) -> str: + """生成serializers/__init__.py文件""" + imports = [] + for model in models: + imports.append(f'from .{model.lower()}_serializers import {model}Serializer') + + return '\n'.join(imports) + '\n' + + def generate_views_init(self, models: List[str]) -> str: + """生成views/__init__.py文件""" + imports = [] + for model in models: + imports.append(f'from .{model.lower()}_views import {model}ViewSet') + + return '\n'.join(imports) + '\n' + + def generate_main_urls(self, app_name: str, models: List[str], api_version: str) -> str: + """生成主URL配置文件""" + context = { + 'app_name': app_name, + 'models': models, + 'api_version': api_version, + 'url_includes': [f'path(\'{model.lower()}/\', include(\'{app_name}.urls.{model.lower()}_urls\'))' for model in models] + } + return self.render_template('django/main_urls.mako', context) + + def generate_admin_config(self, models: List[str]) -> str: + """生成管理后台配置""" + context = { + 'models': models + } + return self.render_template('django/admin.mako', context) + + def generate_tests(self, models: List[str]) -> str: + """生成测试文件""" + context = { + 'models': models + } + return self.render_template('django/tests.mako', context) + + def generate_full_app( + self, + app_name: str, + models: List[Dict[str, Any]], + output_dir: str = None, + **kwargs + ) -> Dict[str, str]: + """ + 生成完整的Django应用并写入文件 + + Args: + app_name: 应用名称 + models: 模型配置列表 + output_dir: 输出目录 + **kwargs: 其他参数 + + Returns: + Dict[str, str]: 生成的文件路径映射 + """ + generated_files = self.generate(app_name, models, **kwargs) + + if output_dir: + file_paths = {} + for file_name, content in generated_files.items(): + file_path = os.path.join(output_dir, app_name, file_name) + os.makedirs(os.path.dirname(file_path), exist_ok=True) + + with open(file_path, 'w', encoding='utf-8') as f: + f.write(content) + + file_paths[file_name] = file_path + + return file_paths + + return generated_files + + def generate_django_project( + self, + project_name: str, + apps: List[Dict[str, Any]], + output_dir: str = None, + **kwargs + ) -> Dict[str, str]: + """ + 生成完整的Django项目 + + Args: + project_name: 项目名称 + apps: 应用配置列表 + output_dir: 输出目录 + **kwargs: 其他参数 + + Returns: + Dict[str, str]: 生成的文件路径映射 + """ + generated_files = {} + + # 生成项目配置文件 + generated_files['manage.py'] = self.generate_manage_py(project_name) + generated_files[f'{project_name}/settings.py'] = self.generate_settings(project_name, apps) + generated_files[f'{project_name}/urls.py'] = self.generate_project_urls(project_name, apps) + generated_files[f'{project_name}/wsgi.py'] = self.generate_wsgi(project_name) + generated_files[f'{project_name}/asgi.py'] = self.generate_asgi(project_name) + generated_files[f'{project_name}/__init__.py'] = '' + + # 生成每个应用 + for app_config in apps: + app_name = app_config.get('name', 'default_app') + models = app_config.get('models', []) + + app_files = self.generate(app_name, models, **app_config) + for file_name, content in app_files.items(): + generated_files[f'{app_name}/{file_name}'] = content + + return generated_files + + def generate_manage_py(self, project_name: str) -> str: + """生成manage.py文件""" + context = {'project_name': project_name} + return self.render_template('django/manage.mako', context) + + def generate_settings(self, project_name: str, apps: List[Dict[str, Any]]) -> str: + """生成settings.py文件""" + app_names = [app.get('name', 'default_app') for app in apps] + context = { + 'project_name': project_name, + 'apps': app_names + } + return self.render_template('django/settings.mako', context) + + def generate_project_urls(self, project_name: str, apps: List[Dict[str, Any]]) -> str: + """生成项目主URL配置""" + app_names = [app.get('name', 'default_app') for app in apps] + context = { + 'project_name': project_name, + 'apps': app_names + } + return self.render_template('django/project_urls.mako', context) + + def generate_wsgi(self, project_name: str) -> str: + """生成WSGI配置""" + context = {'project_name': project_name} + return self.render_template('django/wsgi.mako', context) + + def generate_asgi(self, project_name: str) -> str: + """生成ASGI配置""" + context = {'project_name': project_name} + return self.render_template('django/asgi.mako', context) \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/base_generator.py b/hertz_studio_django_utils/code_generator/base_generator.py new file mode 100644 index 0000000..8458a28 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/base_generator.py @@ -0,0 +1,262 @@ +""" +基础代码生成器类 + +提供代码生成的基础功能和通用方法 +""" + +import os +import re +from typing import Dict, List, Any, Optional +from abc import ABC, abstractmethod +from .template_engine import TemplateEngine + + +class BaseGenerator(ABC): + """ + 基础代码生成器抽象类 + """ + + def __init__(self, template_dir: str = None): + """ + 初始化基础生成器 + + Args: + template_dir: 模板目录路径 + """ + self.template_vars = {} + self.template_engine = TemplateEngine(template_dir) + + def render_template(self, template_name: str, context: Dict[str, Any] = None) -> str: + """ + 渲染模板 + + Args: + template_name: 模板文件名 + context: 模板上下文变量 + + Returns: + str: 渲染后的代码字符串 + """ + if context is None: + context = {} + + # 合并模板变量和上下文 + merged_context = {**self.template_vars, **context} + + return self.template_engine.render_template(template_name, merged_context) + + def create_template_context(self, **kwargs) -> Dict[str, Any]: + """ + 创建模板上下文 + + Args: + **kwargs: 上下文变量 + + Returns: + Dict[str, Any]: 模板上下文 + """ + context = {**self.template_vars, **kwargs} + + # 添加常用的辅助函数到上下文 + context.update({ + 'snake_to_camel': self.snake_to_camel, + 'camel_to_snake': self.camel_to_snake, + 'format_field_name': self.format_field_name, + 'format_class_name': self.format_class_name, + 'format_verbose_name': self.format_verbose_name, + 'get_django_field_type': self.get_django_field_type, + }) + + return context + + @abstractmethod + def generate(self, **kwargs) -> str: + """ + 生成代码的抽象方法 + + Returns: + str: 生成的代码字符串 + """ + pass + + def set_template_var(self, key: str, value: Any) -> None: + """ + 设置模板变量 + + Args: + key: 变量名 + value: 变量值 + """ + self.template_vars[key] = value + + def get_template_var(self, key: str, default: Any = None) -> Any: + """ + 获取模板变量 + + Args: + key: 变量名 + default: 默认值 + + Returns: + Any: 变量值 + """ + return self.template_vars.get(key, default) + + def snake_to_camel(self, snake_str: str) -> str: + """ + 将蛇形命名转换为驼峰命名 + + Args: + snake_str: 蛇形命名字符串 + + Returns: + str: 驼峰命名字符串 + """ + components = snake_str.split('_') + return ''.join(word.capitalize() for word in components) + + def camel_to_snake(self, camel_str: str) -> str: + """ + 将驼峰命名转换为蛇形命名 + + Args: + camel_str: 驼峰命名字符串 + + Returns: + str: 蛇形命名字符串 + """ + s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str) + return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower() + + def format_field_name(self, field_name: str) -> str: + """ + 格式化字段名称 + + Args: + field_name: 原始字段名 + + Returns: + str: 格式化后的字段名 + """ + return field_name.lower().replace(' ', '_').replace('-', '_') + + def format_class_name(self, name: str) -> str: + """ + 格式化类名 + + Args: + name: 原始名称 + + Returns: + str: 格式化后的类名 + """ + return self.snake_to_camel(self.format_field_name(name)) + + def format_verbose_name(self, field_name: str) -> str: + """ + 格式化verbose_name + + Args: + field_name: 字段名 + + Returns: + str: 格式化后的verbose_name + """ + return field_name.replace('_', ' ').title() + + def generate_imports(self, imports: List[str]) -> str: + """ + 生成导入语句 + + Args: + imports: 导入列表 + + Returns: + str: 导入语句字符串 + """ + if not imports: + return '' + + return '\n'.join(imports) + '\n\n' + + def indent_code(self, code: str, indent_level: int = 1) -> str: + """ + 为代码添加缩进 + + Args: + code: 代码字符串 + indent_level: 缩进级别 + + Returns: + str: 缩进后的代码 + """ + indent = ' ' * indent_level + lines = code.split('\n') + return '\n'.join(indent + line if line.strip() else line for line in lines) + + def write_to_file(self, file_path: str, content: str) -> bool: + """ + 将内容写入文件 + + Args: + file_path: 文件路径 + content: 文件内容 + + Returns: + bool: 是否写入成功 + """ + try: + # 确保目录存在 + os.makedirs(os.path.dirname(file_path), exist_ok=True) + + with open(file_path, 'w', encoding='utf-8') as f: + f.write(content) + return True + except Exception as e: + print(f"写入文件失败: {e}") + return False + + def validate_field_config(self, field_config: Dict[str, Any]) -> bool: + """ + 验证字段配置 + + Args: + field_config: 字段配置字典 + + Returns: + bool: 配置是否有效 + """ + required_keys = ['name', 'type'] + return all(key in field_config for key in required_keys) + + def get_django_field_type(self, field_type: str) -> str: + """ + 获取Django字段类型 + + Args: + field_type: 字段类型 + + Returns: + str: Django字段类型 + """ + field_mapping = { + 'string': 'CharField', + 'text': 'TextField', + 'integer': 'IntegerField', + 'float': 'FloatField', + 'decimal': 'DecimalField', + 'boolean': 'BooleanField', + 'date': 'DateField', + 'datetime': 'DateTimeField', + 'time': 'TimeField', + 'email': 'EmailField', + 'url': 'URLField', + 'file': 'FileField', + 'image': 'ImageField', + 'json': 'JSONField', + 'uuid': 'UUIDField', + 'foreign_key': 'ForeignKey', + 'many_to_many': 'ManyToManyField', + 'one_to_one': 'OneToOneField' + } + return field_mapping.get(field_type.lower(), 'CharField') \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/README.md b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/README.md new file mode 100644 index 0000000..8ad7a0a --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/README.md @@ -0,0 +1,401 @@ +# Hertz Server Django 主项目配置 + +## 📋 项目概述 + +Hertz Server Django 是一个基于 Django 和 Django REST Framework 构建的现代化后端服务框架，提供认证授权、验证码、工具类等核心功能模块。主项目配置模块负责整个项目的全局配置、路由管理和基础设置。 + +## ✨ 核心特性 + +- **模块化架构**: 采用微服务架构设计，各功能模块独立开发部署 +- **RESTful API**: 基于DRF构建的标准REST API接口 +- **OpenAPI 3.0文档**: 自动生成的API文档，支持Swagger UI和ReDoc +- **多数据库支持**: 支持SQLite和MySQL，可配置Redis作为缓存和会话存储 +- **跨域支持**: 内置CORS跨域请求处理 +- **WebSocket支持**: 基于Channels的实时通信能力 +- **环境配置**: 使用python-decouple进行环境变量管理 + +## 📁 项目结构 + +``` +hertz_server_django/ # 项目根目录 +├── hertz_server_django/ # 主项目配置模块 +│ ├── __init__.py # 包初始化文件 +│ ├── settings.py # 项目全局配置 +│ ├── urls.py # 主URL路由配置 +│ ├── asgi.py # ASGI应用配置 +│ ├── wsgi.py # WSGI应用配置 +│ └── views.py # 根视图函数 +├── hertz_demo/ # 演示模块 +├── hertz_studio_django_captcha/ # 验证码模块 +├── hertz_studio_django_auth/ # 认证授权模块 +├── hertz_studio_django_utils/ # 工具类模块 +├── manage.py # Django管理脚本 +├── requirements.txt # 项目依赖 +├── .env # 环境变量配置 +└── data/ # 数据目录（SQLite数据库等） +``` + +## ⚙️ 核心配置文件 + +### settings.py - 项目全局配置 + +#### 基础配置 +```python +# 项目根目录 +BASE_DIR = Path(__file__).resolve().parent.parent + +# 安全密钥（从环境变量读取） +SECRET_KEY = config('SECRET_KEY', default='django-insecure-...') + +# 调试模式 +DEBUG = config('DEBUG', default=True, cast=bool) + +# 允许的主机 +ALLOWED_HOSTS = config('ALLOWED_HOSTS', default='localhost,127.0.0.1') +``` + +#### 应用配置 +```python +INSTALLED_APPS = [ + # Django核心应用 + 'django.contrib.auth', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.messages', + 'django.contrib.staticfiles', + + # 第三方应用 + 'rest_framework', # Django REST Framework + 'corsheaders', # CORS跨域支持 + 'channels', # WebSocket支持 + 'drf_spectacular', # OpenAPI文档生成 + + # 本地应用模块 + 'hertz_demo', # 演示模块 + 'hertz_studio_django_captcha', # 验证码模块 + 'hertz_studio_django_auth', # 认证授权模块 +] +``` + +#### 数据库配置 +```python +# 数据库切换配置 +USE_REDIS_AS_DB = config('USE_REDIS_AS_DB', default=True, cast=bool) + +if USE_REDIS_AS_DB: + # 开发环境使用SQLite + DATABASES = { + 'default': { + 'ENGINE': 'django.db.backends.sqlite3', + 'NAME': BASE_DIR / 'data/db.sqlite3', + } + } +else: + # 生产环境使用MySQL + DATABASES = { + 'default': { + 'ENGINE': 'django.db.backends.mysql', + 'NAME': config('DB_NAME', default='hertz_server'), + 'USER': config('DB_USER', default='root'), + 'PASSWORD': config('DB_PASSWORD', default='root'), + 'HOST': config('DB_HOST', default='localhost'), + 'PORT': config('DB_PORT', default='3306'), + 'OPTIONS': {'charset': 'utf8mb4'}, + } + } +``` + +#### Redis缓存配置 +```python +CACHES = { + 'default': { + 'BACKEND': 'django_redis.cache.RedisCache', + 'LOCATION': config('REDIS_URL', default='redis://127.0.0.1:6379/0'), + 'OPTIONS': { + 'CLIENT_CLASS': 'django_redis.client.DefaultClient', + } + } +} +``` + +#### DRF配置 +```python +REST_FRAMEWORK = { + 'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema', + 'DEFAULT_AUTHENTICATION_CLASSES': [], + 'DEFAULT_PERMISSION_CLASSES': [ + 'rest_framework.permissions.AllowAny', + ], + 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination', + 'PAGE_SIZE': 20, + 'DEFAULT_RENDERER_CLASSES': [ + 'rest_framework.renderers.JSONRenderer', + 'rest_framework.renderers.BrowsableAPIRenderer', + ], +} +``` + +#### OpenAPI文档配置 +```python +SPECTACULAR_SETTINGS = { + 'TITLE': 'Hertz Server API', + 'DESCRIPTION': 'API documentation for Hertz Server Django project', + 'VERSION': '1.0.0', + 'SERVE_INCLUDE_SCHEMA': False, + 'COMPONENT_SPLIT_REQUEST': True, + 'SCHEMA_PATH_PREFIX': '/api/', +} +``` + +### urls.py - 主路由配置 + +```python +from django.urls import path, include +from drf_spectacular.views import SpectacularAPIView, SpectacularRedocView, SpectacularSwaggerView +from . import views + +urlpatterns = [ + # 首页路由 + path('', views.index, name='index'), + + # Hertz Captcha路由 + path('api/captcha/', include('hertz_studio_django_captcha.urls')), + + # Hertz Auth路由 + path('api/', include('hertz_studio_django_auth.urls')), + + # Demo应用路由 + path('', include('hertz_demo.urls')), + + # API文档 + path('api/docs/', SpectacularSwaggerView.as_view(url_name='schema'), name='swagger-ui'), + path('api/redoc/', SpectacularRedocView.as_view(url_name='schema'), name='redoc'), + path('api/schema/', SpectacularAPIView.as_view(), name='schema'), +] +``` + +## 🚀 快速开始 + +### 1. 环境准备 + +```bash +# 创建虚拟环境 +python -m venv venv + +# 激活虚拟环境 +# Windows: +venv\Scripts\activate +# Linux/Mac: +source venv/bin/activate + +# 安装依赖 +pip install -r requirements.txt +``` + +### 2. 环境配置 + +创建 `.env` 文件： + +```ini +# 基础配置 +DEBUG=True +SECRET_KEY=your-secret-key-here +ALLOWED_HOSTS=localhost,127.0.0.1 + +# 数据库配置 +USE_REDIS_AS_DB=True +REDIS_URL=redis://127.0.0.1:6379/0 + +# MySQL配置（如果USE_REDIS_AS_DB=False） +DB_NAME=hertz_server +DB_USER=root +DB_PASSWORD=root +DB_HOST=localhost +DB_PORT=3306 +``` + +### 3. 数据库初始化 + +```bash +# 创建数据库迁移 +python manage.py makemigrations + +# 应用数据库迁移 +python manage.py migrate + +# 创建超级用户（可选） +python manage.py createsuperuser +``` + +### 4. 启动开发服务器 + +```bash +# 启动Django开发服务器 +python manage.py runserver + +# 访问应用 +# 首页: http://localhost:8000/ +# API文档: http://localhost:8000/api/docs/ +# 演示页面: http://localhost:8000/demo/captcha/ +``` + +## 🔧 配置详解 + +### 环境变量管理 + +项目使用 `python-decouple` 进行环境变量管理，支持： +- 从 `.env` 文件读取配置 +- 类型转换和默认值设置 +- 开发和生产环境分离 + +### 数据库配置策略 + +**开发环境**: 使用SQLite + Redis缓存 +- 快速启动和开发测试 +- 数据存储在SQLite文件 +- 会话和缓存使用Redis + +**生产环境**: 使用MySQL + Redis缓存 +- 高性能数据库支持 +- 数据持久化存储 +- Redis用于缓存和会话 + +### 中间件配置 + +```python +MIDDLEWARE = [ + 'corsheaders.middleware.CorsMiddleware', # CORS处理 + 'django.middleware.security.SecurityMiddleware', # 安全中间件 + 'django.contrib.sessions.middleware.SessionMiddleware', # 会话管理 + 'django.middleware.common.CommonMiddleware', # 通用处理 + 'django.middleware.csrf.CsrfViewMiddleware', # CSRF保护 + 'django.contrib.auth.middleware.AuthenticationMiddleware', # 认证 + 'hertz_studio_django_auth.utils.middleware.AuthMiddleware', # 自定义认证 + 'django.contrib.messages.middleware.MessageMiddleware', # 消息框架 + 'django.middleware.clickjacking.XFrameOptionsMiddleware', # 点击劫持保护 +] +``` + +## 🌐 API文档访问 + +项目提供完整的OpenAPI 3.0文档： + +- **Swagger UI**: http://localhost:8000/api/docs/ +- **ReDoc**: http://localhost:8000/api/redoc/ +- **Schema JSON**: http://localhost:8000/api/schema/ + +## 🚢 部署配置 + +### 生产环境部署 + +1. **环境变量配置**: +```ini +DEBUG=False +SECRET_KEY=your-production-secret-key +ALLOWED_HOSTS=your-domain.com,api.your-domain.com +USE_REDIS_AS_DB=False +``` + +2. **静态文件收集**: +```bash +python manage.py collectstatic +``` + +3. **WSGI部署**: +```python +# 使用Gunicorn + Nginx +# gunicorn hertz_server_django.wsgi:application +``` + +4. **ASGI部署**: +```python +# 使用Daphne + Nginx +# daphne hertz_server_django.asgi:application +``` + +## 🔒 安全配置 + +### 生产环境安全设置 + +```python +# 强制HTTPS +SECURE_SSL_REDIRECT = True +SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') + +# CSRF保护 +CSRF_COOKIE_SECURE = True +CSRF_COOKIE_HTTPONLY = True + +# 会话安全 +SESSION_COOKIE_SECURE = True +SESSION_COOKIE_HTTPONLY = True + +# 安全头部 +SECURE_BROWSER_XSS_FILTER = True +SECURE_CONTENT_TYPE_NOSNIFF = True +X_FRAME_OPTIONS = 'DENY' +``` + +## 📊 性能优化 + +### 缓存策略 + +```python +# 数据库查询缓存 +from django.core.cache import cache + +# 使用缓存 +cache.set('key', 'value', timeout=300) +value = cache.get('key') +``` + +### 数据库优化 + +```python +# 使用select_related减少查询 +users = User.objects.select_related('profile').filter(is_active=True) + +# 使用prefetch_related优化多对多关系 +users = User.objects.prefetch_related('groups', 'permissions') +``` + +## 🐛 故障排除 + +### 常见问题 + +1. **Redis连接失败**: 检查Redis服务是否启动，配置是否正确 +2. **数据库迁移错误**: 删除数据库文件重新迁移，或检查MySQL连接 +3. **静态文件404**: 运行 `python manage.py collectstatic` +4. **CORS问题**: 检查CORS配置和中间件顺序 + +### 日志配置 + +```python +# settings.py 中添加日志配置 +LOGGING = { + 'version': 1, + 'disable_existing_loggers': False, + 'handlers': { + 'console': { + 'class': 'logging.StreamHandler', + }, + }, + 'root': { + 'handlers': ['console'], + 'level': 'INFO', + }, +} +``` + +## 🔗 相关链接 + +- [🎮 演示模块](../hertz_demo/README.md) - 功能演示和测试页面 +- [🔐 认证授权模块](../hertz_studio_django_auth/README.md) - 用户管理和权限控制 +- [📸 验证码模块](../hertz_studio_django_captcha/README.md) - 验证码生成和验证 +- [🛠️ 工具类模块](../hertz_studio_django_utils/README.md) - 加密、邮件和验证工具 +- [🐍 Django文档](https://docs.djangoproject.com/) - Django官方文档 +- [🔌 DRF文档](https://www.django-rest-framework.org/) - Django REST Framework文档 + +--- + +💡 **提示**: 此配置模块是整个项目的核心，负责协调各功能模块的协同工作。生产部署前请务必检查所有安全配置。 \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/__init__.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/asgi.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/asgi.py new file mode 100644 index 0000000..fb05dfc --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/asgi.py @@ -0,0 +1,35 @@ +""" +ASGI config for hertz_server_django project. + +It exposes the ASGI callable as a module-level variable named ``application``. + +For more information on this file, see +https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/ +""" + +import os +from django.core.asgi import get_asgi_application +from channels.routing import ProtocolTypeRouter, URLRouter +from channels.auth import AuthMiddlewareStack +from channels.security.websocket import AllowedHostsOriginValidator + +from hertz_demo import routing + +os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'hertz_server_django.settings') + +# Initialize Django ASGI application early to ensure the AppRegistry +# is populated before importing code that may import ORM models. +django_asgi_app = get_asgi_application() + +# Import websocket routing + +application = ProtocolTypeRouter({ + "http": django_asgi_app, + "websocket": AllowedHostsOriginValidator( + AuthMiddlewareStack( + URLRouter( + routing.websocket_urlpatterns + ) + ) + ), +}) diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/settings.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/settings.py new file mode 100644 index 0000000..83f18d7 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/settings.py @@ -0,0 +1,335 @@ +""" +Django settings for hertz_server_django project. + +Generated by 'django-admin startproject' using Django 5.2.6. + +For more information on this file, see +https://docs.djangoproject.com/en/5.2/topics/settings/ + +For the full list of settings and their values, see +https://docs.djangoproject.com/en/5.2/ref/settings/ +""" + +import os +from pathlib import Path +from decouple import config + +# 修复DRF的ip_address_validators函数 +def fix_drf_ip_validators(): + """ + 修复DRF的ip_address_validators函数返回值问题 + """ + try: + from rest_framework import fields + + # 保存原始函数 + original_ip_address_validators = fields.ip_address_validators + + def fixed_ip_address_validators(protocol, unpack_ipv4): + """ + 修复后的ip_address_validators函数，确保返回两个值 + """ + validators = original_ip_address_validators(protocol, unpack_ipv4) + # 如果只返回了validators，添加默认的error_message + if isinstance(validators, list): + return validators, 'Enter a valid IP address.' + else: + # 如果已经返回了两个值，直接返回 + return validators + + # 应用猴子补丁 + fields.ip_address_validators = fixed_ip_address_validators + + except ImportError: + # 如果DRF未安装，忽略错误 + pass + +# 应用修复 +fix_drf_ip_validators() + +# Build paths inside the project like this: BASE_DIR / 'subdir'. +BASE_DIR = Path(__file__).resolve().parent.parent + + +# Quick-start development settings - unsuitable for production +# See https://docs.djangoproject.com/en/5.2/howto/deployment/checklist/ + +# SECURITY WARNING: keep the secret key used in production secret! +SECRET_KEY = config('SECRET_KEY', default='django-insecure-0a1bx*8!97l^4z#ml#ufn_*9ut*)zlso$*k-g^h&(2=p@^51md') + +# SECURITY WARNING: don't run with debug turned on in production! +DEBUG = config('DEBUG', default=True, cast=bool) + +ALLOWED_HOSTS = config('ALLOWED_HOSTS', default='localhost,127.0.0.1', cast=lambda v: [s.strip() for s in v.split(',')]) + +# Database switch configuration +USE_REDIS_AS_DB = config('USE_REDIS_AS_DB', default=True, cast=bool) + +# Application definition + +INSTALLED_APPS = [ + 'django.contrib.admin', + 'django.contrib.auth', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.messages', + 'django.contrib.staticfiles', + + # Third party apps + 'rest_framework', + 'corsheaders', + 'channels', + 'drf_spectacular', + + # Local apps + 'hertz_demo', + 'hertz_studio_django_captcha', + 'hertz_studio_django_auth', # 权限管理系统 + 'hertz_studio_django_notice', # 通知公告模块 + 'hertz_studio_django_ai', + 'hertz_studio_django_system_monitor', # 系统监测模块 + 'hertz_studio_django_log', # 日志管理模块 + 'hertz_studio_django_wiki', # 知识管理模块 + +] + +MIDDLEWARE = [ + 'corsheaders.middleware.CorsMiddleware', + 'django.middleware.security.SecurityMiddleware', + 'django.contrib.sessions.middleware.SessionMiddleware', + 'django.middleware.common.CommonMiddleware', + 'django.middleware.csrf.CsrfViewMiddleware', + 'django.contrib.auth.middleware.AuthenticationMiddleware', + 'hertz_studio_django_auth.utils.middleware.AuthMiddleware', # 权限认证中间件 + 'django.contrib.messages.middleware.MessageMiddleware', + 'django.middleware.clickjacking.XFrameOptionsMiddleware', +] + +ROOT_URLCONF = 'hertz_server_django.urls' + +TEMPLATES = [ + { + 'BACKEND': 'django.template.backends.django.DjangoTemplates', + 'DIRS': [BASE_DIR / 'templates'] + , + 'APP_DIRS': True, + 'OPTIONS': { + 'context_processors': [ + 'django.template.context_processors.request', + 'django.contrib.auth.context_processors.auth', + 'django.contrib.messages.context_processors.messages', + ], + }, + }, +] + +WSGI_APPLICATION = 'hertz_server_django.wsgi.application' + + +# Database +# https://docs.djangoproject.com/en/5.2/ref/settings/#databases + +if USE_REDIS_AS_DB: + # Redis as primary database (for caching and session storage) + DATABASES = { + 'default': { + 'ENGINE': 'django.db.backends.sqlite3', + 'NAME': BASE_DIR / 'data/db.sqlite3', + } + } + + # Use Redis for sessions + SESSION_ENGINE = 'django.contrib.sessions.backends.cache' + SESSION_CACHE_ALIAS = 'default' + +else: + # MySQL database configuration + DATABASES = { + 'default': { + 'ENGINE': 'django.db.backends.mysql', + 'NAME': config('DB_NAME', default='hertz_server'), + 'USER': config('DB_USER', default='root'), + 'PASSWORD': config('DB_PASSWORD', default='root'), + 'HOST': config('DB_HOST', default='localhost'), + 'PORT': config('DB_PORT', default='3306'), + 'OPTIONS': { + 'charset': 'utf8mb4', + }, + } + } + +# Redis +CACHES = { + 'default': { + 'BACKEND': 'django_redis.cache.RedisCache', + 'LOCATION': config('REDIS_URL', default='redis://127.0.0.1:6379/0'), + 'OPTIONS': { + 'CLIENT_CLASS': 'django_redis.client.DefaultClient', + } + } +} + + +# Password validation +# https://docs.djangoproject.com/en/5.2/ref/settings/#auth-password-validators + +AUTH_PASSWORD_VALIDATORS = [ + { + 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', + }, + { + 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', + }, + { + 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', + }, + { + 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', + }, +] + + +# Internationalization +# https://docs.djangoproject.com/en/5.2/topics/i18n/ + +LANGUAGE_CODE = 'en-us' + +TIME_ZONE = 'UTC' + +USE_I18N = True + +USE_TZ = True + + +# Static files (CSS, JavaScript, Images) +# https://docs.djangoproject.com/en/5.2/howto/static-files/ + +STATIC_URL = 'static/' +STATICFILES_DIRS = [ + BASE_DIR / 'static', +] + +# Media files (User uploaded files) +MEDIA_URL = '/media/' +MEDIA_ROOT = BASE_DIR / 'media' + +# Default primary key field type +# https://docs.djangoproject.com/en/5.2/ref/settings/#default-auto-field + +DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField' + +# Django REST Framework configuration +# 使用自定义AuthMiddleware进行认证，不使用DRF的认证和权限系统 +REST_FRAMEWORK = { + 'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema', + 'DEFAULT_AUTHENTICATION_CLASSES': [], # 不使用DRF认证类 + 'DEFAULT_PERMISSION_CLASSES': [ + 'rest_framework.permissions.AllowAny', # 所有接口默认允许访问，由AuthMiddleware控制权限 + ], + 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination', + 'PAGE_SIZE': 20, + 'DEFAULT_RENDERER_CLASSES': [ + 'rest_framework.renderers.JSONRenderer', + 'rest_framework.renderers.BrowsableAPIRenderer', + ], +} + +# Spectacular (OpenAPI 3.0) configuration +SPECTACULAR_SETTINGS = { + 'TITLE': 'Hertz Server API', + 'DESCRIPTION': 'API documentation for Hertz Server Django project', + 'VERSION': '1.0.0', + 'SERVE_INCLUDE_SCHEMA': False, + 'COMPONENT_SPLIT_REQUEST': True, + 'SCHEMA_PATH_PREFIX': '/api/', +} + +# CORS configuration +CORS_ALLOWED_ORIGINS = config( + 'CORS_ALLOWED_ORIGINS', + default='http://localhost:3000,http://127.0.0.1:3000', + cast=lambda v: [s.strip() for s in v.split(',')] +) + +CORS_ALLOW_CREDENTIALS = True + +CORS_ALLOW_ALL_ORIGINS = config('CORS_ALLOW_ALL_ORIGINS', default=False, cast=bool) + +# Captcha settings +CAPTCHA_IMAGE_SIZE = ( + config('CAPTCHA_IMAGE_SIZE_WIDTH', default=120, cast=int), + config('CAPTCHA_IMAGE_SIZE_HEIGHT', default=50, cast=int) +) +CAPTCHA_LENGTH = config('CAPTCHA_LENGTH', default=4, cast=int) +CAPTCHA_TIMEOUT = config('CAPTCHA_TIMEOUT', default=5, cast=int) # minutes +CAPTCHA_FONT_SIZE = config('CAPTCHA_FONT_SIZE', default=40, cast=int) +CAPTCHA_BACKGROUND_COLOR = config('CAPTCHA_BACKGROUND_COLOR', default='#ffffff') +CAPTCHA_FOREGROUND_COLOR = config('CAPTCHA_FOREGROUND_COLOR', default='#000000') +# 验证码词典文件路径 +CAPTCHA_WORDS_DICTIONARY = str(BASE_DIR / 'captcha_words.txt') +# 验证码挑战函数配置 +CAPTCHA_CHALLENGE_FUNCT = 'captcha.helpers.random_char_challenge' # 默认使用随机字符 +# 数学验证码配置 +CAPTCHA_MATH_CHALLENGE_OPERATOR = '+-*' +# 验证码噪声和过滤器 +CAPTCHA_NOISE_FUNCTIONS = ( + 'captcha.helpers.noise_arcs', + 'captcha.helpers.noise_dots', +) +CAPTCHA_FILTER_FUNCTIONS = ( + 'captcha.helpers.post_smooth', +) + +# Email configuration +EMAIL_BACKEND = config('EMAIL_BACKEND', default='django.core.mail.backends.smtp.EmailBackend') +EMAIL_HOST = config('EMAIL_HOST', default='smtp.qq.com') +EMAIL_PORT = config('EMAIL_PORT', default=465, cast=int) +EMAIL_USE_SSL = config('EMAIL_USE_SSL', default=True, cast=bool) +EMAIL_USE_TLS = config('EMAIL_USE_TLS', default=False, cast=bool) +EMAIL_HOST_USER = config('EMAIL_HOST_USER', default='563161210@qq.com') +EMAIL_HOST_PASSWORD = config('EMAIL_HOST_PASSWORD', default='') +DEFAULT_FROM_EMAIL = config('DEFAULT_FROM_EMAIL', default='563161210@qq.com') + +# Channels configuration for WebSocket support +ASGI_APPLICATION = 'hertz_server_django.asgi.application' + +# Channel layers configuration +CHANNEL_LAYERS = { + 'default': { + 'BACKEND': 'channels_redis.core.RedisChannelLayer', + 'CONFIG': { + "hosts": [config('REDIS_URL', default='redis://127.0.0.1:6379/2')], + }, + }, +} + +# 自定义用户模型 +AUTH_USER_MODEL = 'hertz_studio_django_auth.HertzUser' + +# JWT配置 +JWT_SECRET_KEY = config('JWT_SECRET_KEY', default=SECRET_KEY) +JWT_ALGORITHM = 'HS256' +JWT_ACCESS_TOKEN_LIFETIME = config('JWT_ACCESS_TOKEN_LIFETIME', default=60 * 60 * 24, cast=int) # 24小时 +JWT_REFRESH_TOKEN_LIFETIME = config('JWT_REFRESH_TOKEN_LIFETIME', default=60 * 60 * 24 * 7, cast=int) # 7天 + +# 权限系统配置 +HERTZ_AUTH_SETTINGS = { + 'SUPER_ADMIN_PERMISSIONS': ['*'], # 超级管理员拥有所有权限 + 'DEFAULT_PERMISSIONS': [], # 默认权限 +} + +# AuthMiddleware配置 - 不需要登录验证的URL模式（支持正则表达式） +NO_AUTH_PATTERNS = config( + 'NO_AUTH_PATTERNS', + default=r'^/api/auth/login/?$,^/api/auth/register/?$,^/api/auth/email/code/?$,^/api/auth/send-email-code/?$,^/api/auth/password/reset/?$,^/api/captcha/.*$,^/api/docs/.*$,^/api/redoc/.*$,^/api/schema/.*$,^/admin/.*$,^/static/.*$,^/media/.*$,^/demo/.*$,^/websocket/.*$,^/api/system/.*$', + cast=lambda v: [s.strip() for s in v.split(',')] +) + +# 密码加密配置 +PASSWORD_HASHERS = [ + 'hertz_studio_django_utils.crypto.MD5PasswordHasher', # 使用MD5加密 + 'django.contrib.auth.hashers.PBKDF2PasswordHasher', + 'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher', + 'django.contrib.auth.hashers.Argon2PasswordHasher', + 'django.contrib.auth.hashers.BCryptSHA256PasswordHasher', +] diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/urls.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/urls.py new file mode 100644 index 0000000..ae143a3 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/urls.py @@ -0,0 +1,62 @@ +""" +URL configuration for hertz_server_django project. + +The `urlpatterns` list routes URLs to views. For more information please see: + https://docs.djangoproject.com/en/5.2/topics/http/urls/ +Examples: +Function views + 1. Add an import: from my_app import views + 2. Add a URL to urlpatterns: path('', views.home, name='home') +Class-based views + 1. Add an import: from other_app.views import Home + 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') +Including another URLconf + 1. Import the include() function: from django.urls import include, path + 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) +""" +from django.urls import path, include +from django.conf import settings +from django.conf.urls.static import static +from drf_spectacular.views import SpectacularAPIView, SpectacularRedocView, SpectacularSwaggerView +from . import views + +urlpatterns = [ + # 首页路由 + path('', views.index, name='index'), + + # Hertz Captcha routes + path('api/captcha/', include('hertz_studio_django_captcha.urls')), + + # Hertz Auth routes + path('api/', include('hertz_studio_django_auth.urls')), + + # Demo app routes + path('', include('hertz_demo.urls')), + + # Hertz AI routes + path('api/ai/', include('hertz_studio_django_ai.urls')), + + # Hertz System Monitor routes + path('api/system/', include('hertz_studio_django_system_monitor.urls')), + + # Hertz System Notification routes + path('api/notice/', include('hertz_studio_django_notice.urls')), + + # Hertz Log routes + path('api/log/', include('hertz_studio_django_log.urls')), + + # Hertz Wiki routes + path('api/wiki/', include('hertz_studio_django_wiki.urls')), + + + + # OpenAPI documentation + path('api/docs/', SpectacularSwaggerView.as_view(url_name='schema'), name='swagger-ui'), + path('api/redoc/', SpectacularRedocView.as_view(url_name='schema'), name='redoc'), + path('api/schema/', SpectacularAPIView.as_view(), name='schema'), +] + +# 在开发环境下提供媒体文件服务 +if settings.DEBUG: + urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) + urlpatterns += static(settings.STATIC_URL, document_root=settings.STATICFILES_DIRS[0]) diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/views.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/views.py new file mode 100644 index 0000000..5d1f7e8 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/views.py @@ -0,0 +1,13 @@ +from django.contrib.auth.models import Permission +from django.shortcuts import render + +from hertz_studio_django_auth.utils.decorators import no_login_required + + +@no_login_required +def index(request): + """ + 系统首页视图 + 展示系统的基础介绍和功能特性 + """ + return render(request, 'index.html') \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/copy/hertz_server_django/wsgi.py b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/wsgi.py new file mode 100644 index 0000000..1e9fdf9 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/copy/hertz_server_django/wsgi.py @@ -0,0 +1,16 @@ +""" +WSGI config for hertz_server_django project. + +It exposes the WSGI callable as a module-level variable named ``application``. + +For more information on this file, see +https://docs.djangoproject.com/en/5.2/howto/deployment/wsgi/ +""" + +import os + +from django.core.wsgi import get_wsgi_application + +os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'hertz_server_django.settings') + +application = get_wsgi_application() diff --git a/hertz_studio_django_utils/code_generator/django_code_generator.py b/hertz_studio_django_utils/code_generator/django_code_generator.py new file mode 100644 index 0000000..dea34f3 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/django_code_generator.py @@ -0,0 +1,687 @@ +""" +Django代码生成器主入口类 + +该模块提供了一个统一的Django代码生成器入口， +整合了模型、序列化器、视图、URL路由等所有生成器功能。 + +使用示例: + generator = DjangoCodeGenerator() + + # 生成完整的CRUD模块 + generator.generate_full_module( + model_name='User', + fields=[ + {'name': 'username', 'type': 'CharField', 'max_length': 150}, + {'name': 'email', 'type': 'EmailField'}, + {'name': 'phone', 'type': 'CharField', 'max_length': 20} + ], + output_dir='./generated_code' + ) +""" + +import os +from typing import Dict, List, Optional, Any +from .base_generator import BaseGenerator +from .model_generator import ModelGenerator +from .serializer_generator import SerializerGenerator +from .view_generator import ViewGenerator +from .url_generator import URLGenerator +from .yaml_parser import YAMLParser + + +class DjangoCodeGenerator(BaseGenerator): + """Django代码生成器主入口类""" + + def __init__(self): + """初始化Django代码生成器""" + super().__init__() + self.model_generator = ModelGenerator() + self.serializer_generator = SerializerGenerator() + self.view_generator = ViewGenerator() + self.url_generator = URLGenerator() + self.yaml_parser = YAMLParser() + + def generate(self, **kwargs) -> str: + """ + 实现抽象方法generate + + Returns: + str: 生成的代码字符串 + """ + return "Django代码生成器" + + def generate_full_module( + self, + model_name: str, + fields: List[Dict[str, Any]], + output_dir: str = './generated_code', + app_name: str = None, + operations: List[str] = None, + permissions: List[str] = None, + validators: Optional[Dict[str, str]] = None, + table_name: str = None, + verbose_name: str = None, + ordering: List[str] = None + ) -> Dict[str, str]: + """ + 生成完整的Django模块代码（模型、序列化器、视图、URL） + + Args: + model_name: 模型名称 + fields: 字段配置列表 + output_dir: 输出目录 + app_name: 应用名称 + operations: 支持的操作列表 + permissions: 权限装饰器列表 + validators: 字段验证器映射 + table_name: 数据库表名 + verbose_name: 模型显示名称 + ordering: 默认排序字段 + + Returns: + Dict[str, str]: 生成的代码文件映射 + """ + if operations is None: + operations = ['create', 'read', 'update', 'delete', 'list'] + + if not app_name: + app_name = self.to_snake_case(model_name) + + generated_files = {} + + # 创建输出目录 + os.makedirs(output_dir, exist_ok=True) + + # 生成模型代码 + model_code = self.generate_model( + model_name=model_name, + fields=fields, + table_name=table_name, + verbose_name=verbose_name, + ordering=ordering + ) + generated_files['models.py'] = model_code + + # 生成序列化器代码 + serializer_code = self.generate_serializers( + model_name=model_name, + fields=[field['name'] for field in fields], + validators=validators + ) + generated_files['serializers.py'] = serializer_code + + # 生成视图代码 + view_code = self.generate_views( + model_name=model_name, + operations=operations, + permissions=permissions + ) + generated_files['views.py'] = view_code + + # 生成URL路由代码 + url_code = self.generate_urls( + model_name=model_name, + operations=operations, + app_name=app_name + ) + generated_files['urls.py'] = url_code + + # 写入文件 + for filename, code in generated_files.items(): + file_path = os.path.join(output_dir, filename) + self.write_to_file(file_path, code) + + return generated_files + + def generate_model( + self, + model_name: str, + fields: List[Dict[str, Any]], + table_name: str = None, + verbose_name: str = None, + ordering: List[str] = None, + status_choices: List[tuple] = None + ) -> str: + """ + 生成模型代码 + + Args: + model_name: 模型名称 + fields: 字段配置列表 + table_name: 数据库表名 + verbose_name: 模型显示名称 + ordering: 默认排序字段 + status_choices: 状态选择项 + + Returns: + str: 生成的模型代码 + """ + return self.model_generator.generate( + model_name=model_name, + fields=fields, + table_name=table_name, + verbose_name=verbose_name, + ordering=ordering, + status_choices=status_choices + ) + + def generate_serializers( + self, + model_name: str, + fields: List[str], + validators: Optional[Dict[str, str]] = None, + create_fields: Optional[List[str]] = None, + update_fields: Optional[List[str]] = None, + list_fields: Optional[List[str]] = None + ) -> str: + """ + 生成序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + validators: 字段验证器映射 + create_fields: 创建时使用的字段 + update_fields: 更新时使用的字段 + list_fields: 列表时显示的字段 + + Returns: + str: 生成的序列化器代码 + """ + return self.serializer_generator.generate( + model_name=model_name, + fields=fields, + create_fields=create_fields, + update_fields=update_fields, + list_fields=list_fields, + validators=validators + ) + + def generate_views( + self, + model_name: str, + operations: List[str] = None, + permissions: List[str] = None, + filters: Optional[List[str]] = None, + ordering: Optional[List[str]] = None, + search_fields: Optional[List[str]] = None, + pagination: bool = True + ) -> str: + """ + 生成视图代码 + + Args: + model_name: 模型名称 + operations: 支持的操作列表 + permissions: 权限装饰器列表 + filters: 过滤字段列表 + ordering: 排序字段列表 + search_fields: 搜索字段列表 + pagination: 是否启用分页 + + Returns: + str: 生成的视图代码 + """ + if operations is None: + operations = ['create', 'read', 'update', 'delete', 'list'] + + return self.view_generator.generate( + model_name=model_name, + operations=operations, + permissions=permissions, + filters=filters, + ordering=ordering, + search_fields=search_fields, + pagination=pagination + ) + + def generate_urls( + self, + model_name: str, + operations: List[str] = None, + prefix: str = '', + app_name: str = '', + namespace: str = '' + ) -> str: + """ + 生成URL路由代码 + + Args: + model_name: 模型名称 + operations: 支持的操作列表 + prefix: URL前缀 + app_name: 应用名称 + namespace: 命名空间 + + Returns: + str: 生成的URL路由代码 + """ + if operations is None: + operations = ['create', 'read', 'update', 'delete', 'list'] + + return self.url_generator.generate( + model_name=model_name, + operations=operations, + prefix=prefix, + app_name=app_name, + namespace=namespace + ) + + def generate_api_module( + self, + model_name: str, + fields: List[Dict[str, Any]], + output_dir: str = './generated_api', + version: str = 'v1', + permissions: List[str] = None + ) -> Dict[str, str]: + """ + 生成RESTful API模块代码 + + Args: + model_name: 模型名称 + fields: 字段配置列表 + output_dir: 输出目录 + version: API版本 + permissions: 权限装饰器列表 + + Returns: + Dict[str, str]: 生成的代码文件映射 + """ + generated_files = {} + + # 创建输出目录 + os.makedirs(output_dir, exist_ok=True) + + # 生成模型代码 + model_code = self.generate_model( + model_name=model_name, + fields=fields + ) + generated_files['models.py'] = model_code + + # 生成序列化器代码 + serializer_code = self.generate_serializers( + model_name=model_name, + fields=[field['name'] for field in fields] + ) + generated_files['serializers.py'] = serializer_code + + # 生成API视图代码 + view_code = self.generate_views( + model_name=model_name, + permissions=permissions + ) + generated_files['views.py'] = view_code + + # 生成API URL路由代码 + url_code = self.url_generator.generate_api_urls( + model_name=model_name, + version=version + ) + generated_files['urls.py'] = url_code + + # 写入文件 + for filename, code in generated_files.items(): + file_path = os.path.join(output_dir, filename) + self.write_to_file(file_path, code) + + return generated_files + + def generate_nested_module( + self, + parent_model: str, + child_model: str, + parent_fields: List[Dict[str, Any]], + child_fields: List[Dict[str, Any]], + output_dir: str = './generated_nested', + relationship_type: str = 'foreign_key' + ) -> Dict[str, str]: + """ + 生成嵌套资源模块代码 + + Args: + parent_model: 父模型名称 + child_model: 子模型名称 + parent_fields: 父模型字段配置 + child_fields: 子模型字段配置 + output_dir: 输出目录 + relationship_type: 关系类型 ('foreign_key', 'one_to_one', 'many_to_many') + + Returns: + Dict[str, str]: 生成的代码文件映射 + """ + generated_files = {} + + # 创建输出目录 + os.makedirs(output_dir, exist_ok=True) + + # 在子模型字段中添加父模型关系 + if relationship_type == 'foreign_key': + child_fields.append({ + 'name': self.to_snake_case(parent_model), + 'type': 'ForeignKey', + 'to': parent_model, + 'on_delete': 'models.CASCADE', + 'verbose_name': f'{parent_model}', + 'help_text': f'关联的{parent_model}' + }) + + # 生成父模型代码 + parent_model_code = self.generate_model( + model_name=parent_model, + fields=parent_fields + ) + generated_files[f'{self.to_snake_case(parent_model)}_models.py'] = parent_model_code + + # 生成子模型代码 + child_model_code = self.generate_model( + model_name=child_model, + fields=child_fields + ) + generated_files[f'{self.to_snake_case(child_model)}_models.py'] = child_model_code + + # 生成嵌套URL路由 + nested_url_code = self.url_generator.generate_nested_urls( + parent_model=parent_model, + child_model=child_model + ) + generated_files['nested_urls.py'] = nested_url_code + + # 写入文件 + for filename, code in generated_files.items(): + file_path = os.path.join(output_dir, filename) + self.write_to_file(file_path, code) + + return generated_files + + def generate_app_structure( + self, + app_name: str, + models: List[Dict[str, Any]], + output_dir: str = None + ) -> Dict[str, str]: + """ + 生成完整的Django应用结构 + + Args: + app_name: 应用名称 + models: 模型配置列表 + output_dir: 输出目录 + + Returns: + Dict[str, str]: 生成的代码文件映射 + """ + if not output_dir: + output_dir = f'./generated_{app_name}' + + generated_files = {} + + # 创建应用目录结构 + app_dir = os.path.join(output_dir, app_name) + os.makedirs(app_dir, exist_ok=True) + os.makedirs(os.path.join(app_dir, 'serializers'), exist_ok=True) + os.makedirs(os.path.join(app_dir, 'views'), exist_ok=True) + os.makedirs(os.path.join(app_dir, 'urls'), exist_ok=True) + + # 生成应用配置文件 + apps_code = self._generate_apps_config(app_name) + generated_files['apps.py'] = apps_code + + # 生成__init__.py文件 + generated_files['__init__.py'] = '' + generated_files['serializers/__init__.py'] = '' + generated_files['views/__init__.py'] = '' + generated_files['urls/__init__.py'] = '' + + # 为每个模型生成代码 + all_models_code = [] + all_serializers_code = [] + all_views_code = [] + all_urls_code = [] + + for model_config in models: + model_name = model_config['name'] + fields = model_config['fields'] + + # 生成模型代码 + model_code = self.generate_model( + model_name=model_name, + fields=fields, + verbose_name=model_config.get('verbose_name', model_name), + table_name=model_config.get('table_name'), + ordering=model_config.get('ordering', ['-created_at']) + ) + all_models_code.append(model_code) + + # 生成序列化器代码 + serializer_code = self.generate_serializers( + model_name=model_name, + fields=[field['name'] for field in fields], + validators=model_config.get('validators', {}) + ) + all_serializers_code.append(serializer_code) + + # 生成视图代码 + view_code = self.generate_views( + model_name=model_name, + operations=model_config.get('operations', ['create', 'read', 'update', 'delete', 'list']), + permissions=model_config.get('permissions', []) + ) + all_views_code.append(view_code) + + # 生成URL代码 + url_code = self.generate_urls( + model_name=model_name, + app_name=app_name, + operations=model_config.get('operations', ['create', 'read', 'update', 'delete', 'list']) + ) + all_urls_code.append(url_code) + + # 合并所有代码 + generated_files['models.py'] = '\n\n'.join(all_models_code) + generated_files['serializers.py'] = '\n\n'.join(all_serializers_code) + generated_files['views.py'] = '\n\n'.join(all_views_code) + generated_files['urls.py'] = '\n\n'.join(all_urls_code) + + # 写入文件 + for filename, code in generated_files.items(): + file_path = os.path.join(app_dir, filename) + # 确保目录存在 + os.makedirs(os.path.dirname(file_path), exist_ok=True) + self.write_to_file(file_path, code) + + return generated_files + + def _generate_apps_config(self, app_name: str) -> str: + """生成Django应用配置代码""" + class_name = self.snake_to_camel(app_name) + 'Config' + + code_parts = [ + 'from django.apps import AppConfig', + '', + f'class {class_name}(AppConfig):', + ' """', + f' {app_name}应用配置', + ' """', + " default_auto_field = 'django.db.models.BigAutoField'", + f" name = '{app_name}'", + f" verbose_name = '{app_name.title()}'" + ] + + return '\n'.join(code_parts) + + def generate_from_yaml_file(self, yaml_file_path: str) -> Dict[str, str]: + """ + 从YAML配置文件生成Django应用代码 + + Args: + yaml_file_path: YAML配置文件路径 + + Returns: + Dict[str, str]: 生成的文件路径和内容映射 + + Raises: + FileNotFoundError: 当YAML文件不存在时 + ValueError: 当配置验证失败时 + """ + # 解析YAML配置 + config = self.yaml_parser.parse_yaml_file(yaml_file_path) + + # 从配置生成代码 + return self.generate_from_yaml_config(config) + + def generate_from_yaml_config(self, config: Dict[str, Any]) -> Dict[str, str]: + """ + 从YAML配置字典生成Django应用代码 + + Args: + config: YAML配置字典 + + Returns: + Dict[str, str]: 生成的文件路径和内容映射 + """ + app_name = config['app_name'] + models = config['models'] + output_dir = config.get('output_dir', '.') # 默认输出到当前目录 + + all_generated_files = {} + + # 为每个模型生成代码 + if isinstance(models, dict): + # 如果models是字典格式 + models_items = models.items() + else: + # 如果models是列表格式，转换为字典格式 + models_items = [(model['name'], model) for model in models] + + for model_name, model_config in models_items: + # 获取模型字段配置 + fields = model_config.get('fields', []) + operations = model_config.get('operations', ['create', 'get', 'update', 'delete', 'list']) + permissions = model_config.get('permissions', {}) + api_config = model_config.get('api', {}) + + # 转换字段格式 + processed_fields = {} + for field in fields: + field_name = field['name'] + processed_fields[field_name] = { + 'type': field['type'], + 'verbose_name': field.get('verbose_name', field_name), + 'help_text': field.get('help_text', f'{field_name}字段'), + } + + # 添加其他字段属性 + for attr in ['max_length', 'null', 'blank', 'default', 'unique', 'choices']: + if attr in field: + processed_fields[field_name][attr] = field[attr] + + # 创建应用目录 + app_dir = os.path.join(output_dir, app_name) + print(f"📁 创建应用目录: {app_dir}") + os.makedirs(app_dir, exist_ok=True) + + # 创建migrations子目录 + migrations_dir = os.path.join(app_dir, 'migrations') + print(f"📁 创建子目录: {migrations_dir}") + os.makedirs(migrations_dir, exist_ok=True) + # 创建migrations/__init__.py文件 + migrations_init_file = os.path.join(migrations_dir, '__init__.py') + with open(migrations_init_file, 'w', encoding='utf-8') as f: + f.write('') + all_generated_files[migrations_init_file] = '' + + # 生成模型代码 + print(f"📝 生成模型代码...") + model_code = self.model_generator.generate(model_name, processed_fields) + model_file = os.path.join(app_dir, 'models.py') + with open(model_file, 'w', encoding='utf-8') as f: + f.write(model_code) + all_generated_files[model_file] = model_code + print(f"✅ 已生成: {model_file}") + + # 生成序列化器代码 + print(f"📝 生成序列化器代码...") + serializer_code = self.serializer_generator.generate(model_name, processed_fields) + serializer_file = os.path.join(app_dir, 'serializers.py') + with open(serializer_file, 'w', encoding='utf-8') as f: + f.write(serializer_code) + all_generated_files[serializer_file] = serializer_code + print(f"✅ 已生成: {serializer_file}") + + # 生成视图代码 + print(f"📝 生成视图代码...") + view_code = self.view_generator.generate(model_name, operations) + view_file = os.path.join(app_dir, 'views.py') + with open(view_file, 'w', encoding='utf-8') as f: + f.write(view_code) + all_generated_files[view_file] = view_code + print(f"✅ 已生成: {view_file}") + + # 生成URL代码 + print(f"📝 生成URL代码...") + url_code = self.url_generator.generate(model_name, operations) + url_file = os.path.join(app_dir, 'urls.py') + with open(url_file, 'w', encoding='utf-8') as f: + f.write(url_code) + all_generated_files[url_file] = url_code + print(f"✅ 已生成: {url_file}") + + # 生成应用配置文件 + print(f"📝 生成应用配置文件...") + apps_code = self._generate_apps_config(app_name) + apps_file = os.path.join(app_dir, 'apps.py') + with open(apps_file, 'w', encoding='utf-8') as f: + f.write(apps_code) + all_generated_files[apps_file] = apps_code + print(f"✅ 已生成: {apps_file}") + + # 生成__init__.py文件 + init_file = os.path.join(app_dir, '__init__.py') + with open(init_file, 'w', encoding='utf-8') as f: + f.write('') + all_generated_files[init_file] = '' + print(f"✅ 已生成: {init_file}") + + # 生成migrations的__init__.py + migrations_init = os.path.join(app_dir, 'migrations', '__init__.py') + with open(migrations_init, 'w', encoding='utf-8') as f: + f.write('') + all_generated_files[migrations_init] = '' + print(f"✅ 已生成: {migrations_init}") + + print(f"\n🎉 Django应用 '{app_name}' 生成完成!") + print(f"📁 输出目录: {os.path.abspath(output_dir)}") + print(f"📄 生成文件数量: {len(all_generated_files)}") + + return all_generated_files + + def generate_yaml_template(self, output_path: str = 'app_template.yaml') -> str: + """ + 生成YAML配置文件模板 + + Args: + output_path: 输出文件路径 + + Returns: + str: 生成的模板内容 + """ + return self.yaml_parser.generate_yaml_template(output_path) + + def validate_yaml_config(self, yaml_file_path: str) -> bool: + """ + 验证YAML配置文件格式 + + Args: + yaml_file_path: YAML配置文件路径 + + Returns: + bool: 验证是否通过 + """ + try: + self.yaml_parser.parse_yaml_file(yaml_file_path) + return True + except Exception as e: + print(f"YAML配置验证失败: {e}") + return False \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/menu_generator.py b/hertz_studio_django_utils/code_generator/menu_generator.py new file mode 100644 index 0000000..b746ad3 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/menu_generator.py @@ -0,0 +1,434 @@ +#!/usr/bin/env python +""" +菜单权限生成器 +用于自动生成菜单配置和权限同步功能 +""" + +from typing import Dict, List, Optional, Any +import os +from pathlib import Path + + +class MenuGenerator: + """ + 菜单权限生成器 + + 用于根据模型和操作自动生成菜单配置，包括： + 1. 菜单项配置 + 2. 权限配置 + 3. 菜单层级结构 + """ + + def __init__(self): + """初始化菜单生成器""" + self.menu_types = { + 'directory': 1, # 目录 + 'menu': 2, # 菜单 + 'button': 3 # 按钮 + } + + # 标准操作映射 - 与视图生成器保持一致 + self.operation_mapping = { + 'list': {'name': '查询', 'permission': 'list'}, + 'create': {'name': '新增', 'permission': 'add'}, + 'retrieve': {'name': '详情', 'permission': 'list'}, # 统一使用list权限 + 'update': {'name': '修改', 'permission': 'edit'}, + 'delete': {'name': '删除', 'permission': 'remove'}, + 'export': {'name': '导出', 'permission': 'export'}, + 'import': {'name': '导入', 'permission': 'import'}, + } + + def generate_menu_config( + self, + module_name: str, + model_name: str, + operations: List[str], + parent_code: Optional[str] = None, + menu_prefix: str = 'system', + sort_order: int = 1, + icon: Optional[str] = None, + component_path: Optional[str] = None + ) -> List[Dict[str, Any]]: + """ + 生成菜单配置 + + Args: + module_name: 模块名称（中文） + model_name: 模型名称（英文，snake_case） + operations: 操作列表 + parent_code: 父级菜单代码 + menu_prefix: 菜单前缀 + sort_order: 排序 + icon: 图标 + component_path: 组件路径 + + Returns: + List[Dict]: 菜单配置列表 + """ + menus = [] + + # 生成主菜单 + main_menu_code = f"{menu_prefix}:{model_name}" + main_menu = { + 'menu_name': module_name, + 'menu_code': main_menu_code, + 'menu_type': self.menu_types['menu'], + 'path': f"/{menu_prefix}/{model_name}", + 'component': component_path or f"{menu_prefix}/{model_name}/index", + 'icon': icon or model_name, + 'permission': f"{main_menu_code}:list", + 'sort_order': sort_order, + 'parent_code': parent_code + } + menus.append(main_menu) + + # 生成操作按钮 + for i, operation in enumerate(operations, 1): + if operation in self.operation_mapping: + op_config = self.operation_mapping[operation] + button_menu = { + 'menu_name': f"{module_name}{op_config['name']}", + 'menu_code': f"{main_menu_code}:{op_config['permission']}", + 'menu_type': self.menu_types['button'], + 'permission': f"{main_menu_code}:{op_config['permission']}", + 'sort_order': i, + 'parent_code': main_menu_code + } + menus.append(button_menu) + + return menus + + def generate_directory_config( + self, + directory_name: str, + directory_code: str, + path: str, + icon: str = 'folder', + sort_order: int = 1 + ) -> Dict[str, Any]: + """ + 生成目录配置 + + Args: + directory_name: 目录名称 + directory_code: 目录代码 + path: 路径 + icon: 图标 + sort_order: 排序 + + Returns: + Dict: 目录配置 + """ + return { + 'menu_name': directory_name, + 'menu_code': directory_code, + 'menu_type': self.menu_types['directory'], + 'path': path, + 'icon': icon, + 'sort_order': sort_order, + 'parent_code': None + } + + def generate_custom_menu_config( + self, + menu_name: str, + menu_code: str, + operations: List[Dict[str, str]], + parent_code: Optional[str] = None, + path: Optional[str] = None, + component: Optional[str] = None, + icon: Optional[str] = None, + sort_order: int = 1 + ) -> List[Dict[str, Any]]: + """ + 生成自定义菜单配置 + + Args: + menu_name: 菜单名称 + menu_code: 菜单代码 + operations: 自定义操作列表 [{'name': '操作名', 'permission': '权限码'}] + parent_code: 父级菜单代码 + path: 路径 + component: 组件 + icon: 图标 + sort_order: 排序 + + Returns: + List[Dict]: 菜单配置列表 + """ + menus = [] + + # 生成主菜单 + main_menu = { + 'menu_name': menu_name, + 'menu_code': menu_code, + 'menu_type': self.menu_types['menu'], + 'sort_order': sort_order, + 'parent_code': parent_code + } + + if path: + main_menu['path'] = path + if component: + main_menu['component'] = component + if icon: + main_menu['icon'] = icon + if operations: + main_menu['permission'] = f"{menu_code}:{operations[0]['permission']}" + + menus.append(main_menu) + + # 生成操作按钮 + for i, operation in enumerate(operations, 1): + button_menu = { + 'menu_name': f"{menu_name}{operation['name']}", + 'menu_code': f"{menu_code}:{operation['permission']}", + 'menu_type': self.menu_types['button'], + 'permission': f"{menu_code}:{operation['permission']}", + 'sort_order': i, + 'parent_code': menu_code + } + menus.append(button_menu) + + return menus + + def update_menus_config_file( + self, + new_menus: List[Dict[str, Any]], + config_file_path: str = None + ) -> bool: + """ + 更新菜单配置文件 + + Args: + new_menus: 新的菜单配置列表 + config_file_path: 配置文件路径 + + Returns: + bool: 更新是否成功 + """ + if not config_file_path: + config_file_path = os.path.join( + Path(__file__).parent.parent, + 'config', + 'menus_config.py' + ) + + try: + # 读取现有配置 + with open(config_file_path, 'r', encoding='utf-8') as f: + content = f.read() + + # 查找现有菜单列表的结束位置 + import_end = content.find(']') + if import_end == -1: + return False + + # 生成新菜单配置代码 + new_menu_code = self._generate_menu_code(new_menus) + + # 在现有菜单列表末尾添加新菜单（在最后一个 ] 之前） + updated_content = ( + content[:import_end] + + ',\n\n # 新增菜单配置\n' + + new_menu_code + + content[import_end:] + ) + + # 写入更新后的配置 + with open(config_file_path, 'w', encoding='utf-8') as f: + f.write(updated_content) + + return True + + except Exception as e: + print(f"更新菜单配置文件失败: {e}") + return False + + def _generate_menu_code(self, menus: List[Dict[str, Any]]) -> str: + """ + 生成菜单配置代码 + + Args: + menus: 菜单配置列表 + + Returns: + str: 菜单配置代码 + """ + code_lines = [] + + for menu in menus: + code_lines.append(" {") + for key, value in menu.items(): + if isinstance(value, str): + code_lines.append(f" '{key}': '{value}',") + elif value is None: + code_lines.append(f" '{key}': None,") + else: + code_lines.append(f" '{key}': {value},") + code_lines.append(" }") + + return '\n'.join(code_lines) + + def generate_permission_sync_code( + self, + menu_configs: List[Dict[str, Any]] + ) -> str: + """ + 生成权限同步代码 + + Args: + menu_configs: 菜单配置列表 + + Returns: + str: 权限同步代码 + """ + sync_code = ''' +def sync_new_menus(): + """ + 同步新增菜单到数据库 + """ + from hertz_studio_django_auth.models import HertzMenu + from django.db import transaction + + new_menus = [ +''' + + # 添加菜单配置 + sync_code += self._generate_menu_code(menu_configs) + + sync_code += ''' + ] + + print("正在同步新增菜单...") + + with transaction.atomic(): + created_menus = {} + + # 按层级创建菜单 + for menu_data in new_menus: + parent_code = menu_data.pop('parent_code', None) + parent_id = None + + if parent_code and parent_code in created_menus: + parent_id = created_menus[parent_code] + + menu, created = HertzMenu.objects.get_or_create( + menu_code=menu_data['menu_code'], + defaults={ + **menu_data, + 'parent_id': parent_id + } + ) + + created_menus[menu.menu_code] = menu + + if created: + print(f"菜单创建成功: {menu.menu_name}") + else: + print(f"菜单已存在: {menu.menu_name}") + + print("菜单同步完成") +''' + + return sync_code + + def create_menu_sync_script( + self, + menu_configs: List[Dict[str, Any]], + script_path: str = None + ) -> bool: + """ + 创建菜单同步脚本 + + Args: + menu_configs: 菜单配置列表 + script_path: 脚本路径 + + Returns: + bool: 创建是否成功 + """ + if not script_path: + script_path = os.path.join( + Path(__file__).parent.parent.parent, + 'sync_menus.py' + ) + + try: + script_content = f'''#!/usr/bin/env python +""" +菜单同步脚本 +自动生成的菜单权限同步脚本 +""" + +import os +import sys +import django + +# 添加项目路径 +project_root = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, project_root) + +# 设置Django环境 +os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'hertz_server_django.settings') +django.setup() + +{self.generate_permission_sync_code(menu_configs)} + +if __name__ == "__main__": + sync_new_menus() +''' + + with open(script_path, 'w', encoding='utf-8') as f: + f.write(script_content) + + return True + + except Exception as e: + print(f"创建菜单同步脚本失败: {e}") + return False + + +# 使用示例 +def example_usage(): + """使用示例""" + generator = MenuGenerator() + + # 生成标准CRUD菜单 + crud_menus = generator.generate_menu_config( + module_name="产品管理", + model_name="product", + operations=['list', 'create', 'update', 'delete'], + parent_code="system", + sort_order=5, + icon="product" + ) + + # 生成自定义菜单 + custom_menus = generator.generate_custom_menu_config( + menu_name="报表管理", + menu_code="system:report", + operations=[ + {'name': '查看', 'permission': 'view'}, + {'name': '导出', 'permission': 'export'}, + {'name': '打印', 'permission': 'print'} + ], + parent_code="system", + path="/system/report", + component="system/report/index", + icon="report", + sort_order=8 + ) + + # 更新配置文件 + all_menus = crud_menus + custom_menus + generator.update_menus_config_file(all_menus) + + # 创建同步脚本 + generator.create_menu_sync_script(all_menus) + + print("菜单配置生成完成") + + +if __name__ == "__main__": + example_usage() \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/model_generator.py b/hertz_studio_django_utils/code_generator/model_generator.py new file mode 100644 index 0000000..dba7965 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/model_generator.py @@ -0,0 +1,262 @@ +""" +Django模型代码生成器 + +该模块负责根据配置生成Django模型代码 +""" + +import os +from typing import Dict, List, Any, Optional +from .base_generator import BaseGenerator + + +class ModelGenerator(BaseGenerator): + """Django模型代码生成器""" + + def __init__(self): + """初始化模型生成器""" + super().__init__() + + def generate(self, model_name: str = None, fields: List[Dict[str, Any]] = None, **kwargs) -> str: + """ + 生成Django模型代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + **kwargs: 其他参数 + + Returns: + str: 生成的模型代码 + """ + # 处理参数，支持位置参数和关键字参数 + if model_name is None: + model_name = kwargs.get('model_name', 'DefaultModel') + if fields is None: + fields = kwargs.get('fields', []) + + table_name = kwargs.get('table_name') + verbose_name = kwargs.get('verbose_name') + verbose_name_plural = kwargs.get('verbose_name_plural') + ordering = kwargs.get('ordering', ['-created_at']) + status_choices = kwargs.get('status_choices', [ + ('active', '激活'), + ('inactive', '未激活'), + ('deleted', '已删除') + ]) + + # 确保verbose_name不为None + if verbose_name is None: + verbose_name = model_name + + # 确保verbose_name_plural不为None + if verbose_name_plural is None: + verbose_name_plural = verbose_name + '列表' + + # 处理字段列表，确保每个字段都有必要的属性 + processed_fields = [] + for field in fields: + if isinstance(field, dict): + # 字段已经在YAML解析器中处理过类型转换，这里不再重复处理 + processed_fields.append(field) + elif isinstance(field, str): + # 如果字段是字符串，转换为字典格式 + processed_fields.append({ + 'name': field, + 'type': 'CharField', # 直接使用Django字段类型 + 'django_field_type': 'CharField', + 'max_length': 100, + 'verbose_name': field, + 'help_text': f'{field}字段' + }) + + # 添加默认的时间戳字段（如果不存在） + has_created_at = any(field.get('name') == 'created_at' for field in processed_fields) + has_updated_at = any(field.get('name') == 'updated_at' for field in processed_fields) + + if not has_created_at: + processed_fields.append({ + 'name': 'created_at', + 'type': 'DateTimeField', + 'auto_now_add': True, + 'verbose_name': '创建时间', + 'help_text': '记录创建时间' + }) + + if not has_updated_at: + processed_fields.append({ + 'name': 'updated_at', + 'type': 'DateTimeField', + 'auto_now': True, + 'verbose_name': '更新时间', + 'help_text': '记录最后更新时间' + }) + + # 准备模板上下文 + context = { + 'model_name': model_name, + 'fields': processed_fields, + 'table_name': table_name or self.camel_to_snake(model_name), + 'verbose_name': verbose_name, + 'verbose_name_plural': verbose_name_plural, + 'ordering': ordering, + 'status_choices': status_choices, + 'has_status_field': any(field.get('name') == 'status' for field in processed_fields) + } + + # 渲染模板 + return self.render_template('django/models.mako', context) + + def generate_model_with_relationships( + self, + model_name: str, + fields: List[Dict[str, Any]], + relationships: List[Dict[str, Any]] = None, + **kwargs + ) -> str: + """ + 生成包含关系字段的模型代码 + + Args: + model_name: 模型名称 + fields: 字段配置列表 + relationships: 关系字段配置列表 + + Returns: + str: 生成的模型代码 + """ + if relationships: + # 将关系字段添加到字段列表中 + for rel in relationships: + fields.append(rel) + + return self.generate( + model_name=model_name, + fields=fields, + **kwargs + ) + + def generate_abstract_model( + self, + model_name: str, + fields: List[Dict[str, Any]], + **kwargs + ) -> str: + """ + 生成抽象模型代码 + + Args: + model_name: 模型名称 + fields: 字段配置列表 + + Returns: + str: 生成的抽象模型代码 + """ + kwargs['abstract'] = True + return self.generate( + model_name=model_name, + fields=fields, + **kwargs + ) + + def generate_proxy_model( + self, + model_name: str, + base_model: str, + **kwargs + ) -> str: + """ + 生成代理模型代码 + + Args: + model_name: 模型名称 + base_model: 基础模型名称 + + Returns: + str: 生成的代理模型代码 + """ + kwargs['proxy'] = True + kwargs['base_model'] = base_model + return self.generate( + model_name=model_name, + fields=[], + **kwargs + ) + + def validate_field_config(self, field_config: Dict[str, Any]) -> bool: + """ + 验证字段配置 + + Args: + field_config: 字段配置字典 + + Returns: + bool: 验证是否通过 + """ + required_keys = ['name', 'type'] + for key in required_keys: + if key not in field_config: + return False + + # 验证字段类型 + valid_types = { + 'CharField', 'TextField', 'IntegerField', 'FloatField', + 'DecimalField', 'BooleanField', 'DateField', 'DateTimeField', + 'EmailField', 'URLField', 'ImageField', 'FileField', + 'ForeignKey', 'ManyToManyField', 'OneToOneField', 'JSONField', + 'SlugField', 'PositiveIntegerField', 'BigIntegerField', + 'SmallIntegerField', 'UUIDField', 'TimeField' + } + + if field_config['type'] not in valid_types: + return False + + return True + + def add_timestamp_fields(self, fields: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + """ + 添加时间戳字段 + + Args: + fields: 原字段列表 + + Returns: + List[Dict[str, Any]]: 包含时间戳字段的字段列表 + """ + timestamp_fields = [ + { + 'name': 'created_at', + 'type': 'DateTimeField', + 'auto_now_add': True, + 'verbose_name': '创建时间', + 'help_text': '记录创建时间' + }, + { + 'name': 'updated_at', + 'type': 'DateTimeField', + 'auto_now': True, + 'verbose_name': '更新时间', + 'help_text': '记录最后更新时间' + } + ] + + return fields + timestamp_fields + + def add_status_field(self, fields: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + """ + 添加状态字段 + + Args: + fields: 原字段列表 + + Returns: + List[Dict[str, Any]]: 包含状态字段的字段列表 + """ + status_field = { + 'name': 'status', + 'type': 'IntegerField', + 'choices': 'StatusChoices.choices', + 'default': 'StatusChoices.ENABLED', + 'verbose_name': '状态' + } + + return fields + [status_field] \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/serializer_generator.py b/hertz_studio_django_utils/code_generator/serializer_generator.py new file mode 100644 index 0000000..bc1e9b9 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/serializer_generator.py @@ -0,0 +1,336 @@ +""" +Django序列化器代码生成器 + +该模块负责根据配置生成Django REST Framework序列化器代码 +""" + +import os +from typing import Dict, List, Any, Optional +from .base_generator import BaseGenerator + + +class SerializerGenerator(BaseGenerator): + """Django序列化器代码生成器""" + + def __init__(self): + """初始化序列化器生成器""" + super().__init__() + + def generate(self, model_name: str = None, fields: List[Any] = None, **kwargs) -> str: + """ + 生成Django序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表（可以是字符串列表或字典列表） + **kwargs: 其他参数 + + Returns: + str: 生成的序列化器代码 + """ + # 处理参数，支持位置参数和关键字参数 + if model_name is None: + model_name = kwargs.get('model_name', 'DefaultModel') + if fields is None: + fields = kwargs.get('fields', []) + + # 处理字段列表，统一转换为字典格式 + processed_fields = [] + + for field in fields: + if isinstance(field, str): + # 字符串字段转换为字典格式 + field_config = { + 'name': field, + 'type': 'CharField', + 'create': True, + 'update': True, + 'list': True, + 'required': True, + 'read_only': False + } + processed_fields.append(field_config) + elif isinstance(field, dict): + # 字典字段，确保有必要的属性 + field_config = { + 'name': field.get('name', 'unknown_field'), + 'type': field.get('type', 'CharField'), + 'create': field.get('create', True), + 'update': field.get('update', True), + 'list': field.get('list', True), + 'required': field.get('required', True), + 'read_only': field.get('read_only', False) + } + processed_fields.append(field_config) + + # 添加默认字段（如果不存在） + field_names = [f['name'] for f in processed_fields] + + if 'id' not in field_names: + processed_fields.insert(0, { + 'name': 'id', + 'type': 'IntegerField', + 'create': False, + 'update': False, + 'list': True, + 'required': False, + 'read_only': True + }) + + if 'created_at' not in field_names: + processed_fields.append({ + 'name': 'created_at', + 'type': 'DateTimeField', + 'create': False, + 'update': False, + 'list': True, + 'required': False, + 'read_only': True + }) + + if 'updated_at' not in field_names: + processed_fields.append({ + 'name': 'updated_at', + 'type': 'DateTimeField', + 'create': False, + 'update': False, + 'list': True, + 'required': False, + 'read_only': True + }) + + # 生成字段列表 + create_fields_list = [f['name'] for f in processed_fields if f.get('create', False)] + update_fields_list = [f['name'] for f in processed_fields if f.get('update', False)] + list_fields_list = [f['name'] for f in processed_fields if f.get('list', False)] + + # 准备模板上下文 + context = { + 'model_name': model_name, + 'model_name_lower': model_name.lower(), + 'fields': processed_fields, + 'create_fields_list': create_fields_list, + 'update_fields_list': update_fields_list, + 'list_fields_list': list_fields_list, + 'has_create_serializer': bool(create_fields_list), + 'has_update_serializer': bool(update_fields_list), + 'has_list_serializer': bool(list_fields_list) + } + + # 渲染模板 + return self.render_template('django/serializers.mako', context) + + def generate_crud_serializers( + self, + model_name: str, + fields: List[str], + create_fields: Optional[List[str]] = None, + update_fields: Optional[List[str]] = None, + list_fields: Optional[List[str]] = None, + validators: Optional[Dict[str, str]] = None + ) -> str: + """ + 生成CRUD序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + create_fields: 创建时使用的字段 + update_fields: 更新时使用的字段 + list_fields: 列表时显示的字段 + validators: 字段验证器映射 + + Returns: + str: 生成的序列化器代码 + """ + # 默认字段配置 + if create_fields is None: + create_fields = [f for f in fields if f not in ['id', 'created_at', 'updated_at']] + if update_fields is None: + update_fields = [f for f in fields if f not in ['id', 'created_at', 'updated_at']] + if list_fields is None: + list_fields = fields + + # 构建字段配置 + field_configs = [] + for field_name in fields: + field_config = { + 'name': field_name, + 'create': field_name in create_fields, + 'update': field_name in update_fields, + 'list': field_name in list_fields, + 'validators': validators.get(field_name, {}) if validators else {} + } + field_configs.append(field_config) + + return self.generate( + model_name=model_name, + fields=field_configs + ) + + def generate_nested_serializer( + self, + model_name: str, + fields: List[str], + nested_fields: Dict[str, Dict[str, Any]] + ) -> str: + """ + 生成嵌套序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + nested_fields: 嵌套字段配置 + + Returns: + str: 生成的嵌套序列化器代码 + """ + # 构建字段配置，包含嵌套字段信息 + field_configs = [] + for field_name in fields: + field_config = { + 'name': field_name, + 'nested': field_name in nested_fields, + 'nested_config': nested_fields.get(field_name, {}) + } + field_configs.append(field_config) + + return self.generate( + model_name=model_name, + fields=field_configs, + has_nested=True + ) + + def generate_read_only_serializer( + self, + model_name: str, + fields: List[str] + ) -> str: + """ + 生成只读序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + + Returns: + str: 生成的只读序列化器代码 + """ + field_configs = [] + for field_name in fields: + field_config = { + 'name': field_name, + 'read_only': True + } + field_configs.append(field_config) + + return self.generate( + model_name=model_name, + fields=field_configs, + read_only=True + ) + + def generate_create_serializer( + self, + model_name: str, + fields: List[str], + validators: Optional[Dict[str, str]] = None + ) -> str: + """ + 生成创建序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + validators: 字段验证器映射 + + Returns: + str: 生成的创建序列化器代码 + """ + field_configs = [] + for field_name in fields: + field_config = { + 'name': field_name, + 'validators': validators.get(field_name, {}) if validators else {} + } + field_configs.append(field_config) + + return self.generate( + model_name=model_name, + fields=field_configs, + serializer_type='create' + ) + + def generate_update_serializer( + self, + model_name: str, + fields: List[str], + validators: Optional[Dict[str, str]] = None + ) -> str: + """ + 生成更新序列化器代码 + + Args: + model_name: 模型名称 + fields: 字段列表 + validators: 字段验证器映射 + + Returns: + str: 生成的更新序列化器代码 + """ + field_configs = [] + for field_name in fields: + field_config = { + 'name': field_name, + 'validators': validators.get(field_name, {}) if validators else {} + } + field_configs.append(field_config) + + return self.generate( + model_name=model_name, + fields=field_configs, + serializer_type='update' + ) + + def add_custom_validation( + self, + serializer_code: str, + field_name: str, + validation_code: str + ) -> str: + """ + 添加自定义验证方法 + + Args: + serializer_code: 原序列化器代码 + field_name: 字段名称 + validation_code: 验证代码 + + Returns: + str: 包含自定义验证的序列化器代码 + """ + validation_method = f""" + def validate_{field_name}(self, value): + \"\"\" + 验证{field_name}字段 + \"\"\" + {validation_code} + return value +""" + + # 在类定义结束前插入验证方法 + lines = serializer_code.split('\n') + insert_index = -1 + for i, line in enumerate(lines): + if line.strip().startswith('class ') and 'Serializer' in line: + # 找到类定义结束的位置 + for j in range(i + 1, len(lines)): + if lines[j].strip() and not lines[j].startswith(' '): + insert_index = j + break + break + + if insert_index > 0: + lines.insert(insert_index, validation_method) + + return '\n'.join(lines) \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/template_engine.py b/hertz_studio_django_utils/code_generator/template_engine.py new file mode 100644 index 0000000..f6bf33e --- /dev/null +++ b/hertz_studio_django_utils/code_generator/template_engine.py @@ -0,0 +1,248 @@ +""" +模板引擎类 + +基于Mako模板引擎的代码生成模板管理器 +""" + +import os +from typing import Dict, Any, Optional +from mako.template import Template +from mako.lookup import TemplateLookup +from mako.exceptions import TemplateLookupException, CompileException + + +class TemplateEngine: + """ + 模板引擎类 + + 负责管理和渲染Mako模板 + """ + + def __init__(self, template_dir: str = None): + """ + 初始化模板引擎 + + Args: + template_dir: 模板目录路径 + """ + if template_dir is None: + # 默认模板目录 + current_dir = os.path.dirname(os.path.abspath(__file__)) + template_dir = os.path.join(current_dir, 'templates') + + self.template_dir = template_dir + self.lookup = TemplateLookup( + directories=[template_dir], + module_directory=os.path.join(template_dir, '.mako_modules'), + input_encoding='utf-8', + output_encoding='utf-8', + encoding_errors='replace' + ) + + def render_template(self, template_name: str, context: Dict[str, Any]) -> str: + """ + 渲染模板 + + Args: + template_name: 模板文件名 + context: 模板上下文变量 + + Returns: + str: 渲染后的代码字符串 + + Raises: + TemplateLookupException: 模板不存在 + CompileException: 模板编译错误 + """ + try: + template = self.lookup.get_template(template_name) + rendered = template.render(**context) + # 确保返回字符串而不是bytes + if isinstance(rendered, bytes): + return rendered.decode('utf-8') + return rendered + except TemplateLookupException as e: + raise TemplateLookupException(f"模板 '{template_name}' 不存在: {str(e)}") + except CompileException as e: + raise CompileException(f"模板 '{template_name}' 编译错误: {str(e)}") + except Exception as e: + raise Exception(f"渲染模板 '{template_name}' 时发生错误: {str(e)}") + + def render_django_model(self, context: Dict[str, Any]) -> str: + """ + 渲染Django模型模板 + + Args: + context: 模板上下文 + + Returns: + str: 生成的模型代码 + """ + return self.render_template('django/models.mako', context) + + def render_django_serializer(self, context: Dict[str, Any]) -> str: + """ + 渲染Django序列化器模板 + + Args: + context: 模板上下文 + + Returns: + str: 生成的序列化器代码 + """ + return self.render_template('django/serializers.mako', context) + + def render_django_view(self, context: Dict[str, Any]) -> str: + """ + 渲染Django视图模板 + + Args: + context: 模板上下文 + + Returns: + str: 生成的视图代码 + """ + return self.render_template('django/views.mako', context) + + def render_django_url(self, context: Dict[str, Any]) -> str: + """ + 渲染Django URL配置模板 + + Args: + context: 模板上下文 + + Returns: + str: 生成的URL配置代码 + """ + return self.render_template('django/urls.mako', context) + + def render_django_app(self, context: Dict[str, Any]) -> str: + """ + 渲染Django应用配置模板 + + Args: + context: 模板上下文 + + Returns: + str: 生成的应用配置代码 + """ + return self.render_template('django/apps.mako', context) + + def get_available_templates(self) -> list: + """ + 获取可用的模板列表 + + Returns: + list: 模板文件列表 + """ + templates = [] + for root, dirs, files in os.walk(self.template_dir): + for file in files: + if file.endswith('.mako'): + rel_path = os.path.relpath(os.path.join(root, file), self.template_dir) + templates.append(rel_path.replace('\\', '/')) + return templates + + def template_exists(self, template_name: str) -> bool: + """ + 检查模板是否存在 + + Args: + template_name: 模板名称 + + Returns: + bool: 模板是否存在 + """ + try: + self.lookup.get_template(template_name) + return True + except TemplateLookupException: + return False + + def validate_template(self, template_name: str) -> tuple: + """ + 验证模板语法 + + Args: + template_name: 模板名称 + + Returns: + tuple: (是否有效, 错误信息) + """ + try: + template = self.lookup.get_template(template_name) + # 尝试编译模板 + template.code + return True, None + except CompileException as e: + return False, f"模板编译错误: {str(e)}" + except TemplateLookupException as e: + return False, f"模板不存在: {str(e)}" + except Exception as e: + return False, f"未知错误: {str(e)}" + + def create_context(self, **kwargs) -> Dict[str, Any]: + """ + 创建模板上下文 + + Args: + **kwargs: 上下文变量 + + Returns: + Dict[str, Any]: 模板上下文 + """ + return kwargs + + def add_template_directory(self, directory: str) -> None: + """ + 添加模板目录 + + Args: + directory: 模板目录路径 + """ + if os.path.exists(directory): + self.lookup.directories.append(directory) + else: + raise FileNotFoundError(f"模板目录不存在: {directory}") + + def clear_cache(self) -> None: + """ + 清除模板缓存 + """ + self.lookup._collection.clear() + + def get_template_info(self, template_name: str) -> Dict[str, Any]: + """ + 获取模板信息 + + Args: + template_name: 模板名称 + + Returns: + Dict[str, Any]: 模板信息 + """ + try: + template = self.lookup.get_template(template_name) + template_path = template.filename + + info = { + 'name': template_name, + 'path': template_path, + 'exists': True, + 'size': os.path.getsize(template_path) if template_path else 0, + 'modified_time': os.path.getmtime(template_path) if template_path else None + } + + # 验证模板 + is_valid, error = self.validate_template(template_name) + info['valid'] = is_valid + info['error'] = error + + return info + except TemplateLookupException: + return { + 'name': template_name, + 'exists': False, + 'valid': False, + 'error': '模板不存在' + } \ No newline at end of file diff --git a/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/models.mako.py b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/models.mako.py new file mode 100644 index 0000000..10688af --- /dev/null +++ b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/models.mako.py @@ -0,0 +1,225 @@ +# -*- coding:utf-8 -*- +from mako import runtime, filters, cache +UNDEFINED = runtime.UNDEFINED +STOP_RENDERING = runtime.STOP_RENDERING +__M_dict_builtin = dict +__M_locals_builtin = locals +_magic_number = 10 +_modified_time = 1760426258.0375054 +_enable_loop = True +_template_filename = 'C:/2025.8/project/9/moban/hertz_server_django/hertz_studio_django_utils/code_generator/templates/django/models.mako' +_template_uri = 'django/models.mako' +_source_encoding = 'utf-8' +_exports = [] + + + +from datetime import datetime + + +def render_body(context,**pageargs): + __M_caller = context.caller_stack._push_frame() + try: + __M_locals = __M_dict_builtin(pageargs=pageargs) + any = context.get('any', UNDEFINED) + chr = context.get('chr', UNDEFINED) + ordering = context.get('ordering', UNDEFINED) + fields = context.get('fields', UNDEFINED) + verbose_name = context.get('verbose_name', UNDEFINED) + model_name = context.get('model_name', UNDEFINED) + str = context.get('str', UNDEFINED) + table_name = context.get('table_name', UNDEFINED) + status_choices = context.get('status_choices', UNDEFINED) + tuple = context.get('tuple', UNDEFINED) + isinstance = context.get('isinstance', UNDEFINED) + len = context.get('len', UNDEFINED) + __M_writer = context.writer() + __M_writer('"""\r\nDjango模型模板\r\n"""\r\n') + __M_writer('\r\n') + +# 导入必要的模块 + imports = [] + if any(field.get('type') == 'ForeignKey' for field in fields): + imports.append('from django.contrib.auth import get_user_model') + if any(field.get('type') in ['DateTimeField', 'DateField', 'TimeField'] for field in fields): + imports.append('from django.utils import timezone') + if any(field.get('choices') for field in fields): + imports.append('from django.core.validators import validate_email') + + # 生成状态选择项 + status_choices_code = "" + if status_choices: + choices_list = [] + for choice in status_choices: + if isinstance(choice, tuple) and len(choice) == 2: + choices_list.append(f" ('{choice[0]}', '{choice[1]}')") + else: + choices_list.append(f" ('{choice}', '{choice}')") + status_choices_code = f""" STATUS_CHOICES = [ +{',{}'.format(chr(10)).join(choices_list)}, + ]""" + + + __M_locals_builtin_stored = __M_locals_builtin() + __M_locals.update(__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ['field','choice','choices_list','imports','status_choices_code'] if __M_key in __M_locals_builtin_stored])) + __M_writer('from django.db import models\r\n') + for import_line in imports: + __M_writer(str(import_line)) + __M_writer('\r\n') + __M_writer('\r\nclass ') + __M_writer(str(model_name)) + __M_writer('(models.Model):\r\n """\r\n ') + __M_writer(str(verbose_name or model_name)) + __M_writer('模型\r\n') + if table_name: + __M_writer(' \r\n 数据表名: ') + __M_writer(str(table_name)) + __M_writer('\r\n') + __M_writer(' 创建时间: ') + __M_writer(str(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))) + __M_writer('\r\n """\r\n') + if status_choices_code: + __M_writer(str(status_choices_code)) + __M_writer('\r\n\r\n') + for field in fields: + + field_name = field['name'] + # 使用转换后的Django字段类型 + field_type = field.get('type', 'CharField') + field_options = [] + + # 处理字段选项 + if field.get('verbose_name'): + field_options.append(f"verbose_name='{field['verbose_name']}'") + if field.get('help_text'): + field_options.append(f"help_text='{field['help_text']}'") + if field.get('max_length'): + field_options.append(f"max_length={field['max_length']}") + if field.get('null'): + field_options.append(f"null={field['null']}") + if field.get('blank'): + field_options.append(f"blank={field['blank']}") + if field.get('default') is not None: + if isinstance(field['default'], str): + field_options.append(f"default='{field['default']}'") + else: + field_options.append(f"default={field['default']}") + if field.get('unique'): + field_options.append(f"unique={field['unique']}") + if field.get('db_index'): + field_options.append(f"db_index={field['db_index']}") + + # 处理特殊字段类型 + if field_type == 'ForeignKey': + if field.get('to'): + field_options.insert(0, f"'{field['to']}'") + else: + field_options.insert(0, "get_user_model()") + if field.get('on_delete'): + field_options.append(f"on_delete=models.{field['on_delete']}") + else: + field_options.append("on_delete=models.CASCADE") + elif field_type == 'ManyToManyField': + if field.get('to'): + field_options.insert(0, f"'{field['to']}'") + elif field_type == 'OneToOneField': + if field.get('to'): + field_options.insert(0, f"'{field['to']}'") + if field.get('on_delete'): + field_options.append(f"on_delete=models.{field['on_delete']}") + else: + field_options.append("on_delete=models.CASCADE") + + # 处理选择项 + if field.get('choices'): + if field_name == 'status' and status_choices: + field_options.append("choices=STATUS_CHOICES") + else: + choices_list = [] + for choice in field['choices']: + if isinstance(choice, tuple) and len(choice) == 2: + choices_list.append(f"('{choice[0]}', '{choice[1]}')") + else: + choices_list.append(f"('{choice}', '{choice}')") + field_options.append(f"choices=[{', '.join(choices_list)}]") + + # 处理特殊字段类型的额外参数 + if field_type == 'DecimalField': + if not any('max_digits' in opt for opt in field_options): + field_options.append('max_digits=10') + if not any('decimal_places' in opt for opt in field_options): + field_options.append('decimal_places=2') + elif field_type == 'DateTimeField': + if field_name == 'created_at' and not any('auto_now_add' in opt for opt in field_options): + field_options.append('auto_now_add=True') + elif field_name == 'updated_at' and not any('auto_now' in opt for opt in field_options): + field_options.append('auto_now=True') + + options_str = ', '.join(field_options) if field_options else '' + + + __M_locals_builtin_stored = __M_locals_builtin() + __M_locals.update(__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ['field_options','options_str','choice','choices_list','opt','field_name','field_type'] if __M_key in __M_locals_builtin_stored])) + __M_writer('\r\n ') + __M_writer(str(field_name)) + __M_writer(' = models.') + __M_writer(str(field_type)) + __M_writer('(') + __M_writer(str(options_str)) + __M_writer(')\r\n') + __M_writer('\r\n class Meta:\r\n') + if table_name: + __M_writer(" db_table = '") + __M_writer(str(table_name)) + __M_writer("'\r\n") + __M_writer(" verbose_name = '") + __M_writer(str(verbose_name or model_name)) + __M_writer("'\r\n verbose_name_plural = '") + __M_writer(str(verbose_name or model_name)) + __M_writer("'\r\n") + if ordering: + __M_writer(' ordering = [') + __M_writer(str(', '.join([f"'{field}'" for field in ordering]))) + __M_writer(']\r\n') + else: + __M_writer(" ordering = ['-created_at']\r\n") + __M_writer('\r\n def __str__(self):\r\n """字符串表示"""\r\n') + if fields: + __M_writer(' ') + + # 寻找合适的字段作为字符串表示 + str_field = None + for field in fields: + if field['name'] in ['name', 'title', 'username', 'email']: + str_field = field['name'] + break + if not str_field: + # 如果没有找到合适的字段，使用第一个字符串字段 + for field in fields: + if field['type'] in ['CharField', 'TextField', 'EmailField']: + str_field = field['name'] + break + if not str_field: + str_field = 'id' + + + __M_locals_builtin_stored = __M_locals_builtin() + __M_locals.update(__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ['field','str_field'] if __M_key in __M_locals_builtin_stored])) + __M_writer('\r\n return str(self.') + __M_writer(str(str_field)) + __M_writer(')\r\n') + else: + __M_writer(' return f"') + __M_writer(str(model_name)) + __M_writer('({self.id})"\r\n') + __M_writer('\r\n def save(self, *args, **kwargs):\r\n """保存方法"""\r\n super().save(*args, **kwargs)\r\n\r\n @classmethod\r\n def get_by_id(cls, obj_id):\r\n """根据ID获取对象"""\r\n try:\r\n return cls.objects.get(id=obj_id)\r\n except cls.DoesNotExist:\r\n return None') + return '' + finally: + context.caller_stack._pop_frame() + + +""" +__M_BEGIN_METADATA +{"filename": "C:/2025.8/project/9/moban/hertz_server_django/hertz_studio_django_utils/code_generator/templates/django/models.mako", "uri": "django/models.mako", "source_encoding": "utf-8", "line_map": {"16": 4, "17": 5, "18": 6, "19": 7, "20": 0, "37": 1, "38": 6, "39": 7, "40": 8, "41": 9, "42": 10, "43": 11, "44": 12, "45": 13, "46": 14, "47": 15, "48": 16, "49": 17, "50": 18, "51": 19, "52": 20, "53": 21, "54": 22, "55": 23, "56": 24, "57": 25, "58": 26, "59": 27, "60": 28, "61": 29, "62": 30, "65": 30, "66": 31, "67": 32, "68": 32, "69": 34, "70": 35, "71": 35, "72": 37, "73": 37, "74": 38, "75": 39, "76": 40, "77": 40, "78": 42, "79": 42, "80": 42, "81": 44, "82": 45, "83": 45, "84": 48, "85": 49, "86": 50, "87": 51, "88": 52, "89": 53, "90": 54, "91": 55, "92": 56, "93": 57, "94": 58, "95": 59, "96": 60, "97": 61, "98": 62, "99": 63, "100": 64, "101": 65, "102": 66, "103": 67, "104": 68, "105": 69, "106": 70, "107": 71, "108": 72, "109": 73, "110": 74, "111": 75, "112": 76, "113": 77, "114": 78, "115": 79, "116": 80, "117": 81, "118": 82, "119": 83, "120": 84, "121": 85, "122": 86, "123": 87, "124": 88, "125": 89, "126": 90, "127": 91, "128": 92, "129": 93, "130": 94, "131": 95, "132": 96, "133": 97, "134": 98, "135": 99, "136": 100, "137": 101, "138": 102, "139": 103, "140": 104, "141": 105, "142": 106, "143": 107, "144": 108, "145": 109, "146": 110, "147": 111, "148": 112, "149": 113, "150": 114, "151": 115, "152": 116, "153": 117, "154": 118, "155": 119, "156": 120, "157": 121, "158": 122, "159": 123, "160": 124, "163": 123, "164": 124, "165": 124, "166": 124, "167": 124, "168": 124, "169": 124, "170": 126, "171": 128, "172": 129, "173": 129, "174": 129, "175": 131, "176": 131, "177": 131, "178": 132, "179": 132, "180": 133, "181": 134, "182": 134, "183": 134, "184": 135, "185": 136, "186": 138, "187": 141, "188": 142, "189": 142, "190": 143, "191": 144, "192": 145, "193": 146, "194": 147, "195": 148, "196": 149, "197": 150, "198": 151, "199": 152, "200": 153, "201": 154, "202": 155, "203": 156, "204": 157, "205": 158, "208": 157, "209": 158, "210": 158, "211": 159, "212": 160, "213": 160, "214": 160, "215": 162, "221": 215}} +__M_END_METADATA +""" diff --git a/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/serializers.mako.py b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/serializers.mako.py new file mode 100644 index 0000000..38e5534 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/serializers.mako.py @@ -0,0 +1,173 @@ +# -*- coding:utf-8 -*- +from mako import runtime, filters, cache +UNDEFINED = runtime.UNDEFINED +STOP_RENDERING = runtime.STOP_RENDERING +__M_dict_builtin = dict +__M_locals_builtin = locals +_magic_number = 10 +_modified_time = 1760424185.601884 +_enable_loop = True +_template_filename = 'C:/2025.8/project/9/moban/hertz_server_django/hertz_studio_django_utils/code_generator/templates/django/serializers.mako' +_template_uri = 'django/serializers.mako' +_source_encoding = 'utf-8' +_exports = [] + + + +from datetime import datetime + + +def render_body(context,**pageargs): + __M_caller = context.caller_stack._push_frame() + try: + __M_locals = __M_dict_builtin(pageargs=pageargs) + model_name = context.get('model_name', UNDEFINED) + fields = context.get('fields', UNDEFINED) + __M_writer = context.writer() + __M_writer('"""\nDjango序列化器模板\n"""\n') + __M_writer('\n') + +# 生成字段列表 + all_fields = [] + create_fields_list = [] + update_fields_list = [] + list_fields_list = [] + + # 处理字段列表 + for field in fields: + field_name = field['name'] + all_fields.append(field_name) + + # 排除自动生成的字段 + if field_name not in ['id', 'created_at', 'updated_at']: + create_fields_list.append(field_name) + update_fields_list.append(field_name) + + list_fields_list.append(field_name) + + # 添加默认字段 + if 'id' not in all_fields: + all_fields.insert(0, 'id') + if 'created_at' not in all_fields: + all_fields.append('created_at') + if 'updated_at' not in all_fields: + all_fields.append('updated_at') + + # 如果没有指定列表字段，使用所有字段 + if not list_fields_list: + list_fields_list = all_fields + + + __M_locals_builtin_stored = __M_locals_builtin() + __M_locals.update(__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ['all_fields','field_name','update_fields_list','field','create_fields_list','list_fields_list'] if __M_key in __M_locals_builtin_stored])) + __M_writer('\nfrom rest_framework import serializers\nfrom .models import ') + __M_writer(str(model_name)) + __M_writer('\n\n\nclass ') + __M_writer(str(model_name)) + __M_writer('Serializer(serializers.ModelSerializer):\n """\n ') + __M_writer(str(model_name)) + __M_writer('序列化器\n \n 用于') + __M_writer(str(model_name)) + __M_writer('模型的序列化和反序列化\n 创建时间: ') + __M_writer(str(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))) + __M_writer('\n """\n \n class Meta:\n model = ') + __M_writer(str(model_name)) + __M_writer('\n fields = [') + __M_writer(str(', '.join([f"'{field}'" for field in all_fields]))) + __M_writer("]\n read_only_fields = ['id', 'created_at', 'updated_at']\n \n") + for field in fields: + pass + if field.get('validators'): + __M_writer(' def validate_') + __M_writer(str(field['name'])) + __M_writer('(self, value):\n """\n 验证') + __M_writer(str(field['name'])) + __M_writer('字段\n """\n') + for validator_name, validator_rule in field['validators'].items(): + __M_writer(' # ') + __M_writer(str(validator_name)) + __M_writer('验证: ') + __M_writer(str(validator_rule)) + __M_writer('\n') + __M_writer(' return value\n \n') + __M_writer(' def validate(self, attrs):\n """\n 对象级别的验证\n """\n # 在这里添加跨字段验证逻辑\n return attrs\n \n def create(self, validated_data):\n """\n 创建') + __M_writer(str(model_name)) + __M_writer('实例\n """\n return ') + __M_writer(str(model_name)) + __M_writer('.objects.create(**validated_data)\n \n def update(self, instance, validated_data):\n """\n 更新') + __M_writer(str(model_name)) + __M_writer('实例\n """\n for attr, value in validated_data.items():\n setattr(instance, attr, value)\n instance.save()\n return instance\n\n\nclass ') + __M_writer(str(model_name)) + __M_writer('CreateSerializer(serializers.ModelSerializer):\n """\n ') + __M_writer(str(model_name)) + __M_writer('创建序列化器\n \n 用于创建') + __M_writer(str(model_name)) + __M_writer('实例\n """\n \n class Meta:\n model = ') + __M_writer(str(model_name)) + __M_writer('\n fields = [') + __M_writer(str(', '.join([f"'{field}'" for field in create_fields_list]))) + __M_writer(']\n \n') + for field in fields: + pass + if field['name'] in create_fields_list and field.get('validators'): + __M_writer(' def validate_') + __M_writer(str(field['name'])) + __M_writer('(self, value):\n """\n 验证') + __M_writer(str(field['name'])) + __M_writer('字段\n """\n') + for validator_name, validator_rule in field['validators'].items(): + __M_writer(' # ') + __M_writer(str(validator_name)) + __M_writer('验证: ') + __M_writer(str(validator_rule)) + __M_writer('\n') + __M_writer(' return value\n \n') + __M_writer('\n\nclass ') + __M_writer(str(model_name)) + __M_writer('UpdateSerializer(serializers.ModelSerializer):\n """\n ') + __M_writer(str(model_name)) + __M_writer('更新序列化器\n \n 用于更新') + __M_writer(str(model_name)) + __M_writer('实例\n """\n \n class Meta:\n model = ') + __M_writer(str(model_name)) + __M_writer('\n fields = [') + __M_writer(str(', '.join([f"'{field}'" for field in update_fields_list]))) + __M_writer(']\n \n') + for field in fields: + pass + if field['name'] in update_fields_list and field.get('validators'): + __M_writer(' def validate_') + __M_writer(str(field['name'])) + __M_writer('(self, value):\n """\n 验证') + __M_writer(str(field['name'])) + __M_writer('字段\n """\n') + for validator_name, validator_rule in field['validators'].items(): + __M_writer(' # ') + __M_writer(str(validator_name)) + __M_writer('验证: ') + __M_writer(str(validator_rule)) + __M_writer('\n') + __M_writer(' return value\n \n') + __M_writer('\n\nclass ') + __M_writer(str(model_name)) + __M_writer('ListSerializer(serializers.ModelSerializer):\n """\n ') + __M_writer(str(model_name)) + __M_writer('列表序列化器\n \n 用于列表显示') + __M_writer(str(model_name)) + __M_writer('实例\n """\n \n class Meta:\n model = ') + __M_writer(str(model_name)) + __M_writer('\n fields = [') + __M_writer(str(', '.join([f"'{field}'" for field in list_fields_list]))) + __M_writer(']\n read_only_fields = [') + __M_writer(str(', '.join([f"'{field}'" for field in list_fields_list]))) + __M_writer(']') + return '' + finally: + context.caller_stack._pop_frame() + + +""" +__M_BEGIN_METADATA +{"filename": "C:/2025.8/project/9/moban/hertz_server_django/hertz_studio_django_utils/code_generator/templates/django/serializers.mako", "uri": "django/serializers.mako", "source_encoding": "utf-8", "line_map": {"16": 4, "17": 5, "18": 6, "19": 7, "20": 0, "27": 1, "28": 6, "29": 7, "30": 8, "31": 9, "32": 10, "33": 11, "34": 12, "35": 13, "36": 14, "37": 15, "38": 16, "39": 17, "40": 18, "41": 19, "42": 20, "43": 21, "44": 22, "45": 23, "46": 24, "47": 25, "48": 26, "49": 27, "50": 28, "51": 29, "52": 30, "53": 31, "54": 32, "55": 33, "56": 34, "57": 35, "58": 36, "59": 37, "60": 38, "63": 37, "64": 39, "65": 39, "66": 42, "67": 42, "68": 44, "69": 44, "70": 46, "71": 46, "72": 47, "73": 47, "74": 51, "75": 51, "76": 52, "77": 52, "78": 55, "80": 56, "81": 57, "82": 57, "83": 57, "84": 59, "85": 59, "86": 61, "87": 62, "88": 62, "89": 62, "90": 62, "91": 62, "92": 64, "93": 68, "94": 77, "95": 77, "96": 79, "97": 79, "98": 83, "99": 83, "100": 91, "101": 91, "102": 93, "103": 93, "104": 95, "105": 95, "106": 99, "107": 99, "108": 100, "109": 100, "110": 102, "112": 103, "113": 104, "114": 104, "115": 104, "116": 106, "117": 106, "118": 108, "119": 109, "120": 109, "121": 109, "122": 109, "123": 109, "124": 111, "125": 115, "126": 117, "127": 117, "128": 119, "129": 119, "130": 121, "131": 121, "132": 125, "133": 125, "134": 126, "135": 126, "136": 128, "138": 129, "139": 130, "140": 130, "141": 130, "142": 132, "143": 132, "144": 134, "145": 135, "146": 135, "147": 135, "148": 135, "149": 135, "150": 137, "151": 141, "152": 143, "153": 143, "154": 145, "155": 145, "156": 147, "157": 147, "158": 151, "159": 151, "160": 152, "161": 152, "162": 153, "163": 153, "169": 163}} +__M_END_METADATA +""" diff --git a/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/urls.mako.py b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/urls.mako.py new file mode 100644 index 0000000..d0386e5 --- /dev/null +++ b/hertz_studio_django_utils/code_generator/templates/.mako_modules/django/urls.mako.py @@ -0,0 +1,129 @@ +# -*- coding:utf-8 -*- +from mako import runtime, filters, cache +UNDEFINED = runtime.UNDEFINED +STOP_RENDERING = runtime.STOP_RENDERING +__M_dict_builtin = dict +__M_locals_builtin = locals +_magic_number = 10 +_modified_time = 1760498624.445131 +_enable_loop = True +_template_filename = 'C:/2025.8/project/9/moban/hertz_server_django/hertz_studio_django_utils/code_generator/templates/django/urls.mako' +_template_uri = 'django/urls.mako' +_source_encoding = 'utf-8' +_exports = [] + + + +from datetime import datetime + + +def render_body(context,**pageargs): + __M_caller = context.caller_stack._push_frame() + try: + __M_locals = __M_dict_builtin(pageargs=pageargs) + app_name = context.get('app_name', UNDEFINED) + operations = context.get('operations', UNDEFINED) + model_name = context.get('model_name', UNDEFINED) + prefix = context.get('prefix', UNDEFINED) + __M_writer = context.writer() + __M_writer('"""\nDjango URL配置模板\n"""\n') + __M_writer('\n') + +# 生成操作列表 + operations_list = operations or ['create', 'get', 'update', 'delete', 'list'] + snake_model_name = model_name.lower() + resource_name = snake_model_name + + + __M_locals_builtin_stored = __M_locals_builtin() + __M_locals.update(__M_dict_builtin([(__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ['operations_list','resource_name','snake_model_name'] if __M_key in __M_locals_builtin_stored])) + __M_writer("\nfrom django.urls import path\nfrom . import views\n\napp_name = '") + __M_writer(str(app_name or snake_model_name)) + __M_writer("'\n\nurlpatterns = [\n") + if 'create' in operations_list: + __M_writer(' # 创建') + __M_writer(str(model_name)) + __M_writer("\n path('', views.create_") + __M_writer(str(snake_model_name)) + __M_writer(", name='create_") + __M_writer(str(snake_model_name)) + __M_writer("'),\n") + __M_writer(' \n') + if 'list' in operations_list: + __M_writer(' # 获取') + __M_writer(str(model_name)) + __M_writer("列表\n path('list/', views.list_") + __M_writer(str(snake_model_name)) + __M_writer(", name='list_") + __M_writer(str(snake_model_name)) + __M_writer("'),\n") + __M_writer(' \n') + if 'get' in operations_list: + __M_writer(' # 获取') + __M_writer(str(model_name)) + __M_writer("详情\n path('亲爱的 {recipient_name}，
+{description}
+验证码有效期为5分钟，请尽快使用。如果您没有进行此操作，请忽略此邮件。
+此致
Hertz Server Django 团队