use of org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclarer in project mule by mulesoft.
the class ParameterModelsLoaderDelegate method declare.
public List<ParameterDeclarer> declare(HasParametersDeclarer component, List<? extends ExtensionParameter> parameters, ParameterDeclarationContext declarationContext, ParameterGroupDeclarer parameterGroupDeclarer) {
List<ParameterDeclarer> declarerList = new ArrayList<>();
checkAnnotationsNotUsedMoreThanOnce(parameters, Connection.class, Config.class, MetadataKeyId.class);
boolean supportsNestedElements = component instanceof HasNestedComponentsDeclarer;
for (ExtensionParameter extensionParameter : parameters) {
// Both nested components and parameters are declared using the @Parameter annotation in order to simplify the API
if (supportsNestedElements && declaredAsNestedComponent((HasNestedComponentsDeclarer) component, extensionParameter)) {
continue;
}
if (!extensionParameter.shouldBeAdvertised()) {
continue;
}
if (isParameterGroup(extensionParameter)) {
List<ParameterDeclarer> groupParams = declaredAsGroup(component, declarationContext, extensionParameter);
declarerList.addAll(groupParams);
continue;
}
ParameterGroupDeclarer groupDeclarer = parameterGroupDeclarer != null ? parameterGroupDeclarer : component.onDefaultParameterGroup();
ParameterDeclarer parameter;
if (extensionParameter.isRequired()) {
parameter = groupDeclarer.withRequiredParameter(extensionParameter.getAlias());
} else {
parameter = groupDeclarer.withOptionalParameter(extensionParameter.getAlias()).defaultingTo(extensionParameter.defaultValue().isPresent() ? extensionParameter.defaultValue().get() : null);
}
parameter.ofType(extensionParameter.getType().asMetadataType()).describedAs(extensionParameter.getDescription());
parseParameterRole(extensionParameter, parameter);
parseExpressionSupport(extensionParameter, parameter);
parseConfigOverride(extensionParameter, parameter);
parseNullSafe(extensionParameter, parameter);
parseLayout(extensionParameter, parameter);
parseExclusiveOptional(extensionParameter, groupDeclarer, parameter);
parameter.withModelProperty(new ExtensionParameterDescriptorModelProperty(extensionParameter));
extensionParameter.getDeclaringElement().ifPresent(element -> addImplementingTypeModelProperty(element, parameter));
parseParameterDsl(extensionParameter, parameter);
contributors.forEach(contributor -> contributor.contribute(extensionParameter, parameter, declarationContext));
declarerList.add(parameter);
}
return declarerList;
}
use of org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclarer in project mule by mulesoft.
the class SourceModelLoaderDelegate method declareSourceParameters.
/**
* Declares the parameters needed to generate messages
*/
private void declareSourceParameters(SourceElement sourceType, SourceDeclarer source) {
ParameterModelsLoaderDelegate parametersLoader = loader.getFieldParametersLoader();
ParameterDeclarationContext declarationContext = new ParameterDeclarationContext(SOURCE, source.getDeclaration());
List<ParameterDeclarer> parameters = parametersLoader.declare(source, sourceType.getParameters(), declarationContext);
parameters.forEach(p -> p.withExpressionSupport(NOT_SUPPORTED));
}
use of org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclarer in project mule by mulesoft.
the class XmlExtensionLoaderDelegate method extractParameter.
private void extractParameter(ParameterizedDeclarer parameterizedDeclarer, ComponentModel param, ParameterRole role) {
Map<String, String> parameters = param.getParameters();
String receivedInputType = parameters.get(TYPE_ATTRIBUTE);
final LayoutModel.LayoutModelBuilder layoutModelBuilder = builder();
if (parseBoolean(parameters.get(PASSWORD))) {
layoutModelBuilder.asPassword();
}
layoutModelBuilder.order(getOrder(parameters.get(ORDER_ATTRIBUTE)));
layoutModelBuilder.tabName(getTab(parameters.get(TAB_ATTRIBUTE)));
final DisplayModel displayModel = getDisplayModel(param);
MetadataType parameterType = extractType(receivedInputType);
ParameterDeclarer parameterDeclarer = getParameterDeclarer(parameterizedDeclarer, parameters);
parameterDeclarer.describedAs(getDescription(param)).withLayout(layoutModelBuilder.build()).withDisplayModel(displayModel).withRole(role).ofType(parameterType);
}
use of org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclarer in project mule by mulesoft.
the class ParameterModelsLoaderDelegate method declaredAsGroup.
private List<ParameterDeclarer> declaredAsGroup(HasParametersDeclarer component, ParameterDeclarationContext declarationContext, ExtensionParameter groupParameter) throws IllegalParameterModelDefinitionException {
ParameterGroup groupAnnotation = groupParameter.getAnnotation(ParameterGroup.class).orElse(null);
if (groupAnnotation == null) {
return emptyList();
}
final String groupName = groupAnnotation.name();
if (DEFAULT_GROUP_NAME.equals(groupName)) {
throw new IllegalParameterModelDefinitionException(format("%s '%s' defines parameter group of name '%s' which is the default one. " + "@%s cannot be used with the default group name", getComponentDeclarationTypeName(((Declarer) component).getDeclaration()), ((NamedDeclaration) ((Declarer) component).getDeclaration()).getName(), groupName, ParameterGroup.class.getSimpleName()));
}
final Type type = groupParameter.getType();
final List<FieldElement> nestedGroups = type.getAnnotatedFields(ParameterGroup.class);
if (!nestedGroups.isEmpty()) {
throw new IllegalParameterModelDefinitionException(format("Class '%s' is used as a @%s but contains fields which also hold that annotation. Nesting groups is not allowed. " + "Offending fields are: [%s]", type.getName(), ParameterGroup.class.getSimpleName(), nestedGroups.stream().map(element -> element.getName()).collect(joining(","))));
}
if (groupParameter.isAnnotatedWith(org.mule.runtime.extension.api.annotation.param.Optional.class)) {
throw new IllegalParameterModelDefinitionException(format("@%s can not be applied alongside with @%s. Affected parameter is [%s].", org.mule.runtime.extension.api.annotation.param.Optional.class.getSimpleName(), ParameterGroup.class.getSimpleName(), groupParameter.getName()));
}
ParameterGroupDeclarer declarer = component.onParameterGroup(groupName);
if (declarer.getDeclaration().getModelProperty(ParameterGroupModelProperty.class).isPresent()) {
throw new IllegalParameterModelDefinitionException(format("Parameter group '%s' has already been declared on %s '%s'", groupName, getComponentDeclarationTypeName(((Declarer) component).getDeclaration()), ((NamedDeclaration) ((Declarer) component).getDeclaration()).getName()));
} else {
declarer.withModelProperty(new ParameterGroupModelProperty(new ParameterGroupDescriptor(groupName, type, groupParameter.getType().asMetadataType(), // TODO: Eliminate dependency to Annotated Elements
groupParameter.getDeclaringElement().orElse(null), groupParameter)));
}
final List<FieldElement> annotatedParameters = type.getAnnotatedFields(Parameter.class);
type.getAnnotation(ExclusiveOptionals.class).ifPresent(annotation -> {
Set<String> optionalParamNames = annotatedParameters.stream().filter(f -> !f.isRequired()).map(WithAlias::getAlias).collect(toSet());
declarer.withExclusiveOptionals(optionalParamNames, annotation.isOneRequired());
});
declarer.withDslInlineRepresentation(groupAnnotation.showInDsl());
groupParameter.getAnnotation(DisplayName.class).ifPresent(displayName -> declarer.withDisplayModel(DisplayModel.builder().displayName(displayName.value()).build()));
parseLayoutAnnotations(groupParameter, LayoutModel.builder()).ifPresent(declarer::withLayout);
declarer.withModelProperty(new ExtensionParameterDescriptorModelProperty(groupParameter));
if (!annotatedParameters.isEmpty()) {
return declare(component, annotatedParameters, declarationContext, declarer);
} else {
return declare(component, getFieldsWithGetters(type), declarationContext, declarer);
}
}
Aggregations