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 an update 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 pull request:'))

            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 pull request:') % (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 - show diff since previous version:"))

                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 pull request 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 version.') % (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 update info at the top of the list

        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,

                revisions, reviewers_ids, title, description

            )

        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())

            return redirect(old_pull_request.url())

        ChangesetCommentsModel().create(

            text=_('Closed, replaced by %s .') % pull_request.url(canonical=True),

            repo=old_pull_request.other_repo.repo_id,

            user=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(_('Pull request update created'),

                category='success')

        return redirect(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

        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)

        reviewers_ids = [int(s) for s in _form['review_members']]

        if _form['updaterev']:

            return self.create_update(pull_request,

                                      _form['updaterev'],

                                      _form['pullrequest_title'],

                                      _form['pullrequest_desc'],

                                      reviewers_ids)

        old_description = pull_request.description

        pull_request.title = _form['pullrequest_title']

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

        try:

            PullRequestModel().mention_from_description(pull_request, old_description)

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

        except UserInvalidException as u:

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

            raise HTTPBadRequest()

        Session().commit()

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

        return redirect(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 !

            PullRequestModel().delete(pull_request)

            Session().commit()

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

                    category='success')

            return redirect(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

        c.cs_ranges = [org_scm_instance.get_changeset(x) for x in c.pull_request.revisions]

        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))

        avail_revs = set()

        avail_show = []

        c.cs_branch_name = c.cs_ref_name

        other_scm_instance = c.a_repo.scm_instance

        c.update_msg = ""

        c.update_msg_other = ""

        if 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:

                    c.a_branch_name = 'null' # not a branch name ... but close enough

            # candidates: descendants of old head that are on the right branch

            #             and not are the old head itself ...

            #             and nothing at all if old head is a descendant of target ref name

            if other_scm_instance._repo.revs('present(%s)::&%s', c.cs_ranges[-1].raw_id, c.a_branch_name):

                c.update_msg = _('This pull request has already been merged to %s.') % c.a_branch_name

            elif c.pull_request.is_closed():

                c.update_msg = _('This pull request has been closed and can not be updated.')

            else: # look for descendants of PR head on source branch in org repo

                avail_revs = org_scm_instance._repo.revs('%s:: & branch(%s)',

                                                         revs[0], c.cs_branch_name)

                if len(avail_revs) > 1: # more than just revs[0]

                    # also show changesets that not are descendants but would be merged in

                    targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                    if org_scm_instance.path != other_scm_instance.path:

                        # Note: org_scm_instance.path must come first so all

                        # valid revision numbers are 100% org_scm compatible

                        # - both for avail_revs and for revset results

                        hgrepo = unionrepo.unionrepository(org_scm_instance.baseui,

                                                           org_scm_instance.path,

                                                           other_scm_instance.path)

                    else:

                        hgrepo = org_scm_instance._repo

                    show = set(hgrepo.revs('::%ld & !::%s & !::%s',

                                           avail_revs, revs[0], targethead))

                    c.update_msg = _('This pull request can be updated with changes on %s:') % c.cs_branch_name

                else:

                    show = set()

                    c.update_msg = _('No changesets found for updating this pull request.')

                # TODO: handle branch heads that not are tip-most

                brevs = org_scm_instance._repo.revs('%s - %ld', c.cs_branch_name, avail_revs)

                if brevs:

                    # also show changesets that are on branch but neither ancestors nor descendants

                    show.update(org_scm_instance._repo.revs('::%ld - ::%ld - ::%s', brevs, avail_revs, c.a_branch_name))

                    show.add(revs[0]) # make sure graph shows this so we can see how they relate

                    c.update_msg_other = _('Note: Branch %s has another head: %s.') % (c.cs_branch_name,

                        h.short_id(org_scm_instance.get_changeset((max(brevs))).raw_id))

                avail_show = sorted(show, reverse=True)

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

# 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/>.

"""

kallithea.model.comment

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

comments model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 11, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

from pylons.i18n.translation import _

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from kallithea.lib import helpers as h

from kallithea.model import BaseModel

from kallithea.model.db import ChangesetComment, User, \

    Notification, PullRequest

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    cls = ChangesetComment

    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 _get_notification_data(self, repo, comment, user, comment_text,

                               line_no=None, revision=None, pull_request=None,

                               status_change=None, closing_pr=False):

        """

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

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

        #changeset

        if revision:

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

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

            subj = safe_unicode(

                h.link_to('Re changeset: %(desc)s %(line)s' % \

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

                          comment_url)

            )

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                cs_author = repo.user

            recipients += [cs_author]

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': h.person(user, 'full_name_and_username'),

                'cs_target_repo': h.canonical_url('summary_home', repo_name=repo.repo_name),

                'cs_comment_url': comment_url,

                'raw_id': revision,

                'message': cs.message,

                'repo_name': repo.repo_name,

                'short_id': h.short_id(revision),

                'branch': cs.branch,

                'comment_username': user.username,

                'threading': threading,

            }

        #pull request

        elif pull_request:

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

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

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

                                          pull_request.pull_request_id,

                                          h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-pr-%s-line-%s@%s' % (pull_request.other_repo.repo_name,

                                                          pull_request.pull_request_id, line_no,

                                                          h.canonical_hostname()))

            comment_url = pull_request.url(canonical=True,

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

            subj = safe_unicode(

                h.link_to('Re pull request %(pr_nice_id)s: %(desc)s %(line)s' % \

                          {'desc': desc,

                           'pr_nice_id': comment.pull_request.nice_id(),

                           'line': line},

                          comment_url)

            )

            # get the current participants of this pull request

            recipients = ChangesetComment.get_users(pull_request_id=

                                                pull_request.pull_request_id)

            # add pull request author

            # add the reviewers to notification

            recipients += [x.user for x in pull_request.reviewers]

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

                'pr_nice_id': pull_request.nice_id(),

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': comment_url,

                'pr_comment_user': h.person(user, 'full_name_and_username'),

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

                                   repo_name=pull_request.other_repo.repo_name),

                'repo_name': pull_request.other_repo.repo_name,

                'ref': org_ref_name,

                'comment_username': user.username,

                'threading': threading,

            }

        return subj, body, recipients, notification_type, email_kwargs

    def create(self, text, repo, user, revision=None, pull_request=None,

               f_path=None, line_no=None, status_change=None, closing_pr=False,

               send_email=True):

        """

        Creates a new comment for either a changeset or a pull request.

        status_change and closing_pr is only for the optional email.

        Returns the created comment.

        """

        if not status_change and not text:

            log.warning('Missing text for comment, skipping...')

            return None

        repo = self._get_repo(repo)

        user = self._get_user(user)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = user

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision is not None:

            comment.revision = revision

        elif pull_request is not None:

            pull_request = self.__get_pull_request(pull_request)

            comment.pull_request = pull_request

        else:

            raise Exception('Please specify revision or pull_request_id')

        Session().add(comment)

        Session().flush()

        if send_email:

            (subj, body, recipients, notification_type,

             email_kwargs) = self._get_notification_data(

                                repo, comment, user,

                                comment_text=text,

                                line_no=line_no,

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                closing_pr=closing_pr)

            email_kwargs['is_mention'] = False

            # create notification objects, and emails

            NotificationModel().create(

                created_by=user, subject=subj, body=body,

                recipients=recipients, type_=notification_type,

                email_kwargs=email_kwargs,

            )

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

                                    .difference(recipients)

            if mention_recipients:

                email_kwargs['is_mention'] = True

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

                NotificationModel().create(

                    created_by=user, subject=subj, body=body,

                    recipients=mention_recipients,

                    type_=notification_type,

                    email_kwargs=email_kwargs

                )

        return comment

    def delete(self, comment):

        comment = self.__get_changeset_comment(comment)

        Session().delete(comment)

        return comment

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

        """

        Gets general comments for either revision or pull_request.

class ChangesetStatus(Base, BaseModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        Index('cs_revision_idx', 'revision'),

        Index('cs_version_idx', 'version'),

        Index('cs_pull_request_id_idx', 'pull_request_id'),

        Index('cs_changeset_comment_id_idx', 'changeset_comment_id'),

        Index('cs_pull_request_id_user_id_version_idx', 'pull_request_id', 'user_id', 'version'),

        UniqueConstraint('repo_id', 'revision', 'version'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

    )

    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

    STATUS_APPROVED = 'approved'

    STATUS_REJECTED = 'rejected'

    STATUS_UNDER_REVIEW = 'under_review'

    STATUSES = [

        (STATUS_NOT_REVIEWED, _("Not reviewed")),  # (no icon) and default

        (STATUS_APPROVED, _("Approved")),

        (STATUS_REJECTED, _("Rejected")),

        (STATUS_UNDER_REVIEW, _("Under review")),

    ]

    changeset_status_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

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

    revision = Column(String(40), nullable=False)

    status = Column(String(128), nullable=False, default=DEFAULT)

    changeset_comment_id = Column(Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)

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

    version = Column(Integer(), nullable=False, default=0)

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

    author = relationship('User')

    repo = relationship('Repository')

    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 dict(cls.STATUSES).get(value)

    @property

    def status_lbl(self):

        return ChangesetStatus.get_status_lbl(self.status)

class PullRequest(Base, BaseModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        Index('pr_org_repo_id_idx', 'org_repo_id'),

        Index('pr_other_repo_id_idx', 'other_repo_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

    )

    # values for .status

    STATUS_NEW = u'new'

    STATUS_CLOSED = u'closed'

    pull_request_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    description = Column(UnicodeText(10240))

    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)

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

    _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max

    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(':')

    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')

    comments = relationship('ChangesetComment',

                             cascade="all, delete-orphan")

    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, BaseModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

    )

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

        self.user = user

        self.pull_request = pull_request

    pull_requests_reviewers_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

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

    user = relationship('User')

    pull_request = relationship('PullRequest')

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        Index('notification_type_idx', 'type'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    TYPE_PULL_REQUEST = u'pull_request'

    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

    notification_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    body = Column(UnicodeText(50000), nullable=True)

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

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

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

    created_by_user = relationship('User')

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

    @property

    def recipients(self):

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

# 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/>.

"""

kallithea.model.pull_request

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

pull request model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jun 6, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import datetime

from pylons.i18n.translation import _

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserInvalidException

from kallithea.model import BaseModel

from kallithea.model.db import PullRequest, PullRequestReviewers, Notification,\

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def get_pullrequest_cnt_for_user(self, user):

        return PullRequest.query()\

                                .join(PullRequestReviewers)\

                                .filter(PullRequestReviewers.user_id == user)\

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

                                .count()

    def get_all(self, repo_name, from_=False, closed=False):

        """Get all PRs for repo.

        Default is all PRs to the repo, PRs from the repo if from_.

        Closed PRs are only included if closed is true."""

        repo = self._get_repo(repo_name)

        q = PullRequest.query()

        if from_:

            q = q.filter(PullRequest.org_repo == repo)

        else:

            q = q.filter(PullRequest.other_repo == repo)

        if not closed:

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

        return q.order_by(PullRequest.created_on.desc()).all()

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

               revisions, reviewers, title, description=None):

        from kallithea.model.changeset_status import ChangesetStatusModel

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        other_repo = self._get_repo(other_repo)

        new = PullRequest()

        new.org_repo = org_repo

        new.org_ref = org_ref

        new.other_repo = other_repo

        new.other_ref = other_ref

        new.revisions = revisions

        new.title = title

        new.description = description

        Session().add(new)

        Session().flush()

        #reset state to under-review

        from kallithea.model.comment import ChangesetCommentsModel

        comment = ChangesetCommentsModel().create(

            text=u'',

            repo=org_repo,

            pull_request=new,

            send_email=False,

            status_change=ChangesetStatus.STATUS_UNDER_REVIEW,

        )

        ChangesetStatusModel().set_status(

            org_repo,

            ChangesetStatus.STATUS_UNDER_REVIEW,

            comment,

            pull_request=new

        )

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(new.description))

        self.__add_reviewers(new, reviewers, mention_recipients)

        return new

    def __add_reviewers(self, pr, reviewers, mention_recipients=None):

        #members

        for member in set(reviewers):

            _usr = self._get_user(member)

            if _usr is None:

                raise UserInvalidException(member)

            reviewer = PullRequestReviewers(_usr, 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') % \

                 '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(':')

        email_kwargs = {

            'pr_title': pr.title,

            '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,

            'pr_nice_id': pr.nice_id(),

            'ref': org_ref_name,

            'threading': threading,

            'is_mention': False,

            }

        if reviewers:

                                       recipients=reviewers,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            mention_recipients.discard(None)

            mention_recipients.difference_update(reviewers)

        if mention_recipients:

            email_kwargs['is_mention'] = True

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

                                       recipients=mention_recipients,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

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

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(pr.description))

        mention_recipients.difference_update(User.get_by_username(username, case_insensitive=True)

                                             for username in extract_mentioned_users(old_description))

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

        self.__add_reviewers(pr, [], mention_recipients)

    def update_reviewers(self, pull_request, reviewers_ids):

        reviewers_ids = set(reviewers_ids)

        pull_request = self.__get_pull_request(pull_request)