Examples with ParameterModel org.mule.runtime.api.meta.model.parameter.ParameterModel used on opensource projects

Example 11 with ParameterModel

use of org.mule.runtime.api.meta.model.parameter.ParameterModel in project mule by mulesoft.

the class ExportedPackagesValidatorTestCase method mockParameterModel.

private ParameterModel mockParameterModel(Type type) {
    ParameterModel pm = mock(ParameterModel.class);
    when(pm.getType()).thenReturn(loader.load(type));
    return pm;
}

Example 12 with ParameterModel

use of org.mule.runtime.api.meta.model.parameter.ParameterModel in project mule by mulesoft.

the class DefaultExtensionBuildingDefinitionProvider method registerExtensionParsers.

private void registerExtensionParsers(ExtensionModel extensionModel) {
    XmlDslModel xmlDslModel = extensionModel.getXmlDslModel();
    final ExtensionParsingContext parsingContext = createParsingContext(extensionModel);
    final Builder definitionBuilder = new Builder().withNamespace(xmlDslModel.getPrefix());
    final DslSyntaxResolver dslSyntaxResolver = DslSyntaxResolver.getDefault(extensionModel, DslResolvingContext.getDefault(extensions));
    if (extensionModel.getModelProperty(CustomBuildingDefinitionProviderModelProperty.class).isPresent()) {
        return;
    }
    if (extensionModel.getModelProperty(XmlExtensionModelProperty.class).isPresent()) {
        registerXmlExtensionParsers(definitionBuilder, extensionModel, dslSyntaxResolver);
    } else {
        final ClassLoader extensionClassLoader = getClassLoader(extensionModel);
        withContextClassLoader(extensionClassLoader, () -> {
            ReflectionCache reflectionCache = new ReflectionCache();
            new IdempotentExtensionWalker() {

                @Override
                public void onConfiguration(ConfigurationModel model) {
                    parseWith(new ConfigurationDefinitionParser(definitionBuilder, extensionModel, model, dslSyntaxResolver, parsingContext));
                }

                @Override
                protected void onConstruct(ConstructModel model) {
                    parseWith(new ConstructDefinitionParser(definitionBuilder, extensionModel, model, dslSyntaxResolver, parsingContext));
                }

                @Override
                public void onOperation(OperationModel model) {
                    parseWith(new OperationDefinitionParser(definitionBuilder, extensionModel, model, dslSyntaxResolver, parsingContext));
                }

                @Override
                public void onConnectionProvider(ConnectionProviderModel model) {
                    parseWith(new ConnectionProviderDefinitionParser(definitionBuilder, model, extensionModel, dslSyntaxResolver, parsingContext));
                }

                @Override
                public void onSource(SourceModel model) {
                    parseWith(new SourceDefinitionParser(definitionBuilder, extensionModel, model, dslSyntaxResolver, parsingContext));
                }

                @Override
                protected void onParameter(ParameterGroupModel groupModel, ParameterModel model) {
                    registerTopLevelParameter(model.getType(), definitionBuilder, extensionClassLoader, dslSyntaxResolver, parsingContext, reflectionCache);
                }
            }.walk(extensionModel);
            registerExportedTypesTopLevelParsers(extensionModel, definitionBuilder, extensionClassLoader, dslSyntaxResolver, parsingContext, reflectionCache);
            registerSubTypes(definitionBuilder, extensionClassLoader, dslSyntaxResolver, parsingContext, reflectionCache);
        });
    }
}

Example 13 with ParameterModel

use of org.mule.runtime.api.meta.model.parameter.ParameterModel in project mule by mulesoft.

the class ExtensionDefinitionParser method parseParameters.

/**
 * Parsers the given {@code parameters} and generates matching definitions
 *
 * @param parameters a list of {@link ParameterModel}
 */
protected void parseParameters(List<ParameterModel> parameters) {
    parameters.forEach(parameter -> {
        final DslElementSyntax paramDsl = dslResolver.resolve(parameter);
        final boolean isContent = isContent(parameter);
        parameter.getType().accept(new MetadataTypeVisitor() {

            @Override
            protected void defaultVisit(MetadataType metadataType) {
                if (!parseAsContent(metadataType)) {
                    parseAttributeParameter(parameter);
                }
            }

            @Override
            public void visitString(StringType stringType) {
                if (paramDsl.supportsChildDeclaration()) {
                    parseFromTextExpression(parameter, paramDsl, () -> {
                        Optional<QueryParameterModelProperty> query = parameter.getModelProperty(QueryParameterModelProperty.class);
                        return value -> {
                            ValueResolver<String> resolver = resolverOf(parameter.getName(), stringType, value, parameter.getDefaultValue(), parameter.getExpressionSupport(), parameter.isRequired(), parameter.getModelProperties(), acceptsReferences(parameter));
                            return query.map(p -> (ValueResolver<String>) new NativeQueryParameterValueResolver(resolver, p.getQueryTranslator())).orElse(resolver);
                        };
                    });
                } else {
                    defaultVisit(stringType);
                }
            }

            @Override
            public void visitObject(ObjectType objectType) {
                if (parseAsContent(objectType)) {
                    return;
                }
                if (isMap(objectType)) {
                    parseMapParameters(parameter, objectType, paramDsl);
                    return;
                }
                if (!parsingContext.isRegistered(paramDsl.getElementName(), paramDsl.getPrefix())) {
                    if (!paramDsl.supportsTopLevelDeclaration() && paramDsl.supportsChildDeclaration()) {
                        parsingContext.registerObjectType(paramDsl.getElementName(), paramDsl.getPrefix(), objectType);
                    }
                    parseObjectParameter(parameter, paramDsl);
                } else {
                    parseObject(getKey(parameter), parameter.getName(), objectType, parameter.getDefaultValue(), parameter.getExpressionSupport(), parameter.isRequired(), acceptsReferences(parameter), paramDsl, parameter.getModelProperties());
                }
            }

            @Override
            public void visitArrayType(ArrayType arrayType) {
                if (!parseAsContent(arrayType)) {
                    parseCollectionParameter(parameter, arrayType, paramDsl);
                }
            }

            private boolean parseAsContent(MetadataType type) {
                if (isContent) {
                    parseFromTextExpression(parameter, paramDsl, () -> value -> resolverOf(parameter.getName(), type, value, parameter.getDefaultValue(), parameter.getExpressionSupport(), parameter.isRequired(), parameter.getModelProperties(), acceptsReferences(parameter)));
                    return true;
                }
                return false;
            }
        });
    });
}

Example 14 with ParameterModel

use of org.mule.runtime.api.meta.model.parameter.ParameterModel in project mule by mulesoft.

the class ExtensionDefinitionParser method parseObjectParameter.

/**
 * Registers a definition for a {@link ParameterModel} which represents an {@link ObjectType}
 *
 * @param key               the key that the parsed value should have on the parsed parameter's map
 * @param name              the parameter's name
 * @param type              an {@link ObjectType}
 * @param defaultValue      the parameter's default value
 * @param expressionSupport the parameter's {@link ExpressionSupport}
 * @param required          whether the parameter is required or not
 * @param modelProperties   parameter's {@link ModelProperty}s
 */
protected void parseObjectParameter(String key, String name, ObjectType type, Object defaultValue, ExpressionSupport expressionSupport, boolean required, boolean acceptsReferences, DslElementSyntax elementDsl, Set<ModelProperty> modelProperties) {
    parseObject(key, name, type, defaultValue, expressionSupport, required, acceptsReferences, elementDsl, modelProperties);
    final String elementNamespace = elementDsl.getPrefix();
    final String elementName = elementDsl.getElementName();
    if (elementDsl.supportsChildDeclaration() && !elementDsl.isWrapped() && modelProperties.stream().noneMatch(m -> m.getName().equals(InfrastructureParameterModelProperty.NAME))) {
        try {
            new ObjectTypeParameterParser(baseDefinitionBuilder, elementName, elementNamespace, type, getContextClassLoader(), dslResolver, parsingContext).parse().forEach(this::addDefinition);
        } catch (Exception e) {
            throw new MuleRuntimeException(new ConfigurationException(e));
        }
    }
}

Example 15 with ParameterModel

use of org.mule.runtime.api.meta.model.parameter.ParameterModel in project mule by mulesoft.

the class ObjectTypeSchemaDelegate method declareObjectField.

private void declareObjectField(DslElementSyntax fieldDsl, ObjectFieldType field, ExtensionType extension, List<TopLevelElement> all) {
    ParameterModel parameter = asParameter(field);
    if (fieldDsl == null) {
        fieldDsl = dsl.resolve(parameter);
    }
    final String id = getId(field.getValue());
    if (id.equals(TlsContextFactory.class.getName())) {
        builder.addTlsSupport(extension, all);
        return;
    }
    if (id.equals(Scheduler.class.getName())) {
        builder.addSchedulerSupport(all);
        return;
    }
    builder.declareAsParameter(field.getValue(), extension, parameter, fieldDsl, all);
}