#    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, '', self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session.commit()

        except IntegrityError, e:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete %s it still contains attached '

                          'forks') % repo_name,

                        category='warning')

            else:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during '

                          'deletion of %s') % repo_name,

                        category='error')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

        :param repo_name:

        """

    @HasPermissionAnyDecorator('hg.admin')

    def delete(self, id):

        """DELETE /repos_groups/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repos_group', id=ID),

        #           method='delete')

        # url('repos_group', id=ID)

        gr = RepoGroup.get(id)

        repos = gr.repositories.all()

        if repos:

            h.flash(_('This group contains %s repositores and cannot be '

                      'deleted' % len(repos)),

                    category='error')

            return redirect(url('repos_groups'))

        try:

            ReposGroupModel().delete(id)

            Session.commit()

            h.flash(_('removed repos group %s' % gr.group_name), category='success')

            #TODO: in future action_logger(, '', '', '', self.sa)

        except IntegrityError, e:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete this group it still contains '

                          'subgroups'),

                        category='warning')

            else:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during deletion of repos '

                          'group %s' % gr.group_name), category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during deletion of repos '

                      'group %s' % gr.group_name), category='error')

        return redirect(url('repos_groups'))

    def show_by_name(self, group_name):

        id_ = RepoGroup.get_by_group_name(group_name).group_id

        return self.show(id_)

    def show(self, id, format='html'):

        """GET /repos_groups/id: Show a specific item"""

        # url('repos_group', id=ID)

from rhodecode.lib.compat import OrderedDict

from rhodecode.model.db import ChangesetComment

from rhodecode.model.comment import ChangesetCommentsModel

from vcs.exceptions import RepositoryError, ChangesetError, \

    ChangesetDoesNotExistError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

from webob.exc import HTTPForbidden

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class ChangesetController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def index(self, revision):

        def wrap_to_table(str):

            return '''<table class="code-difftable">

                        <tr class="line">

                        <td class="lineno new"></td>

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

        #get ranges of revisions if preset

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

        try:

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

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

                                                            end=rev_end)

            else:

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

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

                        .get_inline_comments(c.rhodecode_db_repo.repo_id,

                                             changeset.raw_id)

            c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

            #==================================================================

            # ADDED FILES

            #==================================================================

            for node in changeset.added:

                filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                    st = (0, 0)

                else:

                    # in this case node.size is good parameter since those are

                    # added nodes and their size defines how many changes were

                    # made

                    c.sum_added += node.size

                    if c.sum_added < self.cut_off_limit:

                        d = differ.DiffProcessor(f_gitdiff, format='gitdiff')

                        st = d.stat()

                        diff = d.as_html()

                    else:

                        diff = wrap_to_table(_('Changeset is to big and '

                                               'was cut off, see raw '

                                               'changeset instead'))

                        c.cut_off = True

                        break

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(('added', node, diff,

                                                    cs1, cs2, st))

            #==================================================================

            # CHANGED FILES

            #==================================================================

            if not c.cut_off:

                for node in changeset.changed:

                    try:

                        filenode_old = changeset_parent.get_node(node.path)

                    except ChangesetError:

                        log.warning('Unable to fetch parent node for diff')

                        filenode_old = FileNode(node.path, '',

                                                EmptyChangeset())

                    if filenode_old.is_binary or node.is_binary:

                        diff = wrap_to_table(_('binary file'))

                        st = (0, 0)

                    else:

                        if c.sum_removed < self.cut_off_limit:

                            d = differ.DiffProcessor(f_gitdiff,

                                                     format='gitdiff')

                            st = d.stat()

                            if (st[0] + st[1]) * 256 > self.cut_off_limit:

                                diff = wrap_to_table(_('Diff is to big '

                                                       'and was cut off, see '

                                                       'raw diff instead'))

                            else:

                                diff = d.as_html()

                            if diff:

                                c.sum_removed += len(diff)

                        else:

                            diff = wrap_to_table(_('Changeset is to big and '

                                                   'was cut off, see raw '

                                                   'changeset instead'))

                            c.cut_off = True

                            break

                    cs1 = filenode_old.last_changeset.raw_id

                    cs2 = node.last_changeset.raw_id

                    c.lines_added += st[0]

                    c.lines_deleted += st[1]

                    c.changes[changeset.raw_id].append(('changed', node, diff,

            #==================================================================

            # REMOVED FILES

            #==================================================================

            if not c.cut_off:

                for node in changeset.removed:

                    c.changes[changeset.raw_id].append(('removed', node, None,

                                                        None, None, (0, 0)))

        # count inline comments

        for path, 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.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        try:

            c.scm_type = c.rhodecode_repo.alias

            c.changeset = c.rhodecode_repo.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    diff = differ.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    diff = differ.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

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

                                            % revision

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

                                                 c.changeset.parents])

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    def comment(self, repo_name, revision):

        ChangesetCommentsModel().create(text=request.POST.get('text'),

        response.content_type = content_type

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

            % (repo_name, revision, ext)

        import tempfile

        archive = tempfile.mkstemp()[1]

        t = open(archive, 'wb')

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

        def get_chunked_archive(archive):

            stream = open(archive, 'rb')

            while True:

                data = stream.read(4096)

                if not data:

                    os.remove(archive)

                    break

                yield data

        return get_chunked_archive(archive)

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def diff(self, repo_name, f_path):

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

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

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

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        try:

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

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

                node1 = c.changeset_1.get_node(f_path)

            else:

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

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

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

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

                node2 = c.changeset_2.get_node(f_path)

            else:

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

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

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        if c.action == 'download':

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

            response.content_type = 'text/plain'

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

                                                    % diff_name

            return diff.raw_diff()

        elif c.action == 'raw':

            response.content_type = 'text/plain'

            return diff.raw_diff()

        elif c.action == 'diff':

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

            elif node1.size > self.cut_off_limit or \

                    node2.size > self.cut_off_limit:

                c.cur_diff = ''

                c.big_diff = True

            else:

                c.cur_diff = diff.as_html()

        else:

            #default option

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

            elif node1.size > self.cut_off_limit or \

                    node2.size > self.cut_off_limit:

                c.cur_diff = ''

                c.big_diff = True

            else:

                c.cur_diff = diff.as_html()

        if not c.cur_diff and not c.big_diff:

            c.no_changes = True

        return render('files/file_diff.html')

    def _get_node_history(self, cs, f_path):

        changesets = cs.get_file_history(f_path)

        hist_l = []

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

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

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

        for chs in changesets:

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

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

        hist_l.append(changesets_group)

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

            #chs = chs.split(':')[-1]

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

        hist_l.append(branches_group)