arthexis 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

core/models.py

@@ -15,7 +15,13 @@ from django.apps import apps
 from django.db.models.signals import m2m_changed, post_delete, post_save
 from django.dispatch import receiver
 from django.views.decorators.debug import sensitive_variables
-from datetime import time as datetime_time, timedelta
+from datetime import (
+    time as datetime_time,
+    timedelta,
+    datetime as datetime_datetime,
+    date as datetime_date,
+    timezone as datetime_timezone,
+)
 import logging
 import json
 from django.contrib.contenttypes.models import ContentType
@@ -33,7 +39,8 @@ import uuid
 from pathlib import Path
 from django.core import serializers
 from django.core.management.color import no_style
-from urllib.parse import quote_plus, urlparse
+from urllib.parse import quote, quote_plus, urlparse
+from zoneinfo import ZoneInfo
 from utils import revision as revision_utils
 from typing import Any, Type
 from defusedxml import xmlrpc as defused_xmlrpc
@@ -522,6 +529,10 @@ class User(Entity, AbstractUser):
     def social_profile(self):
         return self._direct_profile("SocialProfile")
 
+    @property
+    def google_calendar_profile(self):
+        return self._direct_profile("GoogleCalendarProfile")
+
 
 class UserPhoneNumber(Entity):
     """Store phone numbers associated with a user."""
@@ -839,6 +850,184 @@ class OpenPayProfile(Profile):
         ]
 
 
+class GoogleCalendarProfile(Profile):
+    """Store Google Calendar configuration for a user or security group."""
+
+    profile_fields = ("calendar_id", "api_key", "display_name", "timezone")
+
+    calendar_id = SigilShortAutoField(max_length=255)
+    api_key = SigilShortAutoField(max_length=255)
+    display_name = models.CharField(max_length=255, blank=True)
+    max_events = models.PositiveIntegerField(
+        default=5,
+        validators=[MinValueValidator(1), MaxValueValidator(20)],
+        help_text=_("Number of upcoming events to display (1-20)."),
+    )
+    timezone = SigilShortAutoField(max_length=100, blank=True)
+
+    GOOGLE_EVENTS_URL = (
+        "https://www.googleapis.com/calendar/v3/calendars/{calendar}/events"
+    )
+    GOOGLE_EMBED_URL = "https://calendar.google.com/calendar/embed?src={calendar}&ctz={tz}"
+
+    class Meta:
+        verbose_name = _("Google Calendar")
+        verbose_name_plural = _("Google Calendars")
+        constraints = [
+            models.CheckConstraint(
+                check=(
+                    (Q(user__isnull=False) & Q(group__isnull=True))
+                    | (Q(user__isnull=True) & Q(group__isnull=False))
+                ),
+                name="googlecalendarprofile_requires_owner",
+            )
+        ]
+
+    def __str__(self):  # pragma: no cover - simple representation
+        label = self.get_display_name()
+        return label or self.resolved_calendar_id()
+
+    def resolved_calendar_id(self) -> str:
+        value = self.resolve_sigils("calendar_id")
+        return value or self.calendar_id or ""
+
+    def resolved_api_key(self) -> str:
+        value = self.resolve_sigils("api_key")
+        return value or self.api_key or ""
+
+    def resolved_timezone(self) -> str:
+        value = self.resolve_sigils("timezone")
+        return value or self.timezone or ""
+
+    def get_timezone(self) -> ZoneInfo:
+        tz_name = self.resolved_timezone() or settings.TIME_ZONE
+        try:
+            return ZoneInfo(tz_name)
+        except Exception:
+            return ZoneInfo("UTC")
+
+    def get_display_name(self) -> str:
+        value = self.resolve_sigils("display_name")
+        if value:
+            return value
+        if self.display_name:
+            return self.display_name
+        return ""
+
+    def build_events_url(self) -> str:
+        calendar = self.resolved_calendar_id().strip()
+        if not calendar:
+            return ""
+        encoded = quote(calendar, safe="@")
+        return self.GOOGLE_EVENTS_URL.format(calendar=encoded)
+
+    def build_calendar_url(self) -> str:
+        calendar = self.resolved_calendar_id().strip()
+        if not calendar:
+            return ""
+        tz = self.get_timezone().key
+        encoded_calendar = quote_plus(calendar)
+        encoded_tz = quote_plus(tz)
+        return self.GOOGLE_EMBED_URL.format(calendar=encoded_calendar, tz=encoded_tz)
+
+    def _parse_event_point(self, data: dict) -> tuple[datetime_datetime | None, bool]:
+        if not isinstance(data, dict):
+            return None, False
+
+        tz_name = data.get("timeZone")
+        default_tz = self.get_timezone()
+        tzinfo = default_tz
+        if tz_name:
+            try:
+                tzinfo = ZoneInfo(tz_name)
+            except Exception:
+                tzinfo = default_tz
+
+        timestamp = data.get("dateTime")
+        if timestamp:
+            dt = parse_datetime(timestamp)
+            if dt is None:
+                try:
+                    dt = datetime_datetime.fromisoformat(
+                        timestamp.replace("Z", "+00:00")
+                    )
+                except ValueError:
+                    dt = None
+            if dt is not None and dt.tzinfo is None:
+                dt = dt.replace(tzinfo=tzinfo)
+            return dt, False
+
+        date_value = data.get("date")
+        if date_value:
+            try:
+                day = datetime_date.fromisoformat(date_value)
+            except ValueError:
+                return None, True
+            dt = datetime_datetime.combine(day, datetime_time.min, tzinfo=tzinfo)
+            return dt, True
+
+        return None, False
+
+    def fetch_events(self, *, max_results: int | None = None) -> list[dict[str, object]]:
+        calendar_id = self.resolved_calendar_id().strip()
+        api_key = self.resolved_api_key().strip()
+        if not calendar_id or not api_key:
+            return []
+
+        url = self.build_events_url()
+        if not url:
+            return []
+
+        now = timezone.now().astimezone(datetime_timezone.utc).replace(microsecond=0)
+        params = {
+            "key": api_key,
+            "singleEvents": "true",
+            "orderBy": "startTime",
+            "timeMin": now.isoformat().replace("+00:00", "Z"),
+            "maxResults": max_results or self.max_events or 5,
+        }
+
+        try:
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            payload = response.json()
+        except (requests.RequestException, ValueError):
+            logger.warning(
+                "Failed to fetch Google Calendar events for profile %s", self.pk,
+                exc_info=True,
+            )
+            return []
+
+        items = payload.get("items")
+        if not isinstance(items, list):
+            return []
+
+        events: list[dict[str, object]] = []
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            start, all_day = self._parse_event_point(item.get("start") or {})
+            end, _ = self._parse_event_point(item.get("end") or {})
+            summary = item.get("summary") or ""
+            link = item.get("htmlLink") or ""
+            location = item.get("location") or ""
+            if start is None:
+                continue
+            events.append(
+                {
+                    "summary": summary,
+                    "start": start,
+                    "end": end,
+                    "all_day": all_day,
+                    "html_link": link,
+                    "location": location,
+                }
+            )
+
+        events.sort(key=lambda event: event.get("start") or timezone.now())
+        return events
+
+
 class EmailInbox(Profile):
     """Credentials and configuration for connecting to an email mailbox."""
 
@@ -3725,7 +3914,38 @@ class Todo(Entity):
     generated_for_version = models.CharField(max_length=20, blank=True, default="")
     generated_for_revision = models.CharField(max_length=40, blank=True, default="")
     done_on = models.DateTimeField(null=True, blank=True)
+    done_node = models.ForeignKey(
+        "nodes.Node",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="completed_todos",
+        help_text="Node where this TODO was completed.",
+    )
+    done_version = models.CharField(max_length=20, blank=True, default="")
+    done_revision = models.CharField(max_length=40, blank=True, default="")
+    done_username = models.CharField(max_length=150, blank=True, default="")
     on_done_condition = ConditionTextField(blank=True, default="")
+    origin_node = models.ForeignKey(
+        "nodes.Node",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="originated_todos",
+        help_text="Node where this TODO was generated.",
+    )
+    original_user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="originated_todos",
+        help_text="User responsible for creating this TODO.",
+    )
+    original_user_is_authenticated = models.BooleanField(
+        default=False,
+        help_text="Whether the originating user was authenticated during creation.",
+    )
 
     objects = TodoManager()
 
@@ -3766,6 +3986,203 @@ class Todo(Entity):
             return field.evaluate(self)
         return ConditionCheckResult(True, "")
 
+    def save(self, *args, **kwargs):
+        created = self.pk is None
+        tracked_fields = {
+            "done_on",
+            "done_node",
+            "done_node_id",
+            "done_revision",
+            "done_username",
+            "done_version",
+            "is_deleted",
+        }
+        update_fields = kwargs.get("update_fields")
+        monitor_changes = not created and (
+            update_fields is None or tracked_fields.intersection(update_fields)
+        )
+        previous_state = None
+        if monitor_changes:
+            previous_state = (
+                type(self)
+                .all_objects.filter(pk=self.pk)
+                .values(
+                    "done_on",
+                    "done_node_id",
+                    "done_revision",
+                    "done_username",
+                    "done_version",
+                    "is_deleted",
+                )
+                .first()
+            )
+        super().save(*args, **kwargs)
+
+        if created:
+            return
+
+        previous_done_on = previous_state["done_on"] if previous_state else None
+        previous_is_deleted = previous_state["is_deleted"] if previous_state else False
+        previous_done_node = (
+            previous_state["done_node_id"] if previous_state else None
+        )
+        previous_done_revision = (
+            previous_state["done_revision"] if previous_state else ""
+        )
+        previous_done_username = (
+            previous_state["done_username"] if previous_state else ""
+        )
+        previous_done_version = (
+            previous_state["done_version"] if previous_state else ""
+        )
+        if (
+            previous_done_on == self.done_on
+            and previous_is_deleted == self.is_deleted
+            and previous_done_node == getattr(self, "done_node_id", None)
+            and previous_done_revision == self.done_revision
+            and previous_done_username == self.done_username
+            and previous_done_version == self.done_version
+        ):
+            return
+
+        self._update_fixture_state()
+
+    def populate_done_metadata(self, user=None) -> None:
+        """Populate metadata fields for a completed TODO."""
+
+        node = None
+        try:  # pragma: no cover - defensive import guard
+            from nodes.models import Node  # type: ignore
+        except Exception:  # pragma: no cover - when app not ready
+            Node = None
+
+        if Node is not None:
+            try:
+                node = Node.get_local()
+            except Exception:  # pragma: no cover - fallback on errors
+                node = None
+        self.done_node = node if node else None
+
+        version_value = ""
+        revision_value = ""
+        if node is not None:
+            version_value = (node.installed_version or "").strip()
+            revision_value = (node.installed_revision or "").strip()
+
+        if not version_value:
+            version_path = Path(settings.BASE_DIR) / "VERSION"
+            try:
+                version_value = version_path.read_text(encoding="utf-8").strip()
+            except OSError:
+                version_value = ""
+
+        if not revision_value:
+            try:
+                revision_value = revision_utils.get_revision() or ""
+            except Exception:  # pragma: no cover - defensive fallback
+                revision_value = ""
+
+        username_value = ""
+        if user is not None and getattr(user, "is_authenticated", False):
+            try:
+                username_value = user.get_username() or ""
+            except Exception:  # pragma: no cover - fallback to attribute
+                username_value = getattr(user, "username", "") or ""
+
+        self.done_version = version_value
+        self.done_revision = revision_value
+        self.done_username = username_value
+
+    def _update_fixture_state(self) -> None:
+        if not self.is_seed_data:
+            return
+
+        request_text = (self.request or "").strip()
+        if not request_text:
+            return
+
+        slug = self._fixture_slug(request_text)
+        if not slug:
+            return
+
+        base_dir = Path(settings.BASE_DIR)
+        fixture_path = base_dir / "core" / "fixtures" / f"todo__{slug}.json"
+        if not fixture_path.exists():
+            return
+
+        try:
+            with fixture_path.open("r", encoding="utf-8") as handle:
+                data = json.load(handle)
+        except Exception:
+            logger.exception("Failed to read TODO fixture %s", fixture_path)
+            return
+
+        if not isinstance(data, list):
+            return
+
+        updated = False
+        normalized_request = request_text.lower()
+        for item in data:
+            if not isinstance(item, dict):
+                continue
+            fields = item.get("fields")
+            if not isinstance(fields, dict):
+                continue
+            candidate = (fields.get("request") or "").strip().lower()
+            if candidate != normalized_request:
+                continue
+            if self._apply_fixture_fields(fields):
+                updated = True
+
+        if not updated:
+            return
+
+        content = json.dumps(data, indent=2, ensure_ascii=False)
+        if not content.endswith("\n"):
+            content += "\n"
+
+        try:
+            fixture_path.write_text(content, encoding="utf-8")
+        except OSError:
+            logger.exception("Failed to write TODO fixture %s", fixture_path)
+
+    def _apply_fixture_fields(self, fields: dict[str, object]) -> bool:
+        changed = False
+
+        def _assign(key: str, value: object) -> None:
+            nonlocal changed
+            if fields.get(key) != value:
+                fields[key] = value
+                changed = True
+
+        _assign("request", self.request or "")
+        _assign("url", self.url or "")
+        _assign("request_details", self.request_details or "")
+        _assign("done_version", self.done_version or "")
+        _assign("done_revision", self.done_revision or "")
+        _assign("done_username", self.done_username or "")
+
+        if self.done_on:
+            done_value = timezone.localtime(self.done_on)
+            _assign("done_on", done_value.isoformat())
+        else:
+            if fields.get("done_on") is not None:
+                fields["done_on"] = None
+                changed = True
+
+        if self.is_deleted:
+            _assign("is_deleted", True)
+        elif fields.get("is_deleted"):
+            fields["is_deleted"] = False
+            changed = True
+
+        return changed
+
+    @staticmethod
+    def _fixture_slug(value: str) -> str:
+        slug = re.sub(r"[^a-z0-9]+", "_", value.lower()).strip("_")
+        return slug
+
 
 class TOTPDeviceSettings(models.Model):
     """Per-device configuration options for authenticator enrollments."""

core/system.py

@@ -101,6 +101,72 @@ def _open_changelog_entries() -> list[dict[str, str]]:
     return entries
 
 
+def _latest_release_changelog() -> dict[str, object]:
+    """Return the most recent tagged release entries for display."""
+
+    changelog_path = Path("CHANGELOG.rst")
+    try:
+        text = changelog_path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return {"title": "", "entries": []}
+
+    lines = text.splitlines()
+    state = "before"
+    release_title = ""
+    entries: list[dict[str, str]] = []
+
+    for raw_line in lines:
+        stripped = raw_line.strip()
+
+        if state == "before":
+            if stripped == "Unreleased":
+                state = "unreleased-heading"
+            continue
+
+        if state == "unreleased-heading":
+            if set(stripped) == {"-"}:
+                state = "unreleased-body"
+            else:
+                state = "unreleased-body"
+            continue
+
+        if state == "unreleased-body":
+            if not stripped:
+                state = "after-unreleased"
+            continue
+
+        if state == "after-unreleased":
+            if not stripped:
+                continue
+            release_title = stripped
+            state = "release-heading"
+            continue
+
+        if state == "release-heading":
+            if set(stripped) == {"-"}:
+                state = "release-body"
+            else:
+                state = "release-body"
+            continue
+
+        if state == "release-body":
+            if not stripped:
+                if entries:
+                    break
+                continue
+            if not stripped.startswith("- "):
+                break
+            trimmed = stripped[2:].strip()
+            if not trimmed:
+                continue
+            parts = trimmed.split(" ", 1)
+            sha = parts[0]
+            message = parts[1] if len(parts) > 1 else ""
+            entries.append({"sha": sha, "message": message})
+
+    return {"title": release_title, "entries": entries}
+
+
 def _exclude_changelog_entries(shas: Iterable[str]) -> int:
     """Remove entries matching ``shas`` from the changelog.
 
@@ -1073,6 +1139,7 @@ def _system_changelog_report_view(request):
         {
             "title": _("Changelog Report"),
             "open_changelog_entries": _open_changelog_entries(),
+            "latest_release_changelog": _latest_release_changelog(),
         }
     )
     return TemplateResponse(request, "admin/system_changelog_report.html", context)
@@ -1119,6 +1186,14 @@ class PendingTodoForm(forms.ModelForm):
         for name in ["request_details", "on_done_condition"]:
             self.fields[name].widget.attrs.setdefault("class", "vLargeTextField")
 
+        mark_done_widget = self.fields["mark_done"].widget
+        existing_classes = mark_done_widget.attrs.get("class", "").split()
+        if "approve-checkbox" not in existing_classes:
+            existing_classes.append("approve-checkbox")
+        mark_done_widget.attrs["class"] = " ".join(
+            class_name for class_name in existing_classes if class_name
+        )
+
 
 PendingTodoFormSet = modelformset_factory(Todo, form=PendingTodoForm, extra=0)
 
@@ -1144,6 +1219,7 @@ def _system_pending_todos_report_view(request):
                 has_changes = form.has_changed()
                 if mark_done and todo.done_on is None:
                     todo.done_on = timezone.now()
+                    todo.populate_done_metadata(request.user)
                     approved_count += 1
                     has_changes = True
                 if has_changes: