argus-alm 0.12.2__py3-none-any.whl → 0.12.4b1__py3-none-any.whl

argus/backend/service/stats.py

@@ -1,14 +1,17 @@
+from collections import defaultdict
+from functools import reduce
 import logging
 
 from datetime import datetime
 from typing import TypedDict
 from uuid import UUID
 
+from cassandra.cqlengine.models import Model
 from argus.backend.plugins.loader import all_plugin_models
-from argus.backend.util.common import get_build_number
+from argus.backend.util.common import chunk, get_build_number
 from argus.backend.util.enums import TestStatus, TestInvestigationStatus
 from argus.backend.models.web import ArgusGithubIssue, ArgusRelease, ArgusGroup, ArgusTest,\
-    ArgusScheduleTest, ArgusTestRunComment
+    ArgusScheduleTest, ArgusTestRunComment, ArgusUserView
 from argus.backend.db import ScyllaCluster
 
 LOGGER = logging.getLogger(__name__)
@@ -140,6 +143,96 @@ def generate_field_status_map(
                 status_map[run_number] = (run[field_name], run)
     return status_map
 
+class ViewStats:
+    def __init__(self, release: ArgusUserView) -> None:
+        self.release = release
+        self.groups: list[GroupStats] = []
+        self.status_map = {status: 0 for status in TestStatus}
+        self.total_tests = 0
+        self.last_status = TestStatus.NOT_PLANNED
+        self.last_investigation_status = TestInvestigationStatus.NOT_INVESTIGATED
+        self.has_bug_report = False
+        self.issues: list[ArgusGithubIssue] = []
+        self.comments: list[ArgusTestRunComment] = []
+        self.test_schedules: dict[UUID, ArgusScheduleTest] = {}
+        self.forced_collection = False
+        self.rows = []
+        self.releases = {}
+        self.all_tests = []
+
+    def to_dict(self) -> dict:
+        converted_groups = {str(group.group.id): group.to_dict() for group in self.groups}
+        aggregated_investigation_status = {}
+        for group in converted_groups.values():
+            for investigation_status in TestInvestigationStatus:
+                current_status = aggregated_investigation_status.get(investigation_status.value, {})
+                result = {
+                    status.value: current_status.get(status.value, 0) + group.get(investigation_status.value, {}).get(status, 0)
+                    for status in TestStatus
+                }
+                aggregated_investigation_status[investigation_status.value] = result
+
+        return {
+            "release": dict(self.release.items()),
+            "releases": self.releases,
+            "groups": converted_groups,
+            "total": self.total_tests,
+            **self.status_map,
+            "disabled": False,
+            "perpetual": False,
+            "lastStatus": self.last_investigation_status,
+            "lastInvestigationStatus": self.last_investigation_status,
+            "hasBugReport": self.has_bug_report,
+            **aggregated_investigation_status
+        }
+
+    def _fetch_multiple_release_queries(self, entity: Model, releases: list[str]):
+        result_set = []
+        for release_id in releases:
+            result_set.extend(entity.filter(release_id=release_id).all())
+        return result_set
+
+    def collect(self, rows: list[TestRunStatRow], limited=False, force=False, dict: dict[str, TestRunStatRow] | None = None, tests: list[ArgusTest] = None) -> None:
+        self.forced_collection = force
+        all_release_ids = list({t.release_id for t in tests})
+        if not limited:
+            self.test_schedules = reduce(
+                lambda acc, row: acc[row["test_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusScheduleTest, all_release_ids),
+                defaultdict(list)
+            )
+
+        self.rows = rows
+        self.dict = dict
+        if not limited or force:
+            self.issues = reduce(
+                lambda acc, row: acc[row["run_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusGithubIssue, all_release_ids),
+                defaultdict(list)
+            )
+            self.comments = reduce(
+                lambda acc, row: acc[row["test_run_id"]].append(row) or acc,
+                self._fetch_multiple_release_queries(ArgusTestRunComment, all_release_ids),
+                defaultdict(list)
+            )
+        self.all_tests = tests
+        groups = []
+        for slice in chunk(list({t.release_id for t in tests})):
+            self.releases.update({str(release.id): release for release in ArgusRelease.filter(id__in=slice).all()})
+
+        for slice in chunk(list({t.group_id for t in tests})):
+            groups.extend(ArgusGroup.filter(id__in=slice).all())
+        for group in groups:
+            if group.enabled:
+                stats = GroupStats(group=group, parent_release=self)
+                stats.collect(limited=limited)
+                self.groups.append(stats)
+
+    def increment_status(self, status=TestStatus.NOT_PLANNED):
+        self.total_tests += 1
+        self.status_map[TestStatus(status)] += 1
+        self.last_status = TestStatus(status)
+
 
 class ReleaseStats:
     def __init__(self, release: ArgusRelease) -> None:
@@ -152,7 +245,7 @@ class ReleaseStats:
         self.has_bug_report = False
         self.issues: list[ArgusGithubIssue] = []
         self.comments: list[ArgusTestRunComment] = []
-        self.test_schedules: list[ArgusScheduleTest] = []
+        self.test_schedules: dict[UUID, ArgusScheduleTest] = {}
         self.forced_collection = False
         self.rows = []
         self.all_tests = []
@@ -182,21 +275,32 @@ class ReleaseStats:
             **aggregated_investigation_status
         }
 
-    def collect(self, rows: list[TestRunStatRow], limited=False, force=False) -> None:
+    def collect(self, rows: list[TestRunStatRow], limited=False, force=False, dict: dict | None = None, tests=None) -> None:
         self.forced_collection = force
         if not self.release.enabled and not force:
             return
 
         if not self.release.perpetual and not limited:
-            self.test_schedules = list(ArgusScheduleTest.filter(
-                release_id=self.release.id
-            ).all())
+            self.test_schedules = reduce(
+                lambda acc, row: acc[row["test_id"]].append(row) or acc,
+                ArgusScheduleTest.filter(release_id=self.release.id).all(), 
+                defaultdict(list)
+            )
 
         self.rows = rows
+        self.dict = dict
         if not limited or force:
-            self.issues = ArgusGithubIssue.filter(release_id=self.release.id).all()
-            self.comments = ArgusTestRunComment.filter(release_id=self.release.id).all()
-        self.all_tests = ArgusTest.filter(release_id=self.release.id).all()
+            self.issues = reduce(
+                lambda acc, row: acc[row["run_id"]].append(row) or acc,
+                ArgusGithubIssue.filter(release_id=self.release.id).all(),
+                defaultdict(list)
+            )
+            self.comments = reduce(
+                lambda acc, row: acc[row["test_run_id"]].append(row) or acc,
+                ArgusTestRunComment.filter(release_id=self.release.id).all(),
+                defaultdict(list)
+            )
+        self.all_tests = ArgusTest.filter(release_id=self.release.id).all() if not tests else tests
         groups: list[ArgusGroup] = ArgusGroup.filter(release_id=self.release.id).all()
         for group in groups:
             if group.enabled:
@@ -250,8 +354,7 @@ class GroupStats:
                 stats = TestStats(
                     test=test,
                     parent_group=self,
-                    schedules=tuple(
-                        schedule for schedule in self.parent_release.test_schedules if schedule.test_id == test.id)
+                    schedules=self.parent_release.test_schedules.get(test.id, [])
                 )
                 stats.collect(limited=limited)
                 self.tests.append(stats)
@@ -292,13 +395,17 @@ class TestStats:
             "hasBugReport": self.has_bug_report,
             "hasComments": self.has_comments,
             "buildNumber": self.tracked_run_number,
+            "buildId": self.test.build_system_id,
         }
 
     def collect(self, limited=False):
 
         # TODO: Parametrize run limit
         # FIXME: This is only a mitigation, build_number overflows on the build system side.
-        last_runs = [r for r in self.parent_group.parent_release.rows if r["build_id"] == self.test.build_system_id][:15]
+        if not self.parent_group.parent_release.dict:
+            last_runs = [r for r in self.parent_group.parent_release.rows if r["build_id"] == self.test.build_system_id]
+        else:
+            last_runs = self.parent_group.parent_release.dict.get(self.test.build_system_id, [])
         last_runs: list[TestRunStatRow] = sorted(
             last_runs, reverse=True, key=lambda r: get_build_number(r["build_job_url"]))
         try:
@@ -326,8 +433,8 @@ class TestStats:
                 "build_job_name": run["build_id"],
                 "start_time": run["start_time"],
                 "assignee": run["assignee"],
-                "issues": [dict(i.items()) for i in self.parent_group.parent_release.issues if i.run_id == run["id"]],
-                "comments": [dict(i.items()) for i in self.parent_group.parent_release.comments if i.test_run_id == run["id"]],
+                "issues": [dict(issue.items()) for issue in self.parent_group.parent_release.issues[run["id"]]],
+                "comments": [dict(comment.items()) for comment in self.parent_group.parent_release.comments[run["id"]]],
             }
             for run in last_runs
         ]
@@ -335,8 +442,8 @@ class TestStats:
             target_run = next(run for run in self.last_runs if run["id"] == worst_case[1]["id"])
         except StopIteration:
             target_run = worst_case[1]
-            target_run["issues"] = [dict(i.items()) for i in self.parent_group.parent_release.issues if i.run_id == target_run["id"]]
-            target_run["comments"] = [dict(i.items()) for i in self.parent_group.parent_release.comments if i.test_run_id == target_run["id"]]
+            target_run["issues"] = [dict(issue.items()) for issue in self.parent_group.parent_release.issues[target_run["id"]]]
+            target_run["comments"] = [dict(comment.items()) for comment in self.parent_group.parent_release.comments[target_run["id"]]]
         self.has_bug_report = len(target_run["issues"]) > 0
         self.parent_group.parent_release.has_bug_report = self.has_bug_report or self.parent_group.parent_release.has_bug_report
         self.has_comments = len(target_run["comments"]) > 0
@@ -356,13 +463,15 @@ class ReleaseStatsCollector:
 
     def collect(self, limited=False, force=False, include_no_version=False) -> dict:
         self.release: ArgusRelease = ArgusRelease.get(name=self.release_name)
-        self.release_rows = [row for plugin in all_plugin_models()
-                             for row in plugin.get_stats_for_release(release=self.release)]
+        all_tests: list[ArgusTest] = list(ArgusTest.filter(release_id=self.release.id).all())
+        build_ids = reduce(lambda acc, test: acc[test.plugin_name or "unknown"].append(test.build_system_id) or acc, all_tests, defaultdict(list))
+        self.release_rows = [futures for plugin in all_plugin_models()
+                             for futures in plugin.get_stats_for_release(release=self.release, build_ids=build_ids.get(plugin._plugin_name, []))]
+        self.release_rows = [row for future in self.release_rows for row in future.result()]
         if self.release.dormant and not force:
             return {
                 "dormant": True
             }
-
         if self.release_version:
             if include_no_version:
                 expr = lambda row: row["scylla_version"] == self.release_version or not row["scylla_version"] 
@@ -376,7 +485,56 @@ class ReleaseStatsCollector:
             else:
                 expr = lambda row: row["scylla_version"]
         self.release_rows = list(filter(expr, self.release_rows))
+        self.release_dict = {}
+        for row in self.release_rows:
+            runs = self.release_dict.get(row["build_id"], [])
+            runs.append(row)
+            self.release_dict[row["build_id"]] = runs
 
         self.release_stats = ReleaseStats(release=self.release)
-        self.release_stats.collect(rows=self.release_rows, limited=limited, force=force)
+        self.release_stats.collect(rows=self.release_rows, limited=limited, force=force, dict=self.release_dict, tests=all_tests)
         return self.release_stats.to_dict()
+
+
+class ViewStatsCollector:
+    def __init__(self, view_id: UUID, filter: str | None = None) -> None:
+        self.database = ScyllaCluster.get()
+        self.session = self.database.get_session()
+        self.view = None
+        self.view_stats = None
+        self.view_rows = []
+        self.runs_by_build_id = {}
+        self.view_id = view_id
+        self.filter = filter
+
+    def collect(self, limited=False, force=False, include_no_version=False) -> dict:
+        self.view: ArgusUserView = ArgusUserView.get(id=self.view_id)
+        all_tests: list[ArgusTest] = []
+        for slice in chunk(self.view.tests):
+            all_tests.extend(ArgusTest.filter(id__in=slice).all())
+        build_ids = reduce(lambda acc, test: acc[test.plugin_name or "unknown"].append(test.build_system_id) or acc, all_tests, defaultdict(list))
+        self.view_rows = [futures for plugin in all_plugin_models()
+                             for futures in plugin.get_stats_for_release(release=self.view, build_ids=build_ids.get(plugin._plugin_name, []))]
+        self.view_rows = [row for future in self.view_rows for row in future.result()]
+
+        if self.filter:
+            if include_no_version:
+                expr = lambda row: row["scylla_version"] == self.filter or not row["scylla_version"] 
+            elif self.filter == "!noVersion":
+                expr = lambda row: not row["scylla_version"]
+            else:
+                expr = lambda row: row["scylla_version"] == self.filter
+        else:
+            if include_no_version:
+                expr = lambda row: row
+            else:
+                expr = lambda row: row["scylla_version"]
+        self.view_rows = list(filter(expr, self.view_rows))
+        for row in self.view_rows:
+            runs = self.runs_by_build_id.get(row["build_id"], [])
+            runs.append(row)
+            self.runs_by_build_id[row["build_id"]] = runs
+
+        self.view_stats = ViewStats(release=self.view)
+        self.view_stats.collect(rows=self.view_rows, limited=limited, force=force, dict=self.runs_by_build_id, tests=all_tests)
+        return self.view_stats.to_dict()

argus/backend/service/testrun.py

@@ -1,4 +1,6 @@
+from collections import defaultdict
 from datetime import datetime, timedelta
+from functools import reduce
 import json
 import logging
 import re
@@ -22,6 +24,7 @@ from argus.backend.models.web import (
     ArgusRelease,
     ArgusTest,
     ArgusTestRunComment,
+    ArgusUserView,
     User,
     UserOauthToken,
 )
@@ -33,7 +36,7 @@ from argus.backend.events.event_processors import EVENT_PROCESSORS
 from argus.backend.service.event_service import EventService
 from argus.backend.service.notification_manager import NotificationManagerService
 from argus.backend.service.stats import ComparableTestStatus
-from argus.backend.util.common import get_build_number, strip_html_tags
+from argus.backend.util.common import chunk, get_build_number, strip_html_tags
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
 LOGGER = logging.getLogger(__name__)
@@ -163,6 +166,12 @@ class TestRunService:
     def change_run_assignee(self, test_id: UUID, run_id: UUID, new_assignee: UUID | None):
         test = ArgusTest.get(id=test_id)
         plugin = self.get_plugin(plugin_name=test.plugin_name)
+        if not plugin:
+            return {
+                "test_run_id": run.id,
+                "assignee": None
+            }
+
         run: PluginModelBase = plugin.model.get(id=run_id)
         old_assignee = run.assignee
         run.assignee = new_assignee
@@ -219,6 +228,7 @@ class TestRunService:
         plugin = self.get_plugin(test.plugin_name)
         release: ArgusRelease = ArgusRelease.get(id=test.release_id)
         comment = ArgusTestRunComment()
+        comment.test_id = test.id
         comment.message = message_stripped
         comment.reactions = reactions
         comment.mentions = [m.id for m in mentions]
@@ -374,13 +384,23 @@ class TestRunService:
 
         return response
 
+    def _get_github_issues_for_view(self, view_id: UUID | str) -> list[ArgusGithubIssue]:
+        view: ArgusUserView = ArgusUserView.get(id=view_id)
+        issues = []
+        for batch in chunk(view.tests):
+            issues.extend(ArgusGithubIssue.filter(test_id__in=batch).allow_filtering().all())
+        
+        return issues
+
     def get_github_issues(self, filter_key: str, filter_id: UUID, aggregate_by_issue: bool = False) -> dict:
-        if filter_key not in ["release_id", "group_id", "test_id", "run_id", "user_id"]:
+        if filter_key not in ["release_id", "group_id", "test_id", "run_id", "user_id", "view_id"]:
             raise Exception(
-                "filter_key can only be one of: \"release_id\", \"group_id\", \"test_id\", \"run_id\", \"user_id\""
+                "filter_key can only be one of: \"release_id\", \"group_id\", \"test_id\", \"run_id\", \"user_id\", \"view_id\""
             )
-
-        all_issues = ArgusGithubIssue.filter(**{filter_key: filter_id}).all()
+        if filter_key == "view_id":
+            all_issues = self._get_github_issues_for_view(filter_id)
+        else:
+            all_issues = ArgusGithubIssue.filter(**{filter_key: filter_id}).all()
         if aggregate_by_issue:
             runs_by_issue = {}
             response = []
@@ -398,6 +418,25 @@ class TestRunService:
             response = [dict(issue.items()) for issue in all_issues]
         return response
 
+    def resolve_run_build_id_and_number_multiple(self, runs: list[tuple[UUID, UUID]]) -> dict[UUID, dict[str, Any]]:
+        test_ids = [r[0] for r in runs]
+        all_tests: list = []
+        for id_slice in chunk(test_ids):
+            all_tests.extend(ArgusTest.filter(id__in=id_slice).all())
+
+        tests: dict[str, ArgusTest] = {str(t.id): t for t in all_tests}
+        runs_by_plugin = reduce(lambda acc, val: acc[tests[val[0]].plugin_name].append(val[1]) or acc, runs, defaultdict(list))
+        all_runs = {}
+        for plugin, run_ids in runs_by_plugin.items():
+            model = AVAILABLE_PLUGINS.get(plugin).model
+            model_runs = []
+            for run_id in run_ids:
+                model_runs.append(model.filter(id=run_id).only(["build_id", "start_time", "build_job_url", "id", "test_id"]).get())
+            all_runs.update({ str(run["id"]): {**run, "build_number": get_build_number(run["build_job_url"])} for run in model_runs })
+
+        return all_runs
+
+
     def delete_github_issue(self, issue_id: UUID) -> dict:
         issue: ArgusGithubIssue = ArgusGithubIssue.get(id=issue_id)
 

argus/backend/service/views.py

@@ -0,0 +1,258 @@
+import datetime
+import logging
+import re
+from functools import partial, reduce
+from typing import Any, Callable, TypedDict
+from urllib.parse import unquote
+from uuid import UUID
+
+from cassandra.cqlengine.models import Model
+from argus.backend.models.web import ArgusGroup, ArgusRelease, ArgusTest, ArgusUserView, User
+from argus.backend.plugins.loader import all_plugin_models
+from argus.backend.util.common import chunk, current_user
+
+LOGGER = logging.getLogger(__name__)
+
+
+class UserViewException(Exception):
+    pass
+
+
+class ViewUpdateRequest(TypedDict):
+    name: str
+    description: str
+    display_name: str
+    tests: list[str]
+    widget_settings: str
+
+
+class UserViewService:
+    ADD_ALL_ID = UUID("db6f33b2-660b-4639-ba7f-79725ef96616")
+    def create_view(self, name: str, items: list[str], widget_settings: str, description: str = None, display_name: str = None) -> ArgusUserView:
+        try:
+            name_check = ArgusUserView.get(name=name)
+            raise UserViewException(f"View with name {name} already exists: {name_check.id}", name, name_check, name_check.id)
+        except ArgusUserView.DoesNotExist:
+            pass
+        view = ArgusUserView()
+        view.name = name
+        view.display_name = display_name or name
+        view.description = description
+        view.widget_settings = widget_settings
+        view.tests = []
+        for entity in items:
+            entity_type, entity_id = entity.split(":")
+            match (entity_type):
+                case "release": 
+                    view.tests.extend(t.id for t in ArgusTest.filter(release_id=entity_id).all())
+                    view.release_ids.append(entity_id)
+                case "group": 
+                    view.tests.extend(t.id for t in ArgusTest.filter(group_id=entity_id).all())
+                    view.group_ids.append(entity_id)
+                case "test": 
+                    view.tests.append(entity_id)
+        view.user_id = current_user().id
+
+        view.save()
+        return view
+
+    @staticmethod
+    def index_mapper(item: Model, type = "test"):
+        mapped = dict(item)
+        mapped["type"] = type
+        return mapped
+
+    def test_lookup(self, query: str):
+        def check_visibility(entity: dict):
+            if not entity["enabled"]:
+                return False
+            if entity.get("group") and not entity["group"]["enabled"]:
+                return False
+            if entity.get("release") and not entity["release"]["enabled"]:
+                return False
+            return True
+
+        def facet_extraction(query: str) -> str:
+            extractor = re.compile(r"(?:(?P<name>(?:release|group|type)):(?P<value>\"?[\w\d\.\-]*\"?))")
+            facets = re.findall(extractor, query)
+
+            return (re.sub(extractor, "", query).strip(), facets)
+
+        def type_facet_filter(item: dict, key: str, facet_query: str):
+            entity_type: str = item[key]
+            return facet_query.lower() == entity_type
+
+        def facet_filter(item: dict, key: str, facet_query: str):
+            if entity := item.get(key):
+                name: str = entity.get("pretty_name") or entity.get("name")
+                return facet_query.lower() in name.lower() if name else False
+            return False
+
+        def facet_wrapper(query_func: Callable[[dict], bool], facet_query: str, facet_type: str) -> bool:
+            def inner(item: dict, query: str):
+                return query_func(item, query) and facet_funcs[facet_type](item, facet_type, facet_query)
+            return inner
+
+        facet_funcs = {
+            "type": type_facet_filter,
+            "release": facet_filter,
+            "group": facet_filter,
+        }
+
+        def index_searcher(item, query: str):
+            name: str = item["pretty_name"] or item["name"]
+            return unquote(query).lower() in name.lower() if query else True
+
+        text_query, facets = facet_extraction(query)
+        search_func = index_searcher
+        for facet, value in facets:
+            if facet in facet_funcs.keys():
+                search_func = facet_wrapper(query_func=search_func, facet_query=value, facet_type=facet)
+
+
+        all_tests = ArgusTest.all()
+        all_releases = ArgusRelease.all()
+        all_groups = ArgusGroup.all()
+        release_by_id = {release.id: partial(self.index_mapper, type="release")(release) for release in all_releases}
+        group_by_id = {group.id: partial(self.index_mapper, type="group")(group) for group in all_groups}
+        index = [self.index_mapper(t) for t in all_tests]
+        index = [*release_by_id.values(), *group_by_id.values(), *index]
+        for item in index:
+            item["group"] = group_by_id.get(item.get("group_id"))
+            item["release"] = release_by_id.get(item.get("release_id"))
+
+        results = filter(partial(search_func, query=text_query), index)
+
+        return [{ "id": self.ADD_ALL_ID, "name": "Add all...", "type": "special" }, *list(res for res in results if check_visibility(res))]
+
+    def update_view(self, view_id: str | UUID, update_data: ViewUpdateRequest) -> bool:
+        view: ArgusUserView = ArgusUserView.get(id=view_id)
+        if view.user_id != current_user().id and not current_user().is_admin():
+            raise UserViewException("Unable to modify other users' views")
+        for key in ["user_id", "id"]:
+            update_data.pop(key, None)
+        items = update_data.pop("items")
+        for k, value in update_data.items():
+            view[k] = value
+        view.tests = []
+        view.release_ids = []
+        view.group_ids = []
+        for entity in items:
+            entity_type, entity_id = entity.split(":")
+            match (entity_type):
+                case "release": 
+                    view.tests.extend(t.id for t in ArgusTest.filter(release_id=entity_id).all())
+                    view.release_ids.append(entity_id)
+                case "group": 
+                    view.tests.extend(t.id for t in ArgusTest.filter(group_id=entity_id).all())
+                    view.group_ids.append(entity_id)
+                case "test": 
+                    view.tests.append(entity_id)
+        view.last_updated = datetime.datetime.utcnow()
+        view.save()
+        return True
+
+    def delete_view(self, view_id: str | UUID) -> bool:
+        view = ArgusUserView.get(id=view_id)
+        if view.user_id != current_user().id and not current_user().is_admin():
+            raise UserViewException("Unable to modify other users' views")
+        view.delete()
+
+        return True
+
+    def get_view(self, view_id: str | UUID) -> ArgusUserView:
+        view: ArgusUserView = ArgusUserView.get(id=view_id)
+        if datetime.datetime.utcnow() - (view.last_updated or datetime.datetime.fromtimestamp(0)) > datetime.timedelta(hours=1):
+            self.refresh_stale_view(view)
+        return view
+
+    def get_view_by_name(self, view_name: str) -> ArgusUserView:
+        view: ArgusUserView = ArgusUserView.get(name=view_name)
+        if datetime.datetime.utcnow() - (view.last_updated or datetime.datetime.fromtimestamp(0)) > datetime.timedelta(hours=1):
+            self.refresh_stale_view(view)
+        return view
+
+    def get_all_views(self, user: User | None = None) -> list[ArgusUserView]:
+        if user:
+            return list(ArgusUserView.filter(user_id=user.id).all())
+        return list(ArgusUserView.filter().all())
+
+    def resolve_view_tests(self, view_id: str | UUID) -> list[ArgusTest]:
+        view = ArgusUserView.get(id=view_id)
+        return self.resolve_tests_by_id(view.tests)
+
+    def resolve_tests_by_id(self, test_ids: list[str | UUID]) -> list[ArgusTest]:
+        tests = []
+        for batch in chunk(test_ids):
+            tests.extend(ArgusTest.filter(id__in=batch).all())
+
+        return tests
+
+    def batch_resolve_entity(self, entity: Model, param_name: str, entity_ids: list[UUID]) -> list[Model]:
+        result = []
+        for batch in chunk(entity_ids):
+            result.extend(entity.filter(**{f"{param_name}__in": batch}).allow_filtering().all())
+        return result
+
+    def refresh_stale_view(self, view: ArgusUserView):
+        view.tests = [test.id for test in self.resolve_view_tests(view.id)]
+        all_tests = set(view.tests)
+        all_tests.update(test.id for test in self.batch_resolve_entity(ArgusTest, "group_id", view.group_ids))
+        all_tests.update(test.id for test in self.batch_resolve_entity(ArgusTest, "release_id", view.release_ids))
+        view.tests = list(all_tests)
+        view.last_updated = datetime.datetime.utcnow()
+        view.save()
+
+        return view
+
+    def resolve_releases_for_tests(self, tests: list[ArgusTest]):
+        releases = []
+        unique_release_ids = reduce(lambda releases, test: releases.add(test.release_id) or releases, tests, set())
+        for batch in chunk(unique_release_ids):
+            releases.extend(ArgusRelease.filter(id__in=batch).all())
+
+        return releases
+
+    def resolve_groups_for_tests(self, tests: list[ArgusTest]):
+        releases = []
+        unique_release_ids = reduce(lambda groups, test: groups.add(test.group_id) or groups, tests, set())
+        for batch in chunk(unique_release_ids):
+            releases.extend(ArgusGroup.filter(id__in=batch).all())
+
+        return releases
+
+    def get_versions_for_view(self, view_id: str | UUID) -> list[str]:
+        tests = self.resolve_view_tests(view_id)
+        unique_versions = {ver for plugin in all_plugin_models()
+                           for ver in plugin.get_distinct_versions_for_view(tests=tests)}
+
+        return sorted(list(unique_versions), reverse=True)
+
+    def resolve_view_for_edit(self, view_id: str | UUID) -> dict:
+        view: ArgusUserView = ArgusUserView.get(id=view_id)
+        resolved = dict(view)
+        view_groups = self.batch_resolve_entity(ArgusGroup, "id", view.group_ids)
+        view_releases = self.batch_resolve_entity(ArgusRelease, "id", view.release_ids)
+        view_tests = self.resolve_view_tests(view.id)
+        all_groups = { group.id: partial(self.index_mapper, type="group")(group) for group in self.resolve_releases_for_tests(view_tests) }
+        all_releases ={ release.id: partial(self.index_mapper, type="release")(release) for release in self.resolve_releases_for_tests(view_tests) }
+        entities_by_id = {
+            entity.id: partial(self.index_mapper, type="release" if isinstance(entity, ArgusRelease) else "group")(entity)
+            for container in [view_releases, view_groups]
+            for entity in container
+        }
+
+        items = []
+        for test in view_tests:
+            if not (entities_by_id.get(test.group_id) or entities_by_id.get(test.release_id)):
+                item = dict(test)
+                item["type"] = "test"
+                items.append(item)
+
+        items = [*entities_by_id.values(), *items]
+        for entity in items:
+            entity["group"] = all_groups.get(entity.get("group_id"), {}).get("pretty_name") or all_groups.get(entity.get("group_id"), {}).get("name")
+            entity["release"] = all_releases.get(entity.get("release_id"), {}).get("pretty_name") or all_releases.get(entity.get("release_id"), {}).get("name")
+
+        resolved["items"] = items
+        return resolved

argus/backend/template_filters.py

@@ -18,3 +18,10 @@ def safe_user(user: User):
     user_dict = dict(user.items())
     del user_dict["password"]
     return user_dict
+
+
+@is_filter("formatted_date")
+def formatted_date(date: datetime | None):
+    if date:
+        return date.strftime("%d/%m/%Y %H:%M:%S")
+    return "#unknown"