#url('edit_permission', id=ID)

        c.perms_choices = self.perms_choices

        c.register_choices = self.register_choices

        c.create_choices = self.create_choices

        if id == 'default':

            defaults = {'_method': 'put',

                        'anonymous': default_user.active}

            for p in default_user.user_perms:

                if p.permission.permission_name.startswith('repository.'):

                    defaults['default_perm'] = p.permission.permission_name

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        repo = scm_repo = db_repo.scm_instance

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        c.in_public_journal = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision

        """

        cur_token = request.POST.get('auth_token')

        token = get_token()

        if cur_token == token:

            try:

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

            except:

                h.flash(_('An error occurred during setting this'

                          ' repository in public journal'),

            #import Login Form validator class

            login_form = LoginForm()

            try:

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

                #form checks for username/password, now we're authenticated

                username = c.form_result['username']

                auth_user = AuthUser(user.user_id)

                auth_user.set_authenticated()

                session['rhodecode_user'] = auth_user

                session.save()

                log.info('user %s is now authenticated and stored in session',

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        user_model = UserModel()

        c.auto_active = False

            if perm.permission.permission_name == 'hg.register.auto_activate':

                c.auto_active = True

                break

        if request.POST:

from rhodecode.lib.exceptions import LdapPasswordError, LdapUsernameError

from rhodecode.lib.utils import get_repo_slug

from rhodecode.lib.auth_ldap import AuthLdap

from rhodecode.model import meta

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

class PasswordGenerator(object):

    """This is a simple class for generating password from

    :param username: username

    :param password: password

    """

    user_model = UserModel()

    log.debug('Authenticating user using RhodeCode account')

    if user is not None and not user.ldap_dn:

        if user.active:

            if user.username == 'default' and user.active:

                log.info('user %s authenticated correctly as anonymous user',

                return True

        else:

            log.warning('user %s is disabled', username)

    else:

        log.debug('Regular authentication failed')

        if user_obj is not None and not user_obj.ldap_dn:

            log.debug('this user already exists as non ldap')

            return False

        ldap_settings = RhodeCodeSettings.get_ldap_settings()

        self.permissions = {}

        self._api_key = api_key

        self.propagate_data()

    def propagate_data(self):

        user_model = UserModel()

        if self._api_key and self._api_key != self.anonymous_user.api_key:

            #try go get user by api key

            log.debug('Auth User lookup by API KEY %s', self._api_key)

            user_model.fill_data(self, api_key=self._api_key)

        else:

            log.debug('Auth User lookup by USER ID %s', self.user_id)

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            if c.rhodecode_repo is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

            log.error(traceback.format_exc())

            raise

        repo_name = repo_name.split('/')[0]

        return repo_name

    def __get_user(self, username):

    def __get_action(self, environ):

        """Maps git request commands into a pull or push command.

        :param environ:

        """

            log.error(traceback.format_exc())

            raise

        return repo_name

    def __get_user(self, 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

        sa = meta.Session()

    try:

        if hasattr(user, 'user_id'):

            user_obj = user

        elif isinstance(user, basestring):

        else:

            raise Exception('You have to provide user object or username')

        rm = RepoModel()

        if hasattr(repo, 'repo_id'):

            repo_obj = rm.get(repo.repo_id, cache=False)

            return "<%s('id:%s:%s')>" % (self.__class__.__name__,

                                             self.user_id, self.username)

        except:

            return self.__class__.__name__

    @classmethod

        if case_insensitive:

        else:

    @classmethod

    def get_by_api_key(cls, api_key):

        return Session.query(cls).filter(cls.api_key == api_key).one()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session.add(self)

        Session.commit()

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.repo_id, self.repo_name)

    @classmethod

        q = Session.query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork))\

            .options(joinedload(Repository.user))\

            .options(joinedload(Repository.group))\

            #check if user is unique

            old_un = None

            if edit:

                old_un = UserModel().get(old_data.get('user_id')).username

            if old_un != value or not edit:

                    raise formencode.Invalid(_('This username already '

                                               'exists') , value, state)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                raise formencode.Invalid(_('Username may only contain '

                                           'alphanumeric characters '

              'password':messages['invalid_password']}

    e_dict_disable = {'username':messages['disabled_account']}

    def validate_python(self, value, state):

        password = value['password']

        username = value['username']

        if authenticate(username, password):

            return value

        else:

            if user and user.active is False:

                log.warning('user %s is disabled', username)

            cur_repo = self.get_by_repo_name(repo_name, cache=False)

            #update permissions

            for member, perm, member_type in form_data['perms_updates']:

                if member_type == 'user':

                    r2p = self.sa.query(RepoToPerm)\

                            .filter(RepoToPerm.repository == cur_repo)\

                            .one()

                    r2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.permission_name ==

                                                perm).scalar()

            #set new permissions

            for member, perm, member_type in form_data['perms_new']:

                if member_type == 'user':

                    r2p = RepoToPerm()

                    r2p.repository = cur_repo

                    r2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.

                                                permission_name == perm)\

                                                .scalar()

                    self.sa.add(r2p)

                                                .scalar()

                    self.sa.add(g2p)

            #update current repo

            for k, v in form_data.items():

                if k == 'user':

                elif k == 'repo_name':

                    cur_repo.repo_name = form_data['repo_name_full']

                elif k == 'repo_group':

                    cur_repo.group_id = v

                else:

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

                if p.permission.permission_name.startswith('repository.'):

                    default = p.permission.permission_name

                    break

            default_perm = 'repository.none' if form_data['private'] else default

            repo_to_perm.permission_id = self.sa.query(Permission)\

                    .filter(Permission.permission_name == default_perm)\

                    .one().permission_id

            repo_to_perm.repository = new_repo

            self.sa.add(repo_to_perm)

            if not just_db:

                self.__create_repo(repo_name, form_data['repo_type'],

                                   form_data['repo_group'],

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

import traceback

import logging

from sqlalchemy.exc import DatabaseError

from rhodecode.lib import helpers as h

from rhodecode.lib import safe_str

from rhodecode.lib.auth import HasRepoPermissionAny

from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \

    action_logger, EmptyChangeset

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def is_following_user(self, username, user_id, cache=False):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo_id):

        if not isinstance(repo_id, int):

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        if not isinstance(repo_id, int):

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def pull_changes(self, repo_name, username):

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        try:

                                    key=key))

        self.assertEqual(response.status, '302 Found')

        self.assertTrue(response.location.endswith(url('reset_password')))

        # GOOD KEY

        response = self.app.get(url(controller='login',

                                    action='password_reset_confirmation',

                                    key=key))

        self.assertEqual(response.status, '302 Found')

        self.assertTrue(response.location.endswith(url('login_home')))

        # clone url...

        self.assertTrue("""<input type="text" id="clone_url" readonly="readonly" value="hg clone http://test_admin@localhost:80/%s" size="70"/>""" % HG_REPO in response.body)

    def _enable_stats(self):

        r.enable_statistics = True

        self.sa.add(r)

        self.sa.commit()

add_cache(conf)

USER = 'test_admin'

PASS = 'test12'

HOST = '127.0.0.1:5000'

print 'DEBUG:', DEBUG

log = logging.getLogger(__name__)

class Command(object):

        return stdout, stderr

def test_wrapp(func):

    def __wrapp(*args, **kwargs):

        try:

            res = func(*args, **kwargs)

        except Exception, e:

            print ('###############\n-'

                   '--%s failed %s--\n'

                   '###############\n' % (func.__name__, e))

#smtp_server = mail.server.com

#smtp_username = 

#smtp_password = 

#smtp_port = 

#smtp_use_tls = false

[server:main]

##nr of threads to spawn

threadpool_workers = 5

##max request before thread respawn

cache_dir = /tmp/data

index_dir = /tmp/index

app_instance_uuid = develop-test

cut_off_limit = 256000

force_https = false

commit_parse_limit = 25

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

###        CELERY CONFIG        ####

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

use_celery = false

broker.host = localhost

beaker.cache.short_term.type=memory

beaker.cache.short_term.expire=60

beaker.cache.long_term.type=memory

beaker.cache.long_term.expire=36000

beaker.cache.sql_cache_short.type=memory

beaker.cache.sql_cache_short.expire=10

beaker.cache.sql_cache_med.type=memory

beaker.cache.sql_cache_med.expire=360

[logger_root]

level = ERROR

handlers = console

[logger_routes]

level = ERROR

qualname = routes.middleware

# "level = DEBUG" logs the route matched and routing variables.

[logger_beaker]

level = DEBUG

handlers = 

qualname = beaker.container

propagate = 1

handlers = 

qualname = pylons.templating

propagate = 1

[logger_rhodecode]

level = ERROR

qualname = rhodecode

[logger_sqlalchemy]

level = ERROR

handlers = console

qualname = sqlalchemy.engine

propagate = 0

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

[handler_console]

class = StreamHandler

args = (sys.stderr,)

level = NOTSET

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

## FORMATTERS ##

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

[formatter_generic]