Changeset - bcc67f909d9f
Parent rev.
Child rev.
[Not reviewed]
default
0 3 0
Søren Løvborg - 9 years ago 2017-02-27 15:38:20
sorenl@unity3d.com
pullrequests: pass around reviewer User objects, not IDs

This moves reviewer user validation into the controller and eliminates
the UserInvalidException.
3 files changed with 52 insertions and 53 deletions:
kallithea/controllers/pullrequests.py
32
25
kallithea/lib/exceptions.py
4
kallithea/model/pull_request.py
20
24
0 comments (0 inline, 0 general)
kallithea/controllers/pullrequests.py
➞
Show inline comments
 
# -*- 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.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

			




	
	
	
		
 
import re

			




	
	
	
		
 

			




	
	
	
		
 
from pylons import request, tmpl_context as c

			




	
	
	
		
 
from pylons.i18n.translation import _

			




	
	
	
		
 
from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.config.routing import url

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.lib import diffs

			




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

			




	
	
	
		
 
    NotAnonymous

			




	
	
	
		
 
from kallithea.lib.base import BaseRepoController, render, jsonify

			




	
	
	
		
 
from kallithea.lib.compat import json, OrderedDict

			




	
	
	
		
 
from kallithea.lib.diffs import LimitedDiffContainer

			




	
	
	
		
 
from kallithea.lib.exceptions import UserInvalidException

			




	
	
	
		
 
from kallithea.lib.page import Page

			




	
	
	
		
 
from kallithea.lib.utils import action_logger

			




	
	
	
		
 
from kallithea.lib.vcs.exceptions import EmptyRepositoryError, ChangesetDoesNotExistError

			




	
	
	
		
 
from kallithea.lib.vcs.utils import safe_str

			




	
	
	
		
 
from kallithea.lib.vcs.utils.hgcompat import unionrepo

			




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

			




	
	
	
		
 
    PullRequestReviewer, Repository, User

			




	
	
	
		
 
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.model.forms import PullRequestForm, PullRequestPostForm

			




	
	
	
		
 
from kallithea.lib.utils2 import safe_int

			




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

			




	
	
	
		
 
    create_comment

			




	
	
	
		
 
from kallithea.controllers.compare import CompareController

			




	
	
	
		
 
from kallithea.lib.graphmod import graph_data

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_reviewer(user_id):

			




	
	
	
		
 
    """Look up user by ID and validate it as a potential reviewer."""

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        user = User.get(int(user_id))

			




	
	
	
		
 
    except ValueError:

			




	
	
	
		
 
        user = None

			




	
	
	
		
 

			




	
	
	
		
 
    if user is None or user.is_default_user:

			




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

			




	
	
	
		
 
        raise HTTPBadRequest()

			




	
	
	
		
 

			




	
	
	
		
 
    return user

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class PullrequestsController(BaseRepoController):

			




	
	
	
		
 

			




	
	
	
		
 
    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

			




	
	
	
		
 
        tiprev = repo.tags.get('tip')

			




	
	
	
		
 
        tipbranch = None

			




	
	
	
		
 

			




	
	
	
		
 
        branches = []

			




	
	
	
		
 
        for abranch, branchrev in repo.branches.iteritems():

			




	
	
	
		
 
            n = 'branch:%s:%s' % (abranch, branchrev)

			




	
	
	
		
 
            desc = abranch

			




	
	
	
		
 
            if branchrev == tiprev:

			




	
	
	
		
 
                tipbranch = abranch

			




	
	
	
		
 
                desc = '%s (current tip)' % desc

			




	
	
	
		
 
            branches.append((n, desc))

			




	
	
	
		
 
            if rev == branchrev:

			




	
	
	
		
 
                selected = n

			




	
	
	
		
 
            if branch == abranch:

			




	
	
	
		
 
                if not rev:

			




	
	
	
		
 
                    selected = n

			




	
	
	
		
 
                branch = None

			




	
	
	
		
 
        if branch:  # branch not in list - it is probably closed

			




	
	
	
		
 
            branchrev = repo.closed_branches.get(branch)

			




	
	
	
		
 
            if branchrev:

			




	
	
	
		
 
                n = 'branch:%s:%s' % (branch, branchrev)

			




	
	
	
		
 
                branches.append((n, _('%s (closed)') % branch))

			




	
	
	
		
 
                selected = n

			




	
	
	
		
 
                branch = None

			




	
	
	
		
 
            if branch:

			




	
	
	
		
 
                log.debug('branch %r not found in %s', branch, repo)

			




	
	
	
		
 

			




	
	
	
		
 
        bookmarks = []

			




	
	
	
		
 
        for bookmark, bookmarkrev in repo.bookmarks.iteritems():

			




	
	
	
		
 
            n = 'book:%s:%s' % (bookmark, bookmarkrev)

			




	
	
	
		
 
            bookmarks.append((n, bookmark))

			




	
	
	
		
 
            if rev == bookmarkrev:

			




	
	
	
		
 
                selected = n

			




	
	
	
		
 

			




	
	
	
		
 
        tags = []

			




	
	
	
		
 
        for tag, tagrev in repo.tags.iteritems():

			




	
	
	
		
 
            if tag == 'tip':

			




	
	
	
		
 
                continue

			




	
	
	
		
 
            n = 'tag:%s:%s' % (tag, tagrev)

			




	
	
	
		
 
            tags.append((n, tag))

			




	
	
	
		
 
            # note: even if rev == tagrev, don't select the static tag - it must be chosen explicitly

			




	
	
	
		
 

			




	
	
	
		
 
        # prio 1: rev was selected as existing entry above

			




	
	
	
		
 

			




	
	
	
		
 
        # prio 2: create special entry for rev; rev _must_ be used

			




	
	
	
		
 
        specials = []

			




	
	
	
		
 
        if rev and selected is None:

			




	
	
	
		
 
            selected = 'rev:%s:%s' % (rev, rev)

			




	
	
	
		
 
            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

			




	
	
	
		
 

			




	
	
	
		
 
        # prio 3: most recent peer branch

			




	
	
	
		
 
        if peers and not selected:

			




	
	
	
		
 
            selected = peers[0][0]

			




	
	
	
		
 

			




	
	
	
		
 
        # prio 4: tip revision

			




	
	
	
		
 
        if not selected:

			




	
	
	
		
 
            if h.is_hg(repo):

			




	
	
	
		
 
                if tipbranch:

			




	
	
	
		
 
                    selected = 'branch:%s:%s' % (tipbranch, tiprev)

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

			




	
	
	
		
 
                    tags.append((selected, 'null'))

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                if 'master' in repo.branches:

			




	
	
	
		
 
                    selected = 'branch:master:%s' % repo.branches['master']

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    k, v = repo.branches.items()[0]

			




	
	
	
		
 
                    selected = 'branch:%s:%s' % (k, v)

			




	
	
	
		
 

			




	
	
	
		
 
        groups = [(specials, _("Special")),

			




	
	
	
		
 
                  (peers, _("Peer branches")),

			




	
	
	
		
 
                  (bookmarks, _("Bookmarks")),

			




	
	
	
		
 
                  (branches, _("Branches")),

			




	
	
	
		
 
                  (tags, _("Tags")),

			




	
	
	
		
 
                  ]

			




	
	
	
		
 
        return [g for g in groups if g[0]], selected

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_is_allowed_change_status(self, pull_request):

			




	
	
	
		
 
        if pull_request.is_closed():

			




	
	
	
		
 
            return False

			




	
	
	
		
 

			




	
	
	
		
 
        owner = request.authuser.user_id == pull_request.owner_id

			




	
	
	
		
 
        reviewer = PullRequestReviewer.query() \

			




	
	
	
		
 
            .filter(PullRequestReviewer.pull_request == pull_request) \

			




	
	
	
		
 
            .filter(PullRequestReviewer.user_id == request.authuser.user_id) \

			




	
	
	
		
 
            .count() != 0

			




	
	
	
		
 

			




	
	
	
		
 
        return request.authuser.admin or owner or reviewer

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def show_all(self, repo_name):

			




	
	
	
		
 
        c.from_ = request.GET.get('from_') or ''

			




	
	
	
		
 
        c.closed = request.GET.get('closed') or ''

			




	
	
	
		
 
        p = safe_int(request.GET.get('page'), 1)

			




	
	
	
		
 

			




	
	
	
		
 
        q = PullRequest.query(include_closed=c.closed, sorted=True)

			




	
	
	
		
 
        if c.from_:

			




	
	
	
		
 
            q = q.filter_by(org_repo=c.db_repo)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = q.filter_by(other_repo=c.db_repo)

			




	
	
	
		
 
        c.pull_requests = q.all()

			




	
	
	
		
 

			




	
	
	
		
 
        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100)

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    def show_my(self):

			




	
	
	
		
 
        c.closed = request.GET.get('closed') or ''

			




	
	
	
		
 

			




	
	
	
		
 
        c.my_pull_requests = PullRequest.query(

			




	
	
	
		
 
            include_closed=c.closed,

			




	
	
	
		
 
            sorted=True,

			




	
	
	
		
 
        ).filter_by(owner_id=request.authuser.user_id).all()

			




	
	
	
		
 

			




	
	
	
		
 
        c.participate_in_pull_requests = []

			




	
	
	
		
 
        c.participate_in_pull_requests_todo = []

			




	
	
	
		
 
        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

			




	
	
	
		
 
        for pr in PullRequest.query(

			




	
	
	
		
 
            include_closed=c.closed,

			




	
	
	
		
 
            reviewer_id=request.authuser.user_id,

			




	
	
	
		
 
            sorted=True,

			




	
	
	
		
 
        ):

			




	
	
	
		
 
            status = pr.user_review_status(request.authuser.user_id) # very inefficient!!!

			




	
	
	
		
 
            if status in done_status:

			




	
	
	
		
 
                c.participate_in_pull_requests.append(pr)

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                c.participate_in_pull_requests_todo.append(pr)

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def index(self):

			




	
	
	
		
 
        org_repo = c.db_repo

			




	
	
	
		
 
        org_scm_instance = org_repo.scm_instance

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            org_scm_instance.get_changeset()

			




	
	
	
		
 
        except EmptyRepositoryError as e:

			




	
	
	
		
 
            h.flash(h.literal(_('There are no changesets yet')),

			




	
	
	
		
 
                    category='warning')

			




	
	
	
		
 
            raise HTTPFound(location=url('summary_home', repo_name=org_repo.repo_name))

			




	
	
	
		
 

			




	
	
	
		
 
        org_rev = request.GET.get('rev_end')

			




	
	
	
		
 
        # rev_start is not directly useful - its parent could however be used

			




	
	
	
		
 
        # as default for other and thus give a simple compare view

			




	
	
	
		
 
        rev_start = request.GET.get('rev_start')

			




	
	
	
		
 
        other_rev = None

			




	
	
	
		
 
        if rev_start:

			




	
	
	
		
 
            starters = org_repo.get_changeset(rev_start).parents

			




	
	
	
		
 
            if starters:

			




	
	
	
		
 
                other_rev = starters[0].raw_id

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                other_rev = org_repo.scm_instance.EMPTY_CHANGESET

			




	
	
	
		
 
        branch = request.GET.get('branch')

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    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_ref = _form['org_ref'] # will have merge_rev as rev but symbolic name

			




	
	
	
		
 
        org_repo = Repository.guess_instance(_form['org_repo'])

			




	
	
	
		
 
        (org_ref_type,

			




	
	
	
		
 
         org_ref_name,

			




	
	
	
		
 
         org_rev) = org_ref.split(':')

			




	
	
	
		
 
        org_display = h.short_ref(org_ref_type, org_ref_name)

			




	
	
	
		
 
        if org_ref_type == 'rev':

			




	
	
	
		
 
            cs = org_repo.scm_instance.get_changeset(org_rev)

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        other_repo = Repository.guess_instance(_form['other_repo'])

			




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

			




	
	
	
		
 
        other_display = h.short_ref(other_ref_type, other_ref_name)

			




	
	
	
		
 

			




	
	
	
		
 
        cs_ranges, _cs_ranges_not, ancestor_revs = \

			




	
	
	
		
 
            CompareController._get_changesets(org_repo.scm_instance.alias,

			




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

			




	
	
	
		
 
                                              org_repo.scm_instance, org_rev,

			




	
	
	
		
 
                                              )

			




	
	
	
		
 
        ancestor_rev = msg = None

			




	
	
	
		
 
        if not cs_ranges:

			




	
	
	
		
 
            msg = _('Cannot create empty pull request')

			




	
	
	
		
 
        elif not ancestor_revs:

			




	
	
	
		
 
            ancestor_rev = org_repo.scm_instance.EMPTY_CHANGESET

			




	
	
	
		
 
        elif len(ancestor_revs) == 1:

			




	
	
	
		
 
            ancestor_rev = ancestor_revs[0]

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            msg = _('Cannot create pull request - criss cross merge detected, please merge a later %s revision to %s'

			




	
	
	
		
 
                    ) % (other_ref_name, org_ref_name)

			




	
	
	
		
 
        if ancestor_rev is None:

			




	
	
	
		
 
            h.flash(msg, category='error', logf=log.error)

			




	
	
	
		
 
            raise HTTPNotFound

			




	
	
	
		
 

			




	
	
	
		
 
        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)

			




	
	
	
		
 

			




	
	
	
		
 
        reviewer_ids = []

			




	
	
	
		
 
        reviewers = []

			




	
	
	
		
 

			




	
	
	
		
 
        title = _form['pullrequest_title']

			




	
	
	
		
 
        if not title:

			




	
	
	
		
 
            if org_repo == other_repo:

			




	
	
	
		
 
                title = '%s to %s' % (org_display, other_display)

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                title = '%s#%s to %s#%s' % (org_repo.repo_name, org_display,

			




	
	
	
		
 
                                            other_repo.repo_name, other_display)

			




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

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            created_by = User.get(request.authuser.user_id)

			




	
	
	
		
 
            pull_request = PullRequestModel().create(

			




	
	
	
		
 
                created_by, org_repo, org_ref, other_repo, other_ref, revisions,

			




	
	
	
		
 
                title, description, reviewer_ids)

			




	
	
	
		
 
                title, description, reviewers)

			




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

			




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

			




	
	
	
		
 
        org_repo = old_pull_request.org_repo

			




	
	
	
		
 
        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 = old_pull_request.other_repo

			




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

			




	
	
	
		
 
        ancestor_rev = msg = None

			




	
	
	
		
 
        if not cs_ranges:

			




	
	
	
		
 
            msg = _('Cannot create empty pull request update') # cannot happen!

			




	
	
	
		
 
        elif not ancestor_revs:

			




	
	
	
		
 
            msg = _('Cannot create pull request update - no common ancestor found') # cannot happen

			




	
	
	
		
 
        elif len(ancestor_revs) == 1:

			




	
	
	
		
 
            ancestor_rev = ancestor_revs[0]

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            msg = _('Cannot create pull request update - criss cross merge detected, please merge a later %s revision to %s'

			




	
	
	
		
 
                    ) % (other_ref_name, org_ref_name)

			




	
	
	
		
 
        if ancestor_rev is None:

			




	
	
	
		
 
            h.flash(msg, category='error', logf=log.error)

			




	
	
	
		
 
            raise HTTPNotFound

			




	
	
	
		
 

			




	
	
	
		
 
        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:

			




	
	
	
		
 
            created_by = User.get(request.authuser.user_id)

			




	
	
	
		
 
            pull_request = PullRequestModel().create(

			




	
	
	
		
 
                created_by, org_repo, new_org_ref, other_repo, new_other_ref, revisions,

			




	
	
	
		
 
                title, description, reviewer_ids)

			




	
	
	
		
 
        except UserInvalidException as u:

			




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

			




	
	
	
		
 
            raise HTTPBadRequest()

			




	
	
	
		
 
                title, description, reviewers)

			




	
	
	
		
 
        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=request.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()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    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 == request.authuser.user_id

			




	
	
	
		
 
        repo_admin = h.HasRepoPermissionLevel('admin')(c.repo_name)

			




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

			




	
	
	
		
 
            raise HTTPForbidden()

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        org_reviewer_ids = set(int(s) for s in _form['org_review_members'])

			




	
	
	
		
 
        current_reviewer_ids = set(prr.user_id for prr in pull_request.reviewers)

			




	
	
	
		
 
        other_added = [User.get(u) for u in current_reviewer_ids - org_reviewer_ids]

			




	
	
	
		
 
        other_removed = [User.get(u) for u in org_reviewer_ids - current_reviewer_ids]

			




	
	
	
		
 
        cur_reviewers = set(pull_request.get_reviewer_users())

			




	
	
	
		
 
        new_reviewers = set(_get_reviewer(s) for s in _form['review_members'])

			




	
	
	
		
 
        old_reviewers = set(_get_reviewer(s) for s in _form['org_review_members'])

			




	
	
	
		
 

			




	
	
	
		
 
        other_added = cur_reviewers - old_reviewers

			




	
	
	
		
 
        other_removed = old_reviewers - cur_reviewers

			




	
	
	
		
 

			




	
	
	
		
 
        if other_added:

			




	
	
	
		
 
            h.flash(_('Meanwhile, the following reviewers have been added: %s') %

			




	
	
	
		
 
                    (', '.join(u.username for u in other_added)),

			




	
	
	
		
 
                    category='warning')

			




	
	
	
		
 
        if other_removed:

			




	
	
	
		
 
            h.flash(_('Meanwhile, the following reviewers have been removed: %s') %

			




	
	
	
		
 
                    (', '.join(u.username for u in other_removed)),

			




	
	
	
		
 
                    category='warning')

			




	
	
	
		
 

			




	
	
	
		
 
        if _form['updaterev']:

			




	
	
	
		
 
            return self.create_new_iteration(pull_request,

			




	
	
	
		
 
                                      _form['updaterev'],

			




	
	
	
		
 
                                      _form['pullrequest_title'],

			




	
	
	
		
 
                                      _form['pullrequest_desc'],

			




	
	
	
		
 
                                      reviewer_ids)

			




	
	
	
		
 
                                      new_reviewers)

			




	
	
	
		
 

			




	
	
	
		
 
        added_reviewers = new_reviewers - old_reviewers - cur_reviewers

			




	
	
	
		
 
        removed_reviewers = (old_reviewers - new_reviewers) & cur_reviewers

			




	
	
	
		
 

			




	
	
	
		
 
        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(request.authuser.user_id)

			




	
	
	
		
 
        add_reviewer_ids = reviewer_ids - org_reviewer_ids - current_reviewer_ids

			




	
	
	
		
 
        remove_reviewer_ids = (org_reviewer_ids - reviewer_ids) & current_reviewer_ids

			




	
	
	
		
 
        try:

			




	
	
	
		
 

			




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

			




	
	
	
		
 
            PullRequestModel().add_reviewers(user, pull_request, add_reviewer_ids)

			




	
	
	
		
 
            PullRequestModel().remove_reviewers(user, pull_request, remove_reviewer_ids)

			




	
	
	
		
 
        except UserInvalidException as u:

			




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

			




	
	
	
		
 
            raise HTTPBadRequest()

			




	
	
	
		
 
        PullRequestModel().add_reviewers(user, pull_request, added_reviewers)

			




	
	
	
		
 
        PullRequestModel().remove_reviewers(user, pull_request, removed_reviewers)

			




	
	
	
		
 

			




	
	
	
		
 
        Session().commit()

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        raise HTTPFound(location=pull_request.url())

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    @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 == request.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()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    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(':') # a_rev is ancestor

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        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:

			




	
	
	
		
 
                        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 not c.is_range and 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 & !::parents(%s) & !::%s',

			




	
	
	
		
 
                                               avail_revs, revs[0], targethead))

			




	
	
	
		
 
                        c.update_msg = _('The following additional changes are available on %s:') % c.cs_branch_name

			




	
	
	
		
 
                    else:

			




	
	
	
		
 
                        show = set()

			




	
	
	
		
 
                        avail_revs = set() # drop revs[0]

			




	
	
	
		
 
                        c.update_msg = _('No additional changesets found for iterating on this pull request.')

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
                    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)

			




	
	
	
		
 

			




	
	
	
		
 
            elif org_scm_instance.alias == 'git':

			




	
	
	
		
 
                c.cs_repo.scm_instance.get_changeset(c.cs_rev) # check it exists - raise ChangesetDoesNotExistError if not

			




	
	
	
		
 
                c.update_msg = _("Git pull requests don't support iterating yet.")

			




	
	
	
		
 
        except ChangesetDoesNotExistError:

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        c.avail_revs = avail_revs

			




	
	
	
		
 
        c.avail_cs = [org_scm_instance.get_changeset(r) for r in avail_show]

			




	
	
	
		
 
        c.avail_jsdata = json.dumps(graph_data(org_scm_instance, avail_show))

			




	
	
	
		
 

			




	
	
	
		
 
        raw_ids = [x.raw_id for x in c.cs_ranges]

			




	
	
	
		
 
        c.cs_comments = c.cs_repo.get_comments(raw_ids)

			




	
	
	
		
 
        c.statuses = c.cs_repo.statuses(raw_ids)

			




	
	
	
		
 

			




	
	
	
		
 
        ignore_whitespace = request.GET.get('ignorews') == '1'

			




	
	
	
		
 
        line_context = safe_int(request.GET.get('context'), 3)

			




	
	
	
		
 
        c.ignorews_url = _ignorews_url

			




	
	
	
		
 
        c.context_url = _context_url

			




	
	
	
		
 
        c.fulldiff = request.GET.get('fulldiff')

			




	
	
	
		
 
        diff_limit = self.cut_off_limit if not c.fulldiff else None

			




	
	
	
		
 

			




	
	
	
		
 
        # we swap org/other ref since we run a simple diff on one repo

			




	
	
	
		
 
        log.debug('running diff between %s and %s in %s',

			




	
	
	
		
 
                  c.a_rev, c.cs_rev, org_scm_instance.path)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            txtdiff = org_scm_instance.get_diff(rev1=safe_str(c.a_rev), rev2=safe_str(c.cs_rev),

			




	
	
	
		
 
                                                ignore_whitespace=ignore_whitespace,

			




	
	
	
		
 
                                                context=line_context)

			




	
	
	
		
 
        except ChangesetDoesNotExistError:

			




	
	
	
		
 
            txtdiff =  _("The diff can't be shown - the PR revisions could not be found.")

			




	
	
	
		
 
        diff_processor = diffs.DiffProcessor(txtdiff or '', format='gitdiff',

			




	
	
	
		
 
                                             diff_limit=diff_limit)

			




	
	
	
		
 
        _parsed = diff_processor.prepare()

			




	
	
	
		
 

			




	
	
	
		
 
        c.limited_diff = False

			




	
	
	
		
 
        if isinstance(_parsed, LimitedDiffContainer):

			




	
	
	
		
 
            c.limited_diff = True

			




	
	
	
		
 

			




	
	
	
		
 
        c.file_diff_data = []

			




	
	
	
		
 
        c.lines_added = 0

			




	
	
	
		
 
        c.lines_deleted = 0

			




	
	
	
		
 

			




	
	
	
		
 
        for f in _parsed:

			




	
	
	
		
 
            st = f['stats']

			




	
	
	
		
 
            c.lines_added += st['added']

			




	
	
	
		
 
            c.lines_deleted += st['deleted']

			




	
	
	
		
 
            filename = f['filename']

			




	
	
	
		
 
            fid = h.FID('', filename)

			




	
	
	
		
 
            diff = diff_processor.as_html(enable_comments=True,

			




	
	
	
		
 
                                          parsed_lines=[f])

			




	
	
	
		
 
            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, diff, st))

			




	
	
	
		
 

			




	
	
	
		
 
        # inline comments

			




	
	
	
		
 
        c.inline_cnt = 0

			




	
	
	
		
 
        c.inline_comments = cc_model.get_inline_comments(

			




	
	
	
		
 
                                c.db_repo.repo_id,

			




	
	
	
		
 
                                pull_request=pull_request_id)

			




	
	
	
		
 
        # count inline comments

			




	
	
	
		
 
        for __, lines in c.inline_comments:

			




	
	
	
		
 
            for comments in lines.values():

			




        

    


    
    

    

        

                

                    kallithea/lib/exceptions.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
# -*- 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.lib.exceptions

			




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

			




	
	
	
		
 

			




	
	
	
		
 
Set of custom exceptions used in 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 17, 2010

			




	
	
	
		
 
:author: marcink

			




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

			




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

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
from webob.exc import HTTPClientError

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class LdapUsernameError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class LdapPasswordError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class LdapConnectionError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class LdapImportError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class DefaultUserException(Exception):

			




	
	
	
		
 
    """An invalid action was attempted on the default user"""

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserOwnsReposException(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupsAssignedException(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class StatusChangeOnClosedPullRequestError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class AttachedForksError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class RepoGroupAssignmentError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class NonRelativePathError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class HTTPLockedRC(HTTPClientError):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Special Exception For locked Repos in Kallithea, the return code can

			




	
	
	
		
 
    be overwritten by _code keyword argument passed into constructors

			




	
	
	
		
 
    """

			




	
	
	
		
 
    code = 423

			




	
	
	
		
 
    title = explanation = 'Repository Locked'

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, reponame, username, *args, **kwargs):

			




	
	
	
		
 
        from kallithea import CONFIG

			




	
	
	
		
 
        from kallithea.lib.utils2 import safe_int

			




	
	
	
		
 
        _code = CONFIG.get('lock_ret_code')

			




	
	
	
		
 
        self.code = safe_int(_code, self.code)

			




	
	
	
		
 
        self.title = self.explanation = ('Repository `%s` locked by '

			




	
	
	
		
 
                                         'user `%s`' % (reponame, username))

			




	
	
	
		
 
        super(HTTPLockedRC, self).__init__(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class IMCCommitError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserCreationError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserInvalidException(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class RepositoryCreationError(Exception):

			




	
	
	
		
 
    pass

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class HgsubversionImportError(Exception):

			




	
	
	
		
 
    pass

			




        

    


    
    

    

        

                

                    kallithea/model/pull_request.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
# -*- 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 sqlalchemy.orm import joinedload

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.lib.exceptions import UserInvalidException

			




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

			




	
	
	
		
 
    ChangesetStatus, User

			




	
	
	
		
 
    ChangesetStatus

			




	
	
	
		
 
from kallithea.model.notification import NotificationModel

			




	
	
	
		
 
from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class PullRequestModel(object):

			




	
	
	
		
 
def _assert_valid_reviewers(seq):

			




	
	
	
		
 
    """Sanity check: elements are actual User objects, and not the default user."""

			




	
	
	
		
 
    assert not any(user.is_default_user for user in seq)

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_valid_reviewers(self, seq):

			




	
	
	
		
 
        """ Generate User objects from a sequence of user IDs, usernames or

			




	
	
	
		
 
        User objects. Raises UserInvalidException if the DEFAULT user is

			




	
	
	
		
 
        specified, or if a given ID or username does not match any user.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        for user_spec in seq:

			




	
	
	
		
 
            user = User.guess_instance(user_spec)

			




	
	
	
		
 
            if user is None or user.is_default_user:

			




	
	
	
		
 
                raise UserInvalidException(user_spec)

			




	
	
	
		
 
            yield user

			




	
	
	
		
 

			




	
	
	
		
 
class PullRequestModel(object):

			




	
	
	
		
 

			




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

			




	
	
	
		
 
               revisions, title, description, reviewers):

			




	
	
	
		
 
        reviewers = set(reviewers)

			




	
	
	
		
 
        _assert_valid_reviewers(reviewers)

			




	
	
	
		
 

			




	
	
	
		
 
        pr = PullRequest()

			




	
	
	
		
 
        pr.org_repo = org_repo

			




	
	
	
		
 
        pr.org_ref = org_ref

			




	
	
	
		
 
        pr.other_repo = other_repo

			




	
	
	
		
 
        pr.other_ref = other_ref

			




	
	
	
		
 
        pr.revisions = revisions

			




	
	
	
		
 
        pr.title = title

			




	
	
	
		
 
        pr.description = description

			




	
	
	
		
 
        pr.owner = created_by

			




	
	
	
		
 
        Session().add(pr)

			




	
	
	
		
 
        Session().flush() # make database assign pull_request_id

			




	
	
	
		
 

			




	
	
	
		
 
        #reset state to under-review

			




	
	
	
		
 
        from kallithea.model.changeset_status import ChangesetStatusModel

			




	
	
	
		
 
        from kallithea.model.comment import ChangesetCommentsModel

			




	
	
	
		
 
        comment = ChangesetCommentsModel().create(

			




	
	
	
		
 
            text=u'',

			




	
	
	
		
 
            repo=org_repo,

			




	
	
	
		
 
            author=created_by,

			




	
	
	
		
 
            pull_request=pr,

			




	
	
	
		
 
            send_email=False,

			




	
	
	
		
 
            status_change=ChangesetStatus.STATUS_UNDER_REVIEW,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        ChangesetStatusModel().set_status(

			




	
	
	
		
 
            org_repo,

			




	
	
	
		
 
            ChangesetStatus.STATUS_UNDER_REVIEW,

			




	
	
	
		
 
            created_by,

			




	
	
	
		
 
            comment,

			




	
	
	
		
 
            pull_request=pr,

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        reviewers = set(self._get_valid_reviewers(reviewers))

			




	
	
	
		
 
        mention_recipients = extract_mentioned_users(description)

			




	
	
	
		
 
        self.add_reviewers(created_by, pr, reviewers, mention_recipients)

			




	
	
	
		
 

			




	
	
	
		
 
        return pr

			




	
	
	
		
 

			




	
	
	
		
 
    def add_reviewers(self, user, pr, reviewers, mention_recipients=None):

			




	
	
	
		
 
        """Add reviewer and send notification to them.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        reviewer_users = set(self._get_valid_reviewers(reviewers))

			




	
	
	
		
 
        reviewers = set(reviewers)

			




	
	
	
		
 
        _assert_valid_reviewers(reviewers)

			




	
	
	
		
 
        if mention_recipients is not None:

			




	
	
	
		
 
            mention_recipients = set(mention_recipients) - reviewers

			




	
	
	
		
 
            _assert_valid_reviewers(mention_recipients)

			




	
	
	
		
 

			




	
	
	
		
 
        #members

			




	
	
	
		
 
        for reviewer in reviewer_users:

			




	
	
	
		
 
        for reviewer in reviewers:

			




	
	
	
		
 
            prr = PullRequestReviewer(reviewer, pr)

			




	
	
	
		
 
            Session().add(prr)

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
        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)

			




	
	
	
		
 

			




	
	
	
		
 
        mention_recipient_users = set()

			




	
	
	
		
 
        if mention_recipients:

			




	
	
	
		
 
            mention_recipient_users = set(self._get_valid_reviewers(mention_recipients))

			




	
	
	
		
 
            mention_recipient_users.difference_update(reviewers)

			




	
	
	
		
 
        if mention_recipient_users:

			




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

			




	
	
	
		
 
                                       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)

			




	
	
	
		
 

			




	
	
	
		
 
    def remove_reviewers(self, user, pull_request, reviewer_ids):

			




	
	
	
		
 
        """Remove users in the given user_id list from being reviewers of the PR."""

			




	
	
	
		
 
    def remove_reviewers(self, user, pull_request, reviewers):

			




	
	
	
		
 
        """Remove specified users from being reviewers of the PR."""

			




	
	
	
		
 

			




	
	
	
		
 
        PullRequestReviewer.query() \

			




	
	
	
		
 
            .filter_by(pull_request=pull_request) \

			




	
	
	
		
 
            .filter(PullRequestReviewer.user_id.in_(reviewer_ids)) \

			




	
	
	
		
 
            .filter(PullRequestReviewer.user_id.in_(r.user_id for r in reviewers)) \

			




	
	
	
		
 
            .delete(synchronize_session='fetch') # the default of 'evaluate' is not available

			




	
	
	
		
 

			




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

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: clio-19072
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.
            – Support