from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib import auth_modules

from kallithea.model.forms import AuthSettingsForm

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

            'kallithea.lib.auth_modules.auth_ldap',

            'kallithea.lib.auth_modules.auth_crowd',

        ]

    def index(self, defaults=None, errors=None, prefix_error=False):

        self.__load_defaults()

        formglobals = {

            "auth_plugins": ["kallithea.lib.auth_modules.auth_rhodecode"]

        }

        formglobals["plugin_settings"] = {}

        formglobals["auth_plugins_shortnames"] = {}

        _defaults["auth_plugins"] = formglobals["auth_plugins"]

                if "default" in v:

                    _defaults[fullname] = v["default"]

                # Current values will be the default on the form, if there are any

                if setting:

                    _defaults[fullname] = setting.app_settings_value

        # we want to show , seperated list of enabled plugins

                    # we want to store it comma separated inside our settings

                    v = ','.join(v)

                log.debug("%s = %s" % (k, str(v)))

                Session().add(setting)

            Session().commit()

            h.flash(_('Auth settings updated successfully'),

from kallithea.model.forms import DefaultsForm

from kallithea.model.meta import Session

from kallithea import BACKENDS

log = logging.getLogger(__name__)

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

        # url('defaults')

        c.backends = BACKENDS.keys()

        return htmlfill.render(

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

        try:

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

            for k, v in form_result.iteritems():

                Session().add(setting)

            Session().commit()

            h.flash(_('Default settings updated successfully'),

from kallithea.lib.vcs import RepositoryError

from kallithea.model.meta import Session

from kallithea.model.db import User, Repository, UserFollowing, RepoGroup,\

from kallithea.model.forms import RepoForm, RepoFieldForm, RepoPermsForm

from kallithea.model.scm import ScmModel, RepoGroupList, RepoList

from kallithea.model.repo import RepoModel

        c.new_repo = repo_name_slug(new_repo)

        ## apply the defaults from defaults page

        if parent_group:

            defaults.update({'repo_group': parent_group})

from kallithea.lib.celerylib import tasks, run_task

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.model.forms import ApplicationSettingsForm, \

    ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.scm import ScmModel

        super(SettingsController, self).__before__()

    def _get_hg_ui_settings(self):

        if not ret:

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

                )

            try:

                sett.ui_value = form_result['web_push_ssl']

                Session().add(sett)

                if c.visual.allow_repo_location_change:

                    sett.ui_value = form_result['paths_root_path']

                    Session().add(sett)

                #HOOKS

                sett.ui_active = form_result['hooks_changegroup_update']

                Session().add(sett)

                sett.ui_active = form_result['hooks_changegroup_repo_size']

                Session().add(sett)

                sett.ui_active = form_result['hooks_changegroup_push_logger']

                Session().add(sett)

                sett.ui_active = form_result['hooks_outgoing_pull_logger']

                Session().add(sett)

                ## EXTENSIONS

                if not sett:

                    #make one if it's not there !

                    sett.ui_key = 'largefiles'

                    sett.ui_section = 'extensions'

                sett.ui_active = form_result['extensions_largefiles']

                Session().add(sett)

                if not sett:

                    #make one if it's not there !

                    sett.ui_key = 'hgsubversion'

                    sett.ui_section = 'extensions'

                        raise HgsubversionImportError

                Session().add(sett)

#                if not sett:

#                    #make one if it's not there !

#                    sett.ui_key = 'hggit'

#                    sett.ui_section = 'extensions'

#

                h.flash(_('Error occurred during updating '

                          'application settings'), category='error')

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

                    category='success')

            return redirect(url('admin_settings_mapping'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

                    encoding="UTF-8")

            try:

                                            form_result['rhodecode_title'])

                Session().add(sett1)

                                            form_result['rhodecode_realm'])

                Session().add(sett2)

                                            form_result['rhodecode_ga_code'])

                Session().add(sett3)

                                    form_result['rhodecode_captcha_public_key'])

                Session().add(sett4)

                                    form_result['rhodecode_captcha_private_key'])

                Session().add(sett5)

            return redirect(url('admin_settings_global'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

                    ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),

                ]

                for setting, form_key, type_ in settings:

                                        form_result[form_key], type_)

                    Session().add(sett)

            return redirect(url('admin_settings_visual'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            h.flash(_('Send email task created'), category='success')

            return redirect(url('admin_settings_email'))

        defaults.update(self._get_hg_ui_settings())

        import kallithea

                try:

                    if ui_value and ui_key:

                        h.flash(_('Added new hook'), category='success')

                    elif hook_id:

                        Session().commit()

                    # check for edits

                    _d = request.POST.dict_of_lists()

                    for k, v in zip(_d.get('hook_ui_key', []),

                                    _d.get('hook_ui_value_new', [])):

                        update = True

                    if update:

                return redirect(url('admin_settings_hooks'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            h.flash(_('Whoosh reindex task scheduled'), category='success')

            return redirect(url('admin_settings_search'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

        # url('admin_settings_system')

        c.active = 'system'

        defaults.update(self._get_hg_ui_settings())

        import kallithea

        c.rhodecode_ini = kallithea.CONFIG

        c.rhodecode_update_url = defaults.get('rhodecode_update_url')

        for key, val in server_info.iteritems():

            setattr(c, key, val)

        from kallithea.lib.verlib import NormalizedVersion

        from kallithea import __version__

        defaults.update(self._get_hg_ui_settings())

        _update_url = defaults.get('rhodecode_update_url', '')

from kallithea.model.user_group import UserGroupModel

from kallithea.model.gist import GistModel

from kallithea.model.db import (

    RepoGroup)

from kallithea.lib.compat import json

from kallithea.lib.exceptions import (

          }

          error :  null

        """

    def get_user(self, apiuser, userid=Optional(OAttr('apiuser'))):

        """

        if RepoModel().get_by_repo_name(repo_name):

            raise JSONRPCError("repo `%s` already exist" % repo_name)

        if isinstance(private, Optional):

            private = defs.get('repo_private') or Optional.extract(private)

        if isinstance(repo_type, Optional):

    NotAnonymous, HasRepoPermissionAny, HasPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.model.db import Repository, RepoGroup, UserFollowing, User,\

from kallithea.model.repo import RepoModel

from kallithea.model.forms import RepoForkForm

from kallithea.model.scm import ScmModel, RepoGroupList

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.landing_revs_choices = choices

    def __load_data(self, repo_name=None):

        """

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

            # an approximation that is better than nothing

                form_result['update_after_clone'] = False

            # create fork is done sometimes async on celery, db transaction

from kallithea.lib.auth_modules import importplugin

from kallithea.lib.base import BaseController, render

from kallithea.lib.exceptions import UserCreationError

from kallithea.model.forms import LoginForm, RegisterForm, PasswordResetForm

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

                h.flash(e, 'error')

        # check if we use container plugin, and try to login using it.

        if any((importplugin(name).is_container_auth for name in auth_plugins)):

            from kallithea.lib import auth_modules

            try:

        c.auto_active = 'hg.register.auto_activate' in User.get_default_user()\

            .AuthUser.permissions['global']

        captcha_private_key = settings.get('rhodecode_captcha_private_key')

        c.captcha_active = bool(captcha_private_key)

        c.captcha_public_key = settings.get('rhodecode_captcha_public_key')

        return render('/register.html')

    def password_reset(self):

        captcha_private_key = settings.get('rhodecode_captcha_private_key')

        c.captcha_active = bool(captcha_private_key)

        c.captcha_public_key = settings.get('rhodecode_captcha_public_key')

from kallithea.lib.compat import formatted_json, hybrid_property

from kallithea.lib.auth import PasswordGenerator

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

from kallithea.model.user_group import UserGroupModel

    :returns: None if auth failed, plugin_user dict if auth is correct

    """

    log.debug('Authentication against %s plugins' % (auth_plugins,))

    for module in auth_plugins:

        try:

        plugin_settings = {}

        for v in plugin.plugin_settings():

            conf_key = "auth_%s_%s" % (plugin_name, v["name"])

            plugin_settings[v["name"]] = setting.app_settings_value if setting else None

        log.debug('Plugin settings \n%s' % formatted_json(plugin_settings))

from kallithea.lib.exceptions import UserCreationError

from kallithea.model import meta

from kallithea.model.notification import NotificationModel

from kallithea.model.scm import ScmModel

from kallithea.model.meta import Session

        """

        org_proto = environ['wsgi._org_proto']

        #check if we have SSL required  ! if not it's a bad request !

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

        __before__ is called before controller methods and after __call__

        """

        c.kallithea_version = __version__

        # Visual options

        c.visual = AttributeDict({})

def create_repo(form_data, cur_user):

    from kallithea.model.repo import RepoModel

    from kallithea.model.user import UserModel

    log = get_logger(create_repo)

    DBS = get_session()

    state = form_data.get('repo_state', Repository.STATE_PENDING)

    # repo creation defaults, private and repo_type are filled in form

    enable_statistics = defs.get('repo_enable_statistics')

    enable_locking = defs.get('repo_enable_locking')

    enable_downloads = defs.get('repo_enable_downloads')

from kallithea.model.user import UserModel

from kallithea.lib.utils import ask_ok

from kallithea.model import init_model

    UserRepoGroupToPerm, CacheInvalidation, UserGroup, Repository

from sqlalchemy.engine import create_engine

        Fixes a old rhodecode version path into new one without a '*'

        """

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        try:

            self.sa.add(hgsettings3)

        """

        #HOOKS

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        self.sa.add(hooks1)

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        hooks2.ui_value = 'python:kallithea.lib.hooks.repo_size'

        self.sa.add(hooks2)

        hooks3.ui_section = 'hooks'

        hooks3.ui_value = 'python:kallithea.lib.hooks.log_push_action'

        self.sa.add(hooks3)

        hooks4.ui_section = 'hooks'

        hooks4.ui_value = 'python:kallithea.lib.hooks.pre_push'

        self.sa.add(hooks4)

        hooks5.ui_section = 'hooks'

        hooks5.ui_value = 'python:kallithea.lib.hooks.log_pull_action'

        self.sa.add(hooks5)

        hooks6.ui_section = 'hooks'

        hooks6.ui_value = 'python:kallithea.lib.hooks.pre_pull'

        self.sa.add(hooks6)

        # enable largefiles

        largefiles.ui_section = 'extensions'

        largefiles.ui_key = 'largefiles'

        largefiles.ui_value = ''

        # set default largefiles cache dir, defaults to

        # /repo location/.cache/largefiles

        largefiles.ui_section = 'largefiles'

        largefiles.ui_key = 'usercache'

        largefiles.ui_value = os.path.join(repo_store_path, '.cache',

        self.sa.add(largefiles)

        # enable hgsubversion disabled by default

        hgsubversion.ui_section = 'extensions'

        hgsubversion.ui_key = 'hgsubversion'

        hgsubversion.ui_value = ''

        self.sa.add(hgsubversion)

        # enable hggit disabled by default

        hggit.ui_section = 'extensions'

        hggit.ui_key = 'hggit'

        hggit.ui_value = ''

        for k, v, t in [('auth_plugins', 'kallithea.lib.auth_modules.auth_rhodecode', 'list'),

                     ('auth_rhodecode_enabled', 'True', 'bool')]:

                log.debug('Skipping option %s' % k)

                continue

            self.sa.add(setting)

    def create_default_options(self, skip_existing=False):

            ('default_repo_private', False, 'bool'),

            ('default_repo_type', 'hg', 'unicode')]:

                log.debug('Skipping option %s' % k)

                continue

            self.sa.add(setting)

    def fixup_groups(self):

            #('phases', 'publish', 'false')

        ]

        for section, key, value in ui_config:

            setattr(ui_conf, 'ui_section', section)

            setattr(ui_conf, 'ui_key', key)

            setattr(ui_conf, 'ui_value', value)

            ('use_gravatar', True, 'bool'),

            ('gravatar_url', User.DEFAULT_GRAVATAR_URL, 'unicode'),

            ('clone_uri_tmpl', Repository.DEFAULT_CLONE_URI, 'unicode'),

        ]

        for key, val, type_ in settings:

            self.sa.add(sett)

        self.create_auth_plugin_options()

        Session.commit()

    __tablename__ = 'rhodecode_settings'

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

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

        return fd

    __tablename__ = 'rhodecode_ui'

    __table_args__ = (UniqueConstraint('ui_key'), {'extend_existing':True})

        :param cls:

        """

                                              cls.url_sep())

        q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

                                              Repository.url_sep())

        q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        baseui._tcfg = config.config()

            .options(FromCache("sql_cache_short", "repository_repo_ui")).all()

        hg_ui = ret

            return safe_str(self.__unicode__())

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

    __tablename__ = 'rhodecode_settings'

    __table_args__ = (

        UniqueConstraint('app_settings_name'),

        return fd

    __tablename__ = 'rhodecode_ui'

    __table_args__ = (

        UniqueConstraint('ui_key'),

        :param cls:

        """

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

                                              Repository.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        baseui._ucfg = config.config()

        baseui._tcfg = config.config()

            .options(FromCache("sql_cache_short", "repository_repo_ui")).all()

        hg_ui = ret

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

    __tablename__ = 'rhodecode_settings'

    __table_args__ = (

        UniqueConstraint('app_settings_name'),

        return fd

    __tablename__ = 'rhodecode_ui'

    __table_args__ = (

        UniqueConstraint('ui_key'),

        :param cls:

        """

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

                                              Repository.url_sep())