private static MultivaluedMap<ParameterType, Parameter> getParametersInfo(
Method m, Object[] params, OperationResourceInfo ori) {
MultivaluedMap<ParameterType, Parameter> map = new MetadataMap<ParameterType, Parameter>();
List<Parameter> parameters = ori.getParameters();
if (parameters.size() == 0) {
return map;
}
int requestBodyParam = 0;
int multipartParam = 0;
for (Parameter p : parameters) {
if (isIgnorableParameter(m, p)) {
continue;
}
if (p.getType() == ParameterType.REQUEST_BODY) {
requestBodyParam++;
if (getMultipart(ori, p.getIndex()) != null) {
multipartParam++;
}
}
map.add(p.getType(), p);
}
if (map.containsKey(ParameterType.REQUEST_BODY)) {
if (requestBodyParam > 1 && requestBodyParam != multipartParam) {
reportInvalidResourceMethod(ori.getMethodToInvoke(), "SINGLE_BODY_ONLY");
}
if (map.containsKey(ParameterType.FORM)) {
reportInvalidResourceMethod(ori.getMethodToInvoke(), "ONLY_FORM_ALLOWED");
}
}
return map;
}
private void validate(final MultivaluedMap<String, String> data) throws NullPointerException {
if (!data.containsKey("From")) {
throw new NullPointerException("From can not be null.");
} else if (!data.containsKey("To")) {
throw new NullPointerException("To can not be null.");
} else if (!data.containsKey("Url")) {
throw new NullPointerException("Url can not be null.");
}
}
public KeyRecoveryRequest(MultivaluedMap<String, String> form) {
if (form.containsKey(KEY_ID)) {
attributes.put(KEY_ID, form.getFirst(KEY_ID));
}
if (form.containsKey(REQUEST_ID)) {
attributes.put(REQUEST_ID, form.getFirst(REQUEST_ID));
}
attributes.put(TRANS_WRAPPED_SESSION_KEY, form.getFirst(TRANS_WRAPPED_SESSION_KEY));
attributes.put(SESSION_WRAPPED_PASSPHRASE, form.getFirst(SESSION_WRAPPED_PASSPHRASE));
attributes.put(NONCE_DATA, form.getFirst(NONCE_DATA));
attributes.put(CERTIFICATE, form.getFirst(CERTIFICATE));
attributes.put(PASSPHRASE, form.getFirst(PASSPHRASE));
setClassName(getClass().getName());
}
private void setResponseDate(MultivaluedMap<String, Object> headers, boolean firstTry) {
if (!firstTry || headers.containsKey(HttpHeaders.DATE)) {
return;
}
SimpleDateFormat format = HttpUtils.getHttpDateFormat();
headers.putSingle(HttpHeaders.DATE, format.format(new Date()));
}
@Override
public void writeTo(
Object t,
Class<?> type,
Type genericType,
Annotation[] annotations,
MediaType mediaType,
MultivaluedMap<String, Object> httpHeaders,
OutputStream entityStream)
throws IOException, WebApplicationException {
RenderingContext context = (RenderingContext) ctx.get();
if (context instanceof WebRenderingContext) {
((WebRenderingContext) context).setup(requests.get());
}
ParsedTemplate template = cache.getTemplate(context, type);
// FIXME: Should we really do this?
httpHeaders.putSingle("Content-Type", "text/html; charset=utf-8");
if (!httpHeaders.containsKey("Expires")) {
httpHeaders.putSingle("Expires", -1);
}
TemplateOutputStream out = new HtmlTemplateOutput(entityStream);
renderer.render(context, template, t, out);
out.close();
}
private String getParamString(MultivaluedMap<String, String> params, String param) {
if (params.containsKey(param)) {
return params.getFirst(param);
} else {
return "";
}
}
/**
* Validates this descriptor based on the passed query parameters.
*
* @param queryParams parameters to validate against
* @throws ParameterValidationException when a validation fails
*/
public void validate(MultivaluedMap<String, String> queryParams)
throws ParameterValidationException {
if (!queryParams.containsKey(name)) {
// Check for mandatory property
if (isMandatory) {
throw new ParameterValidationException(name, i18n.tr("Required parameter."));
}
// If this parameter was not specified and is
// not mandatory there is nothing to validate.
return;
}
if (this.mustBeInt) {
validateInteger(queryParams.get(name));
}
if (this.dateFormat != null && !this.dateFormat.isEmpty()) {
validateDate(queryParams.get(name));
}
if (this.mustBeTimeZone) {
validateTimeZone(queryParams.get(name));
}
if (this.validators.size() > 0) {
verifyValidatorsPass(queryParams.get(name));
}
verifyMustHaves(queryParams);
verifyMustNotHaves(queryParams);
}
protected URI getUrl(final String name, final MultivaluedMap<String, String> data) {
URI uri = null;
if (data.containsKey(name)) {
uri = URI.create(data.getFirst(name));
}
return uri;
}
protected Sid getSid(final String name, final MultivaluedMap<String, String> data) {
Sid sid = null;
if (data.containsKey(name)) {
sid = new Sid(data.getFirst(name));
}
return sid;
}
protected String getMethod(final String name, final MultivaluedMap<String, String> data) {
String method = "POST";
if (data.containsKey(name)) {
method = data.getFirst(name);
}
return method;
}
protected String getApiVersion(final MultivaluedMap<String, String> data) {
String apiVersion = defaultApiVersion;
if (data != null && data.containsKey("ApiVersion")) {
apiVersion = data.getFirst("ApiVersion");
}
return apiVersion;
}
private Integer getTimeout(final MultivaluedMap<String, String> data) {
Integer result = 60;
if (data.containsKey("Timeout")) {
result = Integer.parseInt(data.getFirst("Timeout"));
}
return result;
}
private void verifyMustHaves(MultivaluedMap<String, String> queryParams) {
for (String paramToCheck : this.mustHaveParams) {
if (!queryParams.containsKey(paramToCheck)) {
throw new ParameterValidationException(
name, i18n.tr("Parameter must be used with {0}.", paramToCheck));
}
}
}
/**
* Mocks MultivaluedMap for post containin id
*
* @param id Id of post
* @return Map containing id
*/
protected static MultivaluedMap<String, String> createIdPost(String id) {
@SuppressWarnings("unchecked")
MultivaluedMap<String, String> map = mock(MultivaluedMap.class);
when(map.containsKey(FORM_ID)).thenReturn(true);
when(map.getFirst(FORM_ID)).thenReturn(id);
return map;
}
@Test
public void testParseQueryString() throws UnsupportedEncodingException {
String input = "a=b&a=c%2F&z=&x";
MultivaluedMap<String, String> map = interceptor.extractParameters(input);
assertTrue(map.containsKey("a"));
assertTrue(map.containsKey("x"));
assertTrue(map.containsKey("z"));
List<String> a = map.get("a");
assertTrue(a.contains("b"));
assertTrue(a.contains("c/"));
List<String> x = map.get("x");
assertTrue(x.contains(""));
List<String> z = map.get("z");
assertTrue(z.contains(""));
}
@PUT
@Path("{enlaceId}")
@Produces(MediaType.TEXT_XML)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public ResponseMessage update(
@PathParam("enlaceId") String enlaceId, MultivaluedMap<String, String> params)
throws RegistroNoEncontradoException, ParametrosObligatoriosException {
Enlace enlace = Enlace.getEnlace(Long.parseLong(enlaceId));
enlace.setOrden(Long.parseLong(getParamString(params, "orden")));
if (params.containsKey("ocw")) {
enlace.setOcw(true);
} else {
enlace.setOcw(false);
}
Set<EnlaceIdioma> enlacesIdiomas = enlace.getEnlacesIdiomas();
List<Idioma> idiomas = Idioma.getIdiomasEdicion();
boolean exists = false;
for (Idioma idioma : idiomas) {
String url = getParamString(params, "url__" + idioma.getAcronimo().toLowerCase());
String nombre = getParamString(params, "nombre__" + idioma.getAcronimo().toLowerCase());
String descripcion =
getParamString(params, "descripcion__" + idioma.getAcronimo().toLowerCase());
for (EnlaceIdioma enlaceIdioma : enlacesIdiomas) {
if (enlaceIdioma.getIdioma().getAcronimo().equals(idioma.getAcronimo())) {
enlaceIdioma.setUrl(url);
enlaceIdioma.setNombre(nombre);
enlaceIdioma.setDescripcion(descripcion);
exists = true;
break;
}
}
if (!exists) {
if (!url.equals("") || !nombre.equals("") || !descripcion.equals("")) {
EnlaceIdioma enlaceIdioma = new EnlaceIdioma();
enlaceIdioma.setUrl(url);
enlaceIdioma.setNombre(nombre);
enlaceIdioma.setDescripcion(descripcion);
enlaceIdioma.setIdioma(idioma);
enlaceIdioma.setEnlace(enlace);
enlacesIdiomas.add(enlaceIdioma);
}
}
exists = false;
}
enlace.setEnlacesIdiomas(enlacesIdiomas);
enlace.compruebaCamposObligatorios(idiomas.get(0).getAcronimo());
enlace.update();
return new ResponseMessage(true);
}
protected boolean getHasVoiceCallerIdLookup(final MultivaluedMap<String, String> data) {
boolean hasVoiceCallerIdLookup = false;
if (data.containsKey("VoiceCallerIdLookup")) {
final String value = data.getFirst("VoiceCallerIdLookup");
if ("true".equalsIgnoreCase(value)) {
return true;
}
}
return hasVoiceCallerIdLookup;
}
protected String removeParameter(
final MultivaluedMap<java.lang.String, java.lang.String> params, final String key) {
if (params.containsKey(key)) {
final String value = params.getFirst(key);
params.remove(key);
return value;
} else {
return null;
}
}
@Override
public Identity identity() throws IOException {
final MultivaluedMap<String, String> headers = this.resource.httpHeaders().getRequestHeaders();
Identity identity = Identity.ANONYMOUS;
if (headers.containsKey(Auth.HEADER_URN) && headers.containsKey(Auth.HEADER_TOKEN)) {
final URN urn = URN.create(headers.getFirst(Auth.HEADER_URN));
final User user = this.base.user(urn);
if (!user.exists()) {
throw new WebApplicationException(
Response.status(HttpURLConnection.HTTP_UNAUTHORIZED).build());
}
final String token = headers.getFirst(Auth.HEADER_TOKEN);
if (!user.token().equals(token)) {
throw new WebApplicationException(
Response.status(HttpURLConnection.HTTP_UNAUTHORIZED).build());
}
identity = new Identity.Simple(urn, "http", URI.create("#"));
}
return identity;
}
public Link getLocationLink() {
if (location != null) return location;
if (!headers.containsKey("Location")) return null;
String header = headers.getFirst("Location");
location = new Link();
location.setHref(header);
location.setExecutor(executor);
return location;
}
@GET
@Produces({MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF})
public Response get(final @Context UriInfo uriInfo) {
MultivaluedMap<String, String> params = uriInfo.getQueryParameters();
servlet.getMetrics().incrementRequests(1);
try {
CellSetModel model = new CellSetModel();
for (String rk : params.get(ROW_KEYS_PARAM_NAME)) {
RowSpec rowSpec = new RowSpec(rk);
if (this.versions != null) {
rowSpec.setMaxVersions(this.versions);
}
ResultGenerator generator =
ResultGenerator.fromRowSpec(
this.tableResource.getName(),
rowSpec,
null,
!params.containsKey(NOCACHE_PARAM_NAME));
Cell value = null;
RowModel rowModel = new RowModel(rk);
if (generator.hasNext()) {
while ((value = generator.next()) != null) {
rowModel.addCell(
new CellModel(
CellUtil.cloneFamily(value),
CellUtil.cloneQualifier(value),
value.getTimestamp(),
CellUtil.cloneValue(value)));
}
model.addRow(rowModel);
} else {
LOG.trace("The row : " + rk + " not found in the table.");
}
}
if (model.getRows().size() == 0) {
// If no rows found.
servlet.getMetrics().incrementFailedGetRequests(1);
return Response.status(Response.Status.NOT_FOUND)
.type(MIMETYPE_TEXT)
.entity("No rows found." + CRLF)
.build();
} else {
servlet.getMetrics().incrementSucessfulGetRequests(1);
return Response.ok(model).build();
}
} catch (Exception e) {
servlet.getMetrics().incrementFailedGetRequests(1);
return processException(e);
}
}
private void checkSecurityContextEnd(
ContainerRequestContext rc, MultivaluedMap<String, String> requestParams) {
String codeParam = requestParams.getFirst(OAuthConstants.AUTHORIZATION_CODE_VALUE);
SecurityContext sc = rc.getSecurityContext();
if (sc == null || sc.getUserPrincipal() == null) {
if (codeParam == null
&& requestParams.containsKey(OAuthConstants.ERROR_KEY)
&& !faultAccessDeniedResponses) {
if (!applicationCanHandleAccessDenied) {
String error = requestParams.getFirst(OAuthConstants.ERROR_KEY);
rc.abortWith(Response.ok(new AccessDeniedResponse(error)).build());
}
} else {
throw ExceptionUtils.toNotAuthorizedException(null, null);
}
}
}
public LinkHeader getLinkHeader() {
if (linkHeader != null) return linkHeader;
linkHeader = new LinkHeader();
if (!headers.containsKey("Link")) {
return linkHeader;
}
List<String> links = headers.get("Link");
LinkHeaderDelegate delegate = new LinkHeaderDelegate();
for (String link : links) {
LinkHeader tmp = delegate.fromString(link);
linkHeader.getLinks().addAll(tmp.getLinks());
linkHeader.getLinksByRelationship().putAll(tmp.getLinksByRelationship());
linkHeader.getLinksByTitle().putAll(tmp.getLinksByTitle());
}
for (Link link : linkHeader.getLinks()) {
link.setExecutor(executor);
}
return linkHeader;
}
@POST
@Produces(MediaType.TEXT_XML)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public UIEntity insertEnlace(MultivaluedMap<String, String> params)
throws ParametrosObligatoriosException {
Enlace enlace = new Enlace();
enlace.setOrden(Long.parseLong(getParamString(params, "orden")));
if (params.containsKey("ocw")) {
enlace.setOcw(true);
}
Set<EnlaceIdioma> enlacesIdiomas = new HashSet<EnlaceIdioma>();
List<Idioma> idiomas = Idioma.getIdiomasEdicion();
for (Idioma idioma : idiomas) {
String url = getParamString(params, "url__" + idioma.getAcronimo().toLowerCase());
String nombre = getParamString(params, "nombre__" + idioma.getAcronimo().toLowerCase());
String descripcion =
getParamString(params, "descripcion__" + idioma.getAcronimo().toLowerCase());
if (!url.equals("") || !nombre.equals("") || !descripcion.equals("")) {
EnlaceIdioma enlaceIdioma = new EnlaceIdioma();
enlaceIdioma.setUrl(url);
enlaceIdioma.setNombre(nombre);
enlaceIdioma.setDescripcion(descripcion);
enlaceIdioma.setIdioma(idioma);
enlaceIdioma.setEnlace(enlace);
enlacesIdiomas.add(enlaceIdioma);
}
}
enlace.setEnlacesIdiomas(enlacesIdiomas);
enlace.compruebaCamposObligatorios(idiomas.get(0).getAcronimo());
enlace = enlace.insert();
UIEntity entity = UIEntity.toUI(enlace);
return entity;
}
/**
* Obtain the specified action property. An action property can either contain a simple value or
* reference a link property. If it is the latter it will obtain the referenced value stored in
* the link property. e.g. GetEntities filter=myfilter and myfilter="CreditAcctNo eq '{Acc}'",
* Acc="CreditAcctNo" => filter=CreditAcctNo eq '{CreditAcctNo}'
*
* @param propertyName Action property name
* @param actionProperties Action properties
* @param queryParameters Query parameters (keys)
* @return Action property string
*/
protected static String getActionProperty(
String propertyName,
Properties actionProperties,
MultivaluedMap<String, String> queryParameters) {
Object propObj = actionProperties.get(propertyName);
if (propObj != null && propObj instanceof ActionPropertyReference) {
ActionPropertyReference propRef = (ActionPropertyReference) propObj;
Set<String> queryParamKeys = queryParameters.keySet();
if (queryParameters.containsKey(propRef.getKey())) {
return queryParameters.getFirst(propRef.getKey());
}
String key = "_";
for (String queryParamKey : queryParamKeys) {
if (!queryParamKey.startsWith("$")) { // Do not consider $filter, $select, etc.
key += "_" + queryParamKey;
}
}
return propRef.getProperty(key);
} else {
return actionProperties.get(propertyName).toString(); // e.g. fld eq '{code}'
}
}
@Override
public boolean containsKey(Object key) {
return delegate.containsKey(key);
}
@POST
@Path("/")
@Consumes("application/x-www-form-urlencoded")
@Produces("application/json")
public Response issueAccessToken(
@Context HttpServletRequest request, MultivaluedMap<String, String> paramMap)
throws OAuthSystemException {
try {
PrivilegedCarbonContext.startTenantFlow();
PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getThreadLocalCarbonContext();
carbonContext.setTenantId(MultitenantConstants.SUPER_TENANT_ID);
carbonContext.setTenantDomain(MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
HttpServletRequestWrapper httpRequest = new OAuthRequestWrapper(request, paramMap);
if (log.isDebugEnabled()) {
logAccessTokenRequest(httpRequest);
}
// extract the basic auth credentials if present in the request and use for
// authentication.
if (request.getHeader(OAuthConstants.HTTP_REQ_HEADER_AUTHZ) != null) {
try {
String[] clientCredentials =
EndpointUtil.extractCredentialsFromAuthzHeader(
request.getHeader(OAuthConstants.HTTP_REQ_HEADER_AUTHZ));
// The client MUST NOT use more than one authentication method in each request
if (paramMap.containsKey(OAuth.OAUTH_CLIENT_ID)
&& paramMap.containsKey(OAuth.OAUTH_CLIENT_SECRET)) {
return handleBasicAuthFailure();
}
// If a client sends an invalid base64 encoded clientid:clientsecret value, it results in
// this
// array to only contain 1 element. This happens on specific errors though.
if (clientCredentials.length != 2) {
return handleBasicAuthFailure();
}
// add the credentials available in Authorization header to the parameter map
paramMap.add(OAuth.OAUTH_CLIENT_ID, clientCredentials[0]);
paramMap.add(OAuth.OAUTH_CLIENT_SECRET, clientCredentials[1]);
} catch (OAuthClientException e) {
// malformed credential string is considered as an auth failure.
log.error("Error while extracting credentials from authorization header", e);
return handleBasicAuthFailure();
}
}
try {
CarbonOAuthTokenRequest oauthRequest = new CarbonOAuthTokenRequest(httpRequest);
// exchange the access token for the authorization grant.
OAuth2AccessTokenRespDTO oauth2AccessTokenResp = getAccessToken(oauthRequest);
// if there BE has returned an error
if (oauth2AccessTokenResp.getErrorMsg() != null) {
// if there is an auth failure, HTTP 401 Status Code should be sent back to the client.
if (OAuth2ErrorCodes.INVALID_CLIENT.equals(oauth2AccessTokenResp.getErrorCode())) {
return handleBasicAuthFailure();
} else if ("sql_error".equals(oauth2AccessTokenResp.getErrorCode())) {
return handleSQLError();
} else if (OAuth2ErrorCodes.SERVER_ERROR.equals(oauth2AccessTokenResp.getErrorCode())) {
return handleServerError();
} else {
// Otherwise send back HTTP 400 Status Code
OAuthResponse.OAuthErrorResponseBuilder oAuthErrorResponseBuilder =
OAuthASResponse.errorResponse(HttpServletResponse.SC_BAD_REQUEST)
.setError(oauth2AccessTokenResp.getErrorCode())
.setErrorDescription(oauth2AccessTokenResp.getErrorMsg());
OAuthResponse response = oAuthErrorResponseBuilder.buildJSONMessage();
ResponseHeader[] headers = oauth2AccessTokenResp.getResponseHeaders();
ResponseBuilder respBuilder = Response.status(response.getResponseStatus());
if (headers != null && headers.length > 0) {
for (int i = 0; i < headers.length; i++) {
if (headers[i] != null) {
respBuilder.header(headers[i].getKey(), headers[i].getValue());
}
}
}
return respBuilder.entity(response.getBody()).build();
}
} else {
OAuthTokenResponseBuilder oAuthRespBuilder =
OAuthASResponse.tokenResponse(HttpServletResponse.SC_OK)
.setAccessToken(oauth2AccessTokenResp.getAccessToken())
.setRefreshToken(oauth2AccessTokenResp.getRefreshToken())
.setExpiresIn(Long.toString(oauth2AccessTokenResp.getExpiresIn()))
.setTokenType(BEARER);
oAuthRespBuilder.setScope(oauth2AccessTokenResp.getAuthorizedScopes());
// OpenID Connect ID token
if (oauth2AccessTokenResp.getIDToken() != null) {
oAuthRespBuilder.setParam(OAuthConstants.ID_TOKEN, oauth2AccessTokenResp.getIDToken());
}
OAuthResponse response = oAuthRespBuilder.buildJSONMessage();
ResponseHeader[] headers = oauth2AccessTokenResp.getResponseHeaders();
ResponseBuilder respBuilder =
Response.status(response.getResponseStatus())
.header(
OAuthConstants.HTTP_RESP_HEADER_CACHE_CONTROL,
OAuthConstants.HTTP_RESP_HEADER_VAL_CACHE_CONTROL_NO_STORE)
.header(
OAuthConstants.HTTP_RESP_HEADER_PRAGMA,
OAuthConstants.HTTP_RESP_HEADER_VAL_PRAGMA_NO_CACHE);
if (headers != null && headers.length > 0) {
for (int i = 0; i < headers.length; i++) {
if (headers[i] != null) {
respBuilder.header(headers[i].getKey(), headers[i].getValue());
}
}
}
return respBuilder.entity(response.getBody()).build();
}
} catch (OAuthProblemException e) {
log.error("Error while creating the Carbon OAuth token request", e);
OAuthResponse res =
OAuthASResponse.errorResponse(HttpServletResponse.SC_BAD_REQUEST)
.error(e)
.buildJSONMessage();
return Response.status(res.getResponseStatus()).entity(res.getBody()).build();
}
} finally {
PrivilegedCarbonContext.endTenantFlow();
}
}
/**
* Updates the current state if Client method is invoked, otherwise does the remote invocation or
* returns a new proxy if subresource method is invoked. Can throw an expected exception if
* ResponseExceptionMapper is registered
*/
public Object invoke(Object o, Method m, Object[] params) throws Throwable {
Class<?> declaringClass = m.getDeclaringClass();
if (Client.class == declaringClass
|| InvocationHandlerAware.class == declaringClass
|| Object.class == declaringClass) {
return m.invoke(this, params);
}
resetResponse();
OperationResourceInfo ori = cri.getMethodDispatcher().getOperationResourceInfo(m);
if (ori == null) {
reportInvalidResourceMethod(m, "INVALID_RESOURCE_METHOD");
}
MultivaluedMap<ParameterType, Parameter> types = getParametersInfo(m, params, ori);
List<Parameter> beanParamsList = getParameters(types, ParameterType.BEAN);
int bodyIndex = getBodyIndex(types, ori);
List<Object> pathParams = getPathParamValues(m, params, types, beanParamsList, ori, bodyIndex);
UriBuilder builder = getCurrentBuilder().clone();
if (isRoot) {
addNonEmptyPath(builder, ori.getClassResourceInfo().getURITemplate().getValue());
}
addNonEmptyPath(builder, ori.getURITemplate().getValue());
handleMatrixes(m, params, types, beanParamsList, builder);
handleQueries(m, params, types, beanParamsList, builder);
URI uri = builder.buildFromEncoded(pathParams.toArray()).normalize();
MultivaluedMap<String, String> headers = getHeaders();
MultivaluedMap<String, String> paramHeaders = new MetadataMap<String, String>();
handleHeaders(m, params, paramHeaders, beanParamsList, types);
handleCookies(m, params, paramHeaders, beanParamsList, types);
if (ori.isSubResourceLocator()) {
ClassResourceInfo subCri = cri.getSubResource(m.getReturnType(), m.getReturnType());
if (subCri == null) {
reportInvalidResourceMethod(m, "INVALID_SUBRESOURCE");
}
MultivaluedMap<String, String> subHeaders = paramHeaders;
if (inheritHeaders) {
subHeaders.putAll(headers);
}
ClientState newState =
getState()
.newState(
uri, subHeaders, getTemplateParametersMap(ori.getURITemplate(), pathParams));
ClientProxyImpl proxyImpl =
new ClientProxyImpl(newState, proxyLoader, subCri, false, inheritHeaders);
proxyImpl.setConfiguration(getConfiguration());
return JAXRSClientFactory.createProxy(m.getReturnType(), proxyLoader, proxyImpl);
}
headers.putAll(paramHeaders);
getState().setTemplates(getTemplateParametersMap(ori.getURITemplate(), pathParams));
Object body = null;
if (bodyIndex != -1) {
body = params[bodyIndex];
if (body == null) {
bodyIndex = -1;
}
} else if (types.containsKey(ParameterType.FORM)) {
body = handleForm(m, params, types, beanParamsList);
} else if (types.containsKey(ParameterType.REQUEST_BODY)) {
body = handleMultipart(types, ori, params);
}
setRequestHeaders(
headers,
ori,
types.containsKey(ParameterType.FORM),
body == null ? null : body.getClass(),
m.getReturnType());
return doChainedInvocation(uri, headers, ori, body, bodyIndex, null, null);
}
protected void applyQueryFilters(
final MultivaluedMap<String, String> p, final CriteriaBuilder builder) {
final MultivaluedMap<String, String> params = new MultivaluedMapImpl();
params.putAll(p);
builder.distinct();
builder.limit(DEFAULT_LIMIT);
// not sure why we remove this, but that's what the old query filter code did, I presume there's
// a reason :)
params.remove("_dc");
if (params.containsKey("limit")) {
builder.limit(Integer.valueOf(params.getFirst("limit")));
params.remove("limit");
}
if (params.containsKey("offset")) {
builder.offset(Integer.valueOf(params.getFirst("offset")));
params.remove("offset");
}
// Is this necessary anymore? setLimitOffset() comments implies it's for Ext-JS.
if (params.containsKey("start")) {
builder.offset(Integer.valueOf(params.getFirst("start")));
params.remove("start");
}
if (params.containsKey("orderBy")) {
builder.orderBy(params.getFirst("orderBy"));
params.remove("orderBy");
if (params.containsKey("order")) {
if ("desc".equalsIgnoreCase(params.getFirst("order"))) {
builder.desc();
} else {
builder.asc();
}
params.remove("order");
}
}
final String query = removeParameter(params, "query");
if (query != null) builder.sql(query);
final String matchType;
final String match = removeParameter(params, "match");
if (match == null) {
matchType = "all";
} else {
matchType = match;
}
builder.match(matchType);
final Class<?> criteriaClass = builder.toCriteria().getCriteriaClass();
final BeanWrapper wrapper = getBeanWrapperForClass(criteriaClass);
final String comparatorParam = removeParameter(params, "comparator", "eq").toLowerCase();
final Criteria currentCriteria = builder.toCriteria();
for (final String key : params.keySet()) {
for (final String paramValue : params.get(key)) { // NOSONAR
// NOSONAR the interface of MultivaluedMap.class declares List<String> as return value,
// the actual implementation com.sun.jersey.core.util.MultivaluedMapImpl returns a String,
// so this is fine in some way ...
if ("null".equalsIgnoreCase(paramValue)) {
builder.isNull(key);
} else if ("notnull".equalsIgnoreCase(paramValue)) {
builder.isNotNull(key);
} else {
Object value;
Class<?> type = Object.class;
try {
type = currentCriteria.getType(key);
} catch (final IntrospectionException e) {
LOG.debug("Unable to determine type for key {}", key);
}
if (type == null) {
type = Object.class;
}
LOG.warn("comparator = {}, key = {}, propertyType = {}", comparatorParam, key, type);
if (comparatorParam.equals("contains")
|| comparatorParam.equals("iplike")
|| comparatorParam.equals("ilike")
|| comparatorParam.equals("like")) {
value = paramValue;
} else {
LOG.debug("convertIfNecessary({}, {})", key, paramValue);
try {
value = wrapper.convertIfNecessary(paramValue, type);
} catch (final Throwable t) {
LOG.debug("failed to introspect (key = {}, value = {})", key, paramValue, t);
value = paramValue;
}
}
try {
final Method m =
builder.getClass().getMethod(comparatorParam, String.class, Object.class);
m.invoke(builder, new Object[] {key, value});
} catch (final Throwable t) {
LOG.warn(
"Unable to find method for comparator: {}, key: {}, value: {}",
comparatorParam,
key,
value,
t);
}
}
}
}
}
private String verifyResponse(
Response resp, String content, int status, HashMap<String, String> expected_map)
throws Exception {
boolean pass = true;
StringBuffer sb = new StringBuffer();
sb.append("========== Verifying a Response with Map: " + newline);
String entity = (String) resp.getEntity();
if ((content == null) || (content == "")) {
if (!(resp.getEntity() == null) || (resp.getEntity() == "")) {
pass = false;
sb.append(
indent
+ "Entity verification failed: expecting no content, got "
+ (String) resp.getEntity()
+ newline);
}
} else if (!content.equals(((String) resp.getEntity()))) {
pass = false;
sb.append(
indent
+ "Entity verification failed: expecting "
+ content
+ ", got "
+ (String) resp.getEntity()
+ newline);
} else {
sb.append(
indent + "Correct content found in Response: " + (String) resp.getEntity() + newline);
}
if (resp.getStatus() != status) {
pass = false;
sb.append(
indent
+ "Status code verification failed: expecting "
+ status
+ ", got "
+ resp.getStatus()
+ newline);
} else {
sb.append(indent + "Correct status found in Response: " + status + newline);
}
MultivaluedMap<java.lang.String, java.lang.Object> mvp = resp.getMetadata();
if (expected_map == null) {
sb.append(
indent
+ "No keys to verify or expected, but found the following keys in Response:"
+ newline);
for (String key : mvp.keySet()) {
sb.append(indent + indent + "Key: " + key + "; " + mvp.getFirst(key) + ";" + newline);
}
} else {
for (String key_actual : mvp.keySet()) {
sb.append(indent + "Response contains key: " + key_actual + newline);
}
sb.append(indent + "Verifying the following keys in Response:" + newline);
String actual, expected = null;
for (Map.Entry<String, String> entry : expected_map.entrySet()) {
String key = entry.getKey();
if (!mvp.containsKey(key)) {
pass = false;
sb.append(indent + indent + "Key: " + key + " is not found in Response;" + newline);
} else if (key.equalsIgnoreCase("last-modified")) {
sb.append(indent + indent + "Key Last-Modified is found in response" + newline);
} else {
expected = entry.getValue().toLowerCase();
actual = mvp.getFirst(key).toString().toLowerCase();
if (actual.startsWith("\"") && actual.endsWith("\"")) {
actual = actual.substring(1, actual.length() - 1);
}
if (!actual.equals(expected)) {
pass = false;
sb.append(
indent
+ indent
+ "Key: "
+ key
+ " found in Response, but with different value;"
+ newline);
sb.append(
indent
+ indent
+ "Expecting "
+ entry.getValue()
+ "; got "
+ mvp.getFirst(key)
+ newline);
}
sb.append(
indent
+ indent
+ "Processed key "
+ key
+ " with expected value "
+ entry.getValue()
+ newline);
}
}
}
sb.append(indent + pass);
return sb.toString();
}