diff --git a/README.md b/README.md
index 3adec25..f75d9da 100644
--- a/README.md
+++ b/README.md
@@ -77,14 +77,17 @@ The project includes custom Django management commands to help with development
For detailed documentation on all available commands, see [Management Commands Documentation](./docs/management-commands.md).
-### Quick Examples
+### Quick Examples (recommended running order)
```bash
# Create sample images and documents for testing
docker exec -it wagtail-starter-kit-app-1 python manage.py create_sample_media
-# Reset all sample content
-docker exec -it wagtail-starter-kit-app-1 python manage.py create_sample_media --reset
+# Populate the home page with sample content
+docker exec -it wagtail-starter-kit-app-1 python manage.py populate_homepage
+
+# Create a complete blog structure with sample posts and authors
+docker exec -it wagtail-starter-kit-app-1 python manage.py populate_blog
```
## View the site
diff --git a/app/blog/__init__.py b/app/blog/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/app/blog/apps.py b/app/blog/apps.py
new file mode 100644
index 0000000..e0e9de1
--- /dev/null
+++ b/app/blog/apps.py
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class BlogConfig(AppConfig):
+ default_auto_field = "django.db.models.BigAutoField"
+ name = "app.blog"
diff --git a/app/blog/management/__init__.py b/app/blog/management/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/app/blog/management/commands/__init__.py b/app/blog/management/commands/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/app/blog/management/commands/populate_blog.py b/app/blog/management/commands/populate_blog.py
new file mode 100644
index 0000000..bfaf936
--- /dev/null
+++ b/app/blog/management/commands/populate_blog.py
@@ -0,0 +1,361 @@
+import random
+from datetime import date, timedelta
+
+from django.core.management.base import BaseCommand
+from wagtail.images.models import Image
+
+from app.blog.models import (
+ Author,
+ BlogIndexPage,
+ BlogPage,
+ BlogPageGalleryImage,
+ BlogTagIndexPage,
+)
+from app.home.models import HomePage
+
+
+class Command(BaseCommand):
+ help = (
+ "Creates a complete blog structure with sample content including blog index pages, "
+ "blog posts with unique titles, authors, tags, and gallery images. Can be run "
+ "multiple times safely to add more content without conflicts."
+ )
+
+ def add_arguments(self, parser):
+ parser.add_argument(
+ "--posts",
+ type=int,
+ default=10,
+ help=(
+ "Number of blog posts to create (default: 10). Each post will have "
+ "unique titles, slugs, content, authors, and tags."
+ ),
+ )
+ parser.add_argument(
+ "--authors",
+ type=int,
+ default=3,
+ help=(
+ "Number of authors to create (default: 3). If authors already exist, "
+ "they will be reused instead of creating new ones."
+ ),
+ )
+ parser.add_argument(
+ "--clear",
+ action="store_true",
+ help=(
+ "Clear existing blog content (posts and index pages) before creating "
+ "new content. Authors are preserved to maintain relationships."
+ ),
+ )
+
+ def handle(self, *args, **options):
+ try:
+ # Get the home page
+ home_page = HomePage.objects.first()
+ if not home_page:
+ self.stdout.write(
+ self.style.ERROR(
+ "No home page found. Please create a home page first."
+ )
+ )
+ return
+
+ # Clear existing content if requested
+ if options["clear"]:
+ self.clear_blog_content()
+ self.clear_authors()
+ self.clear_tags()
+ # Refresh home page from database after clearing content
+ home_page.refresh_from_db()
+
+ # Create or get blog index page
+ blog_index = self.create_blog_index(home_page)
+
+ # Create blog tag index page
+ self.create_blog_tag_index(home_page)
+
+ # Create sample authors
+ authors = self.create_authors(options["authors"])
+
+ # Create blog posts
+ self.create_blog_posts(blog_index, authors, options["posts"])
+
+ self.stdout.write(
+ self.style.SUCCESS(
+ f"Successfully created blog structure with {options['posts']} posts "
+ f"and {len(authors)} authors"
+ )
+ )
+
+ except Exception as e:
+ self.stdout.write(self.style.ERROR(f"An error occurred: {str(e)}"))
+
+ def clear_blog_content(self):
+ """Clear existing blog content"""
+
+ # Then delete the index pages, children also deleted
+ blog_indices = BlogIndexPage.objects.all()
+ for index in blog_indices:
+ index.delete()
+ self.stdout.write("Cleared existing blog index pages")
+
+ tag_indices = BlogTagIndexPage.objects.all()
+ for tag_index in tag_indices:
+ tag_index.delete()
+ self.stdout.write("Cleared existing blog tag pages")
+
+ def clear_authors(self):
+ """Clear all authors"""
+ Author.objects.all().delete()
+ self.stdout.write("Cleared all authors")
+
+ def clear_tags(self):
+ """Clear all blog tags"""
+ BlogPage.tags.through.objects.all().delete()
+ self.stdout.write("Cleared all blog tags")
+
+ def create_blog_index(self, home_page):
+ """Create or get the blog index page"""
+ # Try to get existing blog index that's a child of home page
+ blog_index = home_page.get_children().type(BlogIndexPage).first()
+
+ if not blog_index:
+ blog_index = BlogIndexPage(
+ title="Blog",
+ slug="blog",
+ intro=(
+ "
Welcome to our blog! Here you'll find the latest news, "
+ "insights, and stories from our team.
"
+ ),
+ )
+ home_page.add_child(instance=blog_index)
+ blog_index.save_revision().publish()
+ self.stdout.write("Created blog index page")
+ else:
+ self.stdout.write("Blog index page already exists")
+
+ return blog_index
+
+ def create_blog_tag_index(self, home_page):
+ """Create or get the blog tag index page"""
+ # Try to get existing blog tag index that's a child of home page
+ tag_index = home_page.get_children().type(BlogTagIndexPage).first()
+
+ if not tag_index:
+ tag_index = BlogTagIndexPage(
+ title="Blog Tags",
+ slug="blog-tags",
+ )
+ home_page.add_child(instance=tag_index)
+ tag_index.save_revision().publish()
+ self.stdout.write("Created blog tag index page")
+ else:
+ self.stdout.write("Blog tag index page already exists")
+
+ return tag_index
+
+ def create_authors(self, num_authors):
+ """Create sample authors"""
+ existing_authors = Author.objects.all()
+ if existing_authors.exists():
+ self.stdout.write(f"Using {existing_authors.count()} existing authors")
+ return list(existing_authors)
+
+ author_names = [
+ "Alice Johnson",
+ "Bob Smith",
+ "Carol Davis",
+ "David Wilson",
+ "Eva Brown",
+ "Frank Miller",
+ "Grace Lee",
+ "Henry Taylor",
+ "Ivy Chen",
+ "Jack Thompson",
+ ]
+
+ authors = []
+ available_images = list(Image.objects.all())
+
+ for i in range(min(num_authors, len(author_names))):
+ author = Author.objects.create(
+ name=author_names[i],
+ author_image=(
+ random.choice(available_images) if available_images else None
+ ),
+ )
+ authors.append(author)
+
+ self.stdout.write(f"Created {len(authors)} authors")
+ return authors
+
+ def create_blog_posts(self, blog_index, authors, num_posts):
+ """Create sample blog posts"""
+
+ # Sample blog post data
+ post_topics = [
+ "Getting Started with Wagtail CMS",
+ "Building Modern Web Applications",
+ "The Future of Content Management",
+ "Django Development Best Practices",
+ "Responsive Web Design Tips",
+ "SEO Optimization Strategies",
+ "User Experience Design Principles",
+ "Digital Marketing Trends",
+ "Web Performance Optimization",
+ "Accessibility in Web Development",
+ "Progressive Web Applications",
+ "API Design and Development",
+ "Database Optimization Techniques",
+ "Security Best Practices",
+ "DevOps and Deployment Strategies",
+ ]
+
+ blog_tags = [
+ "wagtail",
+ "django",
+ "python",
+ "web-development",
+ "cms",
+ "frontend",
+ "backend",
+ "design",
+ "ux",
+ "seo",
+ "performance",
+ "security",
+ "api",
+ "database",
+ "devops",
+ ]
+
+ available_images = list(Image.objects.all())
+
+ for i in range(num_posts):
+ # Generate unique blog post content
+ topic = post_topics[i % len(post_topics)]
+ post_date = date.today() - timedelta(days=random.randint(1, 365))
+
+ # Select random authors (1-3 authors per post)
+ post_authors = random.sample(
+ authors, k=random.randint(1, min(3, len(authors)))
+ )
+
+ # Select random tags (2-4 tags per post)
+ post_tags = random.sample(blog_tags, k=random.randint(2, 4))
+
+ # Generate unique title
+ unique_title = f"{topic} - {post_date.strftime('%B %Y')} Edition"
+ intro = self.generate_intro(topic)
+ body = self.generate_body(topic)
+
+ blog_post = blog_index.add_child(
+ instance=BlogPage(
+ title=unique_title,
+ date=post_date,
+ intro=intro,
+ body=body,
+ )
+ )
+
+ # Add authors
+ blog_post.authors.set(post_authors)
+
+ # Add tags
+ for tag in post_tags:
+ blog_post.tags.add(tag)
+
+ # Add gallery images (1-6 images per post)
+ if available_images:
+ num_images = random.randint(1, min(6, len(available_images)))
+ selected_images = random.sample(available_images, k=num_images)
+
+ for idx, image in enumerate(selected_images):
+ BlogPageGalleryImage.objects.create(
+ page=blog_post,
+ image=image,
+ caption=f"Image {idx + 1} for {blog_post.title}",
+ )
+
+ revision = blog_post.save_revision()
+ revision.publish()
+
+ self.stdout.write(f"Created {num_posts} blog posts")
+
+ def generate_intro(self, topic):
+ """Generate sample introduction for blog post"""
+ intros = {
+ "Getting Started with Wagtail CMS": (
+ "Learn the basics of Wagtail CMS and how to build your first "
+ "content-driven website with this powerful Django-based platform."
+ ),
+ "Building Modern Web Applications": (
+ "Explore the latest techniques and tools for creating responsive, "
+ "scalable web applications that meet today's user expectations."
+ ),
+ "The Future of Content Management": (
+ "Discover emerging trends in content management systems and how "
+ "they're shaping the digital landscape."
+ ),
+ "Django Development Best Practices": (
+ "Master the art of Django development with proven patterns, "
+ "conventions, and techniques used by experienced developers."
+ ),
+ "Responsive Web Design Tips": (
+ "Create websites that look great on any device with these essential "
+ "responsive design principles and practical implementation tips."
+ ),
+ }
+ return intros.get(
+ topic,
+ f"An in-depth look at {topic.lower()} and its practical applications "
+ f"in modern web development.",
+ )
+
+ def generate_body(self, topic):
+ """Generate sample body content for blog post"""
+ return f"""
+
Introduction
+
In this comprehensive guide, we'll explore {topic.lower()} and its
+ importance in modern web development. Whether you're a beginner or an experienced developer,
+ this article will provide valuable insights and practical examples.
+
+
Key Concepts
+
Understanding the fundamental concepts is crucial for success. We'll cover the most
+ important aspects that every developer should know about this topic.
+
+
+
Core principles and methodologies
+
Best practices and common patterns
+
Tools and frameworks that can help
+
Real-world applications and use cases
+
+
+
Implementation Guide
+
Let's dive into the practical implementation details. This section provides step-by-step
+ instructions and code examples to help you get started.
+
+
The implementation process involves several key steps:
+
+
Planning and Setup: Prepare your development environment and plan
+ your approach
+
Core Implementation: Build the main functionality following best
+ practices
+
Testing and Optimization: Ensure your implementation works correctly
+ and performs well
+
Deployment and Maintenance: Deploy your solution and keep it
+ updated
+
+
+
Advanced Techniques
+
For those looking to take their skills to the next level, here are some advanced
+ techniques and considerations that can make a significant difference in your projects.
+
+
Conclusion
+
By following the guidelines and best practices outlined in this article, you'll be
+ well-equipped to tackle {topic.lower()} in your own projects. Remember to
+ keep learning and stay updated with the latest developments in the field.
+
+
+
+ {% with authors=page.authors.all %}
+ {% if authors %}
+
Posted by:
+ {% for author in authors %}
+
+ {% image author.author_image fill-40x40 as author_image %}
+ {% if author_image %}
+
+ {% else %}
+
+ {% endif %}
+ {{ author.name }}
+
+ {% endfor %}
+ {% endif %}
+ {% endwith %}
+
+ {% blog_tags_page as tags_page %}
+ {% with tags=page.tags.all %}
+ {% if tags %}
+ Tags:
+ {% if tags_page %}
+ {% for tag in tags %}
+ {{ tag }}
+ {% endfor %}
+ {% else %}
+
Create a blog tags page
+ {% endif %}
+ {% endif %}
+ {% endwith %}
+
+
+
+
+
+
+
+
{{ page.intro }}
+ {{ page.body|richtext }}
+
+
+
+
+ {% for item in page.gallery_images.all %}
+ {% if forloop.first or forloop.counter0|divisibleby:3 %}
+ {% comment %} Start a new row {% endcomment %}
+
+ {% endif %}
+
+
+
+
+
+{% endblock %}
diff --git a/app/blog/templatetags/__init__.py b/app/blog/templatetags/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/app/blog/templatetags/blog_tags.py b/app/blog/templatetags/blog_tags.py
new file mode 100644
index 0000000..310d0ae
--- /dev/null
+++ b/app/blog/templatetags/blog_tags.py
@@ -0,0 +1,23 @@
+from django import template
+
+from app.blog.models import BlogIndexPage, BlogTagIndexPage
+
+register = template.Library()
+
+
+@register.simple_tag
+def blog_index_page():
+ """
+ Get the blog index page if it exists.
+ """
+
+ return BlogIndexPage.objects.live().first() or None
+
+
+@register.simple_tag
+def blog_tags_page():
+ """
+ Get the blog tags page if it exists.
+ """
+
+ return BlogTagIndexPage.objects.live().first() or None
diff --git a/app/blog/tests.py b/app/blog/tests.py
new file mode 100644
index 0000000..fb5c465
--- /dev/null
+++ b/app/blog/tests.py
@@ -0,0 +1,122 @@
+from io import StringIO
+
+from django.core.management import call_command
+from django.test import TestCase
+from wagtail.models import Site
+
+from app.blog.models import Author, BlogIndexPage, BlogPage, BlogTagIndexPage
+from app.home.models import HomePage
+
+
+class PopulateBlogTestCase(TestCase):
+ def setUp(self):
+ # Get or create the root page and site
+ from wagtail.models import Page
+
+ try:
+ root = Page.objects.get(slug="root")
+ except Page.DoesNotExist:
+ root = Page.add_root(title="Root", slug="root")
+
+ # Create a home page for testing
+ self.home_page = HomePage(
+ title="Test Home",
+ slug="test-home",
+ )
+ root.add_child(instance=self.home_page)
+
+ # Create site if it doesn't exist
+ if not Site.objects.exists():
+ Site.objects.create(
+ hostname="localhost",
+ port=8000,
+ root_page=self.home_page,
+ is_default_site=True,
+ )
+
+ def test_populate_blog_basic(self):
+ """Test basic blog population"""
+ out = StringIO()
+
+ # Run the command
+ call_command("populate_blog", "--posts", "3", "--authors", "2", stdout=out)
+
+ # Check that content was created
+ self.assertEqual(BlogIndexPage.objects.count(), 1)
+ self.assertEqual(BlogTagIndexPage.objects.count(), 1)
+ self.assertEqual(BlogPage.objects.count(), 3)
+ self.assertEqual(Author.objects.count(), 2)
+
+ # Check success message
+ self.assertIn(
+ "Successfully created blog structure with 3 posts and 2 authors",
+ out.getvalue(),
+ )
+
+ def test_populate_blog_with_existing_authors(self):
+ """Test that existing authors are reused"""
+ # Create an existing author
+ Author.objects.create(name="Existing Author")
+
+ out = StringIO()
+
+ # Run the command
+ call_command("populate_blog", "--posts", "2", "--authors", "3", stdout=out)
+
+ # Should still have only 1 author (the existing one)
+ self.assertEqual(Author.objects.count(), 1)
+ self.assertIn("Using 1 existing authors", out.getvalue())
+
+ def test_populate_blog_clear_option(self):
+ """Test the clear option functionality"""
+ # Create some initial content
+ call_command("populate_blog", "--posts", "2", "--authors", "1")
+
+ # Verify initial content exists
+ self.assertEqual(BlogPage.objects.count(), 2)
+
+ out = StringIO()
+
+ # Run with clear option - focus on testing the clear messages
+ call_command(
+ "populate_blog", "--clear", "--posts", "1", "--authors", "1", stdout=out
+ )
+
+ # Check that clear messages appeared
+ output = out.getvalue()
+ self.assertIn("Cleared existing blog index pages", output)
+ self.assertIn("Cleared existing blog tag pages", output)
+ self.assertIn("Cleared all authors", output)
+ self.assertIn("Cleared all blog tags", output)
+
+ def test_blog_post_structure(self):
+ """Test that blog posts have proper structure and relationships"""
+ call_command("populate_blog", "--posts", "2", "--authors", "2")
+
+ blog_post = BlogPage.objects.first()
+
+ # Check that the blog post has required fields
+ self.assertTrue(blog_post.title)
+ self.assertTrue(blog_post.intro)
+ self.assertTrue(blog_post.body)
+ self.assertTrue(blog_post.date)
+
+ # Check that it has authors and tags
+ self.assertTrue(blog_post.authors.exists())
+ self.assertTrue(blog_post.tags.exists())
+
+ # Check that it's a child of blog index
+ blog_index = BlogIndexPage.objects.first()
+ self.assertEqual(blog_post.get_parent().specific, blog_index)
+
+ def test_blog_index_structure(self):
+ """Test that blog index page is properly structured"""
+ call_command("populate_blog", "--posts", "1", "--authors", "1")
+
+ blog_index = BlogIndexPage.objects.first()
+ home_page = HomePage.objects.first()
+
+ # Check that blog index is a child of home page
+ self.assertEqual(blog_index.get_parent().specific, home_page)
+ self.assertEqual(blog_index.slug, "blog")
+ self.assertTrue(blog_index.intro)
diff --git a/app/home/management/commands/populate_homepage.py b/app/home/management/commands/populate_homepage.py
new file mode 100644
index 0000000..29f39c7
--- /dev/null
+++ b/app/home/management/commands/populate_homepage.py
@@ -0,0 +1,121 @@
+import random
+
+from django.core.management.base import BaseCommand
+from wagtail.images.models import Image
+
+from app.home.models import HomePage
+
+
+class Command(BaseCommand):
+ help = "Populates the existing home page with sample body content"
+
+ def add_arguments(self, parser):
+ parser.add_argument(
+ "--overwrite",
+ action="store_true",
+ help="Overwrite existing body content if it exists",
+ )
+
+ def handle(self, *args, **options):
+ try:
+ # Get the existing home page
+ home_page = HomePage.objects.get()
+
+ # Check if body content already exists
+ if home_page.body and not options["overwrite"]:
+ self.stdout.write(
+ self.style.WARNING(
+ "Home page already has body content. Use --overwrite to replace it."
+ )
+ )
+ self.stdout.write(
+ f"Current content length: {len(home_page.body)} characters"
+ )
+ return
+
+ # Check for existing images
+ available_images = Image.objects.all()
+ selected_image = None
+ image_embed = ""
+
+ if available_images.exists():
+ # Select a random image
+ selected_image = random.choice(available_images)
+ # Create embed code for the image
+ image_embed = (
+ f''
+ )
+ self.stdout.write(f"Selected image: {selected_image.title}")
+ else:
+ self.stdout.write(
+ "No images found - content will be created without images"
+ )
+
+ # Sample body content with optional image
+ sample_content = f"""
+
Welcome to Your Wagtail Site
+
+
This is your homepage, built with Wagtail CMS. Wagtail is a powerful,
+developer-friendly content management system built on Django that makes it easy to create
+beautiful, engaging websites.
+
+{image_embed}
+
+
Getting Started
+
+
You can edit this content by going to the Wagtail admin and
+selecting your home page. From there, you can:
+
+
+
Add and edit content using the rich text editor
+
Create new pages and organize your site structure
+
Upload and manage images and documents
+
Customize your site's design and functionality
+
+
+
Features
+
+
This starter kit includes:
+
+
+
Docker Development Environment - Easy setup and consistent development experience
+
Multiple Database Options - PostgreSQL, MySQL, or SQLite3
+
Frontend Build Tools - SASS compilation and JavaScript bundling
+
Pico CSS Framework - Clean, semantic styling
+
Management Commands - Useful utilities for development and testing
+
+
+
Next Steps
+
+
Now that you have your site running, consider:
+
+
+
Exploring the Style Guide to see available components