Python 如何允许用户删除和编辑他们在Django中创建的帖子？

我试图让用户删除和编辑他们创建的帖子。我被告知“Post.user需要是一个对象实例，您编写的内容不正确。”但我对django还是比较新的，我想知道在帮助下创建此项目的步骤

这是我的模型

        from django.db import models

        from django.db.models import Count, QuerySet, F
        from django.utils import timezone
        from django.conf import settings
        from django.contrib.contenttypes.models import ContentType
        from django.core.urlresolvers import reverse
        from django.db.models.signals import pre_save
        from django.utils.text import slugify
        from markdown_deux import markdown
        from django.utils.safestring import mark_safe
        from taggit.managers import TaggableManager

        from comments.models import Comment

        def upload_location(instance, filename):
            return "%s/%s" %(instance.slug, filename)


        class Post(models.Model):
            user = models.ForeignKey(settings.AUTH_USER_MODEL, default=1 )
            title = models.CharField(max_length=75)
            slug = models.SlugField(unique=True)
            image = models.ImageField(
                    upload_to=upload_location,
                    null=True,
                    blank=True,
                    width_field="width_field",
                    height_field="height_field")
            height_field = models.IntegerField(default=0)
            width_field = models.IntegerField(default=0)
            description = models.TextField()
            tags = TaggableManager()
            public = models.BooleanField(default=False)
            updated = models.DateTimeField(auto_now_add=False, auto_now=True)
            created = models.DateTimeField(auto_now_add=True, auto_now=False)


            def __str__(self):
                return self.title

            def get_absolute_url(self):
                return reverse("posts:detail", kwargs={"slug": self.slug})

            class Meta:
                ordering = ["-created", "-updated" ]

            def get_markdown(self):
                description = self.description
                markdown_text = markdown(description)
                return mark_safe(markdown_text)

            @property
            def comments(self):
                instance = self
                qs = Comment.objects.filter_by_instance(instance)
                return qs

            @property
            def get_content_type(self):
                instance = self
                content_type = ContentType.objects.get_for_model(instance.__class__)
                return content_type


        def create_slug(instance, new_slug=None):
                slug = slugify(instance.title)
                if new_slug is not None:
                    slug = new_slug
                qs = Post.objects.filter(slug=slug).order_by("-id")
                exists = qs.exists()
                if exists:
                    new_slug = "%s-%s" %(slug, qs.first().id)
                    return create_slug(instance, new_slug=new_slug)
                return slug



        def pre_save_post_receiver(sender, instance, *args, **kwargs):
            if not instance.slug:
                instance.slug = create_slug(instance)


        pre_save.connect(pre_save_post_receiver, sender=Post)

以下是我的看法

            from django.contrib import messages
            from django.contrib.contenttypes.models import ContentType
            from django.core.paginator import Paginator, EmptyPage,   PageNotAnInteger
            from django.shortcuts import render
            from django.contrib.auth.decorators import login_required


            from django.db.models import Q
            from django.http import HttpResponse, HttpResponseRedirect, Http404
            from django.shortcuts import render, get_object_or_404, redirect
            from django.core.exceptions import PermissionDenied


            from comments.forms import CommentForm
            from comments.models import Comment
            from .forms import PostForm
            from .models import Post


            def post_main(request):
                return render(request, "base2.html")

            @login_required
            def post_create(request):
                form = PostForm(request.POST or None, request.FILES or None)
                if form.is_valid():
                    instance = form.save(commit=False)
                    instance.user = request.user
                    instance.save()
                    # message success
                    messages.success(request, "Successfully Created")
                    return HttpResponseRedirect(instance.get_absolute_url())
                context = {
                    "form": form,
                }
                return render(request, "post_form.html", context)

            @login_required
            def post_update(request, slug=None):
                    instance = get_object_or_404(Post, slug=slug)
                    form = PostForm(request.POST or None, request.FILES or None, instance=instance)
                    if form.is_valid():
                        instance = form.save(commit=False)
                        instance.save()
                        messages.success(request, "Post Saved")
                        return HttpResponseRedirect(instance.get_absolute_url())

                    context = {
                    "title": instance.title,
                    "instance": instance,
                    "form":form
                    }

                    return render(request, "post_form.html", context)


            def post_user(request):

                return HttpResponse("<h1>Users Post</h1>")

            @login_required
            def post_detail(request, slug=None):
                instance = get_object_or_404(Post, slug=slug)

                initial_data = {
                    "content_type": instance.get_content_type,
                    "object_id": instance.id
                }
                form = CommentForm(request.POST or None, initial=initial_data)
                if form.is_valid() and request.user.is_authenticated():
                    c_type = form.cleaned_data.get("content_type")
                    content_type = ContentType.objects.get(model=c_type)
                    obj_id = form.cleaned_data.get('object_id')
                    content_data = form.cleaned_data.get("content")
                    parent_obj = None
                    try:
                        parent_id = int(request.POST.get("parent_id"))
                    except:
                        parent_id = None

                    if parent_id:
                        parent_qs = Comment.objects.filter(id=parent_id)
                        if parent_qs.exists() and parent_qs.count() == 1:
                            parent_obj = parent_qs.first()


                    new_comment, created = Comment.objects.get_or_create(
                                        user = request.user,
                                        content_type= content_type,
                                        object_id = obj_id,
                                        content = content_data,
                                        parent = parent_obj,
                                    )
                    return HttpResponseRedirect(new_comment.content_object.get_absolute_url())


                comments = instance.comments
                context = {
                    "title": instance.title,
                    "instance": instance,
                    "comments": comments,
                    "comment_form":form,
            }
                return render(request, "post_detail.html", context)

            @login_required
            def post_feed(request):
                queryset_list = Post.objects.all()
                query = request.GET.get("q")
                if query:
                    queryset_list = queryset_list.filter(
                            Q(title__icontains=query)|
                            Q(tags__icontains=query)|
                            Q(content__icontains=query)|
                            Q(user__first_name__icontains=query) |
                            Q(user__last_name__icontains=query)
                            ).distinct()
                paginator = Paginator(queryset_list, 8) # Show 25 contacts per page
                page_request_var = "page"
                page = request.GET.get(page_request_var)
                try:
                    queryset = paginator.page(page)
                except PageNotAnInteger:
                    # If page is not an integer, deliver first page.
                    queryset = paginator.page(1)
                except EmptyPage:
                    # If page is out of range (e.g. 9999), deliver last page of results.
                    queryset = paginator.page(paginator.num_pages)


                context = {
                    "object_list": queryset,
                    "title": "List",
                    "page_request_var": page_request_var,
                }
                return render(request, "post_feed.html", context)

            @login_required
            def post_delete(request,  slug=None):
                instance = get_object_or_404(Post, slug=slug)
                if request.user == Post.user:
                    instance.delete() # or save edits
                    messages.success(request, "Successfully Deleted")
                    return redirect("posts:feed")
                else:
                    raise PermissionDenied # import it from django.core.exceptions
                    return redirect("posts:feed")

            def privacy(request):
                    return render(request, "privacy.html")

            def post_about(request):
                return HttpResponse("<h1>About Page</h1>")

            def home(request):
                return render(request, "base2.html")

来自django.contrib导入消息的

从django.contrib.contenttypes.models导入ContentType
从django.core.paginator导入paginator、EmptyPage、PageNotAnInteger
从django.shortcuts导入渲染
从django.contrib.auth.decorators导入所需的登录名
从django.db.models导入Q
从django.http导入HttpResponse、HttpResponseRedirect、Http404
从django.shortcuts导入渲染，获取对象或重定向
从django.core.exceptions导入权限被拒绝
从comments.forms导入CommentForm
从comments.models导入注释
from.forms导入PostForm
从。模型导入后
def post_干管（请求）：
返回呈现（请求“base2.html”）
@需要登录
def post_创建（请求）：
form=PostForm（request.POST或None，request.FILES或None）
如果form.is_有效（）：
instance=form.save（commit=False）
instance.user=request.user
save（）实例
#消息成功
messages.success（请求“成功创建”）
返回HttpResponseRedirect（instance.get\u absolute\u url（））
上下文={
“形式”：形式，
}
返回呈现（请求“post_form.html”，上下文）
@需要登录
def post_更新（请求，slug=None）：
实例=获取对象或404（Post，slug=slug）
form=PostForm（request.POST或None，request.FILES或None，instance=instance）
如果form.is_有效（）：
instance=form.save（commit=False）
save（）实例
messages.success（请求“Post Saved”）
返回HttpResponseRedirect（instance.get\u absolute\u url（））
上下文={
“title”：instance.title，
“实例”：实例，
“形式”：形式
}
返回呈现（请求“post_form.html”，上下文）
def post_用户（请求）：
返回HttpResponse（“用户帖子”）
@需要登录
def post_详细信息（请求，段塞=无）：
实例=获取对象或404（Post，slug=slug）
初始数据={
“内容类型”：instance.get\u content\u type，
“object_id”：instance.id
}
表单=评论表单（request.POST或None，initial=初始数据）
如果form.is_valid（）和request.user.is_authenticated（）：
c_type=form.cleaned_data.get（“content_type”）
content\u type=ContentType.objects.get（model=c\u type）
obj_id=form.cleaned_data.get（'object_id'））
content\u data=form.cleaned\u data.get（“内容”）
父对象=无
尝试：
parent\u id=int（request.POST.get（“parent\u id”））
除：
父项id=无
如果父项id为：
parent\u qs=Comment.objects.filter（id=parent\u id）
如果父项存在（）且父项计数（）=1：
parent_obj=parent_qs.first（）
new_comment，created=comment.objects.get_或_create(
user=request.user，
内容类型=内容类型，
对象id=对象id，
内容=内容和数据，
父对象=父对象，
)
返回HttpResponseRedirect（new\u comment.content\u object.get\u absolute\u url（））
comments=instance.comments
上下文={
“title”：instance.title，
“实例”：实例，
“评论”：评论，
“评论表格”：表格，
}
返回渲染（请求“post_detail.html”，上下文）
@需要登录
def post_提要（请求）：
queryset_list=Post.objects.all（）
query=request.GET.GET（“q”）
如果查询：
queryset_list=queryset_list.filter(
Q（title\uu icontains=query）|
Q（标记\uuuiCONTAINS=查询）|
Q（内容包含=查询）|
Q（user\u first\u name\u icontains=query）|
Q（用户姓氏icontains=query）
).distinct（）
paginator=paginator（查询列表，8）#每页显示25个联系人
page\u request\u var=“page”
page=request.GET.GET（page\u request\u var）
尝试：
queryset=paginator.page（第页）
除第页外，第页：
#若页面不是整数，则交付第一页。
queryset=paginator.第（1）页
除空页外：
#如果页面超出范围（例如9999），则提供最后一页结果。
queryset=paginator.page（paginator.num_页面）
上下文={
request.user == instance.user

request.user == Post.user

if instance.user == request.user:
    #Now, allow update

if request.method == "POST":