net.sf.jasperreports.dataadapters.http.HttpDataService Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jasperreports-data-adapters-http Show documentation
Show all versions of jasperreports-data-adapters-http Show documentation
JasperReports Data Adapters HTTP
The newest version!
/*
* JasperReports - Free Java Reporting Library.
* Copyright (C) 2001 - 2023 Cloud Software Group, Inc. All rights reserved.
* http://www.jaspersoft.com
*
* Unless you have purchased a commercial license agreement from Jaspersoft,
* the following license terms apply:
*
* This program is part of JasperReports.
*
* JasperReports is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* JasperReports is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with JasperReports. If not, see parameters) throws JRException
{
CloseableHttpClient httpClient = createHttpClient(parameters);
HttpRequestBase request = createRequest(parameters);
return new HttpDataConnection(httpClient, request);
}
protected CloseableHttpClient createHttpClient(Map parameters)
{
HttpClientBuilder clientBuilder = HttpClients.custom();
// single connection
BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager();
clientBuilder.setConnectionManager(connManager);
// ignore cookies for now
RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.IGNORE_COOKIES).build();
clientBuilder.setDefaultRequestConfig(requestConfig);
setAuthentication(parameters, clientBuilder);
CloseableHttpClient client = clientBuilder.build();
return client;
}
protected void setAuthentication(Map parameters, HttpClientBuilder clientBuilder)
{
String username = getUsername(parameters);
if (username != null)
{
String password = getPassword(parameters);
BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
//FIXME proxy authentication?
credentialsProvider.setCredentials(
new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT),
new UsernamePasswordCredentials(username, password));
clientBuilder.setDefaultCredentialsProvider(credentialsProvider);
}
}
protected String getUsername(Map parameters)
{
String username = getPropertyOrParameterValue(PROPERTY_USERNAME, PARAMETER_USERNAME, parameters);
if (username == null)
{
username = dataLocation.getUsername();
}
return username;
}
protected String getPassword(Map parameters)
{
String password = getPropertyOrParameterValue(PROPERTY_PASSWORD, PARAMETER_PASSWORD, parameters);
if (password == null)
{
password = dataLocation.getPassword();
}
if (password != null)
{
SecretsUtil secrets = SecretsUtil.getInstance(context.getJasperReportsContext());
password = secrets.getSecret(AbstractDataAdapterService.SECRETS_CATEGORY, password);
}
return password;
}
protected HttpRequestBase createRequest(Map parameters)
{
URI requestURI = getRequestURI(parameters);
RequestMethod method = getMethod(parameters);
String body = getBody(parameters);
List postParameters = collectPostParameters(parameters);
if (method == null)
{
method = (body == null && postParameters.isEmpty()) ? RequestMethod.GET : RequestMethod.POST;
}
HttpRequestBase request;
switch (method)
{
case GET:
if (body != null)
{
log.warn("Ignoring request body for GET request to " + dataLocation.getUrl());
}
if (!postParameters.isEmpty())
{
log.warn("Ignoring POST parameters for GET request to " + dataLocation.getUrl());
}
request = createGetRequest(requestURI);
break;
case POST:
if (body == null)
{
request = createPostRequest(requestURI, postParameters);
}
else
{
if (!postParameters.isEmpty())
{
log.warn("Ignoring POST parameters for POST request having request body to " + dataLocation.getUrl());
}
request = createPostRequest(requestURI, body);
}
break;
case PUT:
if (body == null)
{
request = createPutRequest(requestURI, postParameters);
}
else
{
if (!postParameters.isEmpty())
{
log.warn("Ignoring POST parameters for PUT request having request body to " + dataLocation.getUrl());
}
request = createPutRequest(requestURI, body);
}
break;
default:
throw
new JRRuntimeException(
EXCEPTION_MESSAGE_KEY_UNKNOWN_REQUEST_METHOD,
new Object[]{method});
}
List headers = collectHeaders(parameters);
if (headers != null)
{
for (NameValuePair header : headers)
{
request.addHeader(header.getName(), header.getValue());
}
}
return request;
}
protected HttpGet createGetRequest(URI requestURI)
{
HttpGet httpGet = new HttpGet(requestURI);
return httpGet;
}
protected HttpPost createPostRequest(URI requestURI, String body)
{
HttpPost httpPost = new HttpPost(requestURI);
HttpEntity entity = createRequestEntity(body);
httpPost.setEntity(entity);
return httpPost;
}
protected HttpPost createPostRequest(URI requestURI, List postParameters)
{
HttpPost httpPost = new HttpPost(requestURI);
HttpEntity entity = createRequestEntity(postParameters);
httpPost.setEntity(entity);
return httpPost;
}
protected HttpPut createPutRequest(URI requestURI, String body)
{
HttpPut httpPost = new HttpPut(requestURI);
HttpEntity entity = createRequestEntity(body);
httpPost.setEntity(entity);
return httpPost;
}
protected HttpPut createPutRequest(URI requestURI, List postParameters)
{
HttpPut httpPost = new HttpPut(requestURI);
HttpEntity entity = createRequestEntity(postParameters);
httpPost.setEntity(entity);
return httpPost;
}
protected HttpEntity createRequestEntity(String body)
{
return new StringEntity(body, "UTF-8");//allow custom?
}
protected HttpEntity createRequestEntity(List postParameters)
{
UrlEncodedFormEntity formEntity;
try
{
formEntity = new UrlEncodedFormEntity(postParameters, "UTF-8");//allow custom?
}
catch (UnsupportedEncodingException e)
{
// should not happen
throw new JRRuntimeException(e);
}
return formEntity;
}
protected List collectUrlParameters(Map reportParameters)
{
return collectParameters(dataLocation.getUrlParameters(), reportParameters, PROPERTY_URL_PARAMETER, PARAMETER_PREFIX_URL_PARAMETER);
}
protected List collectPostParameters(Map reportParameters)
{
return collectParameters(dataLocation.getPostParameters(), reportParameters, PROPERTY_POST_PARAMETER, PARAMETER_PREFIX_POST_PARAMETER);
}
protected List collectHeaders(Map reportParameters)
{
return collectParameters(dataLocation.getHeaders(), reportParameters, PROPERTY_HEADER, null);
}
protected List collectParameters(
List dataAdapterParameters,
Map parameterValues,
String propertyName,
String parameterPrefix
)
{
List postParameters = new ArrayList<>();
Map requestParamMappings = new HashMap<>();
if (
context.getDataset() != null
&& context.getDataset().getParameters() != null
)
{
for (JRParameter parameter : context.getDataset().getParameters())
{
if (
parameter.hasProperties()
&& parameter.getPropertiesMap().containsProperty(propertyName)
)
{
String requestParamName = parameter.getPropertiesMap().getProperty(propertyName);
if (requestParamName == null)
{
requestParamName = parameter.getName();
}
requestParamMappings.put(requestParamName, parameter.getName());
}
}
}
if (dataAdapterParameters != null && !dataAdapterParameters.isEmpty())
{
for (HttpLocationParameter dataAdapterParameter : dataAdapterParameters)
{
String dataAdapterParamName = dataAdapterParameter.getName();
String paramValue = dataAdapterParameter.getValue();
if (paramValue != null)
{
String prefixConventionParamName = parameterPrefix == null ? null : (parameterPrefix + dataAdapterParamName);
String mappedParamName = requestParamMappings.get(dataAdapterParamName);
if (
(prefixConventionParamName != null
&& parameterValues.containsKey(prefixConventionParamName))
|| (requestParamMappings.containsKey(dataAdapterParamName)
&& parameterValues.containsKey(mappedParamName))
)
{
if (log.isDebugEnabled())
{
log.debug("data adapter parameter " + dataAdapterParamName + " overridden by the report");
}
}
else
{
if (log.isDebugEnabled())
{
log.debug("adding parameter " + dataAdapterParamName + " with value " + paramValue);
}
postParameters.add(new BasicNameValuePair(dataAdapterParamName, paramValue));
}
}
}
}
if (parameterPrefix != null)
{
for (Entry paramEntry : parameterValues.entrySet())
{
String paramName = paramEntry.getKey();
Object value = paramEntry.getValue();
if (paramName.startsWith(parameterPrefix))
{
String requestParamName = paramName.substring(parameterPrefix.length(), paramName.length());
String mappedParamName = requestParamMappings.get(requestParamName);
if (
value != null
&& (!requestParamMappings.containsKey(requestParamName)
|| !parameterValues.containsKey(mappedParamName))
)
{
String paramValue = toHttpParameterValue(value);
if (log.isDebugEnabled())
{
log.debug("adding parameter " + requestParamName + " with value " + paramValue);
}
postParameters.add(new BasicNameValuePair(requestParamName, paramValue));
}
else
{
if (log.isDebugEnabled())
{
log.debug("prefix convention parameter " + requestParamName + " overridden by the property mapped parameter");
}
}
}
}
}
if (
context.getDataset() != null
&& context.getDataset().getParameters() != null
)
{
// here, loop through dataset parameters and not through requestParamMappings because we want to support request parameter arrays
// by allowing multiple dataset parameters to provide value for the same request parameter
for (JRParameter parameter : context.getDataset().getParameters())
{
if (
parameter.hasProperties()
&& parameter.getPropertiesMap().containsProperty(propertyName)
)
{
String requestParamName = parameter.getPropertiesMap().getProperty(propertyName);
if (requestParamName == null)
{
requestParamName = parameter.getName();
}
String paramName = parameter.getName();
if (parameterValues.containsKey(paramName))
{
Object value = parameterValues.get(paramName);
String paramValue = toHttpParameterValue(value);
if (log.isDebugEnabled())
{
log.debug("adding parameter " + requestParamName + " with value " + paramValue);
}
postParameters.add(new BasicNameValuePair(requestParamName, paramValue));
}
}
}
}
return postParameters;
}
protected URI getRequestURI(Map parameters)
{
String url = getURL(parameters);
if (url == null)
{
throw
new JRRuntimeException(
EXCEPTION_MESSAGE_KEY_NO_HTTP_URL_SET,
(Object[])null);
}
try
{
URIBuilder uriBuilder = new URIBuilder(url);
List urlParameters = collectUrlParameters(parameters);
if (!urlParameters.isEmpty())
{
uriBuilder.addParameters(urlParameters);
}
URI uri = uriBuilder.build();
if (log.isDebugEnabled())
{
log.debug("request URI " + uri);
}
return uri;
}
catch (URISyntaxException e)
{
throw new JRRuntimeException(e);
}
}
protected String getURL(Map parameters)
{
String url = getPropertyOrParameterValue(PROPERTY_URL, PARAMETER_URL, parameters);
if (url == null)
{
url = dataLocation.getUrl();
}
return url;
}
protected RequestMethod getMethod(Map parameters)
{
String method = getPropertyOrParameterValue(PROPERTY_METHOD, null, parameters);
return method != null ? RequestMethod.valueOf(method.toUpperCase()) : dataLocation.getMethod();
}
protected String getBody(Map parameters)
{
String body = getPropertyOrParameterValue(PROPERTY_BODY, null, parameters);
if (body == null)
{
body = dataLocation.getBody();
}
return body;
}
protected String getPropertyOrParameterValue(String propName, String paramName, Map parameterValues)
{
String value = null;
JRDataset dataset = context.getDataset();
if (dataset != null && dataset.hasProperties())
{
value = JRPropertiesUtil.getOwnProperty(dataset, propName);
}
if (paramName != null && parameterValues.containsKey(paramName))//FIXMEDATAADAPTER should we fallback to prop name used as param name?
{
value = (String) parameterValues.get(paramName);
}
if (dataset != null)
{
JRParameter[] parameters = dataset.getParameters();
if (parameters != null)
{
for (JRParameter parameter : parameters)
{
if (
parameter.hasProperties()
&& parameter.getPropertiesMap().containsProperty(propName)
&& parameterValues.containsKey(parameter.getName())
)
{
value = (String)parameterValues.get(parameter.getName());
}
}
}
}
return value;
}
protected String toHttpParameterValue(Object value)
{
return String.valueOf(value);//FIXME do something smarter than String.valueOf
}
}