feat(events): added context into events so we can track additional context of calling it

rhodecode/events/__init__.py

@@ -1,88 +1,91 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
-from rhodecode.events.base import (
-    RhodeCodeIntegrationEvent,
-    RhodecodeEvent
-)
+from rhodecode.events.base import RhodeCodeIntegrationEvent, RhodecodeEvent
 
 from rhodecode.events.base import (  # pragma: no cover
-    FtsBuild
+    FtsBuild,
 )
 
 from rhodecode.events.user import (  # pragma: no cover
     UserPreCreate,
     UserPostCreate,
     UserPreUpdate,
     UserRegistered,
     UserPermissionsChange,
 )
 
 from rhodecode.events.repo import (  # pragma: no cover
     RepoEvent,
-    RepoCommitCommentEvent, RepoCommitCommentEditEvent,
-    RepoPreCreateEvent, RepoCreateEvent,
-    RepoPreDeleteEvent, RepoDeleteEvent,
-    RepoPrePushEvent,   RepoPushEvent,
-    RepoPrePullEvent,   RepoPullEvent,
+    RepoCommitCommentEvent,
+    RepoCommitCommentEditEvent,
+    RepoPreCreateEvent,
+    RepoCreateEvent,
+    RepoPreDeleteEvent,
+    RepoDeleteEvent,
+    RepoPrePushEvent,
+    RepoPushEvent,
+    RepoPrePullEvent,
+    RepoPullEvent,
 )
 
 from rhodecode.events.repo_group import (  # pragma: no cover
     RepoGroupEvent,
     RepoGroupCreateEvent,
     RepoGroupUpdateEvent,
     RepoGroupDeleteEvent,
 )
 
 from rhodecode.events.pullrequest import (  # pragma: no cover
     PullRequestEvent,
     PullRequestCreateEvent,
     PullRequestUpdateEvent,
     PullRequestCommentEvent,
     PullRequestCommentEditEvent,
     PullRequestReviewEvent,
     PullRequestMergeEvent,
     PullRequestCloseEvent,
 )
 
 
 log = logging.getLogger(__name__)
 
 
 def trigger(event, registry=None):
     """
     Helper method to send an event. This wraps the pyramid logic to send an
     event.
     """
     # For the first step we are using pyramids thread locals here. If the
     # event mechanism works out as a good solution we should think about
     # passing the registry as an argument to get rid of it.
     from pyramid.threadlocal import get_current_registry
 
     event_name = event.__class__
-    log.debug('event %s sent for execution', event_name)
+    log.debug("event %s sent for execution", event_name)
     registry = registry or get_current_registry()
     registry.notify(event)
-    log.debug('event %s triggered using registry %s', event_name, registry)
+    log.debug("event %s triggered using registry %s", event_name, registry)
 
     # Send the events to integrations directly
     from rhodecode.integrations import integrations_event_handler
+
     if isinstance(event, RhodeCodeIntegrationEvent):
         integrations_event_handler(event)

rhodecode/events/base.py

@@ -1,141 +1,140 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.pyramid_utils import get_current_request
 from rhodecode.lib.utils2 import AttributeDict
 
 
 # this is a user object to be used for events caused by the system (eg. shell)
-SYSTEM_USER = AttributeDict(dict(
-    username='__SYSTEM__',
-    user_id='__SYSTEM_ID__'
-))
+SYSTEM_USER = AttributeDict(dict(username="__SYSTEM__", user_id="__SYSTEM_ID__"))
 
 log = logging.getLogger(__name__)
 
 
 class RhodecodeEvent(object):
     """
     Base event class for all RhodeCode events
     """
+
     name = "RhodeCodeEvent"
-    no_url_set = '<no server_url available>'
+    no_url_set = "<no server_url available>"
 
-    def __init__(self, request=None, actor=None):
+    def __init__(self, request=None, actor=None, context=None):
         self._request = request
         self._actor = actor
+        self._context = context
         self.utc_timestamp = datetime.datetime.utcnow()
 
     def __repr__(self):
-        return '<{}:({})>'.format(self.__class__.__name__, self.name)
+        return f"<{self.__class__.__name__}:(name={self.name}, context={self._context})>"
 
     def get_request(self):
         if self._request:
             return self._request
         return get_current_request()
 
     @LazyProperty
     def request(self):
         return self.get_request()
 
     @property
     def auth_user(self):
         if not self.request:
             return
 
-        user = getattr(self.request, 'user', None)
+        user = getattr(self.request, "user", None)
         if user:
             return user
 
-        api_user = getattr(self.request, 'rpc_user', None)
+        api_user = getattr(self.request, "rpc_user", None)
         if api_user:
             return api_user
 
     @property
     def actor(self):
         from rhodecode.lib.auth import AuthUser
 
         # if an explicit actor is specified, use this
         if self._actor:
             return self._actor
 
         auth_user = self.auth_user
-        log.debug('Got integration actor: %s', auth_user)
+        log.debug("Got integration actor: %s", auth_user)
         if isinstance(auth_user, AuthUser):
             instance = auth_user.get_instance()
             # we can't find this DB user...
             if not instance:
-                return AttributeDict(dict(
+                return AttributeDict(
+                    dict(
                     username=auth_user.username,
                     user_id=auth_user.user_id,
-                ))
+                    )
+                )
         elif auth_user:
             return auth_user
         return SYSTEM_USER
 
     @property
     def actor_ip(self):
         auth_user = self.auth_user
         if auth_user:
             return auth_user.ip_addr
-        return '<no ip available>'
+        return "<no ip available>"
 
     @property
     def server_url(self):
         if self.request:
             try:
-                return self.request.route_url('home')
+                return self.request.route_url("home")
             except Exception:
-                log.exception('Failed to fetch URL for server')
+                log.exception("Failed to fetch URL for server")
                 return self.no_url_set
 
         return self.no_url_set
 
     def as_dict(self):
         data = {
-            'name': self.name,
-            'utc_timestamp': self.utc_timestamp,
-            'actor_ip': self.actor_ip,
-            'actor': {
-                'username': self.actor.username,
-                'user_id': self.actor.user_id
-            },
-            'server_url': self.server_url
+            "name": self.name,
+            "utc_timestamp": self.utc_timestamp,
+            "actor_ip": self.actor_ip,
+            "actor": {"username": self.actor.username, "user_id": self.actor.user_id},
+            "server_url": self.server_url,
         }
         return data
 
 
 class RhodeCodeIntegrationEvent(RhodecodeEvent):
     """
     Special subclass for Integration events
     """
-    description = ''
+
+    description = ""
 
 
 class FtsBuild(RhodecodeEvent):
     """
     This event will be triggered when FTS Build is triggered
     """
-    name = 'fts-build'
-    display_name = 'Start FTS Build'
 
+    name = "fts-build"
+    display_name = "Start FTS Build"

rhodecode/events/interfaces.py

@@ -1,43 +1,46 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from zope.interface import Attribute, Interface
 
 
 class IUserRegistered(Interface):
     """
     An event type that is emitted whenever a new user registers a user
     account.
     """
-    user = Attribute('The user object.')
-    session = Attribute('The session while processing the register form post.')
+
+    user = Attribute("The user object.")
+    session = Attribute("The session while processing the register form post.")
 
 
 class IUserPreCreate(Interface):
     """
     An event type that is emitted before a new user object is created.
     """
-    user_data = Attribute('Data used to create the new user')
+
+    user_data = Attribute("Data used to create the new user")
 
 
 class IUserPreUpdate(Interface):
     """
     An event type that is emitted before a user object is updated.
     """
-    user = Attribute('The not yet updated user object')
-    user_data = Attribute('Data used to update the user')
+
+    user = Attribute("The not yet updated user object")
+    user_data = Attribute("Data used to update the user")

rhodecode/events/pullrequest.py

@@ -1,206 +1,212 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 from rhodecode.translation import lazy_ugettext
-from rhodecode.events.repo import (RepoEvent, _commits_as_dict, _issues_as_dict)
+from rhodecode.events.repo import RepoEvent, _commits_as_dict, _issues_as_dict
 
 log = logging.getLogger(__name__)
 
 
 class PullRequestEvent(RepoEvent):
     """
     Base class for pull request events.
 
     :param pullrequest: a :class:`PullRequest` instance
     """
-    name = 'pullrequest-event'
-    display_name = lazy_ugettext('pullrequest generic event')
-    description = lazy_ugettext('All events within a context of a pull request')
+
+    name = "pullrequest-event"
+    display_name = lazy_ugettext("pullrequest generic event")
+    description = lazy_ugettext("All events within a context of a pull request")
 
-    def __init__(self, pullrequest):
-        super().__init__(pullrequest.target_repo)
+    def __init__(self, pullrequest, context=None):
+        super().__init__(pullrequest.target_repo, context=context)
         self.pullrequest = pullrequest
+        self.context = self._context
 
     def as_dict(self):
         from rhodecode.lib.utils2 import md5_safe
         from rhodecode.model.pull_request import PullRequestModel
+
         data = super().as_dict()
 
-        commits = _commits_as_dict(
-            self,
-            commit_ids=self.pullrequest.revisions,
-            repos=[self.pullrequest.source_repo]
-        )
+        commits = _commits_as_dict(self, commit_ids=self.pullrequest.revisions, repos=[self.pullrequest.source_repo])
         issues = _issues_as_dict(commits)
         # calculate hashes of all commits for unique identifier of commits
         # inside that pull request
-        commits_hash = md5_safe(':'.join(x.get('raw_id', '') for x in commits))
+        commits_hash = md5_safe(":".join(x.get("raw_id", "") for x in commits))
 
-        data.update({
-            'pullrequest': {
-                'title': self.pullrequest.title,
-                'issues': issues,
-                'pull_request_id': self.pullrequest.pull_request_id,
-                'url': PullRequestModel().get_url(
-                    self.pullrequest, request=self.request),
-                'permalink_url': PullRequestModel().get_url(
-                    self.pullrequest, request=self.request, permalink=True),
-                'shadow_url': PullRequestModel().get_shadow_clone_url(
-                    self.pullrequest, request=self.request),
-                'status': self.pullrequest.calculated_review_status(),
-                'commits_uid': commits_hash,
-                'commits': commits,
+        data.update(
+            {
+                "pullrequest": {
+                    "title": self.pullrequest.title,
+                    "issues": issues,
+                    "pull_request_id": self.pullrequest.pull_request_id,
+                    "url": PullRequestModel().get_url(self.pullrequest, request=self.request),
+                    "permalink_url": PullRequestModel().get_url(self.pullrequest, request=self.request, permalink=True),
+                    "shadow_url": PullRequestModel().get_shadow_clone_url(self.pullrequest, request=self.request),
+                    "status": self.pullrequest.calculated_review_status(),
+                    "commits_uid": commits_hash,
+                    "commits": commits,
+                },
+                "context": self.context,
             }
-        })
+        )
         return data
 
 
 class PullRequestCreateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is created.
     """
-    name = 'pullrequest-create'
-    display_name = lazy_ugettext('pullrequest created')
-    description = lazy_ugettext('Event triggered after pull request was created')
+
+    name = "pullrequest-create"
+    display_name = lazy_ugettext("pullrequest created")
+    description = lazy_ugettext("Event triggered after pull request was created")
 
 
 class PullRequestCloseEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is closed.
     """
-    name = 'pullrequest-close'
-    display_name = lazy_ugettext('pullrequest closed')
-    description = lazy_ugettext('Event triggered after pull request was closed')
+
+    name = "pullrequest-close"
+    display_name = lazy_ugettext("pullrequest closed")
+    description = lazy_ugettext("Event triggered after pull request was closed")
 
 
 class PullRequestUpdateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request's commits have been updated.
     """
-    name = 'pullrequest-update'
-    display_name = lazy_ugettext('pullrequest commits updated')
-    description = lazy_ugettext('Event triggered after pull requests was updated')
+
+    name = "pullrequest-update"
+    display_name = lazy_ugettext("pullrequest commits updated")
+    description = lazy_ugettext("Event triggered after pull requests was updated")
 
 
 class PullRequestReviewEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request review has changed. A status defines new status of review.
     """
-    name = 'pullrequest-review'
-    display_name = lazy_ugettext('pullrequest review changed')
-    description = lazy_ugettext('Event triggered after a review status of a '
-                                'pull requests has changed to other.')
 
-    def __init__(self, pullrequest, status):
-        super().__init__(pullrequest)
+    name = "pullrequest-review"
+    display_name = lazy_ugettext("pullrequest review changed")
+    description = lazy_ugettext("Event triggered after a review status of a pull requests has changed to other.")
+
+    def __init__(self, pullrequest, status, context=None):
+        super().__init__(pullrequest, context=context)
         self.status = status
 
 
 class PullRequestMergeEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is merged.
     """
-    name = 'pullrequest-merge'
-    display_name = lazy_ugettext('pullrequest merged')
-    description = lazy_ugettext('Event triggered after a successful merge operation '
-                                'was executed on a pull request')
+
+    name = "pullrequest-merge"
+    display_name = lazy_ugettext("pullrequest merged")
+    description = lazy_ugettext("Event triggered after a successful merge operation was executed on a pull request")
 
 
 class PullRequestCommentEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request comment is created.
     """
-    name = 'pullrequest-comment'
-    display_name = lazy_ugettext('pullrequest commented')
-    description = lazy_ugettext('Event triggered after a comment was made on a code '
-                                'in the pull request')
 
-    def __init__(self, pullrequest, comment):
-        super().__init__(pullrequest)
+    name = "pullrequest-comment"
+    display_name = lazy_ugettext("pullrequest commented")
+    description = lazy_ugettext("Event triggered after a comment was made on a code in the pull request")
+
+    def __init__(self, pullrequest, comment, context=None):
+        super().__init__(pullrequest, context=context)
         self.comment = comment
 
     def as_dict(self):
         from rhodecode.model.comment import CommentsModel
+
         data = super().as_dict()
 
         status = None
         if self.comment.status_change:
             status = self.comment.review_status
 
-        data.update({
-            'comment': {
-                'status': status,
-                'text': self.comment.text,
-                'type': self.comment.comment_type,
-                'file': self.comment.f_path,
-                'line': self.comment.line_no,
-                'version': self.comment.last_version,
-                'url': CommentsModel().get_url(
-                    self.comment, request=self.request),
-                'permalink_url': CommentsModel().get_url(
-                    self.comment, request=self.request, permalink=True),
+        data.update(
+            {
+                "comment": {
+                    "status": status,
+                    "text": self.comment.text,
+                    "type": self.comment.comment_type,
+                    "file": self.comment.f_path,
+                    "line": self.comment.line_no,
+                    "version": self.comment.last_version,
+                    "url": CommentsModel().get_url(self.comment, request=self.request),
+                    "permalink_url": CommentsModel().get_url(self.comment, request=self.request, permalink=True),
+                },
+                "context": self.context,
             }
-        })
+        )
         return data
 
 
 class PullRequestCommentEditEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request comment is edited.
     """
-    name = 'pullrequest-comment-edit'
-    display_name = lazy_ugettext('pullrequest comment edited')
-    description = lazy_ugettext('Event triggered after a comment was edited on a code '
-                                'in the pull request')
+
+    name = "pullrequest-comment-edit"
+    display_name = lazy_ugettext("pullrequest comment edited")
+    description = lazy_ugettext("Event triggered after a comment was edited on a code in the pull request")
 
     def __init__(self, pullrequest, comment):
         super().__init__(pullrequest)
         self.comment = comment
 
     def as_dict(self):
         from rhodecode.model.comment import CommentsModel
+
         data = super().as_dict()
 
         status = None
         if self.comment.status_change:
             status = self.comment.review_status
 
-        data.update({
-            'comment': {
-                'status': status,
-                'text': self.comment.text,
-                'type': self.comment.comment_type,
-                'file': self.comment.f_path,
-                'line': self.comment.line_no,
-                'version': self.comment.last_version,
-                'url': CommentsModel().get_url(
-                    self.comment, request=self.request),
-                'permalink_url': CommentsModel().get_url(
-                    self.comment, request=self.request, permalink=True),
+        data.update(
+            {
+                "comment": {
+                    "status": status,
+                    "text": self.comment.text,
+                    "type": self.comment.comment_type,
+                    "file": self.comment.f_path,
+                    "line": self.comment.line_no,
+                    "version": self.comment.last_version,
+                    "url": CommentsModel().get_url(self.comment, request=self.request),
+                    "permalink_url": CommentsModel().get_url(self.comment, request=self.request, permalink=True),
+                },
+                "context": self.context
             }
-        })
+        )
         return data

rhodecode/events/repo.py

@@ -1,444 +1,427 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import collections
 import logging
 import datetime
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.model.db import User, Repository
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
 
 def _commits_as_dict(event, commit_ids, repos):
     """
     Helper function to serialize commit_ids
 
     :param event: class calling this method
     :param commit_ids: commits to get
     :param repos: a list of repos to check
     """
     from rhodecode.lib.utils2 import extract_mentioned_users
-    from rhodecode.lib.helpers import (
-        urlify_commit_message, process_patterns, chop_at_smart)
+    from rhodecode.lib.helpers import urlify_commit_message, process_patterns, chop_at_smart
     from rhodecode.model.repo import RepoModel
 
     if not repos:
-        raise Exception('no repo defined')
+        raise Exception("no repo defined")
 
     if not isinstance(repos, (tuple, list)):
         repos = [repos]
 
     if not commit_ids:
         return []
 
     needed_commits = list(commit_ids)
 
     commits = []
     reviewers = []
     for repo in repos:
         if not needed_commits:
             return commits  # return early if we have the commits we need
 
         vcs_repo = repo.scm_instance(cache=False)
 
         try:
             # use copy of needed_commits since we modify it while iterating
             for commit_id in list(needed_commits):
-                if commit_id.startswith('tag=>'):
+                if commit_id.startswith("tag=>"):
                     raw_id = commit_id[5:]
                     cs_data = {
-                        'raw_id': commit_id, 'short_id': commit_id,
-                        'branch': None,
-                        'git_ref_change': 'tag_add',
-                        'message': f'Added new tag {raw_id}',
-                        'author': event.actor.full_contact,
-                        'date': datetime.datetime.now(),
-                        'refs': {
-                            'branches': [],
-                            'bookmarks': [],
-                            'tags': []
-                        }
+                        "raw_id": commit_id,
+                        "short_id": commit_id,
+                        "branch": None,
+                        "git_ref_change": "tag_add",
+                        "message": f"Added new tag {raw_id}",
+                        "author": event.actor.full_contact,
+                        "date": datetime.datetime.now(),
+                        "refs": {"branches": [], "bookmarks": [], "tags": []},
                     }
                     commits.append(cs_data)
 
-                elif commit_id.startswith('delete_branch=>'):
+                elif commit_id.startswith("delete_branch=>"):
                     raw_id = commit_id[15:]
                     cs_data = {
-                        'raw_id': commit_id, 'short_id': commit_id,
-                        'branch': None,
-                        'git_ref_change': 'branch_delete',
-                        'message': f'Deleted branch {raw_id}',
-                        'author': event.actor.full_contact,
-                        'date': datetime.datetime.now(),
-                        'refs': {
-                            'branches': [],
-                            'bookmarks': [],
-                            'tags': []
-                        }
+                        "raw_id": commit_id,
+                        "short_id": commit_id,
+                        "branch": None,
+                        "git_ref_change": "branch_delete",
+                        "message": f"Deleted branch {raw_id}",
+                        "author": event.actor.full_contact,
+                        "date": datetime.datetime.now(),
+                        "refs": {"branches": [], "bookmarks": [], "tags": []},
                     }
                     commits.append(cs_data)
 
                 else:
                     try:
                         cs = vcs_repo.get_commit(commit_id)
                     except CommitDoesNotExistError:
                         continue  # maybe its in next repo
 
                     cs_data = cs.__json__()
-                    cs_data['refs'] = cs._get_refs()
+                    cs_data["refs"] = cs._get_refs()
 
-                cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
-                cs_data['reviewers'] = reviewers
-                cs_data['url'] = RepoModel().get_commit_url(
-                    repo, cs_data['raw_id'], request=event.request)
-                cs_data['permalink_url'] = RepoModel().get_commit_url(
-                    repo, cs_data['raw_id'], request=event.request,
-                    permalink=True)
-                urlified_message, issues_data, errors = process_patterns(
-                    cs_data['message'], repo.repo_name)
-                cs_data['issues'] = issues_data
-                cs_data['message_html'] = urlify_commit_message(
-                    cs_data['message'], repo.repo_name)
-                cs_data['message_html_title'] = chop_at_smart(
-                    cs_data['message'], '\n', suffix_if_chopped='...')
+                cs_data["mentions"] = extract_mentioned_users(cs_data["message"])
+                cs_data["reviewers"] = reviewers
+                cs_data["url"] = RepoModel().get_commit_url(repo, cs_data["raw_id"], request=event.request)
+                cs_data["permalink_url"] = RepoModel().get_commit_url(
+                    repo, cs_data["raw_id"], request=event.request, permalink=True
+                )
+                urlified_message, issues_data, errors = process_patterns(cs_data["message"], repo.repo_name)
+                cs_data["issues"] = issues_data
+                cs_data["message_html"] = urlify_commit_message(cs_data["message"], repo.repo_name)
+                cs_data["message_html_title"] = chop_at_smart(cs_data["message"], "\n", suffix_if_chopped="...")
                 commits.append(cs_data)
 
                 needed_commits.remove(commit_id)
 
         except Exception:
-            log.exception('Failed to extract commits data')
+            log.exception("Failed to extract commits data")
             # we don't send any commits when crash happens, only full list
             # matters we short circuit then.
             return []
 
     # we failed to remove all needed_commits from all repositories
     if needed_commits:
-        raise ValueError(f'Unexpectedly not found {needed_commits} in all available repos {repos}')
+        raise ValueError(f"Unexpectedly not found {needed_commits} in all available repos {repos}")
 
-    missing_commits = set(commit_ids) - set(c['raw_id'] for c in commits)
+    missing_commits = set(commit_ids) - set(c["raw_id"] for c in commits)
     if missing_commits:
-        log.error('Inconsistent repository state. '
-                  'Missing commits: %s', ', '.join(missing_commits))
+        log.error("Inconsistent repository state. " "Missing commits: %s", ", ".join(missing_commits))
 
     return commits
 
 
 def _issues_as_dict(commits):
     """ Helper function to serialize issues from commits """
     issues = {}
     for commit in commits:
-        for issue in commit['issues']:
-            issues[issue['id']] = issue
+        for issue in commit["issues"]:
+            issues[issue["id"]] = issue
     return issues
 
 
 class RepoEvent(RhodeCodeIntegrationEvent):
     """
     Base class for events acting on a repository.
     """
 
-    def __init__(self, repo, actor=None):
+    def __init__(self, repo, actor=None, context=None):
         """
         :param repo: a :class:`Repository` instance
         """
-        super().__init__(actor=actor)
+        super().__init__(actor=actor, context=context)
         self.repo = repo
+        self.context = self._context
 
     def as_dict(self):
         from rhodecode.model.repo import RepoModel
+
         data = super().as_dict()
 
         extra_fields = collections.OrderedDict()
         for field in self.repo.extra_fields:
             extra_fields[field.field_key] = field.field_value
 
-        data.update({
-            'repo': {
-                'repo_id': self.repo.repo_id,
-                'repo_name': self.repo.repo_name,
-                'repo_type': self.repo.repo_type,
-                'url': RepoModel().get_url(
-                    self.repo, request=self.request),
-                'permalink_url': RepoModel().get_url(
-                    self.repo, request=self.request, permalink=True),
-                'extra_fields': extra_fields
+        data.update(
+            {
+                "repo": {
+                    "repo_id": self.repo.repo_id,
+                    "repo_name": self.repo.repo_name,
+                    "repo_type": self.repo.repo_type,
+                    "url": RepoModel().get_url(self.repo, request=self.request),
+                    "permalink_url": RepoModel().get_url(self.repo, request=self.request, permalink=True),
+                    "extra_fields": extra_fields,
+                },
+                "context": self.context,
             }
-        })
+        )
         return data
 
 
 class RepoCommitCommentEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` after a comment is made
     on repository commit.
     """
 
-    name = 'repo-commit-comment'
-    display_name = lazy_ugettext('repository commit comment')
-    description = lazy_ugettext('Event triggered after a comment was made '
-                                'on commit inside a repository')
+    name = "repo-commit-comment"
+    display_name = lazy_ugettext("repository commit comment")
+    description = lazy_ugettext("Event triggered after a comment was made on commit inside a repository")
 
-    def __init__(self, repo, commit, comment):
-        super().__init__(repo)
+    def __init__(self, repo, commit, comment, context=None):
+        super().__init__(repo, context=context)
         self.commit = commit
         self.comment = comment
 
     def as_dict(self):
         data = super().as_dict()
-        data['commit'] = {
-            'commit_id': self.commit.raw_id,
-            'commit_message': self.commit.message,
-            'commit_branch': self.commit.branch,
+        data["commit"] = {
+            "commit_id": self.commit.raw_id,
+            "commit_message": self.commit.message,
+            "commit_branch": self.commit.branch,
         }
 
-        data['comment'] = {
-            'comment_id': self.comment.comment_id,
-            'comment_text': self.comment.text,
-            'comment_type': self.comment.comment_type,
-            'comment_f_path': self.comment.f_path,
-            'comment_line_no': self.comment.line_no,
-            'comment_version': self.comment.last_version,
+        data["comment"] = {
+            "comment_id": self.comment.comment_id,
+            "comment_text": self.comment.text,
+            "comment_type": self.comment.comment_type,
+            "comment_f_path": self.comment.f_path,
+            "comment_line_no": self.comment.line_no,
+            "comment_version": self.comment.last_version,
         }
+        data["contex"] = self.context
         return data
 
 
 class RepoCommitCommentEditEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` after a comment is edited
     on repository commit.
     """
 
-    name = 'repo-commit-edit-comment'
-    display_name = lazy_ugettext('repository commit edit comment')
-    description = lazy_ugettext('Event triggered after a comment was edited '
-                                'on commit inside a repository')
+    name = "repo-commit-edit-comment"
+    display_name = lazy_ugettext("repository commit edit comment")
+    description = lazy_ugettext("Event triggered after a comment was edited on commit inside a repository")
 
-    def __init__(self, repo, commit, comment):
-        super().__init__(repo)
+    def __init__(self, repo, commit, comment, context=None):
+        super().__init__(repo, context=context)
         self.commit = commit
         self.comment = comment
 
     def as_dict(self):
         data = super().as_dict()
-        data['commit'] = {
-            'commit_id': self.commit.raw_id,
-            'commit_message': self.commit.message,
-            'commit_branch': self.commit.branch,
+        data["commit"] = {
+            "commit_id": self.commit.raw_id,
+            "commit_message": self.commit.message,
+            "commit_branch": self.commit.branch,
         }
 
-        data['comment'] = {
-            'comment_id': self.comment.comment_id,
-            'comment_text': self.comment.text,
-            'comment_type': self.comment.comment_type,
-            'comment_f_path': self.comment.f_path,
-            'comment_line_no': self.comment.line_no,
-            'comment_version': self.comment.last_version,
+        data["comment"] = {
+            "comment_id": self.comment.comment_id,
+            "comment_text": self.comment.text,
+            "comment_type": self.comment.comment_type,
+            "comment_f_path": self.comment.f_path,
+            "comment_line_no": self.comment.line_no,
+            "comment_version": self.comment.last_version,
         }
+        data["context"] = "context"
         return data
 
 
 class RepoPreCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` before a repo is
     created.
     """
-    name = 'repo-pre-create'
-    display_name = lazy_ugettext('repository pre create')
-    description = lazy_ugettext('Event triggered before repository is created')
+
+    name = "repo-pre-create"
+    display_name = lazy_ugettext("repository pre create")
+    description = lazy_ugettext("Event triggered before repository is created")
 
 
 class RepoCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
-    name = 'repo-create'
-    display_name = lazy_ugettext('repository created')
-    description = lazy_ugettext('Event triggered after repository was created')
+
+    name = "repo-create"
+    display_name = lazy_ugettext("repository created")
+    description = lazy_ugettext("Event triggered after repository was created")
 
 
 class RepoPreDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
-    name = 'repo-pre-delete'
-    display_name = lazy_ugettext('repository pre delete')
-    description = lazy_ugettext('Event triggered before a repository is deleted')
+
+    name = "repo-pre-delete"
+    display_name = lazy_ugettext("repository pre delete")
+    description = lazy_ugettext("Event triggered before a repository is deleted")
 
 
 class RepoDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
-    name = 'repo-delete'
-    display_name = lazy_ugettext('repository deleted')
-    description = lazy_ugettext('Event triggered after repository was deleted')
+
+    name = "repo-delete"
+    display_name = lazy_ugettext("repository deleted")
+    description = lazy_ugettext("Event triggered after repository was deleted")
 
 
 class RepoVCSEvent(RepoEvent):
     """
     Base class for events triggered by the VCS
     """
-    name = ''
-    display_name = 'generic_vcs_event'
 
-    def __init__(self, repo_name, extras):
+    name = ""
+    display_name = "generic_vcs_event"
+
+    def __init__(self, repo_name, extras, context=None):
         self.repo = Repository.get_by_repo_name(repo_name)
         if not self.repo:
-            raise Exception(f'repo by this name {repo_name} does not exist')
+            raise Exception(f"repo by this name {repo_name} does not exist")
         self.extras = extras
-        super().__init__(self.repo)
+        super().__init__(self.repo, context=context)
 
     @property
     def actor(self):
-        if self.extras.get('username'):
-            return User.get_by_username(self.extras['username'])
+        if self.extras.get("username"):
+            return User.get_by_username(self.extras["username"])
 
     @property
     def actor_ip(self):
-        if self.extras.get('ip'):
-            return self.extras['ip']
+        if self.extras.get("ip"):
+            return self.extras["ip"]
 
     @property
     def server_url(self):
-        if self.extras.get('server_url'):
-            return self.extras['server_url']
+        if self.extras.get("server_url"):
+            return self.extras["server_url"]
 
     @property
     def request(self):
-        return self.extras.get('request') or self.get_request()
+        return self.extras.get("request") or self.get_request()
 
 
 class RepoPrePullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pulled from a repo.
     """
-    name = 'repo-pre-pull'
-    display_name = lazy_ugettext('repository pre pull')
-    description = lazy_ugettext('Event triggered before repository code is pulled')
+
+    name = "repo-pre-pull"
+    display_name = lazy_ugettext("repository pre pull")
+    description = lazy_ugettext("Event triggered before repository code is pulled")
 
 
 class RepoPullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pulled from a repo.
     """
-    name = 'repo-pull'
-    display_name = lazy_ugettext('repository pull')
-    description = lazy_ugettext('Event triggered after repository code was pulled')
+
+    name = "repo-pull"
+    display_name = lazy_ugettext("repository pull")
+    description = lazy_ugettext("Event triggered after repository code was pulled")
 
 
 class RepoPrePushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pushed to a repo.
     """
-    name = 'repo-pre-push'
-    display_name = lazy_ugettext('repository pre push')
-    description = lazy_ugettext('Event triggered before the code is '
-                                'pushed to a repository')
+
+    name = "repo-pre-push"
+    display_name = lazy_ugettext("repository pre push")
+    description = lazy_ugettext("Event triggered before the code is pushed to a repository")
 
 
 class RepoPushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pushed to a repo.
 
     :param extras: (optional) dict of data from proxied VCS actions
     """
-    name = 'repo-push'
-    display_name = lazy_ugettext('repository push')
-    description = lazy_ugettext('Event triggered after the code was '
-                                'pushed to a repository')
 
-    def __init__(self, repo_name, pushed_commit_ids, extras):
-        super().__init__(repo_name, extras)
+    name = "repo-push"
+    display_name = lazy_ugettext("repository push")
+    description = lazy_ugettext("Event triggered after the code was pushed to a repository")
+
+    def __init__(self, repo_name, pushed_commit_ids, extras, context=None):
+        super().__init__(repo_name, extras, context=context)
         self.pushed_commit_ids = pushed_commit_ids
         self.new_refs = extras.new_refs
 
     def as_dict(self):
         data = super().as_dict()
 
         def branch_url(branch_name):
-            return '{}/changelog?branch={}'.format(
-                data['repo']['url'], branch_name)
+            return "{}/changelog?branch={}".format(data["repo"]["url"], branch_name)
 
         def tag_url(tag_name):
-            return '{}/files/{}/'.format(
-                data['repo']['url'], tag_name)
+            return "{}/files/{}/".format(data["repo"]["url"], tag_name)
 
-        commits = _commits_as_dict(
-            self, commit_ids=self.pushed_commit_ids, repos=[self.repo])
+        commits = _commits_as_dict(self, commit_ids=self.pushed_commit_ids, repos=[self.repo])
 
         last_branch = None
         for commit in reversed(commits):
-            commit['branch'] = commit['branch'] or last_branch
-            last_branch = commit['branch']
+            commit["branch"] = commit["branch"] or last_branch
+            last_branch = commit["branch"]
         issues = _issues_as_dict(commits)
 
         branches = set()
         tags = set()
         for commit in commits:
-            if commit['refs']['tags']:
-                for tag in commit['refs']['tags']:
+            if commit["refs"]["tags"]:
+                for tag in commit["refs"]["tags"]:
                     tags.add(tag)
-            if commit['branch']:
-                branches.add(commit['branch'])
+            if commit["branch"]:
+                branches.add(commit["branch"])
 
         # maybe we have branches in new_refs ?
         try:
-            branches = branches.union(set(self.new_refs['branches']))
+            branches = branches.union(set(self.new_refs["branches"]))
         except Exception:
             pass
 
-        branches = [
-            {
-                'name': branch,
-                'url': branch_url(branch)
-            }
-            for branch in branches
-        ]
+        branches = [{"name": branch, "url": branch_url(branch)} for branch in branches]
 
         # maybe we have branches in new_refs ?
         try:
-            tags = tags.union(set(self.new_refs['tags']))
+            tags = tags.union(set(self.new_refs["tags"]))
         except Exception:
             pass
 
-        tags = [
-            {
-                'name': tag,
-                'url': tag_url(tag)
-            }
-            for tag in tags
-        ]
+        tags = [{"name": tag, "url": tag_url(tag)} for tag in tags]
 
-        data['push'] = {
-            'commits': commits,
-            'issues': issues,
-            'branches': branches,
-            'tags': tags,
+        data["push"] = {
+            "commits": commits,
+            "issues": issues,
+            "branches": branches,
+            "tags": tags,
         }
         return data

rhodecode/events/repo_group.py

@@ -1,83 +1,90 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 
 
 log = logging.getLogger(__name__)
 
 
 class RepoGroupEvent(RhodeCodeIntegrationEvent):
     """
     Base class for events acting on a repository group.
 
-    :param repo: a :class:`RepositoryGroup` instance
+    :param repo_group: a :class:`RepositoryGroup` instance
     """
 
-    def __init__(self, repo_group):
-        super().__init__()
+    def __init__(self, repo_group, context=None):
+        super().__init__(context=context)
         self.repo_group = repo_group
+        self.context = self._context
 
     def as_dict(self):
         data = super().as_dict()
-        data.update({
-            'repo_group': {
-                'group_id': self.repo_group.group_id,
-                'group_name': self.repo_group.group_name,
-                'group_parent_id': self.repo_group.group_parent_id,
-                'group_description': self.repo_group.group_description,
-                'user_id': self.repo_group.user_id,
-                'created_by': self.repo_group.user.username,
-                'created_on': self.repo_group.created_on,
-                'enable_locking': self.repo_group.enable_locking,
+        data.update(
+            {
+                "repo_group": {
+                    "group_id": self.repo_group.group_id,
+                    "group_name": self.repo_group.group_name,
+                    "group_parent_id": self.repo_group.group_parent_id,
+                    "group_description": self.repo_group.group_description,
+                    "user_id": self.repo_group.user_id,
+                    "created_by": self.repo_group.user.username,
+                    "created_on": self.repo_group.created_on,
+                    "enable_locking": self.repo_group.enable_locking,
+                },
+                "context": self.context
             }
-        })
+        )
         return data
 
 
 class RepoGroupCreateEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is created.
     """
-    name = 'repo-group-create'
-    display_name = lazy_ugettext('repository group created')
-    description = lazy_ugettext('Event triggered after a repository group was created')
+
+    name = "repo-group-create"
+    display_name = lazy_ugettext("repository group created")
+    description = lazy_ugettext("Event triggered after a repository group was created")
 
 
 class RepoGroupDeleteEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is deleted.
     """
-    name = 'repo-group-delete'
-    display_name = lazy_ugettext('repository group deleted')
-    description = lazy_ugettext('Event triggered after a repository group was deleted')
+
+    name = "repo-group-delete"
+    display_name = lazy_ugettext("repository group deleted")
+    description = lazy_ugettext("Event triggered after a repository group was deleted")
 
 
 class RepoGroupUpdateEvent(RepoGroupEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a
     repository group is updated.
     """
-    name = 'repo-group-update'
-    display_name = lazy_ugettext('repository group update')
-    description = lazy_ugettext('Event triggered after a repository group was updated')
+
+    name = "repo-group-update"
+    display_name = lazy_ugettext("repository group update")
+    description = lazy_ugettext("Event triggered after a repository group was updated")

rhodecode/events/user.py

@@ -1,104 +1,109 b''
 # Copyright (C) 2016-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 import logging
 
 from zope.interface import implementer
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.events.base import RhodecodeEvent, RhodeCodeIntegrationEvent
-from rhodecode.events.interfaces import (
-    IUserRegistered, IUserPreCreate, IUserPreUpdate)
+from rhodecode.events.interfaces import IUserRegistered, IUserPreCreate, IUserPreUpdate
 
 log = logging.getLogger(__name__)
 
 
 @implementer(IUserRegistered)
 class UserRegistered(RhodeCodeIntegrationEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a user
     account is registered.
     """
-    name = 'user-register'
-    display_name = lazy_ugettext('user registered')
+
+    name = "user-register"
+    display_name = lazy_ugettext("user registered")
 
     def __init__(self, user, session):
         super().__init__()
         self.user = user
         self.session = session
 
 
 @implementer(IUserPreCreate)
 class UserPreCreate(RhodeCodeIntegrationEvent):
     """
     An instance of this class is emitted as an :term:`event` before a new user
     object is created.
     """
-    name = 'user-pre-create'
-    display_name = lazy_ugettext('user pre create')
+
+    name = "user-pre-create"
+    display_name = lazy_ugettext("user pre create")
 
     def __init__(self, user_data):
         super().__init__()
         self.user_data = user_data
 
 
 @implementer(IUserPreCreate)
 class UserPostCreate(RhodeCodeIntegrationEvent):
     """
     An instance of this class is emitted as an :term:`event` after a new user
     object is created.
     """
-    name = 'user-post-create'
-    display_name = lazy_ugettext('user post create')
+
+    name = "user-post-create"
+    display_name = lazy_ugettext("user post create")
 
     def __init__(self, user_data):
         super().__init__()
         self.user_data = user_data
 
 
 @implementer(IUserPreUpdate)
 class UserPreUpdate(RhodeCodeIntegrationEvent):
     """
     An instance of this class is emitted as an :term:`event` before a user
     object is updated.
     """
-    name = 'user-pre-update'
-    display_name = lazy_ugettext('user pre update')
+
+    name = "user-pre-update"
+    display_name = lazy_ugettext("user pre update")
 
     def __init__(self, user, user_data):
         super().__init__()
         self.user = user
         self.user_data = user_data
 
 
 class UserPermissionsChange(RhodecodeEvent):
     """
-    This event should be triggered on an event that permissions of user might changed.
-    Currently this should be triggered on:
+    This event should be triggered on an event that permissions of user might be changed.
+    Currently, this should be triggered on:
 
       - user added/removed from user group
       - repo permissions changed
       - repo group permissions changed
       - user group permissions changed
 
     """
-    name = 'user-permissions-change'
-    display_name = lazy_ugettext('user permissions change')
+
+    name = "user-permissions-change"
+    display_name = lazy_ugettext("user permissions change")
 
-    def __init__(self, user_ids):
-        super().__init__()
+    def __init__(self, user_ids, context=None):
+        super().__init__(context=context)
         self.user_ids = user_ids
+        self.context = self._context