Pupli

In myapp/models.py, define a simple model:

from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

python manage.py makemigrations
python manage.py migrate

from django.shortcuts import render, get_object_or_404, redirect
from .models import Item
from .forms import ItemForm

def item_list(request):
    items = Item.objects.all()
    return render(request, 'myapp/item_list.html', {'items': items})

def item_detail(request, pk):
    item = get_object_or_404(Item, pk=pk)
    return render(request, 'myapp/item_detail.html', {'item': item})

def item_create(request):
    if request.method == "POST":
        form = ItemForm(request.POST)
        if form.is_valid():
            item = form.save()
            return redirect('item_detail', pk=item.pk)
    else:
        form = ItemForm()
    return render(request, 'myapp/item_form.html', {'form': form})

def item_update(request, pk):
    item = get_object_or_404(Item, pk=pk)
    if request.method == "POST":
        form = ItemForm(request.POST, instance=item)
        if form.is_valid():
            item = form.save()
            return redirect('item_detail', pk=item.pk)
    else:
        form = ItemForm(instance=item)
    return render(request, 'myapp/item_form.html', {'form': form})

def item_delete(request, pk):
    item = get_object_or_404(Item, pk=pk)
    if request.method == "POST":
        item.delete()
        return redirect('item_list')
    return render(request, 'myapp/item_confirm_delete.html', {'item': item})

Creating a Django model involves defining a class that inherits from models.Model and specifying various fields. Here’s a step-by-step guide to create a Django model with common fields:

1. Install Django (if you haven’t already):

   pip install django
   

2. Start a Django Project:

   django-admin startproject myproject
   cd myproject
   

3. Create an App:

   python manage.py startapp myapp
   

4. Define the Model: Open the models.py file in your app (myapp/models.py) and define your model. Here’s an example of a Book model:

   from django.db import models
   
   class Book(models.Model):
       title = models.CharField(max_length=200)
       author = models.CharField(max_length=100)
       publication_date = models.DateField()
       isbn = models.CharField(max_length=13, unique=True)
       price = models.DecimalField(max_digits=6, decimal_places=2)
       stock = models.PositiveIntegerField()
       description = models.TextField()
       created_at = models.DateTimeField(auto_now_add=True)
       updated_at = models.DateTimeField(auto_now=True)
   
       def __str__(self):
           return self.title
   

5. Add the App to Project Settings: Add your app to the INSTALLED_APPS list in the settings.py file of your project (myproject/settings.py):

   INSTALLED_APPS = [
       ...
       'myapp',
       ...
   ]
   

6. Make Migrations: Create migrations for your model. Migrations are Django’s way of propagating changes you make to your models (adding a field, deleting a model, etc.) into your database schema.

   python manage.py makemigrations myapp
   

7. Migrate the Database: Apply the migrations to your database.

   python manage.py migrate
   

8. Register the Model in the Admin Site: To make your model visible on the admin site, you need to register it. Open admin.py in your app (myapp/admin.py) and register your model:

   from django.contrib import admin
   from .models import Book
   
   admin.site.register(Book)
   

9. Run the Development Server: Start the development server to see your changes.

   from django.contrib import admin
   from .models import Book
   
   admin.site.register(Book)
   

10. Create a Superuser (if you haven’t already): To access the admin site, you need a superuser. Create one with the following command:

    python manage.py createsuperuser
    

Now, you can log in to the Django admin site at http://127.0.0.1:8000/admin/, add some Book entries, and manage them.

References
https://docs.djangoproject.com/en/5.0/topics/db/models/
https://docs.djangoproject.com/en/5.0/ref/models/fields/

Creating a Partial Template

1. Create the Partial Template File: Create a separate HTML file for the partial template. For instance, you might create a file called _header.html for the header of your web pages.

   <!-- templates/partials/_header.html -->
   <header>
       <h1>My Website Header</h1>
       <nav>
           <ul>
               <li><a href="/">Home</a></li>
               <li><a href="/about/">About</a></li>
               <li><a href="/contact/">Contact</a></li>
           </ul>
       </nav>
   </header>
   

2. Include the Partial Template in Your Main Template: Use the {% include %} template tag to include the partial template in your main templates.

   <!-- templates/base.html -->
   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>My Website</title>
   </head>
   <body>
       {% include "partials/_header.html" %}
       
       <main>
           {% block content %}
           <!-- Main content goes here -->
           {% endblock %}
       </main>
       
       <footer>
           <p>&copy; 2024 My Website</p>
       </footer>
   </body>
   </html>
   

3. Extending the Base Template: If you are using a base template that other templates will extend, make sure to extend it properly in your child templates.

   <!-- templates/home.html -->
   {% extends "base.html" %}
   
   {% block content %}
   <h2>Welcome to My Website!</h2>
   <p>This is the homepage.</p>
   {% endblock %}

Using Context in Partial Templates

If you need to pass context variables to a partial template, you can include it with additional context using the with keyword.

1. Update the Partial Template:

   <!-- templates/partials/_header.html -->
   <header>
       <h1>{{ site_name }}</h1>
       <nav>
           <ul>
               <li><a href="/">Home</a></li>
               <li><a href="/about/">About</a></li>
               <li><a href="/contact/">Contact</a></li>
           </ul>
       </nav>
   </header>
   

2. Include the Partial Template with Context:

   <!-- templates/base.html -->
   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>{{ title }}</title>
   </head>
   <body>
       {% include "partials/_header.html" with site_name="My Awesome Website" %}
       
       <main>
           {% block content %}
           <!-- Main content goes here -->
           {% endblock %}
       </main>
       
       <footer>
           <p>&copy; 2024 My Awesome Website</p>
       </footer>
   </body>
   </html>
   

By breaking your templates into partials and using the {% include %} tag, you can keep your templates clean, modular, and easy to manage. This approach is particularly useful for repetitive components like headers, footers, navigation bars, and sidebars.

Basic Concepts

1. Base Template: A general template that includes common elements (like headers, footers, and navigation bars) used across multiple pages.
2. Block Tags: Special tags in Django templates that define sections of the template that can be overridden by child templates.

Steps to Implement Template Inheritance

1. Create a Base Template

First, create a base template that includes the common layout for your website. For example, base.html:

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My Site{% endblock %}</title>
    <link rel="stylesheet" type="text/css" href="{% static 'css/styles.css' %}">
</head>
<body>
    <header>
        <h1>Welcome to My Site</h1>
    </header>

    <nav>
        <ul>
            <li><a href="{% url 'home' %}">Home</a></li>
            <li><a href="{% url 'about' %}">About</a></li>
            <li><a href="{% url 'contact' %}">Contact</a></li>
        </ul>
    </nav>

    <div class="content">
        {% block content %}{% endblock %}
    </div>

    <footer>
        <p>&copy; 2024 My Site</p>
    </footer>
</body>
</html>

2. Create a Child Template

Next, create a child template that extends the base template. For example, home.html:

{% extends 'base.html' %}

{% block title %}Home - My Site{% endblock %}

{% block content %}
    <h2>Home Page</h2>
    <p>Welcome to the home page of my awesome site!</p>
{% endblock %}

3. Render the Template in Views

In your Django views, render the child template. For example, in views.py:

from django.shortcuts import render

def home(request):
    return render(request, 'home.html')

4. URL Configuration

Ensure you have the appropriate URL configuration in urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    # other paths
]

Key Points to Remember

• {% extends 'base.html' %}: This tag is used in the child template to specify the base template it extends.
• Block Tags ({% block content %}{% endblock %}): Define sections in the base template that can be overridden by child templates.
• Static Files: Use the {% static %} template tag to include static files like CSS and JavaScript.

Example Directory Structure

Here’s an example of what your directory structure might look like:

myproject/
    myapp/
        templates/
            base.html
            home.html
        views.py
        urls.py
    myproject/
        settings.py
        urls.py
        wsgi.py

By using template inheritance, you can efficiently manage and update the layout and design of your website while ensuring consistency across different pages.

{% if athlete_list %}
    Number of athletes: {{ athlete_list|length }}
{% elif athlete_in_locker_room_list %}
    Athletes should be out of the locker room soon!
{% else %}
    No athletes.
{% endif %}

References
https://docs.djangoproject.com/en/5.0/ref/templates/builtins/#if

In Django, the {% url %} template tag is used to generate URLs by reversing the URL patterns defined in your urls.py file. This approach promotes cleaner code and helps avoid hard-coding URLs in your templates.

Here’s how you can use the {% url %} tag:

Syntax: The {% url %} tag syntax is:

{% url 'viewname' arg1 arg2 %}

Here, 'viewname' is the name of the URL pattern you defined in your urls.py. arg1, arg2, etc., are the arguments that the URL pattern expects.

Example: Suppose you have a URL pattern defined in your urls.py like this:

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

urlpatterns = [
    path('article/<int:year>/', views.year_archive, name='news-year-archive'),
]

You can use the {% url %} tag in your template like this:

<!-- In your Django template -->
<a href="{% url 'news-year-archive' 2022 %}">View 2022 Archive</a>

This will resolve to the URL for viewing the 2022 archive, assuming your app is hosted at the root.

Using the {% url %} tag helps ensure your templates remain easy to maintain, particularly if you later decide to change URL patterns. The links in your templates will update automatically to reflect the new patterns.

References
https://docs.djangoproject.com/en/5.0/ref/templates/builtins/#url

In a Django template, you use tags to add logic like loops, conditions, and variable manipulations within the HTML. Tags are enclosed within {% %}

{% for item in item_list %}
  <li>{{ item.name }}</li>
{% endfor %}

References
https://docs.djangoproject.com/en/5.0/ref/templates/builtins/#for