pull requests: add a 'Calculated' comment on current_changeset_status

rhodecode/controllers/pullrequests.py

@@ -1,550 +1,550 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.pullrequests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     pull requests controller for rhodecode for initializing pull requests
 
     :created_on: May 7, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import logging
 import traceback
 import formencode
 
 from webob.exc import HTTPNotFound, HTTPForbidden
 from collections import defaultdict
 from itertools import groupby
 
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib.compat import json
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\
     NotAnonymous
 from rhodecode.lib.helpers import Page
 from rhodecode.lib import helpers as h
 from rhodecode.lib import diffs
 from rhodecode.lib.utils import action_logger, jsonify
 from rhodecode.lib.vcs.utils import safe_str
 from rhodecode.lib.vcs.exceptions import EmptyRepositoryError
 from rhodecode.lib.diffs import LimitedDiffContainer
 from rhodecode.model.db import  PullRequest, ChangesetStatus, ChangesetComment
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.forms import PullRequestForm
 from rhodecode.lib.utils2 import safe_int
 
 log = logging.getLogger(__name__)
 
 
 class PullrequestsController(BaseRepoController):
 
     def __before__(self):
         super(PullrequestsController, self).__before__()
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
     def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):
         """return a structure with repo's interesting changesets, suitable for
         the selectors in pullrequest.html
 
         rev: a revision that must be in the list somehow and selected by default
         branch: a branch that must be in the list and selected by default - even if closed
         branch_rev: a revision of which peers should be preferred and available."""
         # list named branches that has been merged to this named branch - it should probably merge back
         peers = []
 
         if rev:
             rev = safe_str(rev)
 
         if branch:
             branch = safe_str(branch)
 
         if branch_rev:
             branch_rev = safe_str(branch_rev)
             # not restricting to merge() would also get branch point and be better
             # (especially because it would get the branch point) ... but is currently too expensive
             otherbranches = {}
             for i in repo._repo.revs(
                 "sort(parents(branch(id(%s)) and merge()) - branch(id(%s)))",
                 branch_rev, branch_rev):
                 cs = repo.get_changeset(i)
                 otherbranches[cs.branch] = cs.raw_id
             for abranch, node in otherbranches.iteritems():
                 selected = 'branch:%s:%s' % (abranch, node)
                 peers.append((selected, abranch))
 
         selected = None
 
         branches = []
         for abranch, branchrev in repo.branches.iteritems():
             n = 'branch:%s:%s' % (abranch, branchrev)
             branches.append((n, abranch))
             if rev == branchrev:
                 selected = n
             if branch == abranch:
                 selected = n
                 branch = None
         if branch: # branch not in list - it is probably closed
             revs = repo._repo.revs('max(branch(%s))', branch)
             if revs:
                 cs = repo.get_changeset(revs[0])
                 selected = 'branch:%s:%s' % (branch, cs.raw_id)
                 branches.append((selected, branch))
 
         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():
             n = 'tag:%s:%s' % (tag, tagrev)
             tags.append((n, tag))
             if rev == tagrev and tag != 'tip': # tip is not a real tag - and its branch is better
                 selected = n
 
         # 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][0]
 
         # prio 4: tip revision
         if not selected:
             selected = 'tag:tip:%s' % repo.tags['tip']
 
         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):
         owner = self.rhodecode_user.user_id == pull_request.user_id
         reviewer = self.rhodecode_user.user_id in [x.user_id for x in
                                                    pull_request.reviewers]
         return (self.rhodecode_user.admin or owner or reviewer)
 
     def _load_compare_data(self, pull_request, enable_comments=True):
         """
         Load context data needed for generating compare diff
 
         :param pull_request:
         """
         org_repo = pull_request.org_repo
         (org_ref_type,
          org_ref_name,
          org_ref_rev) = pull_request.org_ref.split(':')
 
         other_repo = org_repo
         (other_ref_type,
          other_ref_name,
          other_ref_rev) = pull_request.other_ref.split(':')
 
         # despite opening revisions for bookmarks/branches/tags, we always
         # convert this to rev to prevent changes after bookmark or branch change
         org_ref = ('rev', org_ref_rev)
         other_ref = ('rev', other_ref_rev)
 
         c.org_repo = org_repo
         c.other_repo = other_repo
 
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
 
         c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]
 
         c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])
 
         c.org_ref = org_ref[1]
         c.org_ref_type = org_ref[0]
         c.other_ref = other_ref[1]
         c.other_ref_type = other_ref[0]
 
         diff_limit = self.cut_off_limit if not 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'
                   % (other_ref, org_ref, org_repo.scm_instance.path))
         txtdiff = org_repo.scm_instance.get_diff(rev1=safe_str(other_ref[1]), rev2=safe_str(org_ref[1]))
 
         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.files = []
         c.changes = {}
         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']
             fid = h.FID('', f['filename'])
             c.files.append([fid, f['operation'], f['filename'], f['stats']])
             htmldiff = diff_processor.as_html(enable_comments=enable_comments,
                                               parsed_lines=[f])
             c.changes[fid] = [f['operation'], f['filename'], htmldiff]
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def show_all(self, repo_name):
         c.from_ = request.GET.get('from_') or ''
         c.closed = request.GET.get('closed') or ''
         c.pull_requests = PullRequestModel().get_all(repo_name, from_=c.from_, closed=c.closed)
         c.repo_name = repo_name
         p = safe_int(request.GET.get('page', 1), 1)
 
         c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=10)
 
         c.pullrequest_data = render('/pullrequests/pullrequest_data.html')
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             return c.pullrequest_data
 
         return render('/pullrequests/pullrequest_show_all.html')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self):
         org_repo = c.rhodecode_db_repo
 
         if org_repo.scm_instance.alias != 'hg':
             log.error('Review not available for GIT REPOS')
             raise HTTPNotFound
 
         try:
             org_repo.scm_instance.get_changeset()
         except EmptyRepositoryError, e:
             h.flash(h.literal(_('There are no changesets yet')),
                     category='warning')
             redirect(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
         #other_rev = request.POST.get('rev_start')
         branch = request.GET.get('branch')
 
         c.org_repos = []
         c.org_repos.append((org_repo.repo_name, org_repo.repo_name))
         c.default_org_repo = org_repo.repo_name
         c.org_refs, c.default_org_ref = self._get_repo_refs(org_repo.scm_instance, rev=org_rev, branch=branch)
 
         c.other_repos = []
         other_repos_info = {}
 
         def add_other_repo(repo, branch_rev=None):
             if repo.repo_name in other_repos_info: # shouldn't happen
                 return
             c.other_repos.append((repo.repo_name, repo.repo_name))
             other_refs, selected_other_ref = self._get_repo_refs(repo.scm_instance, branch_rev=branch_rev)
             other_repos_info[repo.repo_name] = {
                 'user': dict(user_id=repo.user.user_id,
                              username=repo.user.username,
                              firstname=repo.user.firstname,
                              lastname=repo.user.lastname,
                              gravatar_link=h.gravatar_url(repo.user.email, 14)),
                 'description': repo.description.split('\n', 1)[0],
                 'revs': h.select('other_ref', selected_other_ref, other_refs, class_='refs')
             }
 
         # add org repo to other so we can open pull request against peer branches on itself
         add_other_repo(org_repo, branch_rev=org_rev)
         c.default_other_repo = org_repo.repo_name
 
         # 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:
             add_other_repo(fork)
 
         # add parents of this fork also, but only if it's not empty
         if org_repo.parent and org_repo.parent.scm_instance.revisions:
             add_other_repo(org_repo.parent)
             c.default_other_repo = org_repo.parent.repo_name
 
         c.default_other_repo_info = other_repos_info[c.default_other_repo]
         c.other_repos_info = json.dumps(other_repos_info)
 
         return render('/pullrequests/pullrequest.html')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def create(self, repo_name):
         repo = RepoModel()._get_repo(repo_name)
         try:
             _form = PullRequestForm(repo.repo_id)().to_python(request.POST)
         except formencode.Invalid, errors:
             log.error(traceback.format_exc())
             if errors.error_dict.get('revisions'):
                 msg = 'Revisions: %s' % errors.error_dict['revisions']
             elif errors.error_dict.get('pullrequest_title'):
                 msg = _('Pull request requires a title with min. 3 chars')
             else:
                 msg = _('Error creating pull request')
 
             h.flash(msg, 'error')
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         org_repo = _form['org_repo']
         org_ref = _form['org_ref'] # will end with merge_rev but have symbolic name
         other_repo = _form['other_repo']
         other_ref = 'rev:ancestor:%s' % _form['ancestor_rev'] # could be calculated from other_ref ...
         revisions = [x for x in reversed(_form['revisions'])]
         reviewers = _form['review_members']
 
         title = _form['pullrequest_title']
         description = _form['pullrequest_desc']
         try:
             pull_request = PullRequestModel().create(
                 self.rhodecode_user.user_id, org_repo, org_ref, other_repo,
                 other_ref, revisions, reviewers, title, description
             )
             Session().commit()
             h.flash(_('Successfully opened new pull request'),
                     category='success')
         except Exception:
             h.flash(_('Error occurred during sending pull request'),
                     category='error')
             log.error(traceback.format_exc())
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         return redirect(url('pullrequest_show', repo_name=other_repo,
                             pull_request_id=pull_request.pull_request_id))
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def update(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
         #only owner or admin can update it
         owner = pull_request.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             reviewers_ids = map(int, filter(lambda v: v not in [None, ''],
                        request.POST.get('reviewers_ids', '').split(',')))
 
             PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)
             Session().commit()
             return True
         raise HTTPForbidden()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def delete(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         #only owner can delete it !
         if pull_request.author.user_id == c.rhodecode_user.user_id:
             PullRequestModel().delete(pull_request)
             Session().commit()
             h.flash(_('Successfully deleted pull request'),
                     category='success')
             return redirect(url('admin_settings_my_account', anchor='pullrequests'))
         raise HTTPForbidden()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def show(self, repo_name, pull_request_id):
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
         c.pull_request = PullRequest.get_or_404(pull_request_id)
         c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)
         cc_model = ChangesetCommentsModel()
         cs_model = ChangesetStatusModel()
         _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,
                                             pull_request=c.pull_request,
                                             with_revisions=True)
 
         cs_statuses = defaultdict(list)
         for st in _cs_statuses:
             cs_statuses[st.author.username] += [st]
 
         c.pull_request_reviewers = []
         c.pull_request_pending_reviewers = []
         for o in c.pull_request.reviewers:
             st = cs_statuses.get(o.user.username, None)
             if st:
                 sorter = lambda k: k.version
                 st = [(x, list(y)[0])
                       for x, y in (groupby(sorted(st, key=sorter), sorter))]
             else:
                 c.pull_request_pending_reviewers.append(o.user)
             c.pull_request_reviewers.append([o.user, st])
 
         # 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
         enable_comments = not c.pull_request.is_closed()
         self._load_compare_data(c.pull_request, enable_comments=enable_comments)
 
         # inline comments
         c.inline_cnt = 0
         c.inline_comments = cc_model.get_inline_comments(
                                 c.rhodecode_db_repo.repo_id,
                                 pull_request=pull_request_id)
         # count inline comments
         for __, lines in c.inline_comments:
             for comments in lines.values():
                 c.inline_cnt += len(comments)
         # comments
         c.comments = cc_model.get_comments(c.rhodecode_db_repo.repo_id,
                                            pull_request=pull_request_id)
 
-        # changeset(pull-request) status calulation based on reviewers
+        # (badly named) pull-request status calculation based on reviewer votes
         c.current_changeset_status = cs_model.calculate_status(
                                         c.pull_request_reviewers,
                                          )
         c.changeset_statuses = ChangesetStatus.STATUSES
 
         c.as_form = False
         c.ancestor = None # there is one - but right here we don't know which
         return render('/pullrequests/pullrequest_show.html')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def comment(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
 
         status = request.POST.get('changeset_status')
         change_status = request.POST.get('change_changeset_status')
         text = request.POST.get('text')
         close_pr = request.POST.get('save_close')
 
         allowed_to_change_status = self._get_is_allowed_change_status(pull_request)
         if status and change_status and allowed_to_change_status:
             _def = (_('Status change -> %s')
                             % ChangesetStatus.get_status_lbl(status))
             if close_pr:
                 _def = _('Closing with') + ' ' + _def
             text = text or _def
         comm = ChangesetCommentsModel().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 change_status
                            and allowed_to_change_status else None),
             closing_pr=close_pr
         )
 
         action_logger(self.rhodecode_user,
                       'user_commented_pull_request:%s' % pull_request_id,
                       c.rhodecode_db_repo, self.ip_addr, self.sa)
 
         if allowed_to_change_status:
             # get status if set !
             if status and change_status:
                 ChangesetStatusModel().set_status(
                     c.rhodecode_db_repo.repo_id,
                     status,
                     c.rhodecode_user.user_id,
                     comm,
                     pull_request=pull_request_id
                 )
 
             if close_pr:
                 if status in ['rejected', 'approved']:
                     PullRequestModel().close_pull_request(pull_request_id)
                     action_logger(self.rhodecode_user,
                               'user_closed_pull_request:%s' % pull_request_id,
                               c.rhodecode_db_repo, self.ip_addr, self.sa)
                 else:
                     h.flash(_('Closing pull request on other statuses than '
                               'rejected or approved forbidden'),
                             category='warning')
 
         Session().commit()
 
         if not request.environ.get('HTTP_X_PARTIAL_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
             data.update(comm.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.html')})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         co = ChangesetComment.get(comment_id)
         if co.pull_request.is_closed():
             #don't allow deleting comments on closed pull request
             raise HTTPForbidden()
 
         owner = co.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             ChangesetCommentsModel().delete(comment=co)
             Session().commit()
             return True
         else:
             raise HTTPForbidden()

rhodecode/model/changeset_status.py

@@ -1,193 +1,193 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.changeset_status
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
     :created_on: Apr 30, 2012
     :author: marcink
     :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 
 
 import logging
 from collections import  defaultdict
 
 from rhodecode.model import BaseModel
 from rhodecode.model.db import ChangesetStatus, PullRequest
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 
 log = logging.getLogger(__name__)
 
 
 class ChangesetStatusModel(BaseModel):
 
     cls = ChangesetStatus
 
     def __get_changeset_status(self, changeset_status):
         return self._get_instance(ChangesetStatus, changeset_status)
 
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
 
     def _get_status_query(self, repo, revision, pull_request,
                           with_revisions=False):
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == repo)
         if not with_revisions:
             q = q.filter(ChangesetStatus.version == 0)
 
         if revision:
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetStatus.pull_request == pull_request)
         else:
             raise Exception('Please specify revision or pull_request')
         q.order_by(ChangesetStatus.version.asc())
         return q
 
     def calculate_status(self, statuses_by_reviewers):
         """
-        leading one wins, if number of occurrences are equal than weaker wins
+        approved if consensus
+        (old description: leading one wins, if number of occurrences are equal than weaker wins)
 
         :param statuses_by_reviewers:
         """
-        status = None
         votes = defaultdict(int)
         reviewers_number = len(statuses_by_reviewers)
         for user, statuses in statuses_by_reviewers:
             if statuses:
                 ver, latest = statuses[0]
                 votes[latest.status] += 1
             else:
                 votes[ChangesetStatus.DEFAULT] += 1
 
         if votes.get(ChangesetStatus.STATUS_APPROVED) == reviewers_number:
             return ChangesetStatus.STATUS_APPROVED
         else:
             return ChangesetStatus.STATUS_UNDER_REVIEW
 
     def get_statuses(self, repo, revision=None, pull_request=None,
                      with_revisions=False):
         q = self._get_status_query(repo, revision, pull_request,
                                    with_revisions)
         return q.all()
 
     def get_status(self, repo, revision=None, pull_request=None, as_str=True):
         """
         Returns latest status of changeset for given revision or for given
         pull request. Statuses are versioned inside a table itself and
         version == 0 is always the current one
 
         :param repo:
         :param revision: 40char hash or None
         :param pull_request: pull_request reference
         :param as_str: return status as string not object
         """
         q = self._get_status_query(repo, revision, pull_request)
 
         # need to use first here since there can be multiple statuses
         # returned from pull_request
         status = q.first()
         if as_str:
             status = status.status if status else status
             st = status or ChangesetStatus.DEFAULT
             return str(st)
         return status
 
     def set_status(self, repo, status, user, comment=None, revision=None,
                    pull_request=None, dont_allow_on_closed_pull_request=False):
         """
         Creates new status for changeset or updates the old ones bumping their
         version, leaving the current status at
 
         :param repo:
         :param revision:
         :param status:
         :param user:
         :param comment:
         :param dont_allow_on_closed_pull_request: don't allow a status change
             if last status was for pull request and it's closed. We shouldn't
             mess around this manually
         """
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()
         if not comment:
             from rhodecode.model.comment import ChangesetCommentsModel
             comment = ChangesetCommentsModel().create(
                 text='Auto status change to %s' % (ChangesetStatus.get_status_lbl(status)),
                 repo=repo,
                 user=user,
                 pull_request=pull_request,
                 send_email=False
             )
         if revision:
             q = q.filter(ChangesetStatus.repo == repo)
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetStatus.repo == pull_request.org_repo)
             q = q.filter(ChangesetStatus.revision.in_(pull_request.revisions))
         cur_statuses = q.all()
 
         #if statuses exists and last is associated with a closed pull request
         # we need to check if we can allow this status change
         if (dont_allow_on_closed_pull_request and cur_statuses
             and getattr(cur_statuses[0].pull_request, 'status', '')
                 == PullRequest.STATUS_CLOSED):
             raise StatusChangeOnClosedPullRequestError(
                 'Changing status on closed pull request is not allowed'
             )
 
         #update all current statuses with older version
         if cur_statuses:
             for st in cur_statuses:
                 st.version += 1
                 self.sa.add(st)
 
         def _create_status(user, repo, status, comment, revision, pull_request):
             new_status = ChangesetStatus()
             new_status.author = self._get_user(user)
             new_status.repo = self._get_repo(repo)
             new_status.status = status
             new_status.comment = comment
             new_status.revision = revision
             new_status.pull_request = pull_request
             return new_status
 
         if revision:
             new_status = _create_status(user=user, repo=repo, status=status,
                            comment=comment, revision=revision,
                            pull_request=None)
             self.sa.add(new_status)
             return new_status
         elif pull_request:
             #pull request can have more than one revision associated to it
             #we need to create new version for each one
             new_statuses = []
             repo = pull_request.org_repo
             for rev in pull_request.revisions:
                 new_status = _create_status(user=user, repo=repo,
                                             status=status, comment=comment,
                                             revision=rev,
                                             pull_request=pull_request)
                 new_statuses.append(new_status)
                 self.sa.add(new_status)
             return new_statuses

rhodecode/templates/pullrequests/pullrequest_show.html

@@ -1,257 +1,257 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Pull Request #%s') % (c.repo_name, c.pull_request.pull_request_id)} &middot; ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('repositories')}
 </%def>
 
 <%def name="main()">
 ${self.repo_context_bar('showpullrequest')}
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     <h3 class="${'closed' if c.pull_request.is_closed() else ''}">
         <img src="${h.url('/images/icons/flag_status_%s.png' % str(c.pull_request.last_review_status))}" />
         ${_('Title')}: ${c.pull_request.title}
         %if c.pull_request.is_closed():
             (${_('Closed')})
         %endif
     </h3>
 
     <div class="form">
       <div id="summary" class="fields">
          <div class="field">
           <div class="label-summary">
               <label>${_('Review status')}:</label>
           </div>
           <div class="input">
             <div class="changeset-status-container" style="float:none;clear:both">
             %if c.current_changeset_status:
-              <div title="${_('Pull request status')}" class="changeset-status-lbl">
+              <div title="${_('Pull request status calculated from votes')}" class="changeset-status-lbl">
                 %if c.pull_request.is_closed():
                     ${_('Closed')},
                 %endif
                 ${h.changeset_status_lbl(c.current_changeset_status)}
               </div>
-              <div class="changeset-status-ico" style="padding:1px 4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>
+              <div class="changeset-status-ico" style="padding:1px 4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" title="${_('Pull request status calculated from votes')}"/></div>
             %endif
             </div>
           </div>
          </div>
          <div class="field">
           <div class="label-summary">
               <label>${_('Still not reviewed by')}:</label>
           </div>
           <div class="input">
             % if len(c.pull_request_pending_reviewers) > 0:
                 <div class="tooltip" title="${h.tooltip(', '.join([x.username for x in c.pull_request_pending_reviewers]))}">${ungettext('%d reviewer', '%d reviewers',len(c.pull_request_pending_reviewers)) % len(c.pull_request_pending_reviewers)}</div>
             %else:
                 <div>${_('Pull request was reviewed by all reviewers')}</div>
             %endif
           </div>
          </div>
          <div class="field">
           <div class="label-summary">
               <label>${_('Origin repository')}:</label>
           </div>
           <div class="input">
               <div>
              ##%if h.is_hg(c.pull_request.org_repo):
              ##  <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url('/images/icons/hgicon.png')}"/>
              ##%elif h.is_git(c.pull_request.org_repo):
              ##  <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url('/images/icons/giticon.png')}"/>
              ##%endif
               <span class="spantag">${c.pull_request.org_ref_parts[0]}: ${c.pull_request.org_ref_parts[1]}</span>
               <span>
                %if h.is_hg(c.pull_request.org_repo):
                  | ${_('Pull changes')} <span style="font-family: monospace">hg pull -r ${h.short_id(c.cs_ranges[-1].raw_id)} <a href="${h.url('summary_home', repo_name=c.pull_request.org_repo.repo_name)}">${c.pull_request.org_repo.clone_url()}</a></span>
                %elif h.is_git(c.pull_request.org_repo):
                  | ${_('Pull changes')}
                %endif
               </div>
           </div>
          </div>
          <div class="field">
           <div class="label-summary">
               <label>${_('Description')}:</label>
           </div>
           <div class="input">
               <div style="white-space:pre-wrap">${h.urlify_commit(c.pull_request.description)}</div>
           </div>
          </div>
          <div class="field">
           <div class="label-summary">
               <label>${_('Created on')}:</label>
           </div>
           <div class="input">
               <div>${h.fmt_date(c.pull_request.created_on)}</div>
           </div>
          </div>
       </div>
     </div>
 
     <div style="overflow: auto;">
       ##DIFF
       <div class="table" style="float:left;clear:none">
           <div id="body" class="diffblock">
               <div style="white-space:pre-wrap;padding:5px">${_('Compare view')}</div>
           </div>
           <div id="changeset_compare_view_content">
               ##CS
               <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${ungettext('Showing %s commit','Showing %s commits', len(c.cs_ranges)) % len(c.cs_ranges)}</div>
               <%include file="/compare/compare_cs.html" />
 
               ## FILES
               <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">
 
               % if c.limited_diff:
                   ${ungettext('%s file changed', '%s files changed', len(c.files)) % len(c.files)}
               % else:
                   ${ungettext('%s file changed with %s insertions and %s deletions','%s files changed with %s insertions and %s deletions', len(c.files)) % (len(c.files),c.lines_added,c.lines_deleted)}:
               %endif
 
               </div>
               <div class="cs_files">
                 %if not c.files:
                    <span class="empty_data">${_('No files')}</span>
                 %endif
                 %for fid, change, f, stat in c.files:
                     <div class="cs_${change}">
                       <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>
                       <div class="changes">${h.fancy_file_stats(stat)}</div>
                     </div>
                 %endfor
               </div>
               % if c.limited_diff:
                 <h5>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a huge diff might take some time and resources")}')">${_('Show full diff')}</a></h5>
               % endif
           </div>
       </div>
       ## REVIEWERS
        <div style="float:left; border-left:1px dashed #eee">
        <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 5px 10px">
           ## members goes here !
           <div class="group_members_wrap" style="min-height:45px">
             <ul id="review_members" class="group_members">
             %for member,status in c.pull_request_reviewers:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                     <div style="float:left;padding:0px 3px 0px 0px" class="tooltip" title="${h.tooltip(h.changeset_status_lbl(status[0][1].status if status else 'not_reviewed'))}">
                       <img src="${h.url(str('/images/icons/flag_status_%s.png' % (status[0][1].status if status else 'not_reviewed')))}"/>
                     </div>
                   <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>
                   <div style="float:left">${member.full_name} (${_('owner') if c.pull_request.user_id == member.user_id else _('reviewer')})</div>
                   <input type="hidden" value="${member.user_id}" name="review_members" />
                   %if not c.pull_request.is_closed() and (h.HasPermissionAny('hg.admin', 'repository.admin')() or c.pull_request.user_id == c.rhodecode_user.user_id):
                   <span class="delete_icon action_button" onclick="removeReviewMember(${member.user_id})"></span>
                   %endif
                 </div>
               </li>
             %endfor
             </ul>
           </div>
           %if not c.pull_request.is_closed():
           <div class='ac'>
             %if h.HasPermissionAny('hg.admin', 'repository.admin')() or c.pull_request.author.user_id == c.rhodecode_user.user_id:
             <div class="reviewer_ac">
                ${h.text('user', class_='yui-ac-input')}
                <span class="help-block">${_('Add or remove reviewer to this pull request.')}</span>
                <div id="reviewers_container"></div>
             </div>
             <div style="padding:0px 10px">
              <span id="update_pull_request" class="ui-btn xsmall">${_('Save changes')}</span>
             </div>
             %endif
           </div>
           %endif
         </div>
        </div>
     </div>
     <script>
     var _USERS_AC_DATA = ${c.users_array|n};
     var _GROUPS_AC_DATA = ${c.users_groups_array|n};
     // TODO: switch this to pyroutes
     AJAX_COMMENT_URL = "${url('pullrequest_comment',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id)}";
     AJAX_COMMENT_DELETE_URL = "${url('pullrequest_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
 
     pyroutes.register('pullrequest_comment', "${url('pullrequest_comment',repo_name='%(repo_name)s',pull_request_id='%(pull_request_id)s')}", ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_delete', "${url('pullrequest_comment_delete',repo_name='%(repo_name)s',comment_id='%(comment_id)s')}", ['repo_name', 'comment_id']);
     pyroutes.register('pullrequest_update', "${url('pullrequest_update',repo_name='%(repo_name)s',pull_request_id='%(pull_request_id)s')}", ['repo_name', 'pull_request_id']);
 
     </script>
 
     ## diff block
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     %for fid, change, f, stat in c.files:
       ${diff_block.diff_block_simple([c.changes[fid]])}
     %endfor
     % if c.limited_diff:
       <h4>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a huge diff might take some time and resources")}')">${_('Show full diff')}</a></h4>
     % endif
 
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
 
     ## render comments and inlines
     ${comment.generate_comments(include_pr=True)}
 
     % if not c.pull_request.is_closed():
       ## main comment form and it status
       ${comment.comments(h.url('pullrequest_comment', repo_name=c.repo_name,
                                 pull_request_id=c.pull_request.pull_request_id),
                          c.current_changeset_status,
                          is_pr=True, change_status=c.allowed_to_change_status)}
     %endif
 
     <script type="text/javascript">
       YUE.onDOMReady(function(){
           PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
           YUE.on(YUQ('.show-inline-comments'),'change',function(e){
               var show = 'none';
               var target = e.currentTarget;
               if(target.checked){
                   var show = ''
               }
               var boxid = YUD.getAttribute(target,'id_for');
               var comments = YUQ('#{0} .inline-comments'.format(boxid));
               for(c in comments){
                  YUD.setStyle(comments[c],'display',show);
               }
               var btns = YUQ('#{0} .inline-comments-button'.format(boxid));
               for(c in btns){
                   YUD.setStyle(btns[c],'display',show);
                }
           })
 
           YUE.on(YUQ('.line'),'click',function(e){
               var tr = e.currentTarget;
               injectInlineForm(tr);
           });
 
           // inject comments into they proper positions
           var file_comments = YUQ('.inline-comment-placeholder');
           renderInlineComments(file_comments);
 
           YUE.on(YUD.get('update_pull_request'),'click',function(e){
               updateReviewers(undefined, "${c.repo_name}", "${c.pull_request.pull_request_id}");
           })
       })
     </script>
 
 </div>
 
 </%def>