@LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')        

    def index(self):

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

        c.users_log = Page(users_log, page=p, items_per_page=10)

        c.log_data = render('admin/admin_log.html')

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

            return c.log_data

        return render('admin/admin.html')    

"""

Created on July 14, 2010

settings controller for pylons

@author: marcink

"""

from formencode import htmlfill

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from pylons_app.lib import helpers as h

from pylons_app.lib.auth import LoginRequired, HasPermissionAllDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.model.hg_model import HgModel

from pylons_app.model.user_model import UserModel

import formencode

import logging

log = logging.getLogger(__name__)

class SettingsController(BaseController):

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

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

        super(SettingsController, self).__before__()

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

        """GET /admin/settings: All items in the collection"""

        # url('admin_settings')

    def create(self):

        """POST /admin/settings: Create a new item"""

        # url('admin_settings')

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

            log.debug('Rescanning directories with destroy=%s', rm_obsolete)

            initial = HgModel.repo_scan(g.paths[0][0], g.paths[0][1], g.baseui)

            repo2db_mapper(initial, rm_obsolete)

            invalidate_cache('cached_repo_list')

        return redirect(url('admin_settings'))

            c.form_errors = errors.error_dict

            return htmlfill.render(

                 render('admin/users/user_add.html'),

                defaults=errors.value,

                encoding="UTF-8")

        except Exception:

            h.flash(_('error occured during creation of user') \

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

        return redirect(url('users'))

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

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

    return crypt.crypt(password, '6a')

@cache_region('super_short_term', 'cached_user')

def get_user_cached(username):

    sa = meta.Session

    user = sa.query(User).filter(User.username == username).one()

    return user

def authfunc(environ, username, password):

    password_crypt = get_crypt_password(password)

    try:

        user = get_user_cached(username)

    permission given in db. We don't wannt to check each time from db for new 

    permissions since adding a new permission also requires application restart

    ie. to decorate new views with the newly created permission

    @param config:

    """

    log.info('getting information about all available permissions')

    sa = meta.Session

    all_perms = sa.query(Permission).all()

    config['available_permissions'] = [x.permission_name for x in all_perms]

def set_base_path(config):

    config['base_path'] = config['pylons.app_globals'].base_path

def fill_perms(user):

            #set write if owner

            if perm.Repository.user_id == user.user_id:

                p = 'repository.write'

            else:

                p = perm.Permission.permission_name

            user.permissions['repositories'][perm.Repo2Perm.repository] = p            

    return user

def get_user(session):

    """

    Gets user from session, and wraps permissions into user

    @param session:

ROOT = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(ROOT)

from pylons_app.lib.auth import get_crypt_password

from pylons_app.model import init_model

from pylons_app.model.db import User, Permission, HgAppUi, HgAppSettings

from sqlalchemy.engine import create_engine

import logging

log = logging.getLogger('db manage')

log.setLevel(logging.DEBUG)

console_handler = logging.StreamHandler()

class DbManage(object):

    def __init__(self, log_sql):

        self.dbname = 'hg_app.db'

        dburi = 'sqlite:////%s' % jn(ROOT, self.dbname)

        engine = create_engine(dburi, echo=log_sql) 

        init_model(engine)

        self.db_exists = False

    def check_for_db(self, override):

        log.info('checking for exisiting db')

        if os.path.isfile(jn(ROOT, self.dbname)):

            self.db_exists = True

        """

        self.check_for_db(override)

        if override:

            log.info("database exisist and it's going to be destroyed")

            if self.db_exists:

                os.remove(jn(ROOT, self.dbname))

        log.info('Created tables for %s', self.dbname)

    def admin_prompt(self):

        import getpass

        username = raw_input('Specify admin username:')

        password = getpass.getpass('Specify admin password:')

class SimpleHg(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        #authenticate this mercurial request using 

    def __call__(self, environ, start_response):

        if not is_mercurial(environ):

            return self.application(environ, start_response)

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

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

            sa.commit()

            log.info('Adding user %s, action %s on %s',

                                            user.username, action, repo)

        except Exception as e:

            sa.rollback()

            log.error('could not log user action:%s', str(e))

    def __invalidate_cache(self, repo_name):

        """we know that some change was made to repositories and we should

        invalidate the cache to see the changes right away but only for

        push requests"""

        invalidate_cache('cached_repo_list')

import os

import logging

from mercurial import ui, config, hg

from mercurial.error import RepoError

from pylons_app.model.db import Repository, User, HgAppUi, HgAppSettings

log = logging.getLogger(__name__)

def get_repo_slug(request):

    return request.environ['pylons.routes_dict'].get('repo_name')

        log.info('%s repo is free for creation', repo_name)

        return True

@cache_region('super_short_term', 'cached_hg_ui')

def get_hg_ui_cached():

def get_hg_settings():

    ret = sa.query(HgAppSettings).scalar()

    if not ret:

        raise Exception('Could not get application settings !')

    return ret

def make_ui(read_from='file', path=None, checkpaths=True):        

    """

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    from pylons_app.model.repo_model import RepoModel

    user = sa.query(User).filter(User.admin == True).first()

    rm = RepoModel()

    for name, repo in initial_repo_list.items():

        if not sa.query(Repository).get(name):

        #remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                sa.delete(repo)

                sa.commit()

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidPerms, ValidSettings]

    return _RepoForm

"""

from beaker.cache import cache_region

from mercurial import ui

from mercurial.hgweb.hgwebdir_mod import findrepos

from vcs.exceptions import RepositoryError, VCSError

from pylons_app.model.db import Repository

from sqlalchemy.orm import joinedload

import logging

import os

import sys

log = logging.getLogger(__name__)

        """

        Listing of repositories in given path. This path should not be a 

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory it could take syntax with 

        * or ** for deep recursive displaying repositories

        """

        def check_repo_dir(path):

            """

            Checks the repository

            :param path:

            """

            repos_path = path.split('/')

                    if dbrepo:

                        repos_list[name].dbrepo = dbrepo

                        repos_list[name].description = dbrepo.description

                        repos_list[name].contact = dbrepo.user.full_contact

            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

	<div>

	<h2>${_('Settings administration')}</h2>

     ${h.form(url('admin_setting', id='mapping'),method='put')}

       <table class="table_disp">

           <tr class="header">

           </tr>

           <tr align="right">

            <td><span class="tooltip" tooltip_title="${h.tooltip(_('In case a repository was deleted from filesystem and there are leftovers in the database check this option to scan obsolete data in database and remove it.'))}">

            ${_('destroy old data')}</span> ${h.checkbox('destroy',True)}</td>

            <td>${h.submit('rescan','rescan repositories')}</td>   

       </table>

	   <table class="table_disp">

	       <tr class="header">

	           <td colspan="3">${_('Global application settings')}</td>

	       </tr>

	       <tr>

	           <td>${_('Application name')}</td>

	       </tr>

           <tr>

               <td>${_('Realm text')}</td>

           </tr>

           <tr>

	           <td></td>

	           <td>${h.submit('save','save settings')}</td>   

           </tr>

	   </table>

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

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

<%def name="title()">

</%def>

<%def name="breadcrumbs()">

</%def>

<%def name="page_nav()">

	${self.menu('home')}

</%def>

<%def name="main()">

	<%def name="get_sort(name)">

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

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

<%def name="title()">

</%def>

<%def name="breadcrumbs()">

</%def>

<%def name="page_nav()">

	 

	</div>

</%def>

<%def name="main()">