HLTech / pact-gen

@MappingMethodHandler

public class JaxRsGetMappingMethodsHandler implements AnnotatedMethodHandler {

    @Override

    public boolean isSupported(Method method) {

        return method.isAnnotationPresent(GET.class);

    }

    @Override

    public RequestRepresentation handleRequest(Method method) {

        return RequestRepresentation.builder()

                .httpMethod(HttpMethod.GET)

                .path(extractPath(method))

                .headers(extractHeaders(method))

                .body(extractBody(method))

                .requestParameters(extractRequestParameters(method))

                .pathParameters(extractPathParameters(method))

                .build();

    }

    @Override

    public String[] getResponseMediaHeaders(Method method) {

        return new String[0];

    }

    private List<Param> extractPathParameters(Method method) {

        return Arrays.stream(method.getParameters())

                .filter(param -> param.getAnnotation(PathParam.class) != null)

                .map(this::fromPathParam)

                .collect(Collectors.toList());

    }

    private Param fromPathParam(Parameter parameter) {

        return Param.builder()

                .name(parameter.getAnnotation(PathParam.class).value())

                .type(parameter.getType())

                .build();

    }

    private List<Param> extractRequestParameters(Method method) {

        return Arrays.stream(method.getParameters())

                .filter(param -> param.getAnnotation(QueryParam.class) != null)

                .map(this::fromQueryParam)

                .collect(Collectors.toList());

    }

    private Param fromQueryParam(Parameter parameter) {

        return Param.builder()

                .name(parameter.getAnnotation(QueryParam.class).value())

                .type(parameter.getType())

                .build();

    }

    private Body extractBody(Method method) {

        Optional<Parameter> requestBody = Arrays.stream(method.getParameters())

                .filter(p -> p.getAnnotations().length == 0 || p.getAnnotation(Consumes.class) != null)

                .findFirst();

        Body.BodyBuilder builder = Body.builder();

        requestBody

                .map(Parameter::getType)

                .ifPresent(builder::type);

        requestBody

                .map(Parameter::getParameterizedType)

                .map(TypeExtractor::extractParameterTypesFromType)

                .ifPresent(builder::genericArgumentTypes);

        return builder.build();

    }

    //TODO this method supports only headers added via annotation @HeaderParam.class

    private List<Param> extractHeaders(Method method) {

        return Arrays.stream(method.getParameters())

                .filter(param -> param.getAnnotation(HeaderParam.class) != null)

                .map(param -> param.getAnnotation(HeaderParam.class))

                .map(this::fromHeaderParam)

                .collect(Collectors.toList());

    }

    private Param fromHeaderParam(HeaderParam headerParam) {

        return Param

                .builder()

                .name(headerParam.value())

                .build();

    }

    private String extractPath(Method method) {

        Path annotation = method.getAnnotation(Path.class) != null

                ? method.getAnnotation(Path.class)

                : method.getDeclaringClass().getAnnotation(Path.class);

        Assert.notNull(annotation, () -> String.format("Cannot find annotation %s on %s or %s",

                Path.class.getName(), ElementType.TYPE, ElementType.METHOD));

        return annotation.value();