argus-alm 0.12.10__py3-none-any.whl → 0.13.0__py3-none-any.whl

argus/backend/service/notification_manager.py

@@ -1,150 +0,0 @@
-import logging
-from typing import Any
-from uuid import UUID
-from flask import current_app, render_template
-from argus.backend.models.web import ArgusNotification, ArgusNotificationSourceTypes, ArgusNotificationTypes, ArgusNotificationState, User
-from argus.backend.util.send_email import Email
-
-LOGGER = logging.getLogger(__name__)
-
-
-class NotificationManagerException(Exception):
-    pass
-
-
-class NotificationManagerService:
-
-    def __init__(self, notification_senders: list["NotificationSenderBase"] | None = None) -> None:
-        self.notification_services: list["NotificationSenderBase"] = [
-            ArgusDBNotificationSaver(),
-            EmailNotificationServiceSender()
-        ]
-        if notification_senders:
-            self.notification_services.extend(notification_senders)
-
-    def send_notification(self, receiver: UUID, sender: UUID,
-                          notification_type: ArgusNotificationTypes,
-                          source_type: ArgusNotificationSourceTypes,
-                          source_id: UUID, title: str | None = None,
-                          source_message: str | None = None, content_params: dict | None = None) -> Any:
-
-        for service in self.notification_services:
-            service.send_notification(receiver, sender, notification_type, source_type,
-                                      source_id, title, source_message, content_params)
-
-    def get_notificaton(self, receiver: UUID, notification_id: UUID) -> ArgusNotification:
-        return ArgusNotification.get(receiver=receiver, id=notification_id)
-
-    def get_unread_count(self, receiver: UUID) -> int:
-        query = ArgusNotification.filter(
-            receiver=receiver, state__eq=ArgusNotificationState.UNREAD.value).allow_filtering().all()
-        return len(query)
-
-    def read_notification(self, receiver: UUID, notification_id: UUID) -> ArgusNotification:
-        notification = ArgusNotification.get(receiver=receiver, id=notification_id)
-        notification.state = ArgusNotificationState.READ
-        return bool(notification.save().state)
-
-    def get_notifications(self, receiver: UUID, limit: int = 20, after: UUID | None = None) -> list[ArgusNotification]:
-        if after:
-            return ArgusNotification.filter(receiver=receiver, id__lte=after).all().limit(limit)
-        return ArgusNotification.filter(receiver=receiver).all().limit(limit)
-
-
-class NotificationSenderBase:
-    NOTIFICATION_TITLES = {
-        ArgusNotificationTypes.Mention: "You were mentioned in a comment",
-        ArgusNotificationTypes.StatusChange: "A run you are assigned to changed status",
-        ArgusNotificationTypes.AssigneeChange: "You were assigned to a run",
-        ArgusNotificationTypes.ScheduleChange: "You were assigned to a schedule",
-    }
-
-    CONTENT_TEMPLATES = {}
-
-    def _check_user(self, user_id: UUID) -> bool:
-        try:
-            user = User.get(id=user_id)
-            if user.id == user_id:
-                return True
-        except User.DoesNotExist:
-            return False
-
-    def _get_title_for_notification_type(self, notification_type: ArgusNotificationTypes) -> str:
-        if title := self.NOTIFICATION_TITLES.get(notification_type):
-            return title
-        raise NotificationManagerException(
-            f"Title for notification type {notification_type} not found.", notification_type)
-
-    def _render_content(self, content_type: ArgusNotificationTypes, params: dict):
-        if content_renderer := self.CONTENT_TEMPLATES.get(content_type):
-            return content_renderer(params)
-        raise NotificationManagerException(
-            f"Content renderer for notification type {content_type} not found.", content_type)
-
-    def send_notification(self, receiver: UUID, sender: UUID,
-                          notification_type: ArgusNotificationTypes,
-                          source_type: ArgusNotificationSourceTypes,
-                          source_id: UUID,
-                          title: str | None = None,
-                          content: str | None = None,
-                          content_params: dict | None = None) -> Any:
-        raise NotImplementedError()
-
-
-class ArgusDBNotificationSaver(NotificationSenderBase):
-    CONTENT_TEMPLATES = {
-        ArgusNotificationTypes.Mention: lambda p: render_template("notifications/mention.html.j2", **p if p else {}),
-        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned.html.j2", **p if p else {}),
-    }
-
-    def send_notification(self, receiver: UUID, sender: UUID, notification_type: ArgusNotificationTypes, source_type: ArgusNotificationSourceTypes,
-                          source_id: UUID, title: str | None = None, content: str | None = None, content_params: dict | None = None) -> ArgusNotification:
-        new_notification = ArgusNotification()
-        for user in [sender, receiver]:
-            if not self._check_user(user_id=user):
-                raise NotificationManagerException(f"UserId {user} not found in the database", user)
-
-        new_notification.sender = sender
-        new_notification.receiver = receiver
-        new_notification.type = notification_type.value
-        new_notification.source_type = source_type.value
-        new_notification.source_id = source_id
-        new_notification.title = title if title else self._get_title_for_notification_type(notification_type)
-        new_notification.content = content if not content_params else self._render_content(
-            notification_type, content_params)
-        return new_notification.save()
-
-
-class EmailNotificationServiceSender(NotificationSenderBase):
-    CONTENT_TEMPLATES = {
-        ArgusNotificationTypes.Mention: lambda p: render_template(
-            "notifications/email_mention.html.j2", **p if p else {}),
-        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned_email.html.j2", **p if p else {}),
-    }
-
-    def __init__(self):
-        self.email = Email(init_connection=False)
-
-    def get_user(self, user_id: UUID) -> User:
-        return User.get(id=user_id)
-
-    def send_notification(self, receiver: UUID, sender: UUID,
-                          notification_type: ArgusNotificationTypes, source_type: ArgusNotificationSourceTypes,
-                          source_id: UUID, title: str | None = None, content: str | None = None, content_params: dict | None = None):
-        try:
-            content_params = content_params or {}
-            receiver_user = self.get_user(receiver)
-            sender_user = self.get_user(sender)
-            subject = title if title else self._get_title_for_notification_type(notification_type)
-            content_params.update({
-                                  "sender": sender_user.full_name,
-                                  "message": content,
-                                  })
-
-            email_content = self._render_content(notification_type, content_params)
-
-            self.email.send(subject=f"Argus Notification - {subject}",
-                            content=email_content,
-                            recipients=[receiver_user.email])
-        except Exception as details:  # pylint: disable=broad-except
-            current_app.logger.error("Failed to send email: %s", details)

argus/backend/service/release_manager.py

@@ -1,230 +0,0 @@
-import logging
-from typing import TypedDict
-from uuid import UUID
-from argus.backend.db import ScyllaCluster
-from argus.backend.plugins.sct.testrun import SCTTestRun
-from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest
-
-LOGGER = logging.getLogger(__name__)
-
-
-class ReleaseManagerException(Exception):
-    pass
-
-
-class ReleaseEditPayload(TypedDict):
-    id: str
-    pretty_name: str
-    description: str
-    valid_version_regex: str | None
-    enabled: bool
-    perpetual: bool
-    dormant: bool
-
-
-class ReleaseManagerService:
-    def __init__(self) -> None:
-        self.session = ScyllaCluster.get_session()
-        self.database = ScyllaCluster.get()
-        self.runs_by_build_id_stmt = self.database.prepare(
-            "SELECT id, test_id, group_id, release_id, build_id, start_time "
-            f"FROM {SCTTestRun.table_name()} WHERE build_id = ?"
-        )
-        self.update_run_stmt = self.database.prepare(
-            f"UPDATE {SCTTestRun.table_name()} SET test_id = ?, group_id = ?, release_id = ? "
-            "WHERE build_id = ? AND start_time = ?"
-        )
-
-    def get_releases(self) -> list[ArgusRelease]:
-        return list(ArgusRelease.all())
-
-    def get_groups(self, release_id: UUID) -> list[ArgusGroup]:
-        return list(ArgusGroup.filter(release_id=release_id).all())
-
-    def get_tests(self, group_id: UUID) -> list[ArgusTest]:
-        return list(ArgusTest.filter(group_id=group_id).all())
-
-    def toggle_test_enabled(self, test_id: UUID, new_state: bool) -> bool:
-        test: ArgusTest = ArgusTest.get(id=test_id)
-        test.enabled = new_state
-        test.save()
-
-        return test
-
-    def toggle_group_enabled(self, group_id: UUID, new_state: bool) -> bool:
-        test: ArgusGroup = ArgusGroup.get(id=group_id)
-        test.enabled = new_state
-        test.save()
-
-        return test
-
-    def create_release(self, release_name: str, pretty_name: str, perpetual: bool) -> ArgusRelease:
-        try:
-            release = ArgusRelease.get(name=release_name)
-        except ArgusRelease.DoesNotExist:
-            release = ArgusRelease()
-            release.name = release_name
-            release.pretty_name = pretty_name
-            release.perpetual = perpetual
-
-            release.save()
-        else:
-            raise ReleaseManagerException(
-                f"Release {release_name} already exists!", release_name)
-
-        return release
-
-    def create_group(self, group_name: str, pretty_name: str, build_system_id: str,
-                     release_id: str) -> ArgusGroup:
-        release = ArgusRelease.get(id=UUID(release_id))
-
-        new_group = ArgusGroup()
-        new_group.name = group_name
-        new_group.pretty_name = pretty_name
-        new_group.release_id = release.id
-        new_group.build_system_id = build_system_id
-        new_group.save()
-
-        return new_group
-
-    def create_test(self, test_name, pretty_name, build_id, build_url, group_id, release_id, plugin_name) -> ArgusTest:
-        release = ArgusRelease.get(id=UUID(release_id))
-        group = ArgusGroup.get(id=UUID(group_id))
-
-        new_test = ArgusTest()
-        new_test.name = test_name
-        new_test.pretty_name = pretty_name
-        new_test.build_system_id = build_id
-        new_test.release_id = release.id
-        new_test.group_id = group.id
-        new_test.plugin_name = plugin_name
-        new_test.build_system_url = build_url
-        new_test.validate_build_system_id()
-        new_test.save()
-        self.move_test_runs(new_test)
-        return new_test
-
-    def delete_group(self, group_id: str, delete_tests: bool = True, new_group_id: str = "") -> bool:
-        group_to_delete = ArgusGroup.get(id=UUID(group_id))
-
-        tests_to_change = ArgusTest.filter(
-            group_id=group_to_delete.id)
-        if delete_tests:
-            for test in tests_to_change.all():
-                test.delete()
-        else:
-            new_group = ArgusGroup.get(id=UUID(new_group_id))
-            for test in tests_to_change.all():
-                test.group_id = new_group.id
-                test.save()
-
-        group_to_delete.delete()
-
-        return True
-
-    def delete_test(self, test_id: str) -> bool:
-        test_to_delete = ArgusTest.get(id=test_id)
-        test_to_delete.delete()
-
-        return True
-
-    def update_group(self, group_id: str, name: str, pretty_name: str, enabled: bool, build_system_id: str) -> bool:
-        group = ArgusGroup.get(id=UUID(group_id))
-
-        group.name = name
-        group.build_system_id = build_system_id
-        group.pretty_name = pretty_name
-        group.enabled = enabled
-
-        group.save()
-
-        return True
-
-    def update_test(self, test_id: str, name: str, pretty_name: str, plugin_name: str,
-                    enabled: bool, build_system_id: str, build_system_url: str, group_id) -> bool:
-        test: ArgusTest = ArgusTest.get(id=UUID(test_id))
-        group = ArgusGroup.get(id=UUID(group_id))
-
-        test.name = name
-        test.pretty_name = pretty_name
-        test.plugin_name = plugin_name
-        test.enabled = enabled
-        test.build_system_id = build_system_id
-        test.build_system_url = build_system_url
-        if test.group_id != group.id:
-            test.group_id = group.id
-            LOGGER.info("Relocating old test runs into a new group")
-
-        test.validate_build_system_id()
-        test.save()
-        self.move_test_runs(test)
-        return True
-
-    def set_release_state(self, release_id: str, state: bool) -> bool:
-        release = ArgusRelease.get(id=UUID(release_id))
-        release.enabled = state
-        release.save()
-
-        return True
-
-    def set_release_dormancy(self, release_id: str, dormant: bool) -> bool:
-        release = ArgusRelease.get(id=UUID(release_id))
-        release.dormant = dormant
-        release.save()
-
-        return True
-
-    def set_release_perpetuality(self, release_id: str, perpetual: bool) -> bool:
-        release = ArgusRelease.get(id=UUID(release_id))
-        release.perpetual = perpetual
-        release.save()
-
-        return True
-
-    def edit_release(self, payload: ReleaseEditPayload) -> bool:
-
-        release: ArgusRelease = ArgusRelease.get(id=payload["id"])
-        release.pretty_name = payload["pretty_name"]
-        release.perpetual = payload["perpetual"]
-        release.enabled = payload["enabled"]
-        release.dormant = payload["dormant"]
-        release.description = payload["description"]
-        release.valid_version_regex = payload["valid_version_regex"]
-
-
-        release.save()
-        return True
-
-    def delete_release(self, release_id: str) -> bool:
-
-        release: ArgusRelease = ArgusRelease.get(id=release_id)
-
-        release_groups = ArgusGroup.filter(release_id=release.id)
-        release_tests = ArgusTest.filter(release_id=release.id)
-
-        for entity in [*release_groups.all(), *release_tests.all()]:
-            entity.delete()
-
-        release.delete()
-        return True
-
-    def batch_move_tests(self, new_group_id: str, tests: list[str]) -> bool:
-        group = ArgusGroup.get(id=UUID(new_group_id))
-
-        tests: list[ArgusTest] = [ArgusTest.get(id=UUID(test_id)) for test_id in tests]
-
-        for test in tests:
-            test.group_id = group.id
-            test.save()
-            self.move_test_runs(test)
-
-        return True
-
-    def move_test_runs(self, test: ArgusTest) -> None:
-        run_rows = self.session.execute(self.runs_by_build_id_stmt, parameters=(
-            test.build_system_id,), execution_profile="read_fast")
-        for run in run_rows:
-            run["test_id"] = test.id
-            run["group_id"] = test.group_id
-            run["release_id"] = test.release_id
-            self.session.execute(self.update_run_stmt, parameters=run)