# url('admin_setting', setting_id=ID)

        if setting_id == 'mapping':

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

            initial = ScmModel().repo_scan()

            log.debug('invalidating all repositories')

            for repo_name in initial.keys():

        else:

            length = environ['CONTENT_LENGTH'] or 0

            length = int(environ['CONTENT_LENGTH'])

        if length == 0:

            log.debug("Content-Length is 0")

            self._req_id = json_body['id']

            self._req_method = json_body['method']

            self._request_params = json_body['args']

                      self._request_params)

        except KeyError, e:

            return jsonrpc_error(message='Incorrect JSON query missing %s' % e)

        try:

            return json.dumps(response)

        except TypeError, e:

            return json.dumps(

                dict(

                    self._req_id,

        """

        Return method named by `self._req_method` in controller if able

        """

        if self._req_method.startswith('_'):

            raise AttributeError("Method not allowed")

        resp = request.environ.get('pylons.original_response')

        c.rhodecode_name = config.get('rhodecode_title')

        e = request.environ

        c.serv_p = r'%(protocol)s://%(host)s/' \

                except:

                    raise HTTPBadRequest()

        raise HTTPBadRequest()

    @LoginRequired()

            elif user.username == username and check_password(password,

                                                              user.password):

                return True

        else:

    else:

        log.debug('Regular authentication failed')

                aldap = AuthLdap(**kwargs)

                (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,

                                                                password)

                get_ldap_attr = lambda k: ldap_attrs.get(ldap_settings\

                                                           .get(k), [''])[0]

                if user_model.create_ldap(username, password, user_dn,

                                          user_attrs):

                Session.commit()

                return True

        user = UserModel().create_for_container_auth(username, user_attrs)

        if not user:

            return None

    if not user.active:

        return None

        # Removing realm and domain from username

        username = username.partition('@')[0]

        username = username.rpartition('\\')[2]

    return username

        # try go get user by api key

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

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

        # lookup by userid

        elif (self.user_id is not None and

              self.user_id != self.anonymous_user.user_id):

            is_user_loaded = user_model.fill_data(self, user_id=self.user_id)

        # lookup by username

        elif self.username and \

            str2bool(config.get('container_auth_enabled', False)):

            dbuser = login_container_auth(self.username)

            if dbuser is not None:

                for k, v in dbuser.get_dict().items():

        if not self.username:

            self.username = 'None'

        user_model.fill_perms(self)

    @property

        api_access_ok = False

        if self.api_access:

            if user.api_key == request.GET.get('api_key'):

                api_access_ok = True

            else:

                log.debug("API KEY token not valid")

        if user.is_authenticated or api_access_ok:

            return func(*fargs, **fkwargs)

        else:

            p = url.current()

            return redirect(url('login_home', came_from=p))

        cls = fargs[0]

        self.user = cls.rhodecode_user

        anonymous = self.user.username == 'default'

               self.user)

        if self.check_permissions():

            return func(*fargs, **fkwargs)

        else:

            anonymous = self.user.username == 'default'

            if anonymous:

                    break

                except ldap.INVALID_CREDENTIALS:

            else:

                log.debug("No matching LDAP objects for authentication "

                raise LdapPasswordError()

        except ldap.NO_SUCH_OBJECT:

            raise LdapUsernameError()

        except ldap.SERVER_DOWN:

            raise LdapConnectionError("LDAP can't access "

    if CELERY_ON:

        try:

            t = task.apply_async(args=args, kwargs=kwargs)

            return t

        except socket.error, e:

        except Exception, e:

            log.error(traceback.format_exc())

    return ResultWrapper(task(*args, **kwargs))

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

        lockkey_path = config['here']

        try:

            l = DaemonLock(file_=jn(lockkey_path, lockkey))

            ret = func(*fargs, **fkwargs)

                            ts_max_y)

    lockkey_path = config['here']

    try:

        lock = l = DaemonLock(file_=jn(lockkey_path, lockkey))

        akc = lambda k: person(k).replace('"', "")

        co_day_auth_aggr = {}

                                        cur_stats.commit_activity_combined))

            co_day_auth_aggr = json.loads(cur_stats.commit_activity)

        lmktime = mktime

        last_rev = last_rev + 1 if last_rev >= 0 else 0

        stats.commit_activity = json.dumps(co_day_auth_aggr)

        stats.commit_activity_combined = json.dumps(overview_data)

        leftovers = len(repo.revisions[last_rev:])

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

            log.debug('sending email')

            run_task(send_email, user_email,

                     _("password reset link"), body)

        else:

            log.debug("password reset email %s not found" % user_email)

    except:

                user.api_key = auth.generate_api_key(user.username)

                DBS.add(user)

                DBS.commit()

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

        run_task(send_email, user_email,

                 'Your new password',

                 'Your new RhodeCode password:%s' % (new_passwd))

    except:

        log.error('Failed to update user password')

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

    def set_db_version(self):

        ver = DbMigrateVersion()

        ver.repository_id = 'rhodecode_db_migrations'

        ver.repository_path = 'versions'

        self.sa.add(ver)

    def upgrade(self):

        """

        # check proper dir

        if not os.path.isdir(path):

            path_ok = False

        # check write access

        if not os.access(path, os.W_OK) and path_ok:

            path_ok = False

        if retries == 0:

            sys.exit('max retries reached')

        log.info('created ui config')

    def create_user(self, username, password, email='', admin=False):

        UserModel().create_or_update(username, password, email,

                                     name='RhodeCode', lastname='Admin',

                                     active=True, admin=admin)

        return f(*a, **kw)

    finally:

        if isinstance(engine, Engine):

            engine.dispose()

        self.last_login = datetime.datetime.now()

        Session.add(self)

        Session.commit()

    @classmethod

    def create(cls, form_data):

        try:

            alias = get_scm(repo_full_path)[0]

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            self.last_login = datetime.datetime.now()

            session.add(self)

            session.commit()

        except (DatabaseError,):

            session.rollback()

        user_log.user_ip = ipaddr

        sa.add(user_log)

        if commit:

            sa.commit()

    except:

        if not os.path.isfile(path):

            log.warning('Unable to read config file %s' % path)

            return False

        cfg = config.config()

        cfg.read(path)

        for section in ui_sections:

            for k, v in cfg.items(section):

                baseui.setconfig(section, k, v)

    elif read_from == 'db':

    for name, repo in initial_repo_list.items():

        group = map_groups(name.split(Repository.url_sep()))

        if not rm.get_by_repo_name(name, cache=False):

            added.append(name)

            form_data = {

                         'repo_name': name,

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

    :param engine: engine to bind to

    """

    meta.Base.metadata.bind = engine

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session.add(self)

    def __json__(self):

        return dict(

        repo_full_path = self.repo_full_path

        try:

            alias = get_scm(repo_full_path)[0]

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            return value

        else:

            if user and user.active is False:

                raise formencode.Invalid(

                    self.message('disabled_account',

                    state=State_obj),

                    error_dict=self.e_dict_disable

                )

            else:

                raise formencode.Invalid(

                    self.message('invalid_password',

                    state=State_obj), value, state,

        :param old: old name

        :param new: new name

        """

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

        :param repo: repo object

        """

        rm_path = os.path.join(self.repos_path, repo.repo_name)

        # disable hg/git

        alias = repo.repo_type

        shutil.move(os.path.join(rm_path, '.%s' % alias),

        """

        create_path = os.path.join(self.repos_path, group_name)

        if os.path.isdir(create_path):

            raise Exception('That directory already exists !')

            log.debug('skipping group rename')

            return

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already '

        from rhodecode.lib.auth import get_crypt_password

        user = User.get_by_username(username, case_insensitive=True)

        if user is None:

            new_user = User()

        else:

            new_user = user

        try:

                dbuser = self.get(user_id)

            if dbuser is not None and dbuser.active:

                for k, v in dbuser.get_dict().items():

                    setattr(auth_user, k, v)

            else: