^\.settings$

syntax: regexp

^\.project$

syntax: regexp

^\.pydevproject$

syntax: regexp

syntax: regexp

^test\.db$

syntax: regexp

^repositories\.config$

include COPYING

include README.rst

include rhodecode/config/deployment.ini_tmpl

recursive-include rhodecode/public/css *

recursive-include rhodecode/public/images *

include rhodecode/public/js/yui2.js

include rhodecode/public/js/excanvas.min.js

logview.pylons.templating = #bfb

logview.pylons.util = #eee

#########################################################

### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###

#########################################################

#sqlalchemy.db1.echo = False

#sqlalchemy.db1.pool_recycle = 3600

sqlalchemy.convert_unicode = true

################################

### LOGGING CONFIGURATION   ####

#!/sbin/runscript

########################################

#### THIS IS AN GENTOO INIT.D SCRIPT####

########################################

APP_HOMEDIR="marcink/python_workspace"

APP_PATH="/home/$APP_HOMEDIR/$APP_NAME"

CONF_NAME="production.ini"

PID_PATH="$APP_PATH/$APP_NAME.pid"

# Default-Start:     2 3 4 5

# Default-Stop:      0 1 6

# Short-Description: starts instance of hg-app

# Description:       starts instance of hg-app using start-stop-daemon

### END INIT INFO

APP_HOMEDIR="marcink/python_workspace"

APP_PATH="/home/$APP_HOMEDIR/$APP_NAME"

CONF_NAME="production.ini"

PID_PATH="$APP_PATH/$APP_NAME.pid"

logview.pylons.templating = #bfb

logview.pylons.util = #eee

#########################################################

### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###

#########################################################

#sqlalchemy.db1.echo = False

#sqlalchemy.db1.pool_recycle = 3600

sqlalchemy.convert_unicode = true

################################

### LOGGING CONFIGURATION   ####

logview.pylons.templating = #bfb

logview.pylons.util = #eee

#########################################################

### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###

#########################################################

#sqlalchemy.db1.echo = False

#sqlalchemy.db1.pool_recycle = 3600

sqlalchemy.convert_unicode = true

################################

### LOGGING CONFIGURATION   ####

"""Pylons environment configuration"""

from mako.lookup import TemplateLookup

from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

from rhodecode.config.routing import make_map

from rhodecode.lib.auth import set_available_permissions, set_base_path

from rhodecode.model import init_model

from rhodecode.model.hg_model import _get_repos_cached_initial

from sqlalchemy import engine_from_config

import logging

import os

import rhodecode.lib.app_globals as app_globals

    #init baseui

    config['pylons.app_globals'].baseui = make_ui('db')

    repo2db_mapper(_get_repos_cached_initial(config['pylons.app_globals'], initial))

    set_available_permissions(config)

    set_base_path(config)

    # CONFIGURATION OPTIONS HERE (note: all config options will override

    # any Pylons config options)

    return config

        # url('repos')

        repo_model = RepoModel()

        _form = RepoForm()()

        form_result = {}

        try:

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

            invalidate_cache('cached_repo_list')

            h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

            if request.POST.get('user_created'):

                              form_result['repo_name'], '', self.sa)

            else:

                              form_result['repo_name'], '', self.sa)                

        except formencode.Invalid as errors:

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

                              repo_name, '', self.sa)

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception, e:

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

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

from rhodecode.model.db import User, UserLog, HgAppSettings, HgAppUi

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm

from rhodecode.model.hg_model import HgModel

from rhodecode.model.user_model import UserModel

from rhodecode.lib.celerylib import tasks, run_task

            try:

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

                try:

                    hgsettings1 = self.sa.query(HgAppSettings)\

                    .filter(HgAppSettings.app_settings_name == 'title').one()

                    hgsettings2 = self.sa.query(HgAppSettings)\

                    .filter(HgAppSettings.app_settings_name == 'realm').one()

                    self.sa.add(hgsettings1)

                    self.sa.add(hgsettings2)

                    self.sa.commit()

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

                            category='success')

                except:

                    log.error(traceback.format_exc())

                    h.flash(_('error occurred during updating application settings'),

    def my_account(self):

        """

        GET /_admin/my_account Displays info about my account 

        """

        # url('admin_settings_my_account')

        c.user_repos = []

        for repo in c.cached_repo_list.values():

            if repo.dbrepo.user.username == c.user.username:

                c.user_repos.append(repo)

        if c.user.username == 'default':

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

        # Or using helpers:

        #    h.form(url('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        user_model = UserModel()

        _form = UserForm(edit=True, old_data={'user_id':uid,

        form_result = {}

        try:

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

            user_model.update_my_account(uid, form_result)

            h.flash(_('Your account was updated succesfully'),

                    category='success')

        except formencode.Invalid as errors:

            c.user_repos = []

            for repo in c.cached_repo_list.values():

                if repo.dbrepo.user.username == c.user.username:

                    c.user_repos.append(repo)            

            return htmlfill.render(

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

        login_form = UserForm()()

        try:

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

            user_model.create(form_result)

            h.flash(_('created user %s') % form_result['username'],

                    category='success')

        except formencode.Invalid as errors:

            return htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

        super(LoginController, self).__before__()

    def index(self):

        #redirect if already logged in

        c.came_from = request.GET.get('came_from', None)

            return redirect(url('hg_home'))

        if request.POST:

            #import Login Form validator class

            login_form = LoginForm()

            try:

                auth_user.username = user.username

                auth_user.is_authenticated = True

                auth_user.is_admin = user.admin

                auth_user.user_id = user.user_id

                auth_user.name = user.name

                auth_user.lastname = user.lastname

                session.save()

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

                user.update_lastlogin()

                if c.came_from:

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/password_reset.html')

    def logout(self):

        session.save()

        log.info('Logging out and setting user as Empty')

        redirect(url('hg_home'))

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('hg_home'))

        try:

                              repo_name, '', self.sa)            

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception:

            h.flash(_('An error occurred during deletion of %s') % repo_name,

        c.repo_info = repo_model.get(repo_name)

        _form = RepoForkForm()()

        form_result = {}

        try:

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

            form_result.update({'repo_name':repo_name})

            h.flash(_('fork %s repository as %s task added') \

                      % (repo_name, form_result['fork_name']),

                    category='success')

                            repo_name, '', self.sa)                                                 

        except formencode.Invalid as errors:

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

            return htmlfill.render(

        c.repo_info = hg_model.get_repo(c.repo_name)

        c.repo_changesets = Page(list(c.repo_info[:10]), page=1, items_per_page=20)

        e = request.environ

        uri = u'%(protocol)s://%(user)s@%(host)s%(prefix)s/%(repo_name)s' % {

                                        'protocol': e.get('wsgi.url_scheme'),

                                        'host':e.get('HTTP_HOST'),

                                        'prefix':e.get('SCRIPT_NAME'),

                                        'repo_name':c.repo_name, }

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.repo_info.tags.items()[:10]:

def get_user(session):

    """

    Gets user from session, and wraps permissions into user

    @param session:

    """

    if user.is_authenticated:

        user = fill_data(user)

    user = fill_perms(user)

    session.save()

    return user

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

# CHECK DECORATORS

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

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

    def __call__(self, func):

        return decorator(self.__wrapper, func)

    def __wrapper(self, func, *fargs, **fkwargs):

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

        if user.is_authenticated:

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

            return func(*fargs, **fkwargs)

        else:

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

    def __wrapper(self, func, *fargs, **fkwargs):

#        _wrapper.__name__ = func.__name__

#        _wrapper.__dict__.update(func.__dict__)

#        _wrapper.__doc__ = func.__doc__

        log.debug('checking %s permissions %s for %s',

           self.__class__.__name__, self.required_perms, func.__name__)

        if self.check_permissions():

            log.debug('Permission granted for %s', func.__name__)

        self.required_perms = set(perms)

        self.user_perms = None

        self.granted_for = ''

        self.repo_name = None

    def __call__(self, check_Location=''):

        if not user:

            return False

        self.user_perms = user.permissions

        self.granted_for = user.username        

        log.debug('checking %s %s', self.__class__.__name__, self.required_perms)            

from rhodecode.model.hg_model import _get_repos_cached, \

    _get_repos_switcher_cached

class BaseController(WSGIController):

    def __before__(self):

        c.repo_name = get_repo_slug(request)

        c.cached_repo_list = _get_repos_cached()

        c.repo_switcher_list = _get_repos_switcher_cached(c.cached_repo_list)

        if c.repo_name:

            cached_repo = c.cached_repo_list.get(c.repo_name)

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

            #putting this here makes sure that we update permissions every time

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

        sa.remove()

    if not ret:

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

    settings = {}

    for each in ret:

    return settings

def get_hg_ui_settings():

    from rhodecode.model.db import HgAppUi

    try:

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

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

        meta.Session.remove()

    if not ret:

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

    settings = {}

    for each in ret:

    return settings

def get_hg_ui_settings():

    try:

        sa = meta.Session

                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

    return baseui

    hgsettings = get_hg_settings()

    for k, v in hgsettings.items():

        config[k] = v

def invalidate_cache(name, *args):

from vcs.utils.lazy import LazyProperty

import logging

log = logging.getLogger(__name__)

class HgAppSettings(Base):

    __table_args__ = (UniqueConstraint('app_settings_name'), {'useexisting':True})

    app_settings_id = Column("app_settings_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    app_settings_name = Column("app_settings_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    app_settings_value = Column("app_settings_value", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

class HgAppUi(Base):

    __table_args__ = {'useexisting':True}

    ui_id = Column("ui_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    ui_section = Column("ui_section", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_key = Column("ui_key", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_value = Column("ui_value", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_active = Column("ui_active", BOOLEAN(), nullable=True, unique=None, default=True)

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

    return _ApplicationSettingsForm

def ApplicationUiSettingsForm():

    class _ApplicationUiSettingsForm(formencode.Schema):

        allow_extra_fields = True

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                </div>

                <div class="input">

                </div>

             </div>

            <div class="field">

                <div class="label">

                </div>

                <div class="input">

                </div>

            </div>

            <div class="buttons">

                ${h.submit('save','save settings',class_="ui-button ui-widget ui-state-default ui-corner-all")}

           </div>                                                          

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

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

<%def name="title()">

</%def>

<%def name="breadcrumbs_links()">

    ${_('My Account')}

</%def>

    <!-- header -->

    <div id="header">

        <!-- user -->

        <ul id="logged-user">

            <li class="first">

	            <div class="gravatar">

	            </div>

	            <div class="account">

	            </div>	

            </li>

            <li class="last highlight">${h.link_to(u'Logout',h.url('logout_home'))}</li>

        </ul>

        <!-- end user -->

        <div id="header-inner">

            <div id="home">

                <a href="${h.url('hg_home')}"></a>

            </div>

            <!-- logo -->

            <div id="logo">

            </div>

            <!-- end logo -->

            <!-- quick menu -->

            ${self.page_nav()}

            <!-- end quick -->

            <div class="corner tl"></div>

	    </div>

	</div> 

    <!-- END CONTENT -->

	<!-- footer -->

	<div id="footer">

        <script type="text/javascript">${h.tooltip.activate()}</script>	    

	</div>

	<!-- end footer -->

</body>

</html>

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

	%else:

		${_('in all repositories')}		

	%endif

	:${c.cur_query}

</%def>

<%def name="breadcrumbs()">

</%def>

<%def name="page_nav()">

	${self.menu('home')}

</%def>

<%def name="main()">

        print response

        if 'invalid user name' in response.body:

            assert False, 'could not login using %s %s' % (username, password)

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        return response.follow()

    def test_login_admin_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test12'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        response = response.follow()

        assert 'auto description for vcs_test' in response.body

    def test_login_regular_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_regular',

                                  'password':'test12'})

        print response

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        response = response.follow()

        assert 'auto description for vcs_test' in response.body

        assert '<a title="Admin" href="/_admin">' not in response.body

    def test_login_ok_came_from(self):

        test_came_from = '/_admin/users'