You're reading from Building SPAs with Django and HTML Over the Wire

Product typeBook

Published inAug 2022

PublisherPackt

ISBN-139781803240190

Edition1st Edition

Tools

Django

Concepts

Server Side Web Development

Author (1)

Andros Fenollosa

Chapter 7: Creating a Real-Time Blog Using Only Django

In Chapter 6, Creating SPAs on the Backends, we learned essential features for setting up an SPA using HTML over WebSockets, such as changing pages, components, and sessions. We even went a step further by creating a server-side rendering system for each page so that search engines can index all content – a feature that didn’t require much effort as we are inside Django.

We now have the skills and maturity to make applications with all the features that SPA development entails. Now is the time! We will unify all the knowledge acquired in the creation of a perfectly prepared blog. Undoubtedly, this is an excellent exercise regardless of the language or framework that we want to assimilate; it encompasses all the basic tasks of any web development: querying, filtering, and adding to a database (search engine and comments), generating HTML from results (a list of articles and an individual page), use of views (SSR...

Technical requirements

All the code of the different sections can be found at the following link:

https://github.com/PacktPublishing/Building-SPAs-with-Django-and-HTML-Over-the-Wire/tree/main/chapter-7

As in other examples, I will start from the template that we built in Chapter 4, Working with the Database:

https://github.com/PacktPublishing/Building-SPAs-with-Django-and-HTML-Over-the-Wire/tree/main/chapter-4/initial-template

If you find some small differences, it is because I have made some minor adjustments. For example, I have named the project blog, the app website, and changed the path to http://blog.localhost, although, as always, you are free to name each element freely.

Creating models for the database

We will start by building two tables in the database: Post, which will contain the articles, and Comment, so that readers can leave their opinions next to the articles.

In app/website/models.py, add the following database structure:

from django.db import models
from django.utils.text import slugify
from django.urls import reverse
 
class Post(models.Model):
    # Fields: Title of the article, name of the author, 
    content of the article and date of creation.
    title = models.CharField(max_length=200, unique=True)
    author = models.CharField(max_length=20)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
 
    class Meta:
        ordering = ["-created_at"]
 
    @property
   ...

Generating fake articles and comments

After defining the database from the models, we are going to generate random data that we will use to work more comfortably.

We create make_fake_data.py with the following content:

from app.website.models import Post, Comment
from faker import Faker
 
# Delete all posts and comments
Post.objects.all().delete()
 
# Create fake object
fake = Faker()
 
def get_full_name():
    return f"{fake.first_name()} {fake.last_name()}"
 
# Create 30 posts
for _ in range(30):
    post = Post(
        title=fake.sentence()[:200],
        content=fake.text(),
        author=get_full_name()[:20],
    )
    post.save()
 
# Create 150 comments
for _ in range(150):
    comment = Comment(
        ...

Listing of articles

We have prepared the database through the models and by including fake information with the necessary elements, enabling us to focus on how the customer is going to visualize the content.

Before building the different pages, we will need a base for all templates. In app/website/templates/base.html, we include the main layout:

{% load static %}
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width,
        user-scalable=no, initial-scale=1.0, maximum-
            scale=1.0, minimum-scale=1.0">
    <title>Example website</title>
    <link rel="stylesheet" href="{% static 'css/main.css' 
    ...

Navigating between articles with pagination

We are able to show visitors the latest articles, but they are unable to view previous posts. We are going to include a button that allows us to render other articles on the welcome page, and we will incorporate them in blocks of five.

We add a component with the button. In app/website/templates/components/all_posts/_button_paginator.html, add the following HTML:

{% if not is_last_page %}
<button class="button" id="paginator" data-next-page="{{ 
    next_page }}">More posts</button>
{% endif %}

We will only show the button if we are not on the last page, which we will manage with the is_last_page variable. In addition, we will include a dataset with the next_page variable to tell the backend the next page we want to render.

The component is embedded in app/website/templates/components/all_posts/list.html:

<h1>All posts</h1>
<hr>
<section>...

Adding an article search engine

Offering visitors pagination is a good idea to optimize resources and offer controlled navigation. In addition, including a search engine for articles will provide complete exploration. That is why we are going to integrate a text field to find articles by title.

In app/website/forms.py, we incorporate the following form, which will only have one field:

from django import forms
from . models import Comment
 
class SearchForm(forms.Form):
    search = forms.CharField(
        label="Search",
        max_length=255,
        required=False,
        widget=forms.TextInput(
            attrs={
                "id":...

Creating a static page

We are in a situation where we need to grow with new pages to split logic and HTML structures. The first step will be to create a static page.

We create app/website/templates/pages/about_us.html with simple text:

<h1> About us</h1>
<p> Lorem ipsum dolor sit amet, consectetur adipisicing elit. Ad animi aut beatae commodi consectetur cumque ipsam iste labore laudantium magni molestiae nobis nulla quod quos tempore totam velit, voluptas voluptates!</p>

We edit the views (app/website/views.py), including about:

def about(request):
    return render(
        request,
        "base.html",
        { "page": "pages/about_us.html", "active_nav": 
           "about us"},
    ...

Moving between pages and generating a browser

Visitors need to navigate between different pages; a simple button structure and corresponding logic for loading the appropriate templates will need to be incorporated.

We are going to create a browser to dynamically jump between pages or, in other words, request the backend to render the page in the right place:

The first step is to create a component with hyperlinks. We create a file in app/website/templates/components/_nav.html with the following structure:

<ul class="nav__ul">
    <li>
        <a
                href="#"
                class="nav__link nav__link nav__link--page{% if active_nav == "all posts" %} active{% endif %}""
   ...

Implementing an individual page per article

We have the opportunity to create a page that renders an entire article, which will be the basis for the entire commenting system.

We create the template in app/website/templates/pages/single_post.html with basic but sufficient HTML for the minimum Post fields:

<section>
    {# Post #}
    <article>
        <header>
            <h1>{{ post.title }}</h1>
        </header>
        <div>{{ post.content }}</div>
        <footer>
            <p>{{ post.author }}</p>
        </footer>
    </article...

Adding a list of comments

The blog is functional: we can list articles, navigate between pages, paginate, and perform a search. But an essential element is still missing: comments. That’s why we are going to print all the comments that belong to an article.

We start by creating a template that lists all the comments. We add a new component in app/website/templates/components/_list_of_comments.html with the following content:

{% for comment in comments %}
    {% include "components/_single_comment.html" with 
       comment=comment %}
{% endfor %}

This, in turn, will need the app/website/templates/components/_single_comment.html component:

<article>
    <h2>{{ comment.author }}</h2>
    <p>{{ comment.content }}</p>
    <p>{{ comment.created_at }}</p>
</article>

In the views (app/website/views...

Adding new comments

If all the comments were written by us, it would be a bit immoral. We’re going to incorporate a form so that anyone reading the article can leave a personal opinion. If you don’t like what they say, you can always "manage" it with Django’s admin panel. But for now, let’s not be tricky; let’s focus on the more technical side.

First, we add the following form in app/website/forms.py:

class CommentForm(forms.ModelForm):
 
    author = forms.CharField(
        widget=forms.TextInput(
            attrs={
                "id": "author",
                "class": "input",
      ...

Offering an RSS feed

Tech blogs are often consumed by robots, in particular by feed readers. If we want to build a feed in Django, it’s really convenient. Django incorporates a framework called Syndication that automates tasks such as dynamic generation of XML, fields, and caching.

In app/website/feed.py, we add the following class that inherits from Feed:

from django.contrib.syndication.views import Feed
from django.urls import reverse
from .models import Post
 
class LatestEntriesFeed(Feed):
    title = "My blog"
    link = "/feed/"
    description = "Updates to posts."
 
    def items(self):
        return Post.objects.all()[:5]
 
    def item_title(self, item):
        return item.title
 
    def item_description(self, item):
  ...

Summary

We could consider this chapter as a consummation of all the skills acquired throughout the book. Not only are we able to incorporate a WebSockets server into Django, through channels; we now also have techniques to create a real-time, single-page application using Python. We now have a deep knowledge that matches the results we can achieve with other similar projects, such as LiveView in Phoenix (the most popular framework in the Elixir ecosystem), StimulusReflex, Turbo, Action Cable, or Hotwire in Ruby on Rails.

If we are looking to abstract part of the process, there are some frameworks within Django that can be useful, such as Django Sockpuppet or Django Reactor. Unfortunately, neither of them is receiving updates, although it is a great idea to find out how they are constructed in order to further expand our knowledge.

Although the backend is covered, it is still cumbersome to work with the frontend. Events have to be redeclared on every draw, and there are tasks...

The rest of the chapter is locked

You have been reading a chapter from

Building SPAs with Django and HTML Over the Wire

Published in: Aug 2022Publisher: PacktISBN-13: 9781803240190

A free Packt account unlocks extra newsletters, articles, discounted offers, and much more. Start advancing your knowledge today.

undefined

Unlock this book and the full library FREE for 7 days

Get unlimited access to 7000+ expert-authored eBooks and videos courses covering every tech area you can think of

Start free trial

Renews at $15.99/month. Cancel anytime

Author (1)

Andros Fenollosa

Andros Fenollosa is a custom programming expert that works as a teacher, full stack developer, and mobile developer. He's a Web Designer, Web Programmer, and Apps Programmer, among other things ( PWA, Android and iOS ). He has a plethora of commercial expertise, having worked on projects in a variety of locales throughout the world.
Read more about Andros Fenollosa

Personalised recommendations for you

Based on your interests and search pattern

Modernizing Drupal 10 Theme Development

Modernizing Drupal 10 Theme Development covers everything a frontend developer or a Drupal developer needs to know about the Drupal 10 theme layer. Using real-world examples, this book will help you to build up from an empty theme to a fast, responsive, maintainable, and accessible Drupal website in both monolithic and decoupled ways.

BookAug 2023360 pages4

Full Stack Development with Spring Boot 3 and React

Full Stack Development with Spring Boot 3 and React contains a wealth of practical guidance for picking up full stack development. The step-by-step exploration of everything from dependency injection, ORM with Hibernate, and JWTs to RESTful APIs, UI styling, and TypeScript will help you to develop the Spring Boot and React skills you need.

BookOct 2023454 pages5

Modern API Development with Spring 6 and Spring Boot 3

This practical guide teaches inexperienced Java programmers and web developers how to design, develop, test, and deploy highly scalable and maintainable APIs using REST, gRPC, GraphQL, and reactive programming paradigms with Java and Spring Boot. Complete with real-world examples, it will guide you to build enterprise-level APIs and services.

BookSep 2023494 pages1

Hands-On Web Scraping with Python

This book guides you to discover and extract quality data from the web using Python libraries such as requests, lxml, pyquery, scrapy, and to use effective scraping techniques. It’ll help you master the fundamentals and advanced concepts of web scraping and apply your skills to real-world data extraction tasks, with analysis and visualization.

BookOct 2023324 pages

Mastering Blazor WebAssembly

Mastering Blazor WebAssembly is a comprehensive, practical guide that’ll help you to develop advanced web applications. By combining real-world experience with the thorough knowledge needed to build Blazor apps in a masterful fashion, this book enables you to efficiently manage cross-platform mobile development with .NET MAUI and Blazor.

BookAug 2023370 pages4

Mastering Blazor WebAssembly

Mastering Blazor WebAssembly is a comprehensive, practical guide that’ll help you to develop advanced web applications. By combining real-world experience with the thorough knowledge needed to build Blazor apps in a masterful fashion, this book enables you to efficiently manage cross-platform mobile development with .NET MAUI and Blazor.

BookAug 2023370 pages3

Full Stack Web Development with Remix

Unlock the power of the web platform and cutting-edge technologies for your React applications using Remix to take advantage of the full stack to create a great user experience. This book is a complete resource covering the conventions, levers, and primitives of Remix and illustrates concepts through a real-world project.

BookNov 2023318 pages

Real-World Svelte

This book is a must-have guide to unlocking Svelte's true potential. You’ll learn about advanced component development, efficient coding, and powerful UI patterns using actions. With a focus on state management, custom stores, and renderless components, this book equips you to build exceptional web apps with lightning-fast performance.

BookDec 2023282 pages3

Building Micro Frontends with React 18

This book is a step-by-step guide to building production-grade, highly scalable, and performant web apps using multi-SPA and micro apps patterns, where you’ll learn to deal with complexities related to micro frontends. The book is a full life cycle guide to building, deploying, and managing micro frontends in a cloud-native environment.

BookOct 2023218 pages

Drupal 10 Masterclass

This all-in-one guide helps you get up and running with building Drupal applications using the latest Drupal 10 features. You’ll develop a complete practical understanding of Drupal frontend, backend, architecture, content management, themes, and modules to deliver a rich user experience by creating custom Drupal apps.

BookDec 2023310 pages

Full-Stack Flask and React

This book teaches you how to build simple yet efficient production-ready web applications. Starting with an introduction to React, this book will equip you with deeper knowledge of Flask and React technology stacks to undertake web application development with confidence.

BookOct 2023408 pages5

Full-Stack Flask and React

This book teaches you how to build simple yet efficient production-ready web applications. Starting with an introduction to React, this book will equip you with deeper knowledge of Flask and React technology stacks to undertake web application development with confidence.

BookOct 2023408 pages2