"""The base Controller API

Provides the BaseController class for subclassing.

"""

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden

from paste.httpheaders import WWW_AUTHENTICATE, AUTHORIZATION

from pylons import config, tmpl_context as c, request, session, url

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict,\

    safe_str, safe_int

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.db import Repository, RhodeCodeUi, User, RhodeCodeSetting

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

def _filter_proxy(ip):

    """

    client, and each successive proxy that passed the request adding the IP

    address where it received the request from.

    :param ip:

    """

    if ',' in ip:

        _ips = ip.split(',')

        _first_ip = _ips[0].strip()

        log.debug('Got multiple IPs %s, using %s' % (','.join(_ips), _first_ip))

        return _first_ip

    return ip

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

    ip = environ.get(proxy_key)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(proxy_key2)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(def_key, '0.0.0.0')

    return _filter_proxy(ip)

def _get_access_path(environ):

    path = environ.get('PATH_INFO')

    org_req = environ.get('pylons.original_request')

    if org_req:

        path = org_req.environ.get('PATH_INFO')

    return path

class BasicAuth(AuthBasicAuthenticator):

    def __init__(self, realm, authfunc, auth_http_code=None):

        self.realm = realm

        self.authfunc = authfunc

        self._rc_auth_http_code = auth_http_code

    def build_authentication(self):

        head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)

        if self._rc_auth_http_code and self._rc_auth_http_code == '403':

            # return 403 if alternative http return code is specified in

            # RhodeCode config

            return HTTPForbidden(headers=head)

        return HTTPUnauthorized(headers=head)

    def authenticate(self, environ):

        authorization = AUTHORIZATION(environ)

        if not authorization:

            return self.build_authentication()

        (authmeth, auth) = authorization.split(' ', 1)

        if 'basic' != authmeth.lower():

            return self.build_authentication()

        auth = auth.strip().decode('base64')

        _parts = auth.split(':', 1)

        if len(_parts) == 2:

            username, password = _parts

            if self.authfunc(environ, username, password):

                return username

        return self.build_authentication()

    __call__ = authenticate

class BaseVCSController(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        # base path of repo locations

        self.basepath = self.config['base_path']

        #authenticate this mercurial request using authfunc

        self.authenticate = BasicAuth('', authfunc,

                                      config.get('auth_ret_code'))

        self.ip_addr = '0.0.0.0'

    def _handle_request(self, environ, start_response):

        raise NotImplementedError()

    def _get_by_id(self, repo_name):

        """

        Get's a special pattern _<ID> from clone url and tries to replace it

        with a repository_name for support of _<ID> non changable urls

        :param repo_name:

        """

        try:

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

        except Exception:

            log.debug('Failed to extract repo_name from id %s' % (

                      traceback.format_exc()

                      )

            )

        return '/'.join(data)

    def _invalidate_cache(self, repo_name):

        """

        Set's cache for this repository for invalidation on next access

        :param repo_name: full repo name, also a cache key

        """

        ScmModel().mark_for_invalidation(repo_name)

    def _check_permission(self, action, user, repo_name, ip_addr=None):

        """

        Checks permissions using action (push/pull) user and repository

        name

        :param action: push or pull action

        :param user: user instance

        :param repo_name: repository name

        """

        #check IP

        authuser = AuthUser(user_id=user.user_id, ip_addr=ip_addr)

        if not authuser.ip_allowed:

            return False

        else:

            log.info('Access for IP:%s allowed' % (ip_addr))

        if action == 'push':

            if not HasPermissionAnyMiddleware('repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        else:

            #any other action need at least read permission

            if not HasPermissionAnyMiddleware('repository.read',

                                              'repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        return True

    def _get_ip_addr(self, environ):

        return _get_ip_addr(environ)

    def _check_ssl(self, environ, start_response):

        """

        Checks the SSL check flag and returns False if SSL is not present

        and required True otherwise

        """

        org_proto = environ['wsgi._org_proto']

        #check if we have SSL required  ! if not it's a bad request !

        require_ssl = str2bool(RhodeCodeUi.get_by_key('push_ssl').ui_value)

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

            return False

        return True

    def _check_locking_state(self, environ, action, repo, user_id):

        """

        Checks locking on this repository, if locking is enabled and lock is

        present returns a tuple of make_lock, locked, locked_by.

        make_lock can have 3 states None (do nothing) True, make lock

        False release lock, This value is later propagated to hooks, which

        do the locking. Think about this as signals passed to hooks what to do.

        """

        locked = False  # defines that locked error should be thrown to user

        make_lock = None

        repo = Repository.get_by_repo_name(repo)

        user = User.get(user_id)

        # this is kind of hacky, but due to how mercurial handles client-server

        # server see all operation on changeset; bookmarks, phases and

        # obsolescence marker in different transaction, we don't want to check

        # locking on those

        obsolete_call = environ['QUERY_STRING'] in ['cmd=listkeys',]

        locked_by = repo.locked

        if repo and repo.enable_locking and not obsolete_call:

            if action == 'push':

                #check if it's already locked !, if it is compare users

                user_id, _date = repo.locked

                if user.user_id == user_id:

                    log.debug('Got push from user %s, now unlocking' % (user))

                    # unlock if we have push from user who locked

                    make_lock = False

# -*- coding: utf-8 -*-

"""

    rhodecode.lib.paster_commands.make_rcextensions

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

    repo-scan paster command for RhodeCode

    :created_on: Feb 9, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

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

from __future__ import with_statement

import os

import sys

import logging

from rhodecode.model.scm import ScmModel

from rhodecode.lib.utils import BasePasterCommand, repo2db_mapper

# fix rhodecode import

from os.path import dirname as dn

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Rescan default location for new repositories"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        rm_obsolete = self.options.delete_obsolete

        log.info('Now scanning root location for new repos...')

        added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                        remove_obsolete=rm_obsolete)

    def update_parser(self):

        self.parser.add_option('--delete-obsolete',

                          action='store_true',

                          help="Use this flag do delete repositories that are "

                          "present in RhodeCode database but not on the filesystem",

                          )

"""

Utitlites aimed to help achieve mostly basic tasks.

"""

from __future__ import division

import re

import os

import time

import datetime

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.paths import abspath

ALIASES = ['hg', 'git']

def get_scm(path, search_up=False, explicit_alias=None):

    """

    Returns one of alias from ``ALIASES`` (in order of precedence same as

    shortcuts given in ``ALIASES``) and top working dir path for the given

    argument. If no scm-specific directory is found or more than one scm is

    found at that directory, ``VCSError`` is raised.

    :param search_up: if set to ``True``, this function would try to

      move up to parent directory every time no scm is recognized for the

      currently checked path. Default: ``False``.

    :param explicit_alias: can be one of available backend aliases, when given

      it will return given explicit alias in repositories under more than one

      version control, if explicit_alias is different than found it will raise

      VCSError

    """

    if not os.path.isdir(path):

        raise VCSError("Given path %s is not a directory" % path)

    def get_scms(path):

        return [(scm, path) for scm in get_scms_for_path(path)]

    found_scms = get_scms(path)

    while not found_scms and search_up:

        newpath = abspath(path, '..')

        if newpath == path:

            break

        path = newpath

        found_scms = get_scms(path)

    if len(found_scms) > 1:

        for scm in found_scms:

            if scm[0] == explicit_alias:

                return scm

        raise VCSError('More than one [%s] scm found at given path %s'

    if len(found_scms) is 0:

        raise VCSError('No scm found at given path %s' % path)

    return found_scms[0]

def get_scms_for_path(path):

    """

    Returns all scm's found at the given path. If no scm is recognized

    - empty list is returned.

    :param path: path to directory which should be checked. May be callable.

    :raises VCSError: if given ``path`` is not a directory

    """

    from rhodecode.lib.vcs.backends import get_backend

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        raise VCSError("Given path %r is not a directory" % path)

    result = []

    for key in ALIASES:

        dirname = os.path.join(path, '.' + key)

        if os.path.isdir(dirname):

            result.append(key)

            continue

        dirname = os.path.join(path, 'rm__.' + key)

        if os.path.isdir(dirname):

            return result

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            get_backend(key)(path)

            result.append(key)

            continue

        except RepositoryError:

            # Wrong backend

            pass

        except VCSError:

            # No backend at all

            pass

    return result

def run_command(cmd, *args):

    """

    Runs command on the system with given ``args``.

    """

    command = ' '.join((cmd, args))

    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)

    stdout, stderr = p.communicate()

    return p.retcode, stdout, stderr

def get_highlighted_code(name, code, type='terminal'):

    """

    If pygments are available on the system

    then returned output is colored. Otherwise

    unchanged content is returned.

    """

    import logging

    try:

        import pygments

        pygments

    except ImportError:

        return code

    from pygments import highlight

    from pygments.lexers import guess_lexer_for_filename, ClassNotFound

    from pygments.formatters import TerminalFormatter

    try:

        lexer = guess_lexer_for_filename(name, code)

        formatter = TerminalFormatter()

        content = highlight(code, lexer, formatter)

    except ClassNotFound:

        logging.debug("Couldn't guess Lexer, will not use pygments.")

        content = code

    return content

def parse_changesets(text):

    """

    Returns dictionary with *start*, *main* and *end* ids.

    Examples::

        >>> parse_changesets('aaabbb')

        {'start': None, 'main': 'aaabbb', 'end': None}

        >>> parse_changesets('aaabbb..cccddd')

        {'start': 'aaabbb', 'main': None, 'end': 'cccddd'}

    """

    text = text.strip()

    CID_RE = r'[a-zA-Z0-9]+'

    if not '..' in text:

        m = re.match(r'^(?P<cid>%s)$' % CID_RE, text)

        if m:

            return {

                'start': None,

                'main': text,

                'end': None,

            }

    else:

        RE = r'^(?P<start>%s)?\.{2,3}(?P<end>%s)?$' % (CID_RE, CID_RE)

        m = re.match(RE, text)

        if m:

            result = m.groupdict()

            result['main'] = None

            return result

    raise ValueError("IDs not recognized")

def parse_datetime(text):

    """

    Parses given text and returns ``datetime.datetime`` instance or raises

    ``ValueError``.

    :param text: string of desired date/datetime or something more verbose,

      like *yesterday*, *2weeks 3days*, etc.

    """

    text = text.strip().lower()

    INPUT_FORMATS = (

        '%Y-%m-%d %H:%M:%S',

        '%Y-%m-%d %H:%M',

        '%Y-%m-%d',

        '%m/%d/%Y %H:%M:%S',

        '%m/%d/%Y %H:%M',

        '%m/%d/%Y',

        '%m/%d/%y %H:%M:%S',

        '%m/%d/%y %H:%M',

        '%m/%d/%y',

    )

    for format in INPUT_FORMATS:

        try:

            return datetime.datetime(*time.strptime(text, format)[:6])

        except ValueError:

            pass

    # Try descriptive texts

    if text == 'tomorrow':

        future = datetime.datetime.now() + datetime.timedelta(days=1)

        args = future.timetuple()[:3] + (23, 59, 59)

        return datetime.datetime(*args)

    elif text == 'today':

        return datetime.datetime(*datetime.datetime.today().timetuple()[:3])

    elif text == 'now':

        return datetime.datetime.now()

    elif text == 'yesterday':

        past = datetime.datetime.now() - datetime.timedelta(days=1)

        return datetime.datetime(*past.timetuple()[:3])

    else:

        days = 0

        matched = re.match(

            r'^((?P<weeks>\d+) ?w(eeks?)?)? ?((?P<days>\d+) ?d(ays?)?)?$', text)

        if matched:

            groupdict = matched.groupdict()

            if groupdict['days']:

                days += int(matched.groupdict()['days'])

            if groupdict['weeks']:

                days += int(matched.groupdict()['weeks']) * 7

            past = datetime.datetime.now() - datetime.timedelta(days=days)

            return datetime.datetime(*past.timetuple()[:3])

    raise ValueError('Wrong date: "%s"' % text)

def get_dict_for_attrs(obj, attrs):

    """

    Returns dictionary for each attribute from given ``obj``.

    """

    data = {}

    for attr in attrs:

        data[attr] = getattr(obj, attr)

    return data

def get_total_seconds(timedelta):

    """

    Backported for Python 2.5.

    See http://docs.python.org/library/datetime.html.

    """

    return ((timedelta.microseconds + (

            timedelta.seconds +

            timedelta.days * 24 * 60 * 60

        ) * 10**6) / 10**6)

<%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.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">

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

            %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:

            %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><a href="${h.url('summary_home', repo_name=c.pull_request.org_repo.repo_name)}">${c.pull_request.org_repo.clone_url()}</a></span>

              </div>

          </div>

         </div>

         <div class="field">

          <div class="label-summary">

              <label>${_('Description')}:</label>

          </div>

          <div class="input">

              <div style="white-space:pre-wrap">${h.literal(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,

                                close_btn=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>