private void merge(AbstractPropertyMap base, AbstractPropertyMap changes) { for (Map.Entry<String, Property> changesEntry : changes.getMap().entrySet()) { String changesPropertyName = changesEntry.getKey(); Property changesProperty = changesEntry.getValue(); PropertySimple basePropertySimple = (PropertySimple) base.get(changesPropertyName); if (basePropertySimple == null) { basePropertySimple = new PropertySimple(changesPropertyName, changesPropertySimple.getStringValue()); base.put(basePropertySimple); } else { basePropertySimple.setStringValue(changesPropertySimple.getStringValue()); PropertyMap basePropertyMap = (PropertyMap) base.get(changesPropertyName); if (basePropertyMap == null) { basePropertyMap = new PropertyMap(changesPropertyName); base.put(basePropertyMap);
private static void mergeOpenPropertyMap(List<AbstractPropertyMap> memberParentPropertyMaps, AbstractPropertyMap groupParentPropertyMap) { for (String groupMemberPropertyName : groupParentPropertyMap.getMap().keySet()) { PropertySimple groupMemberProperty = groupParentPropertyMap.getSimple(groupMemberPropertyName); if (groupMemberProperty != null && groupMemberProperty.getOverride() != null && groupMemberProperty.getOverride()) { for (AbstractPropertyMap sourceParentPropertyMap : memberParentPropertyMaps) { PropertySimple sourcePropertySimple = sourceParentPropertyMap.getSimple(groupMemberPropertyName); if (sourcePropertySimple == null) { sourcePropertySimple = new PropertySimple(groupMemberPropertyName, groupMemberProperty .getStringValue()); sourceParentPropertyMap.put(sourcePropertySimple); } else { sourcePropertySimple.setStringValue(groupMemberProperty.getStringValue()); } } } } }
private static Map<String, Map<String, Integer>> createMemberNameValueFrequenciesMap( List<AbstractPropertyMap> sourceParentPropertyMaps) { Map<String, Map<String, Integer>> nameValueFrequenciesMap = new HashMap<String, Map<String, Integer>>(); for (AbstractPropertyMap map : sourceParentPropertyMaps) { for (String propertyName : map.getMap().keySet()) { PropertySimple propertySimple = map.getSimple(propertyName); String propertyValue = (propertySimple != null) ? propertySimple.getStringValue() : null; Map<String, Integer> valueFrequencies = nameValueFrequenciesMap.get(propertyName); if (valueFrequencies == null) { valueFrequencies = new HashMap<String, Integer>(); nameValueFrequenciesMap.put(propertyName, valueFrequencies); } Integer valueFrequency = (valueFrequencies.containsKey(propertyValue)) ? (valueFrequencies .get(propertyValue) + 1) : 1; valueFrequencies.put(propertyValue, valueFrequency); } } return nameValueFrequenciesMap; }
private static void calculateGroupOpenPropertyMap(List<AbstractPropertyMap> sourceParentPropertyMaps, AbstractPropertyMap targetParentPropertyMap) { Map<String, Map<String, Integer>> memberNameValueFrequenciesMap = createMemberNameValueFrequenciesMap(sourceParentPropertyMaps); for (String memberName : memberNameValueFrequenciesMap.keySet()) { // Add each unique member to the target map, so the renderer will be able to display it on the main // config page. PropertySimple member = new PropertySimple(memberName, null); targetParentPropertyMap.put(member); // Also add it to each of the source config maps that don't already contain it, so that they can be // rendered as unset on the propSet page. for (AbstractPropertyMap map : sourceParentPropertyMaps) { if (map.get(memberName) == null) map.put(new PropertySimple(memberName, null)); } Map<String, Integer> valueFrequencies = memberNameValueFrequenciesMap.get(memberName); if (valueFrequencies.size() == 1 && valueFrequencies.values().iterator().next() == sourceParentPropertyMaps.size()) { // Set override to true so the renderers will know the prop is homogenous. member.setOverride(true); // And set the value, so it can be displayed on the main config page. member.setStringValue(valueFrequencies.keySet().iterator().next()); } } }
private static void mergeProperty(PropertyDefinition propertyDefinition, List<AbstractPropertyMap> memberParentPropertyMaps, AbstractPropertyMap groupParentPropertyMap) { if (propertyDefinition instanceof PropertyDefinitionSimple) { PropertySimple propertySimple = groupParentPropertyMap.getSimple(propertyDefinition.getName()); if (propertySimple != null && propertySimple.getOverride() != null && propertySimple.getOverride()) { for (AbstractPropertyMap sourceParentPropertyMap : memberParentPropertyMaps) { PropertySimple sourcePropertySimple = sourceParentPropertyMap.getSimple(propertyDefinition .getName()); if (sourcePropertySimple == null) { sourcePropertySimple = new PropertySimple(propertyDefinition.getName(), propertySimple .getStringValue()); sourceParentPropertyMap.put(sourcePropertySimple); } else { sourcePropertySimple.setStringValue(propertySimple.getStringValue()); List<AbstractPropertyMap> nestedSourceParentPropertyMaps = new ArrayList<AbstractPropertyMap>(); for (AbstractPropertyMap sourceParentPropertyMap : memberParentPropertyMaps) nestedSourceParentPropertyMaps.add(sourceParentPropertyMap.getMap(propertyDefinition.getName())); PropertyMap groupPropertyMap = groupParentPropertyMap.getMap(propertyDefinition.getName()); groupParentPropertyMap.put(groupPropertyMap); mergePropertyMap((PropertyDefinitionMap) propertyDefinition, nestedSourceParentPropertyMaps, groupPropertyMap); PropertyDefinitionList propertyDefinitionList = (PropertyDefinitionList) propertyDefinition; PropertyDefinition listMemberPropertyDefinition = propertyDefinitionList.getMemberDefinition(); PropertyList groupPropertyList = groupParentPropertyMap.getList(propertyDefinition.getName()); if (listMemberPropertyDefinition instanceof PropertyDefinitionMap) { PropertyDefinitionMap propertyDefinitionMap = (PropertyDefinitionMap) listMemberPropertyDefinition;
private static void maskProperty(PropertyDefinition propertyDefinition, AbstractPropertyMap parentPropertyMap) { if (parentPropertyMap.get(propertyDefinition.getName()) == null) { PropertyDefinitionSimple propertyDefinitionSimple = (PropertyDefinitionSimple) propertyDefinition; if (propertyDefinitionSimple.getType() == PropertySimpleType.PASSWORD) { PropertySimple propertySimple = parentPropertyMap.getSimple(propertyDefinition.getName()); propertySimple.mask(); PropertyMap propertyMap = parentPropertyMap.getMap(propertyDefinition.getName()); PropertyDefinitionMap propertyDefinitionMap = (PropertyDefinitionMap) propertyDefinition; maskPropertyMap(propertyMap, propertyDefinitionMap); PropertyList propertyList = parentPropertyMap.getList(propertyDefinition.getName()); for (Property property : propertyList.getList()) { PropertyMap propertyMap = (PropertyMap) property;
private static void unmaskProperty(String propertyName, AbstractPropertyMap parentPropertyMap, AbstractPropertyMap unmaskedParentPropertyMap) { Property property = parentPropertyMap.get(propertyName); if (property == null) { PropertyMap unmaskedPropertyMap = unmaskedParentPropertyMap.getMap(property.getName()); unmaskPropertyMap(propertyMap, unmaskedPropertyMap); } else if (property instanceof PropertyList) { PropertyList unmaskedPropertyList = unmaskedParentPropertyMap.getList(propertyList.getName()); if (unmaskedPropertyList != null) { List<Property> unmaskedMemberProperties = unmaskedPropertyList.getList();
protected void setNode(PropertyDefinition propDef, AbstractPropertyMap parentPropMap, Augeas augeas, AugeasNode parentNode) { String propName = getAugeasPathRelativeToParent(propDef, parentNode, augeas); AugeasNode node = (propName.equals(".")) ? parentNode : new AugeasNode(parentNode, propName); if (isPropertyDefined(propDef, parentPropMap)) { // The property *is* defined, which means we either need to add or update the corresponding node in the // Augeas tree. if (propDef instanceof PropertyDefinitionSimple) { PropertyDefinitionSimple propDefSimple = (PropertyDefinitionSimple) propDef; PropertySimple propSimple = parentPropMap.getSimple(propDefSimple.getName()); setNodeFromPropertySimple(augeas, node, propDefSimple, propSimple); } else if (propDef instanceof PropertyDefinitionMap) { PropertyDefinitionMap propDefMap = (PropertyDefinitionMap) propDef; PropertyMap propMap = parentPropMap.getMap(propDefMap.getName()); setNodeFromPropertyMap(propDefMap, propMap, augeas, node); } else if (propDef instanceof PropertyDefinitionList) { PropertyDefinitionList propDefList = (PropertyDefinitionList) propDef; PropertyList propList = parentPropMap.getList(propDefList.getName()); setNodeFromPropertyList(propDefList, propList, augeas, node); } else { throw new IllegalStateException("Unsupported PropertyDefinition subclass: " + propDef.getClass().getName()); } } else { // The property *is not* defined - remove the corresponding node from the Augeas tree if it exists. removeNodeIfItExists(augeas, node); } }
private static void createDefaultProperty(PropertyDefinition propertyDefinition, AbstractPropertyMap parentPropertyMap) { Property property = instantiateDefaultProperty(propertyDefinition); if (property != null) { parentPropertyMap.put(property); } }
targetParentPropertyMap.put(propertySimple); if (valuesHomogenous) for (AbstractPropertyMap sourceParentPropertyMap : sourceParentPropertyMaps) { PropertyMap nestedSourceParentPropertyMap = sourceParentPropertyMap .getMap(propertyDefinition.getName()); nestedSourceParentPropertyMaps .add((nestedSourceParentPropertyMap != null) ? nestedSourceParentPropertyMap : new PropertyMap( targetParentPropertyMap.put(targetPropertyMap); calculateGroupPropertyMap((PropertyDefinitionMap) propertyDefinition, nestedSourceParentPropertyMaps, targetPropertyMap); PropertyDefinition listMemberPropertyDefinition = propertyDefinitionList.getMemberDefinition(); PropertyList targetPropertyList = new PropertyList(propertyDefinition.getName()); targetParentPropertyMap.put(targetPropertyList); if (listMemberPropertyDefinition instanceof PropertyDefinitionMap) { PropertyDefinitionMap propertyDefinitionMap = (PropertyDefinitionMap) listMemberPropertyDefinition;
private boolean isPropertyDefined(PropertyDefinition propDef, AbstractPropertyMap parentPropMap) { Property prop = parentPropMap.get(propDef.getName()); if (prop == null) { return false; } else { return (!(prop instanceof PropertySimple) || ((PropertySimple) prop).getStringValue() != null); } }
private static String getSimpleValue(AbstractPropertyMap parentPropertyMap, String propertyName) { PropertySimple samplePropertySimple = parentPropertyMap.getSimple(propertyName); return (samplePropertySimple != null) ? samplePropertySimple.getStringValue() : null; } }
private static void validatePropertyMap(AbstractPropertyMap propertyMap, AbstractPropertyMap currentPropertyMap, PropertyDefinitionMap propertyDefinitionMap, List<String> errorMessages) { // if the entire map is read-only then the new map must match the current map if the current map is non-empty if (propertyDefinitionMap.isReadOnly() && null != currentPropertyMap && !currentPropertyMap.getMap().isEmpty()) { if (!propertyMap.getMap().equals(currentPropertyMap.getMap())) { errorMessages.add("ReadOnly property '" + propertyDefinitionMap.getName() + "' has a value " + propertyMap.getMap() + " different than the current value " + currentPropertyMap.getMap() + "]. It is not allowed to change."); return; } } Map<String, PropertyDefinition> childPropertyDefinitions = propertyDefinitionMap.getMap(); for (PropertyDefinition childPropertyDefinition : childPropertyDefinitions.values()) { validateProperty(childPropertyDefinition, propertyMap, currentPropertyMap, errorMessages); } }
PropertyList listProperty = this.propertyMap.getList(listPropertyDefinition.getName());
private static void validateProperty(PropertyDefinition propertyDefinition, AbstractPropertyMap parentPropertyMap, AbstractPropertyMap currentParentPropertyMap, List<String> errorMessages) { if (parentPropertyMap.getMap().keySet().contains(propertyDefinition.getName())) // property is already set PropertySimple propertySimple = parentPropertyMap.getSimple(propertyDefinition.getName()); PropertySimple currentPropertySimple = (null == currentParentPropertyMap) ? null : currentParentPropertyMap.getSimple(propertyDefinition.getName()); validatePropertySimple(propertyDefinition, propertySimple, currentPropertySimple, errorMessages); PropertyMap propertyMap = parentPropertyMap.getMap(propertyDefinition.getName()); PropertyMap currentPropertyMap = (null == currentParentPropertyMap) ? null : currentParentPropertyMap .getMap(propertyDefinition.getName()); PropertyDefinitionMap propertyDefinitionMap = (PropertyDefinitionMap) propertyDefinition; validatePropertyMap(propertyMap, currentPropertyMap, propertyDefinitionMap, errorMessages); PropertyList propertyList = parentPropertyMap.getList(propertyDefinition.getName()); PropertyList currentPropertyList = (null == currentParentPropertyMap) ? null : currentParentPropertyMap .getList(propertyDefinition.getName()); if (propertyDefinition instanceof PropertyDefinitionSimple) { PropertySimple propertySimple = new PropertySimple(propertyDefinition.getName(), ""); parentPropertyMap.put(propertySimple);
private static void add(Object parent, Property prop) { if (parent instanceof AbstractPropertyMap) { ((AbstractPropertyMap) parent).put(prop); } else if (parent instanceof PropertyList) { ((PropertyList) parent).add(prop); } }
private Boolean isOverride(PropertyDefinition propertyDefinition) { if (!(propertyDefinition instanceof PropertyDefinitionSimple)) { return false; } Property property = this.propertyMap.get(propertyDefinition.getName()); if (property == null) { return false; } Boolean override = ((PropertySimple) property).getOverride(); return ((override != null) && override); }
private boolean isInvalidRequiredProperty(PropertyDefinition propertyDefinition) { boolean isInvalidRequiredProperty = false; if ((propertyDefinition instanceof PropertyDefinitionSimple) && propertyDefinition.isRequired()) { PropertySimple propertySimple = this.propertyMap.getSimple(propertyDefinition.getName()); String errorMessage = propertySimple.getErrorMessage(); if ((null == propertySimple.getStringValue()) || "".equals(propertySimple.getStringValue()) || ((null != errorMessage) && (!"".equals(errorMessage.trim())))) { // Required properties with no value, or an invalid value (assumed if we see an error message) should never // be set to read-only, otherwise the user will have no way to give the property a value and thereby // get things to a valid state. isInvalidRequiredProperty = true; } } return isInvalidRequiredProperty; }
private boolean hasErrors(AbstractPropertyMap configuration) { if (configuration instanceof PropertyMap) { if (((PropertyMap) configuration).getErrorMessage() != null) { return true; } } for (Map.Entry<String, Property> entry : configuration.getMap().entrySet()) { if (hasErrors(entry.getValue())) { return true; } } return false; }
private static void normalizeProperty(PropertyDefinition propertyDefinition, AbstractPropertyMap parentPropertyMap, boolean normalizeRequiredDefaults, boolean normalizeOptionalDefaults) { if (parentPropertyMap.getMap().keySet().contains(propertyDefinition.getName())) // property is already set PropertySimple propertySimple = parentPropertyMap.getSimple(propertyDefinition.getName()); String value = propertySimple.getStringValue(); if (value != null) { PropertyMap propertyMap = parentPropertyMap.getMap(propertyDefinition.getName()); PropertyDefinitionMap propertyDefinitionMap = (PropertyDefinitionMap) propertyDefinition; normalizePropertyMap(propertyMap, propertyDefinitionMap, false, PropertyList propertyList = parentPropertyMap.getList(propertyDefinition.getName()); for (Property property : propertyList.getList()) { PropertyMap propertyMap = (PropertyMap) property; parentPropertyMap.put(property);