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

"""

    package.rhodecode.lib.cleanup

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

    :created_on: Jul 14, 2012

    :author: marcink

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

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import sys

import re

import shutil

import logging

import datetime

from os.path import dirname as dn, join as jn

from rhodecode.model import init_model

from rhodecode.lib.utils2 import engine_from_config

from rhodecode.model.db import RhodeCodeUi

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from rhodecode.lib.utils import BasePasterCommand, Command, ask_ok,\

    REMOVED_REPO_PAT, add_cache

log = logging.getLogger(__name__)

class CleanupCommand(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Cleanup deleted repos"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = Command.standard_parser(verbose=True)

    def _parse_older_than(self, val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        parts = regex.match(val)

        if not parts:

            return

        parts = parts.groupdict()

        time_params = {}

        for (name, param) in parts.iteritems():

            if param:

                time_params[name] = int(param)

        return datetime.timedelta(**time_params)

    def _extract_date(self, name):

        """

        Extract the date part from rm__<date> pattern of removed repos,

        and convert it to datetime object

        :param name:

        """

        date_part = name[4:19]  # 4:19 since we don't parse milisecods

        return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        #get to remove repos !!

        add_cache(config)

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

        repos_location = RhodeCodeUi.get_repos_location()

        to_remove = []

        for loc in os.listdir(repos_location):

            if REMOVED_REPO_PAT.match(loc):

                to_remove.append([loc, self._extract_date(loc)])

        #filter older than (if present)!

        now = datetime.datetime.now()

        older_than = self.options.older_than

        if older_than:

            to_remove_filtered = []

            older_than_date = self._parse_older_than(older_than)

            for name, date_ in to_remove:

                repo_age = now - date_

                if repo_age > older_than_date:

                    to_remove_filtered.append([name, date_])

            to_remove = to_remove_filtered

            print >> sys.stdout, 'removing [%s] deleted repos older than %s[%s]' \

                % (len(to_remove), older_than, older_than_date)

        else:

            print >> sys.stdout, 'removing all [%s] deleted repos' \

                % len(to_remove)

        if self.options.dont_ask or not to_remove:

            # don't ask just remove !

            remove = True

        else:

            remove = ask_ok('are you sure to remove listed repos \n%s [y/n]?'

                            % ', \n'.join(['%s removed on %s' % (x[0], x[1])

                                           for x in to_remove]))

        if remove:

            for name, date_ in to_remove:

                print >> sys.stdout, 'removing repository %s' % name

                shutil.rmtree(os.path.join(repos_location, name))

        else:

            print 'nothing done exiting...'

            sys.exit(0)

    def update_parser(self):

        self.parser.add_option('--older-than',

                          action='store',

                          dest='older_than',

                          help=(

                            "only remove repos that have been removed "

                            "at least given time ago "

                            "ex. --older-than=30d deletes repositores "

                            "removed more than 30days ago. Possible options "

                            "d[ays]/h[ours]/m[inutes]/s[seconds]. OPTIONAL"),

                          )

        self.parser.add_option('--dont-ask',

                               action='store_true',

                               dest='dont_ask',

                               help=("Don't ask to remove repos"))

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

"""

    rhodecode.lib.indexers.__init__

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

    Whoosh indexing module for RhodeCode

    :created_on: Aug 17, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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 sys

import traceback

import logging

from os.path import dirname as dn, join as jn

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from string import strip

from shutil import rmtree

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, NUMERIC, BOOLEAN, Schema, FieldType

from whoosh.index import create_in, open_dir

from whoosh.formats import Characters

from whoosh.highlight import highlight, HtmlFormatter, ContextFragmenter

from webhelpers.html.builder import escape, literal

from sqlalchemy import engine_from_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.config.environment import load_environment

from rhodecode.lib.utils2 import LazyProperty

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache,\

    load_rcextensions

log = logging.getLogger(__name__)

# CUSTOM ANALYZER wordsplit + lowercase filter

ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()

#INDEX SCHEMA DEFINITION

SCHEMA = Schema(

    fileid=ID(unique=True),

    owner=TEXT(),

    repository=TEXT(stored=True),

    path=TEXT(stored=True),

    content=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    modtime=STORED(),

    extension=TEXT(stored=True)

)

IDX_NAME = 'HG_INDEX'

FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')

FRAGMENTER = ContextFragmenter(200)

CHGSETS_SCHEMA = Schema(

    raw_id=ID(unique=True, stored=True),

    last=BOOLEAN(),

    owner=TEXT(),

    repository=ID(unique=True, stored=True),

    author=TEXT(stored=True),

    message=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    parents=TEXT(),

    added=TEXT(),

    removed=TEXT(),

    changed=TEXT(),

)

CHGSET_IDX_NAME = 'CHGSET_INDEX'

class MakeIndex(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Creates index for full text search given configuration file"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = Command.standard_parser(verbose=True)

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        add_cache(config)

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

        index_location = config['index_dir']

        repo_location = self.options.repo_location \

            if self.options.repo_location else RepoModel().repos_path

        repo_list = map(strip, self.options.repo_list.split(',')) \

            if self.options.repo_list else None

        repo_update_list = map(strip, self.options.repo_update_list.split(',')) \

            if self.options.repo_update_list else None

        load_rcextensions(config['here'])

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

        # WHOOSH DAEMON

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

        from rhodecode.lib.pidlock import LockHeld, DaemonLock

        from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

        try:

            l = DaemonLock(file_=jn(dn(dn(index_location)), 'make_index.lock'))

            WhooshIndexingDaemon(index_location=index_location,

                                 repo_location=repo_location,

                                 repo_list=repo_list,

                                 repo_update_list=repo_update_list)\

                .run(full_index=self.options.full_index)

            l.release()

        except LockHeld:

            sys.exit(1)

    def update_parser(self):

        self.parser.add_option('--repo-location',

                          action='store',

                          dest='repo_location',

                          help="Specifies repositories location to index OPTIONAL",

                          )

        self.parser.add_option('--index-only',

                          action='store',

                          dest='repo_list',

                          help="Specifies a comma separated list of repositores "

                                "to build index on. If not given all repositories "

                                "are scanned for indexing. OPTIONAL",

                          )

        self.parser.add_option('--update-only',

                          action='store',

                          dest='repo_update_list',

                          help="Specifies a comma separated list of repositores "

                                "to re-build index on. OPTIONAL",

                          )

        self.parser.add_option('-f',

                          action='store_true',

                          dest='full_index',

                          help="Specifies that index should be made full i.e"

                                " destroy old and build from scratch",

                          default=False)

class WhooshResultWrapper(object):

    def __init__(self, search_type, searcher, matcher, highlight_items,

                 repo_location):

        self.search_type = search_type

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

        self.fragment_size = 200

        self.repo_location = repo_location

    @LazyProperty

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

            docnum = self.matcher.id()

            chunks = [offsets for offsets in self.get_chunks()]

            docs_id.append([docnum, chunks])

            self.matcher.next()

        return docs_id

    def __str__(self):

        return '<%s at %s>' % (self.__class__.__name__, len(self.doc_ids))

    def __repr__(self):

        return self.__str__()

    def __len__(self):

        return len(self.doc_ids)

    def __iter__(self):

        """

        Allows Iteration over results,and lazy generate content

        *Requires* implementation of ``__getitem__`` method.

        """

        for docid in self.doc_ids:

            yield self.get_full_content(docid)

    def __getitem__(self, key):

        """

        Slicing of resultWrapper

        """

        i, j = key.start, key.stop

        slices = []

        for docid in self.doc_ids[i:j]:

            slices.append(self.get_full_content(docid))

        return slices

    def get_full_content(self, docid):

        res = self.searcher.stored_fields(docid[0])

        log.debug('result: %s' % res)

        if self.search_type == 'content':

            full_repo_path = jn(self.repo_location, res['repository'])

            f_path = res['path'].split(full_repo_path)[-1]

            f_path = f_path.lstrip(os.sep)

            content_short = self.get_short_content(res, docid[1])

            res.update({'content_short': content_short,

                        'content_short_hl': self.highlight(content_short),

                        'f_path': f_path

                      })

        elif self.search_type == 'message':

            res.update({'message_hl': self.highlight(res['message'])})

        log.debug('result: %s' % res)

        return res

    def get_short_content(self, res, chunks):

        return ''.join([res['content'][chunk[0]:chunk[1]] for chunk in chunks])

    def get_chunks(self):

        """

        Smart function that implements chunking the content

        but not overlap chunks so it doesn't highlight the same

        close occurrences twice.

        :param matcher:

        :param size:

        """

        memory = [(0, 0)]

            for span in self.matcher.spans():

                start = span.startchar or 0

                end = span.endchar or 0

                start_offseted = max(0, start - self.fragment_size)

                end_offseted = end + self.fragment_size

                if start_offseted < memory[-1][1]:

                    start_offseted = memory[-1][1]

                memory.append((start_offseted, end_offseted,))

                yield (start_offseted, end_offseted,)

    def highlight(self, content, top=5):

        if self.search_type not in ['content', 'message']:

            return ''

        hl = highlight(

            text=content,

            terms=self.highlight_items,

            analyzer=ANALYZER,

            fragmenter=FRAGMENTER,

            formatter=FORMATTER,

            top=top

        )

        return hl

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

"""

    rhodecode.lib.middleware.simplehg

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

    SimpleHG middleware for handling mercurial protocol request

    (push/clone etc.). It's implemented with basic auth function

    :created_on: Apr 28, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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

import urllib

from mercurial.error import RepoError

from mercurial.hgweb import hgweb_mod

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

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

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.utils2 import safe_str

from rhodecode.lib.base import BaseVCSController

from rhodecode.lib.auth import get_container_username

from rhodecode.lib.utils import make_ui, is_valid_repo, ui_sections

from rhodecode.model.db import User

log = logging.getLogger(__name__)

def is_mercurial(environ):

    """

    Returns True if request's target is mercurial server - header

    ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.

    """

    http_accept = environ.get('HTTP_ACCEPT')

    path_info = environ['PATH_INFO']

    if http_accept and http_accept.startswith('application/mercurial'):

        ishg_path = True

    else:

        ishg_path = False

    log.debug('pathinfo: %s detected as HG %s' % (

        path_info, ishg_path)

    )

    return ishg_path

class SimpleHg(BaseVCSController):

    def _handle_request(self, environ, start_response):

        if not is_mercurial(environ):

            return self.application(environ, start_response)

        if not self._check_ssl(environ, start_response):

            return HTTPNotAcceptable('SSL REQUIRED !')(environ, start_response)

        ipaddr = self._get_ip_addr(environ)

        # skip passing error to error controller

        environ['pylons.status_code_redirect'] = True

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

        # EXTRACT REPOSITORY NAME FROM ENV

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

        try:

            repo_name = environ['REPO_NAME'] = self.__get_repository(environ)

            log.debug('Extracted repo name is %s' % repo_name)

        except:

            return HTTPInternalServerError()(environ, start_response)

        # quick check if that dir exists...

        if is_valid_repo(repo_name, self.basepath) is False:

            return HTTPNotFound()(environ, start_response)

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

        # GET ACTION PULL or PUSH

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

        action = self.__get_action(environ)

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

        # CHECK ANONYMOUS PERMISSION

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

        if action in ['pull', 'push']:

            anonymous_user = self.__get_user('default')

            username = anonymous_user.username

            anonymous_perm = self._check_permission(action, anonymous_user,

                                                    repo_name)

            if anonymous_perm is not True or anonymous_user.active is False:

                if anonymous_perm is not True:

                    log.debug('Not enough credentials to access this '

                              'repository as anonymous user')

                if anonymous_user.active is False:

                    log.debug('Anonymous access is disabled, running '

                              'authentication')

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

                # DEFAULT PERM FAILED OR ANONYMOUS ACCESS IS DISABLED SO WE

                # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS

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

                # Attempting to retrieve username from the container

                username = get_container_username(environ, self.config)

                # If not authenticated by the container, running basic auth

                if not username:

                    self.authenticate.realm = \

                        safe_str(self.config['rhodecode_realm'])

                    result = self.authenticate(environ)

                    if isinstance(result, str):

                        AUTH_TYPE.update(environ, 'basic')

                        REMOTE_USER.update(environ, result)

                        username = result

                    else:

                        return result.wsgi_application(environ, start_response)

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

                # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME

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

                try:

                    user = self.__get_user(username)

                    if user is None or not user.active:

                        return HTTPForbidden()(environ, start_response)

                    username = user.username

                except:

                    log.error(traceback.format_exc())

                    return HTTPInternalServerError()(environ, start_response)

                #check permissions for this repository

                perm = self._check_permission(action, user, repo_name)

                if perm is not True:

                    return HTTPForbidden()(environ, start_response)

        # extras are injected into mercurial UI object and later available

        # in hg hooks executed by rhodecode

        extras = {

            'ip': ipaddr,

            'username': username,

            'action': action,

            'repository': repo_name,

            'scm': 'hg',

        }

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

        # MERCURIAL REQUEST HANDLING

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

        repo_path = os.path.join(safe_str(self.basepath), safe_str(repo_name))

        log.debug('Repository path is %s' % repo_path)

        baseui = make_ui('db')

        self.__inject_extras(repo_path, baseui, extras)

        try:

            # invalidate cache on push

            if action == 'push':

                self._invalidate_cache(repo_name)

            log.info('%s action on HG repo "%s"' % (action, repo_name))

            app = self.__make_app(repo_path, baseui, extras)

            return app(environ, start_response)

        except RepoError, e:

            if str(e).find('not found') != -1:

                return HTTPNotFound()(environ, start_response)

        except Exception:

            log.error(traceback.format_exc())

            return HTTPInternalServerError()(environ, start_response)

    def __make_app(self, repo_name, baseui, extras):

        """

        Make an wsgi application using hgweb, and inject generated baseui

        instance, additionally inject some extras into ui object

        """

        return hgweb_mod.hgweb(repo_name, name=repo_name, baseui=baseui)

    def __get_repository(self, environ):

        """

        Get's repository name out of PATH_INFO header

        :param environ: environ where PATH_INFO is stored

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])

            repo_name = '/'.join(environ['PATH_INFO'].split('/')[1:])

            if repo_name.endswith('/'):

                repo_name = repo_name.rstrip('/')

        except:

            log.error(traceback.format_exc())

            raise

        return repo_name

    def __get_user(self, username):

        return User.get_by_username(username)

    def __get_action(self, environ):

        """

        Maps mercurial request commands into a clone,pull or push command.

        This should always return a valid command string

        :param environ:

        """

        mapping = {'changegroup': 'pull',

                   'changegroupsubset': 'pull',

                   'stream_out': 'pull',

                   'listkeys': 'pull',

                   'unbundle': 'push',

                   'pushkey': 'push', }

        for qry in environ['QUERY_STRING'].split('&'):

            if qry.startswith('cmd'):

                cmd = qry.split('=')[-1]

                if cmd in mapping:

                    return mapping[cmd]

                return 'pull'

        raise Exception('Unable to detect pull/push action !!'

                        'Are you using non standard command or client ?')

    def __inject_extras(self, repo_path, baseui, extras={}):

        """

        Injects some extra params into baseui instance

        also overwrites global settings with those takes from local hgrc file

        :param baseui: baseui instance

        :param extras: dict with extra params to put into baseui

        """

        hgrc = os.path.join(repo_path, '.hg', 'hgrc')

        # make our hgweb quiet so it doesn't print output

        baseui.setconfig('ui', 'quiet', 'true')

        #inject some additional parameters that will be available in ui

        #for hooks

        for k, v in extras.items():

            baseui.setconfig('rhodecode_extras', k, v)

        repoui = make_ui('file', hgrc, False)

        if repoui:

            #overwrite our ui instance with the section from hgrc file

            for section in ui_sections:

                for k, v in repoui.configitems(section):

                    baseui.setconfig(section, k, v)

"""

Email message and email sending related helper functions.

"""

import socket

# Cache the hostname, but do it lazily: socket.getfqdn() can take a couple of

# seconds, which slows down the restart of the server.

class CachedDnsName(object):

    def __str__(self):

        return self.get_fqdn()

    def get_fqdn(self):

        if not hasattr(self, '_fqdn'):

            self._fqdn = socket.getfqdn()

        return self._fqdn

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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('My Notifications')} ${c.rhodecode_user.username} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${_('My Notifications')}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

        ##<ul class="links">

        ##    <li>

        ##      <span style="text-transform: uppercase;"><a href="#">${_('Compose message')}</a></span>

        ##    </li>

        ##</ul>

    </div>

      <div style="padding:14px 18px;text-align: right;float:left">

      <span id='all' class="ui-btn"><a href="${h.url.current()}">${_('All')}</a></span>

      <span id='comment' class="ui-btn"><a href="${h.url.current(type=c.comment_type)}">${_('Comments')}</a></span>

      <span id='pull_request' class="ui-btn"><a href="${h.url.current(type=c.pull_request_type)}">${_('Pull requests')}</a></span>

      </div>

      %if c.notifications:

      <div style="padding:14px 18px;text-align: right;float:right">

      <span id='mark_all_read' class="ui-btn">${_('Mark all read')}</span>

      </div>

      %endif

  <div id='notification_data'>

    <%include file='notifications_data.html'/>

  </div>

</div>

<script type="text/javascript">

var url_action = "${url('notification', notification_id='__NOTIFICATION_ID__')}";

var run = function(){

  YUE.on(YUQ('.delete-notification'),'click',function(e){

   var notification_id = e.currentTarget.id;

   deleteNotification(url_action,notification_id)

  })

  YUE.on(YUQ('.read-notification'),'click',function(e){

     var notification_id = e.currentTarget.id;

     readNotification(url_action,notification_id)

  })

}

run()

YUE.on('mark_all_read','click',function(e){

    var url = "${h.url('notifications_mark_all_read', **request.GET.mixed())}";

    ypjax(url,'notification_data',function(){run()});

})

var current_filter = "${c.current_filter}";

if (YUD.get(current_filter)){

	YUD.addClass(current_filter, 'active');

}

</script>

</%def>

%if c.notifications:

<%

unread = lambda n:{False:'unread'}.get(n)

%>

<div class="notification-list  notification-table">

%for notification in c.notifications:

  <div id="notification_${notification.notification.notification_id}" class="container ${unread(notification.read)}">

    <div class="notification-header">

      <div class="gravatar">

          <img alt="gravatar" src="${h.gravatar_url(h.email(notification.notification.created_by_user.email),24)}"/>

      </div>

      <div class="desc ${unread(notification.read)}">

      <a href="${url('notification', notification_id=notification.notification.notification_id)}">${notification.notification.description}</a>

      </div>

      <div class="delete-notifications">

        <span id="${notification.notification.notification_id}" class="delete-notification delete_icon action"></span>

      </div>

      %if not notification.read:

      <div class="read-notifications">

        <span id="${notification.notification.notification_id}" class="read-notification accept_icon action"></span>

      %endif

    </div>

    <div class="notification-subject">${h.literal(notification.notification.subject)}</div>

  </div>

%endfor

</div>

<div class="notification-paginator">

  <div class="pagination-wh pagination-left">

  ${c.notifications.pager('$link_previous ~2~ $link_next',**request.GET.mixed())}

  </div>

</div>

%else:

    <div class="table">${_('No notifications here yet')}</div>

%endif

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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Repositories administration')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/> ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; <span id="repo_count">0</span> ${_('repositories')}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <div class="title">

        ${self.breadcrumbs()}

        <ul class="links">

          <li>

            <span>${h.link_to(_(u'ADD REPOSITORY'),h.url('new_repo'))}</span>

          </li>

        </ul>

    </div>

    <div class="table yui-skin-sam" id="repos_list_wrap"></div>

    <div id="user-paginator" style="padding: 0px 0px 0px 20px"></div>

</div>

<script>

  var url = "${h.url('formatted_users', format='json')}";

  var data = ${c.data|n};

  var myDataSource = new YAHOO.util.DataSource(data);

  myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSON;