protected void parseFields(ObjectType type, DslElementSyntax typeDsl, Map<String, ParameterRole> parametersRole) { type.getFields().forEach(f -> parseField(type, typeDsl, f, parametersRole)); }
protected void parseFields(ObjectType type, DslElementSyntax typeDsl) { type.getFields().forEach(f -> parseField(type, typeDsl, f, emptyMap())); }
private void populateObjectElementFields(ObjectType objectType, ParameterObjectValue objectValue, DslElementSyntax objectDsl, InternalComponentConfiguration.Builder objectConfig, DslElementModel.Builder objectElement) { List<ObjectFieldType> fields = objectType.getFields() .stream() .flatMap(f -> isFlattenedParameterGroup(f) ? ((ObjectType) f.getValue()).getFields().stream() : of(f)) .collect(toList()); fields.forEach(field -> objectValue.getParameters().entrySet().stream() .filter(e -> getAlias(field).equals(e.getKey())) .findFirst() .ifPresent(e -> objectDsl.getContainedElement(e.getKey()) .ifPresent(nestedDsl -> addObjectField(field.getValue(), e.getValue(), nestedDsl, objectConfig, objectElement)))); }
private MetadataType getMetadataTypeFromFlattenedFields(ObjectType objectMetadataType, String modelParamName) { MetadataType childMetadataType = null; List<MetadataType> flattenedFieldTypes = objectMetadataType.getFields().stream().filter(field -> field.getAnnotation(FlattenedTypeAnnotation.class).isPresent()) .map(ObjectFieldType::getValue).collect(Collectors.toList()); for (MetadataType flattenedFieldType : flattenedFieldTypes) { for (ObjectFieldType field : ((ObjectType) flattenedFieldType).getFields()) { if (field.getKey().getName().getLocalPart().equals(modelParamName)) { childMetadataType = field.getValue(); break; } } if (childMetadataType != null) { break; } } return childMetadataType; }
@Override public void visitObject(ObjectType objectType) { if (!registeredTypes.contains(objectType)) { registeredTypes.add(objectType); objectType.getAnnotation(StereotypeTypeAnnotation.class).ifPresent(a -> a.resolveStereotypes(resolver)); objectType.getFields().forEach(f -> f.getValue().accept(this)); } }
@Override public void visitObject(ObjectType objectType) { if (objectType.getMetadataFormat() != JAVA) { return; } final Class<Object> clazz = getType(objectType).orElse(null); if (clazz == null || relativeClasses.contains(clazz)) { return; } Optional<ClassInformationAnnotation> classInformation = objectType.getAnnotation(ClassInformationAnnotation.class); if (classInformation.isPresent()) { classInformation.get().getGenericTypes() .forEach(generic -> relativeClasses.add(loadClass(generic, extensionClassLoader))); } relativeClasses.add(clazz); objectType.getFields().stream().forEach(objectFieldType -> objectFieldType.accept(this)); objectType.getOpenRestriction().ifPresent(t -> t.accept(this)); }
@Override public void visitObject(ObjectType objectType) { if (objectType.getMetadataFormat() != JAVA) { return; } final String clazz = getId(objectType).orElse(null); if (clazz == null || relativeClasses.contains(clazz)) { return; } Optional<ClassInformationAnnotation> classInformation = objectType.getAnnotation(ClassInformationAnnotation.class); classInformation .ifPresent(classInformationAnnotation -> relativeClasses .addAll(classInformationAnnotation.getGenericTypes())); relativeClasses.add(clazz); objectType.getFields().forEach(objectFieldType -> objectFieldType.accept(this)); objectType.getOpenRestriction().ifPresent(t -> t.accept(this)); }
private List<XmlExtensionElementDocumentation> getTypesDocumentation(ExtensionModel extensionModel) { List<XmlExtensionElementDocumentation> types = new ArrayList<>(); extensionModel.getTypes().forEach(type -> ExtensionMetadataTypeUtils.getId(type) .ifPresent(id -> { XmlExtensionElementDocumentation element = new XmlExtensionElementDocumentation(); element.setName(id); element.setDescription(type.getAnnotation(DescriptionAnnotation.class) .map(DescriptionAnnotation::getValue).orElse("")); element.setParameters(type.getFields().stream() .map(f -> new XmlExtensionParameterDocumentation(getAlias(f), f.getAnnotation(DescriptionAnnotation.class) .map(DescriptionAnnotation::getValue).orElse(""))) .collect(toList())); types.add(element); })); return types; }
private void declareGroupedFields(ExtensionType extension, List<TopLevelElement> childElements, ObjectFieldType field) { DslElementSyntax groupDsl = dsl.resolve(field.getValue()).get(); ((ObjectType) field.getValue()).getFields().forEach( subField -> { DslElementSyntax subFieldDsl = groupDsl .getContainedElement(subField.getKey().getName().getLocalPart()) .orElse(null); declareObjectField(subFieldDsl, subField, extension, childElements); }); }
@Override public void visitObject(ObjectType objectType) { ObjectTypeBuilder objectTypeBuilder = builder.objectType(); objectType.getFields() .stream() .filter(p -> fields.stream().anyMatch(f -> f.getName().equalsIgnoreCase(p.getKey().getName().getLocalPart()))) .forEach(p -> { ObjectFieldTypeBuilder field = objectTypeBuilder.addField(); field.key(p.getKey().getName()); field.value(p.getValue()); }); } });
@Override public void visitObject(ObjectType objectType) { type = new DefaultObjectType(objectType.getFields(), objectType.isOrdered(), objectType.getOpenRestriction().orElse(null), objectType.getMetadataFormat(), getAllTypeAnnotationsMap()); }
private void assertJsonPerson(Typed typed) { MetadataType type = typed.getType(); assertThat(typed.hasDynamicType(), is(false)); assertThat(type.getMetadataFormat(), is(JSON)); assertThat(type, instanceOf(ObjectType.class)); assertThat(((ObjectType) type).getFields(), hasSize(3)); }
@Test public void getTrimmedOutputMetadata() throws MetadataResolvingException, ConnectionException { DsqlQuery dsqlQuery = dsqlParser.parse("dsql:SELECT id FROM Circle WHERE (diameter < 18)"); MetadataType outputMetadata = getQueryMetadataResolver().getOutputType(context, dsqlQuery); ObjectType type = getAndAssertTypeOf(outputMetadata); assertThat(type.getFields(), hasSize(1)); ObjectFieldType onlyField = type.getFields().iterator().next(); assertThat(onlyField.getValue(), is(instanceOf(NumberType.class))); assertThat(onlyField.getKey().getName().getLocalPart(), is("id")); }
private void createObjectValueFromType(ObjectType objectType, ParameterObjectValue.Builder objectValue, ConfigLine config, DslElementSyntax paramDsl) { getId(objectType).ifPresent(objectValue::ofType); objectType.getFieldByName(CONFIG_ATTRIBUTE_NAME) .map(f -> config.getConfigAttributes().get(CONFIG_ATTRIBUTE_NAME)) .ifPresent(configRef -> objectValue.withParameter(CONFIG_ATTRIBUTE_NAME, ParameterSimpleValue.of(configRef.getValue(), STRING))); copyExplicitAttributes(config.getConfigAttributes(), objectValue, objectType); config.getChildren().forEach(fieldConfig -> objectType.getFields().stream() .filter(fieldType -> paramDsl.getContainedElement(getLocalPart(fieldType)) .map(fieldDsl -> fieldDsl.getElementName().equals(fieldConfig.getIdentifier())).orElse(false)) .findFirst() .ifPresent(fieldType -> fieldType.getValue().accept( getParameterDeclarerVisitor(fieldConfig, paramDsl .getContainedElement(getLocalPart(fieldType)) .get(), fieldValue -> objectValue .withParameter(getLocalPart(fieldType), fieldValue))))); }
@Test public void getFullOutputMetadata() throws MetadataResolvingException, ConnectionException { DsqlQuery dsqlQuery = dsqlParser.parse("dsql:SELECT * FROM Circle WHERE (diameter < 18)"); MetadataType outputMetadata = getQueryMetadataResolver().getOutputType(context, dsqlQuery); ObjectType type = getAndAssertTypeOf(outputMetadata); assertThat(type.getFields(), hasSize(3)); type.getFields().forEach(f -> { String name = f.getKey().getName().getLocalPart(); assertThat(name, isIn(asList("color", "id", "diameter"))); }); }
private void populateObjectFields(ObjectType type, ComponentConfiguration configuration, DslElementSyntax typeDsl, DslElementModel.Builder typeBuilder, Deque<String> typeResolvingStack) { type.getFields().forEach(field -> { if (field.getValue() instanceof ObjectType && field.getAnnotation(FlattenedTypeAnnotation.class).isPresent()) { ((ObjectType) field.getValue()).getFields().forEach(nested -> { final String name = getLocalPart(nested); typeDsl.getContainedElement(name) .ifPresent(fieldDsl -> nested.getValue() .accept(getComponentChildVisitor(typeBuilder, configuration, nested, name, fieldDsl, getDefaultValue(name, field.getValue()), typeResolvingStack))); }); } else { final String name = getLocalPart(field); typeDsl.getContainedElement(name) .ifPresent(fieldDsl -> field.getValue() .accept(getComponentChildVisitor(typeBuilder, configuration, field, name, fieldDsl, getDefaultValue(name, type), typeResolvingStack))); } }); }
/** * {@inheritDoc} */ @Override public void resolveParameterGroups(ObjectType objectType, DefaultObjectBuilder builder) { Class<?> objectClass = getType(objectType); objectType.getFields().stream() .filter(ExtensionMetadataTypeUtils::isFlattenedParameterGroup) .forEach(groupField -> { if (!(groupField.getValue() instanceof ObjectType)) { return; } final ObjectType groupType = (ObjectType) groupField.getValue(); final Field objectField = getField(objectClass, getLocalPart(groupField)); DefaultObjectBuilder groupBuilder = getParameterGroupObjectBuilder(groupField); builder.addPropertyResolver(objectField, new ObjectBuilderValueResolver<>(groupBuilder, muleContext)); resolveParameters(groupType, groupBuilder); resolveParameterGroups(groupType, groupBuilder); }); }
@Test public void metadataKeyDefaultValue() throws Exception { location = Location.builder().globalName(METADATA_KEY_DEFAULT_VALUE).addProcessorsPart().addIndexPart(0).build(); MetadataResult<ComponentMetadataDescriptor<OperationModel>> result = metadataService.getOperationMetadata(location); assertSuccessResult(result); MetadataType type = result.get().getModel().getOutput().getType(); assertThat(type, is(instanceOf(ObjectType.class))); ObjectType objectType = (ObjectType) type; assertThat(objectType.getFields(), hasSize(2)); objectType.getFields().forEach(f -> assertThat(f.getKey().getName().getLocalPart(), isOneOf(TIRES, BRAND))); Optional<MetadataKey> metadataKeyOptional = result.get().getMetadataAttributes().getKey(); assertThat(metadataKeyOptional.isPresent(), is(true)); assertThat(metadataKeyOptional.get().getId(), is(CAR)); }
@Test public void defaultValueMetadataKey() throws Exception { location = Location.builder().globalName(METADATA_KEY_DEFAULT_VALUE).addProcessorsPart().addIndexPart(0).build(); final MetadataResult<ComponentMetadataDescriptor<OperationModel>> result = metadataService.getOperationMetadata(location); assertSuccessResult(result); assertResolvedKey(result, CAR_KEY); ComponentMetadataDescriptor<OperationModel> descriptor = result.get(); MetadataType type = descriptor.getModel().getOutput().getType(); assertThat(type, is(instanceOf(ObjectType.class))); assertThat(((ObjectType) type).getFields(), hasSize(2)); }