DJANGO EASY COURSE, BUILD BLOG WEB APPLICATION with DEPLOY!

Now that your app is set up, follow either of these simple workflows every time you want to make changes to your app:

Basic:

1. Navigate to your project

2. Activate virtualenv

3. Develop

Setup Django project

django-admin.py startproject

Create your new app:

python manage.py startapp Blog

Following commands are used while initiating our first Django project.

Creating Django Views in Easy Steps

In the previous tutorial we generated a model now we will be connecting our model with the view. We have actually used view.py, but here we will perform it again from the beginning.

Here are the steps to create Django views for our project:

Step 1: In our blog app directory create a new python file named urls.py.

Step 2: Inside that, all the URL patterns of the model are to be established. Let us check.

Understanding the code:

Here, we are creating a URLs file for our application rather than the whole project. This URLs file will contain all the URLs inside it related to our app. Thus, we get a cleaner main urls_config file.

Now, we will be connecting our project with the application.

Step 3: Open the urls.py file of the project that is in the root folder.

Here we have imported HttpResponse from the library django.http because we need to respond in the HTTP format. Also, we are passing the parameter request to the function.

Every view function will have its first parameter as a request.

This tutorial is a continuation of the previous lecture where we have seen how to create our first view in Django and some abstract knowledge about URL patterns and paths.

In Django, views have to be created in the app views.py file.

Simple View

We will create a simple view in our blog.

In this view, we use HttpResponse to render the HTML. To see this view as a page we just need to map it to a URL. We used HttpResponse to render the HTML in the view before. This is not the best way to render pages. This Views file is special as you can see, we are passing HTML as a string and that presents on the browser.

The following command is used to run the Django server.

python manage.py runserver

Make sure to run the Django server.

To run this view simply type in the URL bar, http://127.0.0.1:8000/

This will display text on the browser as:

This is great, my first view in Django

Hello django

All the source codes of the programs discussed so far in the section are present in section 5

Regards,

Chaand

We’ve set up the first view, the home page, which inherits the base.html template, containing the navbar. We need to build out unique content that can be inputted into this base template.

But first, let’s make a quick alteration. In your blog app, we need the template to be different. Previously we had told it to use the base.html template, but instead, let’s create home.html in our src/templates folder. Well, we will use those as well as the extended logic to add unique content to base.html.

Let us discuss another page i.e. about.html where we will store our details consisting of a title and to access this page via scripts we will use another HTML page named homepage.html to print the output.

In urls.py file, contains the view model of the homepage and about HTML pages. Based on the view the name is provided inside this urls.py file to access the contents from our blog app.

Before directly heading out to the purpose, let’s first know what is ‘Template’. A template is referred to as the form, pattern, or mold which is used as a guide to creating similar items. A template is known to control the overall layout and look of a website. A bootstrap template is nothing but an integrated form where the layout is pre-designed with HTML/CSS, jquery, javascript technologies. It enhances the look and feel of a particular website. There are plenty of free as well as paid templates available over the internet.

Coming on to its purpose, the template is used for:

• Consistency and Clarity

• Uniquely customizable

• Saving Time and Money

• Customer Satisfaction

One of the most important purposes for using templates is high-end customer satisfaction. They impart information to end-users professionally and allow them to find their choice of information without any hassle.

So, these are some important factors that ensure the need for templates for any website.

Django provides a convenient way to generate dynamic HTML pages by using its template system.

A template consists of static parts of the desired HTML output as well as some special syntax describing how dynamic content will be inserted.

Why Django Template?

In HTML file, we can't write python code because the code is only interpreted by the python interpreter not the browser. We know that HTML is a static markup language, while Python is a dynamic programming language.

Django template engine is used to separate the design from the python code and allows us to build dynamic web pages.

Django Template Configuration

To configure the template system, we have to provide some entries in settings.py file.

This tutorial will provide the debugging process in which how to fix broken links, pages that are not loaded properly, or any error that has been encountered. One of the best and recommended ways to debug a link or any issue in a page is by checking the source of the page. With the help of the view page source, it becomes easy to know the structure and flow of the page. And if we click on these links, it will not load and throw us an exception like, error 404(page not found) type of error. To fix this error, we will understand how static functionality will be loaded in our project.

Static files include stuff like CSS, JavaScript, and images that you may want to serve alongside your site. In this tutorial, you will learn how to add static files to a Django application.

Open the settings.py file inside the inner Django templates folder. At the very bottom of the file you should see these lines:

# djangotemplates/djangotemplates/settings.py

# Static files (CSS, JavaScript, Images)

# https://docs.djangoproject.com/en/1.10/howto/static-files/

STATIC_URL = '/static/'

This line tells Django to append static to the base URL (in our case localhost:8000) when searching for static files.

This tutorial is a continuation part of the previous lecture. The path of each URL link is provided properly but there is a catch in our blog path which we will check. On our about.html page, we have provided the blog url in the header section. This will apply the required changes needed to make our About page a beautiful-looking page.

Headers and footers are the top and bottom sections of the template respectively. They are separate sections and are often used to hold footnotes, page numbers, titles, and other information. Headers and footers are useful in providing quick information about your document or data in a predictable format and also help set out different parts of a template or any document.

In this tutorial, we will check and understand some common tags inside our about.hml page. On this page, we will see two sections of your requirement where we will add our code linking the template. Also, we will remove the redundant part of the information on our about page and copy the contents on our base.html page.   

On a website without a navigation bar, it's much harder to find what you need. And don't even get us started on the terrible user experience!

Navigation bars make browsing effortless - it gets almost intuitive as you keep using it. In this tutorial, we will explain using the Bootstrap navigation bar (also called simply Bootstrap navbar). You will be introduced to different ways to display and place it, as well as elements you can include inside it.

This tutorial will also be full of Bootstrap navbar examples that will help you understand the different ways to use a navigation bar.

Bootstrap provides you how to fix the navigation bar using predefined classes. Add class fixed-top (fixed navbar at the top), fixed-bottom (fixed navbar at the bottom), and use class sticky-top (when scrolling page it can be fixed the navbar at the top) together with class navbar in <nav> element.

Django provides a default admin interface that can be used to perform create, read, update and delete operations on the model directly. It reads a set of data that explains and gives information about data from the model, to provide an instant interface where the user can adjust the contents of the application. This is an in-built module and design to execute admin-related work to the user.

This lecture illustrates how we will explore the basics of the Django admin, like creating a superuser login, registering models with the admin, customizing how our models are viewed in the admin, adding and editing model data, and learning how to manage users in the admin.

A Django model is the built-in feature that Django uses to create tables, their fields, and various constraints. In short, Django Models is the SQL Database that uses with Django.

Django has come with built-in support for database migrations. In Django, database migrations usually go hand in hand with models: whenever you code up a new model, you also generate a migration to create the necessary table in the database. However, migrations can do much more.

You are going to learn how Django Migrations work and how you can get the most out of them. Some of the outstanding features with which migrations help in our project build-up include:

• To create database tables without writing any SQL

• To automatically modify your database after you changed your models

• To revert changes made to your database

This lecture depicts the Django admin panel semantics. It also specifies the fields, database entries in the form of action, and many other things in our Django project.

While registering a model first open admin.py file in the templates folder (/blog/templates/admin.py). 

Register the models by copying the following text into the bottom of the file. This code imports the models and then calls admin.site.register to register each of them.

In the following lecture, Once we have created our data models we will learn how Django automatically gives us a database-abstraction API approach that lets us create, retrieve, update and delete objects. To understand the concept in depth we will make use of all() method to retrieve the objects in the database which is the simplest way to retrieve objects from a table.

In this tutorial, we’ll build a Blog application with Django that allows users to create, edit, and delete posts. The homepage will list all blog posts, and there will be a dedicated detail page for each individual post.

We're now ready to add the code that displays our first complete page i.e. a homepage for our blog website. In this tutorial, we will understand the user model object and their fields. Along the way we'll gain practical experience in writing basic URL maps and views, getting records from the database, and using templates.

This tutorial is a bonus lecture, where we will discuss the entries, hyperlinks on our page, and some additional stuff related to our template.

In this tutorial, we’ll be using Django’s built-in user model. In practice, we would more likely create a custom user model, extending the functionality offered by Django. It focuses on user management, for creating and managing user accounts.

In this tutorial, we will use a web template and make necessary alterations to that template. The basic requirement would be to implement this template for user signup or registering user.

This tutorial delivers the required methods to implement user models in general. User creation forms in Django provide a very easy and secure way of creating a sign-up form by drawing upon the concept of models. Similarly, using it is also quite straightforward.

In this tutorial, we will modify our form and add additional functionalities to the form. We will change the look and feel of the form by adding validations and a button for addressing users. 

A form comes with 3 in-built methods that can be used to render Django form fields.

• {{ form.as_table }} will render them as table cells wrapped in <tr> tags

• {{ form.as_p }} will render them wrapped in <p> tags

• {{ form.as_ul }} will render them wrapped in <li> tags

These render the form automatically but if you want to create a beautiful form, you need to render the form fields manually. The form is working properly but visuals are disappointing, we can render these fields manually to improve some visual stuff.

In this tutorial we are going to explore some of the Django Crispy Forms features to handle advanced/custom forms rendering. In our previous lecture, we have installed crispy forms in our project environment and understand the django-crispy-forms which have built-in support for different CSS frameworks, known as template packs within django-crispy-forms in greater detail.

We will be creating a new Django Model to store the extra information that relates to the User Model. To do so let us implement the fields of the user model in our form.

In this tutorial, we have applied all the attributes and performed the linking of pages in our form. Our registration page is now completed with required validations and looks sorted for any user to feed information.

Built-in Field Validations in Django models are the validations that come predefined to all Django fields. Every field comes in with built-in validations from Django validators. One can also add more built-in field validations for applying or removing certain constraints on a particular field. In this tutorial, we will check what happens when we remove help_text attribute from our form.

In this tutorial, we will learn how our form is saving the data into the database. In our Django app, the view to be able to deal with a POST request. To make our work simple we will use the Form and field validation method to perform the task easily.

This tutorial signifies the implementation of Django widgets in our Blog app. We will learn the features of enhancing our form with the use of widgets in the following lecture.

A widget is Django’s representation of an HTML input element. The widget handles the HTML rendering and the extraction of data it corresponds to. Whenever you specify a field on a form, Django will use a default widget that is appropriate to the type of data that is to be displayed.

What is Linting?

Linting is the process of running a program that analyses code for programmatic errors such as bugs, actual errors, styling issues, etc.

Put it in the same basket as the process running in your favorite text editor that keeps an eye out for typos and grammatical errors. This brings us to Flake8.

What is Flake8?

It's one of these linting programs and is pretty damn simple to use. It also happens to analyze your code for PEP8 standard violations.

Every web application needs a navigation bar. Common practice is to indicate to the user usually implemented by using a visual aid such as a bold type-face, different color, or an icon. In this tutorial, we will learn how to modify the default view of our template using a sample bootstrap template.

Django flash messages are managed on a per request basis and are added in view methods, as this is the best place to determine whether flash messages are needed or not. To add messages we need to import django.contrib.messages package.

In this tutorial, we will modify our registration page. The purpose would be to display alert messages in Django, check that the settings are configured properly, add a message to a view function, and display the message in a template. Then we will check whether all the users got created or not in the Django administration database.

These are all the source codes of the programs discussed so far in the section. At the end of each section, we have presented the same.