events: fixed missing construcors on user based events.

rhodecode/events/repo.py

@@ -1,263 +1,265 b''
 # Copyright (C) 2016-2017 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.model.db import User, Repository, Session
 from rhodecode.events.base import RhodecodeEvent
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
+
 def _commits_as_dict(commit_ids, repos):
     """
     Helper function to serialize commit_ids
 
     :param commit_ids: commits to get
     :param repos: list of repos to check
     """
     from rhodecode.lib.utils2 import extract_mentioned_users
     from rhodecode.model.db import Repository
     from rhodecode.lib import helpers as h
     from rhodecode.lib.helpers import process_patterns
     from rhodecode.lib.helpers import urlify_commit_message
 
     if not repos:
         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):
                 try:
                     cs = vcs_repo.get_changeset(commit_id)
                 except CommitDoesNotExistError:
                     continue # maybe its in next repo
 
                 cs_data = cs.__json__()
                 cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
                 cs_data['reviewers'] = reviewers
                 cs_data['url'] = h.url('changeset_home',
                     repo_name=repo.repo_name,
                     revision=cs_data['raw_id'],
                     qualified=True
                 )
                 urlified_message, issues_data = 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)
                 commits.append(cs_data)
 
                 needed_commits.remove(commit_id)
 
         except Exception as e:
             log.exception(e)
             # we don't send any commits when crash happens, only full list matters
             # we short circuit then.
             return []
 
     missing_commits = set(commit_ids) - set(c['raw_id'] for c in commits)
     if missing_commits:
         log.error('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
     return issues
 
+
 class RepoEvent(RhodecodeEvent):
     """
     Base class for events acting on a repository.
 
     :param repo: a :class:`Repository` instance
     """
 
     def __init__(self, repo):
         super(RepoEvent, self).__init__()
         self.repo = repo
 
     def as_dict(self):
         from rhodecode.model.repo import RepoModel
         data = super(RepoEvent, self).as_dict()
         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)
             }
         })
         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')
 
 
 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')
 
 
 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')
 
 
 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')
 
 
 class RepoVCSEvent(RepoEvent):
     """
     Base class for events triggered by the VCS
     """
     def __init__(self, repo_name, extras):
         self.repo = Repository.get_by_repo_name(repo_name)
         if not self.repo:
             raise Exception('repo by this name %s does not exist' % repo_name)
         self.extras = extras
         super(RepoVCSEvent, self).__init__(self.repo)
 
     @property
     def actor(self):
         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']
 
     @property
     def server_url(self):
         if self.extras.get('server_url'):
             return self.extras['server_url']
 
 
 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')
 
 
 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')
 
 
 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')
 
 
 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')
 
     def __init__(self, repo_name, pushed_commit_ids, extras):
         super(RepoPushEvent, self).__init__(repo_name, extras)
         self.pushed_commit_ids = pushed_commit_ids
 
     def as_dict(self):
         data = super(RepoPushEvent, self).as_dict()
         branch_url = repo_url = data['repo']['url']
 
         commits = _commits_as_dict(
             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']
         issues = _issues_as_dict(commits)
 
         branches = set(
             commit['branch'] for commit in commits if commit['branch'])
         branches = [
             {
                 'name': branch,
                 'url': '{}/changelog?branch={}'.format(
                     data['repo']['url'], branch)
             }
             for branch in branches
         ]
 
         data['push'] = {
             'commits': commits,
             'issues': issues,
             'branches': branches,
         }
         return data

rhodecode/events/user.py

@@ -1,78 +1,82 b''
 # Copyright (C) 2016-2017 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 implementer
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.events.base import RhodecodeEvent
 from rhodecode.events.interfaces import (
     IUserRegistered, IUserPreCreate, IUserPreUpdate)
 
 
 @implementer(IUserRegistered)
 class UserRegistered(RhodecodeEvent):
     """
     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')
 
     def __init__(self, user, session):
+        super(UserRegistered, self).__init__()
         self.user = user
         self.session = session
 
 
 @implementer(IUserPreCreate)
 class UserPreCreate(RhodecodeEvent):
     """
     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')
 
     def __init__(self, user_data):
+        super(UserPreCreate, self).__init__()
         self.user_data = user_data
 
 
 @implementer(IUserPreCreate)
 class UserPostCreate(RhodecodeEvent):
     """
     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')
 
     def __init__(self, user_data):
+        super(UserPostCreate, self).__init__()
         self.user_data = user_data
 
 
 @implementer(IUserPreUpdate)
 class UserPreUpdate(RhodecodeEvent):
     """
     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')
 
     def __init__(self, user, user_data):
+        super(UserPreUpdate, self).__init__()
         self.user = user
         self.user_data = user_data