Example usage for com.fasterxml.jackson.databind.type TypeFactory defaultInstance

List of usage examples for com.fasterxml.jackson.databind.type TypeFactory defaultInstance

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.type TypeFactory defaultInstance.

Prototype

public static TypeFactory defaultInstance() 

Source Link

Usage

From source file:com.spotify.helios.client.HeliosClient.java

public ListenableFuture<Map<JobId, JobStatus>> jobStatuses(final Set<JobId> jobs) {
    final ConvertResponseToPojo<Map<JobId, JobStatus>> converter = ConvertResponseToPojo.create(
            TypeFactory.defaultInstance().constructMapType(Map.class, JobId.class, JobStatus.class),
            ImmutableSet.of(HTTP_OK));/*from  w  ww.j a  v  a  2  s .  c  o m*/

    return transform(request(uri("/jobs/statuses"), "POST", jobs), converter);
}

From source file:com.googlecode.jsonrpc4j.JsonRpcServer.java

/**
 * Invokes the given method on the {@code handler} passing
 * the given params (after converting them to beans\objects)
 * to it.//from   w w w.j a v  a 2  s  .c  om
 *
 * @param an optional service name used to locate the target object
 *  to invoke the Method on
 * @param m the method to invoke
 * @param params the params to pass to the method
 * @return the return value (or null if no return)
 * @throws IOException on error
 * @throws IllegalAccessException on error
 * @throws InvocationTargetException on error
 */
protected JsonNode invoke(Object target, Method m, List<JsonNode> params)
        throws IOException, IllegalAccessException, InvocationTargetException {

    // debug log
    if (LOGGER.isLoggable(Level.FINE)) {
        LOGGER.log(Level.FINE, "Invoking method: " + m.getName());
    }

    // convert the parameters
    Object[] convertedParams = new Object[params.size()];
    Type[] parameterTypes = m.getGenericParameterTypes();

    for (int i = 0; i < parameterTypes.length; i++) {
        JsonParser paramJsonParser = mapper.treeAsTokens(params.get(i));
        JavaType paramJavaType = TypeFactory.defaultInstance().constructType(parameterTypes[i]);
        convertedParams[i] = mapper.readValue(paramJsonParser, paramJavaType);
    }

    // invoke the method
    Object result = m.invoke(target, convertedParams);
    return (m.getGenericReturnType() != null) ? mapper.valueToTree(result) : null;
}

From source file:plugins.PlayReader.java

private Operation parseMethod(Class<?> cls, Method method, List<Parameter> globalParameters) {
    Operation operation = new Operation();

    ApiOperation apiOperation = ReflectionUtils.getAnnotation(method, ApiOperation.class);
    ApiResponses responseAnnotation = ReflectionUtils.getAnnotation(method, ApiResponses.class);

    String operationId = method.getName();
    String responseContainer = null;

    Type responseType = null;// ww w  . j a  v  a 2  s .  co  m
    Map<String, Property> defaultResponseHeaders = new HashMap<String, Property>();

    if (apiOperation != null) {
        if (apiOperation.hidden()) {
            return null;
        }
        if (!"".equals(apiOperation.nickname())) {
            operationId = apiOperation.nickname();
        }

        defaultResponseHeaders = parseResponseHeaders(apiOperation.responseHeaders());

        operation.summary(apiOperation.value()).description(apiOperation.notes());

        if (apiOperation.response() != null && !isVoid(apiOperation.response())) {
            responseType = apiOperation.response();
        }
        if (!"".equals(apiOperation.responseContainer())) {
            responseContainer = apiOperation.responseContainer();
        }
        if (apiOperation.authorizations() != null) {
            List<SecurityRequirement> securities = new ArrayList<SecurityRequirement>();
            for (Authorization auth : apiOperation.authorizations()) {
                if (auth.value() != null && !"".equals(auth.value())) {
                    SecurityRequirement security = new SecurityRequirement();
                    security.setName(auth.value());
                    AuthorizationScope[] scopes = auth.scopes();
                    for (AuthorizationScope scope : scopes) {
                        if (scope.scope() != null && !"".equals(scope.scope())) {
                            security.addScope(scope.scope());
                        }
                    }
                    securities.add(security);
                }
            }
            if (securities.size() > 0) {
                for (SecurityRequirement sec : securities) {
                    operation.security(sec);
                }
            }
        }
        if (apiOperation.consumes() != null && !apiOperation.consumes().isEmpty()) {
            operation.consumes(apiOperation.consumes());
        }
        if (apiOperation.produces() != null && !apiOperation.produces().isEmpty()) {
            operation.produces(apiOperation.produces());
        }
    }

    if (apiOperation != null && StringUtils.isNotEmpty(apiOperation.responseReference())) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        response.schema(new RefProperty(apiOperation.responseReference()));
        operation.addResponse(String.valueOf(apiOperation.code()), response);
    } else if (responseType == null) {
        // pick out response from method declaration
        Logger.debug("picking up response class from method " + method);
        responseType = method.getGenericReturnType();
    }
    if (isValidResponse(responseType)) {
        final Property property = ModelConverters.getInstance().readAsProperty(responseType);
        if (property != null) {
            final Property responseProperty = ContainerWrapper.wrapContainer(responseContainer, property);
            final int responseCode = apiOperation == null ? 200 : apiOperation.code();
            operation.response(responseCode, new Response().description(SUCCESSFUL_OPERATION)
                    .schema(responseProperty).headers(defaultResponseHeaders));
            appendModels(responseType);
        }
    }

    operation.operationId(operationId);

    if (apiOperation != null && apiOperation.consumes() != null && apiOperation.consumes().isEmpty()) {
        final Consumes consumes = ReflectionUtils.getAnnotation(method, Consumes.class);
        if (consumes != null) {
            for (String mediaType : ReaderUtils.splitContentValues(consumes.value())) {
                operation.consumes(mediaType);
            }
        }
    }

    if (apiOperation != null && apiOperation.produces() != null && apiOperation.produces().isEmpty()) {
        final Produces produces = ReflectionUtils.getAnnotation(method, Produces.class);
        if (produces != null) {
            for (String mediaType : ReaderUtils.splitContentValues(produces.value())) {
                operation.produces(mediaType);
            }
        }
    }

    List<ApiResponse> apiResponses = new ArrayList<ApiResponse>();
    if (responseAnnotation != null) {
        for (ApiResponse apiResponse : responseAnnotation.value()) {
            Map<String, Property> responseHeaders = parseResponseHeaders(apiResponse.responseHeaders());

            Response response = new Response().description(apiResponse.message()).headers(responseHeaders);

            if (apiResponse.code() == 0) {
                operation.defaultResponse(response);
            } else {
                operation.response(apiResponse.code(), response);
            }

            if (StringUtils.isNotEmpty(apiResponse.reference())) {
                response.schema(new RefProperty(apiResponse.reference()));
            } else if (!isVoid(apiResponse.response())) {
                responseType = apiResponse.response();
                final Property property = ModelConverters.getInstance().readAsProperty(responseType);
                if (property != null) {
                    response.schema(ContainerWrapper.wrapContainer(apiResponse.responseContainer(), property));
                    appendModels(responseType);
                }
            }
        }
    }
    if (ReflectionUtils.getAnnotation(method, Deprecated.class) != null) {
        operation.setDeprecated(true);
    }

    // process parameters
    for (Parameter globalParameter : globalParameters) {
        operation.parameter(globalParameter);
    }

    Type[] genericParameterTypes = method.getGenericParameterTypes();
    Annotation[][] paramAnnotations = method.getParameterAnnotations();
    for (int i = 0; i < genericParameterTypes.length; i++) {
        final Type type = TypeFactory.defaultInstance().constructType(genericParameterTypes[i], cls);
        List<Parameter> parameters = getParameters(type, Arrays.asList(paramAnnotations[i]));

        for (Parameter parameter : parameters) {
            operation.parameter(parameter);
        }
    }

    if (operation.getResponses() == null) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        operation.defaultResponse(response);
    }
    return operation;
}

From source file:io.sinistral.proteus.server.tools.swagger.Reader.java

public Operation parseMethod(Method method) {
    JavaType classType = TypeFactory.defaultInstance().constructType(method.getDeclaringClass());
    BeanDescription bd = new ObjectMapper().getSerializationConfig().introspect(classType);
    return parseMethod(classType.getClass(), method,
            bd.findMethod(method.getName(), method.getParameterTypes()), Collections.<Parameter>emptyList(),
            Collections.<ApiResponse>emptyList(), Collections.emptyList());
}

From source file:org.wso2.msf4j.swagger.ExtendedSwaggerReader.java

private Operation parseMethod(Class<?> cls, Method method, List<Parameter> globalParameters,
        List<ApiResponse> classApiResponses) {
    Operation operation = new Operation();

    ApiOperation apiOperation = ReflectionUtils.getAnnotation(method, ApiOperation.class);
    ApiResponses responseAnnotation = ReflectionUtils.getAnnotation(method, ApiResponses.class);

    String operationId = method.getName();
    String responseContainer = null;

    Type responseType = null;/*from w w w. ja  v a2s .  c o  m*/
    Map<String, Property> defaultResponseHeaders = new HashMap<>();

    if (apiOperation != null) {
        if (apiOperation.hidden()) {
            return null;
        }
        if (!"".equals(apiOperation.nickname())) {
            operationId = apiOperation.nickname();
        }

        defaultResponseHeaders = parseResponseHeaders(apiOperation.responseHeaders());

        operation.summary(apiOperation.value()).description(apiOperation.notes());

        if (apiOperation.response() != null && !isVoid(apiOperation.response())) {
            responseType = apiOperation.response();
        }
        if (!"".equals(apiOperation.responseContainer())) {
            responseContainer = apiOperation.responseContainer();
        }
        if (apiOperation.authorizations() != null) {
            List<SecurityRequirement> securities = new ArrayList<>();
            for (Authorization auth : apiOperation.authorizations()) {
                if (auth.value() != null && !"".equals(auth.value())) {
                    SecurityRequirement security = new SecurityRequirement();
                    security.setName(auth.value());
                    AuthorizationScope[] scopes = auth.scopes();
                    for (AuthorizationScope scope : scopes) {
                        if (scope.scope() != null && !"".equals(scope.scope())) {
                            security.addScope(scope.scope());
                        }
                    }
                    securities.add(security);
                }
            }
            if (securities.size() > 0) {
                securities.forEach(operation::security);
            }
        }
        if (apiOperation.consumes() != null && !apiOperation.consumes().isEmpty()) {
            String[] consumesAr = ReaderUtils.splitContentValues(new String[] { apiOperation.consumes() });
            for (String consume : consumesAr) {
                operation.consumes(consume);
            }
        }
        if (apiOperation.produces() != null && !apiOperation.produces().isEmpty()) {
            String[] producesAr = ReaderUtils.splitContentValues(new String[] { apiOperation.produces() });
            for (String produce : producesAr) {
                operation.produces(produce);
            }
        }
    }

    if (apiOperation != null && StringUtils.isNotEmpty(apiOperation.responseReference())) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        response.schema(new RefProperty(apiOperation.responseReference()));
        operation.addResponse(String.valueOf(apiOperation.code()), response);
    } else if (responseType == null) {
        // pick out response from method declaration
        LOGGER.debug("picking up response class from method " + method);
        responseType = method.getGenericReturnType();
    }
    if (isValidResponse(responseType)) {
        final Property property = ModelConverters.getInstance().readAsProperty(responseType);
        if (property != null) {
            final Property responseProperty = ContainerWrapper.wrapContainer(responseContainer, property);
            final int responseCode = apiOperation == null ? 200 : apiOperation.code();
            operation.response(responseCode, new Response().description(SUCCESSFUL_OPERATION)
                    .schema(responseProperty).headers(defaultResponseHeaders));
            appendModels(responseType);
        }
    }

    operation.operationId(operationId);

    if (operation.getConsumes() == null || operation.getConsumes().isEmpty()) {
        final Consumes consumes = ReflectionUtils.getAnnotation(method, Consumes.class);
        if (consumes != null) {
            for (String mediaType : ReaderUtils.splitContentValues(consumes.value())) {
                operation.consumes(mediaType);
            }
        }
    }

    if (operation.getProduces() == null || operation.getProduces().isEmpty()) {
        final Produces produces = ReflectionUtils.getAnnotation(method, Produces.class);
        if (produces != null) {
            for (String mediaType : ReaderUtils.splitContentValues(produces.value())) {
                operation.produces(mediaType);
            }
        }
    }

    List<ApiResponse> apiResponses = new ArrayList<>();
    if (responseAnnotation != null) {
        apiResponses.addAll(Arrays.asList(responseAnnotation.value()));
    }

    Class<?>[] exceptionTypes = method.getExceptionTypes();
    for (Class<?> exceptionType : exceptionTypes) {
        ApiResponses exceptionResponses = ReflectionUtils.getAnnotation(exceptionType, ApiResponses.class);
        if (exceptionResponses != null) {
            apiResponses.addAll(Arrays.asList(exceptionResponses.value()));
        }
    }

    for (ApiResponse apiResponse : apiResponses) {
        addResponse(operation, apiResponse);
    }
    // merge class level @ApiResponse
    for (ApiResponse apiResponse : classApiResponses) {
        String key = apiResponse.code() == 0 ? "default" : String.valueOf(apiResponse.code());
        if (operation.getResponses().containsKey(key)) {
            continue;
        }
        addResponse(operation, apiResponse);
    }

    if (ReflectionUtils.getAnnotation(method, Deprecated.class) != null) {
        operation.setDeprecated(true);
    }

    // process parameters
    globalParameters.forEach(operation::parameter);

    Type[] genericParameterTypes = method.getGenericParameterTypes();
    Annotation[][] paramAnnotations = method.getParameterAnnotations();
    for (int i = 0; i < genericParameterTypes.length; i++) {
        final Type type = TypeFactory.defaultInstance().constructType(genericParameterTypes[i], cls);
        List<Parameter> parameters = getParameters(type, Arrays.asList(paramAnnotations[i]));

        parameters.forEach(operation::parameter);
    }

    if (operation.getResponses() == null) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        operation.defaultResponse(response);
    }
    return operation;
}

From source file:io.swagger.jaxrs.Reader.java

private Operation parseMethod(Class<?> cls, Method method, List<Parameter> globalParameters) {
    Operation operation = new Operation();

    ApiOperation apiOperation = ReflectionUtils.getAnnotation(method, ApiOperation.class);
    ApiResponses responseAnnotation = ReflectionUtils.getAnnotation(method, ApiResponses.class);

    String operationId = method.getName();
    String responseContainer = null;

    Type responseType = null;// w w w  . j a va 2  s  .co m
    Map<String, Property> defaultResponseHeaders = new HashMap<String, Property>();

    if (apiOperation != null) {
        if (apiOperation.hidden()) {
            return null;
        }
        if (!"".equals(apiOperation.nickname())) {
            operationId = apiOperation.nickname();
        }

        defaultResponseHeaders = parseResponseHeaders(apiOperation.responseHeaders());

        operation.summary(apiOperation.value()).description(apiOperation.notes());

        if (apiOperation.response() != null && !isVoid(apiOperation.response())) {
            responseType = apiOperation.response();
        }
        if (!"".equals(apiOperation.responseContainer())) {
            responseContainer = apiOperation.responseContainer();
        }
        if (apiOperation.authorizations() != null) {
            List<SecurityRequirement> securities = new ArrayList<SecurityRequirement>();
            for (Authorization auth : apiOperation.authorizations()) {
                if (auth.value() != null && !"".equals(auth.value())) {
                    SecurityRequirement security = new SecurityRequirement();
                    security.setName(auth.value());
                    AuthorizationScope[] scopes = auth.scopes();
                    for (AuthorizationScope scope : scopes) {
                        if (scope.scope() != null && !"".equals(scope.scope())) {
                            security.addScope(scope.scope());
                        }
                    }
                    securities.add(security);
                }
            }
            if (securities.size() > 0) {
                for (SecurityRequirement sec : securities) {
                    operation.security(sec);
                }
            }
        }
        if (apiOperation.consumes() != null && !apiOperation.consumes().isEmpty()) {
            operation.consumes(apiOperation.consumes());
        }
        if (apiOperation.produces() != null && !apiOperation.produces().isEmpty()) {
            operation.produces(apiOperation.produces());
        }
    }

    if (apiOperation != null && StringUtils.isNotEmpty(apiOperation.responseReference())) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        response.schema(new RefProperty(apiOperation.responseReference()));
        operation.addResponse(String.valueOf(apiOperation.code()), response);
    } else if (responseType == null) {
        // pick out response from method declaration
        LOGGER.debug("picking up response class from method " + method);
        responseType = method.getGenericReturnType();
    }
    if (isValidResponse(responseType)) {
        final Property property = ModelConverters.getInstance().readAsProperty(responseType);
        if (property != null) {
            final Property responseProperty = ContainerWrapper.wrapContainer(responseContainer, property);
            final int responseCode = apiOperation == null ? 200 : apiOperation.code();
            operation.response(responseCode, new Response().description(SUCCESSFUL_OPERATION)
                    .schema(responseProperty).headers(defaultResponseHeaders));
            appendModels(responseType);
        }
    }

    operation.operationId(operationId);

    if (apiOperation != null && apiOperation.consumes() != null && apiOperation.consumes().isEmpty()) {
        final Consumes consumes = ReflectionUtils.getAnnotation(method, Consumes.class);
        if (consumes != null) {
            for (String mediaType : ReaderUtils.splitContentValues(consumes.value())) {
                operation.consumes(mediaType);
            }
        }
    }

    if (apiOperation != null && apiOperation.produces() != null && apiOperation.produces().isEmpty()) {
        final Produces produces = ReflectionUtils.getAnnotation(method, Produces.class);
        if (produces != null) {
            for (String mediaType : ReaderUtils.splitContentValues(produces.value())) {
                operation.produces(mediaType);
            }
        }
    }

    List<ApiResponse> apiResponses = new ArrayList<ApiResponse>();
    if (responseAnnotation != null) {
        apiResponses.addAll(Arrays.asList(responseAnnotation.value()));
    }

    Class<?>[] exceptionTypes = method.getExceptionTypes();
    for (Class<?> exceptionType : exceptionTypes) {
        ApiResponses exceptionResponses = ReflectionUtils.getAnnotation(exceptionType, ApiResponses.class);
        if (exceptionResponses != null) {
            apiResponses.addAll(Arrays.asList(exceptionResponses.value()));
        }
    }

    for (ApiResponse apiResponse : apiResponses) {
        Map<String, Property> responseHeaders = parseResponseHeaders(apiResponse.responseHeaders());

        Response response = new Response().description(apiResponse.message()).headers(responseHeaders);

        if (apiResponse.code() == 0) {
            operation.defaultResponse(response);
        } else {
            operation.response(apiResponse.code(), response);
        }

        if (StringUtils.isNotEmpty(apiResponse.reference())) {
            response.schema(new RefProperty(apiResponse.reference()));
        } else if (!isVoid(apiResponse.response())) {
            responseType = apiResponse.response();
            final Property property = ModelConverters.getInstance().readAsProperty(responseType);
            if (property != null) {
                response.schema(ContainerWrapper.wrapContainer(apiResponse.responseContainer(), property));
                appendModels(responseType);
            }
        }
    }
    if (ReflectionUtils.getAnnotation(method, Deprecated.class) != null) {
        operation.setDeprecated(true);
    }

    // process parameters
    for (Parameter globalParameter : globalParameters) {
        operation.parameter(globalParameter);
    }

    Type[] genericParameterTypes = method.getGenericParameterTypes();
    Annotation[][] paramAnnotations = method.getParameterAnnotations();
    for (int i = 0; i < genericParameterTypes.length; i++) {
        final Type type = TypeFactory.defaultInstance().constructType(genericParameterTypes[i], cls);
        List<Parameter> parameters = getParameters(type, Arrays.asList(paramAnnotations[i]));

        for (Parameter parameter : parameters) {
            operation.parameter(parameter);
        }
    }

    if (operation.getResponses() == null) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        operation.defaultResponse(response);
    }
    return operation;
}

From source file:io.sinistral.proteus.server.tools.swagger.Reader.java

@SuppressWarnings("deprecation")
private Operation parseMethod(Class<?> cls, Method method, AnnotatedMethod annotatedMethod,
        List<Parameter> globalParameters, List<ApiResponse> classApiResponses, List<String> pathParamNames) {
    Operation operation = new Operation();
    if (annotatedMethod != null) {
        method = annotatedMethod.getAnnotated();
    }/*from w w w.  jav  a2 s .c om*/
    ApiOperation apiOperation = ReflectionUtils.getAnnotation(method, ApiOperation.class);
    ApiResponses responseAnnotation = ReflectionUtils.getAnnotation(method, ApiResponses.class);

    String operationId;
    // check if it's an inherited or implemented method.
    boolean methodInSuperType = false;
    if (!cls.isInterface()) {
        methodInSuperType = ReflectionUtils.findMethod(method, cls.getSuperclass()) != null;
    }
    if (!methodInSuperType) {
        for (Class<?> implementedInterface : cls.getInterfaces()) {
            methodInSuperType = ReflectionUtils.findMethod(method, implementedInterface) != null;
            if (methodInSuperType) {
                break;
            }
        }
    }
    if (!methodInSuperType) {
        operationId = method.getName();
    } else {
        operationId = this.getOperationId(method.getName());
    }

    String responseContainer = null;

    Type responseType = null;
    Map<String, Property> defaultResponseHeaders = new LinkedHashMap<String, Property>();

    if (apiOperation != null) {
        if (apiOperation.hidden()) {
            return null;
        }
        if (operationId == null) {
            operationId = apiOperation.nickname();
        }

        defaultResponseHeaders = parseResponseHeaders(apiOperation.responseHeaders());

        operation.summary(apiOperation.value()).description(apiOperation.notes());

        if (!isVoid(apiOperation.response())) {
            responseType = apiOperation.response();
        }
        if (!apiOperation.responseContainer().isEmpty()) {
            responseContainer = apiOperation.responseContainer();
        }
        List<SecurityRequirement> securities = new ArrayList<SecurityRequirement>();
        for (Authorization auth : apiOperation.authorizations()) {
            if (!auth.value().isEmpty()) {
                SecurityRequirement security = new SecurityRequirement();
                security.setName(auth.value());
                for (AuthorizationScope scope : auth.scopes()) {
                    if (!scope.scope().isEmpty()) {
                        security.addScope(scope.scope());
                    }
                }
                securities.add(security);
            }
        }
        for (SecurityRequirement sec : securities) {
            operation.security(sec);
        }
        if (!apiOperation.consumes().isEmpty()) {
            String[] consumesAr = ReaderUtils.splitContentValues(new String[] { apiOperation.consumes() });
            for (String consume : consumesAr) {
                operation.consumes(consume);
            }
        }
        if (!apiOperation.produces().isEmpty()) {
            String[] producesAr = ReaderUtils.splitContentValues(new String[] { apiOperation.produces() });
            for (String produce : producesAr) {
                operation.produces(produce);
            }
        }
    }

    /*
     * @TODO
     * Use apiOperation response class instead of unwrapping ServerResponse's inner type
     */

    if (apiOperation != null && StringUtils.isNotEmpty(apiOperation.responseReference())) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);
        response.schema(new RefProperty(apiOperation.responseReference()));
        operation.addResponse(String.valueOf(apiOperation.code()), response);
    } else if (responseType == null) {
        // pick out response from method declaration
        LOGGER.debug("picking up response class from method {}", method);
        responseType = method.getGenericReturnType();
    }

    if (responseType != null) {
        final JavaType javaType = TypeFactory.defaultInstance().constructType(responseType);
        if (!isVoid(javaType)) {

            final Class<?> responseCls = javaType.getRawClass();

            if (responseCls != null) {
                if (responseCls.isAssignableFrom(ServerResponse.class)) {
                    responseType = javaType.containedType(0);
                } else if (responseCls.isAssignableFrom(CompletableFuture.class)) {
                    Class<?> futureCls = javaType.containedType(0).getRawClass();

                    if (futureCls.isAssignableFrom(ServerResponse.class)) {
                        final JavaType futureType = TypeFactory.defaultInstance()
                                .constructType(javaType.containedType(0));
                        responseType = futureType.containedType(0);
                    } else {
                        responseType = javaType.containedType(0);
                    }
                }
            }
        }
    }

    if (isValidResponse(responseType)) {
        final Property property = ModelConverters.getInstance().readAsProperty(responseType);
        if (property != null) {
            final Property responseProperty = ContainerWrapper.wrapContainer(responseContainer, property);
            final int responseCode = (apiOperation == null) ? 200 : apiOperation.code();
            operation.response(responseCode, new Response().description(SUCCESSFUL_OPERATION)
                    .schema(responseProperty).headers(defaultResponseHeaders));
            appendModels(responseType);
        }
    }

    operation.operationId(operationId);

    if (operation.getConsumes() == null || operation.getConsumes().isEmpty()) {
        final Consumes consumes = ReflectionUtils.getAnnotation(method, Consumes.class);
        if (consumes != null) {
            for (String mediaType : ReaderUtils.splitContentValues(consumes.value())) {
                operation.consumes(mediaType);
            }
        }
    }

    if (operation.getProduces() == null || operation.getProduces().isEmpty()) {
        final Produces produces = ReflectionUtils.getAnnotation(method, Produces.class);
        if (produces != null) {
            for (String mediaType : ReaderUtils.splitContentValues(produces.value())) {
                operation.produces(mediaType);
            }
        }
    }

    List<ApiResponse> apiResponses = new ArrayList<>();
    if (responseAnnotation != null) {
        apiResponses.addAll(Arrays.asList(responseAnnotation.value()));
    }

    Class<?>[] exceptionTypes = method.getExceptionTypes();
    for (Class<?> exceptionType : exceptionTypes) {
        ApiResponses exceptionResponses = ReflectionUtils.getAnnotation(exceptionType, ApiResponses.class);
        if (exceptionResponses != null) {
            apiResponses.addAll(Arrays.asList(exceptionResponses.value()));
        }
    }

    for (ApiResponse apiResponse : apiResponses) {
        addResponse(operation, apiResponse);
    }
    // merge class level @ApiResponse
    for (ApiResponse apiResponse : classApiResponses) {
        String key = (apiResponse.code() == 0) ? "default" : String.valueOf(apiResponse.code());
        if (operation.getResponses() != null && operation.getResponses().containsKey(key)) {
            continue;
        }
        addResponse(operation, apiResponse);
    }

    if (ReflectionUtils.getAnnotation(method, Deprecated.class) != null) {
        operation.setDeprecated(true);
    }

    // process parameters
    for (Parameter globalParameter : globalParameters) {

        LOGGER.debug("globalParameters TYPE: " + globalParameter);

        operation.parameter(globalParameter);
    }

    Annotation[][] paramAnnotations = ReflectionUtils.getParameterAnnotations(method);
    java.lang.reflect.Parameter[] methodParameters = method.getParameters();

    if (annotatedMethod == null) {
        Type[] genericParameterTypes = method.getGenericParameterTypes();

        for (int i = 0; i < genericParameterTypes.length; i++) {

            Type type = TypeFactory.defaultInstance().constructType(genericParameterTypes[i], cls);

            if (type.getTypeName().contains("Optional")
                    || type.getTypeName().contains("io.sinistral.proteus.server.ServerResponse")) {
                if (type instanceof com.fasterxml.jackson.databind.type.SimpleType) {
                    com.fasterxml.jackson.databind.type.SimpleType simpleType = (com.fasterxml.jackson.databind.type.SimpleType) type;

                    type = simpleType.containedType(0);
                }

            }

            if (type.equals(ServerRequest.class) || type.equals(HttpServerExchange.class)
                    || type.equals(HttpHandler.class)
                    || type.getTypeName().contains("io.sinistral.proteus.server.ServerResponse")) {
                continue;
            }

            List<Parameter> parameters = getParameters(type, Arrays.asList(paramAnnotations[i]),
                    methodParameters[i], pathParamNames);

            for (Parameter parameter : parameters) {
                operation.parameter(parameter);
            }
        }
    } else {
        for (int i = 0; i < annotatedMethod.getParameterCount(); i++) {
            AnnotatedParameter param = annotatedMethod.getParameter(i);

            if (param.getParameterType().equals(ServerRequest.class)
                    || param.getParameterType().equals(HttpServerExchange.class)
                    || param.getParameterType().equals(HttpHandler.class)
                    || param.getParameterType().getTypeName().contains("ServerResponse")) {
                continue;
            }

            Type type = TypeFactory.defaultInstance().constructType(param.getParameterType(), cls);

            List<Parameter> parameters = getParameters(type, Arrays.asList(paramAnnotations[i]),
                    methodParameters[i], pathParamNames);

            for (Parameter parameter : parameters) {

                operation.parameter(parameter);
            }
        }
    }

    if (operation.getResponses() == null) {
        Response response = new Response().description(SUCCESSFUL_OPERATION);

        operation.response(200, response);
    }

    processOperationDecorator(operation, method);

    return operation;
}

From source file:io.sinistral.proteus.server.tools.swagger.Reader.java

private List<Parameter> getParameters(Type type, List<Annotation> annotations,
        java.lang.reflect.Parameter methodParameter, List<String> pathParamNames) {
    final Iterator<SwaggerExtension> chain = SwaggerExtensions.chain();

    if (!chain.hasNext()) {
        return Collections.emptyList();
    }/*from  ww  w  .  j a  v a  2  s  .  c  om*/

    //   LOGGER.debug("getParameters for {}", type);
    Set<Type> typesToSkip = new HashSet<>();
    typesToSkip.add(TypeFactory.defaultInstance().constructType(ServerRequest.class));
    typesToSkip.add(TypeFactory.defaultInstance().constructType(HttpServerExchange.class));
    typesToSkip.add(TypeFactory.defaultInstance().constructType(ServerResponse.class));
    typesToSkip.add(TypeFactory.defaultInstance().constructType(HttpHandler.class));
    typesToSkip.add(TypeFactory.defaultInstance().constructType(io.undertow.server.session.Session.class));

    final SwaggerExtension extension = chain.next();

    if (typesToSkip.contains(type)) {
        return Collections.emptyList();
    }

    annotations = new ArrayList<>(annotations);

    if (!annotations.stream().filter(a -> a instanceof ApiParam).findFirst().isPresent()) {
        annotations.add(AnnotationHelper.createApiParam(methodParameter));
    }

    if (type.getTypeName().contains("java.nio.file.Path") || type.getTypeName().contains("java.nio.ByteBuffer")
            || type.getTypeName().contains("java.io.File")) {
        if (type.getTypeName().contains("java.nio.file.Path")
                || type.getTypeName().contains("java.nio.ByteBuffer")) {
            type = java.io.File.class;
        }

        annotations.add(AnnotationHelper.createFormParam(methodParameter));

    }

    if (annotations.size() == 1) {
        if (annotations.get(0) instanceof ApiParam) {
            // If there is only one ApiParam and the parameter type is a member of the java.lang and the name of that parameter is in the path operation's path make the assumption that this is a path param
            if (methodParameter.getType().getName().indexOf("java.lang") > -1
                    && pathParamNames.contains(methodParameter.getName())) {
                annotations.add(AnnotationHelper.createPathParam(methodParameter));

            }
            // If there is only one ApiParam and the parameter type is a member of the java.lang or java.util package we make the assumption that this is a query param
            else if (methodParameter.getType().getName().indexOf("java.lang") > -1
                    || methodParameter.getType().getName().indexOf("java.util") > -1) {
                annotations.add(AnnotationHelper.createQueryParam(methodParameter));
            }
        }
    }

    final List<Parameter> parameters = extension.extractParameters(annotations, type, typesToSkip, chain);
    if (!parameters.isEmpty()) {
        final List<Parameter> processed = new ArrayList<Parameter>(parameters.size());
        for (Parameter parameter : parameters) {

            //  LOGGER.debug("getParameters for {}", type);

            if (ParameterProcessor.applyAnnotations(swagger, parameter, type, annotations) != null) {

                processed.add(parameter);
            }
        }
        return processed;
    } else {
        //  LOGGER.debug("no parameter found, looking at body params");
        final List<Parameter> body = new ArrayList<Parameter>();
        if (!typesToSkip.contains(type)) {

            Parameter param = ParameterProcessor.applyAnnotations(swagger, null, type, annotations);
            if (param != null) {

                body.add(param);
            }
        }
        return body;
    }
}

From source file:io.sinistral.proteus.server.tools.swagger.Reader.java

private static boolean isValidResponse(Type type) {
    if (type == null) {
        return false;
    }//from   w ww.j  av  a2  s  .  c  o m
    final JavaType javaType = TypeFactory.defaultInstance().constructType(type);
    if (isVoid(javaType)) {
        return false;
    }

    final Class<?> cls = javaType.getRawClass();

    if (cls != null) {
        if (cls.isAssignableFrom(ServerResponse.class) || cls.isAssignableFrom(CompletableFuture.class)
                || cls.isAssignableFrom(ByteBuffer.class)) {
            return false;
        }
    }

    return !javax.ws.rs.core.Response.class.isAssignableFrom(cls) && !isResourceClass(cls);
}

From source file:com.epam.catgenome.manager.FileManager.java

/**
 * Returns {@link Map} object contains default track configurations
 *
 * @return {@link Map}, representing default track configurations
 * @throws IOException// w w w.  j a  v  a 2 s. c o m
 */
public Map<String, Map<String, Object>> getDefaultTrackSettings() throws IOException {
    Map<String, Map<String, Object>> defaultTracksSettings = new HashMap<>();

    if (StringUtils.isBlank(defaultTrackSettingsDirPath)) {
        LOGGER.debug("Default configuration isn't provided, empty settings set will be returned.");
        return defaultTracksSettings;
    }

    LOGGER.debug("Default configurations directory: {}", defaultTrackSettingsDirPath);
    Path settingsDirPath = Paths.get(defaultTrackSettingsDirPath);
    Assert.isTrue(settingsDirPath.toFile().exists() || settingsDirPath.toFile().isDirectory(),
            getMessage(MessagesConstants.ERROR_DIRECTORY_NOT_FOUND, settingsDirPath));

    List<File> trackSettingsFiles = Files.walk(settingsDirPath).filter(Files::isRegularFile)
            .filter(filePath -> filePath.getFileName().toString().endsWith(JSON_FILE_EXTENSION))
            .map(Path::toFile).collect(Collectors.toList());

    for (File trackSettingsFile : trackSettingsFiles) {
        String trackSettingsFileName = trackSettingsFile.getName();
        LOGGER.debug("Process configurations file: {}", trackSettingsFileName);
        JsonMapper jsonMapper = new JsonMapper();
        try {
            defaultTracksSettings.put(trackSettingsFileName.replace(JSON_FILE_EXTENSION, EMPTY),
                    jsonMapper.readValue(trackSettingsFile, TypeFactory.defaultInstance()
                            .constructParametricType(Map.class, String.class, Object.class)));
        } catch (JsonParseException e) {
            LOGGER.error(getMessage(MessagesConstants.ERROR_LOGGER_JSON_FILE_INVALID, trackSettingsFile), e);
        }
    }

    return defaultTracksSettings;
}