代码注释

src/django-master/comments/admin.py

@@ -1,100 +1,47 @@
-#django核心组件导入
-from django import forms# Django 表单处理模块
-from django.contrib.auth.admin import UserAdmin # Django 默认用户管理后台类
-from django.contrib.auth.forms import UserChangeForm # 用户信息修改表单基类
-from django.contrib.auth.forms import UsernameField# 用户名专用表单字段
-from django.utils.translation import gettext_lazy as _ # 国际化翻译函数
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
 
-# 本地应用导入
-# Register your models here.
-from .models import BlogUser # 导入自定义用户模型
 
+def disable_commentstatus(modeladmin, request, queryset):
+    queryset.update(is_enable=False)
 
-class BlogUserCreationForm(forms.ModelForm):
-    """
-    自定义用户创建表单(用于管理后台添加新用户)
-    继承自 ModelForm专门处理 BlogUser 模型的创建
-    """
 
-    # 定义密码输入字段（需要输入两次以确保一致）
-    password1 = forms.CharField(label=_('password'), # 字段标签（支持国际化）
-    widget=forms.PasswordInput) # 密码输入控件
-    password2 = forms.CharField(label=_('Enter password again'),  # 确认密码标签
-    widget=forms.PasswordInput) # 密码输入控件
+def enable_commentstatus(modeladmin, request, queryset):
+    queryset.update(is_enable=True)
 
-    class Meta:
-        model = BlogUser# 关联的模型类
-        fields = ('email',)# 创建用户时显示的字段（这里只显示email字段）
 
-    def clean_password2(self):
-        """
-        验证两次输入的密码是否一致
-        Django 表单验证方法，方法名必须以 clean_ 开头
-        """
-        # Check that the two password entries match
-        password1 = self.cleaned_data.get("password1")# 获取第一次输入的密码
-        password2 = self.cleaned_data.get("password2")# 获取第二次输入的密码
-          # 如果两次密码不一致，抛出验证错误
-        if password1 and password2 and password1 != password2:
-            raise forms.ValidationError(_("passwords do not match"))# 错误信息（支持国际化）
-        return password2# 返回验证后的值
+disable_commentstatus.short_description = _('Disable comments')
+enable_commentstatus.short_description = _('Enable comments')
 
 
-    def save(self, commit=True):
-        """
-        重写保存方法，在保存用户前处理密码哈希
-        """
-        # Save the provided password in hashed format
-        user = super().save(commit=False) # 调用父类保存方法但不提交到数据库
-        user.set_password(self.cleaned_data["password1"]) # 对密码进行哈希加密
-        if commit:
-            user.source = 'adminsite' # 设置用户来源标记（表示通过管理后台创建）
-            user.save()# 保存到数据库
-        return user# 返回用户对象
-
-
-class BlogUserChangeForm(UserChangeForm):
-    """
-    自定义用户信息修改表单（用于管理后台编辑用户）
-    继承自 Django 自带的 UserChangeForm
-    """
-
-    class Meta:
-        model = BlogUser # 关联的模型类
-        fields = '__all__'# 显示所有字段
-        field_classes = {'username': UsernameField}# 指定用户名使用专用字段类型
-
-    def __init__(self, *args, **kwargs):
-        """
-        表单初始化方法
-        可以在这里对表单字段进行自定义设置
-        """
-        super().__init__(*args, **kwargs) # 调用父类初始化方法
-        # 可以在这里添加自定义逻辑，如修改字段属性等
-
-class BlogUserAdmin(UserAdmin):
-    """
-    自定义用户管理后台配置
-    继承自 Django 自带的 UserAdmin
-    """
-
-     # 指定使用的表单类
-    form = BlogUserChangeForm  # 编辑用户时使用的表单
-    add_form = BlogUserCreationForm# 添加用户时使用的表单
-
-     # 管理后台列表页显示配置
+class CommentAdmin(admin.ModelAdmin):
+    list_per_page = 20
     list_display = (
-        'id', # 用户ID
-        'nickname', # 用户昵称
-        'username',# 用户名
-        'email', # 电子邮箱
-        'last_login',  # 最后登录时间
-        'date_joined', # 注册时间
-        'source')# 用户来源标记
-
-    # 设置哪些字段可以点击跳转到编辑页
-    list_display_links = ('id', 'username')
-
-     # 默认排序规则（按ID降序排列）
-    ordering = ('-id',)
-
+        'id',
+        'body',
+        'link_to_userinfo',
+        'link_to_article',
+        'is_enable',
+        'creation_time')
+    list_display_links = ('id', 'body', 'is_enable')
+    list_filter = ('is_enable',)
+    exclude = ('creation_time', 'last_modify_time')
+    actions = [disable_commentstatus, enable_commentstatus]
+
+    def link_to_userinfo(self, obj):
+        info = (obj.author._meta.app_label, obj.author._meta.model_name)
+        link = reverse('admin:%s_%s_change' % info, args=(obj.author.id,))
+        return format_html(
+            u'<a href="%s">%s</a>' %
+            (link, obj.author.nickname if obj.author.nickname else obj.author.email))
+
+    def link_to_article(self, obj):
+        info = (obj.article._meta.app_label, obj.article._meta.model_name)
+        link = reverse('admin:%s_%s_change' % info, args=(obj.article.id,))
+        return format_html(
+            u'<a href="%s">%s</a>' % (link, obj.article.title))
+
+    link_to_userinfo.short_description = _('User')
+    link_to_article.short_description = _('Article')

src/django-master/comments/apps.py

@@ -1,11 +1,6 @@
 from django.apps import AppConfig
-     
 
-class AccountsConfig(AppConfig):
-    """
-    Accounts 应用的配置类。
-    功能：
-        1. 定义应用名称（供 Django 内部识别）。
-        2. 可在此处覆盖 ready() 方法以注册信号等。
-    """
-    name = 'accounts'# 必须与项目中的应用目录名完全一致
+
+class CommentsConfig(AppConfig):
+    name = 'comments'
+

src/django-master/comments/forms.py

@@ -1,117 +1,13 @@
 from django import forms
-from django.contrib.auth import get_user_model, password_validation
-from django.contrib.auth.forms import AuthenticationForm, UserCreationForm
-from django.core.exceptions import ValidationError
-from django.forms import widgets
-from django.utils.translation import gettext_lazy as _
-from . import utils
-from .models import BlogUser
+from django.forms import ModelForm
 
-# 登录表单，继承自Django内置的AuthenticationForm
-class LoginForm(AuthenticationForm):
-    def __init__(self, *args, **kwargs):
-        super(LoginForm, self).__init__(*args, **kwargs)
-        self.fields['username'].widget = widgets.TextInput(
-            attrs={'placeholder': "username", "class": "form-control"})
-        self.fields['password'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "password", "class": "form-control"})
+from .models import Comment
 
-# 注册表单，继承自Django内置的UserCreationForm
-class RegisterForm(UserCreationForm):
-    def __init__(self, *args, **kwargs):
-        super(RegisterForm, self).__init__(*args, **kwargs)
-        # 自定义用户名、邮箱和密码字段的HTML属性
-        self.fields['username'].widget = widgets.TextInput(
-            attrs={'placeholder': "username", "class": "form-control"})
-        self.fields['email'].widget = widgets.EmailInput(
-            attrs={'placeholder': "email", "class": "form-control"})
-        self.fields['password1'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "password", "class": "form-control"})
-        self.fields['password2'].widget = widgets.PasswordInput(
-            attrs={'placeholder': "repeat password", "class": "form-control"})
-    # 验证邮箱唯一性
-    def clean_email(self):
-        email = self.cleaned_data['email']
-        if get_user_model().objects.filter(email=email).exists():
-            raise ValidationError(_("email already exists"))
-        return email
-    # 指定关联的用户模型和表单字段
-    class Meta:
-        model = get_user_model()
-        fields = ("username", "email")
-
-# 忘记密码表单（验证邮箱和验证码）
-class ForgetPasswordForm(forms.Form):
-    new_password1 = forms.CharField(
-        label=_("New password"),
-        widget=forms.PasswordInput(
-            attrs={
-                "class": "form-control",
-                'placeholder': _("New password")
-            }
-        ),
-    )
-    # 新密码字段2（用于确认）
-    new_password2 = forms.CharField(
-        label="确认密码",
-        widget=forms.PasswordInput(
-            attrs={
-                "class": "form-control",
-                'placeholder': _("Confirm password")
-            }
-        ),
-    )
-    # 邮箱字段
-    email = forms.EmailField(
-        label='邮箱',
-        widget=forms.TextInput(
-            attrs={
-                'class': 'form-control',
-                'placeholder': _("Email")
-            }
-        ),
-    )
-    # 验证码字段
-    code = forms.CharField(
-        label=_('Code'),
-        widget=forms.TextInput(
-            attrs={
-                'class': 'form-control',
-                'placeholder': _("Code")
-            }
-        ),
-    )
-    # 验证两次输入的密码是否一致，并检查密码强度
-    def clean_new_password2(self):
-        password1 = self.data.get("new_password1")
-        password2 = self.data.get("new_password2")
-        if password1 and password2 and password1 != password2:
-            raise ValidationError(_("passwords do not match"))
-        password_validation.validate_password(password2)# 使用Django的密码验证器
 
-        return password2
-    # 验证邮箱是否已注册
-    def clean_email(self):
-        user_email = self.cleaned_data.get("email")
-        if not BlogUser.objects.filter(
-                email=user_email
-        ).exists():
-            # todo 这里的报错提示可以判断一个邮箱是不是注册过，如果不想暴露可以修改
-            raise ValidationError(_("email does not exist"))
-        return user_email
-    # 验证用户输入的验证码是否正确
-    def clean_code(self):
-        code = self.cleaned_data.get("code")
-        error = utils.verify(# 调用工具函数验证验证码
-            email=self.cleaned_data.get("email"),
-            code=code,
-        )
-        if error:
-            raise ValidationError(error)
-        return code
+class CommentForm(ModelForm):
+    parent_comment_id = forms.IntegerField(
+        widget=forms.HiddenInput, required=False)
 
-# 忘记密码功能中的验证码发送表单（仅需邮箱字段）
-class ForgetPasswordCodeForm(forms.Form):
-    email = forms.EmailField(
-        label=_('Email'),
-    )
+    class Meta:
+        model = Comment
+        fields = ['body']

src/django-master/comments/models.py

@@ -1,39 +1,39 @@
-from django.contrib.auth.models import AbstractUser
+from django.conf import settings
 from django.db import models
-from django.urls import reverse
 from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
-from djangoblog.utils import get_current_site
+
+from blog.models import Article
 
 
 # Create your models here.
-# 自定义用户模型，继承Django内置的AbstractUser
-class BlogUser(AbstractUser):
-    # 用户昵称（可选）
-    nickname = models.CharField(_('nick name'), max_length=100, blank=True)
-    # 账号创建时间（默认当前时间）
+
+class Comment(models.Model):
+    body = models.TextField('正文', max_length=300)
     creation_time = models.DateTimeField(_('creation time'), default=now)
-    # 最后修改时间（默认当前时间）
     last_modify_time = models.DateTimeField(_('last modify time'), default=now)
-    # 账号创建来源（如：网站注册/第三方登录等，可选）
-    source = models.CharField(_('create source'), max_length=100, blank=True)
-    # 获取用户详情页的绝对URL（用于模板中的{% url %}反向解析）
-    def get_absolute_url(self):
-        return reverse(
-            'blog:author_detail', kwargs={
-                'author_name': self.username})
-    # 定义对象的字符串表示（Admin后台和shell中显示）
-    def __str__(self):
-        return self.email
-    # 获取用户详情页的完整URL（包含域名，用于分享链接）
-    def get_full_url(self):
-        site = get_current_site().domain# 获取当前站点域名
-        url = "https://{site}{path}".format(site=site,
-                                            path=self.get_absolute_url())
-        return url
-    # 元数据配置（模型级别的选项）
+    author = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        verbose_name=_('author'),
+        on_delete=models.CASCADE)
+    article = models.ForeignKey(
+        Article,
+        verbose_name=_('article'),
+        on_delete=models.CASCADE)
+    parent_comment = models.ForeignKey(
+        'self',
+        verbose_name=_('parent comment'),
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE)
+    is_enable = models.BooleanField(_('enable'),
+                                    default=False, blank=False, null=False)
+
     class Meta:
-        ordering = ['-id'] # 默认按ID降序排列
-        verbose_name = _('user') # 单数形式名称（后台显示）
-        verbose_name_plural = verbose_name# 复数形式名称（后台显示）
-        get_latest_by = 'id'# 指定最新记录的排序字段
+        ordering = ['-id']
+        verbose_name = _('comment')
+        verbose_name_plural = verbose_name
+        get_latest_by = 'id'
+
+    def __str__(self):
+        return self.body

src/django-master/comments/tests.py

@@ -1,231 +1,109 @@
-from django.test import Client, RequestFactory, TestCase
+from django.test import Client, RequestFactory, TransactionTestCase
 from django.urls import reverse
-from django.utils import timezone
-from django.utils.translation import gettext_lazy as _
 
 from accounts.models import BlogUser
-from blog.models import Article, Category
-from djangoblog.utils import *
-from . import utils
+from blog.models import Category, Article
+from comments.models import Comment
+from comments.templatetags.comments_tags import *
+from djangoblog.utils import get_max_articleid_commentid
 
 
 # Create your tests here.
-# 创建测试类（继承Django的TestCase）
-class AccountTest(TestCase):
-    # 测试初始化方法（每个测试方法运行前都会执行）
+
+class CommentsTest(TransactionTestCase):
     def setUp(self):
-        # 初始化测试客户端（模拟浏览器请求）
         self.client = Client()
-        # 初始化请求工厂（用于生成请求对象）
         self.factory = RequestFactory()
-        # 创建一个普通测试用户
-        self.blog_user = BlogUser.objects.create_user(
-            username="test",
-            email="admin@admin.com",
-            password="12345678"
-        )
-        # 测试用的随机字符串
-        self.new_test = "xxx123--="
-    # 测试用户账号验证功能
-    def test_validate_account(self):
-        # 获取当前站点域名
-        site = get_current_site().domain
-        # 创建一个超级用户（用于测试管理员权限）
-        user = BlogUser.objects.create_superuser(
+        from blog.models import BlogSettings
+        value = BlogSettings()
+        value.comment_need_review = True
+        value.save()
+
+        self.user = BlogUser.objects.create_superuser(
             email="liangliangyy1@gmail.com",
             username="liangliangyy1",
-            password="qwer!@#$ggg")
-        # 从数据库获取刚创建的超级用户（验证是否创建成功）
-        testuser = BlogUser.objects.get(username='liangliangyy1')
-        # 测试登录功能
-        loginresult = self.client.login(
-            username='liangliangyy1',
-            password='qwer!@#$ggg')
-        self.assertEqual(loginresult, True)# 验证登录成功
-        # 测试访问管理员后台
-        response = self.client.get('/admin/')
-        self.assertEqual(response.status_code, 200)# 验证返回200状态码
-        # 创建测试分类
-        category = Category()
-        category.name = "categoryaaa"
-        category.creation_time = timezone.now()
-        category.last_modify_time = timezone.now()
-        category.save()
-        # 创建测试文章
-        article = Article()
-        article.title = "nicetitleaaa"
-        article.body = "nicecontentaaa"
-        article.author = user# 关联超级用户
-        article.category = category# 关联上面创建的分类
-        article.type = 'a' # 文章类型
-        article.status = 'p' # 发布状态
-        article.save()
-        # 测试访问文章的管理URL
-        response = self.client.get(article.get_admin_url())
-        self.assertEqual(response.status_code, 200) # 验证返回200状态码
-
-    # 测试用户注册功能
-    def test_validate_register(self):
-        # 验证测试邮箱初始不存在
-        self.assertEquals(
-            0, len(
-                BlogUser.objects.filter(
-                    email='user123@user.com')))
-        # 模拟注册请求
-        response = self.client.post(reverse('account:register'), {
-            'username': 'user1233',
-            'email': 'user123@user.com',
-            'password1': 'password123!q@wE#R$T',
-            'password2': 'password123!q@wE#R$T',
-        })
-         # 验证用户已创建（通过邮箱查询）
-        self.assertEquals(
-            1, len(
-                BlogUser.objects.filter(
-                    email='user123@user.com')))
-        # 获取刚注册的用户
-        user = BlogUser.objects.filter(email='user123@user.com')[0]
-        # 生成验证签名（用于邮箱验证等场景）
-        sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
-        # 构造验证URL
-        path = reverse('accounts:result')
-        url = '{path}?type=validation&id={id}&sign={sign}'.format(
-            path=path, id=user.id, sign=sign)
-        # 测试访问验证URL
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200) # 验证返回200状态码
-        # 使用测试客户端登录
-        self.client.login(username='user1233', password='password123!q@wE#R$T')
-        # 获取指定邮箱的用户并设置为超级用户和工作人员 
-        user = BlogUser.objects.filter(email='user123@user.com')[0]
-        user.is_superuser = True
-        user.is_staff = True
-        user.save()
-        # 删除侧边栏缓存
-        delete_sidebar_cache()
-        # 创建分类
+            password="liangliangyy1")
+
+    def update_article_comment_status(self, article):
+        comments = article.comment_set.all()
+        for comment in comments:
+            comment.is_enable = True
+            comment.save()
+
+    def test_validate_comment(self):
+        self.client.login(username='liangliangyy1', password='liangliangyy1')
+
         category = Category()
-        category.name = "categoryaaa"
-        category.creation_time = timezone.now()
-        category.last_modify_time = timezone.now()
+        category.name = "categoryccc"
         category.save()
-        # 创建文章
+
         article = Article()
+        article.title = "nicetitleccc"
+        article.body = "nicecontentccc"
+        article.author = self.user
         article.category = category
-        article.title = "nicetitle333"
-        article.body = "nicecontentttt"
-        article.author = user
-
         article.type = 'a'
         article.status = 'p'
         article.save()
-        # 测试已登录用户访问文章管理URL
-        response = self.client.get(article.get_admin_url())
-        self.assertEqual(response.status_code, 200)
-        # 测试注销功能
-        response = self.client.get(reverse('account:logout'))
-        self.assertIn(response.status_code, [301, 302, 200])
-        # 测试注销后访问文章管理URL（应重定向）
-        response = self.client.get(article.get_admin_url())
-        self.assertIn(response.status_code, [301, 302, 200])
-        # 测试使用错误密码登录
-        response = self.client.post(reverse('account:login'), {
-            'username': 'user1233',
-            'password': 'password123'# 注意这里密码与登录时使用的不同
-        })
-        self.assertIn(response.status_code, [301, 302, 200])
-        # 测试使用错误密码登录后访问文章管理URL（应重定向）
-        response = self.client.get(article.get_admin_url())
-        self.assertIn(response.status_code, [301, 302, 200])
-    # 测试邮箱验证码验证
-    def test_verify_email_code(self):
-        to_email = "admin@admin.com"
-        code = generate_code() # 生成验证码
-        utils.set_code(to_email, code)# 存储验证码
-        utils.send_verify_email(to_email, code) # 发送验证邮件（实际测试中可能不会真的发送）
-        # 测试正确验证码
-        err = utils.verify("admin@admin.com", code)
-        self.assertEqual(err, None)
-        # 测试错误邮箱
-        err = utils.verify("admin@123.com", code)
-        self.assertEqual(type(err), str)# 应返回错误信息字符串
-    # 测试忘记密码发送验证码功能 - 成功情况
-    def test_forget_password_email_code_success(self):
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict(email="admin@admin.com") # 使用正确邮箱格式
-        )
-
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.content.decode("utf-8"), "ok")# 验证返回成功消息
-    # 测试忘记密码发送验证码功能 - 失败情况
-    def test_forget_password_email_code_fail(self):
-        # 测试不提供邮箱
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict()
-        )
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
-        # 测试提供错误格式邮箱
-        resp = self.client.post(
-            path=reverse("account:forget_password_code"),
-            data=dict(email="admin@com")
-        )
-        self.assertEqual(resp.content.decode("utf-8"), "错误的邮箱")
-    # 测试忘记密码重置功能 - 成功情况
-    def test_forget_password_email_success(self):
-        code = generate_code()
-        utils.set_code(self.blog_user.email, code)# 为测试用户设置验证码
-        # 准备重置密码数据
-        data = dict(
-            new_password1=self.new_test,  # 新密码
-            new_password2=self.new_test,# 确认密码
-            email=self.blog_user.email,# 用户邮箱
-            code=code,  # 验证码
-        )
-        # 提交重置密码请求
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-        self.assertEqual(resp.status_code, 302)  # 应重定向
-
-        # 验证用户密码是否修改成功
-        blog_user = BlogUser.objects.filter(
-            email=self.blog_user.email,
-        ).first()  # type: BlogUser
-        self.assertNotEqual(blog_user, None)
-        self.assertEqual(blog_user.check_password(data["new_password1"]), True)
-    # 测试忘记密码重置功能 - 用户不存在情况
-    def test_forget_password_email_not_user(self):
-        data = dict(
-            new_password1=self.new_test,
-            new_password2=self.new_test,
-            email="123@123.com",# 不存在的邮箱
-            code="123456",
-        )
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-
-        self.assertEqual(resp.status_code, 200) # 应返回错误页面而非重定向
-
-    # 测试忘记密码重置功能 - 验证码错误情况
-    def test_forget_password_email_code_error(self):
-        code = generate_code()
-        utils.set_code(self.blog_user.email, code)# 设置正确验证码
-        # 使用错误验证码提交
-        data = dict(
-            new_password1=self.new_test,
-            new_password2=self.new_test,
-            email=self.blog_user.email,
-            code="111111",# 错误验证码
-        )
-        resp = self.client.post(
-            path=reverse("account:forget_password"),
-            data=data
-        )
-
-        self.assertEqual(resp.status_code, 200)# 应返回错误页面而非重定向
 
+        comment_url = reverse(
+            'comments:postcomment', kwargs={
+                'article_id': article.id})
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '123ffffffffff'
+                                    })
+
+        self.assertEqual(response.status_code, 302)
+
+        article = Article.objects.get(pk=article.pk)
+        self.assertEqual(len(article.comment_list()), 0)
+        self.update_article_comment_status(article)
+
+        self.assertEqual(len(article.comment_list()), 1)
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '123ffffffffff',
+                                    })
+
+        self.assertEqual(response.status_code, 302)
+
+        article = Article.objects.get(pk=article.pk)
+        self.update_article_comment_status(article)
+        self.assertEqual(len(article.comment_list()), 2)
+        parent_comment_id = article.comment_list()[0].id
+
+        response = self.client.post(comment_url,
+                                    {
+                                        'body': '''
+                                        # Title1
+
+        ```python
+        import os
+        ```
+
+        [url](https://www.lylinux.net/)
+
+        [ddd](http://www.baidu.com)
+
+
+        ''',
+                                        'parent_comment_id': parent_comment_id
+                                    })
+
+        self.assertEqual(response.status_code, 302)
+        self.update_article_comment_status(article)
+        article = Article.objects.get(pk=article.pk)
+        self.assertEqual(len(article.comment_list()), 3)
+        comment = Comment.objects.get(id=parent_comment_id)
+        tree = parse_commenttree(article.comment_list(), comment)
+        self.assertEqual(len(tree), 1)
+        data = show_comment_item(comment, True)
+        self.assertIsNotNone(data)
+        s = get_max_articleid_commentid()
+        self.assertIsNotNone(s)
+
+        from comments.utils import send_comment_email
+        send_comment_email(comment)

src/django-master/comments/views.py

@@ -1,289 +1,62 @@
-# 导入日志模块，用于记录运行时的信息和错误
-import logging
-# Django 国际化工具，`gettext_lazy` 用于延迟翻译（适合模块级字符串）
-from django.utils.translation import gettext_lazy as _
-# Django 配置项，用于访问 settings.py 中的设置
-from django.conf import settings
-# Django 认证系统核心模块
-from django.contrib import auth
-# 认证相关常量（如重定向字段名）
-from django.contrib.auth import REDIRECT_FIELD_NAME
-# 获取当前用户模型的快捷方式
-from django.contrib.auth import get_user_model
-# 用户登出功能
-from django.contrib.auth import logout
-# Django 内置的认证表单（如登录表单）
-from django.contrib.auth.forms import AuthenticationForm
-# 密码哈希工具
-from django.contrib.auth.hashers import make_password
-# HTTP 响应类（重定向、禁止访问等）
-from django.http import HttpResponseRedirect, HttpResponseForbidden
-# HTTP 请求和响应的类型提示（可选，用于类型检查）
-from django.http.request import HttpRequest
-from django.http.response import HttpResponse
-# 快捷函数（如获取对象或返回 404）
+from django.core.exceptions import ValidationError
+from django.http import HttpResponseRedirect
 from django.shortcuts import get_object_or_404
-# 渲染模板的快捷方式
-from django.shortcuts import render
-# URL 反转工具（通过名称生成 URL）
-from django.urls import reverse
-# 视图装饰器工具
 from django.utils.decorators import method_decorator
-# URL 安全验证工具（防止重定向攻击）
-from django.utils.http import url_has_allowed_host_and_scheme
-# 基础视图类
-from django.views import View
-# 缓存控制装饰器（禁用缓存）
-from django.views.decorators.cache import never_cache
-# CSRF 防护装饰器
 from django.views.decorators.csrf import csrf_protect
-# 敏感参数标记（如密码字段）
-from django.views.decorators.debug import sensitive_post_parameters
-# 通用视图类（表单视图、重定向视图）
-from django.views.generic import FormView, RedirectView
-# 项目自定义工具
-from djangoblog.utils import send_email, get_sha256, get_current_site, generate_code, delete_sidebar_cache
-# 当前应用的工具模块
-from . import utils
-# 当前应用的表单（注册、登录、忘记密码等）
-from .forms import RegisterForm, LoginForm, ForgetPasswordForm, ForgetPasswordCodeForm
-# 当前应用的模型（博客用户）
-from .models import BlogUser
-# 初始化日志记录器（__name__ 表示当前模块名）
-logger = logging.getLogger(__name__)
+from django.views.generic.edit import FormView
 
+from accounts.models import BlogUser
+from blog.models import Article
+from .forms import CommentForm
+from .models import Comment
 
-# Create your views here.
-# 注册视图类（继承自 FormView，处理表单提交）
-class RegisterView(FormView):
-     # 指定使用的表单类
-    form_class = RegisterForm
-    template_name = 'account/registration_form.html'
-    # 使用装饰器确保视图禁用缓存（never_cache）并启用 CSRF 防护
-    @method_decorator(csrf_protect)
-    def dispatch(self, *args, **kwargs):
-          # 调用父类方法处理请求
-        return super(RegisterView, self).dispatch(*args, **kwargs)
-       # 表单验证通过后的处理逻辑  
-    def form_valid(self, form):
-        # 再次检查表单有效性（冗余，因为 FormView 已验证）
-        if form.is_valid():
-              # 保存用户对象（但暂不激活 is_active=False）
-            user = form.save(False) 
-            user.is_active = False# 用户需验证邮箱后才能登录
-            user.source = 'Register'  # 标记用户来源为注册
-            user.save(True)# 实际保存到数据库
-
-            # 获取当前站点域名（用于生成验证链接）
-            site = get_current_site().domain
-            # 生成签名（双重 SHA256 哈希，用于验证链接安全性）
-            sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
-            # 开发环境使用本地地址（避免因域名未配置导致链接失效）
-            if settings.DEBUG:
-                site = '127.0.0.1:8000'
-
-            # 生成验证结果的 URL（如 /account/result/?type=validation&id=1&sign=abc123）
-            path = reverse('account:result')
-            url = "http://{site}{path}?type=validation&id={id}&sign={sign}".format(
-                site=site, path=path, id=user.id, sign=sign)
-            # 构造邮件内容（包含验证链接）
-            content = """
-                            <p>请点击下面链接验证您的邮箱</p>
 
-                            <a href="{url}" rel="bookmark">{url}</a>
+class CommentPostView(FormView):
+    form_class = CommentForm
+    template_name = 'blog/article_detail.html'
 
-                            再次感谢您！
-                            <br />
-                            如果上面链接无法打开，请将此链接复制至浏览器。
-                            {url}
-                            """.format(url=url)
-            # 发送验证邮件
-            send_email(
-                emailto=[
-                    user.email, # 收件人列表
-                ],
-                title='验证您的电子邮箱', # 邮件标题
-                content=content)# 邮件正文
-             # 重定向到注册结果页面（附带用户 ID）
-            url = reverse('accounts:result') + \
-                  '?type=register&id=' + str(user.id)
-            return HttpResponseRedirect(url)
-        else:
-            # 表单无效时重新渲染表单（显示错误信息）
-            return self.render_to_response({
-                'form': form
-            })
+    @method_decorator(csrf_protect)
+    def dispatch(self, *args, **kwargs):
+        return super(CommentPostView, self).dispatch(*args, **kwargs)
 
-# 登出视图，继承自RedirectView，重定向到登录页面
-class LogoutView(RedirectView):
-       # 登出后重定向的URL
-    url = '/login/'
-    # 使用never_cache装饰器确保视图不会被缓存
-    @method_decorator(never_cache)
-    def dispatch(self, request, *args, **kwargs):
-        # 调用父类的dispatch方法处理请求
-        return super(LogoutView, self).dispatch(request, *args, **kwargs)
-    # 处理GET请求
     def get(self, request, *args, **kwargs):
-        # 执行登出操作
-        logout(request)
-        # 删除侧边栏缓存
-        delete_sidebar_cache()
-        # 调用父类的get方法完成重定向
-        return super(LogoutView, self).get(request, *args, **kwargs)
-
-# 登录视图，继承自FormView
-class LoginView(FormView):
-    # 使用的表单类
-    form_class = LoginForm
-    # 模板文件路径
-    template_name = 'account/login.html'
-    # 登录成功后跳转的URL
-    success_url = '/'
-    # 重定向字段名
-    redirect_field_name = REDIRECT_FIELD_NAME
-    # 登录会话有效期（一个月的时间，单位：秒）
-    login_ttl = 2626560  # 一个月的时间
-    # 使用多个装饰器装饰dispatch方法
-    @method_decorator(sensitive_post_parameters('password'))# 标记密码参数为敏感信息
-    @method_decorator(csrf_protect) # 启用CSRF保护
-    @method_decorator(never_cache)# 禁止缓存
-    def dispatch(self, request, *args, **kwargs):
-        # 调用父类的dispatch方法处理请求
-        return super(LoginView, self).dispatch(request, *args, **kwargs)
-
-    # 获取模板上下文数据
-    def get_context_data(self, **kwargs):
-        # 从GET参数中获取重定向URL
-        redirect_to = self.request.GET.get(self.redirect_field_name)
-        # 如果不存在则设置为根路径
-        if redirect_to is None:
-            redirect_to = '/'
-        # 将重定向URL添加到上下文
-        kwargs['redirect_to'] = redirect_to
-        # 调用父类方法获取其他上下文数据
-
-        return super(LoginView, self).get_context_data(**kwargs)
-    # 表单验证通过后的处理
-    def form_valid(self, form):
-         # 重新创建认证表单（这里可能有逻辑问题，因为form已经传入）
-        form = AuthenticationForm(data=self.request.POST, request=self.request)
-        # 再次验证表单
-        if form.is_valid():
-            # 删除侧边栏缓存
-            delete_sidebar_cache()
-            # 记录日志
-            logger.info(self.redirect_field_name)
-
-            # 登录用户
-            auth.login(self.request, form.get_user())
-            # 如果用户选择了"记住我"
-            if self.request.POST.get("remember"):
-                # 设置较长的会话过期时间
-                self.request.session.set_expiry(self.login_ttl)
-            # 调用父类方法处理成功跳转
-            return super(LoginView, self).form_valid(form)
-            # return HttpResponseRedirect('/')
-        else:
-            # 表单无效，重新渲染表单并显示错误
-            return self.render_to_response({
-                'form': form
-            })
-   # 获取成功后的跳转URL
-    def get_success_url(self):
-
-        # 从POST参数中获取重定向URL
-        redirect_to = self.request.POST.get(self.redirect_field_name)
-         # 检查URL是否安全
-        if not url_has_allowed_host_and_scheme(
-                url=redirect_to, allowed_hosts=[
-                    self.request.get_host()]):
-            # 如果不安全则使用默认成功URL
-            redirect_to = self.success_url
-        return redirect_to
-
-# 账户操作结果页面（如注册成功、邮箱验证等）
-def account_result(request):
-    # 从GET参数中获取类型和用户ID
-    type = request.GET.get('type')
-    id = request.GET.get('id')
-    # 获取用户对象，如果不存在返回404
-    user = get_object_or_404(get_user_model(), id=id)
-    logger.info(type)
-    # 如果用户已激活，直接重定向到首页
-    if user.is_active:
-        return HttpResponseRedirect('/')
-    # 检查类型参数是否有效    
-    if type and type in ['register', 'validation']:
-        if type == 'register':
-            content = '''
-    恭喜您注册成功，一封验证邮件已经发送到您的邮箱，请验证您的邮箱后登录本站。
-    '''
-            title = '注册成功'
-        else:
-            # 生成验证签名
-            c_sign = get_sha256(get_sha256(settings.SECRET_KEY + str(user.id)))
-            # 获取请求中的签名
-            sign = request.GET.get('sign')
-            # 验证签名是否匹配
-            if sign != c_sign:
-                return HttpResponseForbidden()
-            # 激活用户账户
-            user.is_active = True
-            user.save()
-            # 验证成功提示内容
-            content = '''
-            恭喜您已经成功的完成邮箱验证，您现在可以使用您的账号来登录本站。
-            '''
-            title = '验证成功'
-            # 渲染结果页面
-        return render(request, 'account/result.html', {
-            'title': title,
-            'content': content
+        article_id = self.kwargs['article_id']
+        article = get_object_or_404(Article, pk=article_id)
+        url = article.get_absolute_url()
+        return HttpResponseRedirect(url + "#comments")
+
+    def form_invalid(self, form):
+        article_id = self.kwargs['article_id']
+        article = get_object_or_404(Article, pk=article_id)
+
+        return self.render_to_response({
+            'form': form,
+            'article': article
         })
-    else:
-        # 无效类型重定向到首页
-        return HttpResponseRedirect('/')
-
-# 忘记密码视图，继承自FormView
-class ForgetPasswordView(FormView):
-    # 使用的表单类
-    form_class = ForgetPasswordForm
-    # 模板文件路径
-    template_name = 'account/forget_password.html'
 
-
-    # 表单验证通过后的处理
     def form_valid(self, form):
-        if form.is_valid():
-            # 根据邮箱获取用户对象
-            blog_user = BlogUser.objects.filter(email=form.cleaned_data.get("email")).get()
-            # 设置新密码（加密）
-            blog_user.password = make_password(form.cleaned_data["new_password2"])
-            # 保存用户对象
-            blog_user.save()
-            # 重定向到登录页面
-            return HttpResponseRedirect('/login/')
-        else:
-            # 表单无效，重新渲染表单并显示错误
-            return self.render_to_response({'form': form})
-
-# 忘记密码验证码发送视图，继承自View
-class ForgetPasswordEmailCode(View):
-    # 处理POST请求
-    def post(self, request: HttpRequest):
-        # 验证表单
-        form = ForgetPasswordCodeForm(request.POST)
-        if not form.is_valid():
-            # 表单无效返回错误
-            return HttpResponse("错误的邮箱")
-        # 获取邮箱地址
-        to_email = form.cleaned_data["email"]
-        # 生成验证码
-        code = generate_code()
-        # 发送验证邮件
-        utils.send_verify_email(to_email, code)
-        # 存储验证码（通常有有效期）
-        utils.set_code(to_email, code)
-        # 返回成功响应
-        return HttpResponse("ok")
+        """提交的数据验证合法后的逻辑"""
+        user = self.request.user
+        author = BlogUser.objects.get(pk=user.pk)
+        article_id = self.kwargs['article_id']
+        article = get_object_or_404(Article, pk=article_id)
+
+        if article.comment_status == 'c' or article.status == 'c':
+            raise ValidationError("该文章评论已关闭.")
+        comment = form.save(False)
+        comment.article = article
+        from djangoblog.utils import get_blog_setting
+        settings = get_blog_setting()
+        if not settings.comment_need_review:
+            comment.is_enable = True
+        comment.author = author
+
+        if form.cleaned_data['parent_comment_id']:
+            parent_comment = Comment.objects.get(
+                pk=form.cleaned_data['parent_comment_id'])
+            comment.parent_comment = parent_comment
+
+        comment.save(True)
+        return HttpResponseRedirect(
+            "%s#div-comment-%d" %
+            (article.get_absolute_url(), comment.pk))