Implement Forgejo event handling in Packit Service

Author: mynk8

packit_service/events/__init__.py

@@ -7,6 +7,7 @@
     copr,
     enums,
     event,
+    forgejo,
     github,
     gitlab,
     koji,
@@ -22,6 +23,7 @@
     anitya.__name__,
     github.__name__,
     gitlab.__name__,
+    forgejo.__name__,
     koji.__name__,
     openscanhub.__name__,
     pagure.__name__,

packit_service/events/forgejo/__init__.py

@@ -0,0 +1,6 @@
+# Copyright Contributors to the Packit project.
+# SPDX-License-Identifier: MIT
+
+from . import abstract, issue, pr, push
+
+__all__ = [abstract.__name__, push.__name__, issue.__name__, pr.__name__]

packit_service/events/forgejo/abstract.py

@@ -0,0 +1,17 @@
+# Copyright Contributors to the Packit project.
+# SPDX-License-Identifier: MIT
+
+from typing import Optional
+
+from ..abstract.base import ForgeIndependent
+
+
+class ForgejoEvent(ForgeIndependent):
+    def __init__(self, project_url: str, pr_id: Optional[int] = None, **kwargs):
+        super().__init__(pr_id=pr_id)
+        self.project_url: str = project_url
+        # git ref that can be 'git checkout'-ed
+        self.git_ref: Optional[str] = None
+        self.identifier: Optional[str] = (
+            None  # will be shown to users -- e.g. in logs or in the copr-project name
+        )

packit_service/events/forgejo/issue.py

@@ -0,0 +1,92 @@
+# Copyright Contributors to the Packit project.
+# SPDX-License-Identifier: MIT
+
+# SPDX-License-Identifier: MIT
+
+from typing import Optional
+
+from ogr.abstract import Comment as OgrComment
+
+from ..abstract.comment import Issue as AbstractIssueCommentEvent
+from ..enums import IssueCommentAction
+from .abstract import ForgejoEvent
+
+
+class Comment(AbstractIssueCommentEvent, ForgejoEvent):
+    def __init__(
+        self,
+        action: IssueCommentAction,
+        issue_id: int,
+        repo_namespace: str,
+        repo_name: str,
+        target_repo: str,
+        project_url: str,
+        actor: str,
+        comment: str,
+        comment_id: int,
+        tag_name: str = "",
+        base_ref: Optional[str] = "main",
+        comment_object: Optional[OgrComment] = None,
+        dist_git_project_url=None,
+    ) -> None:
+        super().__init__(
+            issue_id=issue_id,
+            repo_namespace=repo_namespace,
+            repo_name=repo_name,
+            project_url=project_url,
+            comment=comment,
+            comment_id=comment_id,
+            tag_name=tag_name,
+            comment_object=comment_object,
+            dist_git_project_url=dist_git_project_url,
+        )
+        self.action = action
+        self.actor = actor
+        self.base_ref = base_ref
+        self.target_repo = target_repo
+        self.identifier = str(issue_id)
+
+    @classmethod
+    def event_type(cls) -> str:
+        return "forgejo.issue.Comment"
+
+    @property
+    def tag_name(self):
+        """
+        For Forgejo issue comments, return the tag_name passed in constructor
+        without making API calls to avoid authentication issues.
+        """
+        return self._tag_name
+
+    @tag_name.setter
+    def tag_name(self, value: str) -> None:
+        self._tag_name = value
+
+    @property
+    def commit_sha(self) -> Optional[str]:
+        """
+        For Forgejo issue comments, return the commit_sha passed in constructor
+        without making API calls to avoid authentication issues.
+        """
+        return self._commit_sha
+
+    @commit_sha.setter
+    def commit_sha(self, value: Optional[str]) -> None:
+        self._commit_sha = value
+
+    def get_dict(self, default_dict: Optional[dict] = None) -> dict:
+        """
+        Override get_dict to avoid accessing properties that make API calls.
+        """
+        # Get the basic dict from CommentEvent, not from Issue to avoid tag_name access
+        from ..abstract.comment import CommentEvent
+
+        result = CommentEvent.get_dict(self, default_dict=default_dict)
+
+        # Add the specific fields we need without triggering API calls
+        result["action"] = self.action.value
+        result["issue_id"] = self.issue_id
+        result["tag_name"] = self._tag_name  # Use the private attribute directly
+        result["commit_sha"] = self._commit_sha  # Use the private attribute directly
+
+        return result

packit_service/events/forgejo/pr.py

@@ -0,0 +1,121 @@
+# Copyright Contributors to the Packit project.
+# SPDX-License-Identifier: MIT
+
+from typing import Optional
+
+from ogr.abstract import Comment as OgrComment
+from ogr.abstract import GitProject
+
+from packit_service.service.db_project_events import AddPullRequestEventToDb
+
+from ..abstract.comment import PullRequest as AbstractPRCommentEvent
+from ..enums import PullRequestAction, PullRequestCommentAction
+from .abstract import ForgejoEvent
+
+
+class Action(AddPullRequestEventToDb, ForgejoEvent):
+    def __init__(
+        self,
+        action: PullRequestAction,
+        pr_id: int,
+        base_repo_namespace: str,
+        base_repo_name: str,
+        base_ref: str,
+        target_repo_namespace: str,
+        target_repo_name: str,
+        project_url: str,
+        commit_sha: str,
+        commit_sha_before: str,
+        actor: str,
+        body: str,
+    ):
+        super().__init__(project_url=project_url, pr_id=pr_id)
+        self.action = action
+        self.base_repo_namespace = base_repo_namespace
+        self.base_repo_name = base_repo_name
+        self.base_ref = base_ref
+        self.target_repo_namespace = target_repo_namespace
+        self.target_repo_name = target_repo_name
+        self.commit_sha = commit_sha
+        self.commit_sha_before = commit_sha_before
+        self.actor = actor
+        self.identifier = str(pr_id)
+        self._pr_id = pr_id
+        self.git_ref = None  # use pr_id for checkout
+        self.body = body
+
+    def get_dict(self, default_dict: Optional[dict] = None) -> dict:
+        result = super().get_dict()
+        result["action"] = result["action"].value
+        return result
+
+    @classmethod
+    def event_type(cls) -> str:
+        return "forgejo.pr.Action"
+
+    def get_base_project(self) -> GitProject:
+        return self.project.service.get_project(
+            namespace=self.target_repo_namespace,
+            repo=self.target_repo_name,
+        )
+
+
+class Comment(AbstractPRCommentEvent, ForgejoEvent):
+    def __init__(
+        self,
+        action: PullRequestCommentAction,
+        pr_id: int,
+        base_repo_namespace: str,
+        base_repo_name: Optional[str],
+        base_ref: Optional[str],
+        target_repo_namespace: str,
+        target_repo_name: str,
+        project_url: str,
+        actor: str,
+        comment: str,
+        comment_id: int,
+        commit_sha: Optional[str] = None,
+        comment_object: Optional[OgrComment] = None,
+    ) -> None:
+        super().__init__(
+            pr_id=pr_id,
+            project_url=project_url,
+            comment=comment,
+            comment_id=comment_id,
+            commit_sha=commit_sha,
+            comment_object=comment_object,
+        )
+        self.action = action
+        self.base_repo_namespace = base_repo_namespace
+        self.base_repo_name = base_repo_name
+        self.base_ref = base_ref
+        self.target_repo_namespace = target_repo_namespace
+        self.target_repo_name = target_repo_name
+        self.actor = actor
+        self.identifier = str(pr_id)
+        self.git_ref = None
+        self.pr_id = pr_id
+
+    @classmethod
+    def event_type(cls) -> str:
+        return "forgejo.pr.Comment"
+
+    def get_dict(self, default_dict: Optional[dict] = None) -> dict:
+        """
+        Override get_dict to avoid accessing properties that make API calls.
+        Use private attributes directly, similar to forgejo/issue.py.
+        """
+        from ..abstract.comment import CommentEvent
+
+        result = CommentEvent.get_dict(self, default_dict=default_dict)
+        result.pop("_comment_object")
+        result["action"] = self.action.value
+        result["pr_id"] = self.pr_id
+        result["commit_sha"] = self._commit_sha
+        return result
+
+    def get_base_project(self) -> GitProject:
+        return self.project.service.get_project(
+            namespace=self.target_repo_namespace,
+            repo=self.target_repo_name,
+        )

packit_service/events/forgejo/push.py

@@ -0,0 +1,29 @@
+# Copyright Contributors to the Packit project.
+# SPDX-License-Identifier: MIT
+
+from packit_service.service.db_project_events import AddBranchPushEventToDb
+
+from .abstract import ForgejoEvent
+
+
+class Commit(AddBranchPushEventToDb, ForgejoEvent):
+    def __init__(
+        self,
+        repo_namespace: str,
+        repo_name: str,
+        git_ref: str,
+        project_url: str,
+        commit_sha: str,
+        commit_sha_before: str,
+    ):
+        super().__init__(project_url=project_url)
+        self.repo_namespace = repo_namespace
+        self.repo_name = repo_name
+        self.git_ref = git_ref
+        self.commit_sha = commit_sha
+        self.commit_sha_before = commit_sha_before
+        self.identifier = git_ref
+
+    @classmethod
+    def event_type(cls) -> str:
+        return "forgejo.push.Commit"