configeditor key reading refactoring

server/src/main/java/password/pwm/config/stored/StoredConfigKey.java

@@ -105,7 +105,7 @@ public class StoredConfigKey implements Serializable, Comparable<StoredConfigKey
         return new StoredConfigKey( RecordType.SETTING, domainID, pwmSetting.getKey(), profileID );
     }
 
-    static StoredConfigKey forLocaleBundle( final PwmLocaleBundle localeBundle, final String key, final DomainID domainID )
+    public static StoredConfigKey forLocaleBundle( final PwmLocaleBundle localeBundle, final String key, final DomainID domainID )
     {
         return new StoredConfigKey( RecordType.LOCALE_BUNDLE, domainID, localeBundle.getKey(), key );
     }

server/src/main/java/password/pwm/http/servlet/configeditor/ConfigEditorServlet.java

@@ -33,7 +33,6 @@ import password.pwm.config.DomainConfig;
 import password.pwm.config.PwmSetting;
 import password.pwm.config.PwmSettingCategory;
 import password.pwm.config.PwmSettingTemplate;
-import password.pwm.http.servlet.configeditor.function.SettingUIFunction;
 import password.pwm.config.profile.EmailServerProfile;
 import password.pwm.config.profile.PwmPasswordPolicy;
 import password.pwm.config.stored.ConfigSearchMachine;
@@ -69,6 +68,7 @@ import password.pwm.http.servlet.configeditor.data.NavTreeItem;
 import password.pwm.http.servlet.configeditor.data.NavTreeSettings;
 import password.pwm.http.servlet.configeditor.data.SettingData;
 import password.pwm.http.servlet.configeditor.data.SettingDataMaker;
+import password.pwm.http.servlet.configeditor.function.SettingUIFunction;
 import password.pwm.http.servlet.configmanager.ConfigManagerServlet;
 import password.pwm.i18n.Config;
 import password.pwm.i18n.Message;
@@ -104,7 +104,6 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.StringTokenizer;
 import java.util.TreeMap;
 
 @WebServlet(
@@ -120,9 +119,16 @@ import java.util.TreeMap;
 )
 public class ConfigEditorServlet extends ControlledPwmServlet
 {
-
     private static final PwmLogger LOGGER = PwmLogger.forClass( ConfigEditorServlet.class );
 
+    public static final String REQ_PARAM_ALIAS = "alias";
+    public static final String REQ_PARAM_PASSWORD = "password";
+    public static final String REQ_PARAM_FORMAT = "format";
+    public static final String REQ_PARAM_LOCALE_BUNDLE = "localeBundle";
+    public static final String REQ_PARAM_KEY = "key";
+    public static final String REQ_PARAM_PROFILE = "profile";
+    public static final String REQ_PARAM_TEMPLATE = "template";
+
     public enum ConfigEditorAction implements AbstractPwmServlet.ProcessAction
     {
         readSetting( HttpMethod.POST ),
@@ -246,7 +252,7 @@ public class ConfigEditorServlet extends ControlledPwmServlet
         final PwmSetting pwmSetting = PwmSetting.forKey( requestMap.get( "setting" ) )
                 .orElseThrow( () -> new IllegalStateException( "invalid setting parameter value" ) );
         final String functionName = requestMap.get( "function" );
-        final String profileID = pwmSetting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( "profile" ) : null;
+        final String profileID = pwmSetting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( REQ_PARAM_PROFILE ) : null;
         final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( pwmSetting );
         final String extraData = requestMap.get( "extraData" );
 
@@ -287,16 +293,16 @@ public class ConfigEditorServlet extends ControlledPwmServlet
     {
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
         final StoredConfiguration storedConfig = configManagerBean.getStoredConfiguration();
-        final String key = pwmRequest.readParameterAsString( "key" );
+        final StoredConfigKey storedConfigKey = ConfigEditorServletUtils.readConfigKeyFromRequest( pwmRequest );
 
         final ReadSettingResponse readSettingResponse;
-        if ( key.startsWith( "localeBundle" ) )
+        if ( storedConfigKey.getRecordType() == StoredConfigKey.RecordType.LOCALE_BUNDLE )
         {
-            readSettingResponse = ConfigEditorServletUtils.handleLocaleBundleReadSetting( pwmRequest, storedConfig, key );
+            readSettingResponse = ConfigEditorServletUtils.handleLocaleBundleReadSetting( pwmRequest, storedConfig, storedConfigKey );
         }
         else
         {
-            readSettingResponse = ConfigEditorServletUtils.handleReadSetting( pwmRequest, storedConfig, key );
+            readSettingResponse = ConfigEditorServletUtils.handleReadSetting( pwmRequest, storedConfig, storedConfigKey );
         }
 
         pwmRequest.outputJsonResult( RestResultBean.withData( readSettingResponse, ReadSettingResponse.class ) );
@@ -325,43 +331,35 @@ public class ConfigEditorServlet extends ControlledPwmServlet
     {
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
         final StoredConfigurationModifier modifier = StoredConfigurationModifier.newModifier( configManagerBean.getStoredConfiguration() );
-        final String settingKey = pwmRequest.readParameterAsString( "key" );
         final String bodyString = pwmRequest.readRequestBodyAsString();
         final UserIdentity loggedInUser = pwmRequest.getUserInfoIfLoggedIn();
 
         final ReadSettingResponse readSettingResponse;
 
-        if ( settingKey.startsWith( "localeBundle" ) )
+        final StoredConfigKey key = ConfigEditorServletUtils.readConfigKeyFromRequest( pwmRequest );
+
+        if ( key.getRecordType() == StoredConfigKey.RecordType.LOCALE_BUNDLE )
         {
-            final StringTokenizer st = new StringTokenizer( settingKey, "-" );
-            st.nextToken();
-            final PwmLocaleBundle pwmLocaleBundle = PwmLocaleBundle.forKey( st.nextToken() )
-                    .orElseThrow( () -> new IllegalArgumentException( "unknown locale bundle name" ) );
-            final String keyName = st.nextToken();
             final Map<String, String> valueMap = JsonFactory.get().deserializeStringMap( bodyString );
             final Map<String, String> outputMap = new LinkedHashMap<>( valueMap );
 
-            final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainIDForLocaleBundle();
-            modifier.writeLocaleBundleMap( domainID, pwmLocaleBundle, keyName, outputMap );
-            readSettingResponse = ConfigEditorServletUtils.handleLocaleBundleReadSetting( pwmRequest, modifier.newStoredConfiguration(), settingKey );
+            final PwmLocaleBundle pwmLocaleBundle = key.toLocaleBundle();
+            final String keyName = key.getProfileID();
+            modifier.writeLocaleBundleMap( key.getDomainID(), pwmLocaleBundle, keyName, outputMap );
+            readSettingResponse = ConfigEditorServletUtils.handleLocaleBundleReadSetting( pwmRequest, modifier.newStoredConfiguration(), key );
         }
         else
         {
-            final PwmSetting setting = PwmSetting.forKey( settingKey )
-                    .orElseThrow( () -> new IllegalStateException( "invalid setting parameter value" ) );
-            final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( setting );
-            final String profileID = setting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( "profile" ) : null;
-            final StoredConfigKey key = StoredConfigKey.forSetting( setting, profileID, domainID );
             try
             {
-                final StoredValue storedValue = ValueFactory.fromJson( setting, bodyString );
+                final StoredValue storedValue = ValueFactory.fromJson( key.toPwmSetting(), bodyString );
                 modifier.writeSetting( key, storedValue, loggedInUser );
             }
             catch ( final PwmOperationalException e )
             {
                 throw new PwmUnrecoverableException( e.getErrorInformation() );
             }
-            readSettingResponse = ConfigEditorServletUtils.handleReadSetting( pwmRequest, modifier.newStoredConfiguration(), settingKey );
+            readSettingResponse = ConfigEditorServletUtils.handleReadSetting( pwmRequest, modifier.newStoredConfiguration(), key );
         }
 
         ConfigurationCleaner.postProcessStoredConfig( modifier );
@@ -379,25 +377,17 @@ public class ConfigEditorServlet extends ControlledPwmServlet
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
         final StoredConfigurationModifier modifier = StoredConfigurationModifier.newModifier( configManagerBean.getStoredConfiguration() );
         final UserIdentity loggedInUser = pwmRequest.getUserInfoIfLoggedIn();
-        final String settingKey = pwmRequest.readParameterAsString( "key" );
+        final StoredConfigKey key = ConfigEditorServletUtils.readConfigKeyFromRequest( pwmRequest );
 
-        if ( settingKey.startsWith( "localeBundle" ) )
+        if ( key.getRecordType() == StoredConfigKey.RecordType.LOCALE_BUNDLE )
         {
-            final StringTokenizer st = new StringTokenizer( settingKey, "-" );
-            st.nextToken();
-            final PwmLocaleBundle pwmLocaleBundle = PwmLocaleBundle.forKey( st.nextToken() )
-                    .orElseThrow( () -> new IllegalArgumentException( "unknown locale bundle name" ) );
-            final String keyName = st.nextToken();
+            final PwmLocaleBundle pwmLocaleBundle = key.toLocaleBundle();
+            final String keyName = key.getProfileID();
             final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainIDForLocaleBundle();
             modifier.resetLocaleBundleMap( pwmLocaleBundle, keyName, domainID );
         }
         else
         {
-            final PwmSetting setting = PwmSetting.forKey( settingKey )
-                    .orElseThrow( () -> new IllegalStateException( "invalid setting parameter value" ) );
-            final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( setting );
-            final String profileID = setting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( "profile" ) : null;
-            final StoredConfigKey key = StoredConfigKey.forSetting( setting, profileID, domainID );
             modifier.resetSetting( key, loggedInUser );
         }
 
@@ -498,36 +488,20 @@ public class ConfigEditorServlet extends ControlledPwmServlet
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
         final StoredConfigurationModifier modifier = StoredConfigurationModifier.newModifier( configManagerBean.getStoredConfiguration() );
         {
-            final String updateDescriptionTextCmd = pwmRequest.readParameterAsString( "updateNotesText" );
-            if ( StringUtil.nullSafeEqualsIgnoreCase( "true", updateDescriptionTextCmd ) )
+
+            final String requestedTemplate = pwmRequest.readParameterAsString( REQ_PARAM_TEMPLATE );
+            if ( requestedTemplate != null && requestedTemplate.length() > 0 )
             {
                 try
                 {
-                    final String bodyString = pwmRequest.readRequestBodyAsString();
-                    final String value = JsonFactory.get().deserialize( bodyString, String.class );
-                    modifier.writeConfigProperty( ConfigurationProperty.NOTES, value );
-                    LOGGER.trace( () -> "updated notesText" );
+                    final PwmSettingTemplate template = PwmSettingTemplate.valueOf( requestedTemplate );
+                    modifier.writeConfigProperty( ConfigurationProperty.LDAP_TEMPLATE, template.toString() );
+                    LOGGER.trace( () -> "setting template to: " + requestedTemplate );
                 }
-                catch ( final Exception e )
+                catch ( final IllegalArgumentException e )
                 {
-                    LOGGER.error( () -> "error updating notesText: " + e.getMessage() );
-                }
-            }
-            {
-                final String requestedTemplate = pwmRequest.readParameterAsString( "template" );
-                if ( requestedTemplate != null && requestedTemplate.length() > 0 )
-                {
-                    try
-                    {
-                        final PwmSettingTemplate template = PwmSettingTemplate.valueOf( requestedTemplate );
-                        modifier.writeConfigProperty( ConfigurationProperty.LDAP_TEMPLATE, template.toString() );
-                        LOGGER.trace( () -> "setting template to: " + requestedTemplate );
-                    }
-                    catch ( final IllegalArgumentException e )
-                    {
-                        modifier.writeConfigProperty( ConfigurationProperty.LDAP_TEMPLATE, PwmSettingTemplate.DEFAULT.toString() );
-                        LOGGER.error( () -> "unknown template set request: " + requestedTemplate );
-                    }
+                    modifier.writeConfigProperty( ConfigurationProperty.LDAP_TEMPLATE, PwmSettingTemplate.DEFAULT.toString() );
+                    LOGGER.error( () -> "unknown template set request: " + requestedTemplate );
                 }
             }
         }
@@ -619,7 +593,7 @@ public class ConfigEditorServlet extends ControlledPwmServlet
         final Instant startTime = Instant.now();
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
         LOGGER.debug( pwmRequest, () -> "beginning restLdapHealthCheck" );
-        final String profileID = pwmRequest.readParameterAsString( "profile" );
+        final String profileID = pwmRequest.readParameterAsString( REQ_PARAM_PROFILE );
         final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( PwmSetting.LDAP_SERVER_URLS );
         final DomainConfig config = new AppConfig( configManagerBean.getStoredConfiguration() ).getDomainConfigs().get( domainID );
         final PublicHealthData healthData = LDAPHealthChecker.healthForNewConfiguration(
@@ -710,7 +684,7 @@ public class ConfigEditorServlet extends ControlledPwmServlet
     {
         final Instant startTime = Instant.now();
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
-        final String profileID = pwmRequest.readParameterAsString( "profile" );
+        final String profileID = pwmRequest.readParameterAsString( REQ_PARAM_PROFILE );
 
         LOGGER.debug( pwmRequest, () -> "beginning restEmailHealthCheck" );
 
@@ -765,7 +739,7 @@ public class ConfigEditorServlet extends ControlledPwmServlet
     {
         final ConfigManagerBean configManagerBean = getBean( pwmRequest );
 
-        final String settingKey = pwmRequest.readParameterAsString( "key" );
+        final String settingKey = pwmRequest.readParameterAsString( REQ_PARAM_KEY );
         final PwmSetting pwmSetting = PwmSetting.forKey( settingKey )
                 .orElseThrow( () -> new IllegalStateException( "invalid setting parameter value" ) );
         final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( pwmSetting );

server/src/main/java/password/pwm/http/servlet/configeditor/ConfigEditorServletUtils.java

@@ -166,19 +166,15 @@ public class ConfigEditorServletUtils
     static ConfigEditorServlet.ReadSettingResponse handleLocaleBundleReadSetting(
             final PwmRequest pwmRequest,
             final StoredConfiguration storedConfig,
-            final String key
+            final StoredConfigKey key
 
     )
             throws PwmUnrecoverableException
     {
         final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainIDForLocaleBundle();
         final ConfigEditorServlet.ReadSettingResponse.ReadSettingResponseBuilder builder = ConfigEditorServlet.ReadSettingResponse.builder();
-        final StringTokenizer st = new StringTokenizer( key, "-" );
-        st.nextToken();
-        final String localeBundleName = st.nextToken();
-        final PwmLocaleBundle pwmLocaleBundle = PwmLocaleBundle.forKey( localeBundleName )
-                .orElseThrow( () -> new IllegalArgumentException( "unknown locale bundle name '" + localeBundleName + "'" ) );
-        final String keyName = st.nextToken();
+        final PwmLocaleBundle pwmLocaleBundle = key.toLocaleBundle();
+        final String keyName = key.getProfileID();
         final Map<String, String> bundleMap = storedConfig.readLocaleBundleMap( pwmLocaleBundle, keyName, domainID );
         if ( bundleMap == null || bundleMap.isEmpty() )
         {
@@ -209,28 +205,23 @@ public class ConfigEditorServletUtils
             builder.value( bundleMap );
             builder.isDefault( false );
         }
-        builder.key( key );
+        builder.key( keyName );
         return builder.build();
     }
 
     static ConfigEditorServlet.ReadSettingResponse handleReadSetting(
             final PwmRequest pwmRequest,
             final StoredConfiguration storedConfig,
-            final String settingKey
+            final StoredConfigKey key
     )
             throws PwmUnrecoverableException
     {
         final ConfigEditorServlet.ReadSettingResponse.ReadSettingResponseBuilder builder = ConfigEditorServlet.ReadSettingResponse.builder();
-        final PwmSetting pwmSetting = PwmSetting.forKey( settingKey )
-                .orElseThrow( () -> new IllegalStateException( "invalid setting parameter value" ) );
 
-        final Object returnValue;
-        final String profile = pwmSetting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( "profile" ) : null;
-        final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( pwmSetting );
-
-        final StoredConfigKey key = StoredConfigKey.forSetting( pwmSetting, profile, domainID );
+        final PwmSetting pwmSetting = key.toPwmSetting();
         final boolean isDefault = StoredConfigurationUtil.isDefaultValue( storedConfig, key );
 
+        final Object returnValue;
         switch ( pwmSetting.getSyntax() )
         {
             case PASSWORD:
@@ -268,7 +259,7 @@ public class ConfigEditorServletUtils
                 builder.modifyUser( settingMetaData.map( ValueMetaData::getUserIdentity ).orElse( null ) );
             }
         }
-        builder.key( settingKey );
+        builder.key( key.toPwmSetting().getKey() );
         builder.category( pwmSetting.getCategory().toString() );
         builder.syntax( pwmSetting.getSyntax().toString() );
         return builder.build();
@@ -282,20 +273,20 @@ public class ConfigEditorServletUtils
     {
         try
         {
-            final PasswordData passwordData = pwmRequest.readParameterAsPassword( "password" )
+            final PasswordData passwordData = pwmRequest.readParameterAsPassword( ConfigEditorServlet.REQ_PARAM_PASSWORD )
                     .orElseThrow( () -> new NoSuchElementException( "missing 'password' field" ) );
 
-            final String alias = pwmRequest.readParameterAsString( "alias" );
+            final String alias = pwmRequest.readParameterAsString( ConfigEditorServlet.REQ_PARAM_ALIAS );
             final HttpsServerCertificateManager.KeyStoreFormat keyStoreFormat;
             try
             {
-                keyStoreFormat = HttpsServerCertificateManager.KeyStoreFormat.valueOf( pwmRequest.readParameterAsString( "format" ) );
+                keyStoreFormat = HttpsServerCertificateManager.KeyStoreFormat.valueOf( pwmRequest.readParameterAsString( ConfigEditorServlet.REQ_PARAM_FORMAT ) );
             }
             catch ( final IllegalArgumentException e )
             {
                 throw new PwmUnrecoverableException( new ErrorInformation( PwmError.ERROR_MISSING_PARAMETER, "unknown format type: " + e.getMessage(), new String[]
                         {
-                                "format",
+                                ConfigEditorServlet.REQ_PARAM_FORMAT,
                         }
                 ) );
             }
@@ -323,4 +314,36 @@ public class ConfigEditorServletUtils
             pwmRequest.respondWithError( e.getErrorInformation(), false );
         }
     }
+
+    static StoredConfigKey readConfigKeyFromRequest( final PwmRequest pwmRequest )
+            throws PwmUnrecoverableException
+    {
+
+        final String keyStringParam = pwmRequest.readParameterAsString( ConfigEditorServlet.REQ_PARAM_KEY );
+
+        if ( keyStringParam.startsWith( ConfigEditorServlet.REQ_PARAM_LOCALE_BUNDLE ) )
+        {
+            try
+            {
+                final StringTokenizer st = new StringTokenizer( keyStringParam, "-" );
+                st.nextToken();
+                final PwmLocaleBundle pwmLocaleBundle = PwmLocaleBundle.forKey( st.nextToken() )
+                        .orElseThrow( () -> new IllegalArgumentException( "invalid StoredConfigKey locale key" ) );
+                final String keyName = st.nextToken();
+
+                final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainIDForLocaleBundle();
+                return StoredConfigKey.forLocaleBundle( pwmLocaleBundle, keyName, domainID );
+            }
+            catch ( final NoSuchElementException e )
+            {
+                throw new IllegalArgumentException( "invalid StoredConfigKey locale key format" );
+            }
+        }
+
+        final PwmSetting setting = PwmSetting.forKey( keyStringParam )
+                .orElseThrow( () -> new IllegalStateException( "invalid StoredConfigKey setting key" ) );
+        final DomainID domainID = DomainStateReader.forRequest( pwmRequest ).getDomainID( setting );
+        final String profileID = setting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString( ConfigEditorServlet.REQ_PARAM_PROFILE ) : null;
+        return StoredConfigKey.forSetting( setting, profileID, domainID );
+    }
 }