1:19:00
To-do list with Django | Build a task application | Django projects | #3
Cloud With Django
Overview
This video tutorial guides viewers through building a to-do list application using Django. It covers the foundational steps of setting up a Django project, including creating a project folder, managing virtual environments, and installing Django. The tutorial then progresses to creating a Django app, configuring URLs and views, setting up templates for rendering HTML, and migrating the database. Key functionalities like creating, updating, and deleting tasks are implemented, demonstrating how to define models, register them with the Django admin, and handle form submissions for task management. The process emphasizes practical application of Django's core features for web development.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- Create a dedicated development folder for your project.
- Use the command prompt to navigate to your project folder.
- Install the 'virtualenv' package globally to manage project-specific dependencies.
- Create and activate a virtual environment (e.g., 'venv') to isolate project packages.
- Install Django within the activated virtual environment using pip.
Setting up a virtual environment is crucial for isolating project dependencies, preventing conflicts between different projects, and ensuring reproducibility.
Navigating to the 'Dev' folder on the desktop using `cd Dev` and then creating a virtual environment with `virtualenv venv`.
- Start a new Django project using `django-admin startproject <project_name>` (e.g., 'to-do').
- Open the project in a code editor (like VS Code) to view the project structure.
- Navigate into the project directory in the command prompt (`cd to-do`).
- Run the development server using `python manage.py runserver` to verify the project setup.
- Create a new Django app within the project using `django-admin startapp <app_name>` (e.g., 'tasks').
Structuring your project into apps allows for better organization and modularity, making it easier to manage different functionalities of your application.
Creating the 'tasks' app using `django-admin startapp tasks` and then adding 'tasks' to the `INSTALLED_APPS` list in `settings.py`.
- Create a `urls.py` file within the 'tasks' app to define app-specific URL patterns.
- Include the app's URLs in the main project's `urls.py` using the `include` function.
- Define a simple view function in `views.py` that returns an `HttpResponse` (e.g., 'Hello World').
- Map a URL pattern (e.g., '/') in the app's `urls.py` to the view function.
- Ensure the server is restarted to recognize new URL configurations and views.
Proper URL routing connects user requests to the correct view functions, enabling the application to respond with the appropriate content or actions.
In `to-do/urls.py`, including `path('', include('tasks.urls'))`, and in `tasks/views.py`, defining `def index(request): return HttpResponse('Hello World')`.
- Create a 'templates' folder within the 'tasks' app directory.
- Create an HTML file (e.g., `tasks.html`) inside the 'templates' folder.
- Modify the view function to use `render` instead of `HttpResponse` to load the HTML template.
- Pass necessary data from the view to the template via a context dictionary.
- Restart the server and refresh the browser to see the rendered HTML content.
Templates separate presentation logic from application logic, allowing for dynamic content to be displayed to the user using HTML.
Creating `tasks.html` with an `<h1>` tag and in `views.py`, using `render(request, 'tasks.html', context)` to display it.
- Run `python manage.py migrate` to apply default database migrations for built-in Django apps.
- Create a superuser account using `python manage.py create superuser` for admin access.
- Access the Django admin interface at `/admin` and log in with superuser credentials.
- Register your app's models with the admin site in `admin.py` to manage data through the admin panel.
- The admin panel automatically appends an 's' to registered model names (e.g., 'Task' becomes 'Tasks').
Migrations manage database schema changes, and the admin interface provides a powerful tool for managing application data without writing custom interfaces.
Running `python manage.py migrate`, creating a superuser named 'onor', and then registering the `Task` model in `tasks/admin.py`.
- Define a `Task` model in `models.py` with fields like `title` (CharField), `completed` (BooleanField), and `created` (DateTimeField).
- Implement a `__str__` method in the model to define how task objects are represented as strings (e.g., by their title).
- Run `python manage.py makemigrations` to generate migration files for the new model.
- Run `python manage.py migrate` again to apply these model changes to the database.
- Add task instances through the Django admin interface.
Models define the structure of your data, acting as blueprints for database tables, and registering them allows for data persistence and management.
Defining the `Task` model with `title`, `completed`, and `created` fields, and then adding tasks like 'Buy food' and 'Watch movies' via the admin panel.
- In `views.py`, query all task objects from the database using `Task.objects.all()`.
- Pass the retrieved tasks to the template via a context dictionary (e.g., `{'tasks': all_tasks}`).
- In `tasks.html`, use a Django template `for` loop to iterate over the `tasks` variable.
- Display task attributes (e.g., `task.title`, `task.completed`, `task.created`) within the loop.
- Restart the server to see the list of tasks rendered on the webpage.
This step connects the data retrieved from the database to the user interface, allowing users to view their to-do items.
In `views.py`, `tasks = Task.objects.all()`, and in `tasks.html`, using `{% for task in tasks %}{{ task.title }}{% endfor %}`.
- Create a `forms.py` file in the 'tasks' app.
- Define a `TaskForm` inheriting from `forms.ModelForm` to represent the `Task` model.
- In `views.py`, instantiate the `TaskForm` and pass it to the template context.
- In `tasks.html`, create an HTML `<form>` element with `method='post'` and include the `{% csrf_token %}`.
- Render the form fields (e.g., `{{ task_form.as_p }}`) and a submit button.
- Implement POST request handling in `views.py` to save new tasks or update existing ones using `form.save()`.
- For updates, fetch the specific task instance and pass it to the `TaskForm` (`instance=task`).
- Create a dynamic URL (e.g., `/update-task/<int:pk>/`) for updating specific tasks.
Forms provide a structured way to handle user input for creating and modifying data, ensuring data integrity and simplifying the development process.
Creating a task by submitting the form on the homepage, and updating a task by navigating to `/update-task/1/` and modifying its details.
- Create a `delete-task.html` template to confirm deletion.
- Add a 'Cancel' link to return to the homepage.
- Create a `delete_task` view function that accepts a task's primary key (`pk`).
- Define a dynamic URL pattern (e.g., `/delete-task/<int:pk>/`) that maps to the `delete_task` view.
- In the view, retrieve the task by `pk` and handle a POST request to delete it using `task.delete()`.
- Redirect to the homepage after successful deletion.
- Add an 'Update' link to each task in `tasks.html` that points to the dynamic update URL (e.g., `/update-task/{{ task.id }}/`).
Implementing deletion functionality allows users to remove completed or unwanted tasks, keeping their to-do list organized.
Clicking an 'Update' link next to a task, modifying it, and then clicking a 'Delete' button (implicitly handled by a form submission) to remove it.
Key takeaways
- Virtual environments are essential for managing project dependencies and avoiding conflicts.
- Django projects are structured into reusable apps, each handling a specific functionality.
- URL routing connects user-facing URLs to backend view logic.
- Templates separate presentation from logic, allowing dynamic HTML generation.
- Models define data structure, and migrations manage database schema changes.
- The Django admin site provides a powerful interface for data management.
- Forms simplify the process of handling user input for creating and updating data.
- Dynamic URLs are used to perform actions on specific data instances (e.g., updating or deleting a particular task).
Key terms
Django ProjectDjango AppVirtual Environmentpipdjango-adminURL RoutingViewsTemplatesModelsMigrationsModelFormCSRF TokenHttpResponserenderContext DictionaryPrimary Key (PK)
Test your understanding
- What is the primary purpose of a virtual environment in a Django project?
- How do you create a new Django app and register it with your project?
- Explain the relationship between URLs, views, and templates in Django.
- What are Django migrations, and why are they necessary when defining models?
- How can you display a list of tasks retrieved from the database in an HTML template?
- Describe the process of creating a new task using a Django ModelForm.
- How does Django handle updating a specific task instance using dynamic URLs and forms?