src:对DjangoBlog的数据分析

src/DjangoBlog/analyze_models.py

@@ -0,0 +1,377 @@
+# analyze_models_final.py
+import os
+import sys
+import django
+import json
+
+
+def setup_django():
+    """配置Django环境"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0, current_dir)
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoblog.settings')
+    django.setup()
+    print("✅ Django环境配置成功")
+
+
+def serialize_field_default(default_value):
+    """序列化字段的默认值"""
+    if callable(default_value):
+        return f"<function {default_value.__name__}>"
+    elif hasattr(default_value, '__class__'):
+        return str(default_value)
+    else:
+        return default_value
+
+
+def comprehensive_model_analysis():
+    """全面分析Django模型"""
+    from django.apps import apps
+    from django.db import models
+
+    all_models = apps.get_models()
+
+    print("🔍 Django Blog 数据模型全面分析")
+    print("=" * 80)
+
+    # 按应用分组
+    apps_data = {}
+    for model in all_models:
+        app_label = model._meta.app_label
+        if app_label not in apps_data:
+            apps_data[app_label] = []
+
+        model_info = {
+            'name': model.__name__,
+            'db_table': model._meta.db_table,
+            'fields': [],
+            'relationships': [],
+            'meta': {
+                'managed': model._meta.managed,
+                'abstract': model._meta.abstract,
+            }
+        }
+
+        # 分析字段
+        for field in model._meta.fields:
+            try:
+                field_info = {
+                    'name': field.name,
+                    'type': field.get_internal_type(),
+                    'primary_key': getattr(field, 'primary_key', False),
+                    'unique': getattr(field, 'unique', False),
+                    'null': getattr(field, 'null', False),
+                    'blank': getattr(field, 'blank', False),
+                    'default': serialize_field_default(field.default) if hasattr(field,
+                                                                                 'default') and field.default != models.NOT_PROVIDED else None,
+                    'max_length': getattr(field, 'max_length', None),
+                    'related_model': field.related_model.__name__ if field.related_model else None,
+                    'relationship': None
+                }
+
+                # 确定关系类型
+                if field.is_relation:
+                    if field.many_to_one:
+                        field_info['relationship'] = 'ForeignKey'
+                    elif field.one_to_one:
+                        field_info['relationship'] = 'OneToOneField'
+
+                model_info['fields'].append(field_info)
+
+                # 添加到关系列表
+                if field.related_model:
+                    model_info['relationships'].append({
+                        'type': field_info['relationship'],
+                        'target': field.related_model.__name__,
+                        'field': field.name
+                    })
+            except Exception as e:
+                print(f"⚠️ 分析字段 {field.name} 时出错: {e}")
+                continue
+
+        # 分析多对多字段
+        for field in model._meta.many_to_many:
+            try:
+                field_info = {
+                    'name': field.name,
+                    'type': 'ManyToManyField',
+                    'primary_key': False,
+                    'unique': False,
+                    'null': getattr(field, 'null', False),
+                    'blank': getattr(field, 'blank', False),
+                    'related_model': field.related_model.__name__ if field.related_model else None,
+                }
+                model_info['fields'].append(field_info)
+
+                if field.related_model:
+                    model_info['relationships'].append({
+                        'type': 'ManyToManyField',
+                        'target': field.related_model.__name__,
+                        'field': field.name
+                    })
+            except Exception as e:
+                print(f"⚠️ 分析多对多字段 {field.name} 时出错: {e}")
+                continue
+
+        apps_data[app_label].append(model_info)
+
+    return apps_data
+
+
+def generate_markdown_documentation(apps_data):
+    """生成Markdown格式的详细文档"""
+
+    content = [
+        "# Django Blog 数据模型设计文档",
+        "",
+        "## 1. 系统概述",
+        "",
+        "本文档详细描述了Django Blog项目的数据库模型设计。",
+        "",
+        "## 2. 模型统计",
+        "",
+        f"系统共包含 **{sum(len(models) for models in apps_data.values())}** 个数据模型，分布在 **{len(apps_data)}** 个应用中。",
+        "",
+        "### 应用列表",
+        ""
+    ]
+
+    # 应用统计
+    for app_label, models in apps_data.items():
+        content.append(f"- **{app_label}**: {len(models)} 个模型")
+
+    content.extend([
+        "",
+        "## 3. 核心实体关系图",
+        "",
+        "```mermaid",
+        "erDiagram",
+        ""
+    ])
+
+    # 生成Mermaid ER图
+    for app_label, models in apps_data.items():
+        for model_info in models:
+            content.append(f"    {model_info['name']} {{")
+            # 显示关键字段
+            for field in model_info['fields'][:5]:  # 只显示前5个字段避免过于复杂
+                if field.get('primary_key'):
+                    content.append(f"        {field['type']} {field['name']} PK")
+                elif field['type'] in ['CharField', 'DateTimeField', 'BooleanField', 'TextField']:
+                    content.append(f"        {field['type']} {field['name']}")
+            content.append("    }")
+
+    content.append("")
+
+    # 添加主要关系
+    relationships_added = set()
+    for app_label, models in apps_data.items():
+        for model_info in models:
+            for rel in model_info['relationships']:
+                if rel.get('type') == 'ForeignKey':
+                    rel_str = f"    {model_info['name']} ||--o{{ {rel['target']} : \"{rel['field']}\""
+                    if rel_str not in relationships_added:
+                        relationships_added.add(rel_str)
+                        content.append(rel_str)
+
+    content.extend([
+        "```",
+        "",
+        "## 4. 详细数据字典",
+        ""
+    ])
+
+    # 每个模型的详细说明
+    for app_label, models in apps_data.items():
+        content.append(f"### {app_label} 应用")
+        content.append("")
+
+        for model_info in models:
+            content.append(f"#### {model_info['name']}")
+            content.append("")
+            content.append(f"- **数据库表**: `{model_info['db_table']}`")
+            content.append(f"- **管理方式**: {'Django管理' if model_info['meta']['managed'] else '非Django管理'}")
+            content.append("")
+
+            content.append("| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |")
+            content.append("|--------|----------|------|----------|------|")
+
+            for field in model_info['fields']:
+                try:
+                    constraints = []
+                    if field.get('primary_key'):
+                        constraints.append("PK")
+                    if field.get('unique'):
+                        constraints.append("UNIQUE")
+                    if field.get('null'):
+                        constraints.append("NULL")
+                    if field.get('blank'):
+                        constraints.append("BLANK")
+
+                    constraint_str = ", ".join(constraints) if constraints else ""
+                    related_model = field.get('related_model') or ""
+                    field_type = field.get('relationship') or field.get('type', 'Unknown')
+
+                    content.append(f"| {field['name']} | {field_type} | {constraint_str} | {related_model} | |")
+                except Exception as e:
+                    content.append(f"| {field.get('name', 'Unknown')} | Error | | | 字段分析错误 |")
+
+            content.append("")
+
+    # 模型关系分析
+    content.extend([
+        "## 5. 模型关系分析",
+        "",
+        "### 5.1 一对一关系 (OneToOne)",
+        ""
+    ])
+
+    one_to_one_rels = []
+    for app_label, models in apps_data.items():
+        for model_info in models:
+            for rel in model_info['relationships']:
+                if rel.get('type') == 'OneToOneField':
+                    one_to_one_rels.append(f"- `{model_info['name']}.{rel['field']}` → `{rel['target']}`")
+
+    if one_to_one_rels:
+        content.extend(one_to_one_rels)
+    else:
+        content.append("无一对一关系")
+
+    content.extend([
+        "",
+        "### 5.2 一对多关系 (ForeignKey)",
+        ""
+    ])
+
+    foreign_key_rels = []
+    for app_label, models in apps_data.items():
+        for model_info in models:
+            for rel in model_info['relationships']:
+                if rel.get('type') == 'ForeignKey':
+                    foreign_key_rels.append(f"- `{model_info['name']}.{rel['field']}` → `{rel['target']}`")
+
+    if foreign_key_rels:
+        content.extend(foreign_key_rels)
+    else:
+        content.append("无一对多关系")
+
+    content.extend([
+        "",
+        "### 5.3 多对多关系 (ManyToMany)",
+        ""
+    ])
+
+    many_to_many_rels = []
+    for app_label, models in apps_data.items():
+        for model_info in models:
+            for rel in model_info['relationships']:
+                if rel.get('type') == 'ManyToManyField':
+                    many_to_many_rels.append(f"- `{model_info['name']}.{rel['field']}` ↔ `{rel['target']}`")
+
+    if many_to_many_rels:
+        content.extend(many_to_many_rels)
+    else:
+        content.append("无多对多关系")
+
+    content.extend([
+        "",
+        "## 6. 索引设计",
+        "",
+        "### 6.1 主键索引",
+        "- 所有模型默认使用自增ID作为主键",
+        "",
+        "### 6.2 外键索引",
+        "- Django自动为所有ForeignKey和OneToOneField创建索引",
+        "",
+        "### 6.3 业务索引",
+        "- 需要根据具体查询需求添加数据库索引",
+        "",
+        "## 7. 总结",
+        "",
+        "本文档详细描述了Django Blog项目的数据库模型设计，包括：",
+        "- 完整的模型字段定义",
+        "- 模型间的关联关系",
+        "- 数据表结构设计",
+        "- 索引设计建议",
+        "",
+        "该设计支持博客系统的核心功能，包括用户管理、文章发布、评论系统等。"
+    ])
+
+    return "\n".join(content)
+
+
+def main():
+    """主函数"""
+    print("🚀 开始Django Blog数据模型分析...")
+
+    try:
+        # 设置Django环境
+        setup_django()
+
+        # 执行分析
+        print("📊 分析数据模型中...")
+        apps_data = comprehensive_model_analysis()
+
+        # 生成Markdown文档
+        print("📝 生成文档中...")
+        markdown_content = generate_markdown_documentation(apps_data)
+
+        # 保存文档
+        with open('数据模型设计文档.md', 'w', encoding='utf-8') as f:
+            f.write(markdown_content)
+        print("✅ 数据模型设计文档已生成: 数据模型设计文档.md")
+
+        # 同时保存JSON数据用于其他用途（修复序列化问题）
+        try:
+            # 创建一个可序列化的版本
+            serializable_data = {}
+            for app_label, models in apps_data.items():
+                serializable_data[app_label] = []
+                for model in models:
+                    serializable_model = model.copy()
+                    serializable_model['fields'] = []
+                    for field in model['fields']:
+                        serializable_field = field.copy()
+                        # 确保所有值都是可序列化的
+                        for key, value in serializable_field.items():
+                            if callable(value):
+                                serializable_field[key] = f"<function {value.__name__}>"
+                        serializable_model['fields'].append(serializable_field)
+                    serializable_data[app_label].append(serializable_model)
+
+            with open('models_analysis.json', 'w', encoding='utf-8') as f:
+                json.dump(serializable_data, f, indent=2, ensure_ascii=False)
+            print("✅ 模型分析数据已保存: models_analysis.json")
+        except Exception as json_error:
+            print(f"⚠️ JSON保存失败，但文档已生成: {json_error}")
+
+        # 打印简要统计
+        total_models = sum(len(models) for models in apps_data.values())
+        total_fields = sum(sum(len(model['fields']) for model in models) for models in apps_data.values())
+        total_relationships = sum(sum(len(model['relationships']) for model in models) for models in apps_data.values())
+
+        print(f"\n📊 分析统计:")
+        print(f"  应用数量: {len(apps_data)}")
+        print(f"  模型数量: {total_models}")
+        print(f"  字段数量: {total_fields}")
+        print(f"  关系数量: {total_relationships}")
+
+        # 显示发现的模型
+        print(f"\n📁 发现的模型:")
+        for app_label, models in apps_data.items():
+            print(f"  {app_label}:")
+            for model in models:
+                print(f"    - {model['name']} ({len(model['fields'])} 字段)")
+
+        print(f"\n🎉 分析完成！")
+        print("📄 生成的文档: 数据模型设计文档.md")
+
+    except Exception as e:
+        print(f"❌ 分析过程中出现错误: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

src/DjangoBlog/数据模型设计文档.md

@@ -0,0 +1,522 @@
+# Django Blog 数据模型设计文档
+
+## 1. 系统概述
+
+本文档详细描述了Django Blog项目的数据库模型设计。
+
+## 2. 模型统计
+
+系统共包含 **19** 个数据模型，分布在 **11** 个应用中。
+
+### 应用列表
+
+- **admin**: 1 个模型
+- **auth**: 2 个模型
+- **contenttypes**: 1 个模型
+- **sessions**: 1 个模型
+- **sites**: 1 个模型
+- **blog**: 6 个模型
+- **accounts**: 1 个模型
+- **comments**: 1 个模型
+- **oauth**: 2 个模型
+- **servermanager**: 2 个模型
+- **owntracks**: 1 个模型
+
+## 3. 核心实体关系图
+
+```mermaid
+erDiagram
+
+    LogEntry {
+        AutoField id PK
+        DateTimeField action_time
+        TextField object_id
+    }
+    Permission {
+        AutoField id PK
+        CharField name
+        CharField codename
+    }
+    Group {
+        AutoField id PK
+        CharField name
+    }
+    ContentType {
+        AutoField id PK
+        CharField app_label
+        CharField model
+    }
+    Session {
+        CharField session_key PK
+        TextField session_data
+        DateTimeField expire_date
+    }
+    Site {
+        AutoField id PK
+        CharField domain
+        CharField name
+    }
+    Article {
+        AutoField id PK
+        DateTimeField creation_time
+        DateTimeField last_modify_time
+        CharField title
+        TextField body
+    }
+    Category {
+        AutoField id PK
+        DateTimeField creation_time
+        DateTimeField last_modify_time
+        CharField name
+    }
+    Tag {
+        AutoField id PK
+        DateTimeField creation_time
+        DateTimeField last_modify_time
+        CharField name
+    }
+    Links {
+        BigAutoField id PK
+        CharField name
+        CharField link
+        BooleanField is_enable
+    }
+    SideBar {
+        BigAutoField id PK
+        CharField name
+        TextField content
+        BooleanField is_enable
+    }
+    BlogSettings {
+        BigAutoField id PK
+        CharField site_name
+        TextField site_description
+        TextField site_seo_description
+        TextField site_keywords
+    }
+    BlogUser {
+        BigAutoField id PK
+        CharField password
+        DateTimeField last_login
+        BooleanField is_superuser
+        CharField username
+    }
+    Comment {
+        BigAutoField id PK
+        TextField body
+        DateTimeField creation_time
+        DateTimeField last_modify_time
+    }
+    OAuthUser {
+        BigAutoField id PK
+        CharField openid
+        CharField nickname
+        CharField token
+    }
+    OAuthConfig {
+        BigAutoField id PK
+        CharField type
+        CharField appkey
+        CharField appsecret
+        CharField callback_url
+    }
+    commands {
+        BigAutoField id PK
+        CharField title
+        CharField command
+        CharField describe
+        DateTimeField creation_time
+    }
+    EmailSendLog {
+        BigAutoField id PK
+        CharField emailto
+        CharField title
+        TextField content
+        BooleanField send_result
+    }
+    OwnTrackLog {
+        BigAutoField id PK
+        CharField tid
+        DateTimeField creation_time
+    }
+
+    LogEntry ||--o{ BlogUser : "user"
+    LogEntry ||--o{ ContentType : "content_type"
+    Permission ||--o{ ContentType : "content_type"
+    Article ||--o{ BlogUser : "author"
+    Article ||--o{ Category : "category"
+    Category ||--o{ Category : "parent_category"
+    Comment ||--o{ BlogUser : "author"
+    Comment ||--o{ Article : "article"
+    Comment ||--o{ Comment : "parent_comment"
+    OAuthUser ||--o{ BlogUser : "author"
+```
+
+## 4. 详细数据字典
+
+### admin 应用
+
+#### LogEntry
+
+- **数据库表**: `django_admin_log`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| action_time | DateTimeField |  |  | |
+| user | ForeignKey |  | BlogUser | |
+| content_type | ForeignKey | NULL, BLANK | ContentType | |
+| object_id | TextField | NULL, BLANK |  | |
+| object_repr | CharField |  |  | |
+| action_flag | PositiveSmallIntegerField |  |  | |
+| change_message | TextField | BLANK |  | |
+
+### auth 应用
+
+#### Permission
+
+- **数据库表**: `auth_permission`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| name | CharField |  |  | |
+| content_type | ForeignKey |  | ContentType | |
+| codename | CharField |  |  | |
+
+#### Group
+
+- **数据库表**: `auth_group`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| name | CharField | UNIQUE |  | |
+| permissions | ManyToManyField | BLANK | Permission | |
+
+### contenttypes 应用
+
+#### ContentType
+
+- **数据库表**: `django_content_type`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| app_label | CharField |  |  | |
+| model | CharField |  |  | |
+
+### sessions 应用
+
+#### Session
+
+- **数据库表**: `django_session`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| session_key | CharField | PK, UNIQUE |  | |
+| session_data | TextField |  |  | |
+| expire_date | DateTimeField |  |  | |
+
+### sites 应用
+
+#### Site
+
+- **数据库表**: `django_site`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| domain | CharField | UNIQUE |  | |
+| name | CharField |  |  | |
+
+### blog 应用
+
+#### Article
+
+- **数据库表**: `blog_article`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+| title | CharField | UNIQUE |  | |
+| body | TextField |  |  | |
+| pub_time | DateTimeField |  |  | |
+| status | CharField |  |  | |
+| comment_status | CharField |  |  | |
+| type | CharField |  |  | |
+| views | PositiveIntegerField |  |  | |
+| author | ForeignKey |  | BlogUser | |
+| article_order | IntegerField |  |  | |
+| show_toc | BooleanField |  |  | |
+| category | ForeignKey |  | Category | |
+| tags | ManyToManyField | BLANK | Tag | |
+
+#### Category
+
+- **数据库表**: `blog_category`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+| name | CharField | UNIQUE |  | |
+| parent_category | ForeignKey | NULL, BLANK | Category | |
+| slug | SlugField | BLANK |  | |
+| index | IntegerField |  |  | |
+
+#### Tag
+
+- **数据库表**: `blog_tag`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | AutoField | PK, UNIQUE, BLANK |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+| name | CharField | UNIQUE |  | |
+| slug | SlugField | BLANK |  | |
+
+#### Links
+
+- **数据库表**: `blog_links`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| name | CharField | UNIQUE |  | |
+| link | CharField |  |  | |
+| sequence | IntegerField | UNIQUE |  | |
+| is_enable | BooleanField |  |  | |
+| show_type | CharField |  |  | |
+| creation_time | DateTimeField |  |  | |
+| last_mod_time | DateTimeField |  |  | |
+
+#### SideBar
+
+- **数据库表**: `blog_sidebar`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| name | CharField |  |  | |
+| content | TextField |  |  | |
+| sequence | IntegerField | UNIQUE |  | |
+| is_enable | BooleanField |  |  | |
+| creation_time | DateTimeField |  |  | |
+| last_mod_time | DateTimeField |  |  | |
+
+#### BlogSettings
+
+- **数据库表**: `blog_blogsettings`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| site_name | CharField |  |  | |
+| site_description | TextField |  |  | |
+| site_seo_description | TextField |  |  | |
+| site_keywords | TextField |  |  | |
+| article_sub_length | IntegerField |  |  | |
+| sidebar_article_count | IntegerField |  |  | |
+| sidebar_comment_count | IntegerField |  |  | |
+| article_comment_count | IntegerField |  |  | |
+| show_google_adsense | BooleanField |  |  | |
+| google_adsense_codes | TextField | NULL, BLANK |  | |
+| open_site_comment | BooleanField |  |  | |
+| global_header | TextField | NULL, BLANK |  | |
+| global_footer | TextField | NULL, BLANK |  | |
+| beian_code | CharField | NULL, BLANK |  | |
+| analytics_code | TextField |  |  | |
+| show_gongan_code | BooleanField |  |  | |
+| gongan_beiancode | TextField | NULL, BLANK |  | |
+| comment_need_review | BooleanField |  |  | |
+
+### accounts 应用
+
+#### BlogUser
+
+- **数据库表**: `accounts_bloguser`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| password | CharField |  |  | |
+| last_login | DateTimeField | NULL, BLANK |  | |
+| is_superuser | BooleanField |  |  | |
+| username | CharField | UNIQUE |  | |
+| first_name | CharField | BLANK |  | |
+| last_name | CharField | BLANK |  | |
+| email | CharField | BLANK |  | |
+| is_staff | BooleanField |  |  | |
+| is_active | BooleanField |  |  | |
+| date_joined | DateTimeField |  |  | |
+| nickname | CharField | BLANK |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+| source | CharField | BLANK |  | |
+| groups | ManyToManyField | BLANK | Group | |
+| user_permissions | ManyToManyField | BLANK | Permission | |
+
+### comments 应用
+
+#### Comment
+
+- **数据库表**: `comments_comment`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| body | TextField |  |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+| author | ForeignKey |  | BlogUser | |
+| article | ForeignKey |  | Article | |
+| parent_comment | ForeignKey | NULL, BLANK | Comment | |
+| is_enable | BooleanField |  |  | |
+
+### oauth 应用
+
+#### OAuthUser
+
+- **数据库表**: `oauth_oauthuser`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| author | ForeignKey | NULL, BLANK | BlogUser | |
+| openid | CharField |  |  | |
+| nickname | CharField |  |  | |
+| token | CharField | NULL, BLANK |  | |
+| picture | CharField | NULL, BLANK |  | |
+| type | CharField |  |  | |
+| email | CharField | NULL, BLANK |  | |
+| metadata | TextField | NULL, BLANK |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+
+#### OAuthConfig
+
+- **数据库表**: `oauth_oauthconfig`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| type | CharField |  |  | |
+| appkey | CharField |  |  | |
+| appsecret | CharField |  |  | |
+| callback_url | CharField |  |  | |
+| is_enable | BooleanField |  |  | |
+| creation_time | DateTimeField |  |  | |
+| last_modify_time | DateTimeField |  |  | |
+
+### servermanager 应用
+
+#### commands
+
+- **数据库表**: `servermanager_commands`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| title | CharField |  |  | |
+| command | CharField |  |  | |
+| describe | CharField |  |  | |
+| creation_time | DateTimeField | BLANK |  | |
+| last_modify_time | DateTimeField | BLANK |  | |
+
+#### EmailSendLog
+
+- **数据库表**: `servermanager_emailsendlog`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| emailto | CharField |  |  | |
+| title | CharField |  |  | |
+| content | TextField |  |  | |
+| send_result | BooleanField |  |  | |
+| creation_time | DateTimeField | BLANK |  | |
+
+### owntracks 应用
+
+#### OwnTrackLog
+
+- **数据库表**: `owntracks_owntracklog`
+- **管理方式**: Django管理
+
+| 字段名 | 数据类型 | 约束 | 关联模型 | 说明 |
+|--------|----------|------|----------|------|
+| id | BigAutoField | PK, UNIQUE, BLANK |  | |
+| tid | CharField |  |  | |
+| lat | FloatField |  |  | |
+| lon | FloatField |  |  | |
+| creation_time | DateTimeField |  |  | |
+
+## 5. 模型关系分析
+
+### 5.1 一对一关系 (OneToOne)
+
+无一对一关系
+
+### 5.2 一对多关系 (ForeignKey)
+
+- `LogEntry.user` → `BlogUser`
+- `LogEntry.content_type` → `ContentType`
+- `Permission.content_type` → `ContentType`
+- `Article.author` → `BlogUser`
+- `Article.category` → `Category`
+- `Category.parent_category` → `Category`
+- `Comment.author` → `BlogUser`
+- `Comment.article` → `Article`
+- `Comment.parent_comment` → `Comment`
+- `OAuthUser.author` → `BlogUser`
+
+### 5.3 多对多关系 (ManyToMany)
+
+- `Group.permissions` ↔ `Permission`
+- `Article.tags` ↔ `Tag`
+- `BlogUser.groups` ↔ `Group`
+- `BlogUser.user_permissions` ↔ `Permission`
+
+## 6. 索引设计
+
+### 6.1 主键索引
+- 所有模型默认使用自增ID作为主键
+
+### 6.2 外键索引
+- Django自动为所有ForeignKey和OneToOneField创建索引
+
+### 6.3 业务索引
+- 需要根据具体查询需求添加数据库索引
+
+## 7. 总结
+
+本文档详细描述了Django Blog项目的数据库模型设计，包括：
+- 完整的模型字段定义
+- 模型间的关联关系
+- 数据表结构设计
+- 索引设计建议
+
+该设计支持博客系统的核心功能，包括用户管理、文章发布、评论系统等。