8-project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Django UnChained\n",
    "\n",
    "<img src=\"images/django.jpg\">\n",
    "\n",
    "# Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name \"git\" was given by Linus Torvalds when he wrote the very\n",
    "first version. He described the tool as \"the stupid content tracker\"\n",
    "and the name as (depending on your way):\n",
    "\n",
    " - random three-letter combination that is pronounceable, and not actually used by any common UNIX command. The fact that it is a mispronunciation of \"get\" may or may not be relevant.\n",
    " - stupid. contemptible and despicable. simple. Take your pick from the dictionary of slang.\n",
    " - \"global information tracker\": you're in a good mood, and it actually works for you. Angels sing, and a light suddenly fills the room.\n",
    " - \"goddamn idiotic truckload of shit\": when it breaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a href=\"https://git-cola.github.io/downloads.html\">git cola</a>  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arch \t» \tyaourt -S git-cola\n",
    "debian \t» \tapt-get install git-cola\n",
    "fedora \t» \tyum install git-cola\n",
    "gentoo \t» \temerge git-cola\n",
    "opensuse» \tuse the one-click install link\n",
    "ubuntu \t» \tapt-get install git-cola"
   ]
  },
    {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installing Django Framwork"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip3 install django"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "django-admin startproject locallibrary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the catalog application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "python manage.py startapp catalog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Registering the catalog application\n",
    "### tou must add your app config to django setting \n",
    "### 'app_name'.apps.'app_name'Config\n",
    "### we find funtion of app config in apps.py for part of three",
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "INSTALLED_APPS = [\n",
    "    'django.contrib.admin',\n",
    "    'django.contrib.auth',\n",
    "    'django.contrib.contenttypes',\n",
    "    'django.contrib.sessions',\n",
    "    'django.contrib.messages',\n",
    "    'django.contrib.staticfiles',\n",
    "    'catalog.apps.CatalogConfig', \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hooking up the URL mapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "urlpatterns += [\n",
    "    path('catalog/', include('catalog.urls')),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use static() to add url mapping to serve static files during development (only)\n",
    "from django.conf import settings\n",
    "from django.conf.urls.static import static\n",
    "\n",
    "urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing the website framework"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "python manage.py runserver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the LocalLibrary Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Genre(models.Model):\n",
    "    \"\"\"\n",
    "    Model representing a book genre (e.g. Science Fiction, Non Fiction).\n",
    "    \"\"\"\n",
    "    name = models.CharField(max_length=200, help_text=\"Enter a book genre (e.g. Science Fiction, French Poetry etc.)\")\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        String for representing the Model object (in Admin site etc.)\n",
    "        \"\"\"\n",
    "        return self.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.urls import reverse #Used to generate URLs by reversing the URL patterns\n",
    "\n",
    "class Book(models.Model):\n",
    "    \"\"\"\n",
    "    Model representing a book (but not a specific copy of a book).\n",
    "    \"\"\"\n",
    "    title = models.CharField(max_length=200)\n",
    "    author = models.ForeignKey('Author', on_delete=models.SET_NULL, null=True)\n",
    "    # Foreign Key used because book can only have one author, but authors can have multiple books\n",
    "    # Author as a string rather than object because it hasn't been declared yet in the file.\n",
    "    summary = models.TextField(max_length=1000, help_text=\"Enter a brief description of the book\")\n",
    "    isbn = models.CharField('ISBN',max_length=13, help_text='13 Character <a href=\"https://www.isbn-international.org/content/what-isbn\">ISBN number</a>')\n",
    "    genre = models.ManyToManyField(Genre, help_text=\"Select a genre for this book\")\n",
    "    # ManyToManyField used because genre can contain many books. Books can cover many genres.\n",
    "    # Genre class has already been defined so we can specify the object above.\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        String for representing the Model object.\n",
    "        \"\"\"\n",
    "        return self.title\n",
    "    \n",
    "    \n",
    "    def get_absolute_url(self):\n",
    "        \"\"\"\n",
    "        Returns the url to access a particular book instance.\n",
    "        \"\"\"\n",
    "        return reverse('book-detail', args=[str(self.id)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid # Required for unique book instances\n",
    "\n",
    "class BookInstance(models.Model):\n",
    "    \"\"\"\n",
    "    Model representing a specific copy of a book (i.e. that can be borrowed from the library).\n",
    "    \"\"\"\n",
    "    id = models.UUIDField(primary_key=True, default=uuid.uuid4, help_text=\"Unique ID for this particular book across whole library\")\n",
    "    book = models.ForeignKey('Book', on_delete=models.SET_NULL, null=True) \n",
    "    imprint = models.CharField(max_length=200)\n",
    "    due_back = models.DateField(null=True, blank=True)\n",
    "\n",
    "    LOAN_STATUS = (\n",
    "        ('m', 'Maintenance'),\n",
    "        ('o', 'On loan'),\n",
    "        ('a', 'Available'),\n",
    "        ('r', 'Reserved'),\n",
    "    )\n",
    "\n",
    "    status = models.CharField(max_length=1, choices=LOAN_STATUS, blank=True, default='m', help_text='Book availability')\n",
    "\n",
    "    class Meta:\n",
    "        ordering = [\"due_back\"]\n",
    "        \n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        String for representing the Model object\n",
    "        \"\"\"\n",
    "        return '%s (%s)' % (self.id,self.book.title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Author(models.Model):\n",
    "    \"\"\"\n",
    "    Model representing an author.\n",
    "    \"\"\"\n",
    "    first_name = models.CharField(max_length=100)\n",
    "    last_name = models.CharField(max_length=100)\n",
    "    date_of_birth = models.DateField(null=True, blank=True)\n",
    "    date_of_death = models.DateField('Died', null=True, blank=True)\n",
    "    \n",
    "    def get_absolute_url(self):\n",
    "        \"\"\"\n",
    "        Returns the url to access a particular author instance.\n",
    "        \"\"\"\n",
    "        return reverse('author-detail', args=[str(self.id)])\n",
    "    \n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        String for representing the Model object.\n",
    "        \"\"\"\n",
    "        return '%s, %s' % (self.last_name, self.first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the index page"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from .models import Book, Author, BookInstance, Genre\n",
    "\n",
    "def index(request):\n",
    "    \"\"\"\n",
    "    View function for home page of site.\n",
    "    \"\"\"\n",
    "    # Generate counts of some of the main objects\n",
    "    num_books=Book.objects.all().count()\n",
    "    num_instances=BookInstance.objects.all().count()\n",
    "    # Available books (status = 'a')\n",
    "    num_instances_available=BookInstance.objects.filter(status__exact='a').count()\n",
    "    num_authors=Author.objects.count()  # The 'all()' is implied by default.\n",
    "    \n",
    "    # Render the HTML template index.html with the data in the context variable\n",
    "    return render(\n",
    "        request,\n",
    "        'index.html',\n",
    "        context={'num_books':num_books,'num_instances':num_instances,'num_instances_available':num_instances_available,'num_authors':num_authors},\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TemplateView"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.views.generic.base import TemplateView\n",
    "\n",
    "from articles.models import Article\n",
    "\n",
    "class HomePageView(TemplateView):\n",
    "\n",
    "    template_name = \"home.html\"\n",
    "\n",
    "    def get_context_data(self, **kwargs):\n",
    "        context = super().get_context_data(**kwargs)\n",
    "        context['latest_articles'] = Article.objects.all()[:5]\n",
    "        return context"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The LocalLibrary base template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "<!DOCTYPE html>\n",
    "<html lang=\"en\">\n",
    "<head>\n",
    "  \n",
    "  {% block title %}<title>Local Library</title>{% endblock %}\n",
    "  <meta charset=\"utf-8\">\n",
    "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n",
    "  <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css\">\n",
    "  <script src=\"https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js\"></script>\n",
    "  <script src=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js\"></script>\n",
    "  \n",
    "  <!-- Add additional CSS in static file -->\n",
    "  {% load static %}\n",
    "  <link rel=\"stylesheet\" href=\"{% static 'css/styles.css' %}\">\n",
    "</head>\n",
    "\n",
    "<body>\n",
    "\n",
    "  <div class=\"container-fluid\">\n",
    "\n",
    "    <div class=\"row\">\n",
    "      <div class=\"col-sm-2\">\n",
    "      {% block sidebar %}\n",
    "      <ul class=\"sidebar-nav\">\n",
    "          <li><a href=\"{% url 'index' %}\">Home</a></li>\n",
    "          <li><a href=\"\">All books</a></li>\n",
    "          <li><a href=\"\">All authors</a></li>\n",
    "      </ul>\n",
    "     {% endblock %}\n",
    "      </div>\n",
    "      <div class=\"col-sm-10 \">\n",
    "      {% block content %}{% endblock %}\n",
    "      </div>\n",
    "    </div>\n",
    "\n",
    "  </div>\n",
    "</body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CSS styles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ".sidebar-nav {\n",
    "    margin-top: 20px;\n",
    "    padding: 0;\n",
    "    list-style: none;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The index template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "<h1>Local Library Home</h1>\n",
    "\n",
    "  <p>Welcome to <em>LocalLibrary</em>, a very basic Django website </p>\n",
    "\n",
    "<h2>Dynamic content</h2>\n",
    "\n",
    "  <p>The library has the following record counts:</p>\n",
    "  <ul>\n",
    "    <li><strong>Books:</strong> {{ num_books }}</li>\n",
    "    <li><strong>Copies:</strong> {{ num_instances }}</li>\n",
    "    <li><strong>Copies available:</strong> {{ num_instances_available }}</li>\n",
    "    <li><strong>Authors:</strong> {{ num_authors }}</li>\n",
    "  </ul>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Book List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookListView(generic.ListView):\n",
    "    model = Book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookListView(generic.ListView):\n",
    "    model = Book\n",
    "    context_object_name = 'my_book_list'   # your own name for the list as a template variable\n",
    "    queryset = Book.objects.filter(title__icontains='war')[:5] # Get 5 books containing the title war\n",
    "    template_name = 'books/my_arbitrary_template_name_list.html'  # Specify your own template name/location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookListView(generic.ListView):\n",
    "    model = Book\n",
    "\n",
    "    def get_queryset(self):\n",
    "        return Book.objects.filter(title__icontains='war')[:5] # Get 5 books containing the title war"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookListView(generic.ListView):\n",
    "    model = Book\n",
    "\n",
    "    def get_context_data(self, **kwargs):\n",
    "        # Call the base implementation first to get a context\n",
    "        context = super(BookListView, self).get_context_data(**kwargs)\n",
    "        # Get the blog from id and add it to the context\n",
    "        context['some_data'] = 'This is just some data'\n",
    "        return context"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# book_list HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "    <h1>Book List</h1>\n",
    "\n",
    "    {% if book_list %}\n",
    "    <ul>\n",
    "\n",
    "      {% for book in book_list %}\n",
    "      <li>\n",
    "        <a href=\"{{ book.get_absolute_url }}\">{{ book.title }}</a> ({{book.author}})\n",
    "      </li>\n",
    "      {% endfor %}\n",
    "\n",
    "    </ul>\n",
    "    {% else %}\n",
    "      <p>There are no books in the library.</p>\n",
    "    {% endif %}       \n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Book detail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookDetailView(generic.DetailView):\n",
    "    model = Book"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# book_detail HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "  <h1>Title: {{ book.title }}</h1>\n",
    "\n",
    "  <p><strong>Author:</strong> <a href=\"\">{{ book.author }}</a></p> <!-- author detail link not yet defined -->\n",
    "  <p><strong>Summary:</strong> {{ book.summary }}</p>\n",
    "  <p><strong>ISBN:</strong> {{ book.isbn }}</p> \n",
    "  <p><strong>Language:</strong> {{ book.language }}</p>  \n",
    "  <p><strong>Genre:</strong> {% for genre in book.genre.all %} {{ genre }}{% if not forloop.last %}, {% endif %}{% endfor %}</p>  \n",
    "\n",
    "  <div style=\"margin-left:20px;margin-top:20px\">\n",
    "    <h4>Copies</h4>\n",
    "\n",
    "    {% for copy in book.bookinstance_set.all %}\n",
    "    <hr>\n",
    "    <p class=\"{% if copy.status == 'a' %}text-success{% elif copy.status == 'm' %}text-danger{% else %}text-warning{% endif %}\">{{ copy.get_status_display }}</p>\n",
    "    {% if copy.status != 'a' %}<p><strong>Due to be returned:</strong> {{copy.due_back}}</p>{% endif %}\n",
    "    <p><strong>Imprint:</strong> {{copy.imprint}}</p>\n",
    "    <p class=\"text-muted\"><strong>Id:</strong> {{copy.id}}</p>\n",
    "    {% endfor %}\n",
    "  </div>\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "urlpatterns = [\n",
    "    url(r'^$', views.index, name='index'),\n",
    "    url(r'^books/$', views.BookListView.as_view(), name='books'),\n",
    "    url(r'^book/(?P<pk>\\d+)$', views.BookDetailView.as_view(), name='book-detail'),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Admin Page"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@admin.register(BookInstance)\n",
    "class BookInstanceAdmin(admin.ModelAdmin):\n",
    "    list_filter = ('status', 'due_back')\n",
    "    \n",
    "    fieldsets = (\n",
    "        (None, {\n",
    "            'fields': ('book', 'imprint', 'id')\n",
    "        }),\n",
    "        ('Availability', {\n",
    "            'fields': ('status', 'due_back')\n",
    "        }),\n",
    "    )\n",
    "\n",
    "\n",
    "class BooksInstanceInline(admin.TabularInline):\n",
    "    model = BookInstance\n",
    "\n",
    "@admin.register(Book)\n",
    "class BookAdmin(admin.ModelAdmin):\n",
    "    list_display = ('title', 'author', 'display_genre')\n",
    "    inlines = [BooksInstanceInline]\n",
    "    \n",
    "class AuthorAdmin(admin.ModelAdmin):\n",
    "    list_display = ('last_name', 'first_name', 'date_of_birth', 'date_of_death')\n",
    "    fields = ['first_name', 'last_name', ('date_of_birth', 'date_of_death')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_genre(self):\n",
    "    \"\"\"\n",
    "    Creates a string for the Genre. This is required to display genre in Admin.\n",
    "    \"\"\"\n",
    "    return ', '.join([ genre.name for genre in self.genre.all()[:3] ])\n",
    "\n",
    "display_genre.short_description = 'Genre'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enabling authentication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "INSTALLED_APPS = [\n",
    "    ...\n",
    "    'django.contrib.auth',  #Core authentication framework and its default models.\n",
    "    'django.contrib.contenttypes',  #Django content type system (allows permissions to be associated with models).\n",
    "    ....\n",
    "    \n",
    "\n",
    "MIDDLEWARE = [\n",
    "    ...\n",
    "    'django.contrib.sessions.middleware.SessionMiddleware',  #Manages sessions across requests\n",
    "    ...\n",
    "    'django.contrib.auth.middleware.AuthenticationMiddleware',  #Associates users with requests using sessions.\n",
    "    ...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.models import User\n",
    "\n",
    "# Create user and save to the database\n",
    "user = User.objects.create_user('myusername', 'myemail@crazymail.com', 'mypassword')\n",
    "\n",
    "# Update fields and then save again\n",
    "user.first_name = 'John'\n",
    "user.last_name = 'Citizen'\n",
    "user.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up your authentication views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Add Django site authentication urls (for login, logout, password management)\n",
    "urlpatterns += [\n",
    "    url(r'^accounts/', include('django.contrib.auth.urls')),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Template directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Using engine django:\n",
    "\n",
    "    django.template.loaders.app_directories.Loader: /home/pd/djangoEnv/lib/python3.5/site-packages/django/contrib/admin/templates/registration/login.html (Source does not exist)\n",
    "    django.template.loaders.app_directories.Loader: /home/pd/djangoEnv/lib/python3.5/site-packages/django/contrib/auth/templates/registration/login.html (Source does not exist)\n",
    "    django.template.loaders.app_directories.Loader: /home/pd/Desktop/locallibrary/catalog/templates/registration/login.html (Source does not exist)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEMPLATES = [\n",
    "    {\n",
    "        ...\n",
    "        'DIRS': ['./templates',],\n",
    "        'APP_DIRS': True,\n",
    "        ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# login html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "\n",
    "{% if form.errors %}\n",
    "<p>Your username and password didn't match. Please try again.</p>\n",
    "{% endif %}\n",
    "\n",
    "{% if next %}\n",
    "    {% if user.is_authenticated %}\n",
    "    <p>Your account doesn't have access to this page. To proceed,\n",
    "    please login with an account that has access.</p>\n",
    "    {% else %}\n",
    "    <p>Please login to see this page.</p>\n",
    "    {% endif %}\n",
    "{% endif %}\n",
    "\n",
    "<form method=\"post\" action=\"{% url 'login' %}\">\n",
    "{% csrf_token %}\n",
    "\n",
    "<div>\n",
    "  <td>{{ form.username.label_tag }}</td>\n",
    "  <td>{{ form.username }}</td>\n",
    "</div>\n",
    "<div>\n",
    "  <td>{{ form.password.label_tag }}</td>\n",
    "  <td>{{ form.password }}</td>\n",
    "</div>\n",
    "\n",
    "<div>\n",
    "  <input type=\"submit\" value=\"login\" />\n",
    "  <input type=\"hidden\" name=\"next\" value=\"{{ next }}\" />\n",
    "</div>\n",
    "</form>\n",
    "\n",
    "{# Assumes you setup the password_reset view in your URLconf #}\n",
    "<p><a href=\"{% url 'password_reset' %}\">Lost password?</a></p>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# logged_out html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "<p>Logged out!</p>  \n",
    "\n",
    "<a href=\"{% url 'login'%}\">Click here to login again.</a>\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# password_reset_form html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "{% block content %}\n",
    "\n",
    "<form action=\"\" method=\"post\">{% csrf_token %}\n",
    "    {% if form.email.errors %} {{ form.email.errors }} {% endif %}\n",
    "        <p>{{ form.email }}</p> \n",
    "    <input type=\"submit\" class=\"btn btn-default btn-lg\" value=\"Reset password\" />\n",
    "</form>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# password_reset_done html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "{% block content %}\n",
    "<p>We've emailed you instructions for setting your password. If they haven't arrived in a few minutes, check your spam folder.</p>\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# password_reset_email html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Someone asked for password reset for email {{ email }}. Follow the link below:\n",
    "{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# password_reset_confirm html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "\n",
    "    {% if validlink %}\n",
    "        <p>Please enter (and confirm) your new password.</p>\n",
    "        <form action=\"\" method=\"post\">\n",
    "            <div style=\"display:none\">\n",
    "                <input type=\"hidden\" value=\"{{ csrf_token }}\" name=\"csrfmiddlewaretoken\">\n",
    "            </div>\n",
    "            <table>\n",
    "                <tr>\n",
    "                    <td>{{ form.new_password1.errors }}\n",
    "                        <label for=\"id_new_password1\">New password:</label></td>\n",
    "                    <td>{{ form.new_password1 }}</td>\n",
    "                </tr>\n",
    "                <tr>\n",
    "                    <td>{{ form.new_password2.errors }}\n",
    "                        <label for=\"id_new_password2\">Confirm password:</label></td>\n",
    "                    <td>{{ form.new_password2 }}</td>\n",
    "                </tr>\n",
    "                <tr>\n",
    "                    <td></td>\n",
    "                    <td><input type=\"submit\" value=\"Change my password\" /></td>\n",
    "                </tr>\n",
    "            </table>\n",
    "        </form>\n",
    "    {% else %}\n",
    "        <h1>Password reset failed</h1>\n",
    "        <p>The password reset link was invalid, possibly because it has already been used. Please request a new password reset.</p>\n",
    "    {% endif %}\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# password_reset_complete html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "{% block content %}\n",
    "\n",
    "<h1>The password has been changed!</h1>\n",
    "<p><a href=\"{% url 'login' %}\">log in again?</a></p>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Login"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Redirect to home URL after login (Default redirects to /accounts/profile/)\n",
    "LOGIN_REDIRECT_URL = '/'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# {{ user }}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "<ul class=\"sidebar-nav\">\n",
    "\n",
    "    ...\n",
    "\n",
    "   {% if user.is_authenticated %}\n",
    "     <li>User: {{ user.get_username }}</li>\n",
    "     <li><a href=\"{% url 'logout'%}?next={{request.path}}\">Logout</a></li>   \n",
    "   {% else %}\n",
    "     <li><a href=\"{% url 'login'%}?next={{request.path}}\">Login</a></li>   \n",
    "   {% endif %} \n",
    "  </ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# access restricting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.decorators import login_required\n",
    "\n",
    "@login_required\n",
    "def my_view(request):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyView(LoginRequiredMixin, View):\n",
    "    login_url = '/login/'\n",
    "    redirect_field_name = 'redirect_to'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# listing the current user's books"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.models import User\n",
    "\n",
    "class BookInstance:\n",
    "    borrower = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "@property\n",
    "def is_overdue(self):\n",
    "    if self.due_back and date.today() > self.due_back:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@admin.register(BookInstance)\n",
    "class BookInstanceAdmin(admin.ModelAdmin):\n",
    "    list_display = ('book', 'status', 'borrower', 'due_back', 'id')\n",
    "    list_filter = ('status', 'due_back')\n",
    "    \n",
    "    fieldsets = (\n",
    "        (None, {\n",
    "            'fields': ('book','imprint', 'id')\n",
    "        }),\n",
    "        ('Availability', {\n",
    "            'fields': ('status', 'due_back','borrower')\n",
    "        }),\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.mixins import LoginRequiredMixin\n",
    "\n",
    "class LoanedBooksByUserListView(LoginRequiredMixin,generic.ListView):\n",
    "    \"\"\"\n",
    "    Generic class-based view listing books on loan to current user. \n",
    "    \"\"\"\n",
    "    model = BookInstance\n",
    "    template_name ='catalog/bookinstance_list_borrowed_user.html'\n",
    "    paginate_by = 10\n",
    "    \n",
    "    def get_queryset(self):\n",
    "        return BookInstance.objects.filter(borrower=self.request.user).filter(status__exact='o').order_by('due_back')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "urlpatterns += [   \n",
    "    url(r'^mybooks/$', views.LoanedBooksByUserListView.as_view(), name='my-borrowed'),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "    <h1>Borrowed books</h1>\n",
    "\n",
    "    {% if bookinstance_list %}\n",
    "    <ul>\n",
    "\n",
    "      {% for bookinst in bookinstance_list %} \n",
    "      <li class=\"{% if bookinst.is_overdue %}text-danger{% endif %}\">\n",
    "        <a href=\"{% url 'book-detail' bookinst.book.pk %}\">{{bookinst.book.title}}</a> ({{ bookinst.due_back }})        \n",
    "      </li>\n",
    "      {% endfor %}\n",
    "    </ul>\n",
    "\n",
    "    {% else %}\n",
    "      <p>There are no books borrowed.</p>\n",
    "    {% endif %}       \n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "<ul class=\"sidebar-nav\">\n",
    "   {% if user.is_authenticated %}\n",
    "   <li>User: {{ user.get_username }}</li>\n",
    "   <li><a href=\"{% url 'my-borrowed' %}\">My Borrowed</a></li>\n",
    "   <li><a href=\"{% url 'logout'%}?next={{request.path}}\">Logout</a></li>   \n",
    "   {% else %}\n",
    "   <li><a href=\"{% url 'login'%}?next={{request.path}}\">Login</a></li>   \n",
    "   {% endif %} \n",
    " </ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Permissions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BookInstance(models.Model):\n",
    "    \n",
    "\n",
    "    class Meta:\n",
    "        permissions = ((\"can_mark_returned\", \"Set book as returned\"),)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# {{ perms }}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% if perms.catalog.can_mark_returned %}\n",
    "    <!-- We can mark a BookInstance as returned. -->\n",
    "    <!-- Perhaps add code to link to a \"book return\" view here. -->\n",
    "{% endif %}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.decorators import permission_required\n",
    "\n",
    "@permission_required('catalog.can_mark_returned')\n",
    "@permission_required('catalog.can_edit')\n",
    "def my_view(request):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.mixins import PermissionRequiredMixin\n",
    "\n",
    "class MyView(PermissionRequiredMixin, View):\n",
    "    permission_required = 'catalog.can_mark_returned'\n",
    "    # Or multiple permissions\n",
    "    permission_required = ('catalog.can_mark_returned', 'catalog.can_edit')\n",
    "    # Note that 'catalog.can_edit' is just an example\n",
    "    # the catalog application doesn't have such permission!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HTML Forms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "<form action=\"/team_name_url/\" method=\"post\">\n",
    "    <label for=\"team_name\">Enter name: </label>\n",
    "    <input id=\"team_name\" type=\"text\" name=\"name_field\" value=\"Default name for team.\">\n",
    "    <input type=\"submit\" value=\"OK\">\n",
    "</form>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The field's type attribute\n",
    "> defines what sort of widget will be displayed. \n",
    "\n",
    "The name and id of the field \n",
    "> are used to identify the field in JavaScript/CSS/HTML, \n",
    "\n",
    "value defines \n",
    "> the initial value for the field when it is first displayed.\n",
    "\n",
    "The matching team label \n",
    "> is specified using the label tag (see \"Enter name\" above), \n",
    "\n",
    "for field \n",
    "> containing the id value of the associated input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Renew-book form using a Form and function view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django import forms\n",
    "    \n",
    "class RenewBookForm(forms.Form):\n",
    "    renewal_date = forms.DateField(help_text=\"Enter a date between now and 4 weeks (default 3).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_<fieldname>()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# forms.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django import forms\n",
    "\n",
    "from django.core.exceptions import ValidationError\n",
    "from django.utils.translation import ugettext_lazy as _\n",
    "import datetime #for checking renewal date range.\n",
    "    \n",
    "class RenewBookForm(forms.Form):\n",
    "    renewal_date = forms.DateField(help_text=\"Enter a date between now and 4 weeks (default 3).\")\n",
    "\n",
    "    def clean_renewal_date(self):\n",
    "        data = self.cleaned_data['renewal_date']\n",
    "        \n",
    "        #Check date is not in past. \n",
    "        if data < datetime.date.today():\n",
    "            raise ValidationError(_('Invalid date - renewal in past'))\n",
    "\n",
    "        #Check date is in range librarian allowed to change (+4 weeks).\n",
    "        if data > datetime.date.today() + datetime.timedelta(weeks=4):\n",
    "            raise ValidationError(_('Invalid date - renewal more than 4 weeks ahead'))\n",
    "\n",
    "        # Remember to always return the cleaned data.\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.contrib.auth.decorators import permission_required\n",
    "\n",
    "from django.shortcuts import get_object_or_404\n",
    "from django.http import HttpResponseRedirect\n",
    "from django.core.urlresolvers import reverse\n",
    "import datetime\n",
    "\n",
    "from .forms import RenewBookForm\n",
    "\n",
    "@permission_required('catalog.can_mark_returned')\n",
    "def renew_book_librarian(request, pk):\n",
    "    \"\"\"\n",
    "    View function for renewing a specific BookInstance by librarian\n",
    "    \"\"\"\n",
    "    book_inst=get_object_or_404(BookInstance, pk = pk)\n",
    "\n",
    "    # If this is a POST request then process the Form data\n",
    "    if request.method == 'POST':\n",
    "\n",
    "        # Create a form instance and populate it with data from the request (binding):\n",
    "        form = RenewBookForm(request.POST)\n",
    "\n",
    "        # Check if the form is valid:\n",
    "        if form.is_valid():\n",
    "            # process the data in form.cleaned_data as required (here we just write it to the model due_back field)\n",
    "            book_inst.due_back = form.cleaned_data['renewal_date']\n",
    "            book_inst.save()\n",
    "\n",
    "            # redirect to a new URL:\n",
    "            return HttpResponseRedirect(reverse('all-borrowed') )\n",
    "\n",
    "    # If this is a GET (or any other method) create the default form.\n",
    "    else:\n",
    "        proposed_renewal_date = datetime.date.today() + datetime.timedelta(weeks=3)\n",
    "        form = RenewBookForm(initial={'renewal_date': proposed_renewal_date,})\n",
    "\n",
    "    return render(request, 'catalog/book_renew_librarian.html', {'form': form, 'bookinst':book_inst})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "urlpatterns += [   \n",
    "    url(r'^book/(?P<pk>[-\\w]+)/renew/$', views.renew_book_librarian, name='renew-book-librarian'),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# book_renew_librarian.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "{% block content %}\n",
    "\n",
    "    <h1>Renew: {{bookinst.book.title}}</h1>\n",
    "    <p>Borrower: {{bookinst.borrower}}</p>\n",
    "    <p{% if bookinst.is_overdue %} class=\"text-danger\"{% endif %}>Due date: {{bookinst.due_back}}</p>\n",
    "    \n",
    "    <form action=\"\" method=\"post\">\n",
    "        {% csrf_token %}\n",
    "        <table>\n",
    "        {{ form }}\n",
    "        </table>\n",
    "        \n",
    "        <input type=\"submit\" value=\"Submit\" />\n",
    "    </form>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% if perms.catalog.can_mark_returned %}\n",
    "    <a href=\"{% url 'renew-book-librarian' bookinst.id %}\">\n",
    "        Renew\n",
    "    </a>  \n",
    "{% endif %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generic editing views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.views.generic.edit import CreateView, UpdateView, DeleteView\n",
    "from django.urls import reverse_lazy\n",
    "from .models import Author\n",
    "\n",
    "class AuthorCreate(CreateView):\n",
    "    model = Author\n",
    "    fields = '__all__'\n",
    "    initial={'date_of_death':'05/01/2018',}\n",
    "\n",
    "class AuthorUpdate(UpdateView):\n",
    "    model = Author\n",
    "    fields = ['first_name','last_name','date_of_birth','date_of_death']\n",
    "\n",
    "class AuthorDelete(DeleteView):\n",
    "    model = Author\n",
    "    success_url = reverse_lazy('authors')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# author_form.html "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "\n",
    "<form action=\"\" method=\"post\">\n",
    "    {% csrf_token %}\n",
    "    <table>\n",
    "    {{ form.as_table }}\n",
    "    </table>\n",
    "    <input type=\"submit\" value=\"Submit\" />\n",
    "    \n",
    "</form>\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# author_confirm_delete.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{% extends \"base_generic.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "\n",
    "<h1>Delete Author</h1>\n",
    "\n",
    "<p>Are you sure you want to delete the author: {{ author }}?</p>\n",
    "\n",
    "<form action=\"\" method=\"POST\">\n",
    "  {% csrf_token %}\n",
    "  <input type=\"submit\" action=\"\" value=\"Yes, delete.\" />\n",
    "</form>\n",
    "\n",
    "{% endblock %}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "urlpatterns += [  \n",
    "    url(r'^author/create/$', views.AuthorCreate.as_view(), name='author_create'),\n",
    "    url(r'^author/(?P<pk>\\d+)/update/$', views.AuthorUpdate.as_view(), name='author_update'),\n",
    "    url(r'^author/(?P<pk>\\d+)/delete/$', views.AuthorDelete.as_view(), name='author_delete'),\n",
    "]"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}