Tag: Python

Setting Up Template Directories

First, you need to define where Django should look for templates. You can set this up in your settings file (settings.py).

1. Template Directory: By default, Django looks for a templates folder in each app directory. You can also set up a global templates directory by adding it to the DIRS option in the TEMPLATES configuration in settings.py. Here’s an example:

   TEMPLATES = [
       {
           'BACKEND': 'django.template.backends.django.DjangoTemplates',
           'DIRS': [BASE_DIR / 'templates'],  # Path to global templates
           'APP_DIRS': True,
           'OPTIONS': {
               # ... some options here ...
           },
       },
   ]
   

   In this configuration, BASE_DIR / 'templates' refers to a templates directory at the root of your project.

Creating Templates

Create HTML template files in the appropriate templates folder. If you’re using app-specific templates, it’s a good practice to create a subdirectory within the templates folder that matches the name of your app to avoid naming collisions between apps.

For example, if you have an app named blog, your directory structure might look like this:

blog/
│
├── templates/
│   └── blog/
│       └── post_detail.html

Using Templates in Views

To use a template in a view, you need to load it and render it with a context. Here’s a basic example of how to do this in a view function:

from django.shortcuts import render

def post_detail(request):
    context = {'post': Post.objects.get(id=1)}
    return render(request, 'blog/post_detail.html', context)

In this example, post_detail.html will be loaded from the blog/templates/blog/ directory, and the post object will be passed to it.

Use render_to_string

The render_to_string function in Django is very useful for rendering a template into a string. It’s often used when you need the rendered output of a template but don’t want to return an HTTP response directly, such as when sending emails or generating PDF files from HTML. Here’s a basic example to illustrate how to use render_to_string:

from django.template.loader import render_to_string

def send_welcome_email(user):
    # Context to pass to the template
    context = {'user': user}
    
    # Render the template into a string
    email_html_message = render_to_string('users/welcome_email.html', context)
    
    # Send the email using Django's email functionality (assuming configuration is set)
    send_mail(
        'Welcome to Our Site!',
        strip_tags(email_html_message),  # Optional: plain text content
        'from@example.com',  # From email
        [user.email],  # To email list
        html_message=email_html_message,  # HTML content
    )

from django.http import HttpResponseRedirect

def my_view(request):
    # your logic here
    return HttpResponseRedirect('/another-page/')

Or, if you want to redirect to a URL resolved by a named URL pattern, you’d typically use the reverse function to dynamically build the URL:

# urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('home/', views.home, name='home'),
    path('profile/<str:username>/', views.profile, name='profile'),
]

# views.py

from django.http import HttpResponseRedirect
from django.urls import reverse

def my_view(request):
    # Example logic here
    # Suppose we determine the username as follows:
    username = 'john_doe'
    
    # Using reverse to dynamically generate the URL
    url = reverse('profile', args=[username])
    
    # Redirecting to the dynamically generated URL
    return HttpResponseRedirect(url)

def home(request):
    # Logic for home view
    pass

def profile(request, username):
    # Logic for profile view
    return HttpResponse(f"Profile page of {username}")

To return a 404 response in Django, you can use the Http404 exception or the get_object_or_404() utility function, which are both simple and efficient ways to handle cases where a resource is not found. Here’s how you can use each method:

1. Using Http404 Exception

You can raise the Http404 exception in your views when a certain condition is not met (e.g., when an object does not exist in the database). Here’s an example:

from django.http import Http404

def my_view(request, id):
    try:
        item = MyModel.objects.get(pk=id)
    except MyModel.DoesNotExist:
        raise Http404("Item does not exist")

    # Proceed with the rest of the view
    return render(request, 'template.html', {'item': item})

2. Using get_object_or_404()

Django provides a shortcut function get_object_or_404() that encapsulates the try-except block used with Http404. It tries to get an object from the model and if it fails, it automatically raises Http404. Here’s how to use it:

from django.shortcuts import get_object_or_404, render

def my_view(request, id):
    item = get_object_or_404(MyModel, pk=id)
    return render(request, 'template.html', {'item': item})

URL Configuration

To capture values from URLs, you define path converters in your URL patterns. Django offers several built-in path converters like str, int, slug, uuid, and more. You can also define custom path converters if needed.

Here’s an example of how to define a URL pattern that captures an integer value:

# urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('article/<int:article_id>/', views.article_detail, name='article_detail'),
]

In this example, <int:article_id> is a dynamic segment. int is the converter that tells Django to convert this part of the URL into an integer. article_id is the name of the variable that will be passed to the view function.

View Function

In the view, you can capture the value from the URL as a parameter. Here’s how you might handle it:

# views.py

from django.http import HttpResponse

def article_detail(request, article_id):
    # You can now use `article_id` which is passed from the URL
    return HttpResponse(f"Displaying article {article_id}")

In the article_detail function, article_id is received as a parameter directly from the URL.

Using Captured Values

You can use these captured values to perform database queries, logic processing, or pass them into templates. For instance, to fetch an article from a database by its ID:

from django.shortcuts import get_object_or_404
from .models import Article

def article_detail(request, article_id):
    article = get_object_or_404(Article, pk=article_id)
    return HttpResponse(f"Title: {article.title}")

This function fetches an article using the captured article_id, and if the article does not exist, it raises a 404 error.

python manage.py startapp myapp

Register the App

Open the settings.py file in your project directory (myproject/myproject/settings.py). Add your new app to the INSTALLED_APPS list:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Add this line
]

Create a View

In your app directory (myapp), open the views.py file and add the following function:

from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello, world. This is my first Django app.")

Set Up URLs

In your app directory, create a file named urls.py and add the following code:

from django.urls import path
from . import views

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

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),  # Include this line
]

python manage.py runserver 8080

pip install django

django-admin startproject myproject

python manage.py migrate

python manage.py createsuperuser

References
https://stackoverflow.com/questions/39696310/django-contrib-admin-default-admin-and-password