djpress 0.1__tar.gz

djpress-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stuart Maxwell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

djpress-0.1/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+recursive-include djpress/static *
+recursive-include djpress/templates *
+recursive-include docs *

djpress-0.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: djpress
+Version: 0.1
+Summary: A blog application for Django sites, inspired by classic WordPress.
+Author-email: Stuart Maxwell <stuart@amanzi.nz>
+License: MIT License
+        
+        Copyright (c) 2024 Stuart Maxwell
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/stuartmaxwell/djpress
+Project-URL: Repository, https://github.com/stuartmaxwell/djpress
+Project-URL: Issues, https://github.com/stuartmaxwell/djpress/issues
+Keywords: django,blog,cms,markdown,wordpress
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django
+Requires-Dist: markdown
+
+# DJ Press
+
+A blog application for Django sites, inspired by classic WordPress.
+
+> Warning - very alpha.

djpress-0.1/README.md

@@ -0,0 +1,5 @@
+# DJ Press
+
+A blog application for Django sites, inspired by classic WordPress.
+
+> Warning - very alpha.

djpress-0.1/djpress/__init__.py

@@ -0,0 +1 @@
+"""djpress module."""

djpress-0.1/djpress/admin.py

@@ -0,0 +1,9 @@
+"""djpress admin configuration."""
+
+from django.contrib import admin
+
+# Register the models here.
+from djpress.models import Category, Post
+
+admin.site.register(Category)
+admin.site.register(Post)

djpress-0.1/djpress/apps.py

@@ -0,0 +1,15 @@
+"""Djpress app configuration."""
+
+from django.apps import AppConfig
+
+
+class DjpressConfig(AppConfig):
+    """Djpress app configuration."""
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "djpress"
+    label = "djpress"
+
+    def ready(self: "DjpressConfig") -> None:
+        """Import signals."""
+        import djpress.signals  # noqa: F401

djpress-0.1/djpress/feeds.py

@@ -0,0 +1,42 @@
+"""RSS feed for blog posts."""
+
+from typing import TYPE_CHECKING
+
+from django.contrib.syndication.views import Feed
+from django.urls import reverse
+
+from djpress.models import Post
+
+if TYPE_CHECKING:
+    from django.db import models
+
+
+class PostFeed(Feed):
+    """RSS feed for blog posts."""
+
+    title = "stuartm.nz"
+    link = "/rss"
+    description = "stuartm.nz updates"
+
+    def items(self: "PostFeed") -> "models.QuerySet":
+        """Return the most recent posts."""
+        return Post.post_objects.get_recent_published_posts()
+
+    def item_title(self: "PostFeed", item: Post) -> str:
+        """Return the title of the post."""
+        return item.title
+
+    def item_description(self: "PostFeed", item: Post) -> str:
+        """Return the description of the post.
+
+        This is taken from the truncated content of the post converted to HTML from
+        Markdown.
+        """
+        description = item.truncated_content_markdown
+        if item.is_truncated:
+            description += f'<p><a href="{self.item_link(item)}">Read more</a></p>'
+        return description
+
+    def item_link(self: "PostFeed", item: Post) -> str:
+        """Return the link to the post."""
+        return reverse("djpress:post_detail", args=[item.permalink])

djpress-0.1/djpress/migrations/0001_initial.py

@@ -0,0 +1,50 @@
+# Generated by Django 5.0.4 on 2024-05-02 10:46
+
+import django.db.models.deletion
+import django.utils.timezone
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Category',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('slug', models.SlugField(blank=True, unique=True)),
+                ('description', models.TextField(blank=True)),
+            ],
+            options={
+                'verbose_name': 'category',
+                'verbose_name_plural': 'categories',
+            },
+        ),
+        migrations.CreateModel(
+            name='Post',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('slug', models.SlugField(blank=True, unique=True)),
+                ('content', models.TextField()),
+                ('date', models.DateTimeField(default=django.utils.timezone.now)),
+                ('modified_date', models.DateTimeField(auto_now=True)),
+                ('status', models.CharField(choices=[('draft', 'Draft'), ('published', 'Published')], default='draft', max_length=10)),
+                ('content_type', models.CharField(choices=[('post', 'Post'), ('page', 'Page')], default='post', max_length=10)),
+                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('categories', models.ManyToManyField(blank=True, to='djpress.category')),
+            ],
+            options={
+                'verbose_name': 'post',
+                'verbose_name_plural': 'posts',
+            },
+        ),
+    ]

djpress-0.1/djpress/migrations/0002_rename_content_type_post_post_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0.4 on 2024-05-03 11:04
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djpress', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='post',
+            old_name='content_type',
+            new_name='post_type',
+        ),
+    ]

djpress-0.1/djpress/migrations/__init__.py

@@ -0,0 +1 @@
+"""Migrations for the djpress app."""

djpress-0.1/djpress/models/__init__.py

@@ -0,0 +1,4 @@
+"""Models package for djpress app."""
+
+from djpress.models.category import Category  # noqa: F401
+from djpress.models.post import Post  # noqa: F401

djpress-0.1/djpress/models/category.py

@@ -0,0 +1,96 @@
+"""Category model."""
+
+from django.conf import settings
+from django.core.cache import cache
+from django.db import IntegrityError, models, transaction
+from django.utils.text import slugify
+
+CATEGORY_CACHE_KEY = "categories"
+
+
+class CategoryManager(models.Manager):
+    """Category manager."""
+
+    def get_categories(self: "CategoryManager") -> models.QuerySet:
+        """Return the queryset for categories.
+
+        If CACHE_CATEGORIES is set to True, we return the cached queryset.
+        """
+        if settings.CACHE_CATEGORIES:
+            return self._get_cached_categories()
+
+        return self.all()
+
+    def _get_cached_categories(self: "CategoryManager") -> models.QuerySet:
+        """Return the cached categories queryset."""
+        queryset = cache.get(CATEGORY_CACHE_KEY)
+
+        if queryset is None:
+            queryset = self.all()
+            cache.set(CATEGORY_CACHE_KEY, queryset, timeout=None)
+
+        return queryset
+
+    def get_category_by_slug(self: "CategoryManager", slug: str) -> "Category":
+        """Return a single category by its slug."""
+        # First, try to get the category from the cache
+        categories = self.get_categories()
+        category = next(
+            (category for category in categories if category.slug == slug),
+            None,
+        )
+
+        # If the category is not found in the cache, fetch it from the database
+        if not category:
+            try:
+                category = self.get(slug=slug)
+            except Category.DoesNotExist as exc:
+                msg = "Category not found"
+                # Raise a 404 error
+                raise ValueError(msg) from exc
+
+        return category
+
+
+class Category(models.Model):
+    """Category model."""
+
+    name = models.CharField(max_length=100)
+    slug = models.SlugField(unique=True, blank=True)
+    description = models.TextField(blank=True)
+
+    # Custom Manager
+    objects: "CategoryManager" = CategoryManager()
+
+    class Meta:
+        """Meta options for the category model."""
+
+        verbose_name = "category"
+        verbose_name_plural = "categories"
+
+    def __str__(self: "Category") -> str:
+        """Return the string representation of the category."""
+        return self.name
+
+    def save(self: "Category", *args, **kwargs) -> None:  # noqa: ANN002, ANN003
+        """Override the save method to auto-generate the slug."""
+        if not self.slug:
+            self.slug = slugify(self.name)
+            if not self.slug or self.slug.strip("-") == "":
+                msg = "Invalid name. Unable to generate a valid slug."
+                raise ValueError(msg)
+
+        try:
+            with transaction.atomic():
+                super().save(*args, **kwargs)
+        except IntegrityError as exc:
+            msg = f"A category with the slug {self.slug} already exists."
+            raise ValueError(msg) from exc
+
+    @property
+    def permalink(self: "Category") -> str:
+        """Return the category's permalink."""
+        if settings.CATEGORY_PATH_ENABLED and settings.CATEGORY_PATH:
+            return f"{settings.CATEGORY_PATH}/{self.slug}"
+
+        return f"{self.slug}"

djpress-0.1/djpress/models/post.py

@@ -0,0 +1,277 @@
+"""Post model."""
+
+import logging
+from typing import ClassVar
+
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.core.cache import cache
+from django.db import models
+from django.utils import timezone
+from django.utils.text import slugify
+
+from djpress.models import Category
+from djpress.utils import render_markdown
+
+logger = logging.getLogger(__name__)
+
+
+PUBLISHED_POSTS_CACHE_KEY = "published_posts"
+
+
+class PostsManager(models.Manager):
+    """Post custom manager."""
+
+    def get_queryset(self: "PostsManager") -> models.QuerySet:
+        """Return the queryset for published posts."""
+        return super().get_queryset().filter(post_type="post").order_by("-date")
+
+    def _get_published_posts(self: "PostsManager") -> models.QuerySet:
+        """Returns all published posts.
+
+        For a post to be considered published, it must meet the following requirements:
+        - The status must be "published".
+        - The date must be less than or equal to the current date/time.
+        """
+        return self.get_queryset().filter(
+            status="published",
+            date__lte=timezone.now(),
+        )
+
+    def get_recent_published_posts(self: "PostsManager") -> models.QuerySet:
+        """Return recent published posts.
+
+        If CACHE_RECENT_PUBLISHED_POSTS is set to True, we return the cached queryset.
+        """
+        if settings.CACHE_RECENT_PUBLISHED_POSTS:
+            return self._get_cached_recent_published_posts()
+
+        return self._get_published_posts().prefetch_related("categories", "author")[
+            : settings.RECENT_PUBLISHED_POSTS_COUNT
+        ]
+
+    def _get_cached_recent_published_posts(self: "PostsManager") -> models.QuerySet:
+        """Return the cached recent published posts queryset.
+
+        If there are any future posts, we calculate the seconds until that post, then we
+        set the timeout to that number of seconds.
+        """
+        queryset = cache.get(PUBLISHED_POSTS_CACHE_KEY)
+
+        if queryset is None:
+            queryset = (
+                self.get_queryset()
+                .filter(
+                    status="published",
+                )
+                .prefetch_related("categories", "author")
+            )
+
+            future_posts = queryset.filter(date__gt=timezone.now())
+            if future_posts.exists():
+                future_post = future_posts[0]
+                timeout = (future_post.date - timezone.now()).total_seconds()
+            else:
+                timeout = None
+
+            queryset = queryset.filter(date__lte=timezone.now())[
+                : settings.RECENT_PUBLISHED_POSTS_COUNT
+            ]
+            cache.set(
+                PUBLISHED_POSTS_CACHE_KEY,
+                queryset,
+                timeout=timeout,
+            )
+
+        return queryset
+
+    def get_published_post_by_slug(
+        self: "PostsManager",
+        slug: str,
+    ) -> "Post":
+        """Return a single published post.
+
+        Must have a date less than or equal to the current date/time based on its slug.
+        """
+        # First, try to get the post from the cache
+        posts = self.get_recent_published_posts()
+        post = next((post for post in posts if post.slug == slug), None)
+
+        # If the post is not found in the cache, fetch it from the database
+        if not post:
+            try:
+                post = self._get_published_posts().get(slug=slug)
+            except Post.DoesNotExist as exc:
+                msg = "Post not found"
+                raise ValueError(msg) from exc
+
+        return post
+
+    def get_published_post_by_path(
+        self: "PostsManager",
+        path: str,
+    ) -> "Post":
+        """Return a single published post from a path.
+
+        This is a complex piece of logic...
+
+        Here are all the different valid paths that we need to check:
+        - /blog/2021/01/01/post-slug
+        - /blog/2021/01/post-slug
+        - /blog/2021/post-slug
+        - /blog/post-slug
+        - /2021/01/01/post-slug
+        - /2021/01/post-slug
+        - /2021/post-slug
+        - /post-slug
+
+        But we could be getting any invalid path too, e.g.
+        - /blog/2021/01/01/post-slug/extra
+        - /blog/2021/01/post-slug/extra
+        - etc.
+
+        This is what we need to do...
+
+        First, we need to know the following:
+        - Is there a POST_PREFIX defined?
+        - Are DATE_ARCHIVES enabled?
+        - If DATE_ARCHIVES are enabled, what is the POST_PERMALINK set to?
+
+        I don't think I can avoid regex matching here...
+
+        For now we'll just look at the POST_PREFIX.
+        """
+        if settings.POST_PREFIX and path.startswith(settings.POST_PREFIX):
+            slug = path.split(settings.POST_PREFIX + "/")[1]
+            return self.get_published_post_by_slug(slug)
+
+        if settings.POST_PREFIX and not path.startswith(settings.POST_PREFIX):
+            msg = "Invalid path"
+            raise ValueError(msg)
+
+        return self.get_published_post_by_slug(path)
+
+    def get_published_posts_by_category(
+        self: "PostsManager",
+        category: Category,
+    ) -> models.QuerySet:
+        """Return all published posts for a given category.
+
+        Must have a date less than or equal to the current date/time for a specific
+        category, ordered by date in descending order.
+        """
+        return (
+            self._get_published_posts()
+            .filter(categories=category)
+            .prefetch_related("categories", "author")
+        )
+
+    def get_published_posts_by_author(
+        self: "PostsManager",
+        author: User,
+    ) -> models.QuerySet:
+        """Return all published posts for a given author.
+
+        Must have a date less than or equal to the current date/time for a specific
+        author, ordered by date in descending order.
+        """
+        return (
+            self._get_published_posts()
+            .filter(author=author)
+            .prefetch_related("categories", "author")
+        )
+
+
+class Post(models.Model):
+    """Post model."""
+
+    STATUS_CHOICES: ClassVar = [("draft", "Draft"), ("published", "Published")]
+    CONTENT_TYPE_CHOICES: ClassVar = [("post", "Post"), ("page", "Page")]
+
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(unique=True, blank=True)
+    content = models.TextField()
+    author = models.ForeignKey(User, on_delete=models.CASCADE)
+    date = models.DateTimeField(default=timezone.now)
+    modified_date = models.DateTimeField(auto_now=True)
+    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default="draft")
+    post_type = models.CharField(
+        max_length=10,
+        choices=CONTENT_TYPE_CHOICES,
+        default="post",
+    )
+    categories = models.ManyToManyField(Category, blank=True)
+
+    # Managers
+    objects = models.Manager()
+    post_objects: "PostsManager" = PostsManager()
+
+    class Meta:
+        """Meta options for the Post model."""
+
+        verbose_name = "post"
+        verbose_name_plural = "posts"
+
+    def __str__(self: "Post") -> str:
+        """Return the string representation of the post."""
+        return self.title
+
+    def save(self: "Post", *args, **kwargs) -> None:  # noqa: ANN002, ANN003
+        """Override the save method to auto-generate the slug."""
+        if not self.slug:
+            self.slug = slugify(self.title)
+            if not self.slug or self.slug.strip("-") == "":
+                msg = "Invalid title. Unable to generate a valid slug."
+                raise ValueError(msg)
+        super().save(*args, **kwargs)
+
+    @property
+    def content_markdown(self: "Post") -> str:
+        """Return the content as HTML converted from Markdown."""
+        return render_markdown(self.content)
+
+    @property
+    def truncated_content_markdown(self: "Post") -> str:
+        """Return the truncated content as HTML converted from Markdown."""
+        read_more_index = self.content.find(settings.TRUNCATE_TAG)
+        if read_more_index != -1:
+            truncated_content = self.content[:read_more_index]
+        else:
+            truncated_content = self.content
+        return render_markdown(truncated_content)
+
+    @property
+    def is_truncated(self: "Post") -> bool:
+        """Return whether the content is truncated."""
+        return settings.TRUNCATE_TAG in self.content
+
+    @property
+    def permalink(self: "Post") -> str:
+        """Return the post's permalink.
+
+        The posts permalink is constructed of the following elements:
+        - The post prefix - this is configured in POST_PREFIX and could be an empty
+          string or a custom string, e.g. `blog` or `posts`.
+        - The post date structure - this is configured in POST_PERMALINK and is a
+          `strftime` value, e.g. `%Y/%m/%d` or `%Y/%m`. Or it could be an empty string
+          to indicate that no date structure is used.
+        - The post slug - this is a unique identifier for the post. TODO: should this be
+          a database unique constraint, or should we handle it in software instead?
+        """
+        # We start the permalink with just the slug
+        permalink = self.slug
+
+        # If the post type is a page, we return just the slug
+        if self.post_type == "page":
+            return permalink
+
+        # The only other post type is a post so we don't need to check for that
+        # If there's a permalink structure defined, we add that to the permalink
+        if settings.POST_PERMALINK:
+            permalink = f"{self.date.strftime(settings.POST_PERMALINK)}/{self.slug}"
+
+        # If there's a post prefix defined, we add that to the permalink
+        if settings.POST_PREFIX:
+            permalink = f"{settings.POST_PREFIX}/{permalink}"
+
+        return permalink

djpress-0.1/djpress/signals.py

@@ -0,0 +1,28 @@
+"""Signals for djpress app."""
+
+from django.core.cache import cache
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+
+from djpress.models.category import (
+    CATEGORY_CACHE_KEY,
+    Category,
+)
+from djpress.models.post import (
+    PUBLISHED_POSTS_CACHE_KEY,
+    Post,
+)
+
+
+@receiver(post_save, sender=Category)
+@receiver(post_delete, sender=Category)
+def invalidate_category_cache(**kwargs) -> None:  # noqa: ARG001, ANN003
+    """Invalidate the category cache."""
+    cache.delete(CATEGORY_CACHE_KEY)
+
+
+@receiver(post_save, sender=Post)
+@receiver(post_delete, sender=Post)
+def invalidate_published_content_cache(**kwargs) -> None:  # noqa: ARG001, ANN003
+    """Invalidate the published posts cache."""
+    cache.delete(PUBLISHED_POSTS_CACHE_KEY)