Django Noes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "worthy-promise",
   "metadata": {},
   "source": [
    "#  * Django Flask Theory *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "south-meeting",
   "metadata": {},
   "source": [
    "*****"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "headed-jackson",
   "metadata": {},
   "source": [
    "# Model Manager "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abandoned-telephone",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "* A Manager is the interface through which\n",
    "database query operations are provided to \n",
    "Django models. At least one Manager exists\n",
    "for every model in a Django application.\n",
    "Model manager is used to interact with database. \n",
    "By default, Django adds a Manager with the name\n",
    "objects to every Django model class.\n",
    "djanga.db.models.manager.Manager \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "corresponding-comparative",
   "metadata": {},
   "source": [
    "# signals "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bacterial-emission",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "* The signals are utilities that allow us to associate events with actions.\n",
    "Signals allow certain senders to notify a set of receivers that some action \n",
    "has taken place.\n",
    "* \n",
    "• Login and Logout Signals \n",
    "• Model Signals \n",
    "• Management Signals\n",
    "• Request/Response Signals \n",
    "• Test Signals \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "social-cedar",
   "metadata": {},
   "source": [
    "# Abstract Base Classes "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enhanced-helen",
   "metadata": {},
   "source": [
    "\n",
    "* Abstract base classes are useful when you want to put some common information \n",
    "into a number of other models. You write your base class and put abstract—True \n",
    "in the Meta class. This model will then not be used to create any database table.\n",
    "Instead, when it is used m a base class for other models, its fields will be \n",
    "added to those of the child elms. It does not generate a database table or \n",
    "have a manager, and cannot be instantiated or saved directly. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aggregate-voluntary",
   "metadata": {},
   "source": [
    "# JSON Web Token (JWT) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suspected-range",
   "metadata": {},
   "source": [
    "\n",
    "* JSON Web Token is a fairly new standard which can be used for token-based \n",
    "authentication. Unlike the built-in TokenAuthentication scheme, \n",
    "JWT Authentication doesn't need to use a database to validate a token. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "architectural-makeup",
   "metadata": {},
   "source": [
    "# User Authentication System"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "frozen-literacy",
   "metadata": {},
   "source": [
    "\n",
    "* Django comes with a user authentication system. It handles user accounts, groups, permissions and cookie-based user sessions. Django authentication provides both authentication and authorization together and is generally referred to as the authentication system. By default, the required configuration is already included in the settings.py generated by django-admin startproject, these consist of two items listed in your INSTALLED_APPS setting: 'django.contrib.auth' contains the core of the authentication framework, and its default models. 'django.contrib.contenttypes' is the Django content type system, which allows permissions to be associated with models you create. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "retired-background",
   "metadata": {},
   "source": [
    "# What's the Difference Between HTTP and HTTPS? "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "professional-manual",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "* HTTP \n",
    "✓ HTTP stands for Hyper Text Transfer Protocol. \n",
    "✓ HTTP is less secure. ✓ HTTP works in the application layer of 051 model. ✓ HTTP does not uses certificate. ✓ There is no encryption and decryption. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "threatened-mustang",
   "metadata": {},
   "source": [
    "\n",
    "* HTTPs \n",
    "✓ HTTPs stands for Hyper Text Transfer Protocol Secure. \n",
    "✓ HTTPs is more secure. ✓ HTTPs works in the transport layer of OSI model. ✓ HTTPs uses SSL certificate. ✓ There is encryption and decryption "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fitting-resolution",
   "metadata": {},
   "source": [
    "#  Cookies  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vulnerable-yield",
   "metadata": {},
   "source": [
    "\n",
    "* A cookie is a small piece of text data set by Web server that resided on the client's machine. Once it's been set, the client automatically returns the cookie to the web server with each request that it makes. This allows the server to place value it wishes to 'remember' in the cookie, and have access to them when creating a response. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "military-stewart",
   "metadata": {},
   "source": [
    "# Session "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exempt-shelter",
   "metadata": {},
   "source": [
    "* The session framework lets you store and retrieve arbitrary data on a per-site-visitor basis. It stores data on the server side and abstracts the sending and receiving of cookies. Cookies contain a session ID not the data itself. By default, Django stores sessions in your database. As it stores sessions in database so it is mandatory to run makemigmtions and migrate to use session. It will create required tables. The Django sessions framework is entirely, and solely, cookie-based. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "democratic-france",
   "metadata": {},
   "source": [
    "# Cache "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decreased-technology",
   "metadata": {},
   "source": [
    "\n",
    "* A Cache is an information technology for the temporary storage (caching) of Web documents, such as Web pages, images, and other types of Web multimedia, to reduce server lag. Caching is one of those methods which a website implements to become faster. It is cost efficient and saves CPU processing time. Django comes with a robust cache system that lets you save dynamic pages so they don't have to be calculated for each request. You can cache the output of specific views, you can cache only the pieces that are difficult to produce, or you can cache your entire site. Following are the options of caching:- • Database Caching • File System Caching • Local Memory Caching "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exposed-order",
   "metadata": {},
   "source": [
    "# Object Relational Mapper (ORM)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numeric-quality",
   "metadata": {},
   "source": [
    "* Object-Relational Mapper (ORM), which enables application to interact with database\n",
    "such as SQLite, MySQL, PostgreSQL, Oracle. ORMs automatically create a database schema \n",
    "from defined classes or models. It generate SQL from Python code for a particular \n",
    "database which means developer do not need to write SQL Code. ORM maps objects \n",
    "attributes to respective table fields. It is easier to change the database \n",
    "if we use ORMs hence project becomes more portable.\n",
    "Django's ORM is just a way to create SQL to query and manipulate your databasle \n",
    "and get results in a pythonic fashion. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae90f9df",
   "metadata": {},
   "source": [
    "# What Is The Difference Between select_related & prefetch_ related?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "132a43a0",
   "metadata": {},
   "source": [
    "* * select_related: \n",
    "* It Returns a QuerySet that will “follow” foreign-key relationships, selecting additional related-object when it executes its query.\n",
    "* This is a performance booster which results in a single more complex query but means later use of foreign-key relationships won’t require database queries.\n",
    "    \n",
    "* * prefetch_related:\n",
    "* We use prefetch_related when we’ 're going to get a set of things.\n",
    "* That means forward ManyToMany and backward ManyToMany, ForeignKey.  \n",
    "* prefetch_related does a separate lookup for each relationship and performs the “joining” in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c010f4a3",
   "metadata": {},
   "source": [
    "# Q.3 Django Default files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe760f9",
   "metadata": {},
   "source": [
    "* a) __ init__.py: An empty file that tells Python that the current directory should be considered as a Python package.\n",
    "* b) admin.py: Reads model metadata and provides an interface to manage app content\n",
    "* c) app.py: Application configuration details for the app are included e.g custom app name.\n",
    "* d) migrations.py: Contains migrated model details with the corresponding database table structure\n",
    "* e) models.py: A class for each model is defined with the model structure layout\n",
    "* f) tests.py: App unit test automation classes are included in this\n",
    "* g) views.py: Web-based requests and response is configured in this file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb1b16e",
   "metadata": {},
   "source": [
    "# Explain The Migration In Django."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f59feae",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "There are several commands you use to interact with Migrations In Django:\n",
    "* a) makemigration - This command is used to create a migration file.\n",
    "* b) migrate - This command creates a table according to the schema defined in the migration file.\n",
    "* c) showmigrations - This command list all the migrations and their status.\n",
    "* d) sqlmigrate - This command is used to show a raw SQL query of the applied migration.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca870557",
   "metadata": {},
   "source": [
    "# How to setup a database in Django?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10284ec3",
   "metadata": {},
   "source": [
    "* In the case of other databases you have to the following keys in the DATABASE ‘default’ item to match your database connection settings.\n",
    "* Engines: you can change database by using ‘django.db.backends.sqlite3’ , ‘django.db.backeneds.mysql’,\n",
    "* * ‘django.db.backends.postgresql_psycopg2’, ‘django.db.backends.oracle’ and so on\n",
    "* * 'ENGINE': 'django.db.backends.postgresql_psycopg2',\n",
    "* Now we should replace the above code with our connection credentials to Mysql. The updated code should look like the code below.\n",
    "* * {'default': {'ENGINE': 'django.db.backends.postgresql_psycopg2'}}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb891d64",
   "metadata": {},
   "source": [
    "# What do u mean by CSRF token?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcbb0549",
   "metadata": {},
   "source": [
    "* CSRF stands for Cross-Site Request Forgery.\n",
    "* The csrf_token is used for protection against Cross-Site Request Forgeries.\n",
    "* This kind of attack takes place when a malicious website consists of a link, some JavaScript or a form whose aim is to perform some action on your website by using the login credentials of a genuine user.\n",
    "* CSRF tokens can prevent CSREF attacks by making it impossible for an attacker to construct a fully valid HTTP request suitable for feeding to a victim user.\n",
    "* A CSRF token is a unique, secret, unpredictable value that is generated by the server-side application and transmitted to the client in such a way that it is included in a subsequent HTTP request made by the client.\n",
    "* When the later request is made, the server-side application validates that the request includes the expected token and rejects the request if the token is missing or invalid.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb64940",
   "metadata": {},
   "source": [
    "# whar are the Limitation of Django ORM?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb975d9c",
   "metadata": {},
   "source": [
    "* If the data is complex and consists of multiple joins using the SQL will be clearer.\n",
    "* If Performance is a concern for you, ORM isn’t your choice.\n",
    "* Generally. Object-relation-mapping is considered a good option to construct an optimized query, SQL has an upper hand when compared to ORM.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77cee1fb",
   "metadata": {},
   "source": [
    "# What is QuerySet in Django ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "486698ef",
   "metadata": {},
   "source": [
    "\n",
    "* QuerySet is a collection of SQL queries.\n",
    "* QuerySet in Django is basically a collection of objects from our database.\n",
    "* QuerySets are used by the Django ORM. When we use our models to get a single record or a group of records from the database, they are returned as QuerySets.\n",
    "* It is comparable to a database select operation.\n",
    "\n",
    "Ex\n",
    "* users.objects.all()\n",
    "* users.objects.filter(name=\"nitin\")\n",
    "* users.objects.get(id=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6a6cef5",
   "metadata": {},
   "source": [
    "# What Is The Command To Create A Project & An App In Django?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b16e63db",
   "metadata": {},
   "source": [
    "* Command To Create A Project: django-admin startproject ProjectAshish\n",
    "* Command To Create An App: python manage.py startapp AppAshish"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b530796a",
   "metadata": {},
   "source": [
    "# what is the Project Structure in Django?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c211044",
   "metadata": {},
   "source": [
    "* a) manage.py: A command-line utility that allows you to interact with your Django project & this file is used to control your Django project on the server or even to begin one.\n",
    "* b) ___init___.py: An empty file that tells Python that the current directory should be considered as a Python package\n",
    "* c) settings.py: Comprises the configurations of the current project like DB connections, middlewares etc \n",
    "* d) urls.py: All the URLs of the project are present here \n",
    "* e) wsgi.py: This is an entry point for your application which is used by the web servers to serve the project you have created\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a380eded",
   "metadata": {},
   "source": [
    "# What Is The Difference Between Flask, Pyramid And Django?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec00a9c1",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "** Django\n",
    "* Django is a high-level Python framework while Flask is a low-level Python Framework providing you with the minimum functionality, a server would require.\n",
    "* Django comes with lots of built-in functionality like Django ORM, Admin Panel, Web-templating System, Inheritance, and serialization while Flask comes with a development server, NoSQL support, and support for unit testing, which are already there in Django.\n",
    "\n",
    "** Flask\n",
    "* Flask is more customizable than Django as Flask comes with no predefined structure or scaffold while Django’s file structure is fixed.\n",
    "* Flask settings are user made and can be altered completely by the user. Django settings are not customizable to that degree, it has variables where only values are modifiable.\n",
    "* Flask has more speed than Django when it comes to processing requests but that comes without any APIs or functionality that Django gives you in-built.\n",
    "* Flask is for the developers who want more flexibility on their website and don’t need lots of built-in extra functions, while Django is for developers who want rapid development of their applications that can sustain dynamic changes to their environment.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d941d644",
   "metadata": {},
   "source": [
    "# what is Command to create a migration file inside the migration folder?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45624d84",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "* python manage.py makemigrations \n",
    "\n",
    "* After creating a migration to reflect changes in the database permanently execute migrate command:\n",
    "python manage.py migrate\n",
    "\n",
    "* To see raw SQL query executing behind applied migration execute the command:\n",
    "* * python manage.py sqlmigrate app_name migration_name\n",
    "* * python manage.py sqlmigrate nitapp 0001\n",
    "\n",
    "* To see all migrations, execute the command:\n",
    "* * python manage.py showmigrations \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0196cedb",
   "metadata": {},
   "source": [
    "# How To Filter Items In The Model Using Django QuerySet?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b296a065",
   "metadata": {},
   "source": [
    "\n",
    "* Django Command To Filter Items In A Model:\n",
    "* Users.objects.filter(name=\"Nitin\")\n",
    "***?** where “User” is a model name\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65fcc27d",
   "metadata": {},
   "source": [
    "# How To Get A Particular Item In The Model Using Django QuerySet?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc1f2cbe",
   "metadata": {},
   "source": [
    "* Django Command To Get A Particular Item In A Model:\n",
    "\n",
    "* * Users.objects.get(id=25)\n",
    "\n",
    "***?** where “User” is a model name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47e392a7",
   "metadata": {},
   "source": [
    "# How to Delete/Insert/Update An Object Using QuerySet In Django?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ecd6d44",
   "metadata": {},
   "source": [
    "* * QuerySet To Update An Object:\n",
    "    \n",
    "* user_to_be_modify = User.objects.get(pk = 3)\n",
    "* user_to_be_modify.city = \"Pune\"\n",
    "* user_to_be_modify.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a260218",
   "metadata": {},
   "source": [
    "# How to Delete/Insert/Update An Object Using QuerySet In Django?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8645040a",
   "metadata": {},
   "source": [
    "* Users. objects.filter(id= 54).delete()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92a1654b",
   "metadata": {},
   "source": [
    "# How to Delete/Insert/Update An Object Using QuerySet In Django?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "149ce02a",
   "metadata": {},
   "source": [
    "* new_user = User(name = \"Nitin Mangotra\", city=\"Gurgaon\")\n",
    "* new_user.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34474492",
   "metadata": {},
   "source": [
    "*****"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}