c.create_choices = self.create_choices

        if id == 'default':

            defaults = {'_method': 'put',

                        'anonymous': default_user.active}

        """

        self.__load_defaults()

        repo = scm_repo = db_repo.scm_instance

        if c.repo_info is None:

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

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

                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

    def register(self):

        user_model = UserModel()

        c.auto_active = False

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

                c.auto_active = True

                break

from rhodecode.model import meta

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

    """

    user_model = UserModel()

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

    if user is not None and not user.ldap_dn:

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

    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)

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            if c.rhodecode_repo is None:

        return repo_name

    def __get_user(self, username):

    def __get_action(self, environ):

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

        return repo_name

    def __get_user(self, username):

    def __get_action(self, environ):

        """

        if hasattr(user, 'user_id'):

            user_obj = user

        elif isinstance(user, basestring):

        else:

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

            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.repo_id, self.repo_name)

    @classmethod

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

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

                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)

    def validate_python(self, value, state):

        password = value['password']

        username = value['username']

        if authenticate(username, password):

            return value

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

                if member_type == 'user':

                    r2p = RepoToPerm()

                    r2p.repository = cur_repo

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

                                        .filter(Permission.

            #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':

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

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

                    default = p.permission.permission_name

                    break

                    .one().permission_id

            repo_to_perm.repository = new_repo

            self.sa.add(repo_to_perm)

#

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

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

    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:

            extras = {'ip': '',

            from vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

            content = safe_str(content)

            content = content.read()

        message = safe_str(message)

        path = safe_str(f_path)

        author = safe_str(author)

        # GOOD KEY

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

                                    action='password_reset_confirmation',

    def _enable_stats(self):

        r.enable_statistics = True

        self.sa.add(r)

        self.sa.commit()

USER = 'test_admin'

PASS = 'test12'

HOST = '127.0.0.1:5000'

print 'DEBUG:', DEBUG

log = logging.getLogger(__name__)

def test_wrapp(func):

    def __wrapp(*args, **kwargs):

        try:

            res = func(*args, **kwargs)

        except Exception, e:

#smtp_password = 

#smtp_port = 

#smtp_use_tls = false

[server:main]

##nr of threads to spawn

cut_off_limit = 256000

force_https = false

commit_parse_limit = 25

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

###        CELERY CONFIG        ####

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

### LOGGING CONFIGURATION   ####

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

[loggers]

[handlers]

keys = console

[formatters]

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

## LOGGERS ##

[logger_routes]

level = ERROR

qualname = routes.middleware

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

[logger_beaker]

level = DEBUG

[logger_rhodecode]

level = ERROR

qualname = rhodecode

[logger_sqlalchemy]

level = ERROR

class = StreamHandler

args = (sys.stderr,)

level = NOTSET

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

## FORMATTERS ##