django-var-cms 1.0.0__tar.gz

django_var_cms-1.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: django-var-cms
+Version: 1.0.0
+Summary: A modern, role-based Django CMS registry with rich media previews
+Requires-Python: >=3.11
+Requires-Dist: django>=5.0
+Requires-Dist: pillow>=10.0
+Requires-Dist: whitenoise>=6.6
+Provides-Extra: dev
+Requires-Dist: django-debug-toolbar>=4.0; extra == 'dev'
+Provides-Extra: geo
+Requires-Dist: django[gis]>=5.0; extra == 'geo'
+Provides-Extra: pdf
+Requires-Dist: pdf2image>=1.16; extra == 'pdf'
+Provides-Extra: tailwind
+Requires-Dist: django-tailwind-cli>=2.0; extra == 'tailwind'

django_var_cms-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "django-var-cms"
+version = "1.0.0"
+description = "A modern, role-based Django CMS registry with rich media previews"
+requires-python = ">=3.11"
+
+dependencies = [
+    "django>=5.0",
+    "pillow>=10.0",
+    "whitenoise>=6.6",
+]
+
+[project.optional-dependencies]
+tailwind = ["django-tailwind-cli>=2.0"]
+geo = ["django[gis]>=5.0"]
+pdf = ["pdf2image>=1.16"]
+dev = ["django-debug-toolbar>=4.0"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/var_cms",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["var_cms"]
+
+[dependency-groups]
+dev = ["django-debug-toolbar>=4.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+

django_var_cms-1.0.0/var_cms/__init__.py

@@ -0,0 +1 @@
+default_app_config = "var_cms.apps.VarCmsConfig"

django_var_cms-1.0.0/var_cms/apps.py

@@ -0,0 +1,19 @@
+from django.apps import AppConfig
+
+
+class VarCmsConfig(AppConfig):
+    name = "var_cms"
+    verbose_name = "VAR CMS"
+
+    def ready(self):
+        from django.apps import apps
+        for app_config in apps.get_app_configs():
+            try:
+                __import__(f"{app_config.name}.var_cms_admin")
+            except ModuleNotFoundError:
+                pass
+            except Exception as e:
+                import logging
+                logging.getLogger(__name__).warning(
+                    "var_cms_admin import error in %s: %s", app_config.name, e
+                )

django_var_cms-1.0.0/var_cms/media_utils/convert.py

@@ -0,0 +1,140 @@
+"""
+var_cms/media_utils/convert.py
+==============================
+File format converter.
+
+Supported conversions:
+  Images  — jpeg ↔ png ↔ webp ↔ bmp ↔ tiff ↔ gif
+  Audio   — mp3 ↔ wav ↔ ogg ↔ flac ↔ aac   (requires ffmpeg)
+  Video   — mp4 ↔ webm ↔ avi ↔ mov          (requires ffmpeg)
+  PDF → images (page-by-page PNG)             (requires pdf2image + poppler)
+"""
+
+import io
+import os
+import subprocess
+import tempfile
+import uuid
+
+from django.conf import settings
+from django.core.files.base import ContentFile
+from django.core.files.storage import default_storage
+from django.http import JsonResponse
+
+IMAGE_FORMATS  = {"jpeg", "jpg", "png", "webp", "bmp", "tiff", "gif"}
+AUDIO_FORMATS  = {"mp3", "wav", "ogg", "flac", "aac", "m4a"}
+VIDEO_FORMATS  = {"mp4", "webm", "avi", "mov", "mkv"}
+DOC_FORMATS    = {"pdf"}
+
+
+def _abs(file_path: str) -> str:
+    clean = file_path.lstrip("/").replace(settings.MEDIA_URL.lstrip("/"), "", 1)
+    return os.path.join(settings.MEDIA_ROOT, clean)
+
+
+def _save(data: bytes, ext: str) -> dict:
+    name = f"converted/{uuid.uuid4().hex[:12]}.{ext}"
+    path = default_storage.save(name, ContentFile(data))
+    return {"url": default_storage.url(path), "path": path}
+
+
+def handle_convert(request):
+    """
+    POST params:
+        file_path   — relative media path of source file
+        target_fmt  — desired output extension (e.g. "webp", "mp3", "mp4")
+    """
+    file_path  = request.POST.get("file_path", "")
+    target_fmt = request.POST.get("target_fmt", "").lower().lstrip(".")
+
+    if not file_path or not target_fmt:
+        return JsonResponse({"error": "file_path and target_fmt required"}, status=400)
+
+    abs_path = _abs(file_path)
+    if not os.path.exists(abs_path):
+        return JsonResponse({"error": "File not found"}, status=404)
+
+    src_ext = abs_path.rsplit(".", 1)[-1].lower()
+
+    # ── Image conversion ──────────────────────────────────────────────────────
+    if src_ext in IMAGE_FORMATS and target_fmt in IMAGE_FORMATS:
+        return _convert_image(abs_path, target_fmt)
+
+    # ── Audio / Video conversion (ffmpeg) ─────────────────────────────────────
+    if src_ext in (AUDIO_FORMATS | VIDEO_FORMATS) or target_fmt in (AUDIO_FORMATS | VIDEO_FORMATS):
+        return _convert_ffmpeg(abs_path, target_fmt)
+
+    # ── PDF → images ──────────────────────────────────────────────────────────
+    if src_ext == "pdf" and target_fmt in ("png", "jpg", "jpeg"):
+        return _convert_pdf(abs_path, target_fmt)
+
+    return JsonResponse({"error": f"Unsupported conversion: {src_ext} → {target_fmt}"}, status=400)
+
+
+def _convert_image(abs_path: str, target_fmt: str) -> JsonResponse:
+    try:
+        from PIL import Image
+    except ImportError:
+        return JsonResponse({"error": "Pillow not installed"}, status=500)
+
+    fmt_map = {"jpg": "JPEG", "jpeg": "JPEG", "png": "PNG",
+               "webp": "WEBP", "bmp": "BMP", "tiff": "TIFF", "gif": "GIF"}
+    pil_fmt = fmt_map.get(target_fmt, target_fmt.upper())
+
+    img = Image.open(abs_path)
+    if pil_fmt == "JPEG" and img.mode in ("RGBA", "P"):
+        img = img.convert("RGB")
+
+    buf = io.BytesIO()
+    img.save(buf, format=pil_fmt, quality=90)
+    buf.seek(0)
+    ext = "jpg" if target_fmt in ("jpg", "jpeg") else target_fmt
+    return JsonResponse(_save(buf.read(), ext) | {"type": "image"})
+
+
+def _convert_ffmpeg(abs_path: str, target_fmt: str) -> JsonResponse:
+    if subprocess.run(["which", "ffmpeg"], capture_output=True).returncode != 0:
+        return JsonResponse({
+            "error": "ffmpeg not found. Install with: sudo apt install ffmpeg",
+            "install_hint": "sudo apt install ffmpeg"
+        }, status=500)
+
+    with tempfile.NamedTemporaryFile(suffix=f".{target_fmt}", delete=False) as tmp:
+        out_path = tmp.name
+
+    try:
+        cmd = ["ffmpeg", "-y", "-i", abs_path, out_path]
+        result = subprocess.run(cmd, capture_output=True, timeout=120)
+        if result.returncode != 0:
+            err = result.stderr.decode(errors="replace")[-500:]
+            return JsonResponse({"error": f"ffmpeg error: {err}"}, status=500)
+
+        with open(out_path, "rb") as f:
+            data = f.read()
+
+        media_type = "audio" if target_fmt in AUDIO_FORMATS else "video"
+        return JsonResponse(_save(data, target_fmt) | {"type": media_type})
+    finally:
+        if os.path.exists(out_path):
+            os.unlink(out_path)
+
+
+def _convert_pdf(abs_path: str, target_fmt: str) -> JsonResponse:
+    try:
+        from pdf2image import convert_from_path
+    except ImportError:
+        return JsonResponse({
+            "error": "pdf2image not installed. Run: uv add pdf2image",
+            "install_hint": "uv add pdf2image"
+        }, status=500)
+
+    images = convert_from_path(abs_path, dpi=150)
+    urls = []
+    for i, img in enumerate(images):
+        buf = io.BytesIO()
+        img.save(buf, format="PNG")
+        buf.seek(0)
+        result = _save(buf.read(), "png")
+        urls.append(result["url"])
+
+    return JsonResponse({"type": "pdf_pages", "pages": urls, "count": len(urls)})

django_var_cms-1.0.0/var_cms/media_utils/crop.py

@@ -0,0 +1,91 @@
+"""
+var_cms/media_utils/crop.py
+===========================
+Image crop handler — receives crop coordinates from the frontend Cropper.js
+widget and returns a new cropped image saved to MEDIA_ROOT.
+"""
+
+import io
+import os
+import uuid
+
+from django.conf import settings
+from django.core.files.base import ContentFile
+from django.core.files.storage import default_storage
+from django.http import JsonResponse
+
+
+def handle_crop(request):
+    """
+    POST params:
+        file_path  — relative media path of the source image
+        x, y, w, h — crop box in pixels
+        rotate     — rotation degrees (optional, default 0)
+        scale_x    — horizontal flip (-1 or 1)
+        scale_y    — vertical flip (-1 or 1)
+        format     — output format: jpeg | png | webp (default: same as source)
+    """
+    try:
+        from PIL import Image
+    except ImportError:
+        return JsonResponse({"error": "Pillow not installed. Run: uv add pillow"}, status=500)
+
+    file_path = request.POST.get("file_path", "")
+    if not file_path:
+        return JsonResponse({"error": "file_path required"}, status=400)
+
+    # Sanitise — must be inside MEDIA_ROOT
+    abs_path = os.path.join(settings.MEDIA_ROOT, file_path.lstrip("/").replace(settings.MEDIA_URL.lstrip("/"), "", 1))
+    if not os.path.exists(abs_path):
+        return JsonResponse({"error": "File not found"}, status=404)
+
+    try:
+        x = int(float(request.POST.get("x", 0)))
+        y = int(float(request.POST.get("y", 0)))
+        w = int(float(request.POST.get("w", 0)))
+        h = int(float(request.POST.get("h", 0)))
+        rotate   = float(request.POST.get("rotate", 0))
+        scale_x  = float(request.POST.get("scale_x", 1))
+        scale_y  = float(request.POST.get("scale_y", 1))
+        out_fmt  = request.POST.get("format", "").upper()
+    except (ValueError, TypeError) as e:
+        return JsonResponse({"error": f"Invalid params: {e}"}, status=400)
+
+    img = Image.open(abs_path).convert("RGBA")
+
+    # Flip
+    if scale_x == -1:
+        img = img.transpose(Image.FLIP_LEFT_RIGHT)
+    if scale_y == -1:
+        img = img.transpose(Image.FLIP_TOP_BOTTOM)
+
+    # Rotate (expand=True keeps full image)
+    if rotate:
+        img = img.rotate(-rotate, expand=True)
+
+    # Crop
+    if w > 0 and h > 0:
+        img = img.crop((x, y, x + w, y + h))
+
+    # Determine output format
+    orig_ext = abs_path.rsplit(".", 1)[-1].upper()
+    fmt_map  = {"JPG": "JPEG", "JPEG": "JPEG", "PNG": "PNG", "WEBP": "WEBP"}
+    save_fmt = fmt_map.get(out_fmt) or fmt_map.get(orig_ext) or "PNG"
+
+    # JPEG can't have alpha
+    if save_fmt == "JPEG":
+        img = img.convert("RGB")
+
+    ext_map = {"JPEG": "jpg", "PNG": "png", "WEBP": "webp"}
+    ext = ext_map.get(save_fmt, "png")
+
+    buf = io.BytesIO()
+    img.save(buf, format=save_fmt, quality=90)
+    buf.seek(0)
+
+    # Save alongside originals
+    new_name = f"crops/{uuid.uuid4().hex[:12]}.{ext}"
+    saved_path = default_storage.save(new_name, ContentFile(buf.read()))
+    url = default_storage.url(saved_path)
+
+    return JsonResponse({"url": url, "path": saved_path, "format": save_fmt, "size": [img.width, img.height]})

django_var_cms-1.0.0/var_cms/permissions.py

@@ -0,0 +1,123 @@
+"""
+var_cms/permissions.py
+======================
+Role-based permission system for django-var-cms.
+
+RolePermission  — defines what a named role can do
+GroupPermission — same but matches Django auth groups
+UserPermission  — per-user overrides (highest priority)
+
+Resolution order: UserPermission > GroupPermission > RolePermission > deny
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Union
+
+
+ACTIONS = ("add", "list", "view", "edit", "delete")
+
+
+@dataclass
+class RolePermission:
+    """
+    Map a role name (string) to a set of allowed actions.
+
+    The role name is matched against:
+      1. "superuser"          — request.user.is_superuser
+      2. Django group names   — request.user.groups
+      3. Custom role logic    — override VarCMSModelAdmin._get_user_role()
+    """
+    role: str
+    add: bool    = False
+    list: bool   = True
+    view: bool   = True
+    edit: bool   = False
+    delete: bool = False
+
+    def allows(self, action: str) -> bool:
+        return bool(getattr(self, action, False))
+
+
+@dataclass
+class GroupPermission(RolePermission):
+    """Alias — identical to RolePermission, role matches a Django group name."""
+    pass
+
+
+@dataclass
+class UserPermission:
+    """
+    Per-user permission override (matched by username or user pk).
+    Takes priority over all role/group permissions.
+    """
+    username: str
+    add: bool    = False
+    list: bool   = True
+    view: bool   = True
+    edit: bool   = False
+    delete: bool = False
+
+    def allows(self, action: str) -> bool:
+        return bool(getattr(self, action, False))
+
+
+def resolve_permission(
+    permissions: List[Union[RolePermission, UserPermission]],
+    role: str,
+    action: str,
+    username: str = "",
+) -> bool:
+    """
+    Walk the permission list and return True if allowed.
+    UserPermission (matched by username) takes priority.
+    """
+    if action not in ACTIONS:
+        return False
+
+    # 1. User-level overrides first
+    for perm in permissions:
+        if isinstance(perm, UserPermission) and perm.username == username:
+            return perm.allows(action)
+
+    # 2. Role / group match
+    for perm in permissions:
+        if isinstance(perm, RolePermission) and perm.role == role:
+            return perm.allows(action)
+
+    # 3. Default deny
+    return False
+
+
+def resolve_editable_fields(
+    role_editable_fields: Dict[str, Union[List[str], str]],
+    role: str,
+) -> Union[List[str], str]:
+    """
+    Return the editable fields for a given role.
+    Falls back to "__all__" for superuser if not explicitly set.
+    """
+    if role in role_editable_fields:
+        return role_editable_fields[role]
+    if role == "superuser":
+        return "__all__"
+    # Check wildcard
+    if "*" in role_editable_fields:
+        return role_editable_fields["*"]
+    return []   # deny all edits for unknown roles
+
+
+def permission_summary(permissions: List[RolePermission]) -> List[Dict]:
+    """Return a list of dicts for rendering a permission table in templates."""
+    return [
+        {
+            "role": p.role,
+            "add": p.add,
+            "list": p.list,
+            "view": p.view,
+            "edit": p.edit,
+            "delete": p.delete,
+        }
+        for p in permissions
+        if isinstance(p, (RolePermission, UserPermission))
+    ]