import logging

import traceback

import formencode

from formencode import htmlfill

from operator import itemgetter

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import RepoGroup

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class ReposGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repos_group', 'repos_groups')

    @LoginRequired()

    def __before__(self):

        super(ReposGroupsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        self.__load_defaults()

        repo_group = RepoGroup.get(group_id)

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        return data

    @HasPermissionAnyDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos_groups: All items in the collection"""

        # url('repos_groups')

        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name

        c.groups = sorted(RepoGroup.query().all(), key=sk)

        return render('admin/repos_groups/repos_groups_show.html')

    @HasPermissionAnyDecorator('hg.admin')

    def create(self):

        """POST /repos_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        repos_group_form = ReposGroupForm(available_groups=

                                          c.repo_groups_choices)()

        try:

            form_result = repos_group_form.to_python(dict(request.POST))

            ReposGroupModel().create(form_result)

            Session.commit()

            h.flash(_('created repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/repos_groups/repos_groups_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during creation of repos group %s') \

                    % request.POST.get('group_name'), category='error')

        return redirect(url('repos_groups'))

    @HasPermissionAnyDecorator('hg.admin')

    def new(self, format='html'):

        """GET /repos_groups/new: Form to create a new item"""

        # url('new_repos_group')

        self.__load_defaults()

        return render('admin/repos_groups/repos_groups_add.html')

    @HasPermissionAnyDecorator('hg.admin')

    def update(self, id):

        """PUT /repos_groups/id: Update an existing item"""

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

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

        # Or using helpers:

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

        #           method='put')

        # url('repos_group', id=ID)

        self.__load_defaults()

        c.repos_group = RepoGroup.get(id)

        repos_group_form = ReposGroupForm(edit=True,

                                          old_data=c.repos_group.get_dict(),

                                          available_groups=

                                            c.repo_groups_choices)()

        try:

            form_result = repos_group_form.to_python(dict(request.POST))

            ReposGroupModel().update(id, form_result)

            Session.commit()

            h.flash(_('updated repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/repos_groups/repos_groups_edit.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repos group %s') \

                    % request.POST.get('group_name'), category='error')

        return redirect(url('repos_groups'))

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

            if e.message.find('groups_group_parent_id_fkey') != -1:

                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)

        c.group = RepoGroup.get(id)

        if c.group:

            c.group_repos = c.group.repositories.all()

        else:

            return redirect(url('home'))

        #overwrite our cached list with current filter

        gr_filter = c.group_repos

        c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)

        c.repos_list = c.cached_repo_list

        c.repo_cnt = 0

        c.groups = self.sa.query(RepoGroup).order_by(RepoGroup.group_name)\

            .filter(RepoGroup.group_parent_id == id).all()

        return render('admin/repos_groups/repos_groups.html')

    @HasPermissionAnyDecorator('hg.admin')

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

        """GET /repos_groups/id/edit: Form to edit an existing item"""

        # url('edit_repos_group', id=ID)

        id_ = int(id)

        c.repos_group = RepoGroup.get(id_)

        defaults = self.__load_data(id_)

        # we need to exclude this group from the group list for editing

        c.repo_groups = filter(lambda x:x[0] != id_, c.repo_groups)

        return htmlfill.render(

            render('admin/repos_groups/repos_groups_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

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

"""

    rhodecode.controllers.api

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

    JSON RPC controller

    :created_on: Aug 20, 2011

    :author: marcink

    :copyright: (C) 2009-2010 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import inspect

import logging

import types

import urllib

import traceback

from rhodecode.lib.compat import izip_longest, json

from paste.response import replace_header

from pylons.controllers import WSGIController

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

HTTPBadRequest, HTTPError

from rhodecode.model.db import User

from rhodecode.lib.auth import AuthUser

log = logging.getLogger('JSONRPC')

class JSONRPCError(BaseException):

    def __init__(self, message):

        self.message = message

        super(JSONRPCError, self).__init__()

    def __str__(self):

        return str(self.message)

def jsonrpc_error(message, code=None):

    """

    Generate a Response object with a JSON-RPC error body

    """

    from pylons.controllers.util import Response

    resp = Response(body=json.dumps(dict(id=None, result=None, error=message)),

                    status=code,

                    content_type='application/json')

    return resp

class JSONRPCController(WSGIController):

    """

     A WSGI-speaking JSON-RPC controller class

     See the specification:

     <http://json-rpc.org/wiki/specification>`.

     Valid controller return values should be json-serializable objects.

     Sub-classes should catch their exceptions and raise JSONRPCError

     if they want to pass meaningful errors to the client.

     """

    def _get_method_args(self):

        """

        Return `self._rpc_args` to dispatched controller method

        chosen by __call__

        """

        return self._rpc_args

    def __call__(self, environ, start_response):

        """

        Parse the request body as JSON, look up the method on the

        controller and if it exists, dispatch to it.

        """

        if 'CONTENT_LENGTH' not in environ:

            log.debug("No Content-Length")

            return jsonrpc_error(message="No Content-Length in request")

        else:

            length = environ['CONTENT_LENGTH'] or 0

            length = int(environ['CONTENT_LENGTH'])

            log.debug('Content-Length: %s', length)

        if length == 0:

            log.debug("Content-Length is 0")

            return jsonrpc_error(message="Content-Length is 0")

        raw_body = environ['wsgi.input'].read(length)

        try:

            json_body = json.loads(urllib.unquote_plus(raw_body))

        except ValueError, e:

            # catch JSON errors Here

            return jsonrpc_error(message="JSON parse error ERR:%s RAW:%r" \

                                 % (e, urllib.unquote_plus(raw_body)))

        # check AUTH based on API KEY

        try:

            self._req_api_key = json_body['api_key']

            self._req_id = json_body['id']

            self._req_method = json_body['method']

            self._request_params = json_body['args']

            log.debug('method: %s, params: %s',

                      self._req_method,

                      self._request_params)

        except KeyError, e:

            return jsonrpc_error(message='Incorrect JSON query missing %s' % e)

        # check if we can find this session using api_key

        try:

            u = User.get_by_api_key(self._req_api_key)

            if u is None:

                return jsonrpc_error(message='Invalid API KEY')

            auth_u = AuthUser(u.user_id, self._req_api_key)

        except Exception, e:

            return jsonrpc_error(message='Invalid API KEY')

        self._error = None

        try:

            self._func = self._find_method()

        except AttributeError, e:

            return jsonrpc_error(message=str(e))

        # now that we have a method, add self._req_params to

        # self.kargs and dispatch control to WGIController

        argspec = inspect.getargspec(self._func)

        arglist = argspec[0][1:]

        defaults = map(type, argspec[3] or [])

        default_empty = types.NotImplementedType

        # kw arguments required by this method

        func_kwargs = dict(izip_longest(reversed(arglist), reversed(defaults),

                                        fillvalue=default_empty))

        # this is little trick to inject logged in user for

        # perms decorators to work they expect the controller class to have

        # rhodecode_user attribute set

        self.rhodecode_user = auth_u

        # This attribute will need to be first param of a method that uses

        # api_key, which is translated to instance of user at that name

        USER_SESSION_ATTR = 'apiuser'

        if USER_SESSION_ATTR not in arglist:

            return jsonrpc_error(message='This method [%s] does not support '

                                 'authentication (missing %s param)' %

                                 (self._func.__name__, USER_SESSION_ATTR))

        # get our arglist and check if we provided them as args

        for arg, default in func_kwargs.iteritems():

            if arg == USER_SESSION_ATTR:

                # USER_SESSION_ATTR is something translated from api key and

                # this is checked before so we don't need validate it

                continue

            # skip the required param check if it's default value is

            # NotImplementedType (default_empty)

            if (default == default_empty and arg not in self._request_params):

                return jsonrpc_error(

                    message=(

                        'Missing non optional `%s` arg in JSON DATA' % arg

                    )

                )

        self._rpc_args = {USER_SESSION_ATTR: u}

        self._rpc_args.update(self._request_params)

        self._rpc_args['action'] = self._req_method

        self._rpc_args['environ'] = environ

        self._rpc_args['start_response'] = start_response

        status = []

        headers = []

        exc_info = []

        def change_content(new_status, new_headers, new_exc_info=None):

            status.append(new_status)

            headers.extend(new_headers)

            exc_info.append(new_exc_info)

        output = WSGIController.__call__(self, environ, change_content)

        output = list(output)

        headers.append(('Content-Length', str(len(output[0]))))

        replace_header(headers, 'Content-Type', 'application/json')

        start_response(status[0], headers, exc_info[0])

        return output

    def _dispatch_call(self):

        """

        Implement dispatch interface specified by WSGIController

        """

        try:

            raw_response = self._inspect_call(self._func)

            if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

        except JSONRPCError, e:

            self._error = str(e)

        except Exception, e:

            log.error('Encountered unhandled exception: %s' \

                      % traceback.format_exc())

            json_exc = JSONRPCError('Internal server error')

            self._error = str(json_exc)

        if self._error is not None:

            raw_response = None

        response = dict(id=self._req_id, result=raw_response, 

                        error=self._error)

        try:

            return json.dumps(response)

        except TypeError, e:

            log.debug('Error encoding response: %s', e)

            return json.dumps(

                dict(

                    self._req_id,

                    result=None,

                    error="Error encoding response"

                )

            )

    def _find_method(self):

        """

        Return method named by `self._req_method` in controller if able

        """

        log.debug('Trying to find JSON-RPC method: %s', self._req_method)

        if self._req_method.startswith('_'):

            raise AttributeError("Method not allowed")

        try:

            func = getattr(self, self._req_method, None)

        except UnicodeEncodeError:

            raise AttributeError("Problem decoding unicode in requested "

                                 "method name.")

        if isinstance(func, types.MethodType):

            return func

        else:

            raise AttributeError("No such method: %s" % self._req_method)

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

"""

    rhodecode.controllers.changelog

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

    changelog controller for rhodecode

    :created_on: Apr 21, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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/>.

import logging

import traceback

from mercurial import graphmod

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

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json

from vcs.exceptions import RepositoryError, ChangesetError, \

ChangesetDoesNotExistError,BranchDoesNotExistError

log = logging.getLogger(__name__)

class ChangelogController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(ChangelogController, self).__before__()

        c.affected_files_cut_off = 60

    def index(self):

        limit = 100

        default = 20

        if request.params.get('size'):

            try:

                int_size = int(request.params.get('size'))

            except ValueError:

                int_size = default

            int_size = int_size if int_size <= limit else limit

            c.size = int_size

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        p = int(request.params.get('page', 1))

        branch_name = request.params.get('branch', None)

        try:

            if branch_name:

                collection = [z for z in 

                              c.rhodecode_repo.get_changesets(start=0, 

                                                    branch_name=branch_name)]

                c.total_cs = len(collection)

            else:

                collection = list(c.rhodecode_repo)

                c.total_cs = len(c.rhodecode_repo)

            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,

                                    items_per_page=c.size, branch=branch_name)

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))        

        self._graph(c.rhodecode_repo, collection, c.total_cs, c.size, p)

        c.branch_name = branch_name

        c.branch_filters = [('',_('All Branches'))] + \

            [(k,k) for k in c.rhodecode_repo.branches.keys()]

        return render('changelog/changelog.html')

    def changelog_details(self, cs):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.cs = c.rhodecode_repo.get_changeset(cs)

            return render('changelog/changelog_details.html')

    def _graph(self, repo, collection, repo_size, size, p):

        """

        Generates a DAG graph for mercurial

        :param repo: repo instance

        :param size: number of commits to show

        :param p: page number

        """

        if not collection:

            c.jsdata = json.dumps([])

            return

        revcount = min(repo_size, size)

        offset = 1 if p == 1 else  ((p - 1) * revcount + 1)

        try:

            rev_end = collection.index(collection[(-1 * offset)])

        except IndexError:

            rev_end = collection.index(collection[-1])

        rev_start = max(0, rev_end - revcount)

        data = []

        rev_end += 1

        if repo.alias == 'git':

            for _ in xrange(rev_start, rev_end):

                vtx = [0, 1]

                edges = [[0, 0, 1]]

                data.append(['', vtx, edges])

        elif repo.alias == 'hg':

            revs = list(reversed(xrange(rev_start, rev_end)))

            c.dag = graphmod.colored(graphmod.dagwalker(repo._repo, revs))

            for (id, type, ctx, vtx, edges) in c.dag:

                if type != graphmod.CHANGESET:

                    continue

                data.append(['', vtx, edges])

        c.jsdata = json.dumps(data)

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

"""

    rhodecode.controllers.files

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

    Files controller for RhodeCode

    :created_on: Apr 21, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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/>.

import os

import logging

import traceback

from pylons import request, response, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from vcs.conf import settings

from vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \

    EmptyRepositoryError, ImproperArchiveTypeError, VCSError, \

    NodeAlreadyExistsError

from vcs.nodes import FileNode

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib import convert_line_endings, detect_mode, safe_str

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.lib import diffs

import rhodecode.lib.helpers as h

from rhodecode.model.repo import RepoModel

from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from rhodecode.lib.diffs import wrapped_diff

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='')

            add_new = '<a href="%s">[%s]</a>' % (url_, _('add new'))

            h.flash(h.literal(_('There are no files yet %s' % add_new)),

                    category='warning')

            redirect(h.url('summary_home', repo_name=repo_name))

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

    def __get_filenode_or_redirect(self, repo_name, cs, path):

        """

        Returns file_node, if error occurs or given path is directory,

        it'll redirect to top level path

        :param repo_name: repo_name

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        return file_node

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

                                   'repository.admin')

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

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs_or_redirect(post_revision, repo_name)

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

                         revision=cs.raw_id, f_path=f_path))

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)

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

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.rhodecode_repo.get_changeset(cur_rev).next(c.branch)

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

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.file_history = self._get_node_history(c.changeset, f_path)

            else:

                c.file_history = []

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=revision))

        return render('files/files.html')

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

                                   'repository.admin')

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

        cs = self.__get_cs_or_redirect(revision, repo_name)

        file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)

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

            safe_str(f_path.split(os.sep)[-1])

        response.content_type = file_node.mimetype

        return file_node.content

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

                                   'repository.admin')

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

        cs = self.__get_cs_or_redirect(revision, repo_name)

        file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

            # you can also provide a content-disposition to override the

            # default "attachment" disposition.

            # orig_type: (new_type, new_dispo)

            # show images inline:

            'image/x-icon': ('image/x-icon', 'inline'),

            'image/png': ('image/png', 'inline'),

            'image/gif': ('image/gif', 'inline'),

            'image/jpeg': ('image/jpeg', 'inline'),

            'image/svg+xml': ('image/svg+xml', 'inline'),

        }

        mimetype = file_node.mimetype

        try:

            mimetype, dispo = raw_mimetype_mapping[mimetype]

        except KeyError:

            # we don't know anything special about this, handle it safely

            if file_node.is_binary:

                # do same as download raw for binary files

                mimetype, dispo = 'application/octet-stream', 'attachment'

            else:

                # do not just use the original mimetype, but force text/plain,

                # otherwise it would serve text/html and that might be unsafe.

                # Note: underlying vcs library fakes text/plain mimetype if the

                # mimetype can not be determined and it thinks it is not

                # binary.This might lead to erroneous text display in some

                # cases, but helps in other cases, like with text files