data.update(comment.get_dict())

        data.update({'rendered_text':

                     render('changeset/changeset_comment_block.html')})

    return data

def delete_cs_pr_comment(repo_name, comment_id):

    """Delete a comment from a changeset or pull request"""

    co = ChangesetComment.get_or_404(comment_id)

    if co.repo.repo_name != repo_name:

        raise HTTPNotFound()

    if co.pull_request and co.pull_request.is_closed():

        # don't allow deleting comments on closed pull request

        raise HTTPForbidden()

    owner = co.author_id == request.authuser.user_id

    repo_admin = h.HasRepoPermissionLevel('admin')(repo_name)

    if h.HasPermissionAny('hg.admin')() or repo_admin or owner:

        ChangesetCommentsModel().delete(comment=co)

        Session().commit()

        return True

    else:

        raise HTTPForbidden()

class ChangesetController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(ChangesetController, self)._before(*args, **kwargs)

        c.affected_files_cut_off = 60

    def _index(self, revision, method):

        c.pull_request = None

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = request.GET.get('fulldiff') # for reporting number of changed files

        # get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.db_repo_scm_instance.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (ChangesetDoesNotExistError, EmptyRepositoryError):

            log.debug(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        comments = dict()

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.db_repo.repo_id, changeset.raw_id)])

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.comment_id is not None)

                inlines = ChangesetCommentsModel() \

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            raw_diff = diffs.get_diff(c.db_repo_scm_instance, cs1, cs2,

            diff_limit = None if c.fulldiff else self.cut_off_limit

            file_diff_data = []

            if method == 'show':

                diff_processor = diffs.DiffProcessor(raw_diff,

                                                     vcs=c.db_repo_scm_instance.alias,

                                                     diff_limit=diff_limit)

                c.limited_diff = diff_processor.limited_diff

                for f in diff_processor.parsed:

                    st = f['stats']

                    c.lines_added += st['added']

                    c.lines_deleted += st['deleted']

                    filename = f['filename']

                    fid = h.FID(changeset.raw_id, filename)

                    url_fid = h.FID('', filename)

                    html_diff = diffs.as_html(enable_comments=enable_comments, parsed_lines=[f])

                    file_diff_data.append((fid, url_fid, f['operation'], f['old_filename'], filename, html_diff, st))

            else:

                # downloads/raw we only need RAW diff nothing else

                file_diff_data.append(('', None, None, None, raw_diff, None))

            c.changes[changeset.raw_id] = (cs1, cs2, file_diff_data)

        # sort comments in creation order

        c.comments = [com for com_id, com in sorted(comments.items())]

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

            c.changeset_graft_source_hash = ascii_str(c.changeset.extra.get(b'source', b''))

            c.changeset_transplant_source_hash = ascii_str(binascii.hexlify(c.changeset.extra.get(b'transplant_source', b'')))

        if method == 'download':

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s.diff' \

                                            % revision[:12]

            return raw_diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_str(raw_diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return raw_diff

        elif method == 'show':

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                c.cs_ranges_org = None

                c.cs_comments = {}

                revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

                c.jsdata = graph_data(c.db_repo_scm_instance, revs)

                return render('changeset/changeset_range.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, revision, method='show'):

        return self._index(revision, method=method)

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_raw(self, revision):

        return self._index(revision, method='raw')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_patch(self, revision):

        return self._index(revision, method='patch')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changeset_download(self, revision):

        return self._index(revision, method='download')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, revision):

        return create_cs_pr_comment(repo_name, revision=revision)

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        return delete_cs_pr_comment(repo_name, comment_id)

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def changeset_info(self, repo_name, revision):

        if request.is_xhr:

            try:

                return c.db_repo_scm_instance.get_changeset(revision)

            other_changesets = [

                other_repo.get_changeset(rev)

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                    ascii_bytes(other_rev), ascii_bytes(org_rev), ascii_bytes(org_rev))

            ]

            org_changesets = [

                org_repo.get_changeset(ascii_str(hgrepo[rev].hex()))

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                    ascii_bytes(org_rev), ascii_bytes(other_rev), ascii_bytes(other_rev))

            ]

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(org_repo.path, gitrepo_remote)

                revs = [

                    ascii_str(x.commit.id)

                    for x in gitrepo_remote.get_walker(include=[ascii_bytes(other_rev)],

                                                       exclude=[ascii_bytes(org_rev)])

                ]

                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

                if other_changesets:

                    ancestors = [other_changesets[0].parents[0].raw_id]

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()

            else:

                so = org_repo.run_git_command(

                    ['log', '--reverse', '--pretty=format:%H',

                     '-s', '%s..%s' % (org_rev, other_rev)]

                )

                other_changesets = [org_repo.get_changeset(cs)

                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

                so = org_repo.run_git_command(

                    ['merge-base', org_rev, other_rev]

                )

                ancestors = [re.findall(r'[0-9a-fA-F]{40}', so)[0]]

            org_changesets = []

        else:

            raise Exception('Bad alias only git and hg is allowed')

        return other_changesets, org_changesets, ancestors

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        c.compare_home = True

        c.a_ref_name = c.cs_ref_name = None

        return render('compare/compare_diff.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def compare(self, repo_name, org_ref_type, org_ref_name, other_ref_type, other_ref_name):

        org_ref_name = org_ref_name.strip()

        other_ref_name = other_ref_name.strip()

        # If merge is True:

        #   Show what org would get if merged with other:

        #   List changesets that are ancestors of other but not of org.

        #   New changesets in org is thus ignored.

        #   Diff will be from common ancestor, and merges of org to other will thus be ignored.

        # If merge is False:

        #   Make a raw diff from org to other, no matter if related or not.

        #   Changesets in one and not in the other will be ignored

        merge = bool(request.GET.get('merge'))

        # fulldiff disables cut_off_limit

        fulldiff = request.GET.get('fulldiff')

        # partial uses compare_cs.html template directly

        partial = request.environ.get('HTTP_X_PARTIAL_XHR')

        # is_ajax_preview puts hidden input field with changeset revisions

        c.is_ajax_preview = partial and request.GET.get('is_ajax_preview')

        # swap url for compare_diff page - never partial and never is_ajax_preview

        c.swap_url = h.url('compare_url',

            repo_name=c.cs_repo.repo_name,

            org_ref_type=other_ref_type, org_ref_name=other_ref_name,

            other_repo=c.a_repo.repo_name,

            other_ref_type=org_ref_type, other_ref_name=org_ref_name,

            merge=merge or '')

        # set callbacks for generating markup for icons

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.a_rev = self._get_ref_rev(c.a_repo, org_ref_type, org_ref_name,

            returnempty=True)

        c.cs_rev = self._get_ref_rev(c.cs_repo, other_ref_type, other_ref_name)

        c.compare_home = False

        c.a_ref_name = org_ref_name

        c.a_ref_type = org_ref_type

        c.cs_ref_name = other_ref_name

        c.cs_ref_type = other_ref_type

        c.cs_ranges, c.cs_ranges_org, c.ancestors = self._get_changesets(

            c.a_repo.scm_instance.alias, c.a_repo.scm_instance, c.a_rev,

            c.cs_repo.scm_instance, c.cs_rev)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(c.cs_repo.scm_instance, revs)

        if partial:

            return render('compare/compare_cs.html')

        org_repo = c.a_repo

        other_repo = c.cs_repo

        if merge:

            rev1 = msg = None

            if not c.cs_ranges:

                msg = _('Cannot show empty diff')

            elif not c.ancestors:

                msg = _('No ancestor found for merge diff')

            elif len(c.ancestors) == 1:

                rev1 = c.ancestors[0]

            else:

                msg = _('Multiple merge ancestors found for merge compare')

            if rev1 is None:

                h.flash(msg, category='error')

                log.error(msg)

                raise HTTPNotFound

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the other repo (which is known to have other_rev)

            log.debug('Using ancestor %s as rev1 instead of %s',

                      rev1, c.a_rev)

            org_repo = other_repo

        else: # comparing tips, not necessarily linearly related

            if org_repo != other_repo:

                # TODO: we could do this by using hg unionrepo

                log.error('cannot compare across repos %s and %s', org_repo, other_repo)

                h.flash(_('Cannot compare repositories without using common ancestor'), category='error')

                raise HTTPBadRequest

            rev1 = c.a_rev

        diff_limit = None if fulldiff else self.cut_off_limit

        log.debug('running diff between %s and %s in %s',

                  rev1, c.cs_rev, org_repo.scm_instance.path)

        raw_diff = diffs.get_diff(org_repo.scm_instance, rev1=rev1, rev2=c.cs_rev,

        diff_processor = diffs.DiffProcessor(raw_diff, diff_limit=diff_limit)

        c.limited_diff = diff_processor.limited_diff

        c.file_diff_data = []

        c.lines_added = 0

        c.lines_deleted = 0

        for f in diff_processor.parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            html_diff = diffs.as_html(enable_comments=False, parsed_lines=[f])

            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))

        return render('compare/compare_diff.html')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            raise HTTPFound(location=url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_add.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        subrepos = request.GET.get('subrepos') == 'true'

        for a_type, ext_data in settings.ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            dbrepo = RepoModel().get_by_repo_name(repo_name)

            if not dbrepo.enable_downloads:

                return _('Downloads disabled') # TODO: do something else?

            if c.db_repo_scm_instance.alias == 'hg':

                # patch and reset hooks section of UI config to not run any

                # hooks on fetching archives with subrepos

                for k, v in c.db_repo_scm_instance._repo.ui.configitems('hooks'):

                    c.db_repo_scm_instance._repo.ui.setconfig('hooks', k, None)

            cs = c.db_repo_scm_instance.get_changeset(revision)

            content_type = settings.ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        from kallithea import CONFIG

        rev_name = cs.raw_id[:12]

        archive_name = '%s-%s%s' % (repo_name.replace('/', '_'), rev_name, ext)

        archive_path = None

        cached_archive_path = None

        archive_cache_dir = CONFIG.get('archive_cache_dir')

        if archive_cache_dir and not subrepos: # TODO: subrepo caching?

            if not os.path.isdir(archive_cache_dir):

                os.makedirs(archive_cache_dir)

            cached_archive_path = os.path.join(archive_cache_dir, archive_name)

            if os.path.isfile(cached_archive_path):

                log.debug('Found cached archive in %s', cached_archive_path)

                archive_path = cached_archive_path

            else:

                log.debug('Archive %s is not yet cached', archive_name)

        if archive_path is None:

            # generate new archive

            fd, archive_path = tempfile.mkstemp()

            log.debug('Creating new temp archive in %s', archive_path)

            with os.fdopen(fd, 'wb') as stream:

                cs.fill_archive(stream=stream, kind=fileformat, subrepos=subrepos)

                # stream (and thus fd) has been closed by cs.fill_archive

            if cached_archive_path is not None:

                # we generated the archive - move it to cache

                log.debug('Storing new archive in %s', cached_archive_path)

                shutil.move(archive_path, cached_archive_path)

                archive_path = cached_archive_path

        def get_chunked_archive(archive_path):

            stream = open(archive_path, 'rb')

            while True:

                data = stream.read(16 * 1024)

                if not data:

                    break

                yield data

            stream.close()

            if archive_path != cached_archive_path:

                log.debug('Destroying temp archive %s', archive_path)

                os.remove(archive_path)

        action_logger(user=request.authuser,

                      action='user_downloaded_archive:%s' % (archive_name),

                      repo=repo_name, ipaddr=request.ip_addr, commit=True)

        response.content_disposition = str('attachment; filename=%s' % (archive_name))

        response.content_type = str(content_type)

        return get_chunked_archive(archive_path)

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def diff(self, repo_name, f_path):

        diff2 = request.GET.get('diff2', '')

        diff1 = request.GET.get('diff1', '') or diff2

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        fulldiff = request.GET.get('fulldiff')

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.changes = OrderedDict()

        c.changes[diff2] = []

        # special case if we want a show rev only, it's impl here

        # to reduce JS and callbacks

        if request.GET.get('show_rev'):

            if asbool(request.GET.get('annotate', 'False')):

                _url = url('files_annotate_home', repo_name=c.repo_name,

                           revision=diff1, f_path=c.f_path)

            else:

                _url = url('files_home', repo_name=c.repo_name,

                           revision=diff1, f_path=c.f_path)

            raise HTTPFound(location=_url)

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.db_repo_scm_instance.get_changeset(diff1)

                try:

                    node1 = c.changeset_1.get_node(f_path)

                    if node1.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node1, type(node1)))

                except NodeDoesNotExistError:

                    c.changeset_1 = EmptyChangeset(cs=diff1,

                                                   revision=c.changeset_1.revision,

                                                   repo=c.db_repo_scm_instance)

                    node1 = FileNode(f_path, '', changeset=c.changeset_1)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node1 = FileNode(f_path, '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except (RepositoryError, NodeError):

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('files_home', repo_name=c.repo_name,

                                f_path=f_path))

        if c.action == 'download':

            raw_diff = diffs.get_gitdiff(node1, node2,

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = (

                'attachment; filename=%s' % diff_name

            )

            return raw_diff

        elif c.action == 'raw':

            raw_diff = diffs.get_gitdiff(node1, node2,

            response.content_type = 'text/plain'

            return raw_diff

        else:

            fid = h.FID(diff2, node2.path)

            diff_limit = None if fulldiff else self.cut_off_limit

            c.a_rev, c.cs_rev, a_path, diff, st, op = diffs.wrapped_diff(filenode_old=node1,

                                         filenode_new=node2,

                                         diff_limit=diff_limit,

                                         enable_comments=False)

            c.file_diff_data = [(fid, fid, op, a_path, node2.path, diff, st)]

            return render('files/file_diff.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def diff_2way(self, repo_name, f_path):

        diff1 = request.GET.get('diff1', '')

        diff2 = request.GET.get('diff2', '')

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.db_repo_scm_instance.get_changeset(diff1)

                try:

                    node1 = c.changeset_1.get_node(f_path)

                    if node1.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node1, type(node1)))

                except NodeDoesNotExistError:

                    c.changeset_1 = EmptyChangeset(cs=diff1,

                                                   revision=c.changeset_1.revision,

                                                   repo=c.db_repo_scm_instance)

                    node1 = FileNode(f_path, '', changeset=c.changeset_1)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node1 = FileNode(f_path, '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except ChangesetDoesNotExistError as e:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        c.node1 = node1

        c.node2 = node2

        c.cs1 = c.changeset_1

        c.cs2 = c.changeset_2

        return render('files/diff_2way.html')

    def _get_node_history(self, cs, f_path, changesets=None):

        """

        get changesets history for given node

        :param cs: changeset to calculate history

        :param f_path: path for node to calculate history for

        :param changesets: if passed don't calculate history and take

            changesets defined in this list

        """

        # calculate history based on tip

        tip_cs = c.db_repo_scm_instance.get_changeset()

        if changesets is None:

            try:

                changesets = tip_cs.get_file_history(f_path)

            except (NodeDoesNotExistError, ChangesetError):

                # this node is not present at tip !

                changesets = cs.get_file_history(f_path)

        hist_l = []

        changesets_group = ([], _("Changesets"))

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for chs in changesets:

            # TODO: loop over chs.branches ... but that will not give all the bogus None branches for Git ...

            _branch = chs.branch

            n_desc = '%s (%s)' % (h.show_id(chs), _branch)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

        for name, chs in c.db_repo_scm_instance.branches.items():

            branches_group[0].append((chs, name),)

        hist_l.append(branches_group)

        for name, chs in c.db_repo_scm_instance.tags.items():

            tags_group[0].append((chs, name),)

        hist_l.append(tags_group)

        return hist_l, changesets

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def nodelist(self, repo_name, revision, f_path):

                h.flash(_('Revision %s not found in %s') % (x, c.cs_repo.repo_name),

                    'error')

                break

        c.cs_ranges_org = None # not stored and not important and moving target - could be calculated ...

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(org_scm_instance, revs)

        c.is_range = False

        try:

            if c.a_ref_type == 'rev': # this looks like a free range where target is ancestor

                cs_a = org_scm_instance.get_changeset(c.a_rev)

                root_parents = c.cs_ranges[0].parents

                c.is_range = cs_a in root_parents

                #c.merge_root = len(root_parents) > 1 # a range starting with a merge might deserve a warning

        except ChangesetDoesNotExistError: # probably because c.a_rev not found

            pass

        except IndexError: # probably because c.cs_ranges is empty, probably because revisions are missing

            pass

        avail_revs = set()

        avail_show = []

        c.cs_branch_name = c.cs_ref_name

        c.a_branch_name = None

        other_scm_instance = c.a_repo.scm_instance

        c.update_msg = ""

        c.update_msg_other = ""

        try:

            if not c.cs_ranges:

                c.update_msg = _('Error: changesets not found when displaying pull request from %s.') % c.cs_rev

            elif org_scm_instance.alias == 'hg' and c.a_ref_name != 'ancestor':

                if c.cs_ref_type != 'branch':

                    c.cs_branch_name = org_scm_instance.get_changeset(c.cs_ref_name).branch # use ref_type ?

                c.a_branch_name = c.a_ref_name

                if c.a_ref_type != 'branch':

                    try:

                        c.a_branch_name = other_scm_instance.get_changeset(c.a_ref_name).branch # use ref_type ?

                    except EmptyRepositoryError:

                        c.a_branch_name = 'null' # not a branch name ... but close enough

                # candidates: descendants of old head that are on the right branch

                #             and not are the old head itself ...

                #             and nothing at all if old head is a descendant of target ref name

                if not c.is_range and other_scm_instance._repo.revs('present(%s)::&%s', c.cs_ranges[-1].raw_id, c.a_branch_name):

                    c.update_msg = _('This pull request has already been merged to %s.') % c.a_branch_name

                elif c.pull_request.is_closed():

                    c.update_msg = _('This pull request has been closed and can not be updated.')

                else: # look for descendants of PR head on source branch in org repo

                    avail_revs = org_scm_instance._repo.revs('%s:: & branch(%s)',

                                                             revs[0], c.cs_branch_name)

                    if len(avail_revs) > 1: # more than just revs[0]

                        # also show changesets that not are descendants but would be merged in

                        targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                        if org_scm_instance.path != other_scm_instance.path:

                            # Note: org_scm_instance.path must come first so all

                            # valid revision numbers are 100% org_scm compatible

                            # - both for avail_revs and for revset results

                            hgrepo = mercurial.unionrepo.makeunionrepository(org_scm_instance.baseui,

                                                                   safe_bytes(org_scm_instance.path),

                                                                   safe_bytes(other_scm_instance.path))

                        else:

                            hgrepo = org_scm_instance._repo

                        show = set(hgrepo.revs('::%ld & !::parents(%s) & !::%s',

                                               avail_revs, revs[0], targethead))

                        if show:

                            c.update_msg = _('The following additional changes are available on %s:') % c.cs_branch_name

                        else:

                            c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    else:

                        show = set()

                        avail_revs = set() # drop revs[0]

                        c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    # TODO: handle branch heads that not are tip-most

                    brevs = org_scm_instance._repo.revs('%s - %ld - %s', c.cs_branch_name, avail_revs, revs[0])

                    if brevs:

                        # also show changesets that are on branch but neither ancestors nor descendants

                        show.update(org_scm_instance._repo.revs('::%ld - ::%ld - ::%s', brevs, avail_revs, c.a_branch_name))

                        show.add(revs[0]) # make sure graph shows this so we can see how they relate

                        c.update_msg_other = _('Note: Branch %s has another head: %s.') % (c.cs_branch_name,

                            h.short_id(org_scm_instance.get_changeset((max(brevs))).raw_id))

                    avail_show = sorted(show, reverse=True)

            elif org_scm_instance.alias == 'git':

                c.cs_repo.scm_instance.get_changeset(c.cs_rev) # check it exists - raise ChangesetDoesNotExistError if not

                c.update_msg = _("Git pull requests don't support iterating yet.")

        except ChangesetDoesNotExistError:

            c.update_msg = _('Error: some changesets not found when displaying pull request from %s.') % c.cs_rev

        c.avail_revs = avail_revs

        c.avail_cs = [org_scm_instance.get_changeset(r) for r in avail_show]

        c.avail_jsdata = graph_data(org_scm_instance, avail_show)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        fulldiff = request.GET.get('fulldiff')

        diff_limit = None if fulldiff else self.cut_off_limit

        # we swap org/other ref since we run a simple diff on one repo

        log.debug('running diff between %s and %s in %s',

                  c.a_rev, c.cs_rev, org_scm_instance.path)

        try:

            raw_diff = diffs.get_diff(org_scm_instance, rev1=c.a_rev, rev2=c.cs_rev,

        except ChangesetDoesNotExistError:

            raw_diff = safe_bytes(_("The diff can't be shown - the PR revisions could not be found."))

        diff_processor = diffs.DiffProcessor(raw_diff, diff_limit=diff_limit)

        c.limited_diff = diff_processor.limited_diff

        c.file_diff_data = []

        c.lines_added = 0

        c.lines_deleted = 0

        for f in diff_processor.parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            html_diff = diffs.as_html(enable_comments=True, parsed_lines=[f])

            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.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.db_repo.repo_id, pull_request=pull_request_id)

        # (badly named) pull-request status calculation based on reviewer votes

        (c.pull_request_reviewers,

         c.pull_request_pending_reviewers,

         c.current_voting_result,

         ) = cs_model.calculate_pull_request_result(c.pull_request)

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.is_ajax_preview = False

        c.ancestors = None # [c.a_rev] ... but that is shown in an other way

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        allowed_to_change_status = self._is_allowed_to_change_status(pull_request)

        return create_cs_pr_comment(repo_name, pull_request=pull_request,

                allowed_to_change_status=allowed_to_change_status)

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        return delete_cs_pr_comment(repo_name, comment_id)