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

                other_ref, revisions, reviewers, title, description

            )

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

    def create_new_iteration(self, old_pull_request, new_rev, title, description, reviewers_ids):

        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)

    return _AuthSettingsForm

def LdapSettingsForm(tls_reqcert_choices, search_scope_choices,

                     tls_kind_choices):

    class _LdapSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        #pre_validators = [LdapLibValidator]

        ldap_active = v.StringBoolean(if_missing=False)

        ldap_host = v.UnicodeString(strip=True,)

        ldap_port = v.Number(strip=True,)

        ldap_tls_kind = v.OneOf(tls_kind_choices)

        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

        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)

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

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

    return _PullRequestForm

def PullRequestPostForm():

    class _PullRequestPostForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

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

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

        review_members = v.Set()

        updaterev = v.UnicodeString(strip=True, required=False, if_missing=None)

        owner = All(v.UnicodeString(strip=True, required=True),

                    v.ValidRepoUser())

    return _PullRequestPostForm

def GistForm(lifetime_options):

    class _GistForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

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

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

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

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

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

    return _GistForm

import re

from kallithea.tests.base import *

from kallithea.tests.fixture import Fixture

from kallithea.model.meta import Session

from kallithea.controllers.pullrequests import PullrequestsController

fixture = Fixture()

class TestPullrequestsController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='pullrequests', action='index',

                                    repo_name=HG_REPO))

    def test_create_trivial(self):

        self.log_user()

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 }

                                )

        assert response.status == '302 Found'

        response = response.follow()

        assert response.status == '200 OK'

        response.mustcontain('This pull request has already been merged to default.')

    def test_update_with_invalid_reviewer(self):

        invalid_user_id = 99999

        self.log_user()

        # create a valid pull request

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 }

                                )

        assert response.status == '302 Found'

        # location is of the form:

        # http://localhost/vcs_test_hg/pull-request/54/_/title

        m = re.search('/pull-request/(\d+)/', response.location)

        assert m != None

        pull_request_id = m.group(1)

        # update it

        response = self.app.post(url(controller='pullrequests', action='post',

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'updaterev': 'default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': invalid_user_id,

                                 },

                                 status=400)

        response.mustcontain('Invalid reviewer "%s" specified' % invalid_user_id)

    def test_edit_with_invalid_reviewer(self):

        invalid_user_id = 99999

        self.log_user()

        # create a valid pull request

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',