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

core/release.py

@@ -520,11 +520,6 @@ def build(
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
         version = version_path.read_text().strip()
-        if bump:
-            major, minor, patch = map(int, version.split("."))
-            patch += 1
-            version = f"{major}.{minor}.{patch}"
-            version_path.write_text(version + "\n")
     else:
         # Ensure the VERSION file reflects the provided release version
         if version_path.parent != Path("."):

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:

core/tests.py

@@ -1969,7 +1969,7 @@ class PackageReleaseAdminActionTests(TestCase):
 
     @mock.patch("core.admin.PackageRelease.dump_fixture")
     @mock.patch("core.admin.requests.get")
-    def test_refresh_from_pypi_creates_releases(self, mock_get, dump):
+    def test_refresh_from_pypi_reports_missing_releases(self, mock_get, dump):
         mock_get.return_value.raise_for_status.return_value = None
         mock_get.return_value.json.return_value = {
             "releases": {
@@ -1982,13 +1982,17 @@ class PackageReleaseAdminActionTests(TestCase):
             }
         }
         self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
-        new_release = PackageRelease.objects.get(version="1.1.0")
-        self.assertEqual(new_release.revision, "")
-        self.assertEqual(
-            new_release.release_on,
-            datetime(2024, 2, 2, 15, 45, tzinfo=datetime_timezone.utc),
+        self.assertFalse(
+            PackageRelease.objects.filter(version="1.1.0").exists()
+        )
+        dump.assert_not_called()
+        self.assertIn(
+            (
+                "Manual creation required for 1 release: 1.1.0",
+                messages.WARNING,
+            ),
+            self.messages,
         )
-        dump.assert_called_once()
 
     @mock.patch("core.admin.PackageRelease.dump_fixture")
     @mock.patch("core.admin.requests.get")
@@ -2134,6 +2138,25 @@ class PackageReleaseCurrentTests(TestCase):
         self.package.save()
         self.assertFalse(self.release.is_current)
 
+    def test_is_current_false_when_version_has_plus(self):
+        self.version_path.write_text("1.0.0+")
+        self.assertFalse(self.release.is_current)
+
+
+class PackageReleaseRevisionTests(TestCase):
+    def setUp(self):
+        self.package = Package.objects.get(name="arthexis")
+        self.release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.0.0",
+            revision="abcdef123456",
+        )
+
+    def test_matches_revision_ignores_plus_suffix(self):
+        self.assertTrue(
+            PackageRelease.matches_revision("1.0.0+", "abcdef123456")
+        )
+
     def test_is_current_false_when_version_differs(self):
         self.release.version = "2.0.0"
         self.release.save()
@@ -2184,13 +2207,22 @@ class PackageAdminPrepareNextReleaseTests(TestCase):
 
     def test_prepare_next_release_active_creates_release(self):
         PackageRelease.all_objects.filter(package=self.package).delete()
-        request = self.factory.get("/admin/core/package/prepare-next-release/")
+        request = self.factory.post("/admin/core/package/prepare-next-release/")
         response = self.admin.prepare_next_release_active(request)
         self.assertEqual(response.status_code, 302)
         self.assertEqual(
             PackageRelease.all_objects.filter(package=self.package).count(), 1
         )
 
+    def test_prepare_next_release_active_get_creates_release(self):
+        PackageRelease.all_objects.filter(package=self.package).delete()
+        request = self.factory.get("/admin/core/package/prepare-next-release/")
+        response = self.admin.prepare_next_release_active(request)
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(
+            PackageRelease.all_objects.filter(package=self.package).exists()
+        )
+
 
 class PackageAdminChangeViewTests(TestCase):
     def setUp(self):
@@ -2212,13 +2244,97 @@ class TodoDoneTests(TestCase):
         User.objects.create_superuser("admin", "admin@example.com", "pw")
         self.client.force_login(User.objects.get(username="admin"))
 
-    def test_mark_done_sets_timestamp(self):
+    @mock.patch("core.models.revision_utils.get_revision", return_value="rev123")
+    def test_mark_done_sets_timestamp(self, _get_revision):
         todo = Todo.objects.create(request="Task", is_seed_data=True)
         resp = self.client.post(reverse("todo-done", args=[todo.pk]))
         self.assertRedirects(resp, reverse("admin:index"))
         todo.refresh_from_db()
         self.assertIsNotNone(todo.done_on)
         self.assertFalse(todo.is_deleted)
+        self.assertIsNone(todo.done_node)
+        version_path = Path(settings.BASE_DIR) / "VERSION"
+        expected_version = ""
+        if version_path.exists():
+            expected_version = version_path.read_text(encoding="utf-8").strip()
+        self.assertEqual(todo.done_version, expected_version)
+        self.assertEqual(todo.done_revision, "rev123")
+        self.assertEqual(todo.done_username, "admin")
+
+    def test_mark_done_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                with mock.patch(
+                    "core.models.revision_utils.get_revision", return_value="rev456"
+                ):
+                    resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+
+            self.assertRedirects(resp, reverse("admin:index"))
+            data = json.loads(fixture_path.read_text(encoding="utf-8"))
+            self.assertEqual(len(data), 1)
+            fields = data[0]["fields"]
+            self.assertIn("done_on", fields)
+            self.assertTrue(fields["done_on"])
+            self.assertFalse(fields.get("is_deleted", False))
+            self.assertIn("done_version", fields)
+            self.assertEqual(fields.get("done_revision"), "rev456")
+            self.assertEqual(fields.get("done_username"), "admin")
+
+    def test_soft_delete_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                todo.delete()
+
+            data = json.loads(fixture_path.read_text(encoding="utf-8"))
+            self.assertEqual(len(data), 1)
+            fields = data[0]["fields"]
+            self.assertTrue(fields.get("is_deleted"))
 
     def test_mark_done_missing_task_refreshes(self):
         todo = Todo.objects.create(request="Task", is_seed_data=True)
@@ -2324,6 +2440,61 @@ class TodoDoneTests(TestCase):
         self.assertTrue(todo.is_seed_data)
 
 
+class TodoDeleteTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_delete_marks_task_deleted(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        todo.refresh_from_db()
+        self.assertTrue(todo.is_deleted)
+        self.assertIsNone(todo.done_on)
+
+    def test_delete_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+                self.assertRedirects(resp, reverse("admin:index"))
+                data = json.loads(fixture_path.read_text(encoding="utf-8"))
+        self.assertEqual(len(data), 1)
+        fields = data[0]["fields"]
+        self.assertTrue(fields.get("is_deleted"))
+
+    def test_delete_missing_task_redirects(self):
+        todo = Todo.objects.create(request="Task")
+        todo.is_deleted = True
+        todo.save(update_fields=["is_deleted"])
+        resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+
+
 class TodoFocusViewTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2341,6 +2512,7 @@ class TodoFocusViewTests(TestCase):
         self.assertEqual(resp["X-Frame-Options"], "SAMEORIGIN")
         self.assertContains(resp, f'src="{todo.url}"')
         self.assertContains(resp, "Done")
+        self.assertContains(resp, "Delete")
         self.assertContains(resp, "Back")
         self.assertContains(resp, "Take Snapshot")
         snapshot_url = reverse("todo-snapshot", args=[todo.pk])

core/user_data.py

@@ -201,9 +201,49 @@ def dump_user_fixture(instance, user=None) -> None:
 
 def delete_user_fixture(instance, user=None) -> None:
     target_user = user or _resolve_fixture_user(instance)
-    if target_user is None:
+    filename = (
+        f"{instance._meta.app_label}_{instance._meta.model_name}_{instance.pk}.json"
+    )
+
+    def _remove_for_user(candidate) -> None:
+        if candidate is None:
+            return
+        base_path = Path(
+            getattr(candidate, "data_path", "") or Path(settings.BASE_DIR) / "data"
+        )
+        username = _username_for(candidate)
+        if not username:
+            return
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
+
+    if target_user is not None:
+        _remove_for_user(target_user)
         return
-    _fixture_path(target_user, instance).unlink(missing_ok=True)
+
+    root = Path(settings.BASE_DIR) / "data"
+    if root.exists():
+        (root / filename).unlink(missing_ok=True)
+        for path in root.iterdir():
+            if path.is_dir():
+                (path / filename).unlink(missing_ok=True)
+
+    UserModel = get_user_model()
+    manager = getattr(UserModel, "all_objects", UserModel._default_manager)
+    for candidate in manager.all():
+        data_path = getattr(candidate, "data_path", "")
+        if not data_path:
+            continue
+        base_path = Path(data_path)
+        if not base_path.exists():
+            continue
+        username = _username_for(candidate)
+        if not username:
+            continue
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
 
 
 def _mark_fixture_user_data(path: Path) -> None:

core/views.py

@@ -365,6 +365,7 @@ def request_temp_password(request):
     )
 
 
+@staff_member_required
 @require_GET
 def version_info(request):
     """Return the running application version and Git revision."""
@@ -495,6 +496,16 @@ def _sync_with_origin_main(log_path: Path) -> None:
         if stderr:
             _append_log(log_path, "git errors:\n" + stderr)
 
+        status = subprocess.run(
+            ["git", "status"], capture_output=True, text=True, check=False
+        )
+        status_output = (status.stdout or "").strip()
+        status_errors = (status.stderr or "").strip()
+        if status_output:
+            _append_log(log_path, "git status:\n" + status_output)
+        if status_errors:
+            _append_log(log_path, "git status errors:\n" + status_errors)
+
         branch = _current_branch() or "(detached HEAD)"
         instructions = [
             "Manual intervention required to finish syncing with origin/main.",
@@ -679,16 +690,17 @@ def _ensure_origin_main_unchanged(log_path: Path) -> None:
 def _next_patch_version(version: str) -> str:
     from packaging.version import InvalidVersion, Version
 
+    cleaned = version.rstrip("+")
     try:
-        parsed = Version(version)
+        parsed = Version(cleaned)
     except InvalidVersion:
-        parts = version.split(".")
+        parts = cleaned.split(".") if cleaned else []
         for index in range(len(parts) - 1, -1, -1):
             segment = parts[index]
             if segment.isdigit():
                 parts[index] = str(int(segment) + 1)
                 return ".".join(parts)
-        return version
+        return cleaned or version
     return f"{parsed.major}.{parsed.minor}.{parsed.micro + 1}"
 
 
@@ -757,7 +769,9 @@ def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
     version_path = Path("VERSION")
     if version_path.exists():
         try:
-            repo_version = Version(version_path.read_text(encoding="utf-8").strip())
+            raw_version = version_path.read_text(encoding="utf-8").strip()
+            cleaned_version = raw_version.rstrip("+") or "0.0.0"
+            repo_version = Version(cleaned_version)
         except InvalidVersion:
             repo_version = None
 
@@ -924,7 +938,7 @@ def _refresh_changelog_once(ctx, log_path: Path) -> None:
     ctx["changelog_refreshed"] = True
 
 
-def _step_check_todos(release, ctx, log_path: Path) -> None:
+def _step_check_todos(release, ctx, log_path: Path, *, user=None) -> None:
     _refresh_changelog_once(ctx, log_path)
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
@@ -964,7 +978,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
     ctx["todos_ack"] = True
 
 
-def _step_check_version(release, ctx, log_path: Path) -> None:
+def _step_check_version(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
     from packaging.version import InvalidVersion, Version
 
@@ -1099,10 +1113,12 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
     version_path = Path("VERSION")
     if version_path.exists():
         current = version_path.read_text(encoding="utf-8").strip()
-        if current and Version(release.version) < Version(current):
-            raise Exception(
-                f"Version {release.version} is older than existing {current}"
-            )
+        if current:
+            current_clean = current.rstrip("+") or "0.0.0"
+            if Version(release.version) < Version(current_clean):
+                raise Exception(
+                    f"Version {release.version} is older than existing {current}"
+                )
 
     _append_log(log_path, f"Checking if version {release.version} exists on PyPI")
     if release_utils.network_available():
@@ -1152,17 +1168,17 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
         _append_log(log_path, "Network unavailable, skipping PyPI check")
 
 
-def _step_handle_migrations(release, ctx, log_path: Path) -> None:
+def _step_handle_migrations(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Freeze, squash and approve migrations")
     _append_log(log_path, "Migration review acknowledged (manual step)")
 
 
-def _step_changelog_docs(release, ctx, log_path: Path) -> None:
+def _step_changelog_docs(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Compose CHANGELOG and documentation")
     _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
-def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
+def _step_pre_release_actions(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Execute pre-release actions")
     if ctx.get("dry_run"):
         _append_log(log_path, "Dry run: skipping pre-release actions")
@@ -1238,12 +1254,12 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Pre-release actions complete")
 
 
-def _step_run_tests(release, ctx, log_path: Path) -> None:
+def _step_run_tests(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Complete test suite with --all flag")
     _append_log(log_path, "Test suite completion acknowledged")
 
 
-def _step_promote_build(release, ctx, log_path: Path) -> None:
+def _step_promote_build(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     _append_log(log_path, "Generating build files")
@@ -1255,7 +1271,7 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
         release_utils.promote(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
         )
         _append_log(
             log_path,
@@ -1303,8 +1319,10 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     _append_log(new_log, "Build complete")
 
 
-def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
-    if release.to_credentials() is None:
+def _step_release_manager_approval(
+    release, ctx, log_path: Path, *, user=None
+) -> None:
+    if release.to_credentials(user=user) is None:
         ctx.pop("release_approval", None)
         if not ctx.get("approval_credentials_missing"):
             _append_log(log_path, "Release manager publishing credentials missing")
@@ -1338,14 +1356,14 @@ def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
     raise ApprovalRequired()
 
 
-def _step_publish(release, ctx, log_path: Path) -> None:
+def _step_publish(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     if ctx.get("dry_run"):
         test_repository_url = os.environ.get(
             "PYPI_TEST_REPOSITORY_URL", "https://test.pypi.org/legacy/"
         )
-        test_creds = release.to_credentials()
+        test_creds = release.to_credentials(user=user)
         if not (test_creds and test_creds.has_auth()):
             test_creds = release_utils.Credentials(
                 token=os.environ.get("PYPI_TEST_API_TOKEN"),
@@ -1385,7 +1403,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
                 release_utils.build(
                     package=package,
                     version=release.version,
-                    creds=release.to_credentials(),
+                    creds=release.to_credentials(user=user),
                     dist=True,
                     tests=False,
                     twine=False,
@@ -1414,13 +1432,13 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=target.credentials or release.to_credentials(),
+            creds=target.credentials or release.to_credentials(user=user),
             repositories=[target],
         )
         _append_log(log_path, "Dry run: skipped release metadata updates")
         return
 
-    targets = release.build_publish_targets()
+    targets = release.build_publish_targets(user=user)
     repo_labels = []
     for target in targets:
         label = target.name
@@ -1439,7 +1457,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
             repositories=targets,
         )
     except release_utils.PostPublishWarning as warning:
@@ -1808,7 +1826,7 @@ def release_progress(request, pk: int, action: str):
         return redirect(request.path)
 
     manager = release.release_manager or release.package.release_manager
-    credentials_ready = bool(release.to_credentials())
+    credentials_ready = bool(release.to_credentials(user=request.user))
     if credentials_ready and ctx.get("approval_credentials_missing"):
         ctx.pop("approval_credentials_missing", None)
 
@@ -1979,7 +1997,7 @@ def release_progress(request, pk: int, action: str):
         if to_run == step_count:
             name, func = steps[to_run]
             try:
-                func(release, ctx, log_path)
+                func(release, ctx, log_path, user=request.user)
             except PendingTodos:
                 pass
             except ApprovalRequired:
@@ -2360,6 +2378,7 @@ def todo_focus(request, pk: int):
         "focus_auth": focus_auth,
         "next_url": _get_return_url(request),
         "done_url": reverse("todo-done", args=[todo.pk]),
+        "delete_url": reverse("todo-delete", args=[todo.pk]),
         "snapshot_url": reverse("todo-snapshot", args=[todo.pk]),
     }
     return render(request, "core/todo_focus.html", context)
@@ -2378,7 +2397,29 @@ def todo_done(request, pk: int):
         messages.error(request, _format_condition_failure(todo, result))
         return redirect(redirect_to)
     todo.done_on = timezone.now()
-    todo.save(update_fields=["done_on"])
+    todo.populate_done_metadata(request.user)
+    todo.save(
+        update_fields=[
+            "done_on",
+            "done_node",
+            "done_version",
+            "done_revision",
+            "done_username",
+        ]
+    )
+    return redirect(redirect_to)
+
+
+@staff_member_required
+@require_POST
+def todo_delete(request, pk: int):
+    redirect_to = reverse("admin:index")
+    try:
+        todo = Todo.objects.get(pk=pk, is_deleted=False)
+    except Todo.DoesNotExist:
+        return redirect(redirect_to)
+    todo.is_deleted = True
+    todo.save(update_fields=["is_deleted"])
     return redirect(redirect_to)