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)

        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)

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

        """

        :param statuses_by_reviewers:

        """

        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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('%s Pull Request #%s') % (c.repo_name, c.pull_request.pull_request_id)} · ${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:

                %if c.pull_request.is_closed():

                    ${_('Closed')},

                %endif

                ${h.changeset_status_lbl(c.current_changeset_status)}

              </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>