from kallithea.lib import helpers as h

from kallithea.lib.compat import json, formatted_json

from kallithea.lib.base import BaseController, render

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

class AuthSettingsController(BaseController):

        c.available_plugins = [

            'kallithea.lib.auth_modules.auth_rhodecode',

            'kallithea.lib.auth_modules.auth_container',

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

        _defaults = {}

        # default plugins loaded

        formglobals = {

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

        }

        formglobals["plugin_settings"] = {}

        formglobals["auth_plugins_shortnames"] = {}

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

        for module in formglobals["auth_plugins"]:

            plugin = auth_modules.loadplugin(module)

            formglobals["plugin_settings"][module] = plugin.plugin_settings()

            for v in formglobals["plugin_settings"][module]:

                fullname = ("auth_" + plugin_name + "_" + v["name"])

                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

        _defaults['auth_plugins'] = ','.join(_defaults['auth_plugins'])

        if defaults:

            _defaults.update(defaults)

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

            for k, v in form_result.items():

                if k == 'auth_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'),

                       category='success')

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultsForm

from kallithea.model.meta import Session

from kallithea import BACKENDS

log = logging.getLogger(__name__)

class DefaultsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

        super(DefaultsController, self).__before__()

    def index(self, format='html'):

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

        # url('defaults')

        c.backends = BACKENDS.keys()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        _form = DefaultsForm()()

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

                    category='success')

        except formencode.Invalid, errors:

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.utils import action_logger, repo_name_slug, jsonify

from kallithea.lib.helpers import get_token

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

from kallithea.lib.compat import json

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.utils2 import safe_int

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

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

        c.new_repo = repo_name_slug(new_repo)

        ## apply the defaults from defaults page

        if parent_group:

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

        return htmlfill.render(

            render('admin/repos/repo_add.html'),

            defaults=defaults,

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator

from kallithea.lib.base import BaseController, render

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

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.meta import Session

from kallithea.lib.utils2 import str2bool, safe_unicode, safe_str

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    def _get_hg_ui_settings(self):

        if not ret:

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

        settings = {}

        for each in ret:

            k = each.ui_key

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            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'

                sett.ui_active = form_result['extensions_hgsubversion']

                if sett.ui_active:

                    try:

                        import hgsubversion  # pragma: no cover

                    except ImportError:

                        raise HgsubversionImportError

                Session().add(sett)

#                if not sett:

#                    #make one if it's not there !

#                    sett.ui_key = 'hggit'

#                    sett.ui_section = 'extensions'

#

#                sett.ui_active = form_result['extensions_hggit']

#                Session().add(sett)

            except Exception:

                log.error(traceback.format_exc())

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

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

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            h.flash(_('Repositories successfully '

                      'rescanned added: %s ; removed: %s') %

                    (_repr(added), _repr(removed)),

                    category='success')

            return redirect(url('admin_settings_mapping'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    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)

                Session().commit()

                set_app_settings(config)

                h.flash(_('Updated application settings'), category='success')

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

                          'application settings'),

                          category='error')

            return redirect(url('admin_settings_global'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

                    ('show_version', 'rhodecode_show_version', 'bool'),

                    ('use_gravatar', 'rhodecode_use_gravatar', 'bool'),

                    ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),

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

                ]

                for setting, form_key, type_ in settings:

                                        form_result[form_key], type_)

                    Session().add(sett)

                Session().commit()

                set_app_settings(config)

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

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

                          'visualisation settings'),

                        category='error')

            return redirect(url('admin_settings_visual'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            run_task(tasks.send_email, recipients, test_email_subj,

                     test_email_body, test_email_html_body)

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

            return redirect(url('admin_settings_email'))

        defaults.update(self._get_hg_ui_settings())

        import kallithea

        c.rhodecode_ini = kallithea.CONFIG

        return htmlfill.render(

                ui_value = request.POST.get('new_hook_ui_value')

                hook_id = request.POST.get('hook_id')

                try:

                    if ui_value and ui_key:

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

                    elif hook_id:

                        Session().commit()

                    # check for edits

                    update = False

                    _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:

                        h.flash(_('Updated hooks'), category='success')

                    Session().commit()

                except Exception:

                    log.error(traceback.format_exc())

                    h.flash(_('Error occurred during hook creation'),

                            category='error')

                return redirect(url('admin_settings_hooks'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

            repo_location = self._get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index', False)

            run_task(tasks.whoosh_index, repo_location, full_index)

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

            return redirect(url('admin_settings_search'))

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

    @HasPermissionAllDecorator('hg.admin')

    def settings_system(self):

        """GET /admin/settings/system: All items in the collection"""

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

        return htmlfill.render(

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

            defaults=defaults,

        # url('admin_settings_system_update')

        import json

        import urllib2

        from kallithea.lib.verlib import NormalizedVersion

        from kallithea import __version__

        defaults.update(self._get_hg_ui_settings())

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

        _err = lambda s: '<div style="color:#ff8888; padding:4px 0px">%s</div>' % (s)

        try:

            import kallithea

from kallithea.model.scm import ScmModel, UserGroupList

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

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 (

    DefaultUserException, UserGroupsAssignedException)

log = logging.getLogger(__name__)

            'py_version': <python version>,

            'platform': <platform type>,

            'kallithea_version': <rhodecode version>

          }

          error :  null

        """

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

        """

        Get's an user by username or user_id, Returns empty result if user is

        not found. If userid param is skipped it is set to id of user who is

        calling this method. This command can be executed only using api_key

        owner = get_user_or_error(owner)

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

            repo_type = defs.get('repo_type')

        if isinstance(enable_statistics, Optional):

            enable_statistics = defs.get('repo_enable_statistics')

from kallithea.lib.helpers import Page

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator, \

    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

from kallithea.lib.utils2 import safe_int

from kallithea.lib.utils import jsonify

        acl_groups = RepoGroupList(RepoGroup.query().all(),

                               perm_set=['group.write', 'group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)

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

        """

        Load defaults settings for edit, and update

        :param repo_name:

        form_result = {}

        task_id = None

        try:

            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

            # management is handled there.

            task = RepoModel().create_fork(form_result, self.authuser.user_id)

            from celery.result import BaseAsyncResult

import kallithea.lib.helpers as h

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

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

log = logging.getLogger(__name__)

                # the fly can throw this exception signaling that there's issue

                # with user creation, explanation should be provided in

                # Exception itself

                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:

                auth_info = auth_modules.authenticate('', '', request.environ)

            except UserCreationError, e:

                log.error(e)

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

                               'hg.register.manual_activate')

    def register(self):

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

        if request.POST:

            register_form = RegisterForm()()

                # Exception itself

                h.flash(e, 'error')

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

        if request.POST:

            password_reset_form = PasswordResetForm()()

from kallithea.lib.compat import importlib

from kallithea.lib.utils2 import str2bool

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

log = logging.getLogger(__name__)

    :param username: username can be empty for container auth

    :param password: password can be empty for container auth

    :param environ: environ headers passed for container auth

    :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 = loadplugin(module)

        except (ImportError, AttributeError, TypeError), e:

            raise ImportError('Failed to load authentication module %s : %s'

        log.debug('Trying authentication using ** %s **' % (module,))

        # load plugin settings from RhodeCode database

        plugin_name = plugin.name

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

        if not str2bool(plugin_settings["enabled"]):

            log.info("Authentication plugin %s is disabled, skipping for %s"

                     % (module, username))

from kallithea.lib import auth_modules

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware, CookieStoreWrapper

from kallithea.lib.utils import get_repo_slug

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

log = logging.getLogger(__name__)

        """

        Checks the SSL check flag and returns False if SSL is not present

        and required True otherwise

        """

        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)

            return False

        return True

    def __before__(self):

        """

        __before__ is called before controller methods and after __call__

        """

        c.kallithea_version = __version__

        # Visual options

        c.visual = AttributeDict({})

        ## DB stored

        c.visual.show_public_icon = str2bool(rc_config.get('rhodecode_show_public_icon'))

@task(ignore_result=False)

@dbsession

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

    cur_user = UserModel(DBS)._get_user(cur_user)

    copy_fork_permissions = form_data.get('copy_permissions')

    copy_group_permissions = form_data.get('repo_copy_permissions')

    fork_of = form_data.get('fork_parent_id')

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

    try:

        repo = RepoModel(DBS)._create_repo(

from kallithea import __dbversion__, __py_version__

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

from kallithea.model.repo_group import RepoGroupModel

#from kallithea.model import meta

from kallithea.model.meta import Session, Base

    def fix_repo_paths(self):

        """

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

        """

                .scalar()

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

        try:

            self.sa.add(paths)

    def fix_settings(self):

        """

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except Exception:

            self.sa.rollback()

        """

        Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS