/*
* #%L
* Wisdom-Framework
* %%
* Copyright (C) 2013 - 2014 Wisdom Framework
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.wisdom.framework.vertx;
import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.net.MediaType;
import io.vertx.core.MultiMap;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.net.SocketAddress;
import org.wisdom.api.cookies.Cookie;
import org.wisdom.api.cookies.Cookies;
import org.wisdom.api.http.HeaderNames;
import org.wisdom.api.http.MimeTypes;
import org.wisdom.api.http.Request;
import org.wisdom.framework.vertx.cookies.CookiesImpl;
import org.wisdom.framework.vertx.file.VertxFileUpload;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
/**
* An implementation of {@link org.wisdom.api.http.Request} based on Vert.X Request
* ({@link HttpServerRequest}).
*/
public class RequestFromVertx extends Request {
private final HttpServerRequest request;
private final Cookies cookies;
/**
* List of uploaded files.
*/
private List<VertxFileUpload> files = Lists.newArrayList();
/**
* The raw body.
*/
private Buffer raw = Buffer.factory.buffer(0);
/**
* The map used to store data shared in the request scope.
*/
private final Map<String, Object> data;
private Map<String, List<String>> formData;
private Map<String, List<String>> headers;
/**
* Creates a {@link org.wisdom.framework.vertx.RequestFromVertx} object
*
* @param request the Vertx Request
*/
public RequestFromVertx(final HttpServerRequest request) {
this.request = request;
this.cookies = new CookiesImpl(request);
this.data = new HashMap<>();
}
/**
* The Content-Type header field indicates the media type of the request
* body sent to the recipient. E.g. {@code Content-Type: text/html;
* charset=ISO-8859-4}
*
* @return the content type of the incoming request.
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public String contentType() {
return request.headers().get(HeaderNames.CONTENT_TYPE);
}
/**
* Gets the encoding that is acceptable for the client. E.g. Accept-Encoding:
* compress, gzip
* <p/>
* The Accept-Encoding request-header field is similar to Accept, but
* restricts the content-codings that are acceptable in the response.
*
* @return the encoding that is acceptable for the client
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public String encoding() {
return request.headers().get(HeaderNames.ACCEPT_ENCODING);
}
/**
* Gets the language that is acceptable for the client. E.g. Accept-Language:
* da, en-gb;q=0.8, en;q=0.7
* <p/>
* The Accept-Language request-header field is similar to Accept, but
* restricts the set of natural languages that are preferred as a response
* to the request.
*
* @return the language that is acceptable for the client
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public String language() {
return request.headers().get(HeaderNames.ACCEPT_LANGUAGE);
}
/**
* Gets the charset that is acceptable for the client. E.g. Accept-Charset:
* iso-8859-5, unicode-1-1;q=0.8
* <p/>
* The Accept-Charset request-header field can be used to indicate what
* character sets are acceptable for the response. This field allows clients
* capable of understanding more comprehensive or special- purpose character
* sets to signal that capability to a server which is capable of
* representing documents in those character sets.
*
* @return the charset that is acceptable for the client
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public String charset() {
return request.headers().get(HeaderNames.ACCEPT_CHARSET);
}
/**
* The complete request URI, containing both path and query string.
*/
@Override
public String uri() {
return request.uri();
}
/**
* Returns the name of the HTTP method with which this
* request was made, for example, GET, POST, or PUT.
* Same as the value of the CGI variable REQUEST_METHOD.
*
* @return a <code>String</code>
* specifying the name
* of the method with which
* this request was made (eg GET, POST, PUT...)
*/
@Override
public String method() {
return request.method().name();
}
/**
* The client IP address.
* <p/>
* If the <code>X-Forwarded-For</code> header is present, then this method will return the value in that header
* if either the local address is 127.0.0.1, or if <code>trustxforwarded</code> is configured to be true in the
* application configuration file.
*/
@Override
public String remoteAddress() {
if (headers().containsKey(HeaderNames.X_FORWARD_FOR)) {
return getHeader(HeaderNames.X_FORWARD_FOR);
} else {
return host();
}
}
/**
* The request host.
*/
@Override
public String host() {
SocketAddress remote = request.remoteAddress();
return remote.host();
}
/**
* The URI path, without the query part.
*/
@Override
public String path() {
try {
return new URI(request.uri()).getRawPath();
} catch (URISyntaxException e) { //NOSONAR
// Should never be the case.
return uri();
}
}
/**
* Get the preferred content media type that is acceptable for the client. For instance, in Accept: text/*;q=0.3,
* text/html;q=0.7, text/html;level=1,text/html;level=2;q=0.4, text/html is returned.
* <p/>
* The Accept request-header field can be used to specify certain media
* types which are acceptable for the response. Accept headers can be used
* to indicate that the request is specifically limited to a small set of
* desired types, as in the case of a request for an in-line image.
*
* @return a MediaType that is acceptable for the
* client or {@see MediaType#HTML_UTF_8} if not set
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public MediaType mediaType() {
Collection<MediaType> types = mediaTypes();
if (types == null || types.isEmpty()) {
return MediaType.ANY_TEXT_TYPE;
} else if (types.size() == 1 && types.iterator().next().equals(MediaType.ANY_TYPE)) {
return MediaType.ANY_TEXT_TYPE;
} else {
return types.iterator().next();
}
}
/**
* Get the content media type that is acceptable for the client. E.g. Accept: text/*;q=0.3, text/html;q=0.7,
* text/html;level=1,text/html;level=2;q=0.4
* <p/>
* The Accept request-header field can be used to specify certain media
* types which are acceptable for the response. Accept headers can be used
* to indicate that the request is specifically limited to a small set of
* desired types, as in the case of a request for an in-line image.
*
* @return a MediaType that is acceptable for the
* client or {@see MediaType#ANY_TEXT_TYPE} if not set
* @see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html"
* >http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
*/
@Override
public Collection<MediaType> mediaTypes() {
String contentType = request.headers().get(HeaderNames.ACCEPT);
if (contentType == null) {
// Any text by default.
return ImmutableList.of(MediaType.ANY_TEXT_TYPE);
}
TreeSet<MediaType> set = new TreeSet<>(new Comparator<MediaType>() {
@Override
public int compare(MediaType o1, MediaType o2) {
double q1 = 1.0, q2 = 1.0;
List<String> ql1 = o1.parameters().get("q");
List<String> ql2 = o2.parameters().get("q");
if (ql1 != null && !ql1.isEmpty()) {
q1 = Double.parseDouble(ql1.get(0));
}
if (ql2 != null && !ql2.isEmpty()) {
q2 = Double.parseDouble(ql2.get(0));
}
return new Double(q2).compareTo(q1);
}
});
// Split and sort.
String[] segments = contentType.split(",");
for (String segment : segments) {
MediaType type = MediaType.parse(segment.trim());
set.add(type);
}
return set;
}
/**
* Check if this request accepts a given media type.
*
* @return true if <code>mimeType</code> is in the Accept header, otherwise false
*/
@Override
public boolean accepts(String mimeType) {
String contentType = request.headers().get(HeaderNames.ACCEPT);
if (contentType == null) {
contentType = MimeTypes.HTML;
}
// For performance reason, we first try a full match:
if (contentType.contains(mimeType)) {
return true;
}
// Else check the media types:
MediaType input = MediaType.parse(mimeType);
for (MediaType type : mediaTypes()) {
if (input.is(type)) {
return true;
}
}
return false;
}
/**
* Gets the list of cookies.
*
* @return the request cookies
*/
@Override
public Cookies cookies() {
return cookies;
}
/**
* Gets a cookie with the given name.
*
* @param name the cookie to retrieve
* @return the cookie, {@code null} if no cookie have the given name
*/
public Cookie cookie(String name) {
return cookies.get(name);
}
/**
* Retrieves all headers.
*
* @return headers
*/
@Override
public Map<String, List<String>> headers() {
if (headers != null) {
return headers;
}
headers = new HashMap<>();
final MultiMap requestHeaders = request.headers();
Set<String> names = requestHeaders.names();
for (String name : names) {
headers.put(name, requestHeaders.getAll(name));
}
return headers;
}
/**
* Get the parameter with the given key from the request. The parameter may
* either be a query parameter, or in the case of form submissions, may be a
* form parameter.
* <p/>
* When the parameter is multivalued, returns the first value.
* <p/>
* The parameter is decoded by default.
*
* @param name The key of the parameter
* @return The value, or null if no parameter was found.
* @see #parameterMultipleValues
*/
@Override
public String parameter(String name) {
String s = request.params().get(name);
if (s == null) {
// Check form parameter
if (formData != null) {
List<String> l = formData.get(name);
if (l != null && !l.isEmpty()) {
return l.get(0);
}
}
return null;
} else {
return s;
}
}
/**
* Get the parameter with the given key from the request. The parameter may
* either be a query parameter, or in the case of form submissions, may be a
* form parameter.
* <p/>
* The parameter is decoded by default.
*
* @param name The key of the parameter
* @return The values, possibly an empty list.
*/
@Override
public List<String> parameterMultipleValues(String name) {
return request.params().getAll(name);
}
/**
* Same like {@link #parameter(String)}, but returns given defaultValue
* instead of null in case parameter cannot be found.
* <p/>
* The parameter is decoded by default.
*
* @param name The name of the post or query parameter
* @param defaultValue A default value if parameter not found.
* @return The value of the parameter of the defaultValue if not found.
*/
@Override
public String parameter(String name, String defaultValue) {
String v = request.params().get(name);
return v != null ? v : defaultValue;
}
/**
* Same like {@link #parameter(String)}, but converts the parameter to
* Integer if found.
* <p/>
* The parameter is decoded by default.
*
* @param name The name of the post or query parameter
* @return The value of the parameter or null if not found.
*/
@Override
public Integer parameterAsInteger(String name) {
String parameter = parameter(name);
try {
return Integer.parseInt(parameter);
} catch (Exception e) { //NOSONAR
return null;
}
}
/**
* Like {@link #parameter(String, String)}, but converts the
* parameter to Integer if found.
* <p/>
* The parameter is decoded by default.
*
* @param name The name of the post or query parameter
* @param defaultValue A default value if parameter not found.
* @return The value of the parameter of the defaultValue if not found.
*/
@Override
public Integer parameterAsInteger(String name, Integer defaultValue) {
Integer parameter = parameterAsInteger(name);
if (parameter == null) {
return defaultValue;
}
return parameter;
}
/**
* Like {@link #parameter(String)}, but converts the parameter to
* Boolean if found.
* <p/>
* The parameter is decoded by default.
*
* @param name The name of the post or query parameter
* @return The value of the parameter or {@literal false} if not found.
*/
@Override
public Boolean parameterAsBoolean(String name) {
String parameter = parameter(name);
try {
return Boolean.parseBoolean(parameter);
} catch (Exception e) { //NOSONAR
return false;
}
}
/**
* Same like {@link #parameter(String)}, but converts the parameter to
* Boolean if found.
* <p/>
* The parameter is decoded by default.
*
* @param name The name of the post or query parameter
* @param defaultValue A default value if parameter not found.
* @return The value of the parameter or the defaultValue if not found.
*/
@Override
public Boolean parameterAsBoolean(String name, boolean defaultValue) {
// We have to check if the map contains the key, as the retrieval method returns false on missing key.
if (!request.params().contains(name)) {
return defaultValue;
}
Boolean parameter = parameterAsBoolean(name);
if (parameter == null) {
return defaultValue;
}
return parameter;
}
/**
* Gets all the parameters from the request.
*
* @return The parameters
*/
@Override
public Map<String, List<String>> parameters() {
Map<String, List<String>> result = new HashMap<>();
for (String key : request.params().names()) {
result.put(key, request.params().getAll(key));
}
return result;
}
/**
* Retrieves the data shared by all the entities participating to the request resolution (i.e. computation of the
* response). This method returns a live map, meaning that modification impacts all other participants. It can be
* used to let filters or interceptors passing objects to action methods or templates.
*
* @return the map storing the data. Unlike session or flash, these data are not stored in cookies,
* and are cleared once the response is sent back to the client.
*/
@Override
public Map<String, Object> data() {
return data;
}
/**
* Gets the underlying Vert.X Request.
*
* @return the request.
*/
public HttpServerRequest getVertxRequest() {
return request;
}
/**
* Gets the form data.
*
* @return the form data
*/
public Map<String, List<String>> getFormData() {
return formData;
}
/**
* Gets the 'raw' body.
*
* @return the raw body, {@code null} if there is no body.
*/
public String getRawBodyAsString() {
if (raw == null) {
return null;
}
return raw.toString(Charsets.UTF_8.displayName());
}
/**
* Gets the 'raw' body.
*
* @return the raw body, {@code null} if there is no body.
*/
public byte[] getRawBody() {
return raw.getBytes();
}
/**
* Gets the uploaded files.
*
* @return the list of uploaded files.
*/
public List<VertxFileUpload> getFiles() {
return files;
}
/**
* Callbacks invokes when the request has been read completely.
*
* @return a boolean indicating if the request was handled correctly.
*/
public boolean ready() {
for (VertxFileUpload file : files) {
if (file.getErrorIfAny() != null) {
return false;
}
}
String contentType = request.headers().get(HeaderNames.CONTENT_TYPE);
if (contentType != null) {
contentType = HttpUtils.getContentTypeFromContentTypeAndCharacterSetting(contentType);
if ((HttpUtils.isPostOrPut(request))
&&
(contentType.equalsIgnoreCase(MimeTypes.FORM) || contentType.equalsIgnoreCase(MimeTypes.MULTIPART))) {
formData = new HashMap<>();
for (String key : request.formAttributes().names()) {
formData.put(key, request.formAttributes().getAll(key));
}
return true;
}
}
formData = new HashMap<>();
return true;
}
protected void setRawBody(Buffer raw) {
this.raw = raw;
}
}