pip install django-toolbelt

Error: pg_config executable not found.

8.1. Forms - Basic Workflow 略

The basic steps involved in creating a form and allowing users to enter data via the form is as follows.

This workflow is a bit more complicated than previous workflows, and the views that we have to construct have a lot more complexity as well. However, once you undertake the process a few times it will be pretty clear how everything pieces together.

If you haven’t already got one, create a forms.py file within your Django application’s directory to store form-related classes.

Create a ModelForm class for each model that you wish to represent as a form.

Customise the forms as you desire.

Create or update a view to handle the form - including displaying the form, saving the form data, and flagging up errors which may occur when the user enters incorrect data (or no data at all) in the form.

Create or update a template to display the form.

Add a urlpattern to map to the new view (if you created a new one).

Function: add comment

9. User Authentication 略

11. Cookies and Sessions 略

13. Bootstrapping Blog

from django.contrib import admin
from blog.models import Category, Article

# Register your models here.

admin.site.register(Category)
admin.site.register(Article)

you can check out the official Django documentation on the admin interface for more information if you’re interested.

• Database

Basic Workflows

Now that we’ve covered the core principles of dealing with Django’s models functionality, now is a good time to summarise the processes involved in setting everything up. We’ve split the core tasks into separate sections for you.

    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

import os
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tango_with_django_project.settings')

import django
django.setup()

from rango.models import Category, Page


def populate():
    python_cat = add_cat('Python')

    add_page(cat=python_cat,
        title="Official Python Tutorial",
        url="http://docs.python.org/2/tutorial/")

    add_page(cat=python_cat,
        title="How to Think like a Computer Scientist",
        url="http://www.greenteapress.com/thinkpython/")

    add_page(cat=python_cat,
        title="Learn Python in 10 Minutes",
        url="http://www.korokithakis.net/tutorials/python/")

    django_cat = add_cat("Django")

    add_page(cat=django_cat,
        title="Official Django Tutorial",
        url="https://docs.djangoproject.com/en/1.5/intro/tutorial01/")

    add_page(cat=django_cat,
        title="Django Rocks",
        url="http://www.djangorocks.com/")

    add_page(cat=django_cat,
        title="How to Tango with Django",
        url="http://www.tangowithdjango.com/")

    frame_cat = add_cat("Other Frameworks")

    add_page(cat=frame_cat,
        title="Bottle",
        url="http://bottlepy.org/docs/dev/")

    add_page(cat=frame_cat,
        title="Flask",
        url="http://flask.pocoo.org")

    # Print out what we have added to the user.
    for c in Category.objects.all():
        for p in Page.objects.filter(category=c):
            print "- {0} - {1}".format(str(c), str(p))

def add_page(cat, title, url, views=0):
    p = Page.objects.get_or_create(category=cat, title=title)[0]
        p.url=url
        p.views=views
        p.save()
    return p

def add_cat(name):
    c = Category.objects.get_or_create(name=name)[0]
    return c

# Start execution here!
if __name__ == '__main__':
    print "Starting Rango population script..."
    populate()

关于Deploy #TODO(leifos): the DEBUG variable in settings.py, lets you control the output when an error occurs, and is used for debugging. When the application is deployed it is not secure to leave DEBUG equal to True. When you set DEBUG to be False, then you will need to set the ALLOWED_HOSTS variable in settings.py, when running on your local machine this would be 127.0.0.1. You will also need to update the project urls.py file:

上传Media 与static, templates并列建立文件夹media; 在PersonalWebsite/urls.py里加入

# At the top of your urls.py file, add the following line:
from django.conf import settings

# UNDERNEATH your urlpatterns definition, add the following two lines:
if settings.DEBUG:
    urlpatterns += patterns(
        'django.views.static',
        (r'^media/(?P<path>.*)',
        'serve',
        {'document_root': settings.MEDIA_ROOT}), )

The settings module from django.conf allows us access to the variables defined within our project’s settings.py file. The conditional statement then checks if the Django project is being run in DEBUGmode. If the project’s DEBUG setting is set to True, then an additional URL matching pattern is appended to the urlpatterns tuple. The pattern states that for any file requested with a URL starting with media/, the request will be passed to the django.views.static view. This view handles the dispatching of uploaded media files for you.

编辑PersonalWebsite/settings.py 加入

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media') # Absolute path to the media directory

Summary

Creating a template and integrating it within a Django view is a key concept for you to understand. It takes several steps, but becomes second nature to you after a few attempts.

The steps involved for getting a static media file onto one of your pages is another important process you should be familiar with. Check out the steps below on how to do this.

First, create the template you wish to use and save it within the templates directory you specified in your project’s settings.py file. You may wish to use Django template variables (e.g. {{variable_name }}) within your template. You’ll be able to replace these with whatever you like within the corresponding view.

Find or create a new view within an application’s views.py file.

Add your view-specific logic (if you have any) to the view. For example, this may involve extracting data from a database.

Within the view, construct a dictionary object which you can pass to the template engine as part of the template’s context.

Make use of the  render() helper function to generate the rendered response. Ensure you reference the request, then the template file, followed by the context dictionary!

If you haven’t already done so, map the view to a URL by modifying your project’s urls.py file - and the application-specific urls.py file if you have one.

Take the static media file you wish to use and place it within your project’s static directory. This is the directory you specify in your project’s STATICFILES_DIRS tuple within settings.py.

Add a reference to the static media file to a template. For example, an image would be inserted into an HTML page through the use of the <img /> tag.

Remember to use the {% load staticfiles %} and {% static "filename" %} commands within the template to access the static files.

建立templates文件夹与Blog，PersonalWebsite并列

建立templates/blog/index.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    <h1>Librius says...</h1>
    hello world! <strong>{{ boldmessage }}</strong><br/>
    <a href="/blog/">Blog.index</a><br/>
</body>
</html>

修改Blog/views.py

from django.shortcuts import render
from django.http import HttpResponse

# Create your views here.
def index(request):

    # Construct a dictionary to pass to the template engine as its context.
    # Note the key boldmessage is the same as {{ boldmessage }} in the template!
    context_dict = {'boldmessage': "I am bold font from the context"}

    # Return a rendered response to send to the client.
    # We make use of the shortcut function to make our lives easier.
    # Note that the first parameter is the template we wish to use.

    return render(request, 'blog/index.html', context_dict)

在settings.py里设置template的path

TEMPLATE_PATH = os.path.join(BASE_DIR, 'templates’)

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [TEMPLATE_PATH, ],
        'APP_DIRS': False,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

• There are five main steps that you must undertake to create a data driven webpage in Django.

  1. First, import the models you wish to use into your application’s views.py file.
  2. Within the view you wish to use, query the model to get the data you want to present.
  3. Pass the results from your model into the template’s context.
  4. Setup your template to present the data to the user in whatever way you wish.
  5. If you have not done so already, map a URL to your view.
   
• blog/view.py

在index(request)下加入：

category_list = Category.objects.order_by(‘id’) context_dict = {'categories': category_list}

在template/blog/index.html里<body>加入

{% if categories %}
    <ul>
        {% for category in categories %}
            <li>{{ category.name }}</li>
        {% endfor %}
    </ul>
{% else %}
    <strong>There are no categories present.</strong>
{% endif %}

• we could just use the category name as part of the URL. 

在blog/models.py里class Category

        slug = models.SlugField(unique=True)

        def save(self, *args, **kwargs):
                self.slug = slugify(self.name)
                super(Category, self).save(*args, **kwargs)

• 对已存在的row添加slug值，修改blog/admin.py

from django.contrib import admin
from blog.models import Category, Article

# Register your models here.

class CategoryAdmin(admin.ModelAdmin):
    prepopulated_fields = {'slug':('name',)}

admin.site.register(Category, CategoryAdmin)
admin.site.register(Article)

•  Category Page Workflow

  With our URLs design chosen, let’s get started. We’ll undertake the following steps.

  We’ll also need to update the index() view and index.html template to provide links to the category page view.

  1. Import the Page model into blog/views.py.

  2. Create a new view in blog/views.py - called category - The category view will take an additional parameter, category_name_url which will stored the encoded category name.

      

     • We will need some help functions to encode and decode the category_name_url.

      

     from blog.models import Category, Article
     from django.http import HttpResponse
     
     # Create your views here.
     
     def category(request, category_name_slug):
     
         # Create a context dictionary which we can pass to the template rendering engine.
         context_dict = {}
     
         try:
             # Can we find a category name slug with the given name?
             # If we can't, the .get() method raises a DoesNotExist exception.
             # So the .get() method returns one model instance or raises an exception.
             category = Category.objects.get(slug=category_name_slug)
             context_dict['category_name'] = category.name
     
             # Retrieve all of the associated pages.
             # Note that filter returns >= 1 model instance.
             articles = Article.objects.filter(category=category)
     
             # Adds our results list to the template context under name pages.
             context_dict['article'] = articles
             # We also add the category object from the database to the context dictionary.
             # We'll use this in the template to verify that the category exists.
             context_dict['category'] = category
         except Category.DoesNotExist:
             # We get here if we didn't find the specified category.
             # Don't do anything - the template displays the "no category" message for us.
             pass
     
         # Go render the response and return it to the client.
         return render(request, 'blog/category.html', context_dict)

  3. Create a new template, templates/blog/category.html.

     <!DOCTYPE html>
     <html>
     <head>
         <title>Blog</title>
     </head>
     
     <body>
     <h1>{{ category_name }}</h1>
     {% if category %}
         {% if articles %}
             <ul>
                 {% for article in articles %}
                     <li>{{ article.title }}</li>
                 {% endfor %}
             </ul>
         {% else %}
             <strong>No pages currently in category.</strong>
         {% endif %}
     {% else %}
         The specified category {{ category_name }} does not exist!
     {% endif %}
     </body>
     </html>

  4. Update Rango’s urlpatterns to map the new category view to a URL pattern in blog/urls.py.

     url(r'^category/(?P<category_name_slug>[\w\-]+)/$', views.category, name='category’),

     5. add category link on the index, update blog/index.html

     <li><a href="/rango/category/{{ category.slug }}">{{ category.name }}</a></li>

  • Undertake the part three of official Django tutorial if you have not done so already to further what you’ve learnt here.

• 加入Articles
  ​

blog/models.py

class Article(models.Model):
    category = models.ForeignKey(Category)
    created = models.DateTimeField(auto_now=True)
    modified = models.DateTimeField(auto_now_add=True)
    title = models.CharField(max_length=128, unique=True)
    text = models.TextField()
    views = models.IntegerField(default=0)
    slug = models.SlugField(unique=True)

    def save(self, *args, **kwargs):
        self.slug = slugify(self.title)
        super(Article, self).save(*args, **kwargs)

    def __unicode__(self):      # For Python 2, use __str__ on Python 3
        return self.title

blog/views.py

def article(request, article_title_slug):

    # Create a context dictionary which we can pass to the template rendering engine.
    context_dict = {}

    try:
        print article_title_slug
        theArticle = Article.objects.get(slug=article_title_slug)
        context_dict['article'] = theArticle
        context_dict['article_name'] = theArticle.title
        context_dict['article_content'] = theArticle.text
    except Category.DoesNotExist:
        # We get here if we didn't find the specified category.
        # Don't do anything - the template displays the "no category" message for us.
        pass

    # Go render the response and return it to the client.
    return render(request, 'blog/article.html', context_dict)

blog/urls.py

url(r'^article/(?P<article_title_slug>[\w\-]+)/$', views.article, name='article'),

templates/blog/article.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>Article Webpage</title>
</head>
<body>

{% if article %}
<h1>{{ article_name }}</h1>

   <p> {{ article_content }} </p>

{% else %}
    The article does not exist!
{% endif %}

</body>
</html>

templates/blog/category.html

<li><a href="/blog/article/{{ article.slug }}">{{ article.title }}</a></li>

• Referring to URLs in Templates

  So far we have been directly coding the URL of the page/view we want to show within the template, i.e. <a href="/rango/about/"> About  </a>. However, the preferred way is to use the template tag url to look up the url in the urls.py files. To do this we can change the way we reference the URL as follows:

  <li><a href="{% url 'about' %}">About</a></li>
  

  The Django template engine will look up the urls.py files for a url with the name='about' (and then reverse match the actual url). This means if we change the url mappings in urls.py then we do not have to go through all the templates and update them. If we had not given our urlpattern a name, we could directly reference it as follows:

  <li><a href="{% url 'rango.views.about' %}">About</a></li>
  

  Here we need to specify the application, and the view about.

  You can now update the base template with the url template tag so that links in base template are rendered using the following code:

  <div>
          <ul>
      {% if user.is_authenticated %}
          <li><a href="{% url 'restricted' %}">Restricted Page</a></li>
          <li><a href="{% url 'logout' %}">Logout</a></li>
          <li><a href="{% url 'add_category' %}">Add a New Category</a></li>
      {% else %}
          <li><a href="{% url 'register' %}">Register Here</a></li>
          <li><a href="{% url 'login' %}">Login</a></li>
      {% endif %}
  
      <li><a href="{% url 'about' %}">About</a></li>
      </ul>
  </div>
  

  In your index.html template you will notice that you have a parameterized url pattern, i.e. the categoryurl/view takes the category.slug as a parameter. To handle this you can pass the url template tag the name of the url/view and the slug, i.e. {% url ‘category’ category.slug %} within the template, as follows:

  {% for category in categories %}
      <li><a href="{% url 'category'  category.slug %}">{{ category.name }}</a></li>
  {% endfor %}
  

  #TODO(leifos): The official tutorial provides an overview of how to use the url template tag, http://django.readthedocs.org/en/latest/intro/tutorial03.html and the answer at stackoverflow was helpful too: http://stackoverflow.com/questions/4599423/using-url-in-django-templates

  #TODO(leifos): Also point out how the urls can be placed in a namespace and referenced accordingly, see http://django.readthedocs.org/en/latest/intro/tutorial03.html

这里的name是对该映射的命名，以便区分，或者反映射。另外要注意import进来的包urls.py应该给每一个app建立，所以映射文件里可以把url映射到文件的相对路径

• blog/models.py
  
  

  from django.db import models
  from django.template.defaultfilters import slugify
  
  # Create your models here.
  class Category(models.Model):
      name = models.CharField(max_length=128, unique=True)
      slug = models.SlugField(unique=True)
  
      def save(self, *args, **kwargs):
          self.slug = slugify(self.name)
          super(Category, self).save(*args, **kwargs)
  
      def __unicode__(self):  # For Python 2, use __str__ on Python 3
          return self.name
  
  class Article(models.Model):
      category = models.ForeignKey(Category)
      created = models.DateTimeField(auto_now=True)
      modified = models.DateTimeField(auto_now_add=True)
      title = models.CharField(max_length=128, unique=True)
      text = models.TextField()
      views = models.IntegerField(default=0)
      slug = models.SlugField(unique=True)
  
      def save(self, *args, **kwargs):
          self.slug = slugify(self.title)
          super(Article, self).save(*args, **kwargs)
  
      def __unicode__(self):      # For Python 2, use __str__ on Python 3
          return self.title

这里定义了两个数据模型，Category和Article，每个class的属性看名字就能理解了。有一个重点是save：这里运用了slug，有了这个在点击查看博文的时候，url里面会出现博文的名字而不是一些数字或者别的没有意义的符号们。

第一次操作还要创建管理员，现在是管理数据库，后期操作admin。

$ python manage.py createsuperuser

设定好了数据，就要对app注册其变化

$ python manage.py makemigrations APP_NAME
$ python manage.py migrate