use of com.okta.sdk.http.HttpMethod in project okta-sdk-java by okta.
the class HttpClientRequestFactory method createHttpClientRequest.
/**
* Creates an HttpClient method object based on the specified request and
* populates any parameters, headers, etc. from the original request.
*
* @param request The request to convert to an HttpClient method object.
* @param previousEntity The optional, previous HTTP entity to reuse in the new request.
* @return The converted HttpClient method object with any parameters,
* headers, etc. from the original request set.
*/
HttpRequestBase createHttpClientRequest(Request request, HttpEntity previousEntity) {
HttpMethod method = request.getMethod();
URI uri = getFullyQualifiedUri(request);
InputStream body = request.getBody();
long contentLength = request.getHeaders().getContentLength();
HttpRequestBase base;
switch(method) {
case DELETE:
base = new HttpDelete(uri);
break;
case GET:
base = new HttpGet(uri);
break;
case HEAD:
base = new HttpHead(uri);
break;
case POST:
base = new HttpPost(uri);
((HttpEntityEnclosingRequestBase) base).setEntity(new RepeatableInputStreamEntity(request));
break;
case PUT:
base = new HttpPut(uri);
// Enable 100-continue support for PUT operations, since this is where we're potentially uploading
// large amounts of data and want to find out as early as possible if an operation will fail. We
// don't want to do this for all operations since it will cause extra latency in the network
// interaction.
base.setConfig(RequestConfig.copy(defaultRequestConfig).setExpectContinueEnabled(true).build());
if (previousEntity != null) {
((HttpEntityEnclosingRequestBase) base).setEntity(previousEntity);
} else if (body != null) {
HttpEntity entity = new RepeatableInputStreamEntity(request);
if (contentLength < 0) {
entity = newBufferedHttpEntity(entity);
}
((HttpEntityEnclosingRequestBase) base).setEntity(entity);
}
break;
default:
throw new IllegalArgumentException("Unrecognized HttpMethod: " + method);
}
base.setProtocolVersion(HttpVersion.HTTP_1_1);
applyHeaders(base, request);
return base;
}
use of com.okta.sdk.http.HttpMethod in project okta-sdk-java by okta.
the class DefaultDataStore method save.
@SuppressWarnings("unchecked")
private <T extends Resource, R extends Resource> R save(String href, final T resource, final T parentResource, HttpHeaders requestHeaders, final Class<? extends R> returnType, final QueryString qs, final boolean create) {
Assert.hasText(href, "href argument cannot be null or empty.");
Assert.notNull(resource, "resource argument cannot be null.");
Assert.notNull(returnType, "returnType class cannot be null.");
Assert.isInstanceOf(AbstractResource.class, resource);
Assert.isTrue(!CollectionResource.class.isAssignableFrom(resource.getClass()), "Collections cannot be persisted.");
final CanonicalUri uri = canonicalize(href, qs);
final AbstractResource abstractResource = (AbstractResource) resource;
// Most Okta endpoints do not support partial update, we can revisit in the future.
final Map<String, Object> props = resourceConverter.convert(abstractResource, false);
FilterChain chain = new DefaultFilterChain(this.filters, req -> {
CanonicalUri uri1 = req.getUri();
String href1 = uri1.getAbsolutePath();
QueryString qs1 = uri1.getQuery();
HttpHeaders httpHeaders = req.getHttpHeaders();
// if this is an Okta user, we must use a PUT and not a POST
HttpMethod method = HttpMethod.POST;
if (!create) {
method = HttpMethod.PUT;
}
InputStream body;
long length = 0;
if (resource instanceof VoidResource) {
body = new ByteArrayInputStream(new byte[0]);
} else {
ByteArrayOutputStream bodyOut = new ByteArrayOutputStream();
mapMarshaller.marshal(bodyOut, req.getData());
body = new ByteArrayInputStream(bodyOut.toByteArray());
length = bodyOut.size();
}
Request request = new DefaultRequest(method, href1, qs1, httpHeaders, body, length);
Response response = execute(request);
Map<String, Object> responseBody = getBody(response);
if (Collections.isEmpty(responseBody)) {
// Okta response with 200 for deactivate requests (i.e. /api/v1/apps/<id>/lifecycle/deactivate)
if (response.getHttpStatus() == 202 || response.getHttpStatus() == 200 || response.getHttpStatus() == 204) {
// 202 means that the request has been accepted for processing, but the processing has not been completed. Therefore we do not have a response body.
responseBody = java.util.Collections.emptyMap();
} else {
throw new IllegalStateException("Unable to obtain resource data from the API server.");
}
}
ResourceAction responseAction = getPostAction(req, response);
return new DefaultResourceDataResult(responseAction, uri1, returnType, responseBody);
});
ResourceAction action = create ? ResourceAction.CREATE : ResourceAction.UPDATE;
ResourceDataRequest request = new DefaultResourceDataRequest(action, uri, canonicalizeParent(parentResource), returnType, getResourceClass(parentResource), props, requestHeaders);
ResourceDataResult result = chain.filter(request);
Map<String, Object> data = result.getData();
// ensure the caller's argument is updated with what is returned from the server if the types are the same:
if (returnType.isAssignableFrom(abstractResource.getClass())) {
abstractResource.setInternalProperties(data);
}
return resourceFactory.instantiate(returnType, data);
}
Aggregations