c.cs_repos = [(org_repo.repo_name, org_repo.repo_name)]

        c.default_cs_repo = org_repo.repo_name

        c.cs_refs, c.default_cs_ref = self._get_repo_refs(org_scm_instance, rev=org_rev, branch=branch)

        default_cs_ref_type, default_cs_branch, default_cs_rev = c.default_cs_ref.split(':')

        if default_cs_ref_type != 'branch':

            default_cs_branch = org_repo.get_changeset(default_cs_rev).branch

        # add org repo to other so we can open pull request against peer branches on itself

        c.a_repos = [(org_repo.repo_name, '%s (self)' % org_repo.repo_name)]

        if org_repo.parent:

            # add parent of this fork also and select it.

            # use the same branch on destination as on source, if available.

            c.a_repos.append((org_repo.parent.repo_name, '%s (parent)' % org_repo.parent.repo_name))

            c.a_repo = org_repo.parent

            c.a_refs, c.default_a_ref = self._get_repo_refs(

                    org_repo.parent.scm_instance, branch=default_cs_branch, rev=other_rev)

        else:

            c.a_repo = org_repo

            c.a_refs, c.default_a_ref = self._get_repo_refs(org_scm_instance, rev=other_rev)

        # gather forks and add to this list ... even though it is rare to

        # request forks to pull from their parent

        for fork in org_repo.forks:

            c.a_repos.append((fork.repo_name, fork.repo_name))

        return render('/pullrequests/pullrequest.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def repo_info(self, repo_name):

        repo = c.db_repo

        refs, selected_ref = self._get_repo_refs(repo.scm_instance)

        return {

            'description': repo.description.split('\n', 1)[0],

            'selected_ref': selected_ref,

            'refs': refs,

            }

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def create(self, repo_name):

        repo = c.db_repo

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid as errors:

            log.error(traceback.format_exc())

            log.error(str(errors))

            msg = _('Error creating pull request: %s') % errors.msg

            h.flash(msg, 'error')

            raise HTTPBadRequest

        # heads up: org and other might seem backward here ...

        org_repo_name = _form['org_repo']

        org_ref = _form['org_ref'] # will have merge_rev as rev but symbolic name

        org_repo = RepoModel()._get_repo(org_repo_name)

        (org_ref_type,

         org_ref_name,

         org_rev) = org_ref.split(':')

        if org_ref_type == 'rev':

            org_ref_type = 'branch'

            cs = org_repo.scm_instance.get_changeset(org_rev)

            org_ref = '%s:%s:%s' % (org_ref_type, cs.branch, cs.raw_id)

        other_repo_name = _form['other_repo']

        other_ref = _form['other_ref'] # will have symbolic name and head revision

        other_repo = RepoModel()._get_repo(other_repo_name)

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

        if other_ref_type == 'rev':

            cs = other_repo.scm_instance.get_changeset(other_rev)

            other_ref_name = cs.raw_id[:12]

            other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, cs.raw_id)

        cs_ranges, _cs_ranges_not, ancestor_rev = \

            CompareController._get_changesets(org_repo.scm_instance.alias,

                                              other_repo.scm_instance, other_rev, # org and other "swapped"

                                              org_repo.scm_instance, org_rev,

                                              )

        if ancestor_rev is None:

            ancestor_rev = org_repo.scm_instance.EMPTY_CHANGESET

        revisions = [cs_.raw_id for cs_ in cs_ranges]

        # hack: ancestor_rev is not an other_rev but we want to show the

        # requested destination and have the exact ancestor

        other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        title = _form['pullrequest_title']

        if not title:

            if org_repo_name == other_repo_name:

                title = '%s to %s' % (h.short_ref(org_ref_type, org_ref_name),

                                      h.short_ref(other_ref_type, other_ref_name))

            else:

                title = '%s#%s to %s#%s' % (org_repo_name, h.short_ref(org_ref_type, org_ref_name),

                                            other_repo_name, h.short_ref(other_ref_type, other_ref_name))

        description = _form['pullrequest_desc'].strip() or _('No description')

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id, org_repo_name, org_ref, other_repo_name,

            )

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('pullrequest_home', repo_name=repo_name))

        raise HTTPFound(location=pull_request.url())

        org_repo = RepoModel()._get_repo(old_pull_request.org_repo.repo_name)

        org_ref_type, org_ref_name, org_rev = old_pull_request.org_ref.split(':')

        new_org_rev = self._get_ref_rev(org_repo, 'rev', new_rev)

        other_repo = RepoModel()._get_repo(old_pull_request.other_repo.repo_name)

        other_ref_type, other_ref_name, other_rev = old_pull_request.other_ref.split(':') # other_rev is ancestor

        #assert other_ref_type == 'branch', other_ref_type # TODO: what if not?

        new_other_rev = self._get_ref_rev(other_repo, other_ref_type, other_ref_name)

        cs_ranges, _cs_ranges_not, ancestor_rev = CompareController._get_changesets(org_repo.scm_instance.alias,

            other_repo.scm_instance, new_other_rev, # org and other "swapped"

            org_repo.scm_instance, new_org_rev)

        old_revisions = set(old_pull_request.revisions)

        revisions = [cs.raw_id for cs in cs_ranges]

        new_revisions = [r for r in revisions if r not in old_revisions]

        lost = old_revisions.difference(revisions)

        infos = ['This is a new iteration of %s "%s".' %

                 (h.canonical_url('pullrequest_show', repo_name=old_pull_request.other_repo.repo_name,

                      pull_request_id=old_pull_request.pull_request_id),

                  old_pull_request.title)]

        if lost:

            infos.append(_('Missing changesets since the previous iteration:'))

            for r in old_pull_request.revisions:

                if r in lost:

                    rev_desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s %s' % (h.short_id(r), rev_desc))

        if new_revisions:

            infos.append(_('New changesets on %s %s since the previous iteration:') % (org_ref_type, org_ref_name))

            for r in reversed(revisions):

                if r in new_revisions:

                    rev_desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s %s' % (h.short_id(r), h.shorter(rev_desc, 80)))

            if ancestor_rev == other_rev:

                infos.append(_("Ancestor didn't change - diff since previous iteration:"))

                infos.append(h.canonical_url('compare_url',

                                 repo_name=org_repo.repo_name, # other_repo is always same as repo_name

                                 org_ref_type='rev', org_ref_name=h.short_id(org_rev), # use old org_rev as base

                                 other_ref_type='rev', other_ref_name=h.short_id(new_org_rev),

                                 )) # note: linear diff, merge or not doesn't matter

            else:

                infos.append(_('This iteration is based on another %s revision and there is no simple diff.') % other_ref_name)

        else:

           infos.append(_('No changes found on %s %s since previous iteration.') % (org_ref_type, org_ref_name))

           # TODO: fail?

        # hack: ancestor_rev is not an other_ref but we want to show the

        # requested destination and have the exact ancestor

        new_other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        new_org_ref = '%s:%s:%s' % (org_ref_type, org_ref_name, new_org_rev)

        try:

            title, old_v = re.match(r'(.*)\(v(\d+)\)\s*$', title).groups()

            v = int(old_v) + 1

        except (AttributeError, ValueError):

            v = 2

        title = '%s (v%s)' % (title.strip(), v)

        # using a mail-like separator, insert new iteration info in description with latest first

        descriptions = description.replace('\r\n', '\n').split('\n-- \n', 1)

        description = descriptions[0].strip() + '\n\n-- \n' + '\n'.join(infos)

        if len(descriptions) > 1:

            description += '\n\n' + descriptions[1].strip()

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id,

                old_pull_request.org_repo.repo_name, new_org_ref,

                old_pull_request.other_repo.repo_name, new_other_ref,

            )

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        ChangesetCommentsModel().create(

            text=_('Closed, next iteration: %s .') % pull_request.url(canonical=True),

            repo=old_pull_request.other_repo_id,

            author=c.authuser.user_id,

            pull_request=old_pull_request.pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(old_pull_request.pull_request_id)

        Session().commit()

        h.flash(_('New pull request iteration created'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    # pullrequest_post for PR editing

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def post(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        assert pull_request.other_repo.repo_name == repo_name

        #only owner or admin can update it

        owner = pull_request.owner_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if not (h.HasPermissionAny('hg.admin')() or repo_admin or owner):

            raise HTTPForbidden()

        _form = PullRequestPostForm()().to_python(request.POST)

        if _form['updaterev']:

            return self.create_new_iteration(pull_request,

                                      _form['updaterev'],

                                      _form['pullrequest_title'],

                                      _form['pullrequest_desc'],

        old_description = pull_request.description

        pull_request.title = _form['pullrequest_title']

        pull_request.description = _form['pullrequest_desc'].strip() or _('No description')

        pull_request.owner = User.get_by_username(_form['owner'])

        user = User.get(c.authuser.user_id)

        try:

            PullRequestModel().mention_from_description(user, pull_request, old_description)

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        Session().commit()

        h.flash(_('Pull request updated'), category='success')

        raise HTTPFound(location=pull_request.url())

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.owner_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            raise HTTPFound(location=url('my_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def show(self, repo_name, pull_request_id, extra=None):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        c.cs_repo = c.pull_request.org_repo

        (c.cs_ref_type,

         c.cs_ref_name,

         c.cs_rev) = c.pull_request.org_ref.split(':')

        c.a_repo = c.pull_request.other_repo

        (c.a_ref_type,

         c.a_ref_name,

         c.a_rev) = c.pull_request.other_ref.split(':') # other_rev is ancestor

        org_scm_instance = c.cs_repo.scm_instance # property with expensive cache invalidation check!!!

        c.cs_repo = c.cs_repo

        try:

            c.cs_ranges = [org_scm_instance.get_changeset(x)

                           for x in c.pull_request.revisions]

        except ChangesetDoesNotExistError:

            c.cs_ranges = []

            h.flash(_('Revision %s not found in %s') % (x, c.cs_repo.repo_name),

                'error')

        c.cs_ranges_org = None # not stored and not important and moving target - could be calculated ...

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = json.dumps(graph_data(org_scm_instance, revs))

        c.is_range = False

        try:

            if c.a_ref_type == 'rev': # this looks like a free range where target is ancestor

                cs_a = org_scm_instance.get_changeset(c.a_rev)

                root_parents = c.cs_ranges[0].parents

                c.is_range = cs_a in root_parents

                #c.merge_root = len(root_parents) > 1 # a range starting with a merge might deserve a warning

        except ChangesetDoesNotExistError: # probably because c.a_rev not found

            pass

        except IndexError: # probably because c.cs_ranges is empty, probably because revisions are missing

            pass

        avail_revs = set()

        avail_show = []

        c.cs_branch_name = c.cs_ref_name

        c.a_branch_name = None

        other_scm_instance = c.a_repo.scm_instance

        c.update_msg = ""

        c.update_msg_other = ""

        try:

            if not c.cs_ranges:

                c.update_msg = _('Error: changesets not found when displaying pull request from %s.') % c.cs_rev

            elif org_scm_instance.alias == 'hg' and c.a_ref_name != 'ancestor':

                if c.cs_ref_type != 'branch':

                    c.cs_branch_name = org_scm_instance.get_changeset(c.cs_ref_name).branch # use ref_type ?

                c.a_branch_name = c.a_ref_name

                if c.a_ref_type != 'branch':

                    try:

                        c.a_branch_name = other_scm_instance.get_changeset(c.a_ref_name).branch # use ref_type ?

                    except EmptyRepositoryError:

    comment = relationship('ChangesetComment')

    pull_request = relationship('PullRequest')

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (

            self.__class__.__name__,

            self.status, self.author

        )

    @classmethod

    def get_status_lbl(cls, value):

        return cls.STATUSES_DICT.get(value)

    @property

    def status_lbl(self):

        return ChangesetStatus.get_status_lbl(self.status)

class PullRequest(Base, BaseDbModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        Index('pr_org_repo_id_idx', 'org_repo_id'),

        Index('pr_other_repo_id_idx', 'other_repo_id'),

        _table_args_default_dict,

    )

    # values for .status

    STATUS_NEW = u'new'

    STATUS_CLOSED = u'closed'

    pull_request_id = Column(Integer(), primary_key=True)

    title = Column(Unicode(255), nullable=False)

    description = Column(UnicodeText(), nullable=False)

    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    _revisions = Column('revisions', UnicodeText(), nullable=False)

    org_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    org_ref = Column(Unicode(255), nullable=False)

    other_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    other_ref = Column(Unicode(255), nullable=False)

    @hybrid_property

    def revisions(self):

        return self._revisions.split(':')

    @revisions.setter

    def revisions(self, val):

        self._revisions = safe_unicode(':'.join(val))

    @property

    def org_ref_parts(self):

        return self.org_ref.split(':')

    @property

    def other_ref_parts(self):

        return self.other_ref.split(':')

    owner = relationship('User')

    reviewers = relationship('PullRequestReviewers',

                             cascade="all, delete-orphan")

    org_repo = relationship('Repository', primaryjoin='PullRequest.org_repo_id==Repository.repo_id')

    other_repo = relationship('Repository', primaryjoin='PullRequest.other_repo_id==Repository.repo_id')

    statuses = relationship('ChangesetStatus', order_by='ChangesetStatus.changeset_status_id')

    comments = relationship('ChangesetComment', order_by='ChangesetComment.comment_id',

                             cascade="all, delete-orphan")

    @classmethod

    def query(cls, reviewer_id=None, include_closed=True, sorted=False):

        """Add PullRequest-specific helpers for common query constructs.

        reviewer_id: only PRs with the specified user added as reviewer.

        include_closed: if False, do not include closed PRs.

        sorted: if True, apply the default ordering (newest first).

        """

        q = super(PullRequest, cls).query()

        if reviewer_id is not None:

            q = q.join(PullRequestReviewers).filter(PullRequestReviewers.user_id == reviewer_id)

        if not include_closed:

            q = q.filter(PullRequest.status != PullRequest.STATUS_CLOSED)

        if sorted:

            q = q.order_by(PullRequest.created_on.desc())

        return q

    def get_reviewer_users(self):

        """Like .reviewers, but actually returning the users"""

        return User.query() \

            .join(PullRequestReviewers) \

            .filter(PullRequestReviewers.pull_request == self) \

            .all()

    def is_closed(self):

        return self.status == self.STATUS_CLOSED

    def user_review_status(self, user_id):

        """Return the user's latest status votes on PR"""

        # note: no filtering on repo - that would be redundant

        status = ChangesetStatus.query() \

            .filter(ChangesetStatus.pull_request == self) \

            .filter(ChangesetStatus.user_id == user_id) \

            .order_by(ChangesetStatus.version) \

            .first()

        return str(status.status) if status else ''

    @classmethod

    def make_nice_id(cls, pull_request_id):

        '''Return pull request id nicely formatted for displaying'''

        return '#%s' % pull_request_id

    def nice_id(self):

        '''Return the id of this pull request, nicely formatted for displaying'''

        return self.make_nice_id(self.pull_request_id)

    def __json__(self):

        return dict(

            revisions=self.revisions

        )

    def url(self, **kwargs):

        canonical = kwargs.pop('canonical', None)

        import kallithea.lib.helpers as h

        b = self.org_ref_parts[1]

        if b != self.other_ref_parts[1]:

            s = '/_/' + b

        else:

            s = '/_/' + self.title

        kwargs['extra'] = urlreadable(s)

        if canonical:

            return h.canonical_url('pullrequest_show', repo_name=self.other_repo.repo_name,

                                   pull_request_id=self.pull_request_id, **kwargs)

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

                     pull_request_id=self.pull_request_id, **kwargs)

class PullRequestReviewers(Base, BaseDbModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

        Index('pull_request_reviewers_user_id_idx', 'user_id'),

        _table_args_default_dict,

    )

    def __init__(self, user=None, pull_request=None):

        self.user = user

        self.pull_request = pull_request

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    user = relationship('User')

    pull_request = relationship('PullRequest')

class Notification(Base, BaseDbModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        Index('notification_type_idx', 'type'),

        _table_args_default_dict,

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention' # not used

    TYPE_REGISTRATION = u'registration'

    TYPE_PULL_REQUEST = u'pull_request'

    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

    notification_id = Column(Integer(), primary_key=True)

    subject = Column(Unicode(512), nullable=False)

    body = Column(UnicodeText(), nullable=False)

    created_by = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    type_ = Column('type', Unicode(255), nullable=False)

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', cascade="all, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()

                .filter(UserNotification.notification == self)

                .order_by(UserNotification.user_id.asc()).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for recipient in recipients:

            un = UserNotification()

            un.notification = notification

            un.user_id = recipient.user_id

            # Mark notifications to self "pre-read" - should perhaps just be skipped

            if recipient == created_by:

                un.read = True

            Session().add(un)

        Session().add(notification)

        Session().flush() # assign notification.notification_id

        return notification

    @property

    def description(self):

        from kallithea.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseDbModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        _table_args_default_dict,

    )

    user_id = Column(Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column(Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column(Boolean, nullable=False, default=False)

    sent_on = Column(DateTime(timezone=False), nullable=True) # FIXME: not nullable?

    user = relationship('User')

    notification = relationship('Notification')

    def mark_as_read(self):

        self.read = True

class Gist(Base, BaseDbModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

        _table_args_default_dict,

    )

    GIST_PUBLIC = u'public'

        #reset state to under-review

        from kallithea.model.comment import ChangesetCommentsModel

        comment = ChangesetCommentsModel().create(

            text=u'',

            repo=org_repo,

            author=new.owner,

            pull_request=new,

            send_email=False,

            status_change=ChangesetStatus.STATUS_UNDER_REVIEW,

        )

        ChangesetStatusModel().set_status(

            org_repo,

            ChangesetStatus.STATUS_UNDER_REVIEW,

            new.owner,

            comment,

            pull_request=new

        )

        reviewers = set(self._get_valid_reviewers(reviewers))

        mention_recipients = extract_mentioned_users(new.description)

        self.__add_reviewers(created_by_user, new, reviewers, mention_recipients)

        return new

    def __add_reviewers(self, user, pr, reviewers, mention_recipients):

        # reviewers and mention_recipients should be sets of User objects.

        #members

        for reviewer in reviewers:

            reviewer = PullRequestReviewers(reviewer, pr)

            Session().add(reviewer)

        revision_data = [(x.raw_id, x.message)

                         for x in map(pr.org_repo.get_changeset, pr.revisions)]

        #notification to reviewers

        pr_url = pr.url(canonical=True)

        threading = ['%s-pr-%s@%s' % (pr.other_repo.repo_name,

                                      pr.pull_request_id,

                                      h.canonical_hostname())]

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s') % \

                {'user': user.username,

                 'pr_title': pr.title,

                 'pr_nice_id': pr.nice_id()},

                pr_url)

            )

        body = pr.description

        _org_ref_type, org_ref_name, _org_rev = pr.org_ref.split(':')

        _other_ref_type, other_ref_name, _other_rev = pr.other_ref.split(':')

        email_kwargs = {

            'pr_title': pr.title,

            'pr_title_short': h.shorter(pr.title, 50),

            'pr_user_created': user.full_name_and_username,

            'pr_repo_url': h.canonical_url('summary_home', repo_name=pr.other_repo.repo_name),

            'pr_url': pr_url,

            'pr_revisions': revision_data,

            'repo_name': pr.other_repo.repo_name,

            'org_repo_name': pr.org_repo.repo_name,

            'pr_nice_id': pr.nice_id(),

            'pr_target_repo': h.canonical_url('summary_home',

                               repo_name=pr.other_repo.repo_name),

            'pr_target_branch': other_ref_name,

            'pr_source_repo': h.canonical_url('summary_home',

                               repo_name=pr.org_repo.repo_name),

            'pr_source_branch': org_ref_name,

            'pr_owner': pr.owner,

            'pr_owner_username': pr.owner.username,

            'pr_username': user.username,

            'threading': threading,

            'is_mention': False,

            }

        if reviewers:

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=reviewers,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            mention_recipients.difference_update(reviewers)

        if mention_recipients:

            email_kwargs['is_mention'] = True

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

            # FIXME: this subject is wrong and unused!

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=mention_recipients,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

    def mention_from_description(self, user, pr, old_description=''):

        mention_recipients = (extract_mentioned_users(pr.description) -

                              extract_mentioned_users(old_description))

        log.debug("Mentioning %s", mention_recipients)

        self.__add_reviewers(user, pr, set(), mention_recipients)

        pull_request = PullRequest.guess_instance(pull_request)

        current_reviewers = PullRequestReviewers.query() \

            .options(joinedload('user')) \

            .filter_by(pull_request=pull_request) \

            .all()

        current_reviewer_users = set(x.user for x in current_reviewers)

        to_add = new_reviewer_users - current_reviewer_users

        to_remove = current_reviewer_users - new_reviewer_users

        if not to_add and not to_remove:

            return # all done

        log.debug("Adding %s reviewers", to_add)

        self.__add_reviewers(user, pull_request, to_add, set())

        log.debug("Removing %s reviewers", to_remove)

        for prr in current_reviewers:

            if prr.user in to_remove:

                Session().delete(prr)

    def delete(self, pull_request):

        pull_request = PullRequest.guess_instance(pull_request)

        Session().delete(pull_request)

    def close_pull_request(self, pull_request):

        pull_request = PullRequest.guess_instance(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()