How to use

ConfigItem

in

org.guvnor.structure.server.config

private void addEnvironmentParameters(final Collection<ConfigItem> items) {
  for (final ConfigItem item : items) {
    if (item instanceof SecureConfigItem) {
      repo.addEnvironmentParameter(item.getName(),
                     secureService.decrypt(item.getValue().toString()));
    } else {
      repo.addEnvironmentParameter(item.getName(),
                     item.getValue());
    }
  }
}

@Override
public ConfigItem<String> newConfigItem(final String name,
                    final String valueType) {
  final ConfigItem<String> stringConfigItem = new ConfigItem<String>();
  stringConfigItem.setName(name);
  stringConfigItem.setValue(valueType);
  return stringConfigItem;
}

ConfigItem existentConfigItem = existentConfigGroup.getConfigItem(configItem.getName());
if (existentConfigItem == null) {
  existentConfigGroup.addConfigItem(configItem);
  configurationService.updateConfiguration(existentConfigGroup);
} else if (!existentConfigItem.getValue().equals(configItem.getValue())) {
  existentConfigItem.setValue(configItem.getValue());
  configurationService.updateConfiguration(existentConfigGroup);

public String getConfigItemValue(final String name) {
  ConfigItem<String> configItem = this.items.get(name);
  if (configItem == null) {
    return null;
  } else {
    return configItem.getValue();
  }
}

holder.key.setText(item.getColumnDescribe() + ":");
if (!item.isNull()) {
  holder.key.setCompoundDrawables(isNull, null, null, null);
}else{
  public void onFocusChange(View v, boolean hasFocus) {
    if(!hasFocus){
      item.setDisplayValue(((EditText)v).getText().toString());
      item.setValue(((EditText)v).getText().toString());
if(item.isList()){
  holder.edit_value.setText(item.getDisplayValue());
  holder.text_value.setText(item.getDisplayValue());
}else if(item.getColumnType().equals("VIRTUALBUTTON")){
  holder.edit_value.setText(item.getColumnDescribe());
  holder.text_value.setText(item.getColumnDescribe());
}else{
  holder.edit_value.setText(item.getValue());
  holder.text_value.setText(item.getValue());
if(item.getColumnType().equalsIgnoreCase("number")){
  holder.edit_value.setSingleLine(true);
  holder.edit_value.setLines(1);
} else if(item.getColumnType().equalsIgnoreCase("TEXTAREA")){
  holder.text_value.setInputType(InputType.TYPE_CLASS_TEXT);
  holder.edit_value.setInputType(InputType.TYPE_CLASS_TEXT);

final ConfigItem<String> droolsDefaultLanguageConfigItem = new ConfigItem<>();
droolsDefaultLanguageConfigItem.setName("drools.defaultlanguage");
droolsDefaultLanguageConfigItem.setValue("en");
final ConfigItem<String> droolsDefaultCountryConfigItem = new ConfigItem<>();
droolsDefaultCountryConfigItem.setName("drools.defaultcountry");
droolsDefaultCountryConfigItem.setValue("US");
final ConfigItem<String> supportRuntimeDeployConfigItem = new ConfigItem<>();
supportRuntimeDeployConfigItem.setName("support.runtime.deploy");
supportRuntimeDeployConfigItem.setValue("true");
    never()).addConfigItem(supportRuntimeDeployConfigItem);
verify(existentDroolsDefaultLanguageConfigItem).setValue(droolsDefaultLanguageConfigItem.getValue()); // updated config item
verify(existentSupportRuntimeDeployConfigItem,
    never()).setValue(anyString());

public void setConfigItem(final ConfigItem configItem) {
  this.items.put(configItem.getName(),
          configItem);
}

  private ConfigGroup getConfigGroup() {
    ConfigGroup repoConfig = new ConfigGroup();
    ConfigItem configItem = new ConfigItem();
    configItem.setName(EnvironmentParameters.SCHEME);
    repoConfig.addConfigItem(configItem);
    return repoConfig;
  }
}

                                     entry.getValue()));
} else {
  configItem.setValue(entry.getValue());

static Map<String, String> getOrgUnitsByRepo(List<ConfigGroup> orgUnitConfigs) {
  Map<String, String> orgUnitByRepo = new LinkedHashMap<>();
  orgUnitConfigs
         .stream()
         .forEach(group -> {
           @SuppressWarnings("unchecked")
           ConfigItem<List<String>> repos = group.getConfigItem("repositories");
           Optional.ofNullable(repos)
               .map(r -> r.getValue())
               .ifPresent(r -> r.forEach(repo -> orgUnitByRepo.put(repo, group.getName())));
         });
  return orgUnitByRepo;
}

public void addConfigItem(final ConfigItem configItem) {
  if (!this.items.containsKey(configItem.getName())) {
    setConfigItem(configItem);
  }
}

@Override
public void updateContributors(final Repository repository,
                final List<Contributor> contributors) {
  final ConfigGroup thisRepositoryConfig = findRepositoryConfig(repository.getAlias(),
                                 repository.getSpace().getName());
  if (thisRepositoryConfig != null) {
    final ConfigItem<List<Contributor>> contributorsConfigItem = thisRepositoryConfig.getConfigItem("contributors");
    contributorsConfigItem.setValue(contributors);
    configurationService.updateConfiguration(thisRepositoryConfig);
    configuredRepositories.update(repository.getSpace(),
                   repositoryFactory.newRepository(thisRepositoryConfig));
  } else {
    throw new IllegalArgumentException("Repository " + repository.getAlias() + " not found");
  }
}

  @Override
  public ConfigItem<Object> newConfigItem(String name,
                      Object valueType) {
    final ConfigItem<Object> listConfigItem = new ConfigItem<Object>();
    listConfigItem.setName(name);
    listConfigItem.setValue(valueType);
    return listConfigItem;
  }
}

private void addEnvironmentParameters(final Collection<ConfigItem> items) {
  for (final ConfigItem item : items) {
    if (item instanceof SecureConfigItem) {
      repo.addEnvironmentParameter(item.getName(),
          secureService.decrypt(item.getValue().toString()));
    } else {
      repo.addEnvironmentParameter(item.getName(),
          item.getValue());
    }
  }
}

@Override
public boolean accept(final ConfigGroup repoConfig) {
  checkNotNull("repoConfig",
         repoConfig);
  final ConfigItem<String> schemeConfigItem = repoConfig.getConfigItem(EnvironmentParameters.SCHEME);
  checkNotNull("schemeConfigItem",
         schemeConfigItem);
  return SCHEME.equals(schemeConfigItem.getValue());
}

  @Override
  public Map<String, String> load() {
    final Map<String, String> preferences = new HashMap<String, String>();
    final List<ConfigGroup> configs = configurationService.getConfiguration(ConfigType.GLOBAL);
    for (ConfigGroup config : configs) {
      for (ConfigItem item : config.getItems()) {
        final String name = item.getName();
        final String value = config.getConfigItemValue(name);
        log.info("Setting preference '" + name + "' to '" + value + "'.");
        preferences.put(name,
                value);
      }
    }
    return preferences;
  }
}

@Override
public ConfigItem<Boolean> newConfigItem(final String name,
                     final boolean valueType) {
  final ConfigItem<Boolean> booleanConfigItem = new ConfigItem<Boolean>();
  booleanConfigItem.setName(name);
  booleanConfigItem.setValue(valueType);
  return booleanConfigItem;
}

private int getMaxRuleFirings() {
  for (ConfigGroup editorConfigGroup : configurationService.getConfiguration(ConfigType.EDITOR)) {
    if (ScenarioTestEditorService.TEST_SCENARIO_EDITOR_SETTINGS.equals(editorConfigGroup.getName())) {
      for (ConfigItem item : editorConfigGroup.getItems()) {
        String itemName = item.getName();
        if (itemName.equals(ScenarioTestEditorService.TEST_SCENARIO_EDITOR_MAX_RULE_FIRINGS)) {
          return (Integer) item.getValue();
        }
      }
    }
  }
  return 0;
}

@Override
public boolean accept( final ConfigGroup repoConfig ) {
  checkNotNull( "repoConfig", repoConfig );
  final ConfigItem<String> schemeConfigItem = repoConfig.getConfigItem( EnvironmentParameters.SCHEME );
  checkNotNull( "schemeConfigItem", schemeConfigItem );
  return SCHEME.equals( schemeConfigItem.getValue() );
}

  @Override
  public Map<String, String> load() {
    final Map<String, String> preferences = new HashMap<String, String>();
    final List<ConfigGroup> configs = configurationService.getConfiguration(ConfigType.GLOBAL);
    for (ConfigGroup config : configs) {
      for (ConfigItem item : config.getItems()) {
        final String name = item.getName();
        final String value = config.getConfigItemValue(name);
        log.info("Setting preference '" + name + "' to '" + value + "'.");
        preferences.put(name,
                value);
      }
    }
    return preferences;
  }
}