def __load_defaults(self):

        c.available_plugins = [

            'kallithea.lib.auth_modules.auth_container',

            'kallithea.lib.auth_modules.auth_ldap',

            'kallithea.lib.auth_modules.auth_crowd',

        _defaults = {}

        # default plugins loaded

        formglobals = {

        }

        formglobals.update(Setting.get_auth_settings())

        formglobals["plugin_settings"] = {}

                skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',

                              'new_password', 'password_confirmation']

                #TODO: plugin should define if username can be updated

                    # forbid updating username for external accounts

                    skip_attrs.append('username')

from kallithea.lib import helpers as h

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

    AuthUser, generate_api_key

from kallithea.lib import auth_modules

from kallithea.lib.base import BaseController, render

from kallithea.model.api_key import ApiKeyModel

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        user_model = UserModel()

        user_form = UserForm()()

        try:

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

        """GET /users/new: Form to create a new item"""

        # url('new_user')

        return render('admin/users/user_add.html')

    def update(self, id):

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

            skip_attrs = ['extern_type', 'extern_name']

            #TODO: plugin should define if username can be updated

                # forbid updating username for external accounts

                skip_attrs.append('username')

    def create_user(self, apiuser, username, email, password=Optional(''),

                    firstname=Optional(''), lastname=Optional(''),

                    active=Optional(True), admin=Optional(False),

        """

        Creates new user. Returns new user object. This command can

        be executed only using api_key belonging to user with admin rights.

def importplugin(plugin):

    """

    Imports and returns the authentication plugin in the module named by plugin

    RhodeCodeAuthPluginBase subclass on success, raises exceptions on failure.

    raises:

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

RhodeCode authentication plugin for built in internal auth

    @hybrid_property

    def name(self):

    def settings(self):

        return []

        :param skip_existing:

        """

            if skip_existing and Setting.get_by_name(k) != None:

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

                continue

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

                                     firstname='RhodeCode', lastname='Admin',

                                     active=True, admin=admin,

    def create_default_user(self):

        log.info('creating default user')

            usr.extern_name = ldap_dn

            usr.extern_type = 'ldap'

        else:

        _SESSION().add(usr)

        _SESSION().commit()

def fixups(models, _SESSION):

    notify('Fixing default auth modules')

    opts = []

    ldap_enabled = str2bool(getattr(

        models.Setting.get_by_name('ldap_active'),

        opts.append(('auth_ldap_enabled', 'True', 'bool'))

    opts.append(('auth_plugins', plugins, 'list'),)

    for name, default, type_ in opts:

        setting = models.Setting.get_by_name(name)

def fixups(models, _SESSION):

    for usr in models.User.query().all():

        if not usr.extern_name:

            _SESSION().add(usr)

            _SESSION().commit()

        try:

            form_data['admin'] = False

            new_user = self.create(form_data)

            self.sa.add(new_user)

        <% readonly = None %>

        <% disabled = "" %>

        <div class="fields">

                <% readonly = "readonly" %>

                <% disabled = " disabled" %>

                <strong>${_('Your user is in an external Source of Record; some details cannot be managed here')}.</strong>

        <% readonly = None %>

        <% disabled = "" %>

        <div class="fields">

             <div class="field">

               <% readonly = "readonly" %>

               <% disabled = " disabled" %>

        id_, params = _build_data(self.apikey, 'create_user',

                                  username=username,

        response = api_call(self, params)

        usr = UserModel().get_by_username(username)

            lastname='Test',

            active=True,

            admin=False,

            extern_name=None

        )

        defs.update(custom)

        if ldap_lib_installed:

            raise SkipTest('skipping due to missing ldap lib')

        params.update({'auth_ldap_host': u'dc.example.com',

                       'auth_ldap_port': '999',

                       'auth_ldap_tls_kind': 'PLAIN',

        if ldap_lib_installed:

            raise SkipTest('skipping due to missing ldap lib')

        params.update({'auth_ldap_host': '',

                       'auth_ldap_port': 'i-should-be-number',  # bad port num

                       'auth_ldap_tls_kind': 'PLAIN',

        if ldap_lib_installed:

            raise SkipTest('skipping due to missing ldap lib')

        params.update({'auth_ldap_host': 'Host',

                       'auth_ldap_port': '123',

                       'auth_ldap_tls_kind': 'PLAIN',

             'firstname': name,

             'active': True,

             'lastname': lastname,

             'email': email})

        self.checkSessionFlash(response, '''Created user %s''' % (username))

        self.log_user()

        usr = fixture.create_user(self.test_user_1, password='qweqwe',

                                  email='testme@example.com',

                                  extern_name=self.test_user_1,

                                  skip_if_exists=True)

        Session().commit()

            params['emails'] = [attrs['email']]

        if name == 'extern_type':

            #cannot update this via form, expected value is original one

        if name == 'extern_name':

            #cannot update this via form, expected value is original one

            params['extern_name'] = self.test_user_1

    def test_my_account_update(self, name, attrs):

        usr = fixture.create_user(self.test_user_1, password='qweqwe',

                                  email='testme@example.com',

                                  extern_name=self.test_user_1,

                                  skip_if_exists=True)

        params = usr.get_api_data()  # current user data

        params.update({'password_confirmation': ''})

        params.update({'new_password': ''})

        params.update({'extern_name': self.test_user_1})

        params.update(attrs)

            params['emails'] = [attrs['email']]

        if name == 'extern_type':

            #cannot update this via form, expected value is original one

        if name == 'extern_name':

            #cannot update this via form, expected value is original one

            params['extern_name'] = str(user_id)