Python Django uses forms to implement comment functionality

It seems that Django has given up the use of its own comments since version 1.6. The specific reason has not been investigated, but now the comment function can also be implemented using Django’s internal module, that is, with the help of the forms module. Here is mine A small example.

Environment preparation
•Operating system: windows 7 64-bit ultimate version
•IDE: PyCharm 2016.1
•Python:2.7.11
•Django:1.9.6

Design

The so-called design refers to the underlying model that will be involved in the comment function we are going to implement. My simple design here is as follows. You can set it as you like according to your own ideas. My settings here can be found in the models.py file:

from __future__ import unicode_literals
from django.contrib import admin
from django.db import models
from django import forms
# Create your models here.
TOPIC_CHOICES = (
  ('level1','Bad'),
  ('level2','SoSo'),
  ('level3','Good'),
)
 
class RemarkForm(forms.Form):
  subject = forms.CharField(max_length=100,label='Mark Board')
  mail = forms.EmailField(label='email')
  topic = forms.ChoiceField(choices=TOPIC_CHOICES,label='choose one topic')
  message = forms.CharField(label='content for mark',widget=forms.Textarea)
  cc_myself = forms.BooleanField(required=False,label='watch this tie')
 
class Remark(models.Model):
  subject = models.CharField(max_length=100)
  mail = models.EmailField()
  topic = models.CharField(max_length=100)
  message = models.CharField(max_length=300)
  cc_myself = models.BooleanField()
 
  def __unicode__(self):
    return self.subject
 
  class Meta:
    ordering = ['subject']
 
 
admin.site.register([Remark,])

Everyone has seen it, models.py file There is an additional subclass of forms, this time because our operation involves web forms. In this case, it is best to create a Form form class for each model class to facilitate obtaining cleaned_data from the form.

url mapping file urls.py

This file is relatively simple, as follows:

"""FormRelative URL Configuration
 
The `urlpatterns` list routes URLs to views. For more information please see:
  https://docs.djangoproject.com/en/1.9/topics/http/urls/
Examples:
Function views
  1. Add an import: from my_app import views
  2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
  1. Add an import: from other_app.views import Home
  2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
  1. Import the include() function: from django.conf.urls import url, include
  2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from app.views import *
urlpatterns = [
  url(r'^admin/', admin.site.urls),
  url(r'^remark/$',reamark),
]
   
 视图层views.py

This file determines the display view corresponding to the mapping file, so compare importance.

from django.shortcuts import render
from app.models import *
from django.http import *
 
# Create your views here.
# subject = models.CharField(max_length=100)
#   mail = models.EmailField()
#   topic = models.CharField(max_length=100)
#   message = models.CharField(max_length=300)
#   cc_myself = models.BooleanField()
 
def reamark(request):
  if request.method =="POST":
    form = RemarkForm(request.POST)
    if form.is_valid():
      myremark = Remark()
      myremark.subject=form.cleaned_data['subject']
      myremark.mail = form.cleaned_data['mail']
      myremark.topic = form.cleaned_data['topic']
      myremark.message = form.cleaned_data['message']
      myremark.cc_myself = form.cleaned_data['cc_myself']
      myremark.save()
      # return HttpResponse("Publish Success!")
  else:
    form = RemarkForm()
 
  ctx = {
    'form':form,
    'ties':Remark.objects.all()
  }
  return render(request,'message.html',ctx)

Templates templates/message.html

The use of templates greatly reduces the amount of data and enables more flexible data display The separation of layers reduces the coupling between modules.

  
  



  {% for field in form %}
  {% csrf_token %}
  

    {{ field.label_tag }}:{{ field }}
    {{ field.errors }}
  
  {% endfor %}

  



{% for tie in ties %}
  

  

    
{{ tie.subject }}
    
{{ tie.mail}}
    
{{ tie.topic}}
    
{{ tie.message }}
    
{{ tie.cc_myself }}
  
  

  
{% endfor%}

Note that the reissue tags and template variables have been declared in the remark method of views.py, so they can be used directly.

Initialize the database

The sqlite database is used here. The configuration in the settings.py file is as follows;

# Database
# https://docs.djangoproject.com/en/1.9/ref/settings/#databases
 
DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.sqlite3',
    'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
  }
}

Then in the terminal Environment, enter the following commands:

// 创建数据库表结构
python manage.py makemigrations
 
python manage.py migrate
 
// 按照提示进行操作即可，目的是为了创建一个超级管理员
python createsuperuser
 
//在自带的开发服务器上运行我们的项目
python manage.py runserver

Debug Verification

Here we enter in the browser
127.0.0.1:8000/admin
You can see the following

Then enter 127.0.0.1:8000/remark

Database side:

In this way, except for the beautification of the interface, the rest is completed.

Summary

Although this is a very simple example, I also discovered some conceptual problems of my own, such as the unreasonable model design because there is no comment time. This seems very embarrassing.

Then

if request.method =="POST":
    form = RemarkForm(request.POST)
    if form.is_valid():
      myremark = Remark()
      myremark.subject=form.cleaned_data['subject']
      myremark.mail = form.cleaned_data['mail']
      myremark.topic = form.cleaned_data['topic']
      myremark.message = form.cleaned_data['message']
      myremark.cc_myself = form.cleaned_data['cc_myself']
      myremark.save()
      # return HttpResponse("Publish Success!")
  else:
    form = RemarkForm()
 
  ctx = {
    'form':form,
    'ties':Remark.objects.all()
  }
  return render(request,'message.html',ctx)

This code, the action in the corresponding form is. This means that the form is submitted to this page, and the comment on the form data is realized. , this is very clever. And there is another advantage of using this feature of Django, that is, asynchronous loading of comments can still be achieved without manually refreshing the page.

Finally, it is the consistency of the Remark model and the RemarkForm form attributes in the model. You should pay special attention to this!

Okay, that’s it for today. Due to my average ability, if there are any mistakes in the code or logic, everyone is welcome to criticize and correct me!

The above is the entire content of this article. I hope it will be helpful to everyone's learning. I also hope that everyone will support the PHP Chinese website.

For more Python Django uses forms to implement the comment function, please pay attention to the PHP Chinese website!