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

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

            f_path.split(os.sep)[-1].encode('utf8', 'replace')

        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

                # without extension.

                mimetype, dispo = 'text/plain', 'inline'

        if dispo == 'attachment':

            dispo = 'attachment; filename=%s' % \

                        f_path.split(os.sep)[-1].encode('utf8', 'replace')

        response.content_disposition = dispo

        response.content_type = mimetype

        return file_node.content

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

                                   'repository.admin')

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

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

        c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)

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

        c.f_path = f_path

        return render('files/files_annotate.html')

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

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

        r_post = request.POST

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

        c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)

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

        c.f_path = f_path

        if r_post:

            old_content = c.file.content

            sl = old_content.splitlines(1)

            first_line = sl[0] if sl else ''

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

            mode = detect_mode(first_line, 0)

            content = convert_line_endings(r_post.get('content'), mode)

            message = r_post.get('message') or (_('Edited %s via RhodeCode')

                                                % (f_path))

            author = self.rhodecode_user.full_contact

            if content == old_content:

                h.flash(_('No changes'),

                    category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

            try:

                self.scm_model.commit_change(repo=c.rhodecode_repo,

                                             repo_name=repo_name, cs=c.cs,

                                             author=author, message=message,

                                             content=content, f_path=f_path)

                h.flash(_('Successfully committed to %s' % f_path),

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

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

            return redirect(url('changeset_home',

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

        return render('files/files_edit.html')

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

                                   'repository.admin')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        for a_type, ext_data in 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 dbrepo.enable_downloads is False:

                return _('downloads disabled')

            cs = c.rhodecode_repo.get_changeset(revision)

            content_type = ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

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

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        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)

        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 = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

                                        format='gitdiff')

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

            response.content_type = 'text/plain'

    :param value: bool value

    """

    if value is True:

        return HTML.tag('img', src=url("/images/icons/accept.png"),

                        alt=_('True'))

    if value is False:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

    return value

def action_parser(user_log, feed=False):

    """This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 5 #display this amount always

        revs_top_limit = 50 #show upto this amount of changesets hidden

        revs = action_params.split(',')

        repo_name = user_log.repository.repo_name

        from rhodecode.model.scm import ScmModel

        repo, dbrepo = ScmModel().get(repo_name, retval='repo',

                                      invalidation_list=[])

        message = lambda rev: get_changeset_safe(repo, rev).message

        cs_links = " " + ', '.join ([link_to(rev,

                url('changeset_home',

                repo_name=repo_name,

                revision=rev), title=tooltip(message(rev)),

                class_='tooltip') for rev in revs[:revs_limit] ])

        compare_view = (' <div class="compare_view tooltip" title="%s">'

                        '<a href="%s">%s</a> '

                        '</div>' % (_('Show all combined changesets %s->%s' \

                                      % (revs[0], revs[-1])),

                                    url('changeset_home', repo_name=repo_name,

                                        revision='%s...%s' % (revs[0], revs[-1])

                                    ),

                                    _('compare view'))

                        )

        if len(revs) > revs_limit:

            uniq_id = revs[0]

            html_tmpl = ('<span> %s '

            '<a class="show_more" id="_%s" href="#more">%s</a> '

            '%s</span>')

            if not feed:

                cs_links += html_tmpl % (_('and'), uniq_id, _('%s more') \

                                        % (len(revs) - revs_limit),

                                        _('revisions'))

            if not feed:

                html_tmpl = '<span id="%s" style="display:none"> %s </span>'

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            cs_links += html_tmpl % (uniq_id, ', '.join([link_to(rev,

                url('changeset_home',

                repo_name=repo_name, revision=rev),

                title=message(rev), class_='tooltip')

                for rev in revs[revs_limit:revs_top_limit]]))

        if len(revs) > 1:

            cs_links += compare_view

        return cs_links

    def get_fork_name():

        repo_name = action_params

        return _('fork name ') + str(link_to(action_params, url('summary_home',

                                          repo_name=repo_name,)))

    action_map = {'user_deleted_repo':(_('[deleted] repository'), None),

           'user_created_repo':(_('[created] repository'), None),

           'user_forked_repo':(_('[forked] repository'), get_fork_name),

           'user_updated_repo':(_('[updated] repository'), None),

           'admin_deleted_repo':(_('[delete] repository'), None),

           'admin_created_repo':(_('[created] repository'), None),

           'admin_forked_repo':(_('[forked] repository'), None),

           'admin_updated_repo':(_('[updated] repository'), None),

           'push':(_('[pushed] into'), get_cs_links),

           'push_remote':(_('[pulled from remote] into'), get_cs_links),

           'pull':(_('[pulled] from'), None),

           'started_following_repo':(_('[started following] repository'), None),

           'stopped_following_repo':(_('[stopped following] repository'), None),

            }

    action_str = action_map.get(action, action)

    if feed:

        action = action_str[0].replace('[', '').replace(']', '')

    else:

        action = action_str[0].replace('[', '<span class="journal_highlight">')\

                   .replace(']', '</span>')

    action_params_func = lambda :""

    if callable(action_str[1]):

        action_params_func = action_str[1]

    return [literal(action), action_params_func]

def action_parser_icon(user_log):

    action = user_log.action

    action_params = None

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    tmpl = """<img src="%s%s" alt="%s"/>"""

    map = {'user_deleted_repo':'database_delete.png',

           'user_created_repo':'database_add.png',

           'user_forked_repo':'arrow_divide.png',

           'user_updated_repo':'database_edit.png',

           'admin_deleted_repo':'database_delete.png',

           'admin_created_repo':'database_add.png',

           'admin_forked_repo':'arrow_divide.png',

           'admin_updated_repo':'database_edit.png',

           'push':'script_add.png',

           'push_remote':'connect.png',

           'pull':'down_16.png',

           'started_following_repo':'heart_add.png',

           'stopped_following_repo':'heart_delete.png',

            }

    return literal(tmpl % ((url('/images/icons/')),

                           map.get(action, action), action))

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

# PERMS

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

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

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

# GRAVATAR URL

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

def gravatar_url(email_address, size=30):

    if not str2bool(config['app_conf'].get('use_gravatar')):

        return "/images/user%s.png" % size

    ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

    if isinstance(email_address, unicode):

        #hashlib crashes on unicode items

        email_address = email_address.encode('utf8', 'replace')

    # construct the url

    gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"

    gravatar_url += urllib.urlencode({'d':default, 's':str(size)})

    return gravatar_url

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

# REPO PAGER

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

class RepoPage(Page):

    def __init__(self, collection, page=1, items_per_page=20,

        item_count=None, url=None, branch_name=None, **kwargs):

        """Create a "RepoPage" instance. special pager for paging

        repository

        """

        self._url_generator = url

        # Safe the kwargs class-wide so they can be used in the pager() method

        self.kwargs = kwargs

        # Save a reference to the collection

        self.original_collection = collection

        self.collection = collection

        # The self.page is the number of the current page.

        # The first page has the number 1!

        try:

            self.page = int(page) # make it int() if we get it as a string

        except (ValueError, TypeError):

            self.page = 1

        self.items_per_page = items_per_page

        # Unless the user tells us how many items the collections has

        # we calculate that ourselves.

        if item_count is not None:

            self.item_count = item_count

        else:

            self.item_count = len(self.collection)

        # Compute the number of the first and last available page

        if self.item_count > 0:

            self.first_page = 1

            self.page_count = ((self.item_count - 1) / self.items_per_page) + 1

            self.last_page = self.first_page + self.page_count - 1

            # Make sure that the requested page number is the range of valid pages

            if self.page > self.last_page:

                self.page = self.last_page

            elif self.page < self.first_page:

                self.page = self.first_page

            # Note: the number of items on this page can be less than

            #       items_per_page if the last page is not full

            self.first_item = max(0, (self.item_count) - (self.page * items_per_page))

            self.last_item = ((self.item_count - 1) - items_per_page * (self.page - 1))

            iterator = self.collection.get_changesets(start=self.first_item,

                                                      end=self.last_item,

                                                      reverse=True,

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            self.sa.commit()

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def toggle_following_user(self, follow_user_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user_id == follow_user_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                self.sa.commit()

                return

            except:

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def is_following_repo(self, repo_name, user_id, cache=False):

        r = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def is_following_user(self, username, user_id, cache=False):

        u = UserModel(self.sa).get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.by_repo_name(repo_id), 'repo_id')

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.by_repo_name(repo_id), 'repo_id')

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def pull_changes(self, repo_name, username):

        repo, dbrepo = self.get(repo_name, retval='all')

        try:

            extras = {'ip': '',

                      'username': username,

                      'action': 'push_remote',

                      'repository': repo_name}

            #inject ui extra param to log this action via push logger

            for k, v in extras.items():

                repo._repo.ui.setconfig('rhodecode_extras', k, v)

            repo.pull(dbrepo.clone_uri)

            self.mark_for_invalidation(repo_name)

        except:

            log.error(traceback.format_exc())

            raise

                      f_path):

        if repo.alias == 'hg':

            from vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = content.encode('utf8')

        message = message.encode('utf8')

        path = f_path.encode('utf8')

        author = author.encode('utf8')

        m = IMC(repo)

        m.change(FileNode(path, content))

                 author=author,

                 parents=[cs], branch=cs.branch)

        self.mark_for_invalidation(repo_name)

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

    def _should_invalidate(self, repo_name):

        """Looks up database for invalidation signals for this repo_name

        :param repo_name:

        """

        ret = self.sa.query(CacheInvalidation)\

            .filter(CacheInvalidation.cache_key == repo_name)\

            .filter(CacheInvalidation.cache_active == False)\

            .scalar()

        return ret

    def _mark_invalidated(self, cache_key):

        """ Marks all occurrences of cache to invalidation as already

        invalidated

        :param cache_key:

        """

        if cache_key:

            log.debug('marking %s as already invalidated', cache_key)

        try:

            cache_key.cache_active = True

            self.sa.add(cache_key)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()