Django Project: djBlogger

Install Python 3.9.5 on Windows 10/11 from python.org, add to path, choose 64-bit or 32-bit, install on the C drive, and verify with python -V.

Download and install Visual Studio Code, set up a Python project by creating a folder, opening it in Visual Studio Code, and enabling auto save with the integrated terminal.

Create and activate a Python virtual environment within Visual Studio Code to isolate project dependencies for Django projects. Resolve activation issues by adjusting PowerShell execution policy and restarting VS Code.

Download and install Python 3.9.5 on macOS from python.org, choose the universal two installer for M1/M2, then verify with python3 --version in Terminal.

Install visual studio code on mac, move to applications, open a project folder, manage files with explorer, enable auto save and zoom, and use the integrated terminal.

Create, start, and manage a virtual environment for a Django project using Python and VS Code. Activate and deactivate the environment with shell commands to isolate project dependencies.

Explore this optional section to gain underpinning Django knowledge, including starting a new project and building templates, to support the blog and move smoothly to the main course sections.

Set up a Django project by creating and activating a Python virtual environment in Visual Studio Code, covering Mac and Windows commands, folder setup, and terminal basics.

Explore the Python package index (PyPI) to discover, install, and manage Python packages with pip, enabling Django projects to reuse existing packages and replicate environments via requirements.txt.

Install Django from the Python package index using pip within a virtual environment, view installed packages, and create a requirements.txt to capture and share dependencies.

Create a new Django project using the Django admin command and the managed.py wrapper, then start the development server and verify the project builds successfully.

Create a new Django application within a Django project and understand the differences between a project and an app, using the startapp command.

Register your new Django app in the core project's settings to ensure Django recognizes it; add the app to installed apps, and include a trailing comma to prevent errors.

learn how to start the Django development server on macOS, Linux, and Windows using manage.py runserver, and understand loopback address 127.0.0.1 and port 8000.

Explore the Django request-response cycle, from browser request to URL matching, view processing, template rendering, and sending the HTML back to the client, including models and admin.

Create and extend Django url patterns by wiring a new app's url file into the project using include, defining a blank root path for the home page, and connecting views.

Build and connect a Django view as a function named home, accept a request, return an HttpResponse with Hello world, and map it in URLs to the home page.

Create a new HTML template and link it to a view to return an HTML page to the browser, using Django's templates folder and an index.html file.

Relate an html template to a django view by using render to return the index template from the templates folder, then run the server and verify hello world on refresh.

Install a django project by creating a virtual environment, installing dependencies with pip -r requirements.txt, and activating the environment. Then run migrations and start the server to verify the app.

Begin a new Django project by learning how to manage settings, secret keys, and environment variables, while exploring modular build and testing tutorials for a complete workflow.

Learn to configure a Django project for multiple environments by organizing settings into a base, local, and production files, using a settings module and environment-based switching.

Learn how to generate a unique, 50-character Django secret key with Django tools, understand its role in cryptographic signing, and protect it using environment variables.

Learn to configure environment variables in a Django project using Python EMV, create an EMV file for local development, and manage secret key and debug across environments.

Learn to set up a Django testing environment using pytest and pytest-django, install dependencies, configure settings, and organize tests in a dedicated tests folder with example tests.

Create a new Git repository with GitHub Desktop for your Django project, commit changes, ignore virtual environments, and publish to GitHub on the main branch.

Explore how to install and use vscode python extensions, including IntelliSense, linting, debugging, and pep 8 formatting, to speed up Python development for the djBlogger project.

Configure black, the Python formatter, to auto format code on save in a Django project in line with PEP 8, and tailor editor settings for project-specific formatting.

Install flake8 in Visual Studio Code, enable linting on save, set line length to 88, and ignore the VS Code folder when pushing to GitHub.

Create a pip requirements file with pip freeze to capture installed packages like django, flake8, and black for replicating the project environment and commit it to the repository.

Build and connect Django models to your project database by creating the necessary database tables and learning how Django models relate to them, with optional testing.

Learn how to create a new GitHub branch, switch from the main branch to a development branch, commit and push changes, and prepare to merge back into main.

Create a blog app in the Django project, start the app, install Django, and register the blog in installed apps in settings.

Build the blog post model with title, subtitle, unique slug, and content, linked to a user author, plus created and updated timestamps, string representation, and status choices draft or published.

Run make migrations to snapshot the current Django model and prepare database changes. Then run migrate to apply changes to the SQLite database and inspect the results with Skylight.

Access the Django admin site, create a super user, register the blog model, and set __str__ to display the post title.

Master testing Django models with a test-first mindset, focus on app-specific features, use factories (Factory Boy) to seed data, and generate coverage reports with pi test.

Create a new commit while excluding unnecessary files by updating the git ignore, removing cache and coverage files, and ignoring md files, then push to origin.

Explore Django templating, the HTML request cycle, and rendering database data into a home page template. Implement Bootstrap, fonts, CSS, nav bar, splash, and haystacks for dynamic updates, with testing.

Merge a dev branch into the main branch with a pull request, review, and merge on GitHub, then explore post-merge updates and optional branch cleanup.

Create a new development branch from main, fetch from origin, and merge changes back, then begin developing on the Dev branch.

Build the home view with Django's list view to display posts from the post model using a template, with pagination and lazy loading as users scroll.

Set up the blog app URLs, connect the home view with as_view, and resolve template not found by organizing templates and adjusting the base directory.

Create a base template to enforce the DRY principle and reuse code across all pages by using Django templating with blocks, extends, and inheritance, aided by Bootstrap.

Learn to set up and serve static css files in Django by creating a static folder, adding main.css, configuring static urls and templates, and testing with browser tools.

Build a reusable bootstrap nav bar for the djBlogger project by creating a base template and including it. Extend from the base to reuse the nav bar across pages.

Learn how to integrate Google fonts into the djBlogger project by selecting fonts for the logo and body text, importing or linking them, and applying font-family, weight, and letter spacing.

Create a reusable index splash component for the djBlogger home page, using a container-based Bootstrap layout with a two-column grid, responsive center alignment, Bali typography overrides, and a call-to-action button.

learn to render posts from the database on the home page using a Django list view and templates, with lazy loading and a responsive card layout.

Generate realistic Django blog data with factory boy and faker for posts and authors, and implement lazy loading with infinite scroll to improve homepage performance.

Implement infinite scroll pagination with tmx and ajax in a Django blog, loading ten posts at a time and updating content via templates.

Build a tag system for a Django blog by adding tag fields and using the Django tag it package to create a tag cloud template tag for the home page.

Create a reusable footer component for the djBlogger Django project and include it in the base and index templates. Apply bootstrap nav styling and CSS for text and padding.

Validate the Django blog homepage by running tests that confirm a 200 response and the correct template is loaded for standard and header-driven requests, using reverse URL and client.

Build the single post page for djBlogger, enabling navigation from the home page to individual posts using Bootstrap and reusable Django templates, then test with database interactions.

Merge a development branch into main using GitHub Desktop, create and confirm a pull request, and verify main is up to date with tests for home, models, and tags.

Create a new git branch from main (dev v103), ensuring it appears in GitHub Desktop and is ready for the new development section.

Create a Django single post view for djBlogger, loading posts by slug and rendering title, subtitle, and content with a responsive left navigation and right sidebar.

Create a reusable three-column template in Django by building a base, extending it, and defining left, middle, and right blocks.

Build a horizontal navigation bar using a bootstrap nav bar, implement a sticky top, left side panel in large view, and responsive collapse for smaller screens.

Apply responsive post content styling in the Blogger template by centering content with a max width, bold headings, and muted meta, then introduce markdown support for headings and images.

Explore adding a markdown editor to a Django blog by installing python-markdown, building a site-wide template tag for markdown processing, and styling rendered markdown content.

Build the blog sidebar by integrating a tag cloud and a related-posts component on the single post template, using an author-based query, responsive padding tweaks, and a reusable card layout.

Create a single post test using a post factory, build the url with reverse, fetch with the test client, and assert a 200 status for the post page.

We adopt tagging over traditional category tables in the djBlogger project. Learn to install a third-party package, connect posts to tags, create a tag page, and test the app.

Commit changes from version 1.0.3 dev, push to GitHub, then merge into main and ensure the main branch is up to date.

Create a new GitHub branch named dev 1.0 after merging, switch from main, refresh, and open version 1.4 to continue the course.

Build a tag view that lists posts by a clicked tag using a tag cloud, a three-column template, and ten-item pagination via a TagListView and the /tag/<name> URL.

Build a custom queryset in a Django class-based view to filter posts by tag using slug, connect tag clouds, debug queryset issues, and lay groundwork for infinite scroll in djBlogger.

Implement htmx tag post pagination in Django djblogger by reusing the home page template, wiring tag context, dynamic URLs, and fragment responses to paginate ten posts.

Explore a Django testing phase that adds tag list view tests using pytest-django, runs pi test and coverage HTML to verify tag filters, context, and header-based rendering, then commit changes.

Implement a basic search feature and a reusable component to search posts across different pages, then build a post page with HTML and CSS, test, and merge to main.

Move toward a basic search feature by merging development work into the main branch, creating a new GitHub branch, and opening a pull request to review and merge.

Create a new GitHub branch named dev version 1.0 from main. Refresh the repository to make it visible, then begin development in the djBlogger project.

Build a Django search feature by wiring a new URL and a class-based post search view with a template that paginates title-filtered results, reusing tag page code.

Build a searchable form in Django using template tools and a class-based view, style with Bootstrap, capture get data, and run a filter or query to power site search.

Implement a Django blog search by capturing and validating user input, then filtering posts whose titles contain the query. Prepare the results for template rendering and optional pagination.

Build htmx post search pagination in djBlogger by reusing the tag template, adapting it for search results, and handling full-path paging and no-results messaging.

Validate post search functionality in Django tests for views and templates, including the search filter, URL reversal, and HTML response.

Merge the 1.5 branch into main via a pull request after confirming tests are up to date. Open GitHub to review and complete the merge, updating main.