rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset-comment/{revision}',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_preview',

                 '/{repo_name:.*?}/changeset-comment-preview',

                controller='changeset', action='preview_comment',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset-comment-delete/{comment_id}',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_home',

                 '/{repo_name:.*?}/compare',

                 controller='compare', action='index',

                 conditions=dict(function=check_repo))

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref_name:.*?}...{other_ref_type}@{other_ref_name:.*?}',

                 controller='compare', action='compare',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',

                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='index', conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_update',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='update', conditions=dict(function=check_repo,

                                                method=["PUT"]))

    rmap.connect('pullrequest_delete',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='delete', conditions=dict(function=check_repo,

                                                method=["DELETE"]))

    rmap.connect('pullrequest_show_all',

                 '/{repo_name:.*?}/pull-request',

                 controller='pullrequests',

                 action='show_all', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('my_pullrequests',

                 '/my_pullrequests',

                 controller='pullrequests',

                 action='show_my', conditions=dict(method=["GET"]))

    rmap.connect('my_pullrequests_data',

                 '/my_pullrequests_data',

                 controller='pullrequests',

                 action='show_my_data', conditions=dict(method=["GET"]))

    rmap.connect('pullrequest_comment',

                 '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',

                 controller='pullrequests',

                 action='comment', conditions=dict(function=check_repo,

                                                method=["POST"]))

    rmap.connect('pullrequest_comment_delete',

                 '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',

                controller='pullrequests', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('summary_home_summary', '/{repo_name:.*?}/summary',

                controller='summary', conditions=dict(function=check_repo))

    rmap.connect('branches_home', '/{repo_name:.*?}/branches',

                controller='branches', conditions=dict(function=check_repo))

    rmap.connect('tags_home', '/{repo_name:.*?}/tags',

                controller='tags', conditions=dict(function=check_repo))

    rmap.connect('bookmarks_home', '/{repo_name:.*?}/bookmarks',

                controller='bookmarks', conditions=dict(function=check_repo))

# 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.controllers.pullrequests

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

pull requests controller for Kallithea for initializing pull requests

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: May 7, 2012

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from webob.exc import HTTPNotFound, HTTPForbidden

from collections import defaultdict

from itertools import groupby

from pylons import request, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from kallithea.lib.compat import json

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\

    NotAnonymous

from kallithea.lib.helpers import Page

from kallithea.lib import helpers as h

from kallithea.lib import diffs

from kallithea.lib.utils import action_logger, jsonify

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.exceptions import EmptyRepositoryError

from kallithea.lib.diffs import LimitedDiffContainer

from kallithea.model.db import  PullRequest, ChangesetStatus, ChangesetComment,\

    PullRequestReviewers

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.lib.utils2 import safe_int

from kallithea.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

log = logging.getLogger(__name__)

class PullrequestsController(BaseRepoController):

    def __before__(self):

        super(PullrequestsController, self).__before__()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):

        """return a structure with repo's interesting changesets, suitable for

        the selectors in pullrequest.html

        rev: a revision that must be in the list somehow and selected by default

        branch: a branch that must be in the list and selected by default - even if closed

        branch_rev: a revision of which peers should be preferred and available."""

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if rev:

            rev = safe_str(rev)

        if branch:

            branch = safe_str(branch)

        if branch_rev:

            branch_rev = safe_str(branch_rev)

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

            # ... but is currently too expensive

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                "sort(parents(branch(id(%s)) and merge()) - branch(id(%s)), -rev)",

                branch_rev, branch_rev):

                abranch = repo.get_changeset(i).branch

                if abranch not in peerbranches:

                    n = 'branch:%s:%s' % (abranch, repo.get_changeset(abranch).raw_id)

                    peers.append((n, abranch))

                    peerbranches.add(abranch)

        selected = None

        for fork in org_repo.forks:

            add_other_repo(fork)

        # add parents of this fork also, but only if it's not empty

        if org_repo.parent and org_repo.parent.scm_instance.revisions:

            add_other_repo(org_repo.parent)

            c.default_other_repo = org_repo.parent.repo_name

        c.default_other_repo_info = other_repos_info[c.default_other_repo]

        c.other_repos_info = json.dumps(other_repos_info)

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

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

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

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            if errors.error_dict.get('revisions'):

                msg = 'Revisions: %s' % errors.error_dict['revisions']

            elif errors.error_dict.get('pullrequest_title'):

                msg = _('Pull request requires a title with min. 3 chars')

            else:

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

            h.flash(msg, 'error')

            return redirect(url('pullrequest_home', repo_name=repo_name)) ## would rather just go back to form ...

        org_repo = _form['org_repo']

        org_ref = _form['org_ref'] # will end with merge_rev but have symbolic name

        other_repo = _form['other_repo']

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

        ancestor_rev = _form['ancestor_rev'] # revision number of ancestor

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

        # requested destination and have the exact ancestor

        other_ref = other_ref.rsplit(':', 1)[0] + ':' + ancestor_rev

        revisions = [x for x in reversed(_form['revisions'])]

        reviewers = _form['review_members']

        title = _form['pullrequest_title']

        if not title:

            title = '%s#%s to %s' % (org_repo, org_ref.split(':', 2)[1], other_repo)

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id, org_repo, org_ref, other_repo,

                other_ref, revisions, reviewers, title, description

            )

            Session().commit()

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

                    category='success')

        except Exception:

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

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_home', repo_name=repo_name))

        return redirect(url('pullrequest_show', repo_name=other_repo,

                            pull_request_id=pull_request.pull_request_id))

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        #only owner or admin can update it

        owner = pull_request.author.user_id == c.authuser.user_id

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

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

            reviewers_ids = map(int, filter(lambda v: v not in [None, ''],

                request.POST.get('reviewers_ids', '').split(',')))

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            Session().commit()

            return True

        raise HTTPForbidden()

    @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.author.user_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

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

                    category='success')

            return redirect(url('my_account_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    def show(self, repo_name, pull_request_id):

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

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        ldap_tls_reqcert = v.OneOf(tls_reqcert_choices)

        ldap_dn_user = v.UnicodeString(strip=True,)

        ldap_dn_pass = v.UnicodeString(strip=True,)

        ldap_base_dn = v.UnicodeString(strip=True,)

        ldap_filter = v.UnicodeString(strip=True,)

        ldap_search_scope = v.OneOf(search_scope_choices)

        ldap_attr_login = v.AttrLoginValidator()(not_empty=True)

        ldap_attr_firstname = v.UnicodeString(strip=True,)

        ldap_attr_lastname = v.UnicodeString(strip=True,)

        ldap_attr_email = v.UnicodeString(strip=True,)

    return _LdapSettingsForm

def UserExtraEmailForm():

    class _UserExtraEmailForm(formencode.Schema):

        email = All(v.UniqSystemEmail(), v.Email(not_empty=True))

    return _UserExtraEmailForm

def UserExtraIpForm():

    class _UserExtraIpForm(formencode.Schema):

        ip = v.ValidIp()(not_empty=True)

    return _UserExtraIpForm

def PullRequestForm(repo_id):

    class _PullRequestForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        user = v.UnicodeString(strip=True, required=True)

        org_repo = v.UnicodeString(strip=True, required=True)

        org_ref = v.UnicodeString(strip=True, required=True)

        other_repo = v.UnicodeString(strip=True, required=True)

        other_ref = v.UnicodeString(strip=True, required=True)

        revisions = All(v.UniqueList()(not_empty=True))

        review_members = v.UniqueList()()

        pullrequest_title = v.UnicodeString(strip=True, required=True)

        pullrequest_desc = v.UnicodeString(strip=True, required=False)

        ancestor_rev = v.UnicodeString(strip=True, required=True)

        merge_rev = v.UnicodeString(strip=True, required=True)

    return _PullRequestForm

def GistForm(lifetime_options):

    class _GistForm(formencode.Schema):

        filename = All(v.BasePath()(),

                       v.UnicodeString(strip=True, required=False))

        description = v.UnicodeString(required=False, if_missing='')

        lifetime = v.OneOf(lifetime_options)

        mimetype = v.UnicodeString(required=False, if_missing=None)

        content = v.UnicodeString(required=True, not_empty=True)

        public = v.UnicodeString(required=False, if_missing='')

        private = v.UnicodeString(required=False, if_missing='')

    return _GistForm

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('%s Pull Request #%s') % (c.repo_name, c.pull_request.pull_request_id)}

    %if c.site_name:

        · ${c.site_name}

    %endif

</%def>

<%def name="breadcrumbs_links()">

    ${_('Pull request #%s') % c.pull_request.pull_request_id}

</%def>

<%def name="page_nav()">

    ${self.menu('repositories')}

</%def>

<%def name="main()">

${self.repo_context_bar('showpullrequest')}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="form pr-box" style="float: left">

            %endif

        </div>

          <div class="label-summary">

              <label>${_('Review status')}:</label>

          </div>

          <div class="input">

            <div class="changeset-status-container" style="float:none;clear:both">

            %if c.current_changeset_status:

              <div class="changeset-status-ico" style="padding:0px 4px 0px 0px">

                  <img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" title="${_('Pull request status calculated from votes')}"/></div>

              <div class="changeset-status-lbl tooltip" title="${_('Pull request status calculated from votes')}">

                %if c.pull_request.is_closed():

                    ${_('Closed')},

                %endif

                ${h.changeset_status_lbl(c.current_changeset_status)}

              </div>

            %endif

            </div>

          </div>

          <div class="label-summary">

              <label>${_('Still not reviewed by')}:</label>

          </div>

          <div class="input">

            % if len(c.pull_request_pending_reviewers) > 0:

                <div class="tooltip" title="${h.tooltip(', '.join([x.username for x in c.pull_request_pending_reviewers]))}">${ungettext('%d reviewer', '%d reviewers',len(c.pull_request_pending_reviewers)) % len(c.pull_request_pending_reviewers)}</div>

            %else:

                <div>${_('Pull request was reviewed by all reviewers')}</div>

            %endif

          </div>

          <div class="label-summary">

              <label>${_('Origin repository')}:</label>

          </div>

          <div class="input">

              <div>

              <span><a href="${h.url('summary_home', repo_name=c.pull_request.org_repo.repo_name)}">${c.pull_request.org_repo.clone_url()}</a></span>

              ## branch link is only valid if it is a branch

              <span class="spantag"><a href="${h.url('summary_home', repo_name=c.pull_request.org_repo.repo_name, anchor=c.org_ref_name)}">${c.org_ref_type}: ${c.org_ref_name}</a></span>

              </div>

          </div>

          <div class="label-summary">

              <label>${_('Target repository')}:</label>

          </div>

          <div class="input">

              <div>

              <span><a href="${h.url('summary_home', repo_name=c.pull_request.other_repo.repo_name)}">${c.pull_request.other_repo.clone_url()}</a></span>

              ## branch link is only valid if it is a branch

              <span class="spantag"><a href="${h.url('summary_home', repo_name=c.pull_request.other_repo.repo_name, anchor=c.other_ref_name)}">${c.other_ref_type}: ${c.other_ref_name}</a></span>

              </div>

          </div>

          <div class="label-summary">

              <label>${_('Pull changes')}:</label>

          </div>

          <div class="input">

              <div>

               ## TODO: use cs_ranges[-1] or org_ref_parts[1] in both cases?

               %if h.is_hg(c.pull_request.org_repo):

                 <span style="font-family: monospace">hg pull ${c.pull_request.org_repo.clone_url()} -r ${h.short_id(c.cs_ranges[-1].raw_id)}</span>

               %elif h.is_git(c.pull_request.org_repo):

                 <span style="font-family: monospace">git pull ${c.pull_request.org_repo.clone_url()} ${c.pull_request.org_ref_parts[1]}</span>

               %endif

              </div>

          </div>

          <div class="label-summary">

              <label>${_('Created on')}:</label>

          </div>

          <div class="input">

              <div>${h.fmt_date(c.pull_request.created_on)}</div>

          </div>

          <div class="label-summary">

              <label>${_('Created by')}:</label>

          </div>

          <div class="input">

              <div class="author">

                  <div class="gravatar">

                      <img alt="gravatar" src="${h.gravatar_url(c.pull_request.author.email,20)}"/>

                  </div>

                  <span>${c.pull_request.author.username_and_name}</span><br/>

                  <span><a href="mailto:${c.pull_request.author.email}">${c.pull_request.author.email}</a></span><br/>

              </div>

          </div>

      </div>

    </div>

    ## REVIEWERS

    <div style="float:left; border-left:1px dashed #eee">

       <div class="pr-details-title">${_('Pull request reviewers')}</div>

        <div id="reviewers" style="padding:0px 0px 5px 10px">

          ## members goes here !

          <div>

            <ul id="review_members" class="group_members">

            %for member,status in c.pull_request_reviewers:

              <li id="reviewer_${member.user_id}">

                <div class="reviewers_member">

                    <div class="reviewer_status tooltip" title="${h.tooltip(h.changeset_status_lbl(status[0][1].status if status else 'not_reviewed'))}">

                      <img src="${h.url(str('/images/icons/flag_status_%s.png' % (status[0][1].status if status else 'not_reviewed')))}"/>

                    </div>

                  <div class="reviewer_gravatar gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>

                  <div style="float:left;">${member.full_name} (${_('owner') if c.pull_request.user_id == member.user_id else _('reviewer')})</div>

                  <input type="hidden" value="${member.user_id}" name="review_members" />

                  %if not c.pull_request.is_closed() and (h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or c.pull_request.user_id == c.authuser.user_id):

                  <div class="reviewer_member_remove action_button" onclick="removeReviewMember(${member.user_id})" title="${_('Remove reviewer')}">

                      <i class="icon-remove-sign" style="color: #FF4444;"></i>

                  </div>

                  %endif

                </div>

              </li>

            %endfor

            </ul>

          </div>

          %if not c.pull_request.is_closed():

          <div class='ac'>

            %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or c.pull_request.author.user_id == c.authuser.user_id:

            <div class="reviewer_ac">

               ${h.text('user', class_='yui-ac-input',placeholder=_('Type name of reviewer to add'))}

               <div id="reviewers_container"></div>

            </div>

            <div style="padding:0px 10px">

             <span id="update_pull_request" class="btn btn-mini">${_('Save Changes')}</span>

            </div>

            %endif

          </div>

          %endif

        </div>

       </div>

    <div style="overflow: auto; clear: both">

      ##DIFF

      <div class="table" style="float:left;clear:none">

          <div class="diffblock">