🤣 CMS table and API for jokes, questions etc

Author: hardbyte

alembic/versions/281723ba07be_add_cms_content_table.py

@@ -0,0 +1,58 @@
+"""add cms content table
+
+Revision ID: 281723ba07be
+Revises: 156d8781d7b8
+Create Date: 2024-06-23 12:00:32.297761
+
+"""
+
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "281723ba07be"
+down_revision = "156d8781d7b8"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "cms_content",
+        sa.Column(
+            "id", sa.UUID(), server_default=sa.text("gen_random_uuid()"), nullable=False
+        ),
+        sa.Column(
+            "type",
+            sa.Enum("JOKE", "QUESTION", "FACT", "QUOTE", name="enum_cms_content_type"),
+            nullable=False,
+        ),
+        sa.Column("content", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            server_default=sa.text("CURRENT_TIMESTAMP"),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(),
+            server_default=sa.text("CURRENT_TIMESTAMP"),
+            nullable=False,
+        ),
+        sa.Column("user_id", sa.UUID(), nullable=True),
+        sa.ForeignKeyConstraint(
+            ["user_id"], ["users.id"], name="fk_content_user", ondelete="CASCADE"
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_cms_content_id"), "cms_content", ["id"], unique=True)
+    op.create_index(op.f("ix_cms_content_type"), "cms_content", ["type"], unique=False)
+
+
+def downgrade():
+    op.drop_index(op.f("ix_cms_content_type"), table_name="cms_content")
+    op.drop_index(op.f("ix_cms_content_id"), table_name="cms_content")
+    op.drop_table("cms_content")

app/api/cms.py

@@ -0,0 +1,62 @@
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, Security
+from starlette import status
+from structlog import get_logger
+
+from app import crud
+from app.api.common.pagination import PaginatedQueryParams
+from app.api.dependencies.async_db_dep import DBSessionDep
+from app.api.dependencies.security import (
+    get_current_active_superuser_or_backend_service_account,
+)
+from app.models import ContentType
+from app.schemas.cms_content import CMSContentResponse
+from app.schemas.pagination import Pagination
+
+logger = get_logger()
+
+router = APIRouter(
+    tags=["Digital Content Management System"],
+    dependencies=[Security(get_current_active_superuser_or_backend_service_account)],
+)
+
+
+@router.get("/content/{content_type}", response_model=CMSContentResponse)
+async def get_cms_content(
+    session: DBSessionDep,
+    content_type: ContentType = Path(
+        description="What type of content to return",
+    ),
+    query: str | None = Query(
+        None,
+        description="A query string to match against content",
+    ),
+    # user_id: UUID = Query(
+    #     None, description="Filter content that are associated with or created by a user"
+    # ),
+    jsonpath_match: str = Query(
+        None,
+        description="Filter using a JSONPath over the content. The resulting value must be a boolean expression.",
+    ),
+    pagination: PaginatedQueryParams = Depends(),
+):
+    """
+    Get a filtered and paginated list of content by content type.
+    """
+    try:
+        data = await crud.content.aget_all_with_optional_filters(
+            session,
+            content_type=content_type,
+            query_string=query,
+            # user=user,
+            jsonpath_match=jsonpath_match,
+            skip=pagination.skip,
+            limit=pagination.limit,
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+
+    return CMSContentResponse(
+        pagination=Pagination(**pagination.to_dict(), total=None), data=data
+    )

app/api/external_api_router.py

@@ -5,6 +5,7 @@
 from app.api.booklists import public_router as booklist_router_public
 from app.api.booklists import router as booklist_router
 from app.api.classes import router as class_group_router
+from app.api.cms import router as cms_content_router
 from app.api.collections import router as collections_router
 from app.api.commerce import router as commerce_router
 from app.api.dashboards import router as dashboard_router
@@ -25,13 +26,13 @@
 
 api_router = APIRouter()
 
-
 api_router.include_router(auth_router)
 api_router.include_router(user_router)
 api_router.include_router(author_router)
 api_router.include_router(booklist_router)
 api_router.include_router(booklist_router_public)
 api_router.include_router(class_group_router)
+api_router.include_router(cms_content_router)
 api_router.include_router(collections_router)
 api_router.include_router(commerce_router)
 api_router.include_router(dashboard_router)

app/crud/__init__.py

@@ -10,6 +10,7 @@
     CRUDCollectionItemActivity,
     collection_item_activity,
 )
+from app.crud.content import CRUDContent, content
 from app.crud.edition import CRUDEdition, edition
 from app.crud.event import CRUDEvent, event
 from app.crud.illustrator import CRUDIllustrator, illustrator

app/crud/content.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from sqlalchemy import cast, func
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.exc import DataError, ProgrammingError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+from structlog import get_logger
+
+from app.crud import CRUDBase
+from app.models import CMSContent, ContentType, User
+
+logger = get_logger()
+
+
+class CRUDContent(CRUDBase[CMSContent, Any, Any]):
+    def get_all_with_optional_filters_query(
+        self,
+        db: Session,
+        content_type: ContentType | None = None,
+        query_string: str | None = None,
+        user: User | None = None,
+        jsonpath_match: str = None,
+    ):
+        query = self.get_all_query(db=db)
+
+        if content_type is not None:
+            query = query.where(CMSContent.type == content_type)
+
+        if user is not None:
+            query = query.where(CMSContent.user == user)
+
+        if jsonpath_match is not None:
+            # Apply the jsonpath filter to the content field
+            query = query.where(
+                func.jsonb_path_match(
+                    cast(CMSContent.content, JSONB), jsonpath_match
+                ).is_(True)
+            )
+
+        return query
+
+    async def aget_all_with_optional_filters(
+        self,
+        db: AsyncSession,
+        content_type: ContentType | None = None,
+        query_string: str | None = None,
+        user: User | None = None,
+        jsonpath_match: str | None = None,
+        skip: int = 0,
+        limit: int = 100,
+    ):
+        optional_filters = {
+            "query_string": query_string,
+            "content_type": content_type,
+            "user": user,
+            "jsonpath_match": jsonpath_match,
+        }
+        logger.debug("Querying digital content", **optional_filters)
+
+        query = self.apply_pagination(
+            self.get_all_with_optional_filters_query(db=db, **optional_filters),
+            skip=skip,
+            limit=limit,
+        )
+        try:
+            return (await db.scalars(query)).all()
+        except (ProgrammingError, DataError) as e:
+            logger.error("Error querying events", error=e, **optional_filters)
+            raise ValueError("Problem filtering content")
+
+
+content = CRUDContent(CMSContent)

app/json_schema/joke.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Content",
+  "type": "object",
+  "properties": {
+    "nodes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "A unique identifier for the node."
+          },
+          "text": {
+            "type": "string",
+            "description": "The text of this node."
+          },
+          "image": {
+            "type": "string",
+            "format": "uri",
+            "description": "URL to an image supporting this node."
+          },
+          "options": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "optionText": {
+                  "type": "string",
+                  "description": "Text of an option presented to the user."
+                },
+                "optionImage": {
+                  "type": "string",
+                  "format": "uri",
+                  "description": "URL to an image supporting this option"
+                },
+                "nextNodeId": {
+                  "type": "string",
+                  "description": "ID of the next node if this option is chosen."
+                }
+              },
+              "required": ["optionText", "nextNodeId"]
+            },
+            "description": "Options presented to the user at this node."
+          }
+        },
+        "required": ["text"]
+      },
+      "description": "The content nodes"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Tags related to the content."
+    }
+  },
+  "required": ["nodes"]
+}

app/models/__init__.py

@@ -2,6 +2,7 @@
 from .booklist import BookList
 from .booklist_work_association import BookListItem
 from .class_group import ClassGroup
+from .cms_content import CMSContent, ContentType
 from .collection import Collection
 from .collection_item import CollectionItem
 from .collection_item_activity import CollectionItemActivity

app/models/cms_content.py

@@ -0,0 +1,73 @@
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from fastapi_permissions import All, Allow
+from sqlalchemy import DateTime, Enum, ForeignKey, func, text
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.ext.mutable import MutableDict
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db import Base
+from app.schemas import CaseInsensitiveStringEnum
+
+
+class ContentType(CaseInsensitiveStringEnum):
+    JOKE = "joke"
+    QUESTION = "question"
+    FACT = "fact"
+    QUOTE = "quote"
+
+
+class CMSContent(Base):
+    __tablename__ = "cms_content"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        default=uuid.uuid4,
+        server_default=text("gen_random_uuid()"),
+        unique=True,
+        primary_key=True,
+        index=True,
+        nullable=False,
+    )
+
+    type: Mapped[ContentType] = mapped_column(
+        Enum(ContentType, name="enum_cms_content_type"), nullable=False, index=True
+    )
+
+    content: Mapped[Optional[dict]] = mapped_column(MutableDict.as_mutable(JSONB))
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=func.current_timestamp()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.current_timestamp(),
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+        nullable=False,
+    )
+
+    user_id: Mapped[Optional[uuid.UUID]] = mapped_column(
+        ForeignKey("users.id", name="fk_content_user", ondelete="CASCADE"),
+        nullable=True,
+    )
+    user: Mapped[Optional["User"]] = relationship(
+        "User", foreign_keys=[user_id], lazy="joined"
+    )
+
+    def __repr__(self):
+        return f"<CMSContent-{self.type} id={self.id}>"
+
+    def __acl__(self):
+        """
+        Defines who can do what to the content
+        """
+
+        policies = [
+            (Allow, "role:admin", All),
+            (Allow, "role:user", "read"),
+        ]
+
+        return policies

app/schemas/cms_content.py

@@ -0,0 +1,9 @@
+from app.schemas.pagination import PaginatedResponse
+
+
+class CMSTypesResponse(PaginatedResponse):
+    data: list[str]
+
+
+class CMSContentResponse(PaginatedResponse):
+    data: list[str]