Django is an open source web framework which solves most common problems of a web application development. It has some very useful features like an auto generated admin page and an ORM.<\/p>\n
It’s a high-level framework, so we just need to focus on the actual core logic of our business and let Django take care of mappings, filters and such. It works by defining some standards that, if you follow them, will make the application’s development so much easier and faster.<\/p>\n
By using Python 3.4.3 and Django 1.9.1, we’ll build a web application which, through an admin site only available to us, will let us upload riddles. Then we’ll make a public user interface which will let the users answer the riddles we upload. \n \n[ulp id=’R7QVpFMZmjosABLC’]<\/p>\n
1. Creating the project<\/h2>\n
If you’ve installed django correctly, when you run django-admin --version<\/code>, you’ll see the version in the output of that command. Now if we run django-admin startproject django_example<\/code>, we’ll now have the skeleton of our project. Let’s cd to our project’s directory and see:<\/p>\n
\n
django_example<\/strong> is the actual python package for your project.<\/li>\n
django_example\/__init__.py<\/strong> is an empty file that tells python that this directory should be considered a package.<\/li>\n
django_example\/settings.py<\/strong> holds the configuration for this Django project.<\/li>\n
django_example\/urls.py<\/strong> holds the URL declarations.<\/li>\n
django_example\/wsgi.py<\/strong> is an entry-point for WSGI-compatible web servers to serve your project.<\/li>\n
manage.py<\/strong> is a command-line utility that lets you interact with this Django project in various ways. We’ll see some of them below.<\/li>\n<\/ul>\n
Now, let’s see how to run this application. Run python3 manage.py runserver<\/code> and you’ll see some output on the console to finally see Starting development server at http:\/\/127.0.0.1:8000\/<\/code>. Now if we hit that location we’ll see a Django welcome screen telling us that everything worked fine.<\/p>\n
You will probably see something like “You have unapplied migrations; your app may not work properly until they are applied.”<\/em>. We’ll get back to that later, don’t worry about it right now.<\/p>\n
2. Creating our application<\/h2>\n
Now we have our project up and running and we can start writing our application now. Something to notice here is the difference about the terms project and application. An application is a python program that does something, and a project is a group of applications. The same application can be contained in more than one project. A project will almost always contain many applications.<\/p>\n
Each application in Django consists of a package that follows some Django standards. One of the many tools that come with this framework is an utility that automatically generates the basic directory structure of an application, so let’s run python3 manage.py startapp riddles<\/code>, and now there will be a directory called riddles<\/em> wich will hold our application’s source code.<\/p>\n
Let’s write a simple view to see how everything works. Django convention tells us to write them in a file called views.py<\/code> within our application’s module.<\/p>\n
Now we run our server and hit http:\/\/localhost:8000\/riddles\/<\/em> to see our message “Hello, World!”<\/em>. If everything worked fine we’ll start with our database.<\/p>\n
3. Database Setup<\/h2>\n
Now, when we see django_example\/settings.py<\/code>, it’s a normal module with some variables representing Django settings. There is a variable named DATABASES<\/code> which by default uses SQLite which is included within Python, so you won’t need to install anything. For this example, we’ll stick with the default here.<\/p>\n
Also, see the variable INSTALLED_APPS<\/code>, it holds the names of all Django applications which are activated in the project. By default it contains:<\/p>\n
\n
‘django.contrib.admin’<\/strong> is the admin site, we’ll be seeing it in no time.<\/li>\n
‘django.contrib.auth’<\/strong> as an authentication system.<\/li>\n
‘django.contrib.contenttypes’<\/strong> a framework for content types.<\/li>\n
‘django.contrib.sessions’<\/strong> a session framework.<\/li>\n
‘django.contrib.messages’<\/strong> a messaging framework.<\/li>\n
‘django.contrib.staticfiles’<\/strong> a static content framework.<\/li>\n<\/ul>\n
This applications are useful in most cases, but some of them uses databases (like django.contrib.auth<\/em>), and these are not created yet. That’s why you see that migrations message on the output of the runserver command. To create all tables we just run the command python3 manage.py migrate<\/code>. You should see something like:<\/p>\n
Now let’s create our model, which is our database layout with some additional metadata. For now we’ll just create Riddle<\/code> and Option<\/code>. A Riddle contains the actual riddle, and an Option is one of the possible answers of a riddle, with a flag that will tell us if it’s the correct one.<\/p>\n
This model gives Django all the information needed to create the database schema and the database-access API for accessing these objects, but we need to tell our project that the riddles app is installed, we’ll just add an element to the INSTALLED_APPS<\/code> in django_example\/settings.py<\/code>:<\/p>\n
Now we make the migration for this application running python3 manage.py makemigrations riddles<\/code> and we’ll see:<\/p>\n
\r\nMigrations for 'riddles':\r\n 0001_initial.py:\r\n - Create model Option\r\n - Create model Riddle\r\n - Add field riddle to option\r\n<\/pre>\n
By doing this we are telling Django that we made some changes to the models and that these should be stored as a migration, these are just files on the disk, you can read them in a directory called migrations<\/em> within your application. They are designed to be human readable so you would be able to change them if you need.<\/p>\n
We can see de actual SQL statements that te migration will run if we want by running python3 manage.py sqlmigrate riddles 0001<\/code>. That 0001<\/em> is the version of the migration we want to check. In the output we’ll see:<\/p>\n
\r\nBEGIN;\r\n--\r\n-- Create model Option\r\n--\r\nCREATE TABLE \"riddles_option\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"text\" varchar(255) NOT NULL, \"correct\" bool NOT NULL);\r\n--\r\n-- Create model Riddle\r\n--\r\nCREATE TABLE \"riddles_riddle\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"riddle_text\" varchar(255) NOT NULL, \"pub_date\" datetime NOT NULL);\r\n--\r\n-- Add field riddle to option\r\n--\r\nALTER TABLE \"riddles_option\" RENAME TO \"riddles_option__old\";\r\nCREATE TABLE \"riddles_option\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"text\" varchar(255) NOT NULL, \"correct\" bool NOT NULL, \"riddle_id\" integer NOT NULL REFERENCES \"riddles_riddle\" (\"id\"));\r\nINSERT INTO \"riddles_option\" (\"riddle_id\", \"id\", \"text\", \"correct\") SELECT NULL, \"id\", \"text\", \"correct\" FROM \"riddles_option__old\";\r\nDROP TABLE \"riddles_option__old\";\r\nCREATE INDEX \"riddles_option_a7c97949\" ON \"riddles_option\" (\"riddle_id\");\r\n\r\nCOMMIT;\r\n<\/pre>\n
Now we run migrate, and this script will be executed in the database. Notice that the sqlmigrate<\/em> command was only to check the script it will execute, it’s not necessary to run it every time.<\/p>\n
Now we can start using the admin page, but we need a user to log in. By running the createsuperuser<\/em> command we’ll be able to create the root user for our application. It will prompt for a name, a mail and a password. Just run python3 manage.py createsuperuser<\/code>. Now if you run the server and visit http:\/\/127.0.0.1:8000\/admin\/<\/em> you will be able to log in with the credentials you just provided.<\/p>\n
Let’s make our model modifiable by the admin. In riddles\/admin.py<\/code> we give Django all the models that are modifiable via the admin page. Let’s change it to look like this:<\/p>\n
Now, let’s check out that admin page. First, we hit http:\/\/localhost:8000\/admin<\/em>, it will redirect us to a login page.<\/p>\n \n <\/a> Login Page <\/figcaption><\/figure>\n
We input the credentials of the super user we created before, and now we see the home.<\/p>\n \n <\/a> \n Home <\/figcaption><\/figure>\n
There we see a couple useful things:<\/p>\n
\n
\n Authentication and Authorization:<\/strong> These are purely administrative data for our project. We can create, modify, delete and list users and groups.\n <\/li>\n
\n Riddles:<\/strong> Here it is. We can administer our riddles and options in this page. Full CRUD operations are available out of the box, it all comes free if you follow Django conventions.\n <\/li>\n<\/ul>\n
Take a little pause here and navigate this admin page. Create a couple riddles and options, even a user. Explore the permissions system and how groups work. It’s pretty awesome.<\/p>\n
4. The Public Page<\/h2>\n
What do we need to make our public page?<\/p>\n
\n
Templates: The skeleton of the page the user will see.<\/li>\n
Views: The python’s function that will serve the page content.<\/li>\n<\/ul>\n
Let’s start with the templates. Create a module called templates<\/em> within your application module, and there we’ll write our index.html<\/em>.<\/p>\n
![\"Login](\"http:\/\/www.webcodegeeks.com\/wp-content\/uploads\/2016\/01\/login.png\")
![\"Home\"](\"http:\/\/www.webcodegeeks.com\/wp-content\/uploads\/2016\/01\/home.png\")