"""Routes configuration

The more specific and detailed routes should be defined first so they

may take precedent over the more generic routes. For more information

refer to the routes manual at http://routes.groovie.org/docs/

"""

from routes import Mapper

def make_map(config):

    """Create, configure and return the routes Mapper"""

    map = Mapper(directory=config['pylons.paths']['controllers'],

                 always_scan=config['debug'])

    map.minimization = False

    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    map.connect('/error/{action}', controller='error')

    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE

    map.connect('hg_home', '/', controller='hg', action='index')

    map.resource('user', 'users', path_prefix='/_admin')

    map.resource('permission', 'permissions', path_prefix='/_admin')

    #ADMIN

    with map.submapper(path_prefix='/_admin', controller='admin') as m:

        m.connect('admin_home', '/', action='index')#main page

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

    #FEEDS

                controller='feed', action='rss')

                controller='feed', action='atom')

    map.connect('login_home', '/login', controller='login')

    map.connect('logout_home', '/logout', controller='login', action='logout')

                controller='changeset', revision='tip')

                controller='summary')

                controller='shortlog')

                controller='branches')

                controller='tags')

                controller='changelog')    

                controller='files', revision='tip', f_path='')

                controller='files', action='diff', revision='tip', f_path='')

                controller='files', action='rawfile', revision='tip', f_path='')

                controller='files', action='annotate', revision='tip', f_path='')    

                controller='files', action='archivefile', revision='tip')

    return map

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

    app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.auth import LoginRequired

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.filters import clean_repo

from pylons_app.lib.utils import check_repo, invalidate_cache

from pylons_app.model.hg_model import HgModel

import logging

import os

import shutil

from operator import itemgetter

log = logging.getLogger(__name__)

class ReposController(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('repo', 'repos')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

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

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

        # url('repos')

        cached_repo_list = HgModel().get_repos()

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

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

    def create(self):

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

        # url('repos')

        name = request.POST.get('name')

        try:

            self._create_repo(name)

            #clear our cached list for refresh with new repo

            invalidate_cache('cached_repo_list')

        except Exception as e:

            log.error(e)

        return redirect('repos')

    def _create_repo(self, repo_name):        

        repo_path = os.path.join(g.base_path, repo_name)

        if check_repo(repo_name, g.base_path):

            log.info('creating repo %s in %s', repo_name, repo_path)

            from vcs.backends.hg import MercurialRepository

            MercurialRepository(repo_path, create=True)

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

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

        new_repo = request.GET.get('repo', '')

        c.new_repo = clean_repo(new_repo)

        return render('admin/repos/repo_add.html')

    def update(self, id):

        """PUT /repos/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('repo', id=ID),

        #           method='put')

        # url('repo', id=ID)

    def delete(self, id):

        """DELETE /repos/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('repo', id=ID),

        #           method='delete')

        # url('repo', id=ID)

        from datetime import datetime

        path = g.paths[0][1].replace('*', '')

        rm_path = os.path.join(path, id)

        log.info("Removing %s", rm_path)

        shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))

        shutil.move(rm_path, os.path.join(path, 'rm__%s-%s' % (datetime.today(), id)))

        #clear our cached list for refresh with new repo

        invalidate_cache('cached_repo_list')

        return redirect(url('repos'))

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

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

        # url('repo', id=ID)

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

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

        # url('edit_repo', id=ID)

        c.new_repo = id

        return render('admin/repos/repo_edit.html')

    def __init__(self, application, config):

        self.application = application

        self.config = config

        #authenticate this mercurial request using 

        realm = '%s %s' % (config['hg_app_name'], 'mercurial repository')

        self.authenticate = AuthBasicAuthenticator(realm, authfunc)

    def __call__(self, environ, start_response):

        if not is_mercurial(environ):

            return self.application(environ, start_response)

        else:

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

            # AUTHENTICATE THIS MERCURIAL REQUEST

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

            username = REMOTE_USER(environ)

            if not username:

                result = self.authenticate(environ)

                if isinstance(result, str):

                    AUTH_TYPE.update(environ, 'basic')

                    REMOTE_USER.update(environ, result)

                else:

                    return result.wsgi_application(environ, start_response)

            try:

                return HTTPNotFound()(environ, start_response)

            #since we wrap into hgweb, just reset the path

            environ['PATH_INFO'] = '/'

            self.baseui = make_ui(self.config['hg_app_repo_conf'])

            self.basepath = self.baseui.configitems('paths')[0][1]\

                                                            .replace('*', '')

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

            try:

                app = wsgiapplication(self.__make_app)

            except Exception as e:

                return HTTPNotFound()(environ, start_response)

            action = self.__get_action(environ)            

            #invalidate cache on push

            if action == 'push':

                self.__invalidate_cache(repo_name)

            if action:

                username = self.__get_environ_user(environ)

                self.__log_user_action(username, action, repo_name)

            return app(environ, start_response)            

    def __make_app(self):

        hgserve = hgweb(self.repo_path)

        return  self.__load_web_settings(hgserve)

    def __get_environ_user(self, environ):

        return environ.get('REMOTE_USER')

    def __get_action(self, environ):

        """

        Maps mercurial request commands into a pull or push command.

        @param environ:

        """

import os

import logging

from mercurial import ui, config, hg

from mercurial.error import RepoError

log = logging.getLogger(__name__)

def get_repo_slug(request):

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')

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

        return True

    return False

def check_repo_dir(paths):

    repos_path = paths[0][1].split('/')

    if repos_path[-1] in ['*', '**']:

        repos_path = repos_path[:-1]

    if repos_path[0] != '/':

        repos_path[0] = '/'

    if not os.path.isdir(os.path.join(*repos_path)):

        raise Exception('Not a valid repository in %s' % paths[0][1])

def check_repo(repo_name, base_path):

    repo_path = os.path.join(base_path, repo_name)

        from pylons_app.model.hg_model import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from pylons_app.model.hg_model import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

class EmptyChangeset(BaseChangeset):

    revision = -1

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifing this changeset, useful for web

        representation.

        """

        return '0' * 12

def repo2db_mapper():

    """

    """

            """

            Checks the repository

            :param path:

            """

            repos_path = path.split('/')

            if repos_path[-1] in ['*', '**']:

                repos_path = repos_path[:-1]

            if repos_path[0] != '/':

                repos_path[0] = '/'

            if not os.path.isdir(os.path.join(*repos_path)):

                raise RepositoryError('Not a valid repository in %s' % path[0][1])        

        if not repos_path.endswith('*'):

            raise VCSError('You need to specify * or ** at the end of path '

                            'for recursive scanning')

        check_repo_dir(repos_path)

        log.info('scanning for repositories in %s', repos_path)

        repos = findrepos([(repos_prefix, repos_path)])

        if not isinstance(baseui, ui.ui):

            baseui = ui.ui()

        repos_list = {}

        for name, path in repos:

            try:

                repos_list[name] = MercurialRepository(path, baseui=baseui)

            except OSError:

                continue

        return repos_list

    def get_repos(self):

        for name, repo in _get_repos_cached().items():

            if repo._get_hidden():

                #skip hidden web repository

                continue

            last_change = repo.last_change

            try:

                tip = repo.get_changeset('tip')

            except RepositoryError:

                from pylons_app.lib.utils import EmptyChangeset

                tip = EmptyChangeset()

            tmp_d = {}

            tmp_d['name'] = repo.name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['description'] = repo.description

            tmp_d['description_sort'] = tmp_d['description']

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = last_change[1] - last_change[0]