"""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

from pylons_app.lib.utils import check_repo_fast as cr

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

    def check_repo(environ, match_dict):

        """

        check for valid repository for proper 404 handling

        @param environ:

        @param match_dict:

        """

        repo_name = match_dict.get('repo_name')

        return not cr(repo_name, config['base_path'])

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

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

            conditions=dict(method=["GET"]))

        m.connect("new_repo", "/repos/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("repo", "/repos/{repo_name:.*}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        #ajax delete repo perm user

        m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",

             action="delete_perm_user", conditions=dict(method=["DELETE"],

                                                        function=check_repo))

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

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

    #ADMIN

    with map.submapper(path_prefix='/_admin', controller='admin/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')

    #LOGIN/LOGOUT

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

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

    map.connect('register', '/_admin/register', controller='login', action='register')

    #FEEDS

    map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',

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

                conditions=dict(function=check_repo))

    map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',

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

                conditions=dict(function=check_repo))

    #OTHERS

    map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',

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

#!/usr/bin/env python

# encoding: utf-8

# repos controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

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

"""

Created on April 7, 2010

admin controller for pylons

@author: marcink

"""

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 pylons_app.lib.auth import LoginRequired, HasPermissionAllDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import repo2db_mapper, invalidate_cache, \

    set_hg_app_config

from pylons_app.model.db import User, UserLog, HgAppSettings

from pylons_app.model.forms import UserForm, ApplicationSettingsForm

from pylons_app.model.hg_model import HgModel

from pylons_app.model.user_model import UserModel

import formencode

import logging

import traceback

log = logging.getLogger(__name__)

class SettingsController(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('setting', 'settings', controller='admin/settings', 

    #         path_prefix='/admin', name_prefix='admin_')

    @LoginRequired()

    def __before__(self):

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

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

        hgsettings = self.sa.query(HgAppSettings).scalar()

        defaults = hgsettings.__dict__ if hgsettings else {}

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )  

    def create(self):

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

        # url('admin_settings')

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

        """GET /admin/settings/new: Form to create a new item"""

        # url('admin_new_setting')

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

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

        # Or using helpers:

        #           method='put')

            rm_obsolete = request.POST.get('destroy', False)

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

            h.flash(_('Repositories sucessfully rescanned'), category='success')            

            application_form = ApplicationSettingsForm()()

            try:

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

                title = form_result['app_title']

                realm = form_result['app_auth_realm']

                try:

                    hgsettings = self.sa.query(HgAppSettings).get(1)

                    hgsettings.app_auth_realm = realm

                    hgsettings.app_title = title

                    self.sa.add(hgsettings)

                    self.sa.commit()

                    set_hg_app_config(config)

                    h.flash(_('Updated application settings'),

                            category='success')

                except:

                    log.error(traceback.format_exc())

                    h.flash(_('error occured during chaning application settings'),

                            category='error')

                    self.sa.rollback()

            except formencode.Invalid as errors:

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8") 

        return redirect(url('admin_settings'))

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

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

        # Or using helpers:

        #           method='delete')

#!/usr/bin/env python

# encoding: utf-8

# users controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

# 

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

from formencode import htmlfill

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

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.db import User, UserLog

from pylons_app.model.forms import UserForm

from pylons_app.model.user_model import UserModel, DefaultUserException

import formencode

import logging

import traceback

log = logging.getLogger(__name__)

class UsersController(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('user', 'users')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

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

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

        super(UsersController, self).__before__()

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

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

        # url('users')

        c.users_list = self.sa.query(User).all()     

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

        self.is_authenticated = False

        self.is_admin = False

        self.permissions = {}

def set_available_permissions(config):

    """

    This function will propagate pylons globals with all available defined

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

    try:

        sa = meta.Session

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

    finally:

        meta.Session.remove()

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

    """

    Fills user permission attribute with permissions taken from database

    @param user:

    """

    sa = meta.Session

    user.permissions['repositories'] = {}

    #first fetch default permissions

    default_perms = sa.query(Repo2Perm, Repository, Permission)\

        .join((Repository, Repo2Perm.repository_id == Repository.repo_id))\

        .join((Permission, Repo2Perm.permission_id == Permission.permission_id))\

        .filter(Repo2Perm.user_id == sa.query(User).filter(User.username == 

                                            'default').one().user_id).all()

    if user.is_admin:

        #admin have all rights full

        for perm in default_perms:

            p = 'repository.admin'

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

    else:

        for perm in default_perms:

            if perm.Repository.private:

                #disable defaults for private repos,

                p = 'repository.none'

            elif perm.Repository.user_id == user.user_id:

                #set admin if owner

                p = 'repository.admin'

            else:

                p = perm.Permission.permission_name

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

        user_perms = sa.query(Repo2Perm, Permission, Repository)\

            .join((Repository, Repo2Perm.repository_id == Repository.repo_id))\

            .join((Permission, Repo2Perm.permission_id == Permission.permission_id))\

            .filter(Repo2Perm.user_id == user.user_id).all()

        #overwrite userpermissions with defaults

        for perm in user_perms:

            #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.repo_name] = p

    meta.Session.remove()         

    return user

def get_user(session):

    """

    Gets user from session, and wraps permissions into user

    @param session:

    """

    user = session.get('hg_app_user', AuthUser())

    if user.is_authenticated:

        user = fill_perms(user)

    session['hg_app_user'] = user

    session.save()

    return user

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

# CHECK DECORATORS

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

class LoginRequired(object):

    """

    Must be logged in to execute this function else redirect to login page

    """

    def __call__(self, func):

        @wraps(func)

        def _wrapper(*fargs, **fkwargs):

            user = session.get('hg_app_user', AuthUser())

            log.debug('Checking login required for user:%s', user.username)

            if user.is_authenticated:

                log.debug('user %s is authenticated', user.username)

                func(*fargs)

            else:

                log.warn('user %s not authenticated', user.username)

                log.debug('redirecting to login page')

        new_user = User()

        new_user.username = username

        new_user.password = get_crypt_password(password)

        new_user.name = 'Hg'

        new_user.lastname = 'Admin'

        new_user.email = 'admin@localhost'

        new_user.admin = admin

        new_user.active = True

        try:

            self.sa.add(def_user)

            self.sa.add(new_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def create_permissions(self):

        #module.(access|create|change|delete)_[name]

        #module.(read|write|owner)

        perms = [('repository.none', 'Repository no access'),

                 ('repository.read', 'Repository read access'),

                 ('repository.write', 'Repository write access'),

                 ('repository.admin', 'Repository admin access'),

                 ('hg.admin', 'Hg Administrator'),

        for p in perms:

            new_perm = Permission()

            new_perm.permission_name = p[0]

            new_perm.permission_longname = p[1]

            try:

                self.sa.add(new_perm)

                self.sa.commit()

            except:

                self.sa.rollback()

                raise

                setattr(new_user, k, v)

            self.sa.add(new_user)

            self.sa.commit()

        except Exception as e:

            log.error(e)

            self.sa.rollback()

            raise      

    def create_registration(self, form_data):

        try:

            new_user = User()

            for k, v in form_data.items():

                if k != 'admin' or k != 'active':

                    setattr(new_user, k, v)

                setattr(new_user, 'active', True)

            self.sa.add(new_user)

            self.sa.commit()

        except Exception as e:

            log.error(e)

            self.sa.rollback()

            raise      

        try:

            if new_user.username == 'default':

                raise DefaultUserException(

                                _("You can't Edit this user since it's" 

                                  " crucial for entire application"))

            for k, v in form_data.items():

                if k == 'new_password' and v != '':

                    new_user.password = v

                else:

                    setattr(new_user, k, v)

            self.sa.add(new_user)

            self.sa.commit()

        except Exception as e:

            log.error(e)

            self.sa.rollback()

            raise      

    def delete(self, id):

        try:

            user = self.sa.query(User).get(id)

            if user.username == 'default':

                raise DefaultUserException(

                                _("You can't remove this user since it's" 

                                  " crucial for entire application"))

            self.sa.delete(user)

            self.sa.commit()            

        except Exception as e:

            log.error(e)

            self.sa.rollback()

            raise        

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

<%def name="title()">

    ${_('Settings administration')}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))} » ${_('Settings')}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}       

    </div>

    <!-- end box / title -->

    <div class="form">

        <!-- fields -->

        <h3>${_('Remap and rescan repositories')}</h3>

        <div class="fields">

			<div class="field">

		        <div class="label label-checkbox">

		            <label for="-button">${_('rescan option')}:</label>

		        </div>

		        <div class="checkboxes">

		            <div class="checkbox">

		                ${h.checkbox('destroy',True)}

		                <label for="checkbox-1">

		                <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> </label>

		            </div>

		        </div>

			</div>

            <div class="buttons">

            ${h.submit('rescan','rescan repositories',class_="ui-button ui-widget ui-state-default ui-corner-all")}</td>

            </div>                                                          

        </div>

    </div>  

    ${h.end_form()}

    <div class="form">

        <!-- fields -->

        <h3>${_('Global application settings')}</h3>

        <div class="fields">

             <div class="field">

                <div class="label">

                    <label for="input-small">${_('Application name')}:</label>

                </div>

                <div class="input">

                    ${h.text('app_title',size=30)}

                </div>

             </div>

            <div class="field">

                <div class="label">

                    <label for="input-small">${_('Realm text')}:</label>

                </div>

                <div class="input">

                    ${h.text('app_auth_realm',size=30)}

                </div>

            </div>

            <div class="buttons">