# -*- coding: utf-8 -*-

"""

    rhodecode.model.changeset_status

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    :created_on: Apr 30, 2012

    :author: marcink

    :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from collections import  defaultdict

from rhodecode.model import BaseModel

from rhodecode.model.db import ChangesetStatus, PullRequest

log = logging.getLogger(__name__)

class ChangesetStatusModel(BaseModel):

    def __get_changeset_status(self, changeset_status):

        return self._get_instance(ChangesetStatus, changeset_status)

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def _get_status_query(self, repo, revision, pull_request,

                          with_revisions=False):

        repo = self._get_repo(repo)

        q = ChangesetStatus.query()\

            .filter(ChangesetStatus.repo == repo)

        if not with_revisions:

            q = q.filter(ChangesetStatus.version == 0)

        if revision:

            q = q.filter(ChangesetStatus.revision == revision)

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            q = q.filter(ChangesetStatus.pull_request == pull_request)

        else:

            raise Exception('Please specify revision or pull_request')

        q.order_by(ChangesetStatus.version.asc())

        return q

    def calculate_status(self, statuses_by_reviewers):

        """

        leading one wins, if number of occurences are equal than weaker wins

        :param statuses_by_reviewers:

        """

        status = None

        votes = defaultdict(int)

        reviewers_number = len(statuses_by_reviewers)

        for user, statuses in statuses_by_reviewers:

            if statuses:

                ver, latest = statuses[0]

                votes[latest.status] += 1

            else:

                votes[ChangesetStatus.DEFAULT] += 1

        if votes.get(ChangesetStatus.STATUS_APPROVED) == reviewers_number:

            return ChangesetStatus.STATUS_APPROVED

        else:

            return ChangesetStatus.STATUS_UNDER_REVIEW

    def get_statuses(self, repo, revision=None, pull_request=None,

                     with_revisions=False):

        q = self._get_status_query(repo, revision, pull_request,

                                   with_revisions)

        return q.all()

    def get_status(self, repo, revision=None, pull_request=None):

        """

        Returns latest status of changeset for given revision or for given

        pull request. Statuses are versioned inside a table itself and

        version == 0 is always the current one

        :param repo:

        :type repo:

        :param revision: 40char hash or None

        :type revision: str

        :param pull_request: pull_request reference

        :type:

        """

        q = self._get_status_query(repo, revision, pull_request)

        # need to use first here since there can be multiple statuses

        # returned from pull_request

        status = q.first()

        status = status.status if status else status

        st = status or ChangesetStatus.DEFAULT

        return str(st)

    def set_status(self, repo, status, user, comment, revision=None,

                   pull_request=None):

        """

        Creates new status for changeset or updates the old ones bumping their

        version, leaving the current status at

        :param repo:

        :type repo:

        :param revision:

        :type revision:

        :param status:

        :type status:

        :param user:

        :type user:

        :param comment:

        :type comment:

        """

        repo = self._get_repo(repo)

        q = ChangesetStatus.query()

        if revision:

            q = q.filter(ChangesetStatus.repo == repo)

            q = q.filter(ChangesetStatus.revision == revision)

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            q = q.filter(ChangesetStatus.repo == pull_request.org_repo)

            q = q.filter(ChangesetStatus.pull_request == pull_request)

        cur_statuses = q.all()

        if cur_statuses:

            for st in cur_statuses:

                st.version += 1

                self.sa.add(st)

        def _create_status(user, repo, status, comment, revision, pull_request):

            new_status = ChangesetStatus()

            new_status.author = self._get_user(user)

            new_status.repo = self._get_repo(repo)

            new_status.status = status

            new_status.comment = comment

            new_status.revision = revision

            new_status.pull_request = pull_request

            return new_status

        if revision:

            new_status = _create_status(user=user, repo=repo, status=status,

                           comment=comment, revision=revision,

                           pull_request=None)

            self.sa.add(new_status)

            return new_status

        elif pull_request:

            #pull request can have more than one revision associated to it

            #we need to create new version for each one

            new_statuses = []

            repo = pull_request.org_repo

            for rev in pull_request.revisions:

                new_status = _create_status(user=user, repo=repo,

                                            status=status, comment=comment,

                                            revision=rev,

                                            pull_request=pull_request)

                new_statuses.append(new_status)

                self.sa.add(new_status)

            return new_statuses

# -*- coding: utf-8 -*-

"""

    rhodecode.model.comment

    ~~~~~~~~~~~~~~~~~~~~~~~

    comments model for RhodeCode

    :created_on: Nov 11, 2011

    :author: marcink

    :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

from pylons.i18n.translation import _

from sqlalchemy.util.compat import defaultdict

from rhodecode.lib.utils2 import extract_mentioned_users, safe_unicode

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import ChangesetComment, User, Repository, \

    Notification, PullRequest

from rhodecode.model.notification import NotificationModel

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    def __get_changeset_comment(self, changeset_comment):

        return self._get_instance(ChangesetComment, changeset_comment)

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def _extract_mentions(self, s):

        user_objects = []

        for username in extract_mentioned_users(s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

                user_objects.append(user_obj)

        return user_objects

    def create(self, text, repo_id, user_id, revision=None, pull_request=None,

               f_path=None, line_no=None, status_change=None):

        """

        Creates new comment for changeset or pull request.

        IF status_change is not none this comment is associated with a

        status change of changeset or changesets associated with pull request

        :param text:

        :param repo_id:

        :param user_id:

        :param revision:

        :param pull_request:

        :param f_path:

        :param line_no:

        :param status_change:

        """

        if not text:

            return

        repo = Repository.get(repo_id)

        comment = ChangesetComment()

        comment.repo = repo

        comment.user_id = user_id

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision:

            cs = repo.scm_instance.get_changeset(revision)

            desc = "%s - %s" % (cs.short_id, h.shorter(cs.message, 256))

            author_email = cs.author_email

            comment.revision = revision

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            comment.pull_request = pull_request

            desc = ''

        else:

            raise Exception('Please specify revision or pull_request_id')

        self.sa.add(comment)

        self.sa.flush()

        # make notification

        line = ''

        body = text

        #changeset

        if revision:

            if line_no:

                line = _('on line %s') % line_no

            subj = safe_unicode(

                h.link_to('Re commit: %(commit_desc)s %(line)s' % \

                          {'commit_desc': desc, 'line': line},

                          h.url('changeset_home', repo_name=repo.repo_name,

                                revision=revision,

                                anchor='comment-%s' % comment.comment_id,

                                qualified=True,

                          )

                )

            )

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's in rhodecode system

            recipients += [User.get_by_email(author_email)]

        #pull request

        elif pull_request:

            #TODO: make this something usefull

            subj = 'commented on pull request something...'

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            # get the current participants of this pull request

            recipients = ChangesetComment.get_users(pull_request_id=

                                                pull_request.pull_request_id)

            # add pull request author

            recipients += [pull_request.author]

        # create notification objects, and emails

        NotificationModel().create(

          created_by=user_id, subject=subj, body=body,

          recipients=recipients, type_=notification_type,

          email_kwargs={'status_change': status_change}

        )

        mention_recipients = set(self._extract_mentions(body))\

                                .difference(recipients)

        if mention_recipients:

            subj = _('[Mention]') + ' ' + subj

            NotificationModel().create(

                created_by=user_id, subject=subj, body=body,

                recipients=mention_recipients,

                type_=notification_type,

                email_kwargs={'status_change': status_change}

            )

        return comment

    def delete(self, comment):

        """

        Deletes given comment

        :param comment_id:

        """

        comment = self.__get_changeset_comment(comment)

        self.sa.delete(comment)

        return comment

    def get_comments(self, repo_id, revision=None, pull_request=None):

        """

        Get's main comments based on revision or pull_request_id

        :param repo_id:

        :type repo_id:

        :param revision:

        :type revision:

        :param pull_request:

        :type pull_request:

        """

        q = ChangesetComment.query()\

                .filter(ChangesetComment.repo_id == repo_id)\

                .filter(ChangesetComment.line_no == None)\

                .filter(ChangesetComment.f_path == None)

        if revision:

            q = q.filter(ChangesetComment.revision == revision)

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            q = q.filter(ChangesetComment.pull_request == pull_request)

        else:

            raise Exception('Please specify revision or pull_request')

        return q.all()

    def get_inline_comments(self, repo_id, revision=None, pull_request=None):

        q = self.sa.query(ChangesetComment)\

            .filter(ChangesetComment.repo_id == repo_id)\

            .filter(ChangesetComment.line_no != None)\

            .filter(ChangesetComment.f_path != None)\

            .order_by(ChangesetComment.comment_id.asc())\

        if revision:

            q = q.filter(ChangesetComment.revision == revision)

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            q = q.filter(ChangesetComment.pull_request == pull_request)

        else:

            raise Exception('Please specify revision or pull_request_id')

        comments = q.all()

        paths = defaultdict(lambda: defaultdict(list))

        for co in comments:

            paths[co.f_path][co.line_no].append(co)

        return paths.items()

# -*- coding: utf-8 -*-

"""

    rhodecode.model.notification

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Model for notifications

    :created_on: Nov 20, 2011

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import logging

import traceback

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, (int, long)):

            return Notification.get(notification)

        else:

            if notification:

                raise Exception('notification must be int, long or Instance'

                                ' of Notification got %s' % type(notification))

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

               email_kwargs={}):

        """

        Creates notification of given type

        :param created_by: int, str or User instance. User who created this

            notification

        :param subject:

        :param body:

        :param recipients: list of int, str or User objects, when None

            is given send to all admins

        :param type_: type of notification

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        from rhodecode.lib.celerylib import tasks, run_task

        if recipients and not getattr(recipients, '__iter__', False):

            raise Exception('recipients must be a list of iterable')

        created_by_obj = self._get_user(created_by)

        if recipients:

            recipients_objs = []

            for u in recipients:

                obj = self._get_user(u)

                if obj:

                    recipients_objs.append(obj)

            recipients_objs = set(recipients_objs)

            log.debug('sending notifications %s to %s' % (

                type_, recipients_objs)

            )

        else:

            # empty recipients means to all admins

            recipients_objs = User.query().filter(User.admin == True).all()

            log.debug('sending notifications %s to admins: %s' % (

                type_, recipients_objs)

            )

        notif = Notification.create(

            created_by=created_by_obj, subject=subject,

            body=body, recipients=recipients_objs, type_=type_

        )

        if with_email is False:

            return notif

        #don't send email to person who created this comment

        rec_objs = set(recipients_objs).difference(set([created_by_obj]))

        # send email with notification to all other participants

        for rec in rec_objs:

            email_subject = NotificationModel().make_description(notif, False)

            type_ = type_

            email_body = body

            ## this is passed into template

            kwargs = {'subject': subject, 'body': h.rst_w_mentions(body)}

            kwargs.update(email_kwargs)

            email_body_html = EmailNotificationModel()\

                                .get_email_tmpl(type_, **kwargs)

            run_task(tasks.send_email, rec.email, email_subject, email_body,

                     email_body_html)

        return notif

    def delete(self, user, notification):

        # we don't want to remove actual notification just the assignment

        try:

            notification = self.__get_notification(notification)

            user = self._get_user(user)

            if notification and user:

                obj = UserNotification.query()\

                        .filter(UserNotification.user == user)\

                        .filter(UserNotification.notification

                                == notification)\

                        .one()

                self.sa.delete(obj)

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

    def get_for_user(self, user, filter_=None):

        """

        Get mentions for given user, filter them if filter dict is given

        :param user:

        :type user:

        :param filter:

        """

        user = self._get_user(user)

        q = UserNotification.query()\

            .filter(UserNotification.user == user)\

            .join((Notification, UserNotification.notification_id ==

                                 Notification.notification_id))

        if filter_:

            q = q.filter(Notification.type_.in_(filter_))

        return q.all()

    def mark_all_read_for_user(self, user, filter_=None):

        user = self._get_user(user)

        q = UserNotification.query()\

            .filter(UserNotification.user == user)\

            .filter(UserNotification.read == False)\

            .join((Notification, UserNotification.notification_id ==

                                 Notification.notification_id))

        if filter_:

            q = q.filter(Notification.type_.in_(filter_))

        # this is a little inefficient but sqlalchemy doesn't support

        # update on joined tables :(

        for obj in q.all():

            obj.read = True

            self.sa.add(obj)

    def get_unread_cnt_for_user(self, user):

        user = self._get_user(user)

        return UserNotification.query()\

                .filter(UserNotification.read == False)\

                .filter(UserNotification.user == user).count()

    def get_unread_for_user(self, user):

        user = self._get_user(user)

        return [x.notification for x in UserNotification.query()\

                .filter(UserNotification.read == False)\

                .filter(UserNotification.user == user).all()]

    def get_user_notification(self, user, notification):

        user = self._get_user(user)

        notification = self.__get_notification(notification)

        return UserNotification.query()\

            .filter(UserNotification.notification == notification)\

            .filter(UserNotification.user == user).scalar()

    def make_description(self, notification, show_age=True):

        """

        Creates a human readable description based on properties

        of notification object

        """

        #alias

        _n = notification

        _map = {

            _n.TYPE_CHANGESET_COMMENT: _('commented on commit'),

            _n.TYPE_MESSAGE: _('sent message'),

            _n.TYPE_MENTION: _('mentioned you'),

            _n.TYPE_REGISTRATION: _('registered in RhodeCode'),

            _n.TYPE_PULL_REQUEST: _('opened new pull request'),

            _n.TYPE_PULL_REQUEST_COMMENT: _('commented on pull request')

        }

        # action == _map string

        tmpl = "%(user)s %(action)s at %(when)s"

        if show_age:

            when = h.age(notification.created_on)

        else:

            when = h.fmt_date(notification.created_on)

        data = dict(

            user=notification.created_by_user.username,

            action=_map[notification.type_], when=when,

        )

        return tmpl % data

class EmailNotificationModel(BaseModel):

    TYPE_CHANGESET_COMMENT = Notification.TYPE_CHANGESET_COMMENT

    TYPE_PASSWORD_RESET = 'passoword_link'

    TYPE_REGISTRATION = Notification.TYPE_REGISTRATION

    TYPE_PULL_REQUEST = Notification.TYPE_PULL_REQUEST

    TYPE_DEFAULT = 'default'

    def __init__(self):

        self._template_root = rhodecode.CONFIG['pylons.paths']['templates'][0]

        self._tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup

# -*- coding: utf-8 -*-

"""

    rhodecode.model.permission

    ~~~~~~~~~~~~~~~~~~~~~~~~~~

    permissions model for RhodeCode

    :created_on: Aug 20, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

from sqlalchemy.exc import DatabaseError

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import BaseModel

from rhodecode.model.db import User, Permission, UserToPerm, UserRepoToPerm,\

    UserRepoGroupToPerm

log = logging.getLogger(__name__)

class PermissionModel(BaseModel):

    """

    Permissions model for RhodeCode

    """

    def get_permission(self, permission_id, cache=False):

        """

        Get's permissions by id

        :param permission_id: id of permission to get from database

        :param cache: use Cache for this query

        """

        perm = self.sa.query(Permission)

        if cache:

            perm = perm.options(FromCache("sql_cache_short",

                                          "get_permission_%s" % permission_id))

        return perm.get(permission_id)

    def get_permission_by_name(self, name, cache=False):

        """

        Get's permissions by given name

        :param name: name to fetch

        :param cache: Use cache for this query

        """

        perm = self.sa.query(Permission)\

            .filter(Permission.permission_name == name)

        if cache:

            perm = perm.options(FromCache("sql_cache_short",

                                          "get_permission_%s" % name))

        return perm.scalar()

    def update(self, form_result):

        perm_user = self.sa.query(User)\

                        .filter(User.username ==

                                form_result['perm_user_name']).scalar()

        u2p = self.sa.query(UserToPerm).filter(UserToPerm.user ==

                                               perm_user).all()

        if len(u2p) != 3:

            raise Exception('Defined: %s should be 3  permissions for default'

                            ' user. This should not happen please verify'

                            ' your database' % len(u2p))

        try:

            # stage 1 change defaults

            for p in u2p:

                if p.permission.permission_name.startswith('repository.'):

                    p.permission = self.get_permission_by_name(

                                       form_result['default_perm'])

                    self.sa.add(p)

                elif p.permission.permission_name.startswith('hg.register.'):

                    p.permission = self.get_permission_by_name(

                                       form_result['default_register'])

                    self.sa.add(p)

                elif p.permission.permission_name.startswith('hg.create.'):

                    p.permission = self.get_permission_by_name(

                                        form_result['default_create'])

                    self.sa.add(p)

            _def_name = form_result['default_perm'].split('repository.')[-1]

            #stage 2 update all default permissions for repos if checked

            if form_result['overwrite_default'] == True:

                _def = self.get_permission_by_name('repository.' + _def_name)

                # repos

                for r2p in self.sa.query(UserRepoToPerm)\

                               .filter(UserRepoToPerm.user == perm_user)\

                               .all():

                    r2p.permission = _def

                    self.sa.add(r2p)

                # groups

                _def = self.get_permission_by_name('group.' + _def_name)

                for g2p in self.sa.query(UserRepoGroupToPerm)\

                               .filter(UserRepoGroupToPerm.user == perm_user)\

                               .all():

                    g2p.permission = _def

                    self.sa.add(g2p)

            # stage 3 set anonymous access

            if perm_user.username == 'default':

                perm_user.active = bool(form_result['anonymous'])

                self.sa.add(perm_user)

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

# -*- coding: utf-8 -*-

"""

    rhodecode.model.pull_reuquest

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    pull request model for RhodeCode

    :created_on: Jun 6, 2012

    :author: marcink

    :copyright: (C) 2012-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import binascii

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.vcs.utils.hgcompat import discovery

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    def get_all(self, repo):

        repo = self._get_repo(repo)

        return PullRequest.query().filter(PullRequest.other_repo == repo).all()

    def create(self, created_by, org_repo, org_ref, other_repo,

               other_ref, revisions, reviewers, title, description=None):

        created_by_user = self._get_user(created_by)

        new = PullRequest()

        new.org_repo = self._get_repo(org_repo)

        new.org_ref = org_ref

        new.other_repo = self._get_repo(other_repo)

        new.other_ref = other_ref

        new.revisions = revisions

        new.title = title

        new.description = description

        new.author = created_by_user

        self.sa.add(new)

        #members

        for member in reviewers:

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, new)

            self.sa.add(reviewer)

        #notification to reviewers

        notif = NotificationModel()

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request #%(pr_id)s') % \

                {'user': created_by_user.username,

                 'pr_id': new.pull_request_id},

              h.url('pullrequest_show', repo_name=other_repo,

                    pull_request_id=new.pull_request_id,

                    qualified=True,

              )

            )

        )

        body = description

        notif.create(created_by=created_by, subject=subject, body=body,

                     recipients=reviewers,

                     type_=Notification.TYPE_PULL_REQUEST,)

        return new

    def _get_changesets(self, org_repo, org_ref, other_repo, other_ref,

                        discovery_data):

        """

        Returns a list of changesets that are incoming from org_repo@org_ref

        to other_repo@other_ref

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        :param tmp: