@Test public void verifyTargetValueParameterOnOperation() { OperationDeclaration operationDeclaration = getNamedObject(declaration.getOperations(), "transform"); ParameterDeclaration parameterDeclaration = getNamedObject(operationDeclaration.getAllParameters(), "targetValue"); assertThat(parameterDeclaration.getName(), is("targetValue")); assertThat(parameterDeclaration.getExpressionSupport(), is(REQUIRED)); assertThat(parameterDeclaration.getType(), instanceOf(StringType.class)); assertThat(parameterDeclaration.isRequired(), is(false)); }
private void addQueryModelProperties(OperationDeclaration declaration, Query query) { ParameterDeclaration parameterDeclaration = declaration.getAllParameters() .stream() .filter(p -> p.getModelProperty(ImplementingParameterModelProperty.class).isPresent()) .filter(p -> p.getModelProperty(ImplementingParameterModelProperty.class).get() .getParameter().isAnnotationPresent(MetadataKeyId.class)) .findFirst() .orElseThrow(() -> new IllegalParameterModelDefinitionException( "Query operation must have a parameter annotated with @MetadataKeyId")); parameterDeclaration.addModelProperty(new QueryParameterModelProperty(query.translator())); parameterDeclaration.setLayoutModel(builderFrom(parameterDeclaration.getLayoutModel()).asQuery().build()); }
boolean isContent = !declaration.getRole().equals(ParameterRole.BEHAVIOUR); ParameterDslConfiguration dslConfiguration = declaration.getDslConfiguration(); declaration.getType().accept(new MetadataTypeVisitor() { declaration.setDslConfiguration(builder.build());
/** * Resolves the original name of a parameter before it was modified due to the usage of an Alias. * * @param parameterDeclaration parameter from which look for their original name * @return the original name */ public static String getImplementingName(ParameterDeclaration parameterDeclaration) { return getImplementingName(parameterDeclaration.getName(), () -> parameterDeclaration.getModelProperty(ImplementingParameterModelProperty.class), () -> parameterDeclaration.getModelProperty(DeclaringMemberModelProperty.class)); }
private ParameterDeclaration newParameter(String name, String description, boolean shouldAddSinceMuleVersionModelProperty) { ParameterDeclaration parameter = new ParameterDeclaration(name); parameter.setRequired(false); parameter.setExpressionSupport(SUPPORTED); parameter.setType(typeLoader.load(String.class), false); parameter.setDescription(description); parameter.setLayoutModel(LayoutModel.builder().tabName(ADVANCED_TAB_NAME).build()); if (shouldAddSinceMuleVersionModelProperty) { parameter.addModelProperty(SINCE_MULE_VERSION_MODEL_PROPERTY); } return parameter; } }
@Override protected void onParameter(ParameterGroupDeclaration parameterGroup, ParameterDeclaration declaration) { declaration.getModelProperty(ImplementingParameterModelProperty.class) .ifPresent(param -> declaration.setAllowedStereotypeModels(getStereotypes(param.getParameter()))); declaration.getModelProperty(DeclaringMemberModelProperty.class) .ifPresent(field -> declaration.setAllowedStereotypeModels(getStereotypes(field.getDeclaringField()))); } }.walk(extension);
private Map<String, String> getContainerParameterNames(List<ParameterDeclaration> allParameters) { Map<String, String> parameterNames = new HashMap<>(); for (ParameterDeclaration parameterDeclaration : allParameters) { parameterNames.put(getImplementingName(parameterDeclaration), parameterDeclaration.getName()); } return parameterNames; } }
/** * Describes parameters that are defined as Method parameters. */ void document(ParameterizedDeclaration<?> parameterized, Element method, MethodDocumentation documentation) { parameterized.getAllParameters().forEach(p -> { String description = documentation.getParameters().get(p.getName()); if (description != null) { p.setDescription(description); } }); if (method instanceof ExecutableElement) { ((ExecutableElement) method).getParameters().stream() .filter(e -> e.getAnnotation(ParameterGroup.class) != null) .forEach(group -> { TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(group.asType()); document(parameterized, typeElement); }); } }
@Override protected void onSource(SourceDeclaration source) { extractType(source).ifPresent(type -> { if (type.isAssignableTo(PollingSource.class)) { source.setRunsOnPrimaryNodeOnly(true); ParameterDeclaration parameter = new ParameterDeclaration(SCHEDULING_STRATEGY_PARAMETER_NAME); parameter.setDescription(SCHEDULING_STRATEGY_PARAMETER_DESCRIPTION); parameter.setRequired(true); parameter.setType(loader.load(Scheduler.class), false); parameter.setExpressionSupport(NOT_SUPPORTED); parameter.addModelProperty(new InfrastructureParameterModelProperty(10)); parameter.addModelProperty(new QNameModelProperty(new QName(CORE_NAMESPACE, SCHEDULING_STRATEGY_ELEMENT_IDENTIFIER, CORE_PREFIX))); parameter.setDslConfiguration(ParameterDslConfiguration.builder() .allowsInlineDefinition(true) .allowsReferences(false) .allowTopLevelDefinition(false) .build()); thereArePollingSources.set(true); source.getParameterGroup(DEFAULT_GROUP_NAME).addParameter(parameter); } }); } }.walk(extensionDeclarer.getDeclaration());
private Optional<MetadataKeyIdModelProperty> findMetadataKeyIdInParameters( ComponentDeclaration<? extends ComponentDeclaration> component, String categoryName) { return component.getParameterGroups().stream() .flatMap(g -> g.getParameters().stream()) .filter(p -> getExtensionParameter(p).map(element -> element.isAnnotatedWith(MetadataKeyId.class)).orElse(false)) .map(p -> new MetadataKeyIdModelProperty(p.getType(), p.getName(), categoryName)) .findFirst(); }
private void assertParameter(List<ParameterDeclaration> parameters, String name, String description, MetadataType metadataType, boolean required, ExpressionSupport expressionSupport, Object defaultValue) { ParameterDeclaration param = findParameter(parameters, name); assertThat(param, is(notNullValue())); assertThat(param.getName(), equalTo(name)); assertThat(param.getDescription(), equalTo(description)); assertParameterType(metadataType, param); assertThat(param.isRequired(), is(required)); assertThat(param.getExpressionSupport(), is(expressionSupport)); assertThat(param.getDefaultValue(), equalTo(defaultValue)); }
@Override protected void onParameter(ParameterizedDeclaration owner, ParameterGroupDeclaration parameterGroup, ParameterDeclaration declaration) { declaration.getType().accept(new MetadataTypeVisitor() { @Override public void visitBoolean(BooleanType booleanType) { declaration.setRequired(false); if (declaration.getDefaultValue() == null && !declaration.isConfigOverride()) { declaration.setDefaultValue(valueOf(FALSE)); } } }); } }.walk(extensionDeclaration);
/** * Given a component declaration, adds all the stereotypes accepted by the config-ref parameter if it has one. */ private void addConfigRefStereoTypesIfNeeded(ComponentDeclaration<?> declaration) { Collection<ConfigurationDeclaration> configs = componentConfigs.get(declaration); if (configs != null && !configs.isEmpty()) { List<StereotypeModel> stereotypes = configs.stream().map(StereotypedDeclaration::getStereotype).collect(toList()); declaration.getAllParameters().stream() .filter(p -> CONFIG_ATTRIBUTE_NAME.equals(p.getName())) .findAny() .ifPresent(configRef -> configRef.setAllowedStereotypeModels(stereotypes)); } } }
private Optional<ExtensionParameter> getExtensionParameter(ParameterDeclaration parameterDeclaration) { return parameterDeclaration .getModelProperty(ExtensionParameterDescriptorModelProperty.class) .map(ExtensionParameterDescriptorModelProperty::getExtensionParameter); }
private void assertEnrichment(boolean runsOnPrimaryNodeOnly, boolean parameterAdded, boolean defaultParameterValue) { enricher.enrich(extensionLoadingContext); verify(sourceDeclaration).setRunsOnPrimaryNodeOnly(runsOnPrimaryNodeOnly); if (parameterAdded) { ArgumentCaptor<ParameterDeclaration> captor = ArgumentCaptor.forClass(ParameterDeclaration.class); verify(parameterGroup).addParameter(captor.capture()); ParameterDeclaration parameter = captor.getValue(); assertThat(parameter.getName(), equalTo(PRIMARY_NODE_ONLY_PARAMETER_NAME)); assertThat(parameter.getDefaultValue(), is(defaultParameterValue)); } else { verify(parameterGroup, never()).addParameter(any()); } }
@Override protected void onParameter(ParameterGroupDeclaration parameterGroup, ParameterDeclaration parameter) { if (isObjectStore(parameter.getType())) { List<StereotypeModel> stereotypes = parameter.getAllowedStereotypeModels(); if (!stereotypes.contains(OBJECT_STORE)) { stereotypes.add(OBJECT_STORE); } hasObjectStoreParams.set(true); } } }.walk(extension);
private void enrichOAuthParameters(ConnectionProviderDeclaration declaration) { declaration.getAllParameters().forEach(p -> p.getModelProperty(DeclaringMemberModelProperty.class) .map(DeclaringMemberModelProperty::getDeclaringField) .ifPresent(field -> { OAuthParameter annotation = field.getAnnotation(OAuthParameter.class); if (annotation != null) { validateExpressionSupport(declaration, p, field); p.setExpressionSupport(NOT_SUPPORTED); p.addModelProperty(new OAuthParameterModelProperty(annotation.requestAlias())); } })); }
private void assertParameterIsMetadataContent(ParameterDeclaration param) { assertThat(param.getRole(), is(CONTENT)); }
private void assertParameterPlacement(ParameterDeclaration param, Integer order) { LayoutModel layout = param.getLayoutModel(); assertThat(layout, is(notNullValue())); assertThat(layout.getOrder(), equalTo(ofNullable(order))); } }
private void addBackPressureParameter(ExtensionDeclaration extensionDeclaration, SourceDeclaration sourceDeclaration, BackPressureStrategyModelProperty property) { ParameterDeclaration parameter = new ParameterDeclaration(BACK_PRESSURE_STRATEGY_PARAMETER_NAME); parameter.setDescription(BACK_PRESSURE_STRATEGY_PARAMETER_DESCRIPTION); parameter.setRequired(false); parameter.setDefaultValue(property.getDefaultMode()); parameter.setExpressionSupport(NOT_SUPPORTED); parameter.setLayoutModel(LayoutModel.builder().tabName(ADVANCED_TAB).build()); MetadataType type = BaseTypeBuilder.create(JAVA).stringType() .id(format("%s-%s-backPressureStrategy", extensionDeclaration.getName(), sourceDeclaration.getName())) .with(new EnumAnnotation<>(property.getSupportedModes().stream().map(BackPressureMode::name).toArray(String[]::new))) .build(); parameter.setType(type, false); sourceDeclaration.getParameterGroup(DEFAULT_GROUP_NAME).addParameter(parameter); }