Introduction to Django

Django is a high-level Python framework for rapid web development. It follows the Model-Template-View (MTV) architecture, which makes it easier to develop complex, data-driven websites. Django simplifies the web development process and helps developers with vast documentation to guide them through the website creation process. Developers find it easy to create web pages with Django, as the framework provides tools to help neatly organize data and have repositories managed with high relevance. It is a free and open-source framework.

Why Use Django Framework?

Django provides fast, simple, and rapid web development. It has extensive documentation and follows the principle, DRY, i.e., Do not Repeat Yourself. Additionally, Django comes with built-in Object Relational Mapping (ORM) support. A database can be updated through the command-line interface using the following command:

Code:

`python manage.py migrate`

And migrations can be generated using:

Code:

`python manage.py makemigrations`

Django’s MVT Pattern

Django utilizes MVT (Model-View-Template) instead of the traditional MVC (Model-View-Controller) pattern used for user interaction in application development. The template consists of HTML code with Django Template Language (DTL), and Django handles the controller code to manage interactions between the Model and View.

When a user sends a request, Django acts as a controller by checking if the requested URL is available and maps it to the corresponding view. If the URL maps successfully, the view interacts with the model and generates a template, which then returns to the user as a response. With its built-in default controller implementation, Django provides a solid foundation for many applications.

Django Installation and Setup

Installing Django is relatively easy in comparison to other frameworks; however, it differs for operating systems. The latest version can be downloaded from their official website.

• Django can be installed on Linux or Mac OS using the package manager or pip install.
• For Windows, if Python already exists on the system, one should check if Python Path is set for the system variable. Then extract and install it.

Django supports many database engines and can be set as per requirements. It provides a built-in lightweight server for developing and testing the application.

Creating your Django Application

A Django project is a collection of settings that include database configuration, specific options, and default application-specific settings in the project.

Steps to create an application:

1. Create a directory where you want to store your project.
2. Navigate to the created directory using the command line interface and run the following command:

Code:

$ django-admin startproject my_app

If one looks at the directory, the following structure will be created:

mysite/

manage.py

mysite/

__init__.py

settings.py

urls.py

wsgi.py

• manage.py: Allows interaction with the Django project in different ways.
• __init__.py: Informs the Python interpreter that the directory must be considered a Python package. This file is mostly empty.
•  settings.py: The configuration file.
• urls.py: Includes all URL declarations for the Django project and table of contents of the Django-powered site.
• wsgi.py: The entry point for WSGI-compatible web servers to serve the projects and deploy with WSGI.

If one wants to check whether the project is running, one can check it using the following command:

Code:

$ python manage.py runserver

How does Django make your Work Easy?

Django follows the “Simple is better than complex” approach, which is the Pythonic way of development. It is one of the Python packages that is stored inside the site-packages directory of the Python installation along with other important packages like Numpy, Scipy, Pillow, etc.

To verify whether Django is installed, one can try to import it into the project using the following code:

Code:

>>> import django
>>> print(django.get_version())

Django provides everything that is necessary to develop a full-fledged application, including built-in templating using HTML, URL routing, ORM (Object Relational Mapping), session management, etc.

It also offers a number of useful tools for SEO. The SEO framework allows the developers to reduce page loading time by using cached templates and compressing CSS and JavaScript. Additionally, there is also a tool to manage robots.txt. The capabilities of Django CMS exceed the expectations of professional SEO specialists.

Top Companies which use Django Framework

1. Instagram

Instagram is a Python-based photo and video-sharing social networking app that processes huge amounts of data and manages an even greater number of interactions between multiple users every second. Django helps Instagram to handle this workload by simplifying the process and avoiding reinventing the work.

2. Spotify

Spotify has taken the music industry to the next level by changing the way people listen to music and making it accessible to anyone on any device. It uses Python for both backend services and machine learning combined with the Django Framework.

3. YouTube

YouTube is one of the most popular content-sharing platforms. While YouTube was originally a PHP-based project, it moved to Django to improve its performance, and thereby run smoothly.

4. Dropbox

Dropbox is a renowned cloud storage service for documents, videos, and pictures. Both its desktop and server-client software are based on Python. Dropbox uses the Django Framework to enable storage, synchronization, and file-sharing options.

5. Mozilla

Mozilla is one of the most popular and recognizable browsers in the world, with millions of users worldwide. Although their old components were not written in Python, they have implemented new components using Django. For example, building support sites and add-ons. Mozilla shifted from PHP (CakePHP) to Python (Django Framework), which helped them deal with tens, hundreds, and millions of views per month and more API hits per day.

6. Disqus

What can you do with Django?

Django enables the creation of web applications with features such as database connectivity, CRUD (create, read, update, and delete) operations, security, user management, and creating RestAPI using Django RESTful API.

Django is not PHP

It uses Python programming language, which makes things simple. It is a complete framework that uses templating language and has been crowd-tested by many big companies that have implemented their enterprise and mobile applications using Django. Django provides excellent documentation and they are the first-class citizens in the Django world. It has over 3,000 packages available for users, and it is one of the first frameworks to respond to new vulnerabilities.

Why do we Need Django?

Django facilitates rapid development with its clean and practical design, making it a preferred choice for building highly customizable applications. It covers the basic requirements by letting developers focus on experimenting with the important parts, such as the ability to share various types of media.

Django provides a solid user authentication model that allows for user configuration, thereby making it the first choice when security is the top priority. It utilizes separate Python components that are independent of each other.

When Not to Use Django?

While Django is a robust framework with a solid foundation for large projects, it may not always be the best choice. For smaller projects, especially those that do not require a database, Django can be overkill. In such cases, the Flask framework may be a better option as it is more suitable for smaller and simpler projects.

Advantages and Disadvantages of Django Framework

Advantages:

• It is a Python Language: Django is written in Python, which is simple to learn and easy to implement. Python manages much more in fewer lines with large libraries.
• Wide Usage: Django and Python are widely used by Fintech Companies in Silicon Valley, IT giants, Blue chip companies, and in the development of the Internet of Things.
• Administrative Interface: The administrative interface by Django is a powerful and customizable tool that allows developers to quickly create a fully-featured admin interface.

For e.g:

class Interface(models.Model):
interface_title = models.CharField(max_length=50)
some_other_text = models.CharField(max_length=100)
some_boolean_value = models.BooleanField()
admin.site.register(Interface)

• Extensive Support Libraries: Django provides libraries that include features such as string operations, web services, operating system interfaces, and standard protocols.
• Scalability: Django is scalable and can handle heavy traffic demands. It offers various options for scalability, such as running separate servers for the database and using clustering or load-balancing to distribute the application across multiple servers.

Disadvantages:

• Specifying URLs with regular expressions can be challenging for beginners. Additionally, when a template error occurs, it may fail silently, leading to a waste of time in trying to identify the problem.
• Django gives a monolithic feeling since it is a strongly opinionated framework.
• Handling multiple requests at the same time can be a challenge because Django does not empower individual procedures to manage multiple requests simultaneously. Developers may need to explore different approaches to enable a single procedure to control various requests simultaneously.
• Although ORM (Object Relation Mapping) system allows developers to work on different databases concurrently, it lacks some features provided by other ORM systems. Its design is such that it does not let programmers use SQLAlchemy entirely, which is python’s famous toolkit.

Prerequisites to Learn Django

• To learn Django, one should have a basic understanding of the Python programming language, especially its syntax and indentation rules.
• Familiarity with Python functions, such as passing arguments and setting default values, is also necessary.
• Since web application development often requires the use of external modules, understanding how to import external packages into your code is important.
• Regular Expressions (regex) play a vital role in URL mapping and string validation, especially when asking users to provide sensitive information like email IDs and passwords.
• Knowledge of RestAPI and JSON is also essential, as they are commonly used for storing and transferring data between different network entities.

How will it help in Career Growth?

• Certification in Python-Django can be valuable for beginners to enhance their career opportunities in their current organization. It is a highly-demanded skill for programmers and web developers.
• Large organizations often use Django to develop their projects, presenting opportunities for developers to work with top-tier clients.
• As one of the most popular frameworks globally, having experience in Django can lead to lucrative salaries and the chance to work on-site with clients from all over the world.

Conclusion

Although the Django framework may present some challenges, it also enables users to accomplish a huge number of tasks quickly and easily, making Python-based software development affordable and simple. While the ORM may have its limitations, the Django REST framework can mitigate its disadvantages and create an optimal interface for REST. A great advantage of the Django REST framework is that it has perfect interfacing models and can also work with the bare implementation of Data Mapper patterns. For those in the outsourcing business, Django can be advantageous, given the average short duration and budget constraints of such projects. Overall, it is one of the best frameworks available in the market.

Introduction to Django Architecture

The Django is a free and open-source web application framework that is written in Python language. This framework is used in place of servlets, PHP, javascript to build web application backend part. The initial version of Django is released on 15th July 2005, which is developed by Django Software Foundation. The recent release of version 2.2.7 of the Django framework was done on 4th November 2019. Now we will learn about Django architecture with MVT.

The main advantages of Django is to make the creation of complicated database included web applications as easy as possible, it is fast, many components are available implicitly, scalability and good security. Now, getting into the architecture of Django; it follows MVT.

Django Architecture

As mentioned, Django follows the MVT framework for architecture.

• M stands for Model
• V stands for View
• T stands for Template

MVT is generally very similar to that of MVC which is a Model, View, and Controller. The difference between MVC and MVT here is the Django itself does the work done by the controller part in the MVC architecture. Django does this work of controller by using templates. Precisely, the template file is a mixture of HTML part and Django Template Language also known as DTL.

Below is an architecture diagram for MVT.

The Template handles the UI and architecture part of an application. The view does the logical part of the application and interacts with the Model to get the data and in turn modifies the template accordingly. Here as already mentioned, Django works as a controller and gets a URL that is linked to the view part of the application and thus transports the user responses to the application. This complete interaction is dealt with this Django MVT architecture. When we create a project, there would some default files that would be created.

I used the above command to create a new project in my my_projects folder. Now let me show you the files that got created in the empty folder once the above command has been executed. These are the files that got created under the project first that we created.

There is, in turn, one more folder and a manage.py file that has been created. Now going into the first folder, we can observe the below files.

So the above files are those that got created automatically once a new project has been created.

• urls.py: As we know that our web page has to deal with many links, all the mappings from one page to others can be done here.
• wsgi.py: This is used to deploy our project.
• manage.py: Gives us a URL where the project can be displayed.

After running this command, the output is as follows.

Output:

Check the output by using the URL in any web browser. We have learned about this, as there should be some start in learning how to create a project on your own and work on it to clearly understand how the MVT architecture runs using Django with Python.

Django Architecture Model

• In Django, the model does the linking to the database and each model gets mapped to a single table in the database. These fields and methods are declared under the file models.py
• With this linking to the database, we can actually each and every record or row from that particular table and can perform the DML operations on the table.
• Django.db.models.The model is the subclass that is used here. We can use the import statement by defining as from django.db import models.
• So after defining our database tables, columns and records; we are going to get the data linked to our application by defining the mapping in settings.py file under the INSTALLED_APPS.

Django View

• This is the part where actually we would be mentioning our logic. This coding is done through the python file views.py
• This view also sends responses to the user when the application is used, to understand briefly, we can say that this view.py can deal with HttpResponse.
• Now, after creating a view, how can we link it to our application? How do you think that the system is going to understand to display a particular view? This can be done by mapping the views.py in urls.py file. As already mentioned, urls.py keeps track of all those different pages that we created and hence map each of them.

Django Template

• This template helps us to create a dynamic website in an easy manner. The dynamic website deals with dynamic data. Dynamic data deals with a scenario where each user is displayed with their personalized data; as Facebook feeds, Instagram feeds, etc.
• The configuration of the template is done in settings.py file under INSTALLED_APPS. So python code would search for the files under the template subdirectory. We can create an HTML file or import any dynamic web page from the browser and place it under the template folder.
• And after that our usual linking of this file in urls.py and views.py to get a response is mandatory.
• In this way after linking all these together and running the server, we can get our web application ready.

Django Template Language

In short, it is called as DTL. Django template has its own syntax in rendering the data on to the web page. For displaying a dynamic variable, the variable name is written inside the curly braces; denoted by “{{variable_name}}”. And to write if conditions, the syntax would be defined as: {% if condition %}. The same would be followed for the end if syntax also. Django uses render function in DTL. This render function takes three parameters.

• Request
• Mentioning the path of template in settings.py
• Parameters that contain all variables and can create as many as possible.

By these render functions we can have our DTL to make dynamic web pages.

Conclusion

So, this is how the it works. The main python files are used to link with each other to display our web page are settings.py, view.py, and urls.py

Once we define our logic here respectively we can have a workflow linking the database, taking user inputs and responses and display dynamic web pages. After installing Django, go through the files and understand the linking between them.

Introduction to Install Django

Django is an open-source web framework that is based on the Python programming language. It is maintained by an independent organization called Django Software Foundation. The primary goal of Django is to provide ease to complex and data have driven websites. This framework is used to focus on reusability and plug-ability of components where less code and low coupling with the rapid development is given preference. To install Django, first, you need to install Python on your local machine. So installing python is also covered in this document.

Steps to Install Django

For installing the Django, it needs a stable and good internet connection.

Let us discuss the steps required to install Django:

Step 1: First, visit the official site of Python, which is given below as:

https://www.python.org/

Step 2: After landing to the above web page, click on the downloads button shown below as and select your operating system installed in your local system.

In my case, I have clicked on windows.

Step 3: It will redirect to another page where on the very top you will get the title Python Releases for Windows, and just below you will get the Latest python release which is shown below as:

Click the very first link, which is Latest Python 3 Release-Python 3.7.2. This is the latest version available now; for this time, you may get the higher version as well but always use the first link.

Note: If a user uses Windows XP or older windows like Vista, click on the second link, Latest Python 2 Release- Python 2.7.15.

Step 4: After clicking on the above link, it redirects to other pages where on the top it shows the latest version of the Python. Just scroll down you would get the title files under which multiple download options are available, as shown below:

For Windows 64-bit system, select the first Windows x86-64 web-based Installer marked in red and click on that, whereas for 32-bit system, select the last red-marked Windows x86 web-based installer.

Step 5: It will take some time to download the file; when it gets complete, save that installer file. Then, please click on the installer file, but for this, one should have a stable and good internet connection.

Step 6: When you click on the downloaded file, it will start a setup launch. The first step is to select the checkbox and click to tick the “Add Python 3.7 to PATH”, which shows at very extreme below marked in red. Then click on the Install Now as shown below. If one doesn’t select the Add Python 3.7 to PATH, it has to call Python manually each time, and it will take lots of time, so please tick the checkbox.

Next, you can refer to the below-provided image:

Step 7: When one clicks on the Install button, it will start a warning message “Do you want to make changes in your system” so please click on Yes. It shows for few systems, and for a few, it won’t; it depends upon the system.

Then Setup progress as installation will start and looks as below:

Step 8: And when it is done then it shows “Setup was successful” shown below:

Now click on the Close button.

Step 9: To check that Python installed successfully or not. Press Windows (Hold this button then) + R (button from keyboard), it will open the Run command. Type “cmd” and press on OK button.

Step 10: It will open the command prompt.

Code:

Python --version

Output:

If Python is successfully installed, then it shows the version; otherwise, it shows an error. In this case, it shows Python 3.7.2, so Python installed in my system successfully.

Step 11: Then check the current version of pip. Pip is used to install the other packages in the python environment.

Code:

pip --version

It will show the installed version of the pip as shown below:

Output:

Step 12: Now we’re ready to install the Django because we have set up the environment to install Django. Please use the given URL to open other web pages for Django installation: https://docs.djangoproject.com/en/2.1/howto/windows/

Step 13: When the web page opens, scroll down a little bit and stop where it shows “Install virtualenv and virtualenvwrapper title”, shown just above. One needs to use three commands which are marked in red. First, one needs to install the virtualenv and virtualenvwrapper to provide the virtual dedicated environment for Django. Just below this title, there is code available to install the virtual wrapper.

Code:

pip install virtualenvwrapper-win

Step 14: Type Powershell in windows search bar, and it gives the result Windows Powershell on top then right-click on Windows Powershell and click Run as administrator shown as:

Step 15: It will open the power shell and then type the code pip install virtualenvwrapper-win given in the 13th step it will take some time to install the virtual wrapper environment in windows.

Virtual wrapper environment installed successfully.

Step 16: Then, create a virtual environment for a Django project. The code is available in URL: https://docs.djangoproject.com/en/2.1/howto/windows/

Type this code or copy the code from the webpage to the Windows Powershell, which is given as:

Code:

mkvirtualenv myproject

It will create a virtual environment and shown as:

Output:

Step 17: Now activate the virtual environment. So copy the code from the given URL or from below and type in Windows Powershell.

Code:

workon myproject

Output:

Now my virtual environment is ready for the installation of the Django.

Step 18: Now finally install the Django using the pip command as shown below:

Code:

pip install Django

Output:

It will take some time for installation, but before installation, makes sure that your virtual environment is ready, which is done in step 17.

Step 19: Now Django is installed successfully. To verify the Django installation, type the following code in Windows Powershell as given below:

Code:

django-admin --version

Output:

If it shows the version of Django, it means Django is installed successfully if not then please check the previous step. Here it shows 2.1.7 which is now the latest Django version.

Introduction to Uses Of Django

Django is an open-source python web framework used for rapid development, pragmatic, maintainable, clean design, and secures websites. A web application framework is a toolkit of all components need for application development. The main goal of the Django framework is to allow developers to focus on components of the application that are new instead of spending time on already developed components. It is fully featured than many other frameworks on the market. It takes care of a lot of hassle. involved in web development; enables users to focus on developing components needed for their application.

Top 10 Uses of Django

Below is the list of top 10 Uses are as follows:

1. Django is time-tested

It’s been 13 years since Django started developing its framework and the first release of open source commit as it was under development quite a long time before release. During these years, it had many releases; some of them have new features, other releases focuses on security enhancements etc. Django is the first framework to respond to new issues and vulnerabilities and alter other frameworks to make patches to frameworks. The latest release of it is focusing on new features and boundary case problems.

2. Application Development

Django was developed by the online news operation team with the aim to create web applications using the Python programming language. The framework has templates, libraries, and APIS, which work together. In general, applications developed using Django can be upgraded with minimal cost, changes, and additions, and it makes a lot of web development easier.

3. Easy to Use

Django uses Python programming language, which is a popular language in 2015, and now most choosing language by programmers who are learning to code and applications of Django framework is widely used as it is free and open-source, developed and maintained by a large community of developers. It means we can find answers to the problems easily using Google.

4. Operating System Dependent

Django framework runs on any platform like PC, Windows, Mac, Linux etc. It provides a layer between the developer and database called ORM (object-relational mapper), which makes it possible to move or migrate our applications to other major databases with few lines of code change.

5. Excellent Documentation for real-world application

Applications of Django has one of the best documentation for its framework to develop different kinds of real-world applications, whereas many other frameworks used an alphabetical list of modules, attributes, and methods. This is very useful for quick reference for developers when we had confusion between two methods or modules but not for fresher’s who are learning for the first time. It’s a difficult task for Django developers to maintain the documentation quality as it is one of the best open-source documentation for any framework.

6. Scalable and Reliable

As Django is a well-maintained web application framework and widely used across the industries, so cloud providers taking all measures to provide support to run Django applications easily and quickly on cloud platforms. It means, once Django applications deployed then they can be managed by an authorized developer with a single command in a cloud environment. As Django developers are working in the same development environment for a long time so they will grow and expertise in these areas which means applications developed, websites created are getting better day by day, more functional, efficient, and reliable.

7. Community Support

Django community is one of the best communities out there as it is governed by the Django software foundation, which had some rules like for event there is a code of conduct. Django communities will have IRC and mailing list most welcome; even it may have bad appeals, it will rectify immediately. Django offers stability, packages, documentation and a good community.

8. DRY – Don’t repeat yourself

Django framework follows the don’t repeat yourself principle as it concentrates on getting the most out of each and every line of code by which we can spend less time on debugging or code re-orientation etc. In general DRY code means all uses of data change simultaneously rather than a need to be replicated, and its fundamental reason to use of variables and functions in all programming.

9. Batteries of Django

Django framework has everything to build a robust framework with main features as below:

• Template layers,
• Forms, development process,
• Views layers, security,
• Model layers, python compatibility,
• Localization, performance, and optimization
• Geographic framework, common tools for web application development
• Other core functionalities required for websites.

As Django can be used to build any type of website with the help of its frameworks like content management, Wikipedia pages, social networking applications, chat applications, and websites like Mozilla, Instagram, Pinterest, BitBucket etc. Django can work with any client-server application and able to deliver content in any form (HTML, Text, JSON, XML, RSS etc.)

10. Django Benefits

With the uses of the Django framework, we can develop and deploy web applications within hours as it takes care of much of the hassle of web development. Django is very fast, fully loaded such as it takes care of user authentication, content administration, security as Django takes it very seriously and helps to avoid SQL injection, cross-site scripting etc. and scalable as applications can be scalable to meet high demands and used to build any type of applications that’s why we call it as a versatile framework. We can build different applications from content management to social networking websites using the Django framework. It offers lots of resources and good documentation, which helps new learners to learn and experience people for reference.

Conclusion

Finally, it’s an overview of Django, how we need to use it, and its uses in real-world application development as Django framework is versatile and allows developers to concentrate on business logic instead of writing common utilities which will be taken care of by Django itself. So choose Django if you need to complete your web application or website within a short time with full security and offers fast, reliable and scalable services based on traffic. Many good websites are developed using Django frameworks like Instagram, BitBucket, and Mozilla etc.

What is Django?

Django is an open-source, free web framework written in Python. This Django helps us build an end to end complete web application. Django using python language, we can create a web page, through which users can send any requests and view the content of the web page.Thee responses between the back-end and user UI are also done by Django, as we have already seen in the Django architecture. Finally, any updates, select, insert statements into the database also can be done using Django integrated with different databases.

Uses of Django

Let us first understand why and in which scenarios Django is used:

• Usage of the Django framework is for a complete and fast development just like other programming languages like C, C#, Java, etc.
• This can be used to handle a large amount of data, heavy continuous traffic, and dynamic data handling.
• We can certify that the code development would be faster in Django, as it has a great feature of re-usability, which would reduce time and space in writing the same code many times.
• This framework can be easily customized.
• The designing technique is clean enough that it could be easily understandable and managed.

Applications of Django

Now, as we have seen why actually we can use the Django framework, now let us check up on what all applications it is used:

1. Instagram

This is one of the most used social networking applications which is used in sharing photos/videos within your network. In this application, when a user logs in, the news feed or the home page is definitely going to differ from other users. This feed is technically based on user-specific interest. This place is where a huge amount of data needs to be handled. This application must be able to easily update the existing features even without complete detailed knowledge of the backend database. Through which we can have fast updates and new features.

Handling this huge data must have to make sure that the security is nowhere to be compromised. Django here is resistant to SQL Injection. Instagram is completely based on the Django framework with extraordinary scalability availability.

2. Disqus

This application is the most used. But why? This is an application that hosts blog commenting globally. This application is being integrated with any social media platform. Using this application, any user would be able to comment under any article news, photos videos, etc. So obviously, this would require handling lots and lots of user details and maintain a large database. This, in turn, can be used in reviewing and performing analytics. This is done with the help of Django framework included with Postgre SQL, or MySql, which would also work.

3. Spotify

Many of us might be currently using this application. This is an app for music. It is mainly developed with Django technology with machine learning algorithms using python. We can create our playlists and based on the song which we like to hear there would many recommendations pouring in based on that. So, as understood, even this application also has its own feed differentiated between all the users. This is also available as a UI application. It requires large database storage to display each user’s choices and display them whenever they log in to their app.

4. YouTube

Yes, the Django application is used in this trending video sharing application as well. Previously this application has been using PHP, but now this is shifted to python for better scalability. Handling much data and delivering proper content to billions of millions of users, Django has been preferred in handling this. We cannot say that the total application is being used with Django but a certain part of it is done in Django. This application that Google has owned that Django would be a better framework that can handle rapid developments easily and perfectly.

5. DropBox

As you already know that this application is for the global accessing of your files anywhere you want. This application is developed using Python. In this scenario, our Django application will help store, share, and sync all these different types of files. In both UI level and mobile app level, the development is done using Python itself. Using Django made development fast and easy in many ways with respect to usage.

6. Bit Bucket

This is also a well-known repository that is launched around 2008, but it got more famous by 2017. This has been developed using Python with the Django framework. So any new feature developments would be easy as the coding from scratch has been done using python only. This is a place where developers put in their code so that anyone can use them and gain knowledge from it.

7. Mozilla

This is a well-known web browser, and do you believe that this application is running on python. Almost all the web browsers currently being developed now are using python, and Djangotto maintains the load on the servers. These browsers use this trending framework as Django is able to handle any number of views or the big number of hits on the website.

8. Prezi

This is a replacement to powerpoint there are many other features that are built-in here. The scalability of Django has made application development.

Conclusion

As we had already checked upon all these applications, we can definitely be sure that the Django framework completely withstands a large amount of data. This functionality of Django has all the scalability, which made many applications to prefer this web framework. Because of its flexible and easy deployment, nature made this framework to be chosen by all the upcoming applications. So, let’s learn and practice python with the Django framework.

Introduction to Django Cookies

Django is a framework that gives us the option for handling cookies. Cookies provide an option which store and retrieve data which is stored in sessions. These cookies have an expiry date and those are lost after a certain period of time. We already know that, whenever we log in to any web page or application the site default would ask for storing of user id and password, auto-filling of few details with respect to the last logged in sessions are all the work done by cookies. Similarly, we can store our cookies on the client-side and help end-user making their work much easier.

Create Cookies

We can create Django cookie using function set_cookie() and forgetting the response we need to have get() function also.

Syntax:

set_cookie(name, value, max_age=None)

Here, the name would be the name of the cookie set, value is the data that we want to store in the cookie and max is the maximum time limit that cookie has to be expired. This is an optional field, so if no time is set, the cookie would exist till the browser is closed.

How to set Cookie Using Django?

Let us see a small example of how we can manually set up a cookie using Django:

1. view.py

Code:

from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def home(request):
return HttpResponse("Welcome")
def setting_cookie(request):
response = HttpResponse("We are setting a cookie")
response.set_cookie('Learning', 'Django',5)
return response
def getting_cookie(request):
first_test  = request.COOKIES['Learning']
return HttpResponse("Practice: "+  first_test);

Explanation to the above code: Through the above code, we can observe that for displaying any output to the screen we are using the HttpResponse function. And, for displaying or obtaining the cookie which is set, we are defining it in a different function and then we are using the request function with variable/expression COOKIE added to it. We are henceforth setting a variable with the value of the cookie setting.

2. urls.py

Code:

from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('setc', views.setting_cookie, name='setc'),
path('getc', views.getting_cookie, name='getc')
]

Explanation to the above code: In the python file urls, we define all the paths that are to be linked with respect to each function that is being written in the views file.

After running the server through the command line: python manage.py runserver

Output:

Getting the Cookie Response:

As highlighted above in views.py code, we had kept the maximum time that cookie has to be saved. Once the time limit is crossed we get the below error:

There is a large description of the error below, please try for yourself and check the total error that has been obtained.

Modify Cookie

Now let us see how we can modify a cookie.

1. view.py

from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def home(request):
return HttpResponse("Welcome")
def setting_cookie(request):
response = HttpResponse("We are setting cookie")
response.set_cookie('Learning', 'Django')
return response
def updating_cookie(request):
response = HttpResponse("We are updating  the cookie which is set before")
response.set_cookie(Learning, 'Happy')
return response
def getting_cookie(request):
first_test  = request.COOKIES['Stay']
return HttpResponse("Always be: "+  first_test);

We can understand that we have written another function to set up a new cookie value which in turn updated the old one.

2. urls.py

from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('setc', views.setting_cookie, name='setc'),
path('updc', views.updating_cookie, name='updc'),
path('getc', views.getting_cookie, name='getc')
]

Explanation to the above code: In views.py we have added a new function that is updating our already set cookie. And then in our get function, we are returning the cookie which is set after the updating.

Output1:

Output2:

Output3:

Output4:

If you can observe here the value of the cookie has been updated for the previously set value to the updated value. In this way, we can modify or update the cookie value once set.

Update Django Cookies

We have another way of updating a cookie using the redirect function instead of Httpresponse. But still, we use the set_cookie function only. Below is the code for it, as we added a new function in

view.py

Code:

def updating_cookie1(request):
response = redirect(home)
response.set_cookie('Learning', 'Practising')
return response

Output1:

Output2:

Output3:

Delete Cookie

Here let us get into on how we can delete a cookie that is set.

We already know that there is an optional parameter for the set cookie function called max_age, which would delete the cookie session by default. To make it much simpler, we added the below-mentioned code to the above code.

1. view.py

Code:

def deleting_cookie(request):
response = HttpResponse("We are now finally deleting the cookie which is set")
response.delete_cookie('Learning')
return response

The above code is added in the views file and above the getting_cookie function.

2. urls.py

Code:

from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('setc', views.setting_cookie, name='setc'),
path('updc', views.updating_cookie, name='updc'),
path('getc', views.getting_cookie, name='getc'),
path('delc', views.deleting_cookie, name='delc')
]

Output1:

Output2:

Output3:

• We even have an attribute name ‘expires’ for handling the end session for a cookie.
• As an exercise try using the expire function and handle deleting a cookie.
• The code can be written as mentioned in the below format:
• response.cookies[‘cookie_name’][‘expires’] = datetime.today() + timedelta(days= number_of_days)
• So, this is how we can delete the cookie.

Enable and Disable Django Cookies

The cookies enable and disable are based on the settings python file. The session variables are present in the settings file which can handle session cookies. The enabling and disabling of cookies are done manually by setting, updating and deleting cookies. There are session-level cookies also, which can be set to true when required. They are set to FALSE by default. These session cookies are encrypted and make sure those are secured. By using different techniques we can use session cookies and update the number of counts whenever a particular website is visited.

Conclusion

Here we have learned on what cookie is and how to handle them. We created Django cookies, updated them and even deleted those cookies. We can have our cookie set with the login user id and password in the same way as many websites are now portraying of. These cookies can help in easy retrieval of data as whenever a user requests for data it does not always go, search in the database and then fetch details for the user. But at the same time, we must be beware of hackers while handling these cookies.

Introduction to Django Framework

Django is a Python-based server-side web framework used worldwide to make web applications. Some of the top companies using Django are:

• NASA
• Google (Youtube)
• Instagram
• MIT

Since Django employs Python, we can deploy regular websites and Machine Learning Models, such as for Speech Recognition, Fraud Detection, etc., over the web. Django has a very modular approach called MVT (Model-View-Template) architecture. Following this architecture makes the code very easy to develop, deploy and maintain.

Django also provides a built-in Admin module that can be used to store master values on the website. For example, for processing a Loan application, there may be a screen called “New Loan” then in this form, suppose there is a drop-down menu for Loan Types, Personal Loan, Car Loan, Home Loan, etc., then these values are maintained through the admin panel.

Understanding Django Framework

As we know that Django has an MVT architecture, we will go step by step in explaining each term.

The moment we install the Django framework and create a new project, the following files (the most important and frequent) are automatically created for us to write our code :

• models.py
• views.py
• settings.py
• urls.py

Each of these files is intended for code modularity. settings.py file stores all the custom configurations, such as database connection parameters, server details on which the application will be hosted, global variables that can be accessed throughout the application, etc.

urls.py file has a list of all the custom URLs which will be used in the application to access different pages. Let us look at the models, views, and templates.

Model

Model in Django refers to Database Tables created per the requirements to store data. For example, if we want to create a Bank website, then we need tables to store customer data such as Customer Name, Account Number, Bank Balance, etc. The code for writing these models is put into the models.py file.

Now you may wonder which database to use for creating Django Models. Relax! Django supports all major databases (Oracle, PostgreSQL, MS SQL Server, MySQL ), and you need not worry about different types of SQL for different databases. Because Django implicitly can translate your Python code into corresponding Database SQL.

View

View in Django refers to what needs to be done/processed over the requests received from the client to the server. These HTTP requests (GET, POST, etc.) can be for specific purposes such as Account Debit, Account Credit, Creating a new account, etc.

Views, in turn, interact with models to store/retrieve/delete data. The code for writing these views is put into views.py

Template

Templates refer to the HTML pages which the user sees. It contains the background images, TextBoxes, Buttons, etc., which are rendered in the client’s browser and gives the website a look and feel.

Templates don’t have a .py file because templates are HTML codes. Hence, we have to make a templates folder and keep all the .html files in this folder.

Why Use Django?

Django is popularly known as a “Web framework for perfectionists with deadlines.” This is a very apt saying because all the components you may require to build a web application come bundled with this framework viz., in-built web server and SQLite Database. Also, the admin panel prevents reinventing the whole wheel, and the developer can focus on writing the core application code rather than creating basic necessities.

The other most important feature of Django is “SECURITY.” Django forces the developer to implement security-related features into the application; otherwise, the code does not execute successfully. For example, csrf (Cross-Site Request Forgery). csrf is a random token generated every time we submit form data. The Django server validates this token on every HTTP POST Request it receives. If some hacker tries to attack, then this token becomes invalid and our application remains secure.

Another interesting feature of Django is – Template extensions and Tags. Django provides with tons of template tags that can be used directly in the templates (.html codes), thus preventing development effort and reducing the size of templates. One template (for ex: base.html) can be easily extended into another template, and as a result, this other template reduces to only a few lines of HTML code.

Importance of Django Framework

Until now, you must have got a fair idea of how Django can be so useful. The importance of Django can be realized from the fact that the world’s top companies use Django for their application. This includes Mozilla, NASA, Instagram, Pinterest, Dropbox, and many more. The market is full of Django opportunities, yet only a few people are available; hence Django people easily get the upper hand.

Moreover, cloud service providers such as AWS have a dedicated service to host Django applications called Elastic Beanstalk which provides managed Apache server, PostgreSQL, Load Balancer, and AutoScaling for Heavy Load applications. Django applications can also be exposed as APIs for consumption by Third Party Software. This is done by using the Django REST Framework.

Django Prerequisite

Python is the single most important prerequisite for learning Django. More specifically, Concepts related to Class, Inheritance, Functions, and Data Structures (Lists, Dictionaries, Tuples) should be very clear because the entire Django framework revolves around Classes and Functions.

Also, to develop the front-end (Templates section), knowledge of HTML, Javascript, and AJAX will greatly help. To install Django, you need your Computer with Linux/Windows with Python installed. Then with a single command (pip install Django), Django becomes your playground.

Conclusion

Django is extremely rapid in development, scalable and flexible in design, and highly secure and reliable. The vast Django community solves any problem you might face during Django development. If you practice and master the basic concepts of Django, then you can build Production-Ready web applications in a matter of a few days.

Introduction to Django Views

All views for a Django application are placed in views.py file. Here a view is a python function that takes in a request and returns a response. The response can be an HTML-oriented web page or it could be an XML document even an error message or even an image. The view itself hold anything subjective in logic is essential to go back as a response. The code can be placed anywhere needed until it is associated with the python path. Every view is callable and holds the capability to take a request and response. It is more than a function.

How to Create a Plain Django View?

Below we learn how to create a plain Django View:

1. Declare the Function in views.py file of the Django Application 

For Declaring the view in Django we need to have an HTTP request and a response. The HTTP request will be automatically created by the Django framework. the response for this request needs to be created by the programmer. This response will be placed in the HttpResponse() method of Django.http package. HttpResponse has subclasses counting Streaming HttpResponse , JsonResponse  and FileResponse.

Every function created in this views.py file will be considered as a separate view for that application.

Code:

from Django.shortcuts import render
from Django.http import HttpResponse
def view1(request):
return HttpResponse ("Hello World")

2. Tag the view in urls.py File

This is the process of creating a url for the view. The url mentioned here will be used for reaching the web page which is been mentioned.

• Import the library from django.conf.urls import url.
• declare a url entry in the urlpatterns list

url(url_path , view_to_be_tagged , name_for_this_view)

Code:

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'^$',views.index,name='index'),
url(r'admin/', admin.site.urls), ]

3.  Reload the server using python manage.py runserver command and verify the webpage.

4. On running the server the below-mentioned system message will be printed on to the console, from the given message we can notice the time at which the server was kickstarted, the version of the Django setup which is been used, and the HTTP link at which the server is kickstarted.

Code:

Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
June 07, 2020 - 10:13:00
Django version 3.0.7, using settings 'educba.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Output:

Django View Rendered from Templates

The Templates are very helpful in understanding how the functionality of Django works. these templates hold the static items in an HTML page. it could be the Skelton of the page. To render a view from a template the below steps are followed.

1. Create a Template Folder:  All template related HTML code could be placed into this folder. The template folder has to be created under the primary project folder.

2. Tag the Template Folder in settings.py File:  The created Template folder needs to be tagged in settings.py file. So Once tagged it allows every HTML file placed under the templates folder as accessible around the veiws.py file.

Code:

import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
Template_DIR = os.path.join(BASE_DIR,'Templates')
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [Template_DIR,],
'APP_DIRS': True,
'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',
],
},
},
]Template_DIR = os.path.join(BASE_DIR,'Templates')

3.  Place an HTML file inside the Templates Folder

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> Hello world from HTML page <h1>
</body>
</html>

4. Render the HTML File in views.py using() Method: The render function of Django is used to give the newly created HTML content to The render method combines a template with the context dictionary to return a HttpResponse object.

Syntax:

render(request, template_name, context=None, content_type=None, status=None, using=None)

Code:

from django.shortcuts import render
from django.http import HttpResponse
def index(request_iter):
return render(request_iter,'design.html')

5.  Reload the server using python manage.py runserver command and verify the webpage.

Output:

Django view Rendered from Template TAG

The template tags are used for injecting dynamically generated content to the Django views. This is among the key functionalities of the template tag. They could flexibly inject dynamic contents into the file.

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> Hello world from HTML page <h1>
{{ Key1 }}
</body>

2.  Add a context template dictionary in the view and tag the dictionary to the context.

Code:

from django.shortcuts import render
from django.http import HttpResponse
def index(request_iter):
dict_Var = {"Key1" : "The Template tag value is rendered with reference to key1"}
return render(request_iter,'design.html',context=dict_Var)

Output:

Conclusion

Django being the most predominant method for web-based applications. the concept of views are very firmly implied in a Django framework such that these views could generate responses in the most flexible way possible. Concepts like templates and template tag processes in Django views add additional stability set up in making it as one among the most predominantly used web application framework.

Introduction to Django Forms

For a web application creation forms is a critical capability, These forms act as the key source through which the user keyed in input enters into the application. This user keyed-in input could be further validated and processed in a precise manner. These are among the key capabilities in form processing. Django offers a classified set of methods for formulating the form entities.

How to Create a Django Form?

Create a Django form are explain below:

1. Create a forms.py file in the application

The forms.py file is similar to models.py, All fields used in the form will be declared here under a form class.

Example – forms.py

from django import forms
class Valueform(forms.Form):
user = forms.CharField(max_length = 100)

2. Create a View for The Form

A Django view method is created for the form in the views.py file. An object for the form class is created here. this object is used as a value for the context dictionary in the template rendering.

Example – views.py

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform
defform_view(request_iter):
form = Valueform()
return  render(request_iter,'Form_Handeling.html', {"form": form})

3. Formulate an HTML file for displaying the form

An HTML file needs to be created in the templates directory for displaying the form, here the file is template tagged using the below tag,

{{ form.as_p}}

here “as_p” is used for better designing of the form elements. the {% csrf_token %} line is used for attesting the internal security verification performed by django.

Example

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1><u> FORMS HANDELING IN DJANGO </u></h1
<div style = "max-width:470px;">
{{ form.as_p }}
{% csrf_token %}
<input type="submit" class="btnbtn-primary" value="submit">
</div>
</body>
</html>

4. Tag the view in urls.py file

This is the process of creating a url for the view.

• Import the library from django.conf.urls import url
• declare a url entry in the urlpatterns list
  url(url_path,view_to_be_tagged,name_for_this_view)

Example

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'^$',views.index,name='index'),
url(r'formpage/',views.form_view,name='form'),
url(r'admin/', admin.site.urls), ]

Output:

All Form Fields Available in Django Forms

Form fields available in django forms are as given below:

Example – forms.py

The forms.py file below contains several among the above-mentioned form fields declared and executed as an application.

#-*- coding: utf-8 -*-
from django import forms
class Valueform(forms.Form):
first_name = forms.CharField(max_length = 100)
last_name = forms.SlugField()
gender =  forms.BooleanField()
Ip = forms.GenericIPAddressField()
file =  forms.FileField()
department = forms.ChoiceField(choices = (('1','CSE'),('2','IT'),('3','ECE'),('4','EEE')))

Output:

Processing Form Fields in View

The value entered in the form fields can be captured and processed  using the below form handling code in the view method for the form

Example – views.py

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform
defform_view(request_iter):
form = Valueform()
if request_iter.method == "POST":
value = Valueform(request_iter.POST)
if value.is_valid():
print("First Name: ",value.cleaned_data['first_name'])
print("First Name: ",value.cleaned_data['last_name'])
return  render(request_iter,'Form_Handeling.html', {"form": form})
Here when a ‘POST’ is submitted from the form it is passed as a part of the request thread in the method argument, so this is verified in the below statement,

if request_iter.method == "POST":

So when a ‘POST’ is submitted then the value associated with the POST request is captured into an object by referring to the form class declared in forms.py. using the cleaned_data[] argument of this object and using the name of the corresponding field the value keyed from the field is captured. In this example, the captured value is printed onto the console. In real-time cases, further processing will be done to these values like DB storage or server validation, etc.

Output:

Introduction to Django Response

The response is the outcome from the processing of a webpage, This outcome can be captured using the Http response class when a returned value is cached using the Http response class then that response will be assigned with response-oriented characteristics, As like a request framework these characteristics can be captured and verified using special attributes and methods, each of these attributes and methods displays the corresponding value associated to the response, More specifically these response methods and attributes are useful in verifying the various information related to the response. All these attributes and methods are discussed below briefly with suitable examples. In this topic, we are going to learn about Django Response.

Response Framework Attributes

The attributes of Django response framework are listed below,

Response Framework Methods

All methods associated with response framework are mentioned below,

Examples of Django Response

Here are the following examples mention below:

Example #1

1) Design the choiceField() in the forms.py with the values it needs to display and process in the choices attribute of the field.

views.py:

def email_sending(response):
email = emailform()
if response.method == 'POST':
email_id =  response.POST['email'] email_subject =  response.POST['email_subject'] email_message =  response.POST['email_message'] mail = send_mail(email_subject,email_message,'testmysmtpconnection@gmail.com',[email_id],fail_silently = False)
response = HttpResponse(mail)
print("Content of the resposne: ",response.content)
print("Charecterset of the response: ",response.charset)
print("Status code of the response: ",response.status_code)
print("Reason phrase of the response: ",response.reason_phrase)
print("Reason close status: ",response.closed)
return response
return render(response, 'emailpage.html',{"email":email})

2) Design the webpage in the corresponding template file for this page,

Response_methods_check.html:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/font.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
.myDiv {
border: 5px outset red;
background-color: lightblue;
text-align: center;
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 14px;
letter-spacing: 2px;
word-spacing: 1.8px;
text-align: left;
color: #02071C;
font-weight: 200;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}
</style>
</head>
<body>
<h1> <u> DJANGO HANDELING EMAILS </u> </h1>
<div class="myDiv" style = "max-width:470px;">
<form method =  'POST' ">
{{ email.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit" style="text-align:center">
</form>
</div>
</body>
</html>

Output:

,

Example #2

1) Here the response values from a file upload page is been verified

views.py:

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform,fileform,emailform,responsecheckform
from django.core.exceptions import ViewDoesNotExist
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib import messages
from django.core.mail import send_mail,EmailMessage
import responses
def file_upload(response):
file = fileform()
print(" File Values in File Dictionary:", response.FILES)
if response.method == 'POST' and response.FILES['Uploaded_File']:
uploaded_file = response.FILES['Uploaded_File'] fs = FileSystemStorage()
filename = fs.save(uploaded_file.name, uploaded_file)
uploaded_File_Size = 'Size of Uploaded file: ' + str(uploaded_file.size)
content_type_of_uploaded_file = 'Content type of uploaded file: ' + str(uploaded_file.content_type)
uploaded_file_name = 'Name of Uploaded file: ' + str(uploaded_file.name)
uploaded_file_url = fs.url(filename)
print("uploaded file url",uploaded_file_url)
messages.success(response, '!!! File upload successful !!!')
messages.success(response,uploaded_File_Size)
messages.success(response,uploaded_file_name)
messages.success(response,content_type_of_uploaded_file)
response = HttpResponse(filename)
print("Content of the resposne: ",response.content)
print("Charecterset of the response: ",response.charset)
print("Status code of the response: ",response.status_code)
print("Reason phrase of the response: ",response.reason_phrase)
print("Reason close status: ",response.closed)
return render(response, 'filehandeling.html', {"file":file})
return render(response, 'filehandeling.html',{"file":file})

Html file:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/font.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
</style>
</head>
<body>
<h1> <u> FILE UPLOAD HANDELING IN DJANGO </u> </h1>
{% if messages %}
<ul>
{% for message in messages %}
<li>{{ message }}</li>
{% endfor %}
</ul>
{% endif %}
<div style = "max-width:470px;">
<form method =  'POST' enctype="multipart/form-data">
{{ file.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit">
</form>
</div>
</body>
</html>

Output:

Example #3

1) Here the response values generated form a form page is been captured and verified,

views.py:

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform,fileform,emailform,responsecheckform
from django.core.exceptions import ViewDoesNotExist
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib import messages
from django.core.mail import send_mail,EmailMessage
import responses
def formView(response_iter):
form = Valueform()
if response_iter.method == "POST":
value = Valueform(response_iter.POST)
if value.is_valid():
first_name = value.cleaned_data['first_name'] response = HttpResponse(first_name)
print("Content of the resposne: ",response.content)
print("Charecterset of the response: ",response.charset)
print("Status code of the response: ",response.status_code)
print("Reason phrase of the response: ",response.reason_phrase)
print("Reason close status: ",response.closed)
if response_iter.session.has_key(first_name):
print(response_iter.session.items())
return render(response_iter, 'Session.html' )
else:
response_iter.session[first_name] = first_name
return render(response_iter, 'Form_Handeling.html', {"form":form})

Html file:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/base.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background1.jpg' %}");
background-color: #acccbb;
}
</style>
</head>
<body>
<h1> <u> FORMS HANDELING IN DJANGO </u> </h1>
<div style = "max-width:470px;">
<form method =  'GET'>
{{ emailform.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit">
</form>
</div>
<ul class="messages">
{% for message in messages %}
<li{% if message.tags %} class="{{ message.tags }}"{% endif %}>{{ message }}</li>
{% endfor %}
</ul>
</body>
</html>

Output:

Conclusion

From the above-provided descriptions and examples, the key information related to the Httpresponse framework can be understood.

Introduction to Django Session

Sessions are server side cookies. In every web application certain user-oriented inputs will be stored on both server and client(Web browser) end. This data when stored on the server end it is named as Sessions. The data stored on the client end is named as cookies. These sessions came into play in Django framework to ensure the security of the application. These sessions helps to attain the abstraction of how cookies are generated and sent and received. So based on the importance of the data considered for saving lot of security potholes can be successfully attested by implementing these sessions.

Methods to Catch Session Data

Django Sessions can be captured and stored on the server end by three ways.

• Store Sessions onto the connected middleware database.
• Store Sessions onto a file.
• Store Sessions onto a temporary cache.

1. Store Sessions onto the connected middleware database

This is the predominant method for catching session data. The below settings need to be inplace for triggering this setup.

Code:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Django_app1',
] MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

2. Store Sessions onto a file

Here sessions are captured to an input file. The server id must have sufficient access specifications for capturing sessions through this technique.

3. Store Sessions onto a cache

In this technique Sessions are captured in temporary cache. All session data captured by will be erased if the application or the server is restarted. Persistent cache services can also be created.

The below settings parameters need to be in place for activating the cache oriented sessions.

Code:

SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
}
}
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Django_app1',
] MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Creating a Session in Django

Given below shows creating a session:

1. SETTINGS.PY changes

We use cache based session capturing, so the lines are inserted into the SETTINGS.py file.

Example:

(SETTINGS.py)

Code:

SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
}
}
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Django_app1',
] MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

2. Create a forms.py file in the application

The forms.py file is similar to models.py. All fields used in the form will be declared here under a form class.

Example:

(forms.py)

Code:

from django import forms
class Valueform(forms.Form):
user = forms.CharField(max_length = 100)
last_name = forms.SlugField()

3. Create a view for the form

A Django view method is created for the form in the views.py file. An object for the form class is created here. This object is used as a value for the context dictionary in the template rendering.

• A post is performed in the rendered page.
• Through ValueForm class the data of the post is captured into a variable.
• The is_valid() is a mandatory check, which is used to verify whether the captured data is valid. The process of validation here will be performed internally by Django. Additionally if value.is_valid() is not performed then cleaned_data[] cannot be used.
• The session value of first name is captured in the below instance.

request_iter.session[first_name] = first_name

• In this example the sessions are logically assembled so that is the same first name is entered twice it will enter into the sessions page.

Example:

(views.py)

Code:

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform
defformView(request_iter):
form = Valueform()
if request_iter.method == "POST":
value = Valueform(request_iter.POST)
if value.is_valid():
first_name = value.cleaned_data['first_name'] if request_iter.session.has_key(first_name):
print(request_iter.session.items())
return render(request_iter, 'Session.html' )
else:
request_iter.session[first_name] = first_name
return render(request_iter, 'Form_Handeling.html', {"form":form})
return render(request_iter, 'Form_Handeling.html', {"form":form})

4. Formulate a HTML file for displaying the form

A HTML file needs to be created in the templates directory for displaying the form, here the file is template tagged using the below tag,

{{ form.as_p }}

Here “as_p” is used for better designing of the form elements.

{% csrf_token %} line is used for attesting the internal security verification performed by Django.

Example:

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1><u> FORMS HANDELING IN DJANGO </u></h1
<div style = "max-width:470px;">
{{ form.as_p }}
{% csrf_token %}
<input type="submit" class="btnbtn-primary" value="submit">
</div>
</body>
</html>

5. Formulate a HTML file for displaying the page which is triggered when sessions are activated

A HTML file needs to be created in the templates directory for displaying the Session page.

Example:

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1><u> SESSION PAGE IS TRIGGERED </u></h1>
</body>
</html>

6. Tag the view in urls.py file

This is the process of creating a url for the view.

• Import the library from django.conf.urls import url.
• Declare a url entry in the urlpatterns list.

url(url_path, view_to_be_tagged, name_for_this_view)

Example:

Code:

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'^$',views.index,name='index'),
url(r'formpage/',views.form_view,name='form'),
url(r'admin/', admin.site.urls), ]

Output:

Attempt 1:

Attempt 2:

End result:

Output Explanation:

Here the first name and last name are submitted by the user, when the name Rakesh Sharma is submitted for the second time the session value is recollected and session page is triggered. The name raviranjan is triggered in between both these insertions. The server side data printed onto the console is also pasted as the last snapshot. In this last snapshot we can notice the value of the sessions captured.

We can notice the entered first name values by the user are captured as separate entries inside a dictionary with the identified first name itself as both the key and value for the dictionary values of each entry. More significantly the session page is rendered when the rakesh value in first name is entered for the second time. This precisely explains how session data are recollected and processed.

Conclusion

Sessions are always an impressive method for increasing the efficiency of the web application. It gives the flexibility for the user so that they could much smoothly traverse across the application. Django offers the most sophisticated method for handling these sessions in a very precise manner. The above examples show how efficiently cache based sessions help in capturing user data for efficient processing.

Introduction of Django Static Files

Static files are images, CSS scripts in the application. Django offers flexible techniques to induce these static files into the application. This flexible way of managing these static files will help to maintain the application performance better. The django.contrib.staticfiles is responsible for maintaining the static files in Django. The django static files play a wide role in the content management of the items used. from a Django perspective, the framework offers convenient ways through which these file-oriented resources could be very effectively handled. serving these static files precisely in production is also among the key capabilities of the currently derived Django frameworks.

How Static Files Work in Django?

Let’s see how static files work in django?

1. Ensure django.contrib.staticfiles

First we need to ensure the django.contrib.staticfiles is added as a part of INSTALLED APPS in SETTINGS.py.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.postgres',
'Django_app1'
]

2. Ensure static url

Next, we need to ensure the static url is being set to ‘/static/’. All the static files will be served to the webpage using a url, and this url will have this /static/ appended to it. Basically, all the static files collected in STATICFILES_DIRS or STATIC_ROOT are accessed by the webpage using this url
 

SETTINGS.py:

STATIC_URL = '/static/'

3. Ensure STATICFILES_DIRS or STATIC_ROOT

The STATICFILES_DIRS or STATIC_ROOT variables are responsible for mentioning the path at which the static files are stored. the STATIC_ROOT is preferably used in PROD systems whereas the STATICFILES_DIRS are used in test systems. both these variables cannot be declared in the same SETTINGS.py file.
 

SETTINGS.py:

STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static'), ] #STATIC_ROOT = os.path.join(BASE_DIR, 'static')

4. Python manage.py collect static command

This command is used for collecting all the static files in the system and get them associated with the static directory.

python manage.py collectstatic

5. Template file changes

At last the below changes has to be made in the template file. these changes will load the static files in the template files during the rendering process.

• All these changes are associated with the header section of the html file.
• add the static files load command in the template head section.

{% load static %}

• • set the static folder reference path in the item to be pulling the static files.
    • CSS files: <link href=”{% static ‘admin/css/font.css’ %}” rel=”stylesheet”>
    • Image files: <img src=”{% static ‘admin/css/font.css’ %}” ” alt=”My image” height=”300px” width=”700px”/>

• The above changes will successfully pull the static files from the static folder.

Examples of Django Static Files

Following are the examples are given below:

Example #1

css file:

STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static'), ] #STATIC_ROOT = os.path.join(BASE_DIR, 'static') body {
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 36px;
letter-spacing: 2px;
word-spacing: 1.8px;
color: #02071C;
font-weight: 700;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}
h1 {
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 34px;
letter-spacing: 2px;
word-spacing: 1.8px;
color: #02071C;
font-weight: 650;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}
h2 {
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 32px;
letter-spacing: 1px;
word-spacing: 2.0px;
color: #02071C;
font-weight: 600;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}
h3{
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 30px;
letter-spacing: 1px;
word-spacing: 2.1px;
color: #02071C;
font-weight: 400;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}

Image Location:

filehandeling.html:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/font.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
</style>
</head>
<body>
<h1> <u> FILE UPLOAD HANDELING IN DJANGO </u> </h1>
{% if messages %}
<ul>
{% for message in messages %}
<li>{{ message }}</li>
{% endfor %}
</ul>
{% endif %}
<div style = "max-width:470px;">
<form method =  'POST' enctype="multipart/form-data">
{{ file.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit">
</form>
</div>
</body>
</html>

Output:

Example #2

css file:

@import url(fonts.css);
body {
margin: 0;
padding: 0;
font-size: 45px;
font-family: "Roboto","Lucida Grande","DejaVu Sans","Bitstream Vera Sans",Verdana,Arial,sans-serif;
color: grey;
background: #fff;
}
a:link, a:visited {
color: #447e9b;
text-decoration: none;
}
a:focus, a:hover {
color: #036;
}
a:focus {
text-decoration: underline;
}
a img {
border: none;
}
a.section:link, a.section:visited {
color: #fff;
text-decoration: none;
}
a.section:focus, a.section:hover {
text-decoration: underline;
}
/* GLOBAL DEFAULTS */
p, ol, ul, dl {
margin:.2em 0.8em 0;
}
p {
padding: 0;
line-height: 140%;
}
h1,h2,h3,h4,h5 {
font-weight: bold;
}
h1 {
margin: 0 0 20px;
font-weight: 300;
font-size: 20px;
color: #666;
}
h2 {
font-size: 16px;
margin: 1em 0.5em 0;
}
h2.subhead {
font-weight: normal;
margin-top: 0;
}
h3 {
font-size: 14px;
margin:.8em 0.3em 0;
color: #666;
font-weight: bold;
}
h4 {
font-size: 12px;
margin: 1em 0.8em 0;
padding-bottom: 3px;
}
h5 {
font-size: 10px;
margin: 1.5em 0.5em 0;
color: #666;
text-transform: uppercase;
letter-spacing: 1px;
}
ul li {
list-style-type: square;
padding: 1px 0;
}
li ul {
margin-bottom: 0;
}
li, dt, dd {
font-size: 13px;
line-height: 20px;
}
dt {
font-weight: bold;
margin-top: 4px;
}
dd {
margin-left: 0;
}
form {
margin: 0;
padding: 0;
}
fieldset {
margin: 0;
padding: 0;
border: none;
border-top: 1px solid #eee;
}
blockquote {
font-size: 11px;
color: #777;
margin-left: 2px;
padding-left: 10px;
border-left: 5px solid #ddd;
}
code, pre {
font-family: "Bitstream Vera Sans Mono", Monaco, "Courier New", Courier, monospace;
color: #666;
font-size: 12px;
}
pre.literal-block {
margin: 10px;
background: #eee;
padding: 6px 8px;
}
code strong {
color: #930;
}

formhandeling.html:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/base.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
</style>
</head>
<body>
<h1> <u> FORMS HANDELING IN DJANGO </u> </h1>
<div style = "max-width:470px;">
<form method =  'GET'>
{{ form.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit">
</form>
</div>
<ul class="messages">
{% for message in messages %}
<li{% if message.tags %} class="{{ message.tags }}"{% endif %}>{{ message }}</li>
{% endfor %}
</ul>
</body>
</html>

Output:

Introduction to Django Mail

Apart from the smtp mail connectivity offered by python Django also offers the django.core.mail library for handling the email requests. So any email oriented process can be handled by this library in a very flexible manner. We can use this library for sending emails to external users, website admins, website managers, also emails with attachments and even emails to bulk set of mass users can be triggered. It flexibly alterates the email delivery process in the Django based frameworks and the email delivery process is precisely accelerated.

How Django Mail works?

Given below shows how Django Mail works:

1. To connect the email setup to Django the below listed email configurations should be in place at SETTINGS.PY file.

• EMAIL_HOST − SMTP server.
• EMAIL_HOST_USER − SMTP server login credentials.
• EMAIL_HOST_PASSWORD − SMTP server password credentials
• EMAIL_PORT − port of SMTP server.
• EMAIL_USE_TLS or _SSL − True if secure connection.

Code:

#---------- EMAIL HANDELING ----------#
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_PORT = 587
EMAIL_HOST_USER = 'testmysmtpconnection@gmail.com'
EMAIL_HOST_PASSWORD =  '*********'
EMAIL_USE_TLS = True

a. EMAIL_BACKEND

The email backend protocol used is referred in the EMAIL_BACKEND variable. Some among the protocols are SMTP, SMTPS, IMAP etc. By default django uses SMTP protocol, setting the variable to ‘django.core.mail.backends.smtp.EmailBackend’ represents nothing other than SMTP, only thing is it is explicitly mentioned here.

b. EMAIL_HOST

The email host refers the email provider which is expected to reach, it represents the smtp host name of that email provider.

Example:

smtp.mail.yahoo.com

c. EMAIL_PORT

The email port refers the email providers port which is opened for smtp connectivity.

Example:

for yahoo the port number is 465

d. EMAIL_USER

This represents the user name of the email account to be connected.

Example:

user1@gmail.com

e. EMAIL_PASSWORD

This represents the password of the corresponding email account.

f. EMAIL_USE_TLS

This parameter is used to mention whether TLS secure connection need to be turned on or not.

2. The next critical step is the use of django.core.mail.

The django.core.mail library has four methods for handling emails.

• send_mail()
• send_mass_mail()
• mail_admins()
• mail_managers()

a. send_mail()

Syntax:

send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None,connection=None, html_message=None)

Description:

This method sends the email and posts the number of messages delivered.

b. send_mass_mail()

Syntax:

send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)

Description:

Sends mail to a wide set of people, the data tuple is a combination of below elements.

(subject, message, from_email, recipient_list)

c. mail_admins()

Syntax:

mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)

Description:

Sends mail to side admins as the admin names are declared in the ADMIN settings.

d. mail_managers()

Syntax:

mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)

Description:

Sends mail to side Mangers as the Manager names are declared in the MANAGER settings.

Example:

Code:

send_mail(
'Subject',
'Message.',
'from_email@example.com',
['end_email1@example.com', 'end-email2@example.com'],
)

Introduction to Form Validation in Django

The following article provides an outline on Form Validation in Django. Django is a framework which provides built in methods to verify the data within in forms. And this verification can be done automatically using these Django methods. These can be only done by using and submitting CSRF tokens. There are functions that can be used to handle these validations. We can here take many inputs from user based on requirement and make our form validations accordingly.

Form Validations

For validating the forms, we first need to create a form and then use different validation techniques to validate the data written in the forms. For creating the form, each label would correspond to a data type with respect to the format of data that has to be loaded in.

Given few of them below:

• CharField
• EmailField
• BooleanField
• DateField
• DecimalField
• ChoiceField etc.

Example of Form Validation in Django

A small example of creating a form below:

forms.py

class MyForm(forms.Form):
Name=forms.CharField()
email=forms.EmailField(label='Email')
Gender=forms.ChoiceField(choices=[(' ','Choose'),('M','Male'),('F','Female')])
Description=forms.CharField(widget=forms.Textarea,required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper=FormHelper
self.helper.form_method = 'post'
self.helper.layout = Layout(
'Name','email','Gender','Description', Submit('submit','Submit',css_class='btn-success')
)

views.py

from django.shortcuts import render
from django.http import HttpResponse
from .forms import MyForm
# Create your views here.
def first_form(request):
if request.method=='POST':
form=MyForm(request.POST)
if form.is_valid():
Name=form.cleaned_data['name'] Email=form.cleaned_data['email'] Gender=form.cleaned_data['gender'] Description=form.cleaned_data['description'] print(Name,Gender)
form=MyForm()
return render(request,'form.html',{'form':form})

form.html

{% load crispy_forms_tags %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width-device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>My Form </title>
</head>
<body style="padding: 20px;">
{% crispy form form.helper %}
</body>
</html>

Urls.py

from django.contrib import admin
from django.urls import path,include
from . import views
urlpatterns = [
path('first_form',views.first_form,name='first_form'),
]

In the main project of settings.py we need to add our new app name and in the urls.py file also, we need to have a link of our new app that is created. Below we are adding the code snippets of those files also.

Urls.py: Project level

from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('',include('Third.urls')),
path('admin/', admin.site.urls),
]

Settings.py :

We have added our app and the crispy forms module that we have used in forms.html for styling purpose. That library can be added into Django using pip install method.

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Third',
'crispy_forms'
]

Forms can be created using form models and the forms html files and at the same time with the models functionality also. Here we have done it using forms.

When observed, we can see that in views file that is written, there were form validator methods that we have used here.

cleaned_data[‘field_name’]

This is one of the important methods of validating. This would contain the cleaned data which are received from the form. This means that we are specifying a particular data type for a particular variable, which help in storing of the data. We can even raise customized errors.

The main part, in which cleaned data function, is incorporated under function is_valid.

Syntax:

form.is_valid()

This function is used to validate the whole form data. Whatever is uploaded in the form can be validated using this function that is declared above. This validation would be returning the Boolean expressions of validating the complete form data type.

Output of the above code:

Let us check the different errors that are being raised in this simple form.

After giving the name, if we simply try to click on submit as shown below:

System is going to alert error like below:

As we have mentioned the above field mandatory we get that alert that those fields has to be filled.

Now with respect to the email functionality, if we give some random letters directly let us see what we get.

And now if we include the ‘@’ symbol also and if we do not specify any domain name(not necessarily the correct one), we can still get an error.

So, after giving all the details properly as below:

It is okay to either write anything or leave the description part empty as it is not the mandatory required field. After clicking on submit we can have the below output in our python module as written in the code.

As written the code, we wanted to print the name and gender – so that is what that got printed in our python development shell. We have link between all those python files. Form.py file has link with views.py file and in turn both are to be linked with the html file in the templates. As already known we must have the link with urls.py and views.py to display the UI level output through the http web URL. This is the basic flow for all those python files that are written in generating a form and performing it’s vaLidations.

For handling forms, we even have attributes like validators. These are used in case of model level changes to a form. And even with respect to raising a customized error can be done by raising a ValidationError function. These are the functions that are in default available in Django for different form validations. And with all these we can even have separate functions written to raise different validations with respect to forms.

Conclusion

This is how we can have different form validations in Django. We have in turn created a simple form added our in built validations using those respective python files and link each of them to create perfect form validations. There are many level validations that can be done. But here we have done by creating a form and making basic validations for it. We have covered two methods in the same example which is mentioned above. As already listed, we can create forms using Models by models.py python file and include all the customized validations that are required.

Introduction to Django GROUP BY

The following article provides an outline for Django GROUP BY. This operation is a fairly common operation for who are more familiar with the SQL part. The Django ORM is said to be an Abstraction layer which let us work with the database (which is an object-oriented), where finally it’s just a relational database and actually all the operations are translated into SQL statements. The database is a powerful tool with which you can do the work much faster and directly in it. The interesting information, when you get through the GROUP BY Queries, you will be no longer interested in each model instances and table row details.

GROUP BY in Django with SQL (Using Django Querysets & SQL)

We use to have a chaos among GROUP BY and aggregate. As both are not the same one but they can’t work without one-another.

A GROUP BY in Django is used with the AGGREGATE functions or the built-ins. The GROUP BY statement and aggregate functions like COUNT, MAX, MIN, SUM, AVG are used in a combo to group the result – set by one or more columns.

Syntax:

SELECT column _ name(s)
FROM table _ name
WHERE condition
GROUP BY column _ name(s)
ORDER BY column _ name (s);

Understanding this clause using the DJANGO GROUP BY Cheat Sheet.

This is the model from Django’s built-in django. contrib. auth app.

Count Rows:

Counting rows is one of the Django functions on the Query Set. Number of rows in a table can be identified using the method of Count Rows. Here the key name is derived from the ‘Name of the field’ and the ‘Name of the aggregate’.

Example:

The following SQL statement lists the no. of customers from each country:

Sample Database:

Code:

SELECT COUNT (CustomerID), Country
FROM Customers
GROUP BY Country;

Output:

Example:

Count how many users we have.

Code:

SQL:

SELECT
COUNT(id) as total
FROM
auth_user;

Python:

from django.db.models import Count
queryset = (User.objects
.aggregate(
total=Count('id'),
)
)

Output:

Implementing the Process GROUP BY

When we use ‘aggregate’, the aggregate function is applied throughout the table (on the entire table). Eventhough this process makes work simple by applying applying the function on the entire table, the usual way is to apply ‘aggregation’ only on groups of rows.

Active users counting using GROUP BY:

Code:

SQL:

SELECT
is_active,
COUNT(id) AS total
FROM
auth_user
GROUP BY
is_active

Python:

queryset = (User.objects
.values(
'is_active',
)
.annotate(
total=Count('id'),
)
.order_by()
)

Output:

***A combination of ‘VALUES’ & ‘ANNOTATE’ should be used to produce a GROUP BY.

If we fail to call VALUES before annotate, then the aggregate results will not be produced. So, the ORDER is one of the most important things to keep in mind while doing GROUP BY function.

Using Filter in a Query Set:

When a particular or a precise column or row need to be counted, we should use ‘filter’. In the process of applying aggregation in a filtered query, we can use ‘filter’ anywhere in the query set.

Code:

SQL:

SELECT
is_active,
COUNT(id) AS total
FROM
auth_user
WHERE
is_staff = True
GROUP BY
is_active

Python:

queryset = (User.objects
.values(
'is_active',
)
.filter(
is_staff=True,
)
.annotate(
total=Count('id'),
)
)

Similar to filter, ‘order_by’ anywhere in the query to SORT a query set. and for our convenience, we can use both ‘ GROUP BY ‘ and the ‘aggregate’ field.

Code:

SQL:

SELECT
is_active,
COUNT(id) AS total
FROM
auth_user
WHERE
is_staff = True
GROUP BY
is_active
ORDER BY
is_active,
total

Python:

queryset = (User.objects
.values(
'is_active',
)
.filter(
is_staff=True,
)
.annotate(
total=Count('id'),
)
.order_by(
'is_staff',
'total',
)
)

Output:

Conditional Aggregation in GROUP BY

To aggregate a part of the group, we should use Conditional Aggregation.

Example:

To count the number of staff and non-staff users by the year they signed-upCode.

Code:

SELECT
EXTRACT(‘year’ FROM date_jointed),
COUNT(id) FILTER (
WHERE is_employee = True
) AS employee_users,
COUNT(id) FILTER (
WHERE is_employee = False
) AS non_employee_users
FROM
authentic_user
GROUP BY
EXTRACT(‘year’ FROM date_joined)
From Django.db.models import F, Q
(User.objects
.values(‘date_joined__year’)
.annotate(
employee_users=(
Count(‘id’, filter=Q(is_employee=True))
),
non_employee_users=(
Count(‘id’, filter=Q(is_employee=False))
),
))

Having Clause

In SQL WHERE keyword and the aggregate function should not be used together. Instead, the HAVING clause is added to the SQL.

Syntax:

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
HAVING condition
ORDER BY column_name(s);

Usage of Having GROUP BY

To filter out the required data from the result of an aggregate function, the HAVING clause is used.

Sample Case:

Code:

SELECT Employees.LastName, COUNT(Orders.OrderID) AS NumberOfOrders
FROM (Orders
INNER JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID)
GROUP BY LastName
HAVING COUNT(Orders.OrderID) > 10;

Output:

GROUP BY – Distinct:

In a COUNT function, sometimes it would be desirable to only count the DISTINCT OCCURRENCES.

Sample:

To count the number of different last names being there per user active status.

Introduction to Django on_delete

The following article provides an outline for Django on_delete. One of the major advantage of Django is its capability to make changes to the databases. The backend of Django framework-based applications can be very flexibly handled, all processes like database addition, deletion, or even updates can be very flexibly performed by means of Django models. The changes in the databases can also be integrated with the models in an easy and simple manner. The on delete is one among the parameters to have control of this flexibility that Django offers. This is among the parameters which are placed when a relationship is established in Django, this means the on delete function allows to flexibly operate on foreign keys.

So whenever foreign key-like concepts come into place these on delete arguments are expected to be declared as one among the parameters used in the foreign keys. These ondelete arguments decide whether a deletion must happen or what needs to be followed when the referenced object or parent value is deleted. This means when a referenced foreignkey value is deleted what needs to be the impact on the table which refers to the primary key is the context mentioned in Django delete argument. Options like this offer a great extent of flexibility to database-oriented operations.

Syntax of Django on_delete

Given below is the syntax of Django on_delete:

Field Name = models.ForeignKey(WASD, on_delete = OPERATION TYPE)

• The left most value here represents the field which is going to be created in reference, this means the field which will be used to reference this operation on the background, so the field which is used to be the referential field or the field which will be acting to pull data from the parent field needs to be mentioned here. This will be the field which will be referenced further thought the framework. In database terms, the field which is given on the left end will act as the field inheriting the value of the foreignkey field.
• Next the models.Foreignkey is the function that mentions that this operation is a foreign key creation operation. This function call is a mandatory item to use. It mentions that a foreign key is expected to be created further in this section. The syntax means that the from the models program the foreign key function is called and used. Next to these function names the arguments have to be placed. From a Django perspective this function call is a predefined function call. Lets discuss on the arguments used further.
• After the models.Foreignkey function call the arguments of the function needs to be mentioned. This is where the on_delete method comes into play. First the WASD argument represents the foreign key which is expected to be inherited, next the on_delete function will be used. The on_delete function will be equaling it to the various options associated to it.

on_delete Options

The various options for the on_delete arguments are given below:

1. CASCADE

When the on_delete argument is set to cascade then deleting the referenced object will have substantial effect on the referred objects. This means when the referenced object is deleted from the database then all the entries of the object will also be deleted from the entire database. This is how the CASCADE option works in the background. So, there are some impacts on data integrity as far as the CASCADE options is concerned.

2. PROTECT

PROTECT is the direct opposite of cascade option, here if there is impact on the actual object then all instances of the data on the referenced object are not deleted. So, no deletion happens. This makes the data to be protected before delete processing on the referenced object.

3. RESTRICT

The RESTRICT is very similar to the PROTECT option, it does the same job just as like the deletion option. The only difference here is when deletion is targeted on the referenced object then the ON_DELETE will raise an error called the RestrictedError. But the RESTRICT will allow deletion to happen when the referencing object and the object which is referenced object is allotted with a reference to a different common object then the deletion is allowed to takes place.

4. SET_NULL

The option functions in the same way the name suggests, when a deletion happens to the referenced object then the value of the referencing object will be updated as NULL. So a NULL value will be placed for the referencing object. This is how the SET NULL will operate basically.

5. SET_DEFAULT

The option functions in the same way the name suggests, when a deletion happens to the referenced object then the value of the referencing object will be updated with a default value which it is allotted for, so all instances of the referencing object will be allotted with this default value. So a default value will be placed for the referencing object. This is how the SET DEFAULT will operate basically.

Create a Django on_delete Argument

Given below shows the creation of Django on_delete Argument:

Changes in Models.py file: The changes which are applied to the models.py file are depicted below; these changes will be reflected in the front end of the form used.

Here two different ondelete arguments are used, the RESTRICT and CASCADE options.

Example:

(models.py)

Code:

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
models.CharField(max_length=200,null=True)
…..
Example_Post_Graduation_college = models.CharField(max_length=400,null=True)
Example_Rasi = models.CharField(max_length=200,null=True)
Example_Nakshatra = models.ForeignKey(User, null=True, on_delete=models.RESTRICT)
Example_Creator = models.ForeignKey(User, null=True, on_delete=models.CASCADE)
def __str__(self):
return self.name

Output:

Explanation:

• We can notice when a deletion is called on the creator for the record karthi, it does not imply to the record being placed on the user table because of the RESTRICT parameter used.

Conclusion

This article mentions on how flexibly options like on_delete can be used to flexibly delete a record and to control the impact of the deletion to the referenced records involved. This is among the key advantages of the database operations associated to the Django applications.

Introduction to Django Pagination

The pagination is used for setting the pages and display them. It helps to set the number of pages. django.core.paginator is used for declaring a paginator. The pagination helps to set the page details and the total number of pages used. So the process of pagination can be used. The pagination allows to declare the pages associated and the pages associated to it. Django’s capability to produce inbuilt pagination packages is a key advantage of designing the pages in Django setup. Pagination is among the effective ways to declare the items. The import code change section for pagination process is on the All-users section.

Syntax:

Table_object = Table_name.objects.all()
Paginator_object = Paginator(Table_object, page_number)
Page_object = paginator.page(paginator_object)

How does Pagination work?

• Retrieve the objects to be displayed into a variable. So all the objects will get retrieved into the assigned variable.
• Declare a paginator object and set the number of pages and the objects to be displayed in the object declaration.
• Assign the page details to a render variable and pass the render variable to the HTML template. This will have the page displayed in the web address. The retrieval of the object and set up the variable.

Examples of Django Pagination

Following are the examples of django pagination are:

1. (Forms.py)

The forms files will have all the fields to be declared. These fields associated to the forms.py file will have all the fields which needs to be a part of the table declaration. A column-like these will be responsible for display.

from django import forms
from. models import Bride
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
# Create your forms here.
Rasi_CHOICES =(
("1", "Mesham"),
("2", "Rishabam"),
("3", "Mithunam"),
("4", "Kadakam"),
("5", "Simmam"),
("6", "Kanni"),
("7", "Thulam"),
("8", "Viruchikam"),
("9", "Thanusu"),
("10", "Makaram"),
("10", "Kumbam"),
("10", "Meenam"),
)
State_Choices = (
("1", "Mesham"),
("1", "Mesham"))
class Valueform(forms.ModelForm):
Rasi = forms.ChoiceField(choices = Rasi_CHOICES)
class Meta:
model = Bride
fields = "__all__"
class NewUserForm(UserCreationForm):
email = forms.EmailField(required=True,error_messages={'required': 'Please enter your name'})
def clean(self):
cleaned_data = super(NewUserForm, self).clean()
email_passed = cleaned_data.get("email")
if not "gmail.com" in email_passed:
print("came here")
raise forms.ValidationError("Sorry, the email submitted is invalid. All emails have to be registered on this domain only.")
return email_passed
class Meta:
model = User
fields = ("username", "email", "password1", "password2")
def save(self, commit=True):
user = super(NewUserForm, self).save(commit=False)
user.email = self.cleaned_data['email'] if commit:
user.save()
return user

2. (models.py)

The Models files will have all the fields to be declared. These fields associated to the models.py file will have all the fields which needs to be a part of the table declaration. The column like these will be responsible for display.

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
Django_Paginators_Example_name = models.CharField(max_length=200,null=True)
Django_Paginators_Example_thegai = models.CharField(max_length=200,null=True)
Django_Paginators_Example_State =  models.CharField(max_length=50,null=True)
Django_Paginators_Example_District = models.CharField(max_length=50,null=True)
Django_Paginators_Example_Address = models.TextField(null=True)
Django_Paginators_Example_Phone = models.BigInteger_Example_Field(null=True)
Django_Paginators_Example_profession = models.CharField(max_length=200,null=True)
Django_Paginators_Example_salary = models.BigInteger_Example_Field(null=True)
Django_Paginators_Example_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
Django_Paginators_Example_Under_Graduation_college = models.CharField(max_length=400,null=True)
Django_Paginators_Example_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
Django_Paginators_Example_Post_Graduation_college = models.CharField(max_length=400,null=True)
Django_Paginators_Example_Rasi = models.CharField(max_length=200,null=True)
Django_Paginators_Example_Nakshatra = models.CharField(max_length=200,null=True)
def __str__(self):
return self.name

3. Views.py

The import code change section for pagination process is on the All-users section. Here the contents of the table for which the objects or elements are expected to be displayed are retrieved into an object. So, all the object entries will be retrieved. Then the paginator object is created. The paginator object defines the page being used. so, a page object will be created. The page object will be associated with the table objects and the number of pages to be associated. So, the total number of pages and the table details will be declared in the paginator class. This is a very important section of the pagination process.

def All_users(request):
User_entries =  User.objects.all()
page = request.GET.get('page', 1)
paginator = Paginator(User_entries, 5)
users = paginator.page(page)
print(" Has other pages : ",users.has_other_pages())
print(" Has next page : ",users.has_next())
print(" Has previous page : ",users.has_previous())
print(" Has previous page : ",users.has_previous())
print(" Start Index : ",users.start_index())
print(" End Index : ",users.end_index())
if users.has_next():
print(" Next page Number: ",users.next_page_number())
elif users.has_previous():
print(" Has Previous page Number: ",users.previous_page_number())
print(paginator,users)
return render(request,"All_users.html",{'users':users})

4. HTML

The below are the HTML changes for pagination, the process involves declaring a table structure with username and email from the reference table. Next, the section of code for setting the pages as a movable object is listed. Here the second section allows flexible movement between the pages. The first section mentions the content of the pages.

<html style="font-size: 16px;">
<head>
<title>Home</title>
{% load static %}
<link rel="stylesheet" href="{% static 'admin/css/Formpage.css' %}" media="screen">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1" . . .  />
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css" integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
<!-- - -  Script -- - - >
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
</head>
<body class="body">
<nav class='navbar'>
<div class='navbar_div'>
<a class="navbar" onclick="redirect2()" >Home! </a>
<a class="navbar" onclick="redirect2()" >Contact</a>
</div>
</nav>
<table class="table table-bordered">
<thead>
<tr>
<th>Username</th>
<th>Email</th>
</tr>
</thead>
<tbody>
{% for user in users %}
<tr>
<td>{{ user.username }}</td>
<td>{{ user.email }}</td>
</tr>
{% endfor %}
</tbody>
</table>
<body>
<script>
function readURL(input) {
if (input.files && input.files[0]) {
var reader = new FileReader();
reader.onload = function (e)
{
var image = document.getElementById('image');
image.src = URL.createObjectURL(input.files[0]);
}
reader.readAsDataURL(input.files[0]);
var download = document.getElementById('download');
download.src = URL.createObjectURL(input.files[0]);
download.setAttribute("download", 'sample.img');
download.click();
}
}
<script>
{% if users.has_other_pages %}
<ul class="pagination">
{% if users.has_previous %}
<li><a href="?page={{ users.previous_page_number }}">&laquo;</a></li>
{% else %}
<li class="disabled"><span>&laquo;</span></li>
{% endif %}
{% for i in users.paginator.page_range %}
{% if users.number == i %}
<li class="active"><span>{{ i }} <span class="sr-only">(current)</span></span></li>
{% else %}
<li><a href="?page={{ i }}">{{ i }}</a></li>
{% endif %}
{% endfor %}
{% if users.has_next %}
<li><a href="?page={{ users.next_page_number }}">&raquo;</a></li>
{% else %}
<li class="disabled"><span>&raquo;</span></li>
{% endif %}
</ul>
{% endif %}
<script>
function form1() {
window.location.href = "http://127.0.0.1:8000/form";
}
function redirect1() {
window.location.href = "http://127.0.0.1:8000/Mainpage";
}
function redirect2() {
window.location.href = "http://127.0.0.1:8000/";
}
</script>
<script src="https://code.jquery.com/jquery-3.4.1.slim.min.js" integrity="sha384-J6qa4849blE2+poT4WnyKhv5vZF5SrPo0iEjwBvKU7imGFAV0wwj1yYfoRSJoZ+n" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/dist/umd/popper.min.js" integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo" crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js" integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6" crossorigin="anonymous"></script>
</body>
</html>

Output:

Conclusion

So, pagination is a process well allocated in Django. The pagination process of Django helps in the smooth declaration of pages in the Django setup. This helps to set and access pages in a very flexible manner. This is among a key advantages of Django process.

Introduction to Django DateTimeField

As per Django is concerned there are several field types through which the date and time values can be injected for storage on the models. The difference between these fields arises on the format of the data being stored. There are options to store only date value, even time value alone can be capture. As per datetime field both date and time values will be captured. The user will be expected to place both the date and time value at the time of injecting the values for the storage. The stored value can again be retrieved back and displayed on to the console.

Ex: 10-07-2019 00:20

Syntax:

Name_of_field = models.DateTimeField(**options)

The above syntax corresponds to the Django DateTimeField example. The first column mentioned here is the name of the field involved. The first column will form the field name, next to it comes the models.DateTimeField extension. This extension means to export the DateTime field method from the model’s section. So the model’s section will now import the DateTimeField method to generate the expected field. Then the arguments of the DateTimeField() method has to be declared. The usual values here are the null argument which mentions what needs to be the value for the records in which the valid date-time is not in place. The next argument will be the blank argument.

Create a Django DateTimeField

1. Changes in Models.py file:

As mentioned in the syntax section the Date Time field needs to be declared in the models.py file. We can notice that the Date Time field is declared as the age field in the model.

(models.py)

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
DATE_TIME_name = models.CharField(max_length=200,null=True)
DATE_TIME_age = models.Date Time field_Example_Field(null=True)
DATE_TIME_DOB = models. DateTimeField (null=True)
DATE_TIME_thegai = models.CharField(max_length=200,null=True)
DATE_TIME_State = models.CharField(max_length=50,null=True)
DATE_TIME_District = models.CharField(max_length=50,null=True)
DATE_TIME_Address = models.TextField(null=True)
DATE_TIME_Phone = models.BigInteger(null=True)
DATE_TIME_profession = models.CharField(max_length=200,null=True)
DATE_TIME_salary = models.BigInteger(null=True)
DATE_TIME_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
DATE_TIME_Under_Graduation_college = models.CharField(max_length=400,null=True)
DATE_TIME_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
DATE_TIME_Post_Graduation_college = models.CharField(max_length=400,null=True)
DATE_TIME_Rasi = models.CharField(max_length=200,null=True)
DATE_TIME_Nakshatra = models.CharField(max_length=200,null=True)
def __str__(self):
return self.name

2. Changes in Settings.py file:

Ensure all of the values and the database connects are set nicely withinside the settings.py document in order that the venture may be kicked for execution flexibly. The middleware objects stated underneath needs to be declared nicely withinside the settings.py document, due to the fact those center wares are liable for functioning of the software even as processing GET and PUT messages. Additionally, the templates used has additionally want to crammed in order that the template processing occurs withinside the background.

(Settings.py):

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
] ROOT_URLCONF = 'Matrimony.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [Template_DIR,],
'APP_DIRS': True,
'OPTIONS': {
'render_dict_processors': [
'django.template.render_dict_processors.debug',
'django.template.render_dict_processors.request',
'django.contrib.auth.render_dict_processors.auth',
'django.contrib.messages.render_dict_processors.messages',
],
},
},
]

3. Changes in url.py file:

The Media root and document root variable need to be instantiated inside the url.py file as like below. The changes for the url.py file are mentioned below.

url.py:

from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from matrimony_pages import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
url(r'^$',views.Welcome_page,name='Welcome_page'),
url(r'Mainpage/',views.Main_page,name='Main_page'),
url(r'form/',views.form_view,name='form_view'),
url(r"signup/", views.Sign_up_request, name="register"),
url(r"login/", views.login_request, name="login"),
path(r'profile/<str:pk>/',views.DATE_TIME_page,name='profile'),
url(r'logout/',views.logout_request,name='logout'),
url(r'reg/',views.DATE_TIME_reg_user,name='reg'),
path(r'update/<str:pk>/',views.form_update,name='update'),
path('admin/', admin.site.urls),
]+ static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)

4. Create a view for the form:

The Date Time field value when submitted has to be stored and when retrieved it has to be pulled from the database. This can be achieved by means of the object created for the model. The process of doing this is explained in the below given views.py section.

Ex: views.py

@login_required
def DATE_TIME_page(request,pk):
render_dict2 = {}
Key_details = Bride.objects.get(id=pk)
DATE_TIME_name = Key_details.name
DATE_TIME_Age = Key_details.age
DATE_TIME_DOB = Key_details.DOB
DATE_TIME_Thegai = Key_details.thegai
DATE_TIME_state = Key_details.State
DATE_TIME_district = Key_details.District
DATE_TIME_Address = Key_details.Address
DATE_TIME_Phone = Key_details.Phone
DATE_TIME_Profession = Key_details.profession
DATE_TIME_Salary = Key_details.salary
DATE_TIME_UG = Key_details.Under_Graduation_Degree
DATE_TIME_UGC = Key_details.Under_Graduation_college
DATE_TIME_PG = Key_details.Post_Graduation_Degree
DATE_TIME_PGC = Key_details.Post_Graduation_college
DATE_TIME_UG = Key_details.Under_Graduation_Degree
DATE_TIME_UGC = Key_details.Under_Graduation_college
DATE_TIME_PG = Key_details.Post_Graduation_Degree
DATE_TIME_PGC = Key_details.Post_Graduation_college
DATE_TIME_Rasi = Key_details.Rasi
DATE_TIME_Nakshatra = Key_details.Nakshatra
render_dict2['Age'] = DATE_TIME_Age
render_dict2['DOB'] = DATE_TIME_DOB
render_dict2['name'] = DATE_TIME_name
render_dict2['thegai'] = DATE_TIME_Thegai
render_dict2['State'] = DATE_TIME_state
render_dict2['district'] = DATE_TIME_district
render_dict2['Address'] = DATE_TIME_Address
render_dict2['Phone'] = DATE_TIME_Phone
render_dict2['profession'] = DATE_TIME_Profession
render_dict2['Under_Graduation_Degree'] = DATE_TIME_UG
render_dict2['Under_Graduation_college'] = DATE_TIME_UGC
render_dict2['Post_Graduation_Degree'] = DATE_TIME_PG
render_dict2['Post_Graduation_college'] = DATE_TIME_PGC
render_dict2['Rasi'] = DATE_TIME_Rasi
render_dict2['Nakshatra'] = DATE_TIME_Nakshatra
print(Key_details.Creator)
print(render_dict2)
return render(request,'Profilepage.html',render_dict2)

4) Formulate an HTML file for displaying the form: Corresponding changes to the HTML pages has to be performed.

Profilepage.html

<!DOCTYPE html>
<html style="font-size: 16px;">
<head>
<title>Profile</title>
{% load static %}
<link rel="stylesheet" href="{% static 'admin/css/Formpage.css' %}" media="screen">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1" />
<!-- Script -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
</head>
<body class="body">
<nav class='navbar'>
<div class='navbar_div'>
<a class="navbar" onclick="redirect2()" >Home </a>
<a class="navbar" onclick="redirect2()" >Contact</a>
<a class="navbar" onclick="redirect1()" >Profiles</a>
</div>
</nav>
<div class="formarea">
<br>
{% block content %}
{% if Date Time field %}
<img src="{{Date Time field.url}}" align="right" alt="Date Time field" class="img-thumbnail" style="max-height:200px">
{% else %}
<img src="{% static 'admin/img/default.png' %}" align="right" alt="Date Time field" class="img-thumbnail" style="max-height:200px">
{% endif%}
<br></br>
<h6><strong>Name : &nbsp&nbsp {{name}}</strong></h6>
<h6><strong>Age : &nbsp&nbsp {{Age}}</strong></h6>
<h6><strong>DOB : &nbsp&nbsp {{DOB}}</strong></h6>
<h6><strong>Thegai : &nbsp&nbsp {{thegai}}</strong></h6>
<h6><strong>State : &nbsp&nbsp {{State}}</strong></h6>
<h6><strong>district : &nbsp&nbsp {{district}}</strong></h6>
<h6><strong>Address : &nbsp&nbsp {{Address}}</strong></h6>
<h6><strong>Phone : &nbsp&nbsp {{Phone}}</strong></h6>
<h6><strong>profession : &nbsp&nbsp {{profession}}</strong></h6>
<h6><strong>Under Graduation Degree : &nbsp&nbsp {{Under_Graduation_Degree}}</strong></h6>
<h6><strong>Post_Graduation_Degree : &nbsp&nbsp {{Post_Graduation_Degree}}</strong></h6>
<h6><strong>Post_Graduation_college : &nbsp&nbsp {{Post_Graduation_college}}</strong></h6>
<h6><strong>Rasi : &nbsp&nbsp {{Rasi}}</strong></h6>
<h6><strong>Nakshatra : &nbsp&nbsp {{Nakshatra}}</strong></h6>
{% endblock content %}
</div>
<script>
function form1() {
window.location.href = "http://127.0.0.1:8000/form";
}
function redirect1() {
window.location.href = "http://127.0.0.1:8000/Mainpage";
}
function redirect2() {
window.location.href = "http://127.0.0.1:8000/";
}
function redirect3() {
window.location.href = "http://127.0.0.1:8000/profile";
}
</script>
</body>
</html>

Output:

Conclusion

The above article displays the various details corresponding to the DateTimeField capability. The description of how the Datetimefield can be used, what type of values can be stored, the actual syntax of the field and a live example of picking and storing the value is also discussed. The snap of the output from the created example is also shared for reference.

Introduction to Django OneToOneField

The Onetoonefield relationship will happen when there is a real necessity to connect two tables in a tightly coupled manner. So, for every record in the first table, there will be a corresponding record in the second table. Scenarios like these will invite a one-to-one relationship. Especially a common scenario of depicting one to one relationship is when the current table columns are too high and a large amount of columns could impact the retrieving speed of the records from the table then the table can be preferably split and made into two different tables and connectivity will be maintained between both the tables. This kind of split is called onetoone split from a table level. So here both tables will be closely coupled to one specific column. Basically, onetoonefield relationships are not very preferable.

Syntax:

OnetoOneField_name = models.OneToOneField(Table_name, null_argument, Ondelete_arguemnt)

Table call may be declared because of the first argument. So, the primary argument withinside the onetoonefield subject syntax may be similar to desk call. This desk call referred to withinside the first argument of the onetoonefield instance may be representing the desk from which the values may be inherited for the declared subject. So this could be the fee subject from which the OnetoOneField key fee is pulled over from may be related here. so being the primary argument of the technique statement and furthermore one a number of the prioritized argument used it performs a prime role. Next, the null argument is used to mention the fee null to be associated with the statistics coming in addition or already present withinside the desk. Mentioning this record as null allows the records already withinside the lower back of or new records delivered to be complete of Null rate at the same time as no rate is cited for it.

The ondelete argument has to be declared next, this is a very critical argument because this argument decides the impact between the parent table and the staging table at the instance of deletion. This means the removal of a parent table record will have a sustainable impact or no impact based on the value mentioned here. When a parent table records are removed those records will be deleted or held back from deletion based on the value associated here to this field. So the ondelete argument is also another very critical value or argument in the table.

Create a DJANGO OnetoOneField:

1) Changes in Models.py file:

First, the declaration for the onetoone Field has to be declared in the models.py file. Here the onetoonefild creator is declared to be the field that holds the onetoone relationship. This onetoone relationship exists because its field is pulled in from a different table, additionally, properties like associating the null value as True and the ondelete function is made with CASCADE.

Ex: (models.py)

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
OnetoOneField_name = models.CharField(max_length=200,null=True)
OnetoOneField_age = models.IntegerField(null=True)
OnetoOneField_thegai = models.CharField(max_length=200,null=True)
OnetoOneField_State = models.CharField(max_length=50,null=True)
OnetoOneField_District = models.CharField(max_length=50,null=True)
OnetoOneField_Address = models.TextField(null=True)
OnetoOneField_Phone = models.BigIntegerField(null=True)
OnetoOneField_profession = models.CharField(max_length=200,null=True)
OnetoOneField_salary = models.BigIntegerField(null=True)
OnetoOneField_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
OnetoOneField_Under_Graduation_college = models.CharField(max_length=400,null=True)
OnetoOneField_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
OnetoOneField_Post_Graduation_college = models.CharField(max_length=400,null=True)
OnetoOneField_Rasi = models.CharField(max_length=200,null=True)
OnetoOneField_Nakshatra = models.CharField(max_length=200,null=True)
OnetoOneField_Creator = models.OneToOneField(User, null=True, on_delete=models.CASCADE)
def __str__(self):
return self.name

2) Changes in Forms.py file:

Form level integration is performed on the forms.py file. The connectivity between the form declared and the model declared is created here. So this connectivity will associate each and every field in the form to be pleasantly connected with all the fields in the model declared. This brings in an interconnection established between the form declared and the models used.

Ex: (forms.py)

from django import forms
from .models import Bride
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
class Valueform(forms.ModelForm):
# Rasi = forms.ChoiceField(choices = Rasi_CHOICES)
class Meta:
model = Bride
fields = "__all__"

3) Create a view for the form:

A Django view wants to be shaped to make the middleware for the shape via the OnetoOneField key Field registered in it to be rendered. Clicking the publish button will store the shape. The rendering characteristic is the primary imported object withinside the Django library. This import method will permit the HTML report to be rendered to the browser that is presented. After this uploading, the HTTP reaction might be achieved. In the perspectives technique, the predicted cost Form is instantiated which fatherly lets in the shape to be flexibly rendered. The instantiation might be achieved on a cost named as shape. The store method will take the region with the shape. Save() technique. Then the cutting-edge logged-in-person info might be fetched and saved onto the shape. This is how the shape garage will take region. After the shape is efficaciously saved it’ll be rendered directly to the browser with a rendering technique.

Ex: views.py

def form_view(request):
form = Valueform(request.POST or None)
if form.is_valid():
post = form.save()
post.Creator = request.user
print('Creator user stored',request.user)
post.save()
return render(request,'form.html', {"form": form})
def form_edit(request):
form = Valueform(request.POST or None)
if form.is_valid():
post = form.save()
post.Creator = request.user
print('Creator user updated',request.user)
post.save()
return render(request,'form_edit.html', {"form": form}
def form_update(request):
form = Valueform(request.POST or None)
if form.is_valid():
post = form.save()
post.Creator = request.user
print('Creator user updated',request.user)
post.save()
return render(request,'form_edit.html', {"form": form}

4) Formulate an HTML file for displaying the form: Corresponding changes to the HTML pages has to be performed.

Form.html

{% block content %}
<form method="POST" class='formarea'>
<div class='formdiv'>
{{ form.as_p }}
{% csrf_token %}
<input type="submit" class='button' value="submit">
</div>
</form>
{% endblock content %}

Output:

Conclusion

This article depicts how the OnetoOneField key may be flexibly declared in a Dango setup and the adjustments may be rendered to a shape object and the way the enter values may be surpassed from there on. There isn’t any restriction on the variety of OnetoOneField key connections created in an application. Moreover, the structure of a Django setup lets in to preserve those fields very sophisticatedly with no huge adjustments implemented withinside the database. This is the principal gain of Django setup.

Introduction of Django Get_or_Create Field

Sometimes there may be scenarios where the object or the value is not passed default. So in these instances, when the value is not passed from the user or upstream, there will be a need to get the value from the source; in case at the instance when the value is not derived from the source, then the value may need to be created. So, in these instances, when the value is expected to be retrieved, the get or create will be used. The get or create method will create the given values when a get does not return any value.

Syntax:

Object_Name = model_name.objects.Get_or_CreateField(values)

The object to be created is placed as the leftmost item. So the leftmost item will be the object. Then the model for which the object needs to be triggered on get or create is placed. The values for the get or create has to be associated in the arguments area. The methods like get or create provide a lot of flexibility in declaring the object and instantiating the value for the object. These are among the advantages of the GetorCreate function.

How Do Get_or_Create Field Works in Django?

The way through which we get or create works is exciting. The get or create involves a get call. The get process will be triggered based on this value. When the initial get() returns the expected value, a tuple will be returned with a Boolean value as false. Multipleobjects returned error will be raised when the call retunes more than one object. When the case of the object not found is raised, then the get_or_create will instantiate a save new object process, returning a tuple and a Boolean value of True. So the new value will be stored as expected, and the get or create will be instantiated.

Create a Django Get_Or_Create Field

Creating a Django Get_Or_Create Field is explained below:

1. Changes in Models.py file

As the syntax section mentions, the Get_or_Create field must be declared in the models.py file. We can notice that the Get_or_Create field is declared as the age field in the model.

(models.py)

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
Get_or_create_Example__Example_name = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_age = models.Get_or_create_Example_Field(null=True)
Get_or_create_Example__Example_thegai = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_State =  models.CharField(max_length=50,null=True)
Get_or_create_Example__Example_District = models.CharField(max_length=50,null=True)
Get_or_create_Example__Example_Address = models.TextField(null=True)
Get_or_create_Example__Example_Phone = models.BigGet_or_create_Example_Field(null=True)
Get_or_create_Example__Example_profession = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_salary = models.BigGet_or_create_Example_Field(null=True)
Get_or_create_Example__Example_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_Under_Graduation_college = models.CharField(max_length=400,null=True)
Get_or_create_Example__Example_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_Post_Graduation_college = models.CharField(max_length=400,null=True)
Get_or_create_Example__Example_Rasi = models.CharField(max_length=200,null=True)
Get_or_create_Example__Example_Nakshatra = models.CharField(max_length=200,null=True)
def __str__(self):
return self.name

2. Changes in Settings.py file

Ensure all of the values and the database connects are set nicely within the settings.py record so the undertaking may be kicked for execution flexibly. The middleware objects stated under must be declared well within the settings.py record because those center wares are chargeable for the functioning of the software at the same time as processing GET and PUT messages. Additionally, the templates used want to cram so that the template processing takes place within the background.

(Settings.py):

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'Matrimony.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [Template_DIR,],
'APP_DIRS': True,
'OPTIONS': {
'render_dict_processors': [
'django.template.render_dict_processors.debug',
'django.template.render_dict_processors.request',
'django.contrib.auth.render_dict_processors.auth',
'django.contrib.messages.render_dict_processors.messages',
],
},
},
]

3. Changes in url.py file

The Media root and document root variables must be instantiated inside the url.py file like below. The changes for the url.py file are mentioned below.

url.py:

from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from matrimony_pages import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
url(r'^$',views.Welcome_page,name='Welcome_page'),
url(r'Mainpage/',views.Main_page,name='Main_page'),
url(r'form/',views.form_view,name='form_view'),
url(r"signup/", views.Sign_up_request, name="register"),
url(r"login/", views.login_request, name="login"),
path(r'profile/<str:pk>/',views.Get_or_create_Example_page,name='profile'),
url(r'logout/',views.logout_request,name='logout'),
url(r'reg/',views.Get_or_create_Example_reg_user,name='reg'),
path(r'update/<str:pk>/',views.form_update,name='update'),
path('admin/', admin.site.urls),
]+ static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)

3. Create a view for the form

The Get_or_Create fee, while submitted, must be saved, and while retrieved, it must be pulled from the database. This may be executed through the item created for the model. The manner of doing that is defined withinside the given views.py section.

Ex: views.py

@login_required
def Get_or_create_Example_page(request,pk):
dict_to_render = {}
Get_or_create_key_variable_ = Bride.objects.get(id=pk)
Get_or_create_Example_name =  Get_or_create_key_variable_.name
Get_or_create_Example_Age =  Bride.objects.get_or_create(first_name='Nalandan', last_name='Ranjan',defaults={'birthday': date(1990, 10, 9)})
Get_or_create_Example_Thegai =  Get_or_create_key_variable_.thegai
Get_or_create_Example_state =  Get_or_create_key_variable_.State
Get_or_create_Example_district =  Get_or_create_key_variable_.District
Get_or_create_Example_Address =  Get_or_create_key_variable_.Address
Get_or_create_Example_Phone =  Get_or_create_key_variable_.Phone
Get_or_create_Example_Profession =  Get_or_create_key_variable_.profession
Get_or_create_Example_Salary =  Get_or_create_key_variable_.salary
Get_or_create_Example_UG =  Get_or_create_key_variable_.Under_Graduation_Degree
Get_or_create_Example_UGC =  Get_or_create_key_variable_.Under_Graduation_college
Get_or_create_Example_PG =  Get_or_create_key_variable_.Post_Graduation_Degree
Get_or_create_Example_PGC =  Get_or_create_key_variable_.Post_Graduation_college
Get_or_create_Example_UG =  Get_or_create_key_variable_.Under_Graduation_Degree
Get_or_create_Example_UGC =  Get_or_create_key_variable_.Under_Graduation_college
Get_or_create_Example_PG =  Get_or_create_key_variable_.Post_Graduation_Degree
Get_or_create_Example_PGC =  Get_or_create_key_variable_.Post_Graduation_college
Get_or_create_Example_Rasi =  Get_or_create_key_variable_.Rasi
Get_or_create_Example_Nakshatra =  Get_or_create_key_variable_.Nakshatra
dict_to_render['Age'] = Get_or_create_Example_Age
dict_to_render['name'] = Get_or_create_Example_name
dict_to_render['thegai'] = Get_or_create_Example_Thegai
dict_to_render['State'] = Get_or_create_Example_state
dict_to_render['district'] = Get_or_create_Example_district
dict_to_render['Address'] = Get_or_create_Example_Address
dict_to_render['Phone'] = Get_or_create_Example_Phone
dict_to_render['profession'] = Get_or_create_Example_Profession
dict_to_render['Under_Graduation_Degree'] = Get_or_create_Example_UG
dict_to_render['Under_Graduation_college'] = Get_or_create_Example_UGC
dict_to_render['Post_Graduation_Degree'] = Get_or_create_Example_PG
dict_to_render['Post_Graduation_college'] = Get_or_create_Example_PGC
dict_to_render['Rasi'] = Get_or_create_Example_Rasi
dict_to_render['Nakshatra'] = Get_or_create_Example_Nakshatra
print(Get_or_create_key_variable_.Creator)
print(dict_to_render)
return  render(request,'Profilepage.html',dict_to_render)

4. Formulate an HTML file for displaying the form

Corresponding changes to the HTML pages have to be performed.

Profilepage.html

<!DOCTYPE html>
<html style="font-size: 16px;">
<head>
<title>Profile</title>
</head>
<body class="body">
<nav class='navbar'>
<div class='navbar_div'>
<a class="navbar" onclick="redirect2()" >Home </a>
<a class="navbar" onclick="redirect2()" >Contact</a>
<a class="navbar" onclick="redirect1()" >Profiles</a>
</div>
</nav>
<div class="formarea">
<br>
{% block content %}
{% if Get_or_Create %}
<img src="{{Get_or_Create.url}}"  align="right" alt="Get_or_Create" class="img-thumbnail" style="max-height:200px">
{% else %}
<img src="{% static 'admin/img/default.png' %}" align="right" alt="Get_or_Create" class="img-thumbnail" style="max-height:200px">
{% endif%}
<br></br>
<h6><strong>Name :  &nbsp&nbsp {{name}}</strong></h6>
<h6><strong>Age  :  &nbsp&nbsp {{Age}}</strong></h6>
<h6><strong>Thegai : &nbsp&nbsp {{thegai}}</strong></h6>
<h6><strong>State :  &nbsp&nbsp   {{State}}</strong></h6>
<h6><strong>district  : &nbsp&nbsp {{district}}</strong></h6>
<h6><strong>Address : &nbsp&nbsp {{Address}}</strong></h6>
<h6><strong>Phone :  &nbsp&nbsp {{Phone}}</strong></h6>
<h6><strong>profession  : &nbsp&nbsp {{profession}}</strong></h6>
<h6><strong>Under Graduation Degree : &nbsp&nbsp {{Under_Graduation_Degree}}</strong></h6>
<h6><strong>Post_Graduation_Degree : &nbsp&nbsp {{Post_Graduation_Degree}}</strong></h6>
<h6><strong>Post_Graduation_college : &nbsp&nbsp {{Post_Graduation_college}}</strong></h6>
<h6><strong>Rasi  : &nbsp&nbsp  {{Rasi}}</strong></h6>
<h6><strong>Nakshatra : &nbsp&nbsp {{Nakshatra}}</strong></h6>
{% endblock content %}
</div>
</script>
</body>
</html>

 Output:

Conclusion

The process of how the get or create is instantiated, and the values set for the get or create are declared nicely above. The syntax and the coding changes involved in the get or create method are discussed deeply in the above article with suitable references. All code is produced in a detailed manner.

Introduction to Django Templates

To understand and operate the process of Django applications these templates play a major role, all static items in a web page designed with Django hold the templates for constructing the static entities. In other words it could be described that the templates are responsible for building the skeleton of a webpage. These templates make a Django setup a MVT oriented architecture. Where M stands for the models involved, V stands for the views designed and T refers to the templates. On Standard ways the templates used in a python setup are rendered using a Django view.

Using Templates to Render Django Views

Given below are the templates to render Django views:

1. Create a template folder

All template related HTML code could be placed into this folder. The template folder has to be created under the primary project folder.

2. Tag the template folder in settings.py file

The settings.py file is used for tagging these templates to their associated views. When the tagging process is accomplished it allows all the HTML contents placed inside the folder to be falling under this template section.

Code:

import os
# Build paths inside the project like this: os.path.join(BASE_DIR,...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
Template_DIR = os.path.join(BASE_DIR,'Templates')
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [Template_DIR,],
'APP_DIRS': True,
'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',
,
},
},
]Template_DIR = os.path.join(BASE_DIR,'Templates')

For implementing the Django template’s API backend the python path in the BACKEND key is used. Some among the backends which are built in Django are django.template.backends.django.DjangoTemplates and django.template.backends.jinja2.Jinja2.

• The directory at which the template engine needs to locate the template related search files is placed in the DIRS directory.
• Whereas the APP_DIRS is helpful in mentioning the location at which the engine has to verify the templates within the installed applications. For every subdirectory inside the applications a conventional name is provided by each defined backend.

3. Place the HTML file inside the templates folder

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> Hello world from HTML page <h1>
</body>
</html>

Syntax:

render(request,template_name,context=None,content_type=None,status=None,using=None)

Example:

Code:

from django.shortcuts import render
from django.http import  HttpResponse
def index(request_iter):
return  render(request_iter,'design.html')

4. Tag the view in urls.py file

This is the process of creating a url for the view. The url mentioned here will be used for reaching the web page which is been mentioned.

• Import the library from django.conf.urls import url.
• declare a url entry in the urlpatterns list.

url(url_path,view_to_be_tagged,name_for_this_view)

Example:

Code:

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'^$',views.index,name='index'),
url(r'admin/',admin.site.urls),]

5. Reload the server using python manage.py runserver command and verify webpage

The system message which is been placed below will be printed in the project console on loading the runserver. This message holds detailed information of when the server was started, the Django version which is been used and the http link at which the server is kickstarted.

Code:

Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
June 10, 2020 - 11:23:00
Django version 3.0.7, using settings 'educba.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Output:

Django View Rendered from Template Tag

Given below are the Django view rendered from template tag:

1. The template tags are used for injecting dynamically generated content to the Django views. This is among the key functionalities of template tag. They could flexibly inject dynamic contents into the file.

The template tag filters could use the below listed options:

2. In this example we have added the if tags and the filter tags to the template.

• Add a template tag in the HTML file.

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> <u> All valid Technical tutorials </u> </h1>
{% if Entity_type == 'tutorial' %}
{{ Entity_name }}
{% else %}
{{ Error_Message }}
{% endif %}
<h2> <u> Django filters Explained <u> </h2>
<p> Student Count: {{ Entity_students_count | add:"230"}}  <p>
<p> Entity Type: {{ Entity_type | capfirst}}  <p>
</body>
</html></html></html>

Example:

from django.shortcuts import render
from django.http import  HttpResponse
def index(request_iter):
dict_Var =  {
"Entity_name": "Educba",
"Entity_type": "tutorial",
"Entity_students_count": 345,
"Error_Message": "No Valid Entity found"
}
return  render(request_iter,'design.html',context=dict_Var)

3. Reload the server using python manage.py runserver command and verify the webpage.

Output:

Conclusion

The use of templates is on among the biggest capabilities of Django in web development framework. These templates allow the Django setup to flexibility transfer dynamic content between the front end and the middle stream.

Introduction to Django URL

URL is a path through which a specific web-based application and one particular page in that web application can be reached. So for any web-oriented application setting these url paths is a very key necessity. The same applies to Django also, So from a Django perspective setting the necessary URL’s are handled in the urls.py section of the framework and there are several techniques through which the URL’s are maintained through the application. This information on how classifiable Django handles its URL’s and what are the techniques involved for keeping these URL’s assembled are described below.

How to Create a Django URL?

How to create a Django url is given below:

1. Creating a url USING PATH()

The path method allows returning of an element to be included in URL patterns tuple which will be used as an url pattern. This was introduced in Django version 2.0 along with the re_path() method.

Syntax: 

path(route, view, kwargs=None, name=None)

Example

urls.py:

from django.contrib import admin
from django.conf.urls import url,include
from django.urls import path
from Django_app1 import views
admin.autodiscover()
urlpatterns = [
path('index/',views.template_view,name='template'),
url(r'^myapp/', include('Django_app1.urls')),
url(r'admin/', admin.site.urls),
]

Output:

2. Creating  a Django URL USING RE_PATH()

The re_path() method allows the use of python regular expressions in URLs. This was introduced in version 2.0 along with the path() method.

Syntax:

path(route, view, kwargs=None, name=None)

Example

urls.py:

rom django.contrib import admin
from django.conf.urls import url,include
from django.urls import path , re_path
from Django_app1 import views
admin.autodiscover()
urlpatterns = [
re_path('^indexs??/$',views.template_view,name='template'),
url(r'^myapp/', include('Django_app1.urls')),
url(r'admin/', admin.site.urls),
]

Output :

Note: The question mark in regex allows the indexes page to get loaded with only the index mentioned in it.

3. Creating a Django url Through INCLUDE

The technique involves creating url patterns within each app. This will bring more flexibility when the app needs to be plugged into a different application. Just making inclusion of these URL’s in the main project urls.py file will help to easily access the web pages associated with that Django application. Below are the steps related to making an include oriented Django urls.py in place.

Django app urls.py: First a urls.py file needs to be created within the application. So this means every Django application which was expected to be developed as a part of the Django project is considered to hold an individual urls.py file within it. This individual urls.py file will bring flexibility for the applications so that they can be easily plugged and plugged out from the main project.

 As like usual urls.py, this file contains the import of the url class from the django.conf.URLs library, most importantly the views file for this application is expected to be imported here from the Django application mentioned. The view method which has been imported needs to be specified in the import of the views from the Django application. additionally as like mention in the URL declarations above here again a name s associated to the url mapping and the path of the mapping is also placed. So this section acts as the formulation of urls.py file inside the individual Django application.

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'formpage/',views.formView,name='form'),
]

Main project urls.py: This urls.py file will be acting as the premiere URLs linking the library for the entire application. here all the URLs from the Django application can be included which means every page addressed in those applications can be accessed here sophisticatedly. The first major element to be taken care is that the include method is imported from django.conf.urls library. This is the first key thing to be taken care of. Next, ensure the admin class is also imported. This admin class is useful in setting the auto-discover method. At last, it needs to be ensured that the urls.py file from the Django application is included as an item to the urlpatterns tuple. Making this include will automatically import all the urls from that corresponding application.

from django.contrib import admin
from django.conf.urls import url,include
from Django_app1 import views
admin.autodiscover()
urlpatterns = [
url(r'^$',views.template_view,name='template'),
url(r'^myapp/', include('Django_app1.urls')),
url(r'admin/', admin.site.urls),
]

Output:

4. Setting Converters in URLS

The converters are responsible for converting a dynamic value in the URL to a needed value format.

Example

The below example shows how the url value can be converted to a string format and passed into its corresponding view.

urls.py:
from django.contrib import admin
from django.conf.urls import url,include
from django.urls import path , re_path,register_converter
from django.urls.converters import StringConverter
from Django_app1 import views
admin.autodiscover()
register_converter(StringConverter, 'username')
urlpatterns = [
path('index/<username:uname>/',views.template_view,name='template'),
#    url(r'formpage/',views.formView,name='form'),
url(r'^myapp/', include('Django_app1.urls')),
url(r'admin/', admin.site.urls),
]

Views.py:

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform
from django.core.exceptions import ViewDoesNotExist
from django.contrib.auth.models import User
def template_view(request_iter,uname):
template_Var =  {
"Entity_name" : "Educba",
"Entity_type"  : "tutorial",
"Entity_students_count" : 345,
"Error_Message" : "No Valid Entity found"
}
print("Username:",uname)
return  render(request_iter,'design.html',context=template_Var)

Output:

5. Creating a Django URL Through URL()

1. Create a Template folder: First to hold the html design for the web page the necessary templates are expected to be created. these templates are stored in the template folder, So for a Django project all the code associated. The template folder has to be created under the primary project folder.

2. Tag the Template folder in settings.py file: The settings.py file needs to have the tag for the templates folder so that all templates are accessible for the entire Django project. This brings in the capability of accessing all the html files which are been placed as a part of the templates folder.

3. Place an HTML file inside the Templates folder: The HTML content for the web page is drafted.

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> Hello world from HTML page <h1>
</body>
</html>

4. Render the html file in views.py using render() method: For passing the newly created HTML content to the web page or in other words to connect the content to the webpage the render() method is used. The render method combines a template with the context dictionary to return a HttpResponse object.

from django.shortcuts import render
from django.http import  HttpRespons
def index(request_iter):
return  render(request_iter,'design.html')

• Import the library from django.conf.urls import url.
• declare a url entry in the urlpatterns list.

url(url_path, view_to_be_tagged, name_for_this_view)

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'^$',views.index,name='index'),
url(r'admin/', admin.site.urls), ]

• Reload the server using python manage.py runserver command and verify the webpage.
• The console will be pasted with the below listed server messages, So the time of the server to be kickstarted can be identified from this, also the http link and the version of the Django server which is been used will also be displayed.

Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
June 23, 2020 - 13:33:00
Django version 3.0.7, using settings 'educba.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

• Reload the server using python manage.py runserver command and verify the webpage.

Output:

6. Django URL Error Codes

Introduction to Django Exceptions

An exception can be defined as an event that will be deviating the normal execution of a program into an abnormal state. The try and exception blocks in the exception strategy are helpful in handling these exceptions. These python oriented exceptions are widely classified deep. From a django perspective, the django framework holds its own set of exceptions. All these exceptions which are tagged under django framework are considered to be created to be suitable to address the various possible exception scenarios which are generated in django framework. These classified set of django exceptions are mentioned below briefly along with their possible instance of occurrence.

Standard Django Exceptions List

Below are the list of overall standard exceptions which are been triggered in Django setup,

AppRegistryNotReady: There are two instances were this error could be triggered, First is when there is an attempt to use the models associated to django set up before the app is been successfully loaded. Second is placing an invalid app in the INSTALLED_APPS directory. So placing an application that cannot be successfully imported will also throw this error. This error is more related to the INSTALLED APPS section in the settings.py file.

SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
}
}
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.postgres',
'Django_app1'
]

• ObjectDoesNotExist: When an object is not a part of the corresponding model then the error objectDoesNotExit gets triggered. This exception is a base class of the DoesNotExist exceptions.
• FieldDoesNotExist: The field does not exist an error is triggered when the attempted field is not a part of the database or the model referred. this means when the attempted field in the query triggered is not a part of the model produced in the models.py file then the FieldDoesNotExist error will be triggered by the django framework. This error is raised by the _meta.get_field() of a model when the attempted field is not a valid part of that model or the parents of the model.
• MultipleObjectsReturned: This exception is raised when there is a discrepancy on a number of objects being returned back by the query. So when querying the database if the query expects a response of one object to be returned but on execution case, if more than one object is delivered as output for the query then the multiple objects exception will be triggered by the django framework. The base version for this exception is inherited in the core. exceptions class, Basically every model class will be holding a subclassed version which will be helpful in determining the object type for which multiple objects are been returned.
• SuspiciousOperation: All identified operation which are considered to be suspicious by django framework will be tagged under the exception of the suspicious operation. More predominantly exceptions which fall under security bracket are considered to be suspicious operation exceptions. This suspicious operation exception is subdivided into subclass exceptions as listed below.
  • DisallowedHost
  • DisallowedModelAdminLookup
  • DisallowedModelAdminToField
  • DisallowedRedirect
  • InvalidSessionKey
  • RequestDataTooBig
  • SuspiciousFileOperation
  • SuspiciousMultipartForm
  • SuspiciousSession
  • TooManyFieldsSent
• PermissionDenied:The permission denied exception is raised when the user does not hold suitable access or authority for the attempted entity. This is an access oriented exception. At most instances, security oriented issues will be tagged under this exception and triggered as permission denied instance. This exception offers additional integrity in stabilizing the application.
• ViewDoesNotExist: This exception is predominantly raised by the url.py file. When an attempted view mentioned in the urls.py file is not present in the actual views.py file then the ViewDoesNotExist error will be raised. This exception could also be raised conditionally.

Example:

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform
from django.core.exceptions import ViewDoesNotExist
from django.contrib.auth.models import User
deftemplate_view(request_iter):
template_Var=  {
"Entity_name": "Educba",
"Entity_type" : "tutorial",
"Entity_students_count": 345,
"Error_Message": "No Valid Entity found"
}
return  render(request_iter,'design.html',context=template_Var)
defformView(request_iter):
form = Valueform()
if request_iter.method == "POST":
value = Valueform(request_iter.POST)
if value.is_valid():
first_name = value.cleaned_data['first_name'] if request_iter.session.has_key(first_name):
print(request_iter.session.items())
return render(request_iter, 'Session.html' )
else:
request_iter.session[first_name] = first_name
return render(request_iter, 'Form_Handeling.html', {"form":form})
else:
raise ViewDoesNotExist("!!! INVALID VIEW !!!")
return render(request_iter, 'Form_Handeling.html', {"form":form})

• ImproperlyConfigured:The improperly configured exception is raised when the database connected to Django is not been configured properly in the django framework. So when there are connectivity issues on the database are then this exception on improper configuration will be triggered.

Example:

Base.py (Source code from which the exception is raised):

def databases(self):
if self._databases is None:
self._databases = settings.DATABASES
if self._databases == {}:
self._databases = {
DEFAULT_DB_ALIAS: {
'ENGINE': 'django.db.backends.dummy',
},
}
if DEFAULT_DB_ALIAS not in self._databases:
raise ImproperlyConfigured("You must define a '%s' database." % DEFAULT_DB_ALIAS)
if self._databases[DEFAULT_DB_ALIAS] == {}:
self._databases[DEFAULT_DB_ALIAS]['ENGINE'] = 'django.db.backends.dummy'
return self._databases
Base.py (Framework source code which triggers the exception):

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

Snap of The Exception:

• MiddlewareNotUsed:This issue is raised if there is an issue with the middleware setup for the django project. On frequent instance of this issue is when the middleware mentioned is not properly configured in the SETTINGS.py file of the project. When there are valid issues in those middle ware configurations then those will be raised as an middleware configuration issue.

SETTINGS.py (Middleware configurations):

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

• FieldError: With the databases holding a number of fields in it there are possibilities that a field mentioned in a database is not valid or it experiences some kind of issue on its existence or on its retrieval. these classified set of exceptions on the field level are mentioned by the field Error exception in Django.
• ValidationError: There are a number of ways the data in a field are expected to be validated so that they are needed consistency. These verifications can be achieved by means of custom and default validation entities. So an exception raised from these validations is tagged to be Validation Error exception.

Introduction to Django File Upload

Every web application will have form processing within it, uploading files as a part of the form processing is a very common operation. the method through which these files uploaded as a part of form processing is critical. This file upload processing in Django discusses all methods involved as a part of the file level processing in Django. The files uploaded can be retrived, processed, stored, etc. libraries like storage and file system storage are very helpful in the file upload process for storage level necessities. These file fields used for file upload in Django are evolved from the forms processing section of the Django framework.

SETTING File Upload

When a file is uploaded in Django the file is tagged to the request through request.Files[]. Thes request. Files are responsible for capturing the file details being uploaded and keep them tagged within it. the uploaded file details and contents need to be retrieved from this request. Files[] section and then furtherly processed by mentioning the request.FILES with reference to the file name, this will be creating the object which is used to be acting more as like a file-based object in the file setup and storage process. All details regarding the file could be pulled from this file-based object.

How to Upload Django File?

Basically the file upload process consists of below major steps, The below-derived steps is a step by step process of how the file processing during the file upload is achieved in Django.

1. Declare the file field in the Forms.py file. This is the more critical part because this field will be used as a reference for representing the file in the template being used for processing the form. here the forms library is used for importing the FileField() class, the object created for these elements will be acting as the object for the file field. in the below example it is represented as ‘uploaded_File’.

#-*- coding: utf-8 -*-
from django import forms
class fileform(forms.Form):
Uploaded_File = forms.FileField()

2. Create the view for processing the file, This view is the most critical section in rendering and processing the file, here the above-created field will be  While creating this view the below key points need to be taken into accountability.

3. The uploaded file will be tagged as a part of the request. Files, All details regarding the file and file itself can be processed using this request. Files section. The file can be captured into a file-based object by means of below line,

uploaded_file = request.FILES['Uploaded_File']

4. To access the file and details regarding the file the below methods can be used, So all operations on the file like the determination of file size, determination of name of the file, Also identifying the content type of the file which is tagged to the requested file and even reading the file can be accomplished by these methods, there are also methods named as chunks which are useful in reading the file as smaller chunks.

5. Methods of Django File Upload

Below are the methods and its description of Django File Upload:

6. The FileSystemStorage class can be used for performing basic file storage operations on the filesystem of the local area.

Syntax:

FileSystemStorage(location, base_url, file_permissions_mode, directory_permissions_mode).

7. The below view shows all file-level operations being performed on this file. the process involved in the view are explained below. First, the object for the form file is created. The model file field is used as a reference for retrieving the message from the request.files[] header. The request.FILES is assigned to an object. This object is used for all further operations on the file. So the process of identifying the file size, content header, filename, etc are achieved from this object associated to request.file method.

Code:

Views.py

from django.shortcuts import render
from django.http import HttpResponse
from Django_app1.forms import fileform
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib import messages
def file_upload(request):
file = fileform()
print(" File Values in File Dictionary:", request.FILES)
if request.method == 'POST' and request.FILES['Uploaded_File']:
uploaded_file = request.FILES['Uploaded_File'] fs = FileSystemStorage()
filename = fs.save(uploaded_file.name, uploaded_file)
uploaded_File_Size = 'Size of Uploaded file: ' + str(uploaded_file.size)
content_type_of_uploaded_file = 'Content type of uploaded file: ' + str(uploaded_file.content_type)
uploaded_file_name = 'Name of Uploaded file: ' + str(uploaded_file.name)
uploaded_file_url = fs.url(filename)
print("uploaded file url",uploaded_file_url)
messages.success(request, '!!! File upload successful !!!')
messages.success(request,uploaded_File_Size)
messages.success(request,uploaded_file_name)
messages.success(request,content_type_of_uploaded_file)
return render(request, 'filehandeling.html', {"file":file})
return render(request, 'filehandeling.html',{"file":file})

8. The HTML template for the file needs to be formulated, in the below-shown code snippet, the file upload field is rendered from the forms.py section of the application. The HTML file additionally includes code for displaying the messages which are triggered as a part of the file upload process.

Message Framework Methods:

1. messages.debug(request, ‘Intended message’)
2. messages.info(request,’Intended message’)
3. messages.success(request,’Intended message’)
4. messages.warning(request, ‘Intended message’)
5. messages.error(request, ‘Intended message’)

Code:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
</head>
<body>
<h1> <u> FILE UPLOAD HANDELING IN DJANGO </u> </h1>
{% if messages %}
<ul>
{% for message in messages %}
<li>{{ message }}</li>
{% endfor %}
</ul>
{% endif %}
<div style = "max-width:470px;">
<form method = 'POST' enctype="multipart/form-data">
{{ file.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit">
</form>
</div>
</body>
</html>

Output:

Conclusion

We can notice from the above-given examples that how flexibly the file level processing can be achieved from a Django framework from the available set of methods.

Introduction of Django Filter Queryset

When the database connectivity is been established in Django, there is always a need of extracting the needed columns alone from the database and their corresponding rows, basically, the filter query set in django model filters is used for achieving this. When a value is expected to be retrieved from the database then the filter queryset section of the queryset oriented extraction comes into play. Mentioning a filter of a specific column will help us to filter and pull those corresponding values alone from the queryset retrieved. This option in django helps us to achieve abstract level filtering of needed values.

Syntax:

The syntax of filter queryset is as like below,

model.objects.filter(condition)

Creating a Queryset

Lest discuss how to create a queryset.

1. Create a models.py file in the application: The schematic structure of an database needs to be mentioned here in the moedels.py file.

Examples: (models.py)

from django.db import models
# Create your models here.
class sample(models.Model):
name =  models.CharField(max_length=20,unique=True)
card_no =    models.IntegerField()
def _str_(Self):
return self.name, self.id

We can notice the schematic structure is created as an class referring to the models import. All the expected fields of the model need to be declared in this class. also ensure the database configurations are in place so that no issues are generated while reaching the database,

Example: (SETTINGS.py)

TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [Template_DIR,],
'APP_DIRS': True,
'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',
],
},
},
] WSGI_APPLICATION = 'educba.wsgi.application'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'postgres',
'USER': 'postgres',
'PASSWORD' : 'anand',
'HOST': '127.0.0.1',
'PORT': '5432',
}
}

2. Check for Migrations: After the models file is created verify the migrations expected using the make migrations command.

python manage.py makemigrations

3. Apply the Migrations: Next, apply all the needed migrations using the migrate command.

python manage.py migrate

4. Create the needed views in the views.py file: All needed views have to be generated.

views.py

from django.shortcuts import render
from django.http import  HttpResponse
from Django_app1.forms import Valueform,fileform,emailform,requestcheckform
from django.core.exceptions import ViewDoesNotExist
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib import messages
from django.core.mail import send_mail,EmailMessage
from Django_app1.models import sample
import requests
def requestmethods(request):
form = requestcheckform()
if request.method == 'POST':
# REQUEST OBJECT ATTRIBUTES
if request.POST['request_attribute'] == 'Request Header':
data_content = "data content of request method : " + str(request.headers)
messages.success(request,data_content)
elif request.POST['request_attribute'] == 'Request POST':
post_content = "post content of request method : " + str(request.POST)
messages.success(request,post_content)
elif request.POST['request_attribute'] == 'Request Files':
FILES_content = "FILES in request method : " + str(request.FILES)
messages.success(request,FILES_content)
elif request.POST['request_attribute'] == 'Request GET':
GET_content = "GET Content in request method : " + str(request.GET)
messages.success(request,GET_content)
elif request.POST['request_attribute'] == 'Request User':
Request_User = "User Details : " + str(request.user)
messages.success(request,Request_User)
elif request.POST['request_attribute'] == 'Request Body':
Request_body = "Request Body : " + str(request.body)
messages.success(request,Request_body)
elif request.POST['request_attribute'] == 'Request Content Type':
Request_Content_Type = "Request Content type : " + str(request.content_type)
messages.success(request,Request_Content_Type)
elif request.POST['request_attribute'] == 'Request Encoding':
Request_Encoding = "Request Encoding Used : " + str(request.encoding)
messages.success(request,Request_Encoding )
elif request.POST['request_attribute'] == 'Request Method':
Request_method = "Request Method posted : " + str(request.method)
messages.success(request,Request_method )
elif request.POST['request_attribute'] == 'Request Path':
Request_path = "Path of the request : " + str(request.path)
messages.success(request,Request_path )
elif request.POST['request_attribute'] == 'Request Cookies':
Request_Cookies = "Cookies associated to the Request : " + str(request.COOKIES)
messages.success(request,Request_Cookies )
elif request.POST['request_attribute'] == 'Request META':
Request_META = "HTTP headers info : " + str(request.META)
messages.success(request,Request_META )
# REQUEST METHODS
elif request.POST['request_attribute'] == 'Request port':
Request_port =  "Request port number: " + str(request.get_port())
messages.success(request,Request_port )
elif request.POST['request_attribute'] == 'Request host':
Request_host =  "Requested Host: " + str(request.get_host())
messages.success(request,Request_host)
elif request.POST['request_attribute'] == 'Request is_secure':
Request_secure =  "Security level of the request: " + str(request.is_secure())
messages.success(request,Request_secure)
return  render(request,'Request_methods_check.html',{"form":form})
def file_upload(request):
file = fileform()
print(" File Values in File Dictionary :", request.FILES)
if request.method == 'POST' and request.FILES['Uploaded_File']:
uploaded_file = request.FILES['Uploaded_File'] fs = FileSystemStorage()
filename = fs.save(uploaded_file.name, uploaded_file)
uploaded_File_Size = 'Size of Uploaded file : ' + str(uploaded_file.size)
content_type_of_uploaded_file = 'Content type of uploaded file : ' + str(uploaded_file.content_type)
uploaded_file_name = 'Name of Uploaded file : ' + str(uploaded_file.name)
uploaded_file_url = fs.url(filename)
print("uploaded file url",uploaded_file_url)
messages.success(request, '!!! File upload successful !!!')
messages.success(request,uploaded_File_Size)
messages.success(request,uploaded_file_name)
messages.success(request,content_type_of_uploaded_file)
return render(request, 'filehandeling.html', {"file":file})
return render(request, 'filehandeling.html',{"file":file})
def email_sending(request):
email = emailform()
if request.method == 'POST':
email_id =  request.POST['email'] email_subject =  request.POST['email_subject'] email_message =  request.POST['email_message'] mail = send_mail(email_subject,email_message,'testmysmtpconnection@gmail.com',[email_id],fail_silently = False)
response = HttpResponse(mail)
print("Content of the resposne: ",response.content)
print("Charecterset of the response: ",response.charset)
print("Status code of the response: ",response.status_code)
print("Reason phrase of the response: ",response.reason_phrase)
print("Reason close status: ",response.closed)
return response
return render(request, 'emailpage.html',{"email":email})
def db_hit(request):
all_objects =  sample.objects.all()
for i in all_objects:
print(i.card_no)
print(sample.objects.filter(card_no = 102))
return render(request, 'model.html')

6. Generate the needed Templates: The templates mentioning the webpage has to be created.

model.html:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/font.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
</style>
</head>
<body>
<h1> <u> MODEL HANDELING </u> </h1>
</body>
</html>

email_page.html:

<!DOCTYPE html>
<html lang="en" dir="ltr">
<head>
<meta charset="utf-8">
<title>Django App1</title>
{% load static %}
<link href="{% static 'admin/css/font.css' %}" rel="stylesheet">
<style>
body {
background-image: url("{% static 'admin/img/background.jpg' %}");
background-color: #acccbb;
}
.myDiv {
border: 5px outset red;
background-color: lightblue;
text-align: center;
font-family: "Comic Sans MS", cursive, sans-serif;
font-size: 14px;
letter-spacing: 2px;
word-spacing: 1.8px;
text-align: left;
color: #02071C;
font-weight: 200;
text-decoration: none;
font-style: normal;
font-variant: normal;
text-transform: capitalize;
}
</style>
</head>
<body>
<h1> <u> DJANGO HANDELING EMAILS </u> </h1>
<div class="myDiv" style = "max-width:470px;">
<form method =  'POST' ">
{{ email.as_p }}
{% csrf_token %}
<input type="submit" class="btn btn-primary" value="submit" style="text-align:center">
</form>
</div>
</body>
</html>

7. Tag the view in urls.py file: This is the process of creating a url for the view.

• Import the library from django.conf.urls import url
• declare a url entry in the urlpatterns list

url(url_path, view_to_be_tagged, name_for_this_view)

urls.py:

from django.contrib import admin
from django.conf.urls import url
from Django_app1 import views
urlpatterns = [
url(r'formpage/',views.formView,name='form'),
url(r'fileupload/',views.file_upload,name='file_upload'),
url(r'emailpage/',views.email_sending,name='email_sending'),
url(r'requests/',views.Httpmethods,name='Request_check'),
url(r'requestmethod/',views.requestmethods,name='request_method'),
url(r'model/',views.db_hit,name='db_hit'),
]

Output:

Introduction to Django JsonResponse

JSON is a format very flexibly preferred nowadays, so support for JSON is extended across all technology formats. This is because of the easy capability to reference and parse data in JSON objects. This parsing capability offers a large extent of preference for JSON objects. So, like other platforms, Django also provides support for JSON, and support is offered by means of JSON response. So when data is rendered like an HTML page rendering, JSON objects can also be rendered. This rendering of JSON objects is depicted below.

Syntax:

from django.http import JsonResponse
JsonResponse(data,safe=TRUE/FALSE)

How JsonResponse works in Django?

Understanding how JSON objects receive data involves actively working with the JSON format. The first and most significant element to ensure is to import the JsonResponse class from Django. HTTP library. This is a very critical step, only if the Django. HTTP library shares the JsonRespose class, then the JSON-based rendering can be performed. The class will make the JSON response element to be available for the remaining of the program. Next, the data for rendering needs to be formulated. When formulating data, one must consider its source, whether it be from forms, random input, or databases. It is crucial to properly format the data to determine how it will be populated and which information will be involved in the process. After this comes the key part of data rendering. The data rendering is the critical section where the JSON response will be rendered. This process involves depicting the data on the console. Furthermore, you must ensure to add the URL entry for the data.

Create a Django JsonResponse:

1. Changes in Models.py file: The JsonResponse charge at the same time as submitted ought to be stored, and at the same time as retrieved, it ought to be pulled from the database. Use the object created for the model, as explained in the following section of views.py, to complete this task.

models.py

from django.db import models
from django.contrib.auth.models import User

# Model variables
# Create your models here.
class Bride(models.Model):

    JsonResponse_Example_name = models.CharField(max_length=200,null=True)
    JsonResponse_Example_thegai = models.CharField(max_length=200,null=True)
    JsonResponse_Example_State =  models.CharField(max_length=50,null=True)
    JsonResponse_Example_District = models.CharField(max_length=50,null=True)
    JsonResponse_Example_Address = models.TextField(null=True)
    JsonResponse_Example_Phone = models.BigJsonResponse_Example_Field(null=True)
    JsonResponse_Example_profession = models.CharField(max_length=200,null=True)
    JsonResponse_Example_salary = models.BigJsonResponse_Example_Field(null=True)
    JsonResponse_Example_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
    JsonResponse_Example_Under_Graduation_college = models.CharField(max_length=400,null=True)
    JsonResponse_Example_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
    JsonResponse_Example_Post_Graduation_college = models.CharField(max_length=400,null=True)
    JsonResponse_Example_Rasi = models.CharField(max_length=200,null=True)
    JsonResponse_Example_Nakshatra = models.CharField(max_length=200,null=True)
    JsonResponse_Example_Creator  =  models.ForeignKey(User, null=True, on_delete=models.CASCADE)


    def _str_(self):
        return self.name

2. Changes in Forms.py file:

We have made the following modifications to the forms.py file, which include adding the “bride” table and linking and declaring all of its fields within the forms.py file.

forms.py

from django import forms
from .models import Bride
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User

class Valueform(forms.ModelForm):
 #   Rasi = forms.ChoiceField(choices = Rasi_CHOICES)

    class Meta:
        model = Bride
        fields = "__all__"

3. Changes in Settings.py file:

Ensure that you properly configure the values and database connections in the settings.py file to ensure smooth and flexible execution of the project.

Settings.py:

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',


    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'Matrimony.urls'
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [Template_DIR,],
        'APP_DIRS': True,
        'OPTIONS': {
            'render_dict_processors': [
                'django.template.render_dict_processors.debug',
                'django.template.render_dict_processors.request',
                'django.contrib.auth.render_dict_processors.auth',
                'django.contrib.messages.render_dict_processors.messages',
            ],
        },
    },
]

4. Changes in url.py file:

It’s crucial that you instantiate the Media root and document root variables within the url.py file to configure it correctly. Here are the steps you need to take to make the necessary adjustments to the url.py file.

url.py:

from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from matrimony_pages import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
    url(r'^$',views.Welcome_page,name='Welcome_page'),
    url(r'Mainpage/',views.Main_page,name='Main_page'),
    url(r'form/',views.form_view,name='form_view'),
    url(r"signup/", views.Sign_up_request, name="register"),
    url(r"login/", views.login_request, name="login"),
   path(r'profile//',views.JsonResponse_Example_page,name='profile'),
    url(r'logout/',views.logout_request,name='logout'),
    url(r'reg/',views.JsonResponse_Example_reg_user,name='reg'),
    path(r'update//',views.form_update,name='update'),
    path('admin/', admin.site.urls),
]+ static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)

5.  Create a view for the form: The JsonResponse rate while submitted must be stored, and it must be retrieved from the database. Use the object you created for the model to complete this task. Refer to the views.py section provided below for instructions on how to do this.

views.py

from django.shortcuts import render, redirect
from django.http import HttpResponse
from .models import *
from .forms import NewUserForm,Valueform
from  django.contrib.auth import login,authenticate,logout
from django.contrib import messages
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.models import User
from django.contrib.auth.decorators import user_passes_test,login_required
from django.core.paginator import Paginator
from django.http import JsonResponse
def form_view(request):
    form = Valueform(request.POST or None)
    if form.is_valid():
        post = form.save()
        post.Creator = request.user
        print('Creator user stored',request.user)
        post.save()
    return  render(request,'form.html', {"form": form})

@login_required
def JsonResponse_Example_page(request,pk):
      Json_dict = {}
      JsonResponse_key_variable_ = Bride.objects.get(id=pk)
      JsonResponse_Example_name =  JsonResponse_key_variable_.name
      JsonResponse_Example_Age =  Bride.objects.JsonResponse(first_name='Nalandan', last_name='Ranjan',defaults={'birthday': date(1990, 10, 9)})
      JsonResponse_Example_Thegai =  JsonResponse_key_variable_.thegai
      JsonResponse_Example_state =  JsonResponse_key_variable_.State
      JsonResponse_Example_district =  JsonResponse_key_variable_.District
      JsonResponse_Example_Address =  JsonResponse_key_variable_.Address
      JsonResponse_Example_Phone =  JsonResponse_key_variable_.Phone
      JsonResponse_Example_Profession =  JsonResponse_key_variable_.profession
      JsonResponse_Example_Salary =  JsonResponse_key_variable_.salary
      JsonResponse_Example_UG =  JsonResponse_key_variable_.Under_Graduation_Degree
      JsonResponse_Example_UGC =  JsonResponse_key_variable_.Under_Graduation_college
      JsonResponse_Example_PG =  JsonResponse_key_variable_.Post_Graduation_Degree
      JsonResponse_Example_PGC =  JsonResponse_key_variable_.Post_Graduation_college
      JsonResponse_Example_UG =  JsonResponse_key_variable_.Under_Graduation_Degree
      JsonResponse_Example_UGC =  JsonResponse_key_variable_.Under_Graduation_college
      JsonResponse_Example_PG =  JsonResponse_key_variable_.Post_Graduation_Degree
      JsonResponse_Example_PGC =  JsonResponse_key_variable_.Post_Graduation_college
      JsonResponse_Example_Rasi =  JsonResponse_key_variable_.Rasi
      JsonResponse_Example_Nakshatra =  JsonResponse_key_variable_.Nakshatra
      Json_dict['Age'] = JsonResponse_Example_Age
      Json_dict['name'] = JsonResponse_Example_name
      Json_dict['thegai'] = JsonResponse_Example_Thegai
      Json_dict['State'] = JsonResponse_Example_state
      Json_dict['district'] = JsonResponse_Example_district
      Json_dict['Address'] = JsonResponse_Example_Address
      Json_dict['Phone'] = JsonResponse_Example_Phone
      Json_dict['profession'] = JsonResponse_Example_Profession
      Json_dict['Under_Graduation_Degree'] = JsonResponse_Example_UG
      Json_dict['Under_Graduation_college'] = JsonResponse_Example_UGC
      Json_dict['Post_Graduation_Degree'] = JsonResponse_Example_PG
      Json_dict['Post_Graduation_college'] = JsonResponse_Example_PGC
      Json_dict['Rasi'] = JsonResponse_Example_Rasi
      Json_dict['Nakshatra'] = JsonResponse_Example_Nakshatra
      return  render(request,'Profilepage.html',Json_dict)

+def Json_Response(request):
jsondata = [{'name': 'Name of bride'},
         {'Age': 'Age of Bride'},
	   {'thegai': 'Thegai'},
         {'state': 'state of bride'},
	   {'district': 'bride district'},
         {'address': 'address details'},
         {'phone': 'phone details'},
         {'UGD': 'Degree details'},
         {'UGC': 'College details'},
         {'PGD': 'Post Degree details'},
         {'PGC': 'post College details'},
         {'Rasi': 'details of rasi'},
         {'Nakshatra': 'Nakshatra details'}
]
      return JsonResponse(jsondata, safe=False)

Output:

Conclusion

This guide explains how to claim JsonResponse area combos in Django, outlining the syntax and how JsonResponse relationships function in Django. Additionally, it provides a live website example, along with screenshots, and highlights any updates made to Django-related documents.

Introduction to Django Cache

When a page is requested in a web application several processes should be performed in the backend to bring the page to the requester. The process could be of hitting database queries, calling templates, performing several calculations, etc. performing these operations from scratch for every page call may become expensive for sites with heavy traffic. One way to tackle this is by setting a cache system. The cache system will save the outcome of an expensive operation so that the calculation can be omitted next instance.

Types of Django cache

As far as Django is concerned Django is classified into 5 major types, these five major types are the key classifications in the cache process of Django. Each of these types has its own way of caching the data. On the other hand, the intention is to store the data well and make cognitive processing. The various types of cache are discussed below:

• Memcached
• Filesystem caching
• Local memory cache
• Dummy cache
• Database cache

How did the cache work?

The process of caching can be performed in several ways, Through a database, memory, filesystem, etc. each method could be more efficient than the other. The various methods of caching are explained below,

1. Memcahed

Memcached is a daemon server that will do the process of caching. The Memcached will be running as a daemon with memory RAM allocated for it. There are several Memory cache’s in the market. Some of the popular ones are listed here,

1) pylibmc
2) pymemcache
3) memcachedcache

The below example shows the Django cache system based on memcachedcache,

1) Download the Memcached software and extract the software to a desktop location.

2) To view the various options of Memcached below command can be used. Ensure to shift to the Memcached directory before executing the command to view the options.

Cd C:\Users\ANAND\Downloads\memcached-win32-1.4.4-14
.\memcached.exe -h

3) Set the Memcached active using its commands, one sample command is given below.

.\memcached.exe -m 512 -vvv
slab class 32: chunk size 96256 perslab 10
slab class 33: chunk size 120320 perslab 8
slab class 34: chunk size 150400 perslab 6
slab class 35: chunk size 188000 perslab 5
slab class 36: chunk size 235000 perslab 4
slab class 37: chunk size 293752 perslab 3
slab class 38: chunk size 367192 perslab 2
slab class 39: chunk size 458992 perslab 2
slab class 40: chunk size 573744 perslab 1
slab class 41: chunk size 717184 perslab 1
slab class 42: chunk size 1048576 perslab 1
<624 server listening (auto-negotiate)
<652 server listening (auto-negotiate)
<656 send buffer was 65536, now 268435456
<656 server listening (udp)
<656 server listening (udp)
<656 server listening (udp)
<656 server listening (udp)
<660 send buffer was 65536, now 268435456
<660 server listening (udp)
<660 server listening (udp)
<660 server listening (udp)
<660 server listening (udp)

4) Install the Memcached client in Python

pip install python-memcached

6) In the Django project set cache values in the settings.py file,

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

Output:

2. Filesystem caching

In file system caching the cache files will be cached in a file/folder location. To set a file system cache the below are the steps,

1) Make the below changes in the settings.py file, in the below change the location mentions the position where the changes are intended to be stored.

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'D:\sample',
    }
}

Here ensure the location is absolute, Since the location needs to be absolute it must be starting from a root directory.

2) Add the highlighted components to the middleware in the same order.

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

3) Now accessing the website will trigger the cache files to be cached in the mentioned location.

Output:

3. Local-Memorycache

The local memory cache is the default cache service used by Django when no further cache services are explicitly defined.

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'test',
    }
}

Here the location mentions the memory stores. It can be mentioned only when more than one memory store are used.

4. Dummy cache

If the web application doesn’t want any cache in the backend, then dummy caching can be initiated. The dummy cache will not cache anything instead the cache interface will be initiated without doing anything.

CACHES = { 'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
    } } 

5. Database cache

The database cache is a process where the cache values are captured in the database. Here the database cache class has to be referred then the table targeted is expected to be mentioned. First, the database cache class is placed in the Django library inside the core library and within the cache library at the backends section in db and in the database cache. From there on the table has to be mentioned in the location section of the cache services.

CACHES = { 'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'cache_table',
} }

In the above code example the BACKEND value is set to the database-based library ‘django.core.cache.backends.db.DatabaseCache’, whereas the location value is set to the table for which the value is expected to be stored. The cache table needs to be created in the database. The cache table can be most probably created using the python manage.py cachetable command. The above command itself will create the table expected. More interestingly more than one table can be used for storing the cache. This means that at one instance of time more than one table can be used for cache services. This is another example of how the database cache works in Django. The database-level caching process is very similar to caching of the services in file and memory allocation levels.

Conclusion

The given article deals with how the values have to be handled in Django. It also explains on what are the various types of cache services associated with Django. All these types of Django services are compared and expressed with suitable examples along with their operation.

Introduction to Django Reverse

Usually, all web applications involve a huge amount of url’s in them. Based on the web application, the number url’s can be thousands and even lakhs. With these many pages deployed, hardcoding the url’s in each page, or each view, or every template involved may become very hectic in the future. It may create many issues in the future when there are any changes to the url’s used. To overcome this, the reverse function can be used. The reverse function allows retrieving url details from the url’s.py file through the name value provided. This is the primary use of the reverse function in Django.

Syntax:

from django.urls import reverse
Redirect_Variable = reverse(redirect_url_name)

The redirect variable is the variable here that will have the reversed value. So the reversed url value will be placed here. So for the name of the url mentioned in the redirect_url_name, a url value will be allocated in the backend. This url value allocated in the backend will be associated with the redirect variable. Next, the actual reverse function is used. The actual reverse function is used for performing the reverse happens. This method will be responsible for getting the new url value reversed. With the reverse function, the name of the redirect url has to be specified. The name of url value specified here will be for the redirect url name from the url’s.py file.

How does the reverse function work in Django?

The reverse function can be considered very useful in url handling. It helps avoid any future breakdown in the application because of its capability to hold url values in it. The functioning of reverse function can be divided into three straightforward methods as like below,

1) Declare the url to be framed in the url’s.py file. This is the most critical section. All future references of the url will happen from here only.

2) Next, from the url’s.py file, go to the view, and in the new view, the reverse function has to be declared with the variable name of the url hardcoded in it. This section reverses the url field name into a valid url value.

3) The last section involves the actual redirect. Here the redirect will be triggered and processed. So when this section is called, the redirect will happen to the page insisted.

Create a DJANGO reverse function

1. Changes in url.py file

Below is the URL’s file. This will be the url.py file in which all the urls be declared, these url’s are encoded with the name argument in it. This name argument is responsible for calling the reverse function and returning the actual url value in place. We can notice from the below example that each of the urls declared is associated with a url value, which triggers a reverse-based store in the backend.

url.py:

from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from matrimony_pages import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
    url(r'Jsoncheck/',views.Json_Response,name='Json_Response'),
    url(r'^$',views.Entry_page,name='Entry_page'),
    url(r'Mainpage/',views.Main_page,name='Main_page'),
    url(r'all/',views.All_users,name='all'),
    url(r'form/',views.form_view,name='form_view'),
    url(r"signup/", views.Sign_up_Call, name="register"),
    url(r"login/", views.login_Call, name="login"),
    path(r'profile//',views.profile_page,name='profile'),
    url(r'logout/',views.logout_Call,name='logout'),
    url(r'reg/',views.profile_reg_user,name='reg'),
    path(r'update//',views.form_update,name='update'),
    path('admin/', admin.site.urls),
]+ static(settings.MEDIA_URL,document_root=settings.M

2. Create a view for the form

The integer value, when submitted, has to be stored, and when retrieved, it has to be pulled from the database. This can be achieved using the object created for the model. The process of doing this is explained in the below-given views.py section.

views.py

from django.shortcuts import render, redirect
from django.http import HttpResponse
from .models import *
from .forms import NewUserForm,Valueform
from  django.contrib.auth import login,authenticate,logout
from django.contrib import messages
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.models import User
from django.contrib.auth.decorators import user_passes_test,login_required
from django.core.paginator import Paginator
from django.http import JsonResponse
from django.urls import reverse
def All_users(request):
    User_entries =  User.objects.all()
    page = request.GET.get('page', 1)
    paginator = Paginator(User_entries, 5)
    users = paginator.page(page)
    print(" Has other pages : ",users.has_other_pages())
    print(" Has next page : ",users.has_next())
    print(" Has previous page : ",users.has_previous())
    print(" Has previous page : ",users.has_previous())
    print(" Start Index : ",users.start_index())
    print(" End Index : ",users.end_index())
    if users.has_next():
        print(" Next page Number: ",users.next_page_number())
    elif users.has_previous():
        print(" Has Previous page Number: ",users.previous_page_number())
    print(paginator,users)
    return render(request,"All_users.html",{'users':users})
def Sign_up_request(request):
    if request.method == "POST":
        form = NewUserForm(request.POST)
        print(form.is_valid())
        if form.is_valid():
            user = form.save()
            login(request, user)
            print(User.objects.all())
            messages.success(request, "Registration successful." )
            named_redirect = reverse('Welcome_page')
            return redirect(named_redirect)
            messages.error(request, "Unsuccessful registration. Invalid information.")
    form = NewUserForm
    return render (request,template_name="Signup.html", context={"Sign_up_form":form})
def login_request(request):
    if request.method == "POST":
        username = request.POST.get('username', '')
        password = request.POST.get('password', '')
        user = authenticate(request,username=username, password=password)
        if user is not None:
            print('1',request.user.is_authenticated, request.user)
            login(request, user)
#            logout(request)
            print('1',request.user.is_authenticated, request.user)
            messages.info(request, f"You are now logged in as {username}.")
            named_redirect = reverse('Welcome_page')
            return redirect(named_redirect)
        else:
            messages.error(request,"Invalid username or password.")
    form = AuthenticationForm()
    return render(request=request, template_name="login.html", context={"login_form":form})
def logout_request(request):
   if request.user.is_authenticated:
        logout(request)
        print('2',request.user.is_authenticated, request.user)
        messages.info(request, "Logged out successfully!")
        named_redirect = reverse('Welcome_page')
        return redirect(named_redirect)
@login_required
def Reverse_Redirect_Example_page(request,pk):
      render_dict2 = {}
      Key_details = Bride.objects.get(id=pk)
      Reverse_Redirect_Example_name =  Key_details.name
      Reverse_Redirect_Example_Age =  Key_details.age
      Reverse_Redirect_Example_Thegai =  Key_details.thegai
      Reverse_Redirect_Example_state =  Key_details.State
      Reverse_Redirect_Example_district =  Key_details.District
      Reverse_Redirect_Example_Address =  Key_details.Address
      Reverse_Redirect_Example_Phone =  Key_details.Phone
      Reverse_Redirect_Example_Profession =  Key_details.profession
      Reverse_Redirect_Example_Salary =  Key_details.salary
      Reverse_Redirect_Example_UG =  Key_details.Under_Graduation_Degree
      Reverse_Redirect_Example_UGC =  Key_details.Under_Graduation_college
      Reverse_Redirect_Example_PG =  Key_details.Post_Graduation_Degree
      Reverse_Redirect_Example_PGC =  Key_details.Post_Graduation_college
      Reverse_Redirect_Example_UG =  Key_details.Under_Graduation_Degree
      Reverse_Redirect_Example_UGC =  Key_details.Under_Graduation_college
      Reverse_Redirect_Example_PG =  Key_details.Post_Graduation_Degree
      Reverse_Redirect_Example_PGC =  Key_details.Post_Graduation_college
      Reverse_Redirect_Example_Rasi =  Key_details.Rasi
      Reverse_Redirect_Example_Nakshatra =  Key_details.Nakshatra
      render_dict2['Age'] = Reverse_Redirect_Example_Age
      render_dict2['name'] = Reverse_Redirect_Example_name
      render_dict2['thegai'] = Reverse_Redirect_Example_Thegai
      render_dict2['State'] = Reverse_Redirect_Example_state
      render_dict2['district'] = Reverse_Redirect_Example_district
      render_dict2['Address'] = Reverse_Redirect_Example_Address
      render_dict2['Phone'] = Reverse_Redirect_Example_Phone
      render_dict2['profession'] = Reverse_Redirect_Example_Profession
      render_dict2['Under_Graduation_Degree'] = Reverse_Redirect_Example_UG
      render_dict2['Under_Graduation_college'] = Reverse_Redirect_Example_UGC
      render_dict2['Post_Graduation_Degree'] = Reverse_Redirect_Example_PG
      render_dict2['Post_Graduation_college'] = Reverse_Redirect_Example_PGC
      render_dict2['Rasi'] = Reverse_Redirect_Example_Rasi
      render_dict2['Nakshatra'] = Reverse_Redirect_Example_Nakshatra
      print(Key_details.Creator)
      print(render_dict2)
      return  render(request,'Profilepage.html',render_dict2)

Output:

In the below example, output clicking the login button will redirect the user to the application’s main page. This redirect is achieved using the reverse function.

Conclusion

The above article mentions the use of the Django reverse function, how the reverse function can be used in Django to avoid hardcoding URLs, and suitable examples to explain the use and execution of the reverse function in Django.

Introduction to Django create superuser

The following article provides an outline for Django to create a superuser. From the admin perspective, everything can be handled with ease in Django. Moreover, the Django framework itself provides an admin panel. This admin panel can be sophisticatedly handled to manage the admin and other users corresponding to the site. So there can be a process of setting superusers separately in Django. This process is achieved using Django create superuser process. This process involves the creation of the superuser table and then generating the super users within it. This is how the superuser creation process is handled in Django.

Syntax:

Python manage.py createsuperuser

The above command is used for setting the superuser creation process. The above panel will involve the creation of a superuser on the table database declared in the backend. The command shown above works like the one below. First, the python keyword is used for creating the python setup then the manage.py keyword allows us to initiate the superuser setting process for this current project in the superuser table in the backend. Lastly, the create superuser is the command to instantiate the creation.

Working with Django create superuser

• Execute the superuser creation command. The above command in the syntax is used for superuser creation.

Python manage.py runserver

• The superuser’s username will be requested; we need to set the superuser value here for this project. The username of the superuser will be the superuser value expected.
• Next, the email id needs to be mentioned. This is the mapping process between the user id and the email id that will be established in the backend. In other words, the user id will get tagged to the email id at this instance.
• Lastly, the password needs to be entered and confirmed with the user. This process allows you to enter the password and get the password to be confirmed with the user. This is how the superuser setup process is carried out in Django.

The below log shows the admin user setup process:

Code:

C:\Users\ANAND\Desktop\ANAND\Websites\Matrimony\Matrimony\matrimony_pages\admin.py changed, reloading.
Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
July 30, 2021 - 13:54:32
Django version 3.2.3, using settings 'Matrimony.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
[30/Jul/2021 13:39:03] "GET /static/admin/img/Groom.jpg HTTP/1.1" 304 0
[30/Jul/2021 13:39:03] "GET /static/admin/img/Register.jpg HTTP/1.1" 304 0
[30/Jul/2021 13:39:08] "GET /admin/ HTTP/1.1" 302 0
[30/Jul/2021 13:39:08] "GET /admin/login/?next=/admin/ HTTP/1.1" 200 2615
[30/Jul/2021 13:39:08] "GET /static/admin/css/Formpage.css HTTP/1.1" 304 0

Creation snap:

Example of Django creates a superuser

Given below is the example mentioned:

Models.py file

a. (models.py):

Code:

from django.db import models
from django.contrib.auth.models import User
# Model variables
# Create your models here.
class Bride(models.Model):
    Super_user_example_name = models.CharField(max_length=200,null=True)
    Super_user_example_age = models.IntegerField(null=True)
    Super_user_example_thegai = models.CharField(max_length=200,null=True)
    Super_user_example_State =  models.CharField(max_length=50,null=True)
    Super_user_example_District = models.CharField(max_length=50,null=True)
    Super_user_example_Address = models.TextField(null=True)
    Super_user_example_Phone = models.BigIntegerField(null=True)
    Super_user_example_profession = models.CharField(max_length=200,null=True)
    Super_user_example_salary = models.BigIntegerField(null=True)
    Super_user_example_Under_Graduation_Degree = models.CharField(max_length=200,null=True)
    Super_user_example_Under_Graduation_college = models.CharField(max_length=400,null=True)
    Super_user_example_Post_Graduation_Degree = models.CharField(max_length=200,null=True)
    Super_user_example_Post_Graduation_college = models.CharField(max_length=400,null=True)
    Super_user_example_Rasi = models.CharField(max_length=200,null=True)
    Super_user_example_Nakshatra = models.CharField(max_length=200,null=True)
    Image  = models.ImageField(null=True,blank=True,upload_to="img/%y")
    def __str__(self):
        return self.name