auth-plugins: use a nicer visual display of auth plugins that would highlight that order is

important.

- fixed help text.

rhodecode/authentication/views.py

@@ -1,191 +1,191 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import formencode.htmlfill
 import logging
 
 from pyramid.httpexceptions import HTTPFound
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.authentication.base import (
     get_auth_cache_manager, get_perms_cache_manager, get_authn_registry)
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib.caches import clear_cache_manager
 from rhodecode.model.forms import AuthSettingsForm
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class AuthnPluginViewBase(BaseAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         self.plugin = self.context.plugin
         return c
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def settings_get(self, defaults=None, errors=None):
         """
         View that displays the plugin settings as a form.
         """
         c = self.load_default_context()
         defaults = defaults or {}
         errors = errors or {}
         schema = self.plugin.get_settings_schema()
 
         # Compute default values for the form. Priority is:
         # 1. Passed to this method 2. DB value 3. Schema default
         for node in schema:
             if node.name not in defaults:
                 defaults[node.name] = self.plugin.get_setting_by_name(
                     node.name, node.default, cache=False)
 
         template_context = {
             'defaults': defaults,
             'errors': errors,
             'plugin': self.context.plugin,
             'resource': self.context,
         }
 
         return self._get_template_context(c, **template_context)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def settings_post(self):
         """
         View that validates and stores the plugin settings.
         """
         _ = self.request.translate
         self.load_default_context()
         schema = self.plugin.get_settings_schema()
         data = self.request.params
 
         try:
             valid_data = schema.deserialize(data)
         except colander.Invalid as e:
             # Display error message and display form again.
             h.flash(
                 _('Errors exist when saving plugin settings. '
                   'Please check the form inputs.'),
                 category='error')
             defaults = {key: data[key] for key in data if key in schema}
             return self.settings_get(errors=e.asdict(), defaults=defaults)
 
         # Store validated data.
         for name, value in valid_data.items():
             self.plugin.create_or_update_setting(name, value)
         Session().commit()
 
         # cleanup cache managers in case of change for plugin
         # TODO(marcink): because we can register multiple namespaces
         # we should at some point figure out how to retrieve ALL namespace
         # cache managers and clear them...
         cache_manager = get_auth_cache_manager()
         clear_cache_manager(cache_manager)
 
         cache_manager = get_perms_cache_manager()
         clear_cache_manager(cache_manager)
 
         # Display success message and redirect.
         h.flash(_('Auth settings updated successfully.'), category='success')
         redirect_to = self.request.resource_path(
             self.context, route_name='auth_home')
         return HTTPFound(redirect_to)
 
 
 class AuthSettingsView(BaseAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         return c
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def index(self, defaults=None, errors=None, prefix_error=False):
         c = self.load_default_context()
 
         defaults = defaults or {}
         authn_registry = get_authn_registry(self.request.registry)
         enabled_plugins = SettingsModel().get_auth_plugins()
 
         # Create template context and render it.
         template_context = {
             'resource': self.context,
             'available_plugins': authn_registry.get_plugins(),
             'enabled_plugins': enabled_plugins,
         }
         html = render('rhodecode:templates/admin/auth/auth_settings.mako',
                       self._get_template_context(c, **template_context),
                       self.request)
 
         # Create form default values and fill the form.
         form_defaults = {
-            'auth_plugins': ','.join(enabled_plugins)
+            'auth_plugins': ',\n'.join(enabled_plugins)
         }
         form_defaults.update(defaults)
         html = formencode.htmlfill.render(
             html,
             defaults=form_defaults,
             errors=errors,
             prefix_error=prefix_error,
             encoding="UTF-8",
             force_defaults=False)
 
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     def auth_settings(self):
         _ = self.request.translate
         try:
             form = AuthSettingsForm(self.request.translate)()
             form_result = form.to_python(self.request.POST)
             plugins = ','.join(form_result['auth_plugins'])
             setting = SettingsModel().create_or_update_setting(
                 'auth_plugins', plugins)
             Session().add(setting)
             Session().commit()
 
             h.flash(_('Auth settings updated successfully.'), category='success')
         except formencode.Invalid as errors:
             e = errors.error_dict or {}
             h.flash(_('Errors exist when saving plugin setting. '
                       'Please check the form inputs.'), category='error')
             return self.index(
                 defaults=errors.value,
                 errors=e,
                 prefix_error=False)
         except Exception:
             log.exception('Exception in auth_settings')
             h.flash(_('Error occurred during update of auth settings.'),
                     category='error')
 
         redirect_to = self.request.resource_path(
             self.context, route_name='auth_home')
         return HTTPFound(redirect_to)

rhodecode/templates/admin/auth/auth_settings.mako

@@ -1,116 +1,118 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('Authentication Settings')}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
     ${_('Authentication Plugins')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='admin')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
   <div class="title">
     ${self.breadcrumbs()}
   </div>
 
   <div class='sidebar-col-wrapper'>
 
     <div class="sidebar">
         <ul class="nav nav-pills nav-stacked">
           % for item in resource.get_root().get_nav_list():
             <li ${'class=active' if item == resource else ''}>
               <a href="${request.resource_path(item, route_name='auth_home')}">${item.display_name}</a>
             </li>
           % endfor
         </ul>
     </div>
 
     <div class="main-content-full-width">
       ${h.secure_form(request.resource_path(resource, route_name='auth_home'), request=request)}
       <div class="form">
 
         <div class="panel panel-default">
 
           <div class="panel-heading">
             <h3 class="panel-title">${_("Enabled and Available Plugins")}</h3>
           </div>
 
           <div class="fields panel-body">
 
             <div class="field">
               <div class="label">${_("Enabled Plugins")}</div>
               <div class="textarea text-area editor">
                   ${h.textarea('auth_plugins',cols=23,rows=5,class_="medium")}
               </div>
-              <p class="help-block">
-              ${_('Add a list of plugins, separated by commas. '
-                  'The order of the plugins is also the order in which '
-                  'RhodeCode Enterprise will try to authenticate a user.')}
-              </p>
+              <p class="help-block pre-formatting">${_('List of plugins, separated by commas.'
+                  '\nThe order of the plugins is also the order in which '
+                  'RhodeCode Enterprise will try to authenticate a user.')}</p>
             </div>
 
             <div class="field">
               <div class="label">${_('Available Built-in Plugins')}</div>
               <ul class="auth_plugins">
               %for plugin in available_plugins:
                   <li>
                     <div class="auth_buttons">
                         <span plugin_id="${plugin.get_id()}" class="toggle-plugin btn ${'btn-success' if plugin.get_id() in enabled_plugins else ''}">
                           ${_('enabled') if plugin.get_id() in enabled_plugins else _('disabled')}
                         </span>
                         ${plugin.get_display_name()} (${plugin.get_id()})
                     </div>
                   </li>
               %endfor
               </ul>
             </div>
 
             <div class="buttons">
               ${h.submit('save',_('Save'),class_="btn")}
             </div>
           </div>
         </div>
       </div>
       ${h.end_form()}
     </div>
   </div>
 </div>
 
 <script>
   $('.toggle-plugin').click(function(e){
     var auth_plugins_input = $('#auth_plugins');
-    var notEmpty = function(element, index, array) {
-      return (element != "");
-    };
-    var elems = auth_plugins_input.val().split(',').filter(notEmpty);
+    var elems = [];
+
+    $.each(auth_plugins_input.val().split(',') , function (index, element) {
+        if (element !== "") {
+            elems.push(element.strip())
+        }
+    });
+
     var cur_button = e.currentTarget;
     var plugin_id = $(cur_button).attr('plugin_id');
     if($(cur_button).hasClass('btn-success')){
       elems.splice(elems.indexOf(plugin_id), 1);
-      auth_plugins_input.val(elems.join(','));
+      auth_plugins_input.val(elems.join(',\n'));
       $(cur_button).removeClass('btn-success');
       cur_button.innerHTML = _gettext('disabled');
     }
     else{
       if(elems.indexOf(plugin_id) == -1){
         elems.push(plugin_id);
       }
-      auth_plugins_input.val(elems.join(','));
+      auth_plugins_input.val(elems.join(',\n'));
       $(cur_button).addClass('btn-success');
       cur_button.innerHTML = _gettext('enabled');
     }
   });
 </script>
 </%def>