Django

The Django Signals is a tactic to notify decoupled applications when certain events occur. The Django Signal is used when many pieces of code may be interested in the same events or when you need to interact with decoupled applications like A Django core model or A model defined by a third-party app.

Two key elements the Senders and the receivers are in the signals machinery. The sender is responsible to dispatch a signal, and the receiver is the one who receives this signal and then performs something.

A receiver can be a function or an instance method to receive signals. A sender can be a Python object or None to receive events from any sender.

Via the connect method, the connection between the receivers and senders is done through 'Signal Dispatchers', which are instances of Signal.

The Django core defines a ModelSignal, a subclass of Signal that allows the sender to lazily specify as a string of the app_label.ModelName form.

You need to register a receiver function that gets called when the signal is sent by using the Signal.connect() method to receive a signal.

Let us see a post_save built-in signal. The code for post_save is stored in the django.db.models.signals module. This signal is fired right after a model finishes executing its save method.

//models.py
from django.contrib.auth.models import User
from django.db.models.signals import post_save

def save_profile(sender, instance, **kwargs):
   instance.profile.save()

post_save.connect(save_profile, sender=User)

Here save_profile is a receiver, User is the sender and post_save is the signal. Wherever a User instance finalizes the execution of the save method, save_profile function will be executed.

A common question in Django interview questions for experienced, don't miss this one.

Django template engine is part of the Django framework and it is easy, extendible and handy in developing complex web applications. 

A template is a text document or Python string marked-up using the Django template language. It can generate any text-based format like HTML, XML, CSV, ETC. 

Being a web framework, Django requires a convenient way to generate HTML dynamically. A template is the most common approach to rely on. The template contains static parts of desired HTML output and some special syntax describing how dynamic content can be inserted. 

A Django project can be configured with or without a template. You can configure one or more template engines. Django provides a standard API for loading or rendering templates irrespective of the backend.  Loading template consists of searching the template for a given identifier and processing it and mostly compiling it into in-memory representation. Rendering means interpolating the template with context data and return the resulting string. django.template.Context is a context class and its constructor takes two arguments, one is a dictionary mapping variable name to variable values and second is the name of the current application.

The template contains variables and template is evaluated these variables get replaced with values.

Django has only one user type that is User. Users are differentiated on the basis of permissions you give. Any normal user can be authenticated and any user assigned the staff flat can log in to the contributed admin app. Users can be set active or de-active and only active users are allowed to log in. A superuser is just a convenient method to create a user with all permissions. 

In Django, you easily create a superuser account to access the admin site. 

We are assuming here that the project is created and database connection is set up, and you are in a project folder.

Now create an application by executing the command -

$ python manage.py startapp newapp

Register your newapp with the Django project say 'newproject'. Open settings.py in the code editor and update INSTALLED_APPS tuple and middleware tuple. 

//settings.py
INSTALLED_APPS = (
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'newapp',
)

MIDDLEWARE_CLASSES = (
   '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',
)

Now to access Admin Interface, initiate database by executing commands -

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

Now create superuser by executing the command -

$ python manage.py createsuperuser

Wait for the success message and then enter the remaining user information.

We are assuming here that the project is created and database connection is set up, and you are in a project folder.

Your Djong application can be anywhere on your Python path. Here, we’ll create our app right next to your manage.py file so that it can be imported as its own top-level module, rather than a submodule of mysite.

To create an application, make sure you’re in the same directory here manage.py and type this command:

$ python manage.py startapp newapp

It will create a directory newapp, which would look like −

newapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py

Application newapp will house in this directory structure.

Now to write view open newapp/views.py file and update with below lines -

from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, world")

To call this view, you need to map it to a URL. 

Create URLconf in the newapp directory, create a file called urls.py. Your directory should look like -

newapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py

Update urls.py file with the following code -

//urls.py
from django.urls import path
from.import views

urlpatterns = [
    path('', views.index, name='index'),]

Now point the root_URLconf at the newapps.urls module. In newsite/urls.py, import Django.urls.include and insert an include() in the urlpatterns list.

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('newapps/', include('newapps.urls')),
    path('admin/', admin.site.urls),]

ORM that is Object-Relational Mapping is a programming technique to convert data between the relational database and object-oriented programming languages such as Java, C#, etc. ORM maps database entities to Python code usually classes. You can construct your query in Python and it gets translated to SQL behind the scene.

For example instead of this SQL query -

SELECT * FROM <TABLE NAME>

you can use -

users = User.objects.all()

In SQL you have to execute that query using a driver, parse the result and then access the columns, but here ORM is doing that for you. That makes things easier and faster to use.

The most powerful feature of Django is its object-Relational Mapper that enables you to interact with the database.

Let us see the advantages of ORM -

1. You can write in the language you are familiar with.
2. It abstracts away the database system so that switching the backend database easy without any worry.
3. You get a lot of advanced features such as support for transactions, connection pooling, migrations, seeds, etc. depending on the ORM
4. Cache management, Entities are cached in memory thus reducing the load on the database.
5. Key management, Identifiers and surrogate keys automatically propagate and manage.
6. Multiple users can update the same data simultaneously.
7. Data loads are configurable and allow you to load appropriate data for each scenario.
8. You can navigate object relationships transparently, related objects automatically load when required.
9. ORM tools provide an object-oriented query language that allows developers to focus on the object model without worrying about database structure or SQL semantics.

“Django REST framework is a powerful and flexible toolkit used for building Web APIs”. Django REST Framework application easily a REST API into existing Django functionality and allows you to list all your API endpoints that inherit from Django REST Framework automatically. Django REST Framework is very easy to build model-backed APIs that have authentication policies and are browsable.

The purpose of the Django REST Framework is to work out of the box and it should take the minimum to install it. The REST framework is a funded project. 

Some of the reasons why you should use the REST framework are :

• For developers, the Web browsable API is huge usability.
• Authentication policies including packages for OAuth1a and OAuth2.
• Serialization for both ORM and non-ORM data sources.
• Customizable - just use regular function-based views.
• Extensive documentation, along with great community support.
• Used and trusted by internationally recognized companies.

Below is the REST framework requirement-

• Python  - 3.5, 3.6, 3.7
• Django  - 1.11, 2.0, 2.1, 2.2

By default there are four main authentication methods are available -

1. SessionAuthentication - This authentication scheme uses Django's default session backend for authentication and it is appropriate for AJAX clients that are running in the same session context as your website.

If authentication is successful, it provides the following credentials -

• request.user - Django User instance.
• request.auth - none

Unauthenticated responses will result in an HTTP 403 Forbidden response.

2. BasicAuthentication - Basic authentication scheme uses HTTP Basic Authentication that is signed against a user's username and password. BasicAuthentication is appropriate for testing.

If authentication is successful, it provides the following credentials -

• request.user - Django User instance.
• request.auth - None

Unauthenticated responses will result in an HTTP 401 Unauthorized response with an appropriate WWW-Authenticate header. 

3. TokenAuthentication - TokenAuthentication scheme uses a simple token-based HTTP authentication scheme and is suitable for client-server setups like native desktop or mobile client.

If authentication is successful, TokenAuthentication provides the following credentials.

• request.user - a Django User instance.
• request.auth - a rest_framework.authtoken.models.Token instance.

Unauthenticated responses will result in an HTTP 401 Unauthorized response with an appropriate WWW-Authenticate header.

4. RemoteUserAuthentication - RemoteUserAuthentication scheme allows you to delegate authentication to your web server which sets the REMOTE_USERenvironment variable.

If authentication is successful, RemoteUserAuthentication providese following credentials -

• request.user - Django User instance.
• request.auth - None

In web application storing and retrieving information in the database is a common task. To perform these requirements Django comes with database management features. These features allow two things, one is, design database schema and second is, manage the data in the database that is read, write, update, delete, query, etc.

• Django DB toolset is referred to as an object-relational mapper that is ORM.
• Using Python classes database tables are created.
• It is logical that fields are class attributes since tables are created as classes.
• Classes are created in the models.py file. While creating a Django app, by default models.py file is created.

In Django, database tables are called models and these models are created in the models.py file which is located in the Dango app directory. A model is a python class. While defining model you need to give a class name, subclass it from Django's included models. Model class.

from Django.db import models
class Glass(models.Model):

The model is valid only if it has one or more fields. Fields can be created by adding the attribute to the model class.

from django.db import models

class Bottle(models.Model):
    size = models.IntegerField()
    color = models.CharField(max_length=100)

Here field name is 'size' and 'color'. models.IntegerField() is the instance for field class, and you are telling the database what kind of data you want to save in the field.

In the Django template, we can use the request processor to get the URL.

If you want to request a variable in the template, make sure you add 'django.template.context_processors.request' in your 'context_processors' settings. Also, do not forget to add other context processors you used in your application.

Till Django 1.9 version, by default, it comes configured. Default Template configuration is -

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        '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',
            ],
        },
    },
]

Use below line of code to get current path :

 {{ request.path }}

Use below line of code to get current path with querystring:

  {{ request.get_full_path }}

Use below line of code get Domain, path and querystring:

  {{ request.build_absolute_uri }}

For example, suppose your URL is  http://127.0.0.1:8000/home/?q=test

• request.path will give you output /home/
• request.get_full_path will give you output /home/?q=test
• request.build_absolute_uri will give you output http://127.0.0.1:8000/home/?q=test

A simple way to create a user sign up is by using the UserCreationForm.  Django provides a form 'UserCreationForm' inherited from ModelForm class to handle new user creation. The user creation form has three fields username, password1, and password2. Password2 is for password confirmation.

First, you have to import UserCreationForm to use it from django.contrib.auth.forms import UserCreationForm To handle the creation of users, Django does not provide any view, we have to create our own view.

So proceeding further to create user, here we are using project myproject and application myapp. To create user fist update urlpattern at the beginning of the urlpatterns list. Then create a new function in views.py to authenticate and save the user. The last step is to create an HTML template for the form display(view).

The User created, using 'UserCreationForm will have is_superuser and is_staff flag set to false but is_active flag set to True. UserCreationForm does not have an email field, so we can't email verification to the user to verify the account.

Session data is stored on the server. Django creates a random unique string called session-id or SID and Django associates that ID or SID with the data. As a value to the browser, the server sends a cookie named session-id containing SID as value. On-page request, the browser sends a request containing a cookie with SID to the server. To retrieve this session data and make it accessible in code, Django uses this SID. Django generated SID is 32 characters long random string. Django support for anonymous sessions. Django session framework allows to store and retrieve arbitrary data on per site visitor basis. 

Seesions are implemented via middleware. To enable session functionality, edit MIDDLEWARE_CLASSES setting and make sure 'django.contrib.sessions.middleware.SessionMiddleware' is added.

Set the SESSION_ENGINE setting to "django.contrib.sessions.backends.file" to use file-based sessions. Also, set the SESSION_FILE_PATH setting to configure where Django store session files.

No, Django is not a Content Management System (CMS), rather it is a Web application framework and a programming tool that helps you to build websites.

DjangoCMS is a web publishing platform built with Django and offers out of the box support for the common features you expect from a CMS. Django CMS can be easily customized and extended by developers to create a site precise to their needs.

Django CMS is a thoroughly tested platform that supports both large and small web sites. Django CMS is robust internationalization support for creating multilingual sites. It can be configured to handle different requirements. Content editing is possible and provides rapid access to the content management interface. Django CMS supports a variety of editors with advanced text editing features. It is a flexible plugins system. Thorough documentation is available for Django CMS. Each published CMS page exists at two instances public and drat. An only draft version exists till you publish it.

A Mixin is a special type of inheritance in Python. It is gaining a big rise in Django / Web Application Development. Mexin can be used to allow classes in Python to share methods between any class that inherits from that Mixin.

A mixin or mix-in is a class that contains methods for use by other classes without having to be the parent class of those other classes.  Sometimes Mixins are described as "included" rather than "inherited".

Django provides a number of mixins that provide more discrete functionality.  Different type of mixins are -

Simple mixins are -

• ContextMixin - A dictionary to include in the context and is a convenient way of specifying the simple context in as_view().
• TemplateResponseMixin - Given a suitable context, TemplateResponseMixin provides a mechanism to construct a TemplateRespons and the template to use is configurable and can be further customized by a subclass.
• SingleObjectMixin - SingleObjetMixin provides a mechanism for looking up an object associated with the current HTTP request.
• SingleObjectTemplateMixin - SingleObjetTemplateMixin performs template base response rendering for view that operate upon a single object instance. 
• MutlipleObjectMixin - MultipleObjectMixin used to display list of objects

In Django, migrations are a way of propagating changes made in the model into the database schema. Django migrations can be created manually by running certain commands, but migrations automate the task of applying changes to the database. Django Migrations can be used as a version control system for database and Model. Migration keeps track of changes done in application Models/Table like adding a field, deleting a model, etc. Automatically generated migrations are used to apply changes to the database schema and to apply changes in data, you need to manually write the data migrations. Migrations in Django are stored as an on-disk format, referred to as “migration files”. These files are just like normal Python files with an agreed-upon object layout, written in a declarative style. Below is the format of a basic migration file:

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [('migrations', '0001_initial')]

    operations = [
        migrations.DeleteModel('Tribble'),
        migrations.AddField('Author', 'rating', models.IntegerField(default=0)),
    ]

To leverage MongoDB from Django, the following software should be installed and running -

Python
MongoDB
Django-norel - a version of Django designed for use with non-relational database engines
Django toolbox - Django-MongoDB engine depends on this general-purpose utility library
MongoDB-engine - MongoDB driver for Django

1. Create a project named 'testproj' with an application named 'testapp'.
django-admin.py startproject testproj
CD testproj/
django-admin.py startapp testapp

2. Setup - Configure following in settings.py

DATABASES = {  
        'default': {  
            'ENGINE': 'django_mongodb_engine',  
            'NAME': 'testdatabase',  
            'USER': '',  
            'PASSWORD': '',  
            'HOST': 'localhost',  
            'PORT': '27017',  
            'SUPPORTS_TRANSACTIONS': False,  
        },  
    }  

3. Update models.py

   from django.db import models  
    class Article(models.Model):  
    title = models.CharField(max_length = 64)  
    content = models.TextField()

4. Save - Save model data from a Django view.

from django.http import HttpResponse  
from models import *  

  def testview(request):  
  article = Article(title = 'test title',  
  content = 'test content'
  article.save()  

  return HttpResponse("<h1>Saved!</h1>")

5. Execute javascript query like from Django view to check connection-
db.testapp_article.find()

6. Query MongoDB from Django to retrieve a list
articles = Article.objects.all()