##// END OF EJS Templates
comments: skip already deleted comments and make sure we don't raise unnecessary errors.
comments: skip already deleted comments and make sure we don't raise unnecessary errors.

File last commit:

r1326:e70e0f00 default
r1330:17b0bbae default
Show More
pullrequests.py
1029 lines | 41.6 KiB | text/x-python | PythonLexer
# -*- coding: utf-8 -*-
# Copyright (C) 2012-2017 RhodeCode GmbH
#
# 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
"""
import types
import peppercorn
import formencode
import logging
import collections
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 _
from pyramid.threadlocal import get_current_registry
from sqlalchemy.sql import func
from sqlalchemy.sql.expression import or_
from rhodecode import events
from rhodecode.lib import auth, diffs, helpers as h, codeblocks
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)
from rhodecode.lib.channelstream import channelstream_request
from rhodecode.lib.utils import jsonify
from rhodecode.lib.utils2 import (
safe_int, safe_str, str2bool, safe_unicode)
from rhodecode.lib.vcs.backends.base import (
EmptyCommit, UpdateFailureReason, EmptyRepository)
from rhodecode.lib.vcs.exceptions import (
EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
NodeDoesNotExistError)
from rhodecode.model.changeset_status import ChangesetStatusModel
from rhodecode.model.comment import CommentsModel
from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment,
Repository, PullRequestVersion)
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__()
def _load_compare_data(self, pull_request, inline_comments):
"""
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
# 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
c.changes = {}
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(
vcs_diff, format='newdiff', diff_limit=diff_limit,
file_limit=file_limit, show_full_diff=c.fulldiff)
_parsed = diff_processor.prepare()
c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
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)
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,
source_repo_name=c.source_repo.repo_name,
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)
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']
return render('/pullrequests/pullrequests.mako')
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
_render = PartialRenderer('data_table/_dt_elements.mako')
data = []
for pr in pull_requests:
comments = CommentsModel().get_all_comments(
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
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
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
return render('/pullrequests/pullrequest.mako')
@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:
parent_vcs_obj = repo.parent.scm_instance()
if parent_vcs_obj and not parent_vcs_obj.is_empty():
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
controls = peppercorn.parse(request.POST.items())
try:
_form = PullRequestForm(repo.repo_id)().to_python(controls)
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]
reviewers = [
(r['user_id'], r['reasons']) for r in _form['review_members']]
# 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:
controls = peppercorn.parse(request.POST.items())
if 'review_members' in controls:
self._update_reviewers(
pull_request_id, controls['review_members'])
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):
resp = PullRequestModel().update_commits(pull_request)
if resp.executed:
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:
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)
@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()
msg = _('Pull request was successfully merged and closed.')
h.flash(msg, category='success')
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')
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)
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()
def _get_pr_version(self, pull_request_id, version=None):
pull_request_id = safe_int(pull_request_id)
at_version = None
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:
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)
pull_request_display_obj = PullRequest.get_pr_display_object(
pull_request_obj, _org_pull_request_obj)
return _org_pull_request_obj, pull_request_obj, \
pull_request_display_obj, at_version
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
@LoginRequired()
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def show(self, repo_name, pull_request_id):
pull_request_id = safe_int(pull_request_id)
version = request.GET.get('version')
(pull_request_latest,
pull_request_at_ver,
pull_request_display_obj,
at_version) = self._get_pr_version(pull_request_id, version=version)
c.template_context['pull_request_data']['pull_request_id'] = \
pull_request_id
# pull_requests repo_name we opened it against
# ie. target_repo must match
if repo_name != pull_request_at_ver.target_repo.repo_name:
raise HTTPNotFound
c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
pull_request_at_ver)
pr_closed = pull_request_latest.is_closed()
if at_version and not at_version == 'latest':
c.allowed_to_change_status = False
c.allowed_to_update = False
c.allowed_to_merge = False
c.allowed_to_delete = False
c.allowed_to_comment = False
else:
c.allowed_to_change_status = PullRequestModel(). \
check_user_change_status(pull_request_at_ver, c.rhodecode_user)
c.allowed_to_update = PullRequestModel().check_user_update(
pull_request_latest, c.rhodecode_user) and not pr_closed
c.allowed_to_merge = PullRequestModel().check_user_merge(
pull_request_latest, c.rhodecode_user) and not pr_closed
c.allowed_to_delete = PullRequestModel().check_user_delete(
pull_request_latest, c.rhodecode_user) and not pr_closed
c.allowed_to_comment = not pr_closed
cc_model = CommentsModel()
c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
c.pull_request_review_status = pull_request_at_ver.calculated_review_status()
c.pr_merge_status, c.pr_merge_msg = PullRequestModel().merge_status(
pull_request_at_ver)
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
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)
c.versions = pull_request_display_obj.versions()
c.at_version_num = at_version if at_version and at_version != 'latest' else None
c.at_version_pos = ChangesetComment.get_index_from_version(
c.at_version_num, c.versions)
is_outdated = lambda co: \
not c.at_version_num \
or co.pull_request_version_id <= c.at_version_num
# 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
# outdated comments
c.outdated_cnt = 0
if CommentsModel.use_outdated_comments(pull_request_latest):
outdated_comments = cc_model.get_outdated_comments(
c.rhodecode_db_repo.repo_id,
pull_request=pull_request_at_ver)
# Count outdated comments and check for deleted files
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():
for comments in lines.values():
comments = [comm for comm in comments if is_outdated(comm)]
c.outdated_cnt += len(comments)
# load compare data into template context
self._load_compare_data(pull_request_at_ver, inline_comments)
# this is a hack to properly display links, when creating PR, the
# compare view and others uses different notation, and
# compare_commits.mako renders links based on the target_repo.
# We need to swap that here to generate it properly on the html side
c.target_repo = c.source_repo
# general comments
c.comments = cc_model.get_comments(
c.rhodecode_db_repo.repo_id, pull_request=pull_request_id)
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
c.ancestor = None # TODO: add ancestor here
c.pull_request = pull_request_display_obj
c.pull_request_latest = pull_request_latest
c.at_version = at_version
c.changes = None
c.file_changes = None
c.show_version_changes = 1 # control flag, not used yet
if at_version and c.show_version_changes:
c.changes, c.file_changes = self._get_pr_version_changes(
version, pull_request_latest)
return render('/pullrequests/pullrequest_show.mako')
@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')
comment_type = request.POST.get('comment_type')
resolves_comment_id = request.POST.get('resolves_comment_id', None)
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
comm = CommentsModel().create(
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),
status_change_type=(status
if status and allowed_to_change_status else None),
closing_pr=close_pr,
comment_type=comment_type,
resolves_comment_id=resolves_comment_id
)
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()
events.trigger(events.PullRequestCommentEvent(pull_request, comm))
# 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
c.inline_comment = True if comm.line_no else False
data.update(comm.get_dict())
data.update({'rendered_text':
render('changeset/changeset_comment_block.mako')})
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()
CommentsModel().delete(comment=co)
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()