private static boolean isLicense(String key, @Nullable PropertyDefinition definition) { return key.endsWith(LICENSE_SUFFIX) || key.endsWith(LICENSE_HASH_SUFFIX) || (definition != null && definition.type() == LICENSE); }
private static void validatePropertySet(SetRequest request, @Nullable PropertyDefinition definition) { checkRequest(definition != null, "Setting '%s' is undefined", request.getKey()); checkRequest(PropertyType.PROPERTY_SET.equals(definition.type()), "Parameter '%s' is used for setting of property set type only", PARAM_FIELD_VALUES); Set<String> fieldKeys = definition.fields().stream().map(PropertyFieldDefinition::key).collect(Collectors.toSet()); ListMultimap<String, String> valuesByFieldKeys = ArrayListMultimap.create(fieldKeys.size(), request.getFieldValues().size() * fieldKeys.size()); request.getFieldValues().stream() .map(oneFieldValues -> readOneFieldValues(oneFieldValues, request.getKey())) .peek(map -> checkRequest(map.values().stream().anyMatch(StringUtils::isNotBlank), MSG_NO_EMPTY_VALUE)) .flatMap(map -> map.entrySet().stream()) .peek(entry -> valuesByFieldKeys.put(entry.getKey(), entry.getValue())) .forEach(entry -> checkRequest(fieldKeys.contains(entry.getKey()), "Unknown field key '%s' for setting '%s'", entry.getKey(), request.getKey())); checkFieldType(request, definition, valuesByFieldKeys); }
@Override public void accept(SettingData data) { PropertyDefinition definition = definitions.get(data.key); if (definition == null) { return; } if (definition.type() == PropertyType.METRIC) { validateMetric(data); } else if (definition.type() == PropertyType.USER_LOGIN) { validateLogin(data); } else { validateOtherTypes(data, definition); } }
private Set<String> getPropertySetKeys(List<PropertyDto> properties) { return properties.stream() .filter(propertyDto -> propertyDefinitions.get(propertyDto.getKey()) != null) .filter(propertyDto -> propertyDefinitions.get(propertyDto.getKey()).type().equals(PROPERTY_SET)) .flatMap(propertyDto -> extractPropertySetKeys(propertyDto, propertyDefinitions.get(propertyDto.getKey())).stream()) .collect(Collectors.toSet()); }
private void addDefinition(PropertyDefinition definition, ListDefinitionsWsResponse.Builder wsResponse) { String key = definition.key(); Settings.Definition.Builder builder = wsResponse.addDefinitionsBuilder() .setKey(key) .setType(Settings.Type.valueOf(definition.type().name())) .setMultiValues(definition.multiValues()); ofNullable(emptyToNull(definition.deprecatedKey())).ifPresent(builder::setDeprecatedKey); ofNullable(emptyToNull(definition.name())).ifPresent(builder::setName); ofNullable(emptyToNull(definition.description())).ifPresent(builder::setDescription); String category = propertyDefinitions.getCategory(key); ofNullable(emptyToNull(category)).ifPresent(builder::setCategory); String subCategory = propertyDefinitions.getSubCategory(key); ofNullable(emptyToNull(subCategory)).ifPresent(builder::setSubCategory); ofNullable(emptyToNull(definition.defaultValue())).ifPresent(builder::setDefaultValue); List<String> options = definition.options(); if (!options.isEmpty()) { builder.addAllOptions(options); } List<PropertyFieldDefinition> fields = definition.fields(); if (!fields.isEmpty()) { fields.forEach(fieldDefinition -> addField(fieldDefinition, builder)); } }
private void delete(DbSession dbSession, String settingKey, Optional<ComponentDto> componentDto) { PropertyDefinition definition = definitions.get(settingKey); if (definition == null || !definition.type().equals(PropertyType.PROPERTY_SET)) { deleteSetting(dbSession, settingKey, componentDto); } else { deletePropertySet(dbSession, settingKey, definition, componentDto); } }
private static String obfuscateValue(PropertyDefinitions definitions, String key, String value) { PropertyDefinition def = definitions.get(key); if (def != null && def.type() == PropertyType.PASSWORD) { return PASSWORD_VALUE; } if (endsWithIgnoreCase(key, ".secured") || containsIgnoreCase(key, "password") || containsIgnoreCase(key, "passcode") || AUTH_JWT_SECRET.getKey().equals(key)) { return PASSWORD_VALUE; } return abbreviate(value, MAX_VALUE_LENGTH); } }
@Test public void should_auto_detect_password_type() { PropertyDefinition def = PropertyDefinition.builder("scm.password.secured").name("SCM password").build(); assertThat(def.key()).isEqualTo("scm.password.secured"); assertThat(def.type()).isEqualTo(PropertyType.PASSWORD); }
@Test public void PropertyDef() { PropertyDefinition def = PropertyDefinition.builder("views.license.secured").name("Views license").build(); assertThat(def.key()).isEqualTo("views.license.secured"); assertThat(def.type()).isEqualTo(PropertyType.LICENSE); }
@Test public void should_create_from_annotation() { Properties props = AnnotationUtils.getAnnotation(Init.class, Properties.class); Property prop = props.value()[0]; PropertyDefinition def = PropertyDefinition.create(prop); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEqualTo("world"); assertThat(def.category()).isEqualTo("categ"); assertThat(def.options()).containsOnly("de", "en"); assertThat(def.description()).isEqualTo("desc"); assertThat(def.type()).isEqualTo(PropertyType.FLOAT); assertThat(def.global()).isFalse(); assertThat(def.qualifiers()).containsOnly(Qualifiers.PROJECT, Qualifiers.MODULE); assertThat(def.multiValues()).isTrue(); assertThat(def.propertySetKey()).isEqualTo("set"); assertThat(def.fields()).isEmpty(); }
@Test public void should_support_property_sets_from_annotation() { Properties props = AnnotationUtils.getAnnotation(WithPropertySet.class, Properties.class); Property prop = props.value()[0]; PropertyDefinition def = PropertyDefinition.create(prop); assertThat(def.type()).isEqualTo(PropertyType.PROPERTY_SET); assertThat(def.fields()).hasSize(2); assertThat(def.fields().get(0).key()).isEqualTo("first"); assertThat(def.fields().get(0).name()).isEqualTo("First"); assertThat(def.fields().get(0).description()).isEqualTo("Description"); assertThat(def.fields().get(0).type()).isEqualTo(PropertyType.STRING); assertThat(def.fields().get(0).options()).containsOnly("A", "B"); assertThat(def.fields().get(0).indicativeSize()).isEqualTo(20); assertThat(def.fields().get(1).key()).isEqualTo("second"); assertThat(def.fields().get(1).name()).isEqualTo("Second"); assertThat(def.fields().get(1).type()).isEqualTo(PropertyType.INTEGER); assertThat(def.fields().get(1).options()).isEmpty(); assertThat(def.fields().get(1).indicativeSize()).isEqualTo(5); }
@Test public void should_create_property_with_default_values() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .build(); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEmpty(); assertThat(def.category()).isEmpty(); assertThat(def.options()).isEmpty(); assertThat(def.description()).isEmpty(); assertThat(def.type()).isEqualTo(PropertyType.STRING); assertThat(def.global()).isTrue(); assertThat(def.qualifiers()).isEmpty(); assertThat(def.multiValues()).isFalse(); assertThat(def.propertySetKey()).isEmpty(); assertThat(def.fields()).isEmpty(); }
@Test public void should_create_from_annotation_default_values() { Properties props = AnnotationUtils.getAnnotation(DefaultValues.class, Properties.class); Property prop = props.value()[0]; PropertyDefinition def = PropertyDefinition.create(prop); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEmpty(); assertThat(def.category()).isEmpty(); assertThat(def.options()).isEmpty(); assertThat(def.description()).isEmpty(); assertThat(def.type()).isEqualTo(PropertyType.STRING); assertThat(def.global()).isTrue(); assertThat(def.qualifiers()).isEmpty(); assertThat(def.multiValues()).isFalse(); assertThat(def.propertySetKey()).isEmpty(); assertThat(def.fields()).isEmpty(); }
private void setValue(PropertyDto propertyDto, Property property) { String value = propertyDto.getValue(); property.setValue(value); PropertyDefinition definition = propertyDefinitions.get(propertyDto.getKey()); if (definition != null && (definition.multiValues() || definition.type().equals(PROPERTY_SET))) { property.setValues(createValues(value)); } }
@Test public void should_support_property_sets() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .fields( PropertyFieldDefinition.build("first").name("First").description("Description").options("A", "B").build(), PropertyFieldDefinition.build("second").name("Second").type(PropertyType.INTEGER).indicativeSize(5).build()) .build(); assertThat(def.type()).isEqualTo(PropertyType.PROPERTY_SET); assertThat(def.fields()).hasSize(2); assertThat(def.fields().get(0).key()).isEqualTo("first"); assertThat(def.fields().get(0).name()).isEqualTo("First"); assertThat(def.fields().get(0).description()).isEqualTo("Description"); assertThat(def.fields().get(0).type()).isEqualTo(PropertyType.STRING); assertThat(def.fields().get(0).options()).containsOnly("A", "B"); assertThat(def.fields().get(0).indicativeSize()).isEqualTo(20); assertThat(def.fields().get(1).key()).isEqualTo("second"); assertThat(def.fields().get(1).name()).isEqualTo("Second"); assertThat(def.fields().get(1).type()).isEqualTo(PropertyType.INTEGER); assertThat(def.fields().get(1).options()).isEmpty(); assertThat(def.fields().get(1).indicativeSize()).isEqualTo(5); }
@Test public void should_create_property() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .defaultValue("world") .category("categ") .options("de", "en") .description("desc") .type(PropertyType.FLOAT) .onlyOnQualifiers(Qualifiers.MODULE) .multiValues(true) .propertySetKey("set") .build(); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEqualTo("world"); assertThat(def.category()).isEqualTo("categ"); assertThat(def.options()).containsOnly("de", "en"); assertThat(def.description()).isEqualTo("desc"); assertThat(def.type()).isEqualTo(PropertyType.FLOAT); assertThat(def.global()).isFalse(); assertThat(def.qualifiers()).containsOnly(Qualifiers.MODULE); assertThat(def.multiValues()).isTrue(); assertThat(def.propertySetKey()).isEqualTo("set"); assertThat(def.fields()).isEmpty(); }
private void setParent(Setting setting, Settings.Setting.Builder valueBuilder) { Setting parent = settingsByParentKey.get(setting.getKey()); if (parent != null) { String value = valueBuilder.getInherited() ? setting.getValue() : parent.getValue(); PropertyDefinition definition = setting.getDefinition(); if (definition == null) { valueBuilder.setParentValue(value); return; } if (definition.type().equals(PROPERTY_SET)) { valueBuilder.setParentFieldValues( createFieldValuesBuilder(valueBuilder.getInherited() ? filterVisiblePropertySets(setting.getPropertySets()) : filterVisiblePropertySets(parent.getPropertySets()))); } else if (definition.multiValues()) { valueBuilder.setParentValues(createValuesBuilder(value)); } else { valueBuilder.setParentValue(value); } } settingsByParentKey.put(setting.getKey(), setting); }
private void setValue(Setting setting, Settings.Setting.Builder valueBuilder) { PropertyDefinition definition = setting.getDefinition(); String value = setting.getValue(); if (definition == null) { valueBuilder.setValue(value); return; } if (definition.type().equals(PROPERTY_SET)) { valueBuilder.setFieldValues(createFieldValuesBuilder(filterVisiblePropertySets(setting.getPropertySets()))); } else if (definition.multiValues()) { valueBuilder.setValues(createValuesBuilder(value)); } else { valueBuilder.setValue(value); } }
private Set<String> getPropertySetKeys(List<PropertyDto> properties) { return properties.stream() .filter(propertyDto -> definitions.get(propertyDto.getKey()) != null) .filter(propertyDto -> definitions.get(propertyDto.getKey()).type().equals(PROPERTY_SET)) .flatMap(propertyDto -> extractPropertySetKeys(propertyDto, definitions.get(propertyDto.getKey())).stream()) .collect(Collectors.toSet()); }
private void setValue(PropertyDto propertyDto, Property property) { String value = propertyDto.getValue(); property.setValue(value); PropertyDefinition definition = propertyDefinitions.get(propertyDto.getKey()); if (definition != null && (definition.multiValues() || definition.type().equals(PROPERTY_SET))) { property.setValues(createValues(value)); } }