pullrequests.py
1029 lines
| 41.6 KiB
| text/x-python
|
PythonLexer
r1 | # -*- coding: utf-8 -*- | |||
r1271 | # Copyright (C) 2012-2017 RhodeCode GmbH | |||
r1 | # | |||
# This program is free software: you can redistribute it and/or modify | ||||
# it under the terms of the GNU Affero General Public License, version 3 | ||||
# (only), as published by the Free Software Foundation. | ||||
# | ||||
# 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 Affero General Public License | ||||
# along with this program. If not, see <http://www.gnu.org/licenses/>. | ||||
# | ||||
# This program is dual-licensed. If you wish to learn more about the | ||||
# RhodeCode Enterprise Edition, including its added features, Support services, | ||||
# and proprietary license terms, please see https://rhodecode.com/licenses/ | ||||
""" | ||||
pull requests controller for rhodecode for initializing pull requests | ||||
""" | ||||
r1255 | import types | |||
r1 | ||||
r873 | import peppercorn | |||
r1 | import formencode | |||
import logging | ||||
r1268 | import collections | |||
r1255 | ||||
r1 | from webob.exc import HTTPNotFound, HTTPForbidden, HTTPBadRequest | |||
from pylons import request, tmpl_context as c, url | ||||
from pylons.controllers.util import redirect | ||||
from pylons.i18n.translation import _ | ||||
r814 | from pyramid.threadlocal import get_current_registry | |||
r1 | from sqlalchemy.sql import func | |||
from sqlalchemy.sql.expression import or_ | ||||
r443 | from rhodecode import events | |||
r1159 | from rhodecode.lib import auth, diffs, helpers as h, codeblocks | |||
r1 | from rhodecode.lib.ext_json import json | |||
from rhodecode.lib.base import ( | ||||
BaseRepoController, render, vcs_operation_context) | ||||
from rhodecode.lib.auth import ( | ||||
LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, | ||||
HasAcceptedRepoType, XHRRequired) | ||||
r814 | from rhodecode.lib.channelstream import channelstream_request | |||
r1 | from rhodecode.lib.utils import jsonify | |||
r1192 | from rhodecode.lib.utils2 import ( | |||
r1255 | safe_int, safe_str, str2bool, safe_unicode) | |||
from rhodecode.lib.vcs.backends.base import ( | ||||
EmptyCommit, UpdateFailureReason, EmptyRepository) | ||||
r1 | from rhodecode.lib.vcs.exceptions import ( | |||
r1159 | EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError, | |||
NodeDoesNotExistError) | ||||
r1192 | ||||
r1 | from rhodecode.model.changeset_status import ChangesetStatusModel | |||
r1323 | from rhodecode.model.comment import CommentsModel | |||
r1192 | from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment, | |||
Repository, PullRequestVersion) | ||||
r1 | from rhodecode.model.forms import PullRequestForm | |||
from rhodecode.model.meta import Session | ||||
from rhodecode.model.pull_request import PullRequestModel | ||||
log = logging.getLogger(__name__) | ||||
class PullrequestsController(BaseRepoController): | ||||
def __before__(self): | ||||
super(PullrequestsController, self).__before__() | ||||
r1268 | def _load_compare_data(self, pull_request, inline_comments): | |||
r1 | """ | |||
Load context data needed for generating compare diff | ||||
:param pull_request: object related to the request | ||||
:param enable_comments: flag to determine if comments are included | ||||
""" | ||||
source_repo = pull_request.source_repo | ||||
source_ref_id = pull_request.source_ref_parts.commit_id | ||||
target_repo = pull_request.target_repo | ||||
target_ref_id = pull_request.target_ref_parts.commit_id | ||||
# despite opening commits for bookmarks/branches/tags, we always | ||||
# convert this to rev to prevent changes after bookmark or branch change | ||||
c.source_ref_type = 'rev' | ||||
c.source_ref = source_ref_id | ||||
c.target_ref_type = 'rev' | ||||
c.target_ref = target_ref_id | ||||
c.source_repo = source_repo | ||||
c.target_repo = target_repo | ||||
c.fulldiff = bool(request.GET.get('fulldiff')) | ||||
# diff_limit is the old behavior, will cut off the whole diff | ||||
# if the limit is applied otherwise will just hide the | ||||
# big files from the front-end | ||||
diff_limit = self.cut_off_limit_diff | ||||
file_limit = self.cut_off_limit_file | ||||
pre_load = ["author", "branch", "date", "message"] | ||||
c.commit_ranges = [] | ||||
source_commit = EmptyCommit() | ||||
target_commit = EmptyCommit() | ||||
c.missing_requirements = False | ||||
try: | ||||
c.commit_ranges = [ | ||||
source_repo.get_commit(commit_id=rev, pre_load=pre_load) | ||||
for rev in pull_request.revisions] | ||||
c.statuses = source_repo.statuses( | ||||
[x.raw_id for x in c.commit_ranges]) | ||||
target_commit = source_repo.get_commit( | ||||
commit_id=safe_str(target_ref_id)) | ||||
source_commit = source_repo.get_commit( | ||||
commit_id=safe_str(source_ref_id)) | ||||
except RepositoryRequirementError: | ||||
c.missing_requirements = True | ||||
r1268 | # auto collapse if we have more than limit | |||
collapse_limit = diffs.DiffProcessor._collapse_commits_over | ||||
c.collapse_all_commits = len(c.commit_ranges) > collapse_limit | ||||
r1159 | c.changes = {} | |||
r1 | c.missing_commits = False | |||
if (c.missing_requirements or | ||||
isinstance(source_commit, EmptyCommit) or | ||||
source_commit == target_commit): | ||||
_parsed = [] | ||||
c.missing_commits = True | ||||
else: | ||||
vcs_diff = PullRequestModel().get_diff(pull_request) | ||||
diff_processor = diffs.DiffProcessor( | ||||
r1159 | vcs_diff, format='newdiff', diff_limit=diff_limit, | |||
r1 | file_limit=file_limit, show_full_diff=c.fulldiff) | |||
r1159 | _parsed = diff_processor.prepare() | |||
c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer) | ||||
r1268 | included_files = {} | |||
for f in _parsed: | ||||
included_files[f['filename']] = f['stats'] | ||||
c.deleted_files = [fname for fname in inline_comments if | ||||
fname not in included_files] | ||||
c.deleted_files_comments = collections.defaultdict(dict) | ||||
for fname, per_line_comments in inline_comments.items(): | ||||
if fname in c.deleted_files: | ||||
c.deleted_files_comments[fname]['stats'] = 0 | ||||
c.deleted_files_comments[fname]['comments'] = list() | ||||
for lno, comments in per_line_comments.items(): | ||||
c.deleted_files_comments[fname]['comments'].extend(comments) | ||||
r1159 | ||||
def _node_getter(commit): | ||||
def get_node(fname): | ||||
try: | ||||
return commit.get_node(fname) | ||||
except NodeDoesNotExistError: | ||||
return None | ||||
return get_node | ||||
c.diffset = codeblocks.DiffSet( | ||||
repo_name=c.repo_name, | ||||
r1194 | source_repo_name=c.source_repo.repo_name, | |||
r1159 | source_node_getter=_node_getter(target_commit), | |||
target_node_getter=_node_getter(source_commit), | ||||
comments=inline_comments | ||||
).render_patchset(_parsed, target_commit.raw_id, source_commit.raw_id) | ||||
r1 | def _extract_ordering(self, request): | |||
column_index = safe_int(request.GET.get('order[0][column]')) | ||||
order_dir = request.GET.get('order[0][dir]', 'desc') | ||||
order_by = request.GET.get( | ||||
'columns[%s][data][sort]' % column_index, 'name_raw') | ||||
return order_by, order_dir | ||||
@LoginRequired() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@HasAcceptedRepoType('git', 'hg') | ||||
def show_all(self, repo_name): | ||||
# filter types | ||||
c.active = 'open' | ||||
c.source = str2bool(request.GET.get('source')) | ||||
c.closed = str2bool(request.GET.get('closed')) | ||||
c.my = str2bool(request.GET.get('my')) | ||||
c.awaiting_review = str2bool(request.GET.get('awaiting_review')) | ||||
c.awaiting_my_review = str2bool(request.GET.get('awaiting_my_review')) | ||||
c.repo_name = repo_name | ||||
opened_by = None | ||||
if c.my: | ||||
c.active = 'my' | ||||
opened_by = [c.rhodecode_user.user_id] | ||||
statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN] | ||||
if c.closed: | ||||
c.active = 'closed' | ||||
statuses = [PullRequest.STATUS_CLOSED] | ||||
if c.awaiting_review and not c.source: | ||||
c.active = 'awaiting' | ||||
if c.source and not c.awaiting_review: | ||||
c.active = 'source' | ||||
if c.awaiting_my_review: | ||||
c.active = 'awaiting_my' | ||||
data = self._get_pull_requests_list( | ||||
repo_name=repo_name, opened_by=opened_by, statuses=statuses) | ||||
if not request.is_xhr: | ||||
c.data = json.dumps(data['data']) | ||||
c.records_total = data['recordsTotal'] | ||||
r1282 | return render('/pullrequests/pullrequests.mako') | |||
r1 | else: | |||
return json.dumps(data) | ||||
def _get_pull_requests_list(self, repo_name, opened_by, statuses): | ||||
# pagination | ||||
start = safe_int(request.GET.get('start'), 0) | ||||
length = safe_int(request.GET.get('length'), c.visual.dashboard_items) | ||||
order_by, order_dir = self._extract_ordering(request) | ||||
if c.awaiting_review: | ||||
pull_requests = PullRequestModel().get_awaiting_review( | ||||
repo_name, source=c.source, opened_by=opened_by, | ||||
statuses=statuses, offset=start, length=length, | ||||
order_by=order_by, order_dir=order_dir) | ||||
pull_requests_total_count = PullRequestModel( | ||||
).count_awaiting_review( | ||||
repo_name, source=c.source, statuses=statuses, | ||||
opened_by=opened_by) | ||||
elif c.awaiting_my_review: | ||||
pull_requests = PullRequestModel().get_awaiting_my_review( | ||||
repo_name, source=c.source, opened_by=opened_by, | ||||
user_id=c.rhodecode_user.user_id, statuses=statuses, | ||||
offset=start, length=length, order_by=order_by, | ||||
order_dir=order_dir) | ||||
pull_requests_total_count = PullRequestModel( | ||||
).count_awaiting_my_review( | ||||
repo_name, source=c.source, user_id=c.rhodecode_user.user_id, | ||||
statuses=statuses, opened_by=opened_by) | ||||
else: | ||||
pull_requests = PullRequestModel().get_all( | ||||
repo_name, source=c.source, opened_by=opened_by, | ||||
statuses=statuses, offset=start, length=length, | ||||
order_by=order_by, order_dir=order_dir) | ||||
pull_requests_total_count = PullRequestModel().count_all( | ||||
repo_name, source=c.source, statuses=statuses, | ||||
opened_by=opened_by) | ||||
from rhodecode.lib.utils import PartialRenderer | ||||
r1282 | _render = PartialRenderer('data_table/_dt_elements.mako') | |||
r1 | data = [] | |||
for pr in pull_requests: | ||||
r1323 | comments = CommentsModel().get_all_comments( | |||
r1 | c.rhodecode_db_repo.repo_id, pull_request=pr) | |||
data.append({ | ||||
'name': _render('pullrequest_name', | ||||
pr.pull_request_id, pr.target_repo.repo_name), | ||||
'name_raw': pr.pull_request_id, | ||||
'status': _render('pullrequest_status', | ||||
pr.calculated_review_status()), | ||||
'title': _render( | ||||
'pullrequest_title', pr.title, pr.description), | ||||
'description': h.escape(pr.description), | ||||
'updated_on': _render('pullrequest_updated_on', | ||||
h.datetime_to_time(pr.updated_on)), | ||||
'updated_on_raw': h.datetime_to_time(pr.updated_on), | ||||
'created_on': _render('pullrequest_updated_on', | ||||
h.datetime_to_time(pr.created_on)), | ||||
'created_on_raw': h.datetime_to_time(pr.created_on), | ||||
'author': _render('pullrequest_author', | ||||
pr.author.full_contact, ), | ||||
'author_raw': pr.author.full_name, | ||||
'comments': _render('pullrequest_comments', len(comments)), | ||||
'comments_raw': len(comments), | ||||
'closed': pr.is_closed(), | ||||
}) | ||||
# json used to render the grid | ||||
data = ({ | ||||
'data': data, | ||||
'recordsTotal': pull_requests_total_count, | ||||
'recordsFiltered': pull_requests_total_count, | ||||
}) | ||||
return data | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@HasAcceptedRepoType('git', 'hg') | ||||
def index(self): | ||||
source_repo = c.rhodecode_db_repo | ||||
try: | ||||
source_repo.scm_instance().get_commit() | ||||
except EmptyRepositoryError: | ||||
h.flash(h.literal(_('There are no commits yet')), | ||||
category='warning') | ||||
redirect(url('summary_home', repo_name=source_repo.repo_name)) | ||||
commit_id = request.GET.get('commit') | ||||
branch_ref = request.GET.get('branch') | ||||
bookmark_ref = request.GET.get('bookmark') | ||||
try: | ||||
source_repo_data = PullRequestModel().generate_repo_data( | ||||
source_repo, commit_id=commit_id, | ||||
branch=branch_ref, bookmark=bookmark_ref) | ||||
except CommitDoesNotExistError as e: | ||||
log.exception(e) | ||||
h.flash(_('Commit does not exist'), 'error') | ||||
redirect(url('pullrequest_home', repo_name=source_repo.repo_name)) | ||||
default_target_repo = source_repo | ||||
r921 | ||||
if source_repo.parent: | ||||
parent_vcs_obj = source_repo.parent.scm_instance() | ||||
if parent_vcs_obj and not parent_vcs_obj.is_empty(): | ||||
# change default if we have a parent repo | ||||
default_target_repo = source_repo.parent | ||||
r1 | ||||
target_repo_data = PullRequestModel().generate_repo_data( | ||||
default_target_repo) | ||||
selected_source_ref = source_repo_data['refs']['selected_ref'] | ||||
title_source_ref = selected_source_ref.split(':', 2)[1] | ||||
c.default_title = PullRequestModel().generate_pullrequest_title( | ||||
source=source_repo.repo_name, | ||||
source_ref=title_source_ref, | ||||
target=default_target_repo.repo_name | ||||
) | ||||
c.default_repo_data = { | ||||
'source_repo_name': source_repo.repo_name, | ||||
'source_refs_json': json.dumps(source_repo_data), | ||||
'target_repo_name': default_target_repo.repo_name, | ||||
'target_refs_json': json.dumps(target_repo_data), | ||||
} | ||||
c.default_source_ref = selected_source_ref | ||||
r1282 | return render('/pullrequests/pullrequest.mako') | |||
r1 | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@XHRRequired() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@jsonify | ||||
def get_repo_refs(self, repo_name, target_repo_name): | ||||
repo = Repository.get_by_repo_name(target_repo_name) | ||||
if not repo: | ||||
raise HTTPNotFound | ||||
return PullRequestModel().generate_repo_data(repo) | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@XHRRequired() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@jsonify | ||||
def get_repo_destinations(self, repo_name): | ||||
repo = Repository.get_by_repo_name(repo_name) | ||||
if not repo: | ||||
raise HTTPNotFound | ||||
filter_query = request.GET.get('query') | ||||
query = Repository.query() \ | ||||
.order_by(func.length(Repository.repo_name)) \ | ||||
.filter(or_( | ||||
Repository.repo_name == repo.repo_name, | ||||
Repository.fork_id == repo.repo_id)) | ||||
if filter_query: | ||||
ilike_expression = u'%{}%'.format(safe_unicode(filter_query)) | ||||
query = query.filter( | ||||
Repository.repo_name.ilike(ilike_expression)) | ||||
add_parent = False | ||||
if repo.parent: | ||||
if filter_query in repo.parent.repo_name: | ||||
r921 | parent_vcs_obj = repo.parent.scm_instance() | |||
if parent_vcs_obj and not parent_vcs_obj.is_empty(): | ||||
r1 | add_parent = True | |||
limit = 20 - 1 if add_parent else 20 | ||||
all_repos = query.limit(limit).all() | ||||
if add_parent: | ||||
all_repos += [repo.parent] | ||||
repos = [] | ||||
for obj in self.scm_model.get_repos(all_repos): | ||||
repos.append({ | ||||
'id': obj['name'], | ||||
'text': obj['name'], | ||||
'type': 'repo', | ||||
'obj': obj['dbrepo'] | ||||
}) | ||||
data = { | ||||
'more': False, | ||||
'results': [{ | ||||
'text': _('Repositories'), | ||||
'children': repos | ||||
}] if repos else [] | ||||
} | ||||
return data | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@HasAcceptedRepoType('git', 'hg') | ||||
@auth.CSRFRequired() | ||||
def create(self, repo_name): | ||||
repo = Repository.get_by_repo_name(repo_name) | ||||
if not repo: | ||||
raise HTTPNotFound | ||||
r873 | controls = peppercorn.parse(request.POST.items()) | |||
r1 | try: | |||
r873 | _form = PullRequestForm(repo.repo_id)().to_python(controls) | |||
r1 | except formencode.Invalid as errors: | |||
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: {}').format(errors) | ||||
log.exception(msg) | ||||
h.flash(msg, 'error') | ||||
# would rather just go back to form ... | ||||
return redirect(url('pullrequest_home', repo_name=repo_name)) | ||||
source_repo = _form['source_repo'] | ||||
source_ref = _form['source_ref'] | ||||
target_repo = _form['target_repo'] | ||||
target_ref = _form['target_ref'] | ||||
commit_ids = _form['revisions'][::-1] | ||||
r873 | reviewers = [ | |||
(r['user_id'], r['reasons']) for r in _form['review_members']] | ||||
r1 | ||||
# find the ancestor for this pr | ||||
source_db_repo = Repository.get_by_repo_name(_form['source_repo']) | ||||
target_db_repo = Repository.get_by_repo_name(_form['target_repo']) | ||||
source_scm = source_db_repo.scm_instance() | ||||
target_scm = target_db_repo.scm_instance() | ||||
source_commit = source_scm.get_commit(source_ref.split(':')[-1]) | ||||
target_commit = target_scm.get_commit(target_ref.split(':')[-1]) | ||||
ancestor = source_scm.get_common_ancestor( | ||||
source_commit.raw_id, target_commit.raw_id, target_scm) | ||||
target_ref_type, target_ref_name, __ = _form['target_ref'].split(':') | ||||
target_ref = ':'.join((target_ref_type, target_ref_name, ancestor)) | ||||
pullrequest_title = _form['pullrequest_title'] | ||||
title_source_ref = source_ref.split(':', 2)[1] | ||||
if not pullrequest_title: | ||||
pullrequest_title = PullRequestModel().generate_pullrequest_title( | ||||
source=source_repo, | ||||
source_ref=title_source_ref, | ||||
target=target_repo | ||||
) | ||||
description = _form['pullrequest_desc'] | ||||
try: | ||||
pull_request = PullRequestModel().create( | ||||
c.rhodecode_user.user_id, source_repo, source_ref, target_repo, | ||||
target_ref, commit_ids, reviewers, pullrequest_title, | ||||
description | ||||
) | ||||
Session().commit() | ||||
h.flash(_('Successfully opened new pull request'), | ||||
category='success') | ||||
except Exception as e: | ||||
msg = _('Error occurred during sending pull request') | ||||
log.exception(msg) | ||||
h.flash(msg, category='error') | ||||
return redirect(url('pullrequest_home', repo_name=repo_name)) | ||||
return redirect(url('pullrequest_show', repo_name=target_repo, | ||||
pull_request_id=pull_request.pull_request_id)) | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@auth.CSRFRequired() | ||||
@jsonify | ||||
def update(self, repo_name, pull_request_id): | ||||
pull_request_id = safe_int(pull_request_id) | ||||
pull_request = PullRequest.get_or_404(pull_request_id) | ||||
# only owner or admin can update it | ||||
allowed_to_update = PullRequestModel().check_user_update( | ||||
pull_request, c.rhodecode_user) | ||||
if allowed_to_update: | ||||
r873 | controls = peppercorn.parse(request.POST.items()) | |||
if 'review_members' in controls: | ||||
self._update_reviewers( | ||||
pull_request_id, controls['review_members']) | ||||
r1 | elif str2bool(request.POST.get('update_commits', 'false')): | |||
self._update_commits(pull_request) | ||||
elif str2bool(request.POST.get('close_pull_request', 'false')): | ||||
self._reject_close(pull_request) | ||||
elif str2bool(request.POST.get('edit_pull_request', 'false')): | ||||
self._edit_pull_request(pull_request) | ||||
else: | ||||
raise HTTPBadRequest() | ||||
return True | ||||
raise HTTPForbidden() | ||||
def _edit_pull_request(self, pull_request): | ||||
try: | ||||
PullRequestModel().edit( | ||||
pull_request, request.POST.get('title'), | ||||
request.POST.get('description')) | ||||
except ValueError: | ||||
msg = _(u'Cannot update closed pull requests.') | ||||
h.flash(msg, category='error') | ||||
return | ||||
else: | ||||
Session().commit() | ||||
msg = _(u'Pull request title & description updated.') | ||||
h.flash(msg, category='success') | ||||
return | ||||
def _update_commits(self, pull_request): | ||||
|
r1076 | resp = PullRequestModel().update_commits(pull_request) | ||
|
r1083 | if resp.executed: | ||
|
r1076 | msg = _( | ||
u'Pull request updated to "{source_commit_id}" with ' | ||||
u'{count_added} added, {count_removed} removed commits.') | ||||
msg = msg.format( | ||||
source_commit_id=pull_request.source_ref_parts.commit_id, | ||||
count_added=len(resp.changes.added), | ||||
count_removed=len(resp.changes.removed)) | ||||
h.flash(msg, category='success') | ||||
registry = get_current_registry() | ||||
rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {}) | ||||
channelstream_config = rhodecode_plugins.get('channelstream', {}) | ||||
if channelstream_config.get('enabled'): | ||||
message = msg + ( | ||||
' - <a onclick="window.location.reload()">' | ||||
'<strong>{}</strong></a>'.format(_('Reload page'))) | ||||
channel = '/repo${}$/pr/{}'.format( | ||||
pull_request.target_repo.repo_name, | ||||
pull_request.pull_request_id | ||||
) | ||||
payload = { | ||||
'type': 'message', | ||||
'user': 'system', | ||||
'exclude_users': [request.user.username], | ||||
'channel': channel, | ||||
'message': { | ||||
'message': message, | ||||
'level': 'success', | ||||
'topic': '/notifications' | ||||
} | ||||
} | ||||
channelstream_request( | ||||
channelstream_config, [payload], '/message', | ||||
raise_exc=False) | ||||
else: | ||||
|
r1082 | msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason] | ||
warning_reasons = [ | ||||
UpdateFailureReason.NO_CHANGE, | ||||
UpdateFailureReason.WRONG_REF_TPYE, | ||||
] | ||||
category = 'warning' if resp.reason in warning_reasons else 'error' | ||||
h.flash(msg, category=category) | ||||
r1 | ||||
@auth.CSRFRequired() | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
def merge(self, repo_name, pull_request_id): | ||||
""" | ||||
POST /{repo_name}/pull-request/{pull_request_id} | ||||
Merge will perform a server-side merge of the specified | ||||
pull request, if the pull request is approved and mergeable. | ||||
After succesfull merging, the pull request is automatically | ||||
closed, with a relevant comment. | ||||
""" | ||||
pull_request_id = safe_int(pull_request_id) | ||||
pull_request = PullRequest.get_or_404(pull_request_id) | ||||
user = c.rhodecode_user | ||||
if self._meets_merge_pre_conditions(pull_request, user): | ||||
log.debug("Pre-conditions checked, trying to merge.") | ||||
extras = vcs_operation_context( | ||||
request.environ, repo_name=pull_request.target_repo.repo_name, | ||||
username=user.username, action='push', | ||||
scm=pull_request.target_repo.repo_type) | ||||
self._merge_pull_request(pull_request, user, extras) | ||||
return redirect(url( | ||||
'pullrequest_show', | ||||
repo_name=pull_request.target_repo.repo_name, | ||||
pull_request_id=pull_request.pull_request_id)) | ||||
def _meets_merge_pre_conditions(self, pull_request, user): | ||||
if not PullRequestModel().check_user_merge(pull_request, user): | ||||
raise HTTPForbidden() | ||||
merge_status, msg = PullRequestModel().merge_status(pull_request) | ||||
if not merge_status: | ||||
log.debug("Cannot merge, not mergeable.") | ||||
h.flash(msg, category='error') | ||||
return False | ||||
if (pull_request.calculated_review_status() | ||||
is not ChangesetStatus.STATUS_APPROVED): | ||||
log.debug("Cannot merge, approval is pending.") | ||||
msg = _('Pull request reviewer approval is pending.') | ||||
h.flash(msg, category='error') | ||||
return False | ||||
return True | ||||
def _merge_pull_request(self, pull_request, user, extras): | ||||
merge_resp = PullRequestModel().merge( | ||||
pull_request, user, extras=extras) | ||||
if merge_resp.executed: | ||||
log.debug("The merge was successful, closing the pull request.") | ||||
PullRequestModel().close_pull_request( | ||||
pull_request.pull_request_id, user) | ||||
Session().commit() | ||||
r166 | msg = _('Pull request was successfully merged and closed.') | |||
h.flash(msg, category='success') | ||||
r1 | else: | |||
log.debug( | ||||
"The merge was not successful. Merge response: %s", | ||||
merge_resp) | ||||
msg = PullRequestModel().merge_status_message( | ||||
merge_resp.failure_reason) | ||||
h.flash(msg, category='error') | ||||
r873 | def _update_reviewers(self, pull_request_id, review_members): | |||
reviewers = [ | ||||
(int(r['user_id']), r['reasons']) for r in review_members] | ||||
PullRequestModel().update_reviewers(pull_request_id, reviewers) | ||||
r1 | Session().commit() | |||
def _reject_close(self, pull_request): | ||||
if pull_request.is_closed(): | ||||
raise HTTPForbidden() | ||||
PullRequestModel().close_pull_request_with_comment( | ||||
pull_request, c.rhodecode_user, c.rhodecode_db_repo) | ||||
Session().commit() | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@auth.CSRFRequired() | ||||
@jsonify | ||||
def delete(self, repo_name, pull_request_id): | ||||
pull_request_id = safe_int(pull_request_id) | ||||
pull_request = PullRequest.get_or_404(pull_request_id) | ||||
# only owner can delete it ! | ||||
if pull_request.author.user_id == c.rhodecode_user.user_id: | ||||
PullRequestModel().delete(pull_request) | ||||
Session().commit() | ||||
h.flash(_('Successfully deleted pull request'), | ||||
category='success') | ||||
return redirect(url('my_account_pullrequests')) | ||||
raise HTTPForbidden() | ||||
r1192 | def _get_pr_version(self, pull_request_id, version=None): | |||
pull_request_id = safe_int(pull_request_id) | ||||
at_version = None | ||||
r1255 | ||||
if version and version == 'latest': | ||||
pull_request_ver = PullRequest.get(pull_request_id) | ||||
pull_request_obj = pull_request_ver | ||||
_org_pull_request_obj = pull_request_obj | ||||
at_version = 'latest' | ||||
elif version: | ||||
r1192 | pull_request_ver = PullRequestVersion.get_or_404(version) | |||
pull_request_obj = pull_request_ver | ||||
_org_pull_request_obj = pull_request_ver.pull_request | ||||
at_version = pull_request_ver.pull_request_version_id | ||||
else: | ||||
_org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(pull_request_id) | ||||
r1255 | pull_request_display_obj = PullRequest.get_pr_display_object( | |||
pull_request_obj, _org_pull_request_obj) | ||||
r1192 | return _org_pull_request_obj, pull_request_obj, \ | |||
r1194 | pull_request_display_obj, at_version | |||
r1192 | ||||
r1255 | def _get_pr_version_changes(self, version, pull_request_latest): | |||
""" | ||||
Generate changes commits, and diff data based on the current pr version | ||||
""" | ||||
#TODO(marcink): save those changes as JSON metadata for chaching later. | ||||
# fake the version to add the "initial" state object | ||||
pull_request_initial = PullRequest.get_pr_display_object( | ||||
pull_request_latest, pull_request_latest, | ||||
internal_methods=['get_commit', 'versions']) | ||||
pull_request_initial.revisions = [] | ||||
pull_request_initial.source_repo.get_commit = types.MethodType( | ||||
lambda *a, **k: EmptyCommit(), pull_request_initial) | ||||
pull_request_initial.source_repo.scm_instance = types.MethodType( | ||||
lambda *a, **k: EmptyRepository(), pull_request_initial) | ||||
_changes_versions = [pull_request_latest] + \ | ||||
list(reversed(c.versions)) + \ | ||||
[pull_request_initial] | ||||
if version == 'latest': | ||||
index = 0 | ||||
else: | ||||
for pos, prver in enumerate(_changes_versions): | ||||
ver = getattr(prver, 'pull_request_version_id', -1) | ||||
if ver == safe_int(version): | ||||
index = pos | ||||
break | ||||
else: | ||||
index = 0 | ||||
cur_obj = _changes_versions[index] | ||||
prev_obj = _changes_versions[index + 1] | ||||
old_commit_ids = set(prev_obj.revisions) | ||||
new_commit_ids = set(cur_obj.revisions) | ||||
changes = PullRequestModel()._calculate_commit_id_changes( | ||||
old_commit_ids, new_commit_ids) | ||||
old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs( | ||||
cur_obj, prev_obj) | ||||
file_changes = PullRequestModel()._calculate_file_changes( | ||||
old_diff_data, new_diff_data) | ||||
return changes, file_changes | ||||
r1 | @LoginRequired() | |||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
def show(self, repo_name, pull_request_id): | ||||
pull_request_id = safe_int(pull_request_id) | ||||
r1194 | version = request.GET.get('version') | |||
r1192 | ||||
r1194 | (pull_request_latest, | |||
pull_request_at_ver, | ||||
pull_request_display_obj, | ||||
at_version) = self._get_pr_version(pull_request_id, version=version) | ||||
r1 | ||||
r395 | c.template_context['pull_request_data']['pull_request_id'] = \ | |||
pull_request_id | ||||
r394 | ||||
r1 | # pull_requests repo_name we opened it against | |||
# ie. target_repo must match | ||||
r1194 | if repo_name != pull_request_at_ver.target_repo.repo_name: | |||
r1 | raise HTTPNotFound | |||
|
r896 | c.shadow_clone_url = PullRequestModel().get_shadow_clone_url( | ||
r1194 | pull_request_at_ver) | |||
r1192 | ||||
r1194 | pr_closed = pull_request_latest.is_closed() | |||
r1255 | if at_version and not at_version == 'latest': | |||
r1192 | c.allowed_to_change_status = False | |||
r1194 | c.allowed_to_update = False | |||
c.allowed_to_merge = False | ||||
c.allowed_to_delete = False | ||||
c.allowed_to_comment = False | ||||
r1192 | else: | |||
c.allowed_to_change_status = PullRequestModel(). \ | ||||
r1194 | check_user_change_status(pull_request_at_ver, c.rhodecode_user) | |||
r1192 | c.allowed_to_update = PullRequestModel().check_user_update( | |||
r1194 | pull_request_latest, c.rhodecode_user) and not pr_closed | |||
r1192 | c.allowed_to_merge = PullRequestModel().check_user_merge( | |||
r1194 | pull_request_latest, c.rhodecode_user) and not pr_closed | |||
r1192 | c.allowed_to_delete = PullRequestModel().check_user_delete( | |||
r1194 | pull_request_latest, c.rhodecode_user) and not pr_closed | |||
c.allowed_to_comment = not pr_closed | ||||
r1 | ||||
r1323 | cc_model = CommentsModel() | |||
r1 | ||||
r1194 | c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses() | |||
c.pull_request_review_status = pull_request_at_ver.calculated_review_status() | ||||
r1 | c.pr_merge_status, c.pr_merge_msg = PullRequestModel().merge_status( | |||
r1194 | pull_request_at_ver) | |||
r1 | c.approval_msg = None | |||
if c.pull_request_review_status != ChangesetStatus.STATUS_APPROVED: | ||||
c.approval_msg = _('Reviewer approval is pending.') | ||||
c.pr_merge_status = False | ||||
# inline comments | ||||
r1268 | inline_comments = cc_model.get_inline_comments( | |||
c.rhodecode_db_repo.repo_id, pull_request=pull_request_id) | ||||
_inline_cnt, c.inline_versions = cc_model.get_inline_comments_count( | ||||
inline_comments, version=at_version, include_aggregates=True) | ||||
r1286 | c.versions = pull_request_display_obj.versions() | |||
r1268 | c.at_version_num = at_version if at_version and at_version != 'latest' else None | |||
r1286 | c.at_version_pos = ChangesetComment.get_index_from_version( | |||
c.at_version_num, c.versions) | ||||
r1268 | is_outdated = lambda co: \ | |||
not c.at_version_num \ | ||||
or co.pull_request_version_id <= c.at_version_num | ||||
r1206 | ||||
r1268 | # inline_comments_until_version | |||
if c.at_version_num: | ||||
# if we use version, then do not show later comments | ||||
# than current version | ||||
paths = collections.defaultdict(lambda: collections.defaultdict(list)) | ||||
for fname, per_line_comments in inline_comments.iteritems(): | ||||
for lno, comments in per_line_comments.iteritems(): | ||||
for co in comments: | ||||
if co.pull_request_version_id and is_outdated(co): | ||||
paths[co.f_path][co.line_no].append(co) | ||||
inline_comments = paths | ||||
r1183 | ||||
r1 | # outdated comments | |||
c.outdated_cnt = 0 | ||||
r1323 | if CommentsModel.use_outdated_comments(pull_request_latest): | |||
r1268 | outdated_comments = cc_model.get_outdated_comments( | |||
r1 | c.rhodecode_db_repo.repo_id, | |||
r1194 | pull_request=pull_request_at_ver) | |||
r1192 | ||||
r1 | # Count outdated comments and check for deleted files | |||
r1268 | is_outdated = lambda co: \ | |||
not c.at_version_num \ | ||||
or co.pull_request_version_id < c.at_version_num | ||||
for file_name, lines in outdated_comments.iteritems(): | ||||
r1 | for comments in lines.values(): | |||
r1268 | comments = [comm for comm in comments if is_outdated(comm)] | |||
r1 | c.outdated_cnt += len(comments) | |||
r1268 | ||||
# load compare data into template context | ||||
self._load_compare_data(pull_request_at_ver, inline_comments) | ||||
r1 | ||||
r1159 | # this is a hack to properly display links, when creating PR, the | |||
# compare view and others uses different notation, and | ||||
r1282 | # compare_commits.mako renders links based on the target_repo. | |||
r1159 | # We need to swap that here to generate it properly on the html side | |||
c.target_repo = c.source_repo | ||||
r1268 | # general comments | |||
c.comments = cc_model.get_comments( | ||||
c.rhodecode_db_repo.repo_id, pull_request=pull_request_id) | ||||
r1 | ||||
if c.allowed_to_update: | ||||
force_close = ('forced_closed', _('Close Pull Request')) | ||||
statuses = ChangesetStatus.STATUSES + [force_close] | ||||
else: | ||||
statuses = ChangesetStatus.STATUSES | ||||
c.commit_statuses = statuses | ||||
r1255 | c.ancestor = None # TODO: add ancestor here | |||
r1194 | c.pull_request = pull_request_display_obj | |||
r1192 | c.pull_request_latest = pull_request_latest | |||
c.at_version = at_version | ||||
r1 | ||||
r1255 | c.changes = None | |||
c.file_changes = None | ||||
r1268 | c.show_version_changes = 1 # control flag, not used yet | |||
r1255 | ||||
if at_version and c.show_version_changes: | ||||
c.changes, c.file_changes = self._get_pr_version_changes( | ||||
version, pull_request_latest) | ||||
r1282 | return render('/pullrequests/pullrequest_show.mako') | |||
r1 | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@auth.CSRFRequired() | ||||
@jsonify | ||||
def comment(self, repo_name, pull_request_id): | ||||
pull_request_id = safe_int(pull_request_id) | ||||
pull_request = PullRequest.get_or_404(pull_request_id) | ||||
if pull_request.is_closed(): | ||||
raise HTTPForbidden() | ||||
# TODO: johbo: Re-think this bit, "approved_closed" does not exist | ||||
# as a changeset status, still we want to send it in one value. | ||||
status = request.POST.get('changeset_status', None) | ||||
text = request.POST.get('text') | ||||
r1324 | comment_type = request.POST.get('comment_type') | |||
r1326 | resolves_comment_id = request.POST.get('resolves_comment_id', None) | |||
r1325 | ||||
r1 | if status and '_closed' in status: | |||
close_pr = True | ||||
status = status.replace('_closed', '') | ||||
else: | ||||
close_pr = False | ||||
forced = (status == 'forced') | ||||
if forced: | ||||
status = 'rejected' | ||||
allowed_to_change_status = PullRequestModel().check_user_change_status( | ||||
pull_request, c.rhodecode_user) | ||||
if status and allowed_to_change_status: | ||||
message = (_('Status change %(transition_icon)s %(status)s') | ||||
% {'transition_icon': '>', | ||||
'status': ChangesetStatus.get_status_lbl(status)}) | ||||
if close_pr: | ||||
message = _('Closing with') + ' ' + message | ||||
text = text or message | ||||
r1323 | comm = CommentsModel().create( | |||
r1 | text=text, | |||
repo=c.rhodecode_db_repo.repo_id, | ||||
user=c.rhodecode_user.user_id, | ||||
pull_request=pull_request_id, | ||||
f_path=request.POST.get('f_path'), | ||||
line_no=request.POST.get('line'), | ||||
status_change=(ChangesetStatus.get_status_lbl(status) | ||||
if status and allowed_to_change_status else None), | ||||
r548 | status_change_type=(status | |||
if status and allowed_to_change_status else None), | ||||
r1324 | closing_pr=close_pr, | |||
r1325 | comment_type=comment_type, | |||
resolves_comment_id=resolves_comment_id | ||||
r1 | ) | |||
if allowed_to_change_status: | ||||
old_calculated_status = pull_request.calculated_review_status() | ||||
# get status if set ! | ||||
if status: | ||||
ChangesetStatusModel().set_status( | ||||
c.rhodecode_db_repo.repo_id, | ||||
status, | ||||
c.rhodecode_user.user_id, | ||||
comm, | ||||
pull_request=pull_request_id | ||||
) | ||||
Session().flush() | ||||
r443 | events.trigger(events.PullRequestCommentEvent(pull_request, comm)) | |||
r1 | # we now calculate the status of pull request, and based on that | |||
# calculation we set the commits status | ||||
calculated_status = pull_request.calculated_review_status() | ||||
if old_calculated_status != calculated_status: | ||||
PullRequestModel()._trigger_pull_request_hook( | ||||
pull_request, c.rhodecode_user, 'review_status_change') | ||||
calculated_status_lbl = ChangesetStatus.get_status_lbl( | ||||
calculated_status) | ||||
if close_pr: | ||||
status_completed = ( | ||||
calculated_status in [ChangesetStatus.STATUS_APPROVED, | ||||
ChangesetStatus.STATUS_REJECTED]) | ||||
if forced or status_completed: | ||||
PullRequestModel().close_pull_request( | ||||
pull_request_id, c.rhodecode_user) | ||||
else: | ||||
h.flash(_('Closing pull request on other statuses than ' | ||||
'rejected or approved is forbidden. ' | ||||
'Calculated status from all reviewers ' | ||||
'is currently: %s') % calculated_status_lbl, | ||||
category='warning') | ||||
Session().commit() | ||||
if not request.is_xhr: | ||||
return redirect(h.url('pullrequest_show', repo_name=repo_name, | ||||
pull_request_id=pull_request_id)) | ||||
data = { | ||||
'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))), | ||||
} | ||||
if comm: | ||||
c.co = comm | ||||
r1286 | c.inline_comment = True if comm.line_no else False | |||
r1 | data.update(comm.get_dict()) | |||
data.update({'rendered_text': | ||||
r1282 | render('changeset/changeset_comment_block.mako')}) | |||
r1 | ||||
return data | ||||
@LoginRequired() | ||||
@NotAnonymous() | ||||
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write', | ||||
'repository.admin') | ||||
@auth.CSRFRequired() | ||||
@jsonify | ||||
def delete_comment(self, repo_name, comment_id): | ||||
return self._delete_comment(comment_id) | ||||
def _delete_comment(self, comment_id): | ||||
comment_id = safe_int(comment_id) | ||||
co = ChangesetComment.get_or_404(comment_id) | ||||
if co.pull_request.is_closed(): | ||||
# don't allow deleting comments on closed pull request | ||||
raise HTTPForbidden() | ||||
is_owner = co.author.user_id == c.rhodecode_user.user_id | ||||
is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name) | ||||
if h.HasPermissionAny('hg.admin')() or is_repo_admin or is_owner: | ||||
old_calculated_status = co.pull_request.calculated_review_status() | ||||
r1323 | CommentsModel().delete(comment=co) | |||
r1 | Session().commit() | |||
calculated_status = co.pull_request.calculated_review_status() | ||||
if old_calculated_status != calculated_status: | ||||
PullRequestModel()._trigger_pull_request_hook( | ||||
co.pull_request, c.rhodecode_user, 'review_status_change') | ||||
return True | ||||
else: | ||||
raise HTTPForbidden() | ||||