return;
}
issuer = issuer.replaceAll("\\s+", "").toUpperCase();
- Enumeration hdrs = request.getHeaders(CertUtil.AAF_USER_CHAIN_HDR);
+ Enumeration<String> hdrs = request.getHeaders(CertUtil.AAF_USER_CHAIN_HDR);
while (hdrs.hasMoreElements()) {
String headerValue = (String) hdrs.nextElement();
LOGGER.debug("authorizationFilter user chain headerValue=" + headerValue);
}
metricLog.pre(eventName, aaiEvent, transactionId, serviceName);
- HttpEntity httpEntity = new HttpEntity(aaiEvent, httpHeaders);
+ HttpEntity<String> httpEntity = new HttpEntity<String>(aaiEvent, httpHeaders);
String transportType = environment.getProperty("dmaap.ribbon.transportType", "http");
String baseUrl = transportType + "://" + environment.getProperty("dmaap.ribbon.listOfServers");
Class<?> resultClass = null;
Object resultObject = this.getValue(name);
if (resultObject instanceof JSONArray) {
- resultClass = ((List) resultObject).get(0).getClass();
+ resultClass = ((List<?>) resultObject).get(0).getClass();
}
return resultClass;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
+import java.util.Set;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
DatabaseMapping mapping = cd.getMappingForAttributeName(propName);
Map<PropertyMetadata, String> result = new HashMap<>();
if (mapping != null) {
- Set<Entry> entrySet = mapping.getProperties().entrySet();
- for (Entry<?, ?> entry : entrySet) {
+ Set<Map.Entry<String, String>> entrySet = mapping.getProperties().entrySet();
+ for (Entry<String, String> entry : entrySet) {
result.put(
- PropertyMetadata.valueOf(
- CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, (String) entry.getKey())),
- (String) entry.getValue());
+ PropertyMetadata
+ .valueOf(CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, entry.getKey())),
+ entry.getValue());
}
}
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.ws.rs.core.MultivaluedMap;
List<Vertex> results = uriQuery.getQueryBuilder().toList();
if (results.size() == 1) {
Vertex otherVertex = results.get(0);
- VertexProperty otherVProperty = otherVertex.property("aai-node-type");
+ VertexProperty<Object> otherVProperty = otherVertex.property("aai-node-type");
if (otherVProperty.isPresent()) {
httpHeaders.put("Content-Type", "application/json");
List<String> violations = new ArrayList<>();
- ResponseEntity responseEntity;
+ ResponseEntity<String> responseEntity;
try {
responseEntity = validationRestClient.execute(VALIDATION_ENDPOINT, HttpMethod.POST, httpHeaders, body);
return violations;
}
- boolean isSuccess(ResponseEntity responseEntity) {
+ boolean isSuccess(ResponseEntity<String> responseEntity) {
return responseEntity != null && responseEntity.getStatusCode().is2xxSuccessful();
}
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Path;
protected void executeQuery() {
- Admin admin;
+ Admin<Vertex, Vertex> admin;
if (start != null) {
this.completeTraversal = traversal.asAdmin();
} else {
* @return the response
*/
public Response runner(String toe, String tba, String tdl, HttpHeaders headers, UriInfo info, HttpMethod httpMethod,
- Callable c) {
+ Callable<Response> c) {
Response response = null;
Future<Response> handler = null;
ExecutorService executor = null;
throws IllegalArgumentException, SecurityException, UnsupportedEncodingException, AAIException {
HashMap<String, Introspector> relatedVertices = new HashMap<>();
- VertexProperty aaiUriProperty = v.property(AAIProperties.AAI_URI);
+ VertexProperty<Object> aaiUriProperty = v.property(AAIProperties.AAI_URI);
if (!aaiUriProperty.isPresent()) {
if (LOGGER.isDebugEnabled()) {
throw new AAIException("AAI_6136",
"query object mismatch: this object cannot hold multiple items." + obj.getDbName());
} else if (obj.isContainer()) {
- final List getList;
+ final List<Object> getList;
String listProperty = null;
for (String property : obj.getProperties()) {
if (obj.isListType(property) && obj.isComplexGenericType(property)) {
throws UnsupportedEncodingException, AAIException {
List<Object> relationshipObjList = obj.getValue(RELATIONSHIP);
- VertexProperty nodeTypeProperty = v.property(AAIProperties.NODE_TYPE);
+ VertexProperty<Object> nodeTypeProperty = v.property(AAIProperties.NODE_TYPE);
if (!nodeTypeProperty.isPresent()) {
LOGGER.warn("Not processing the vertex {} because its missing required property aai-node-type", v.id());
private Object processEdgeRelationship(Introspector relationshipObj, Vertex cousin, String cleanUp,
String edgeLabel, boolean isSkipRelatedTo) throws UnsupportedEncodingException, AAIUnknownObjectException {
- VertexProperty aaiUriProperty = cousin.property("aai-uri");
+ VertexProperty<Object> aaiUriProperty = cousin.property("aai-uri");
if (!aaiUriProperty.isPresent()) {
return null;
return null;
}
- VertexProperty cousinVertexNodeType = cousin.property(AAIProperties.NODE_TYPE);
+ VertexProperty<Object> cousinVertexNodeType = cousin.property(AAIProperties.NODE_TYPE);
if (cousinVertexNodeType.isPresent()) {
String cousinType = cousinVertexNodeType.value().toString();
package org.onap.aai.serialization.queryformats;
-import com.google.gson.*;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
import java.io.UnsupportedEncodingException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
return Optional.of(json);
}
- private Optional<JsonArray> processInput(Object input, Map properties) throws AAIFormatVertexException {
+ private Optional<JsonArray> processInput(Object input, Map<String, List<String>> properties)
+ throws AAIFormatVertexException {
JsonArray json = new JsonArray();
for (Object l : (ArrayList) input) {
if (l instanceof ArrayList) {
*/
private void removePrivateEdges(JsonObject jsonObject, JsonObject edges, String edgeDirection) {
- Iterator it = edges.entrySet().iterator();
+ Iterator<Map.Entry<String, JsonElement>> it = edges.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, JsonElement> outEntry = (Map.Entry<String, JsonElement>) it.next();
JsonArray edgePropertiesArray = outEntry.getValue().getAsJsonArray();
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import org.apache.tinkerpop.gremlin.structure.*;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import org.onap.aai.db.props.AAIProperties;
import org.onap.aai.introspection.Loader;
import org.onap.aai.serialization.db.DBSerializer;
protected JsonObject createMetaPropertiesObject(VertexProperty<Object> prop) {
JsonObject json = new JsonObject();
- Iterator iter = prop.properties();
+ Iterator<Property<Object>> iter = prop.properties();
while (iter.hasNext()) {
- Property<Object> metaProp = (Property) iter.next();
+ Property<Object> metaProp = iter.next();
mapPropertyValues(json, metaProp.key(), metaProp.value());
}
@Override
protected void addEdge(Edge e, Vertex v, JsonArray array) throws AAIFormatVertexException {
- Property property = e.property("private");
+ Property<Object> property = e.property("private");
if (property.isPresent()) {
if ("true".equals(e.property("private").value().toString())) {
import com.google.gson.JsonParser;
import java.io.UnsupportedEncodingException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
// DSL Query
if (o instanceof BulkSet) {
- BulkSet bs = (BulkSet) o;
- for (Object o1 : bs) {
- Optional<JsonObject> obj = this.getJsonFromVertex((Vertex) o1);
+ BulkSet<Vertex> bs = (BulkSet<Vertex>) o;
+ for (Vertex o1 : bs) {
+ Optional<JsonObject> obj = this.getJsonFromVertex(o1);
if (obj.isPresent()) {
jsonObject = obj.get();
for (Map.Entry<String, JsonElement> mapEntry : jsonObject.entrySet()) {
* @return the list
* @throws Exception the exception
*/
- private <T> List<T> mapJsonToObjectList(T typeDef, String json, Class clazz) throws Exception {
+ private <T> List<T> mapJsonToObjectList(T typeDef, String json, Class<?> clazz) throws Exception {
List<T> list;
ObjectMapper mapper = new ObjectMapper();
System.out.println(json);
String validationResponse =
PayloadUtil.getResourcePayload("prevalidation/success-response-with-empty-violations.json");
- ResponseEntity responseEntity = Mockito.mock(ResponseEntity.class, Mockito.RETURNS_DEEP_STUBS);
+ ResponseEntity<String> responseEntity = Mockito.mock(ResponseEntity.class, Mockito.RETURNS_DEEP_STUBS);
Mockito.when(restClient.execute(eq(ValidationService.VALIDATION_ENDPOINT), eq(HttpMethod.POST), any(),
eq(pserverRequest))).thenReturn(responseEntity);
import java.util.List;
import java.util.concurrent.Callable;
-import javax.ws.rs.core.*;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
import org.junit.Assert;
import org.junit.BeforeClass;
public class RESTAPITest extends AAISetup {
private static RESTAPI restapi;
private static HttpHeaders httpHeaders;
- private static Callable callable;
+ private static Callable<Response> callable;
private static UriInfo info;
private static Response response;
package org.onap.aai.serialization.db;
import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
import org.janusgraph.core.JanusGraphFactory;
-import org.junit.*;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@Test
public void cascadeL3NetworkPreventDeleteTest() throws AAIException, UnsupportedEncodingException {
l3NetworkSetup();
- ArrayList expected_messages = new ArrayList<String>();
+ ArrayList<String> expected_messages = new ArrayList<>();
expected_messages.add(
"Object is being reference by additional objects preventing it from being deleted. Please clean up references from the following types [l3-interface-ipv4-address-list, l3-interface-ipv6-address-list]");
expected_messages.add(
package org.onap.aai.serialization.queryformats;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
FormatFactory ff =
new FormatFactory(loader, serializer, schemaVersions, basePath, "https://localhost:8447/aai/");
- MultivaluedMap mvm = new MultivaluedHashMap();
+ MultivaluedMap<String, String> mvm = new MultivaluedHashMap<>();
mvm.add("depth", "0");
Formatter formatter = ff.get(Format.resource, mvm);
FormatFactory ff =
new FormatFactory(loader, serializer, schemaVersions, basePath, "https://localhost:8447/aai/");
- MultivaluedMap mvm = new MultivaluedHashMap();
+ MultivaluedMap<String, String> mvm = new MultivaluedHashMap<>();
mvm.add("depth", "0");
Formatter formatter = ff.get(Format.simple, mvm);
public static final String BUSINESS_PROCESS_ERROR = "500";
public static final String UNKNOWN_ERROR = "900";
- public static final Map<String, String> responseMap = new HashMap();
+ public static final Map<String, String> responseMap = new HashMap<>();
// Specific Log Event Fields
public static enum LoggingField {
* @return response of request
* @throws RestClientException on internal rest template exception or invalid url
*/
- public ResponseEntity execute(String uri, HttpMethod method, Map<String, String> headers, String body)
+ public ResponseEntity<String> execute(String uri, HttpMethod method, Map<String, String> headers, String body)
throws RestClientException {
HttpEntity<String> httpEntity;
throw new RestClientException(e.getMessage());
}
log.debug("METHOD={}, URL={}, BODY={}", method, url, httpEntity.getBody());
- ResponseEntity responseEntity = getRestTemplate().exchange(url, method, httpEntity, String.class);
+ ResponseEntity<String> responseEntity = getRestTemplate().exchange(url, method, httpEntity, String.class);
log.trace("RESPONSE={}", responseEntity);
return responseEntity;
}
* @return response of request
* @throws RestClientException on internal rest template exception or invalid url
*/
- public ResponseEntity execute(String uri, String method, Map<String, String> headers, String body)
+ public ResponseEntity<String> execute(String uri, String method, Map<String, String> headers, String body)
throws RestClientException {
return execute(uri, HttpMethod.valueOf(method), headers, body);
}
* @return response of request
* @throws RestClientException on internal rest template exception or invalid url
*/
- public ResponseEntity execute(String uri, HttpMethod method, Map<String, String> headers)
+ public ResponseEntity<String> execute(String uri, HttpMethod method, Map<String, String> headers)
throws RestClientException {
return execute(uri, method, headers, null);
}
* @return response of request
* @throws RestClientException on internal rest template exception or invalid url
*/
- public ResponseEntity execute(String uri, String method, Map<String, String> headers) throws RestClientException {
+ public ResponseEntity<String> execute(String uri, String method, Map<String, String> headers)
+ throws RestClientException {
return execute(uri, HttpMethod.valueOf(method), headers, null);
}
- public ResponseEntity executeResource(String uri, HttpMethod method, Map<String, String> headers, String body)
- throws RestClientException {
+ public ResponseEntity<Resource> executeResource(String uri, HttpMethod method, Map<String, String> headers,
+ String body) throws RestClientException {
- HttpEntity httpEntity;
+ HttpEntity<String> httpEntity;
log.debug("Headers: " + headers.toString());
if (body == null) {
httpEntity = new HttpEntity(getHeaders(headers));
return getRestTemplate().exchange(url, method, httpEntity, Resource.class);
}
- public ResponseEntity getGetRequest(String content, String uri, Map<String, String> headersMap) {
+ public ResponseEntity<String> getGetRequest(String content, String uri, Map<String, String> headersMap) {
return this.execute(uri, HttpMethod.GET, headersMap, content);
}
- public ResponseEntity getGetResource(String content, String uri, Map<String, String> headersMap) {
+ public ResponseEntity<Resource> getGetResource(String content, String uri, Map<String, String> headersMap) {
return this.executeResource(uri, HttpMethod.GET, headersMap, content);
}
package org.onap.aai.restclient;
-import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.config.ServiceLocatorFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RestClientFactoryConfiguration {
+ // ServiceLocatorFactoryBean
@Bean
- public FactoryBean restClientFactoryBean() {
+ public ServiceLocatorFactoryBean restClientFactoryBean() {
ServiceLocatorFactoryBean factoryBean = new ServiceLocatorFactoryBean();
factoryBean.setServiceLocatorInterface(RestClientFactory.class);
return factoryBean;
}
@Override
- public ResponseEntity execute(String uri, HttpMethod method, Map<String, String> headers, String body) {
+ public ResponseEntity<String> execute(String uri, HttpMethod method, Map<String, String> headers, String body) {
String url = "https://localhost:8447/aai/v14/" + uri;
headersMap.add("X-FromAppId", "JUNIT");
headersMap.add("X-TransactionId", "JUNIT");
- HttpEntity httpEntity = new HttpEntity(headers);
+ HttpEntity<String> httpEntity = new HttpEntity(headers);
- ResponseEntity responseEntity = restTemplate.exchange(url, HttpMethod.GET, httpEntity, String.class);
+ ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, httpEntity, String.class);
// mockRestServiceServer.verify();
return responseEntity;
}
@Override
- public ResponseEntity executeResource(String uri, HttpMethod method, Map<String, String> headers, String body) {
+ public ResponseEntity<Resource> executeResource(String uri, HttpMethod method, Map<String, String> headers,
+ String body) {
String url = "https://localhost:8447/aai/v14/" + uri;
headersMap.add("X-FromAppId", "JUNIT");
headersMap.add("X-TransactionId", "JUNIT");
- HttpEntity httpEntity = new HttpEntity(headers);
+ HttpEntity<String> httpEntity = new HttpEntity(headers);
- ResponseEntity responseEntity = restTemplate.exchange(url, HttpMethod.GET, httpEntity, Resource.class);
+ ResponseEntity<Resource> responseEntity =
+ restTemplate.exchange(url, HttpMethod.GET, httpEntity, Resource.class);
// mockRestServiceServer.verify();
return responseEntity;
@Test
public void testGetRequestToSchemaService() {
- ResponseEntity aaiResponse;
+ ResponseEntity<String> aaiResponse;
RestClient restClient = null;
restClient = restClientFactory.getRestClient(SCHEMA_SERVICE);
Code Review / aai / aai-common.git / commitdiff