We do that by creating a folder called `static` inside the blog app:

Django will automatically find any folders called "static" inside any of your apps' folders, and it will be able to use their contents as static files.

Let's create a CSS file now, to add your own style to your web-page. Create a new directory called `css` inside your `static` directory. Then create a new file called `blog.css` inside this `css` directory. Ready?

Time to write some CSS! Open up the `blog/static/css/blog.css` file in your code editor.

Let's open the `blog/admin.py` file and replace its content with this:

from django.contrib import admin

from .models import Post

We need to create a file with this name in the `blog` directory.

Ok, let's open it and type the following code:

from django import forms

from .models import Post

It's time to open `blog/templates/blog/base.html`. We will add a link in `div` named `page-header`:

Note that we want to call our new view `post_new`.

After adding the line, your html file should now look like this:

We open `blog/urls.py` and add a line:

And the final code will look like this:

from django.conf.urls import include, url

from . import views

Time to open the `blog/views.py` file and add the following lines with the rest of the `from` rows:

from .forms import PostForm

and our *view*:

def post_new(request):

form = PostForm()

return render(request, 'blog/post_edit.html', {'form': form})

Ok, so let's see how the HTML in `post_edit.html` should look:

Open `blog/views.py` once again. Currently all we have in the `post_new` view is:

def post_new(request):

form = PostForm()

return render(request, 'blog/post_edit.html', {'form': form})

So in our *view* we have two separate situations to handle. First: when we access the page for the first time and we want a blank form. Second: when we go back to the *view* with all form's data we just typed. So we need to add a condition (we will use `if` for that).

if request.method == "POST":

[...]

else:

It's time to fill in the dots `[...]`. If `method` is `POST` then we want to construct the `PostForm` with data from the form, right? We will do that with:

form = PostForm(request.POST)

Easy! Next thing is to check if the form is correct (all required fields are set and no incorrect values will be saved). We do that with `form.is_valid()`.

We check if the form is valid and if so, we can save it!

if form.is_valid():

post = form.save(commit=False)

post.author = request.user

Finally, it would be awesome if we can immediatelly go to `post_detail` page for newly created blog post, right? To do that we need one more import:

from django.shortcuts import redirect

Add it at the very beginning of your file. And now we can say: go to `post_detail` page for a newly created post.

return redirect('blog.views.post_detail', pk=post.pk)

`blog.views.post_detail` is the name of the view we want to go to. Remember that this *view* requires a `pk` variable? To pass it to the views we use `pk=post.pk`, where `post` is the newly created blog post!

Ok, we talked a lot, but we probably want to see what the whole *view* looks like now, right?

def post_new(request):

if request.method == "POST":

form = PostForm(request.POST)

Open `blog/templates/blog/post_detail.html` and add this line:

so that the template will look like:

In `blog/urls.py` we add this line:

url(r'^post/(?P<pk>[0-9]+)/edit/$', views.post_edit, name='post_edit'),

We will reuse the template `blog/templates/blog/post_edit.html`, so the last missing thing is a *view*.

Let's open a `blog/views.py` and add at the very end of the file:

def post_edit(request, pk):

post = get_object_or_404(Post, pk=pk)

if request.method == "POST":

This looks almost exactly the same as our `post_new` view, right? But not entirely. First thing: we pass an extra `pk` parameter from urls. Next: we get the `Post` model we want to edit with `get_object_or_404(Post, pk=pk)` and then, when we create a form we pass this post as an `instance` both when we save the form:

form = PostForm(request.POST, instance=post)

and when we just opened a form with this post to edit:

form = PostForm(instance=post)

* First, commit your new code, and push it up to Github

* Then, in a [PythonAnywhere Bash console](https://www.pythonanywhere.com/consoles/):

After creating an application we also need to tell Django that it should use it. We do that in the file `mysite/settings.py`. We need to find `INSTALLED_APPS` and add a line containing `'blog',` just above `)`. So the final product should look like this:

INSTALLED_APPS = (

'django.contrib.admin',

'django.contrib.auth',

Let's open `blog/models.py`, remove everything from it and write code like this:

from django.db import models

from django.utils import timezone

In settings.py, find the line that contains `TIME_ZONE` and modify it to choose your own timezone:

TIME_ZONE = 'Europe/Berlin'

We'll also need to add a path for static files (we'll find out all about static files and CSS later in the tutorial). Go down to the *end* of the file, and just underneath the `STATIC_URL` entry, add a new one called `STATIC_ROOT`:

STATIC_URL = '/static/'

STATIC_ROOT = os.path.join(BASE_DIR, 'static')

This is already set up in this part of your `mysite/settings.py` file:

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.sqlite3',

The admin URL, which you visited in previous chapter is already here:

It means that for every URL that starts with `admin/` Django will find a corresponding *view*. In this case we're including a lot of admin URLs so it isn't all packed into this small file -- it's more readable and cleaner.