2.2 Using models, part 2 - LiVanych/locallibrary GitHub Wiki

Defining the LocalLibrary Models

Open models.py in /locallibrary/catalog/

from django.db import models

# Create your models here.

Genre model

class Genre(models.Model):
    """Model representing a book genre."""
    name = models.CharField(
           max_length=200,
           help_text='Enter a book genre (e.g. Science Fiction)'
           )

    def __str__(self):
        """String for representing the Model object."""
        return self.name

Book model

# Used to generate URLs by reversing the URL patterns
from django.urls import reverse 

class Book(models.Model):
    
    """Model representing a book (but not a specific copy of a book)."""
    title = models.CharField(max_length=200)

    # Foreign Key used because book can only have one author,
    # but authors can have multiple books
    # Author as a string rather than object because 
    # it hasn't been declared yet in the file
    author = models.ForeignKey('Author', on_delete=models.SET_NULL, null=True)
    
    summary = models.TextField(
                               max_length=1000, 
                               help_text='Enter a brief description of the book'
                               )
    isbn = models.CharField(
           'ISBN', 
           max_length=13, 
           help_text='13 Character 
           <a href="https://www.isbn-international.org/content/what-isbn">
            ISBN number
           </a>'
           )
    
    # ManyToManyField used because genre can contain many books. Books can 
    # cover many genres.
    # Genre class has already been defined so we can specify the object above.
    genre = models.ManyToManyField(
                                   Genre, 
                                   help_text='Select a genre for this book'
                                   )
    
    def __str__(self):
        """String for representing the Model object."""
        return self.title
    
    def get_absolute_url(self):
        """Returns the url to access a detail record for this book."""
        return reverse('book-detail', args=[str(self.id)])

BookInstance model

import uuid # Required for unique book instances

class BookInstance(models.Model):    
    """Model representing a specific copy of a book 
       (i.e. that can be borrowed from the library).
    """
    id = models.UUIDField(
         primary_key=True,
         default=uuid.uuid4, 
         help_text='Unique ID for this particular book across whole library'
         )
    book = models.ForeignKey('Book', on_delete=models.SET_NULL, null=True) 
    imprint = models.CharField(max_length=200)
    due_back = models.DateField(null=True, blank=True)

    LOAN_STATUS = (
        ('m', 'Maintenance'),
        ('o', 'On loan'),
        ('a', 'Available'),
        ('r', 'Reserved'),
    )

    status = models.CharField(
        max_length=1,
        choices=LOAN_STATUS,
        blank=True,
        default='m',
        help_text='Book availability',
    )

    class Meta:
        ordering = ['due_back']

    def __str__(self):
        """String for representing the Model object."""
        return f'{self.id} ({self.book.title})'

Note: A little Python: Starting with Python 3.6, you can use the string interpolation syntax (also known as f-strings):

f'{self.id} ({self.book.title})'.

In older versions of this tutorial, we were using a formatted string syntax, which is also a valid way of formatting strings in Python (e.g. '{0} ({1})'.format(self.id,self.book.title)).

Author model

class Author(models.Model):
    
    """Model representing an author."""
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    date_of_birth = models.DateField(null=True, blank=True)
    date_of_death = models.DateField('Died', null=True, blank=True)

    class Meta:
        ordering = ['last_name', 'first_name']
    
    def get_absolute_url(self):
        """Returns the url to access a particular author instance."""
        return reverse('author-detail', args=[str(self.id)])

    def __str__(self):
        """String for representing the Model object."""
        return f'{self.last_name}, {self.first_name}'

Language model

class Language(models.Model):
    """Model representing a book genre."""
    name = models.CharField(
           max_length=200,
           help_text='Enter a book language (e.g. English, Ukrainian)'
           )

    def __str__(self):
        """String for representing the Model object."""
        return self.name