@Override
public Object resolve(RoutingContext context, RequestBody annotation, Class<?> resultClass) {
String body = context.getBodyAsString();
if (resultClass.equals(String.class)) {
return body;
}
String contentType = ContentTypeProcessor.getContentType(context);
if (contentType == null) {
log.error("No suitable Content-Type found, request body can't be read");
return null;
}
if (contentType.equals("application/json") && resultClass.equals(JsonObject.class)) {
return new JsonObject(body);
}
PayloadMarshaller marshaller = marshallers.get(contentType);
if (marshaller == null) {
log.error(
"No marshaller found for Content-Type : " + contentType + ", request body can't be read");
return null;
}
try {
return marshaller.unmarshallPayload(body, resultClass);
} catch (MarshallingException me) {
context.fail(me);
return null;
}
}
@Override
public void handle(RoutingContext context) {
username = context.user().principal().getString("username");
jdbcClient.getConnection(
connectionRes -> {
if (connectionRes.succeeded()) {
// System.out.println("Able to get JDBC Connection");
queryLocation(context, connectionRes);
} else {
log.error("Could not connect to the database.");
context.fail(402);
}
});
}
synchronized boolean matches(RoutingContext context, String mountPoint, boolean failure) {
if (failure && failureHandler == null || !failure && contextHandler == null) {
return false;
}
if (!enabled) {
return false;
}
HttpServerRequest request = context.request();
if (!methods.isEmpty() && !methods.contains(request.method())) {
return false;
}
if (path != null && pattern == null && !pathMatches(mountPoint, context)) {
return false;
}
if (pattern != null) {
String path =
useNormalisedPath
? Utils.normalisePath(context.request().path(), false)
: context.request().path();
if (mountPoint != null) {
path = path.substring(mountPoint.length());
}
Matcher m = pattern.matcher(path);
if (m.matches()) {
if (m.groupCount() > 0) {
Map<String, String> params = new HashMap<>(m.groupCount());
if (groups != null) {
// Pattern - named params
// decode the path as it could contain escaped chars.
try {
for (int i = 0; i < groups.size(); i++) {
final String k = groups.get(i);
final String value =
URLDecoder.decode(URLDecoder.decode(m.group("p" + i), "UTF-8"), "UTF-8");
if (!request.params().contains(k)) {
params.put(k, value);
} else {
context.pathParams().put(k, value);
}
}
} catch (UnsupportedEncodingException e) {
context.fail(e);
return false;
}
} else {
// Straight regex - un-named params
// decode the path as it could contain escaped chars.
try {
for (int i = 0; i < m.groupCount(); i++) {
String group = m.group(i + 1);
if (group != null) {
final String k = "param" + i;
final String value = URLDecoder.decode(group, "UTF-8");
if (!request.params().contains(k)) {
params.put(k, value);
} else {
context.pathParams().put(k, value);
}
}
}
} catch (UnsupportedEncodingException e) {
context.fail(e);
return false;
}
}
request.params().addAll(params);
context.pathParams().putAll(params);
}
} else {
return false;
}
}
if (!consumes.isEmpty()) {
// Can this route consume the specified content type
String contentType = request.headers().get("content-type");
boolean matches = false;
for (String ct : consumes) {
if (ctMatches(contentType, ct)) {
matches = true;
break;
}
}
if (!matches) {
return false;
}
}
if (!produces.isEmpty()) {
String accept = request.headers().get("accept");
if (accept != null) {
List<String> acceptableTypes = Utils.getSortedAcceptableMimeTypes(accept);
for (String acceptable : acceptableTypes) {
for (String produce : produces) {
if (ctMatches(produce, acceptable)) {
context.setAcceptableContentType(produce);
return true;
}
}
}
} else {
// According to rfc2616-sec14,
// If no Accept header field is present, then it is assumed that the client accepts all
// media types.
context.setAcceptableContentType(produces.iterator().next());
return true;
}
return false;
}
return true;
}