diff options
Diffstat (limited to 'ajsc-aai/src/main/java/org/openecomp/aai/dbmap/SearchGraph.java')
| -rw-r--r-- | ajsc-aai/src/main/java/org/openecomp/aai/dbmap/SearchGraph.java | 1475 |
1 files changed, 1475 insertions, 0 deletions
diff --git a/ajsc-aai/src/main/java/org/openecomp/aai/dbmap/SearchGraph.java b/ajsc-aai/src/main/java/org/openecomp/aai/dbmap/SearchGraph.java new file mode 100644 index 0000000..1dde5b7 --- /dev/null +++ b/ajsc-aai/src/main/java/org/openecomp/aai/dbmap/SearchGraph.java @@ -0,0 +1,1475 @@ +/*- + * ============LICENSE_START======================================================= + * org.openecomp.aai + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.aai.dbmap; + +import java.io.StringReader; +import java.io.StringWriter; +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; + +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import javax.xml.bind.JAXBException; +import javax.xml.transform.stream.StreamSource; + +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.eclipse.persistence.dynamic.DynamicEntity; +import org.eclipse.persistence.dynamic.DynamicType; +import org.eclipse.persistence.exceptions.DynamicException; +import org.eclipse.persistence.jaxb.JAXBMarshaller; +import org.eclipse.persistence.jaxb.JAXBUnmarshaller; +import org.eclipse.persistence.jaxb.MarshallerProperties; +import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext; +import org.openecomp.aai.dbgen.DbMeth; +import org.openecomp.aai.dbgen.ModelBasedProcessing; +import org.openecomp.aai.dbgen.ResultSet; +import org.openecomp.aai.dbmodel.DbEdgeRules; +import org.openecomp.aai.domain.model.AAIResource; +import org.openecomp.aai.domain.model.AAIResourceKey; +import org.openecomp.aai.domain.model.AAIResourceKeys; +import org.openecomp.aai.domain.model.AAIResources; +import org.openecomp.aai.exceptions.AAIException; +import org.openecomp.aai.extensions.AAIExtensionMap; +import org.openecomp.aai.ingestModel.DbMaps; +import org.openecomp.aai.ingestModel.IngestModelMoxyOxm; +import org.openecomp.aai.logging.AAILogger; +import org.openecomp.aai.logging.LogLine; +import org.openecomp.aai.util.AAIApiServerURLBase; +import org.openecomp.aai.util.AAIApiVersion; +import org.openecomp.aai.util.AAIConfig; +import org.openecomp.aai.util.AAIConstants; +import org.openecomp.aai.util.PojoUtils; +import org.openecomp.aai.util.RestURL; +import org.openecomp.aai.util.StoreNotificationEvent; + +import com.google.common.base.CaseFormat; +import com.thinkaurelius.titan.core.TitanGraphQuery; +import com.thinkaurelius.titan.core.TitanTransaction; +import com.thinkaurelius.titan.core.TitanVertex; + +/** + * Database Mapping class which acts as the middle man between the REST interface objects + * for the Search namespace + + */ +public class SearchGraph { + + private LogLine logline = new LogLine(); + private final String COMPONENT = "aaidbmap"; + protected AAILogger aaiLogger = new AAILogger(SearchGraph.class.getName()); + + + /** + * Get the search result based on the includeNodeType and depth provided. + * + * @param fromAppId the from app id + * @param transId the trans id + * @param startNodeType the start node type + * @param startNodeKeyParams the start node key params + * @param includeNodeTypes the include node types + * @param depth the depth + * @param aaiExtMap the aai ext map + * @return Response + * @throws AAIException the AAI exception + */ + public Response runGenericQuery (String fromAppId, + String transId, + String startNodeType, + List <String> startNodeKeyParams, + List <String> includeNodeTypes, + final int depth, + AAIExtensionMap aaiExtMap) throws AAIException { + DynamicEntity searchResults = null; + Response response = null; + boolean success = true; + TitanTransaction g = null; + try { + g = AAIGraph.getInstance().getGraph().newTransaction(); + + logline.init(COMPONENT, transId, fromAppId, "runGenericQuery"); + + if( startNodeType == null ){ + String emsg = "null start-node-type passed to the generic query\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } else { + logline.add("start-node-type", startNodeType); + } + + if( startNodeKeyParams == null ){ + String emsg = "no key param passed to the generic query\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } else { + logline.add("key", startNodeKeyParams.toString()); + } + + if( includeNodeTypes == null ){ + String emsg = "no include params passed to the generic query\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } else { + logline.add("include", includeNodeTypes.toString()); + } + + if (depth > 6) { + String emsg = "The maximum depth supported by the generic query is 6\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } else { + logline.add("depth", depth); + } + + // Build a hash with keys to uniquely identify the start Node + HashMap <String,Object> propHash = new HashMap<String, Object>(); + String keyName = null, keyValue = null; + + String keyNameString = ""; + for( String keyData : startNodeKeyParams ){ + int colonIndex = keyData.indexOf(":"); + if( colonIndex <= 0 ){ + String emsg = "Bad key param passed in: [" + keyData + "]\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + else { + keyName = keyData.substring(0, colonIndex); + keyValue = keyData.substring(colonIndex + 1); + propHash.put(keyName, keyValue); + + keyNameString += keyName.toLowerCase() + "|"; + } + } + + // there is an issue with service-instance - it is a unique node but still dependent + // for now lets use getUniqueNode() to get the startNode if startNodeType is service-instance + TitanVertex startNode = null; + if (startNodeType.equalsIgnoreCase("service-instance")) { + Iterable <?> verts = g.query().has(keyName.substring(keyName.indexOf('.') + 1), keyValue).vertices(); + Iterator <?> vertI = verts.iterator(); + if( vertI != null && vertI.hasNext()) { + // We found a vertex that meets the input criteria. + startNode = (TitanVertex) vertI.next(); + + if( vertI.hasNext() ){ + // Since this routine is looking for a unique node for the given input values, if + // more than one is found - it's a problem. + String detail = "More than one Node found by getUniqueNode for params: " + startNodeKeyParams.toString() + "\n"; + throw new AAIException("AAI_6112", detail); + } + } + else { + // No Vertex was found for this key - throw a not-found exception + String msg = "No Node of type " + "service-instance" + " found for properties: " + startNodeKeyParams.toString(); + logline.add("msg", msg); + throw new AAIException("AAI_6114", msg); + } + + } else { + // Look for the start node based on the key params + startNode = DbMeth.getUniqueNodeWithDepParams(transId, + fromAppId, + g, + startNodeType, + propHash, + aaiExtMap.getApiVersion()); + } + if( startNode == null ){ + String emsg = "No Node of type " + + startNodeType + + " found for properties: " + + startNodeKeyParams.toString(); + logline.add("emsg", emsg); + throw new AAIException("AAI_6114", emsg); + } + + + Collection <Vertex> ver = new HashSet <Vertex> (); + + if (includeNodeTypes.contains(startNodeType) || depth == 0 || includeNodeTypes.contains("all") ) + ver.add(startNode); + + if (depth != 0) { + // Now look for a node of includeNodeType within a given depth + startNode.graph().traversal().withSideEffect("x", ver).V(startNode) + .repeat(__.both().store("x")).times(depth).iterate(); + } + + if( ver.isEmpty()){ + logline.add("msg", "No nodes found - apipe was null/empty"); + } + else { + AAIResources aaiResources = org.openecomp.aai.ingestModel.IngestModelMoxyOxm.aaiResourceContainer + .get(aaiExtMap.getApiVersion()); + DynamicJAXBContext jaxbContext = aaiResources.getJaxbContext(); + if (aaiExtMap.getApiVersion().equals("v2")) { + searchResults = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.SearchResults"); + } else { + searchResults = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + + ".SearchResults"); + } + ArrayList <DynamicEntity> resultDataList = new ArrayList<DynamicEntity>(); + for (Vertex thisNode: ver){ + String nodeType = thisNode.<String>property("aai-node-type").orElse(null); + if (depth == 0 || includeNodeTypes.contains(nodeType) || includeNodeTypes.contains("all")) { + // DbMeth.showPropertiesForNode( transId, fromAppId, thisNode ); + String thisNodeURL = RestURL.getSearchUrl(g, (TitanVertex)thisNode, aaiExtMap.getApiVersion()); + DynamicEntity resultData = null; + if (aaiExtMap.getApiVersion().equals("v2")) { + resultData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.ResultData"); + } else { + resultData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + + ".ResultData"); + } + + resultData.set("resourceType", nodeType); + resultData.set("resourceLink", thisNodeURL); + resultDataList.add(resultData); + } + } + searchResults.set("resultData", resultDataList); + response = getResponseFromDynamicEntity(searchResults, jaxbContext, aaiExtMap); + + logline.add("msg", ver.size() + " node(s) traversed, " + resultDataList.size() + " found"); + } + success = true; + } catch (AAIException e) { + success = false; + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + throw e; + } catch (Exception e) { + success = false; + aaiLogger.info(logline, false, "AAI_5105"); + throw new AAIException("AAI_5105", e); + } finally { + if (g != null) { + if (success) { + g.commit(); + } else { + g.rollback(); + } + } + + } + aaiLogger.info(logline, true, "0"); + return response; + } + + /** + * Run nodes query. + * + * @param fromAppId the from app id + * @param transId the trans id + * @param targetNodeType the target node type + * @param edgeFilterParams the edge filter params + * @param filterParams the filter params + * @param aaiExtMap the aai ext map + * @return Response + * @throws AAIException the AAI exception + */ + public Response runNodesQuery (String fromAppId, + String transId, + String targetNodeType, + List <String> edgeFilterParams, + List <String> filterParams, + AAIExtensionMap aaiExtMap) throws AAIException { + + DynamicEntity searchResults = null; + Response response = null; + boolean success = true; + TitanTransaction g = null; + try { + g = AAIGraph.getInstance().getGraph().newTransaction(); + + logline.init(COMPONENT, transId, fromAppId, "runNodesQuery"); + + DbMaps dbMaps = IngestModelMoxyOxm.dbMapsContainer.get(AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP)); + int resCount = 0; + + if( targetNodeType == null || targetNodeType == "" ){ + String emsg = "null or empty target-node-type passed to the node query\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + else { + logline.add("start-node-type", targetNodeType); + } + + if( ! dbMaps.NodeProps.containsKey(targetNodeType) ){ + String emsg = " Unrecognized nodeType [" + targetNodeType + "] passed to node query.\n"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6115", emsg); + } + + if( filterParams.isEmpty() && edgeFilterParams.isEmpty()){ + // For now, it's ok to pass no filter params. We'll just return ALL the nodes of the requested type. + String wmsg = "No filters passed to the node query\n"; + logline.add("warn-msg", wmsg); + filterParams = new ArrayList <String>(); + edgeFilterParams = new ArrayList <String>(); + } + else { + if( !filterParams.isEmpty()) + logline.add("filterParams", "[" + filterParams.toString() + "]"); + if( !edgeFilterParams.isEmpty()) + logline.add("edgeFilterParams", "[" + edgeFilterParams.toString() + "]"); + } + + Collection <TitanVertex> resultSetVertices = new ArrayList <TitanVertex> (); + String queryStringForMsg = ""; + TitanGraphQuery tgQ = g.query().has("aai-node-type", targetNodeType); + queryStringForMsg = "has(\"aai-node-type\"," + targetNodeType + ")"; + + for( String filter : filterParams ) { + if( (tgQ != null) && (tgQ instanceof TitanGraphQuery) ){ + String [] pieces = filter.split(":"); + if( pieces.length < 2 ){ + String emsg = "bad filter passed to node query: [" + filter + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + else { + String propName = pieces[0]; + String filterType = pieces[1]; + if( filterType.equals("EQUALS")){ + if( pieces.length != 3 ){ + String emsg = "No value passed for filter: [" + filter + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + else { + String value = pieces[2]; + queryStringForMsg = queryStringForMsg + ".has(" + propName + "," + value + ")"; + tgQ = tgQ.has(propName,value); + } + } + else if( filterType.equals("DOES-NOT-EQUAL")){ + if( pieces.length != 3 ){ + String emsg = "No value passed for filter: [" + filter + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + else { + String value = pieces[2]; + queryStringForMsg = queryStringForMsg + ".hasNot(" + propName + "," + value + ")"; + tgQ = tgQ.hasNot(propName,value); + } + } + else if( filterType.equals("EXISTS")){ + queryStringForMsg = queryStringForMsg + ".has(" + propName + ")"; + tgQ = tgQ.has(propName); + } + else if( filterType.equals("DOES-NOT-EXIST")){ + queryStringForMsg = queryStringForMsg + ".hasNot(" + propName + ")"; + tgQ = tgQ.hasNot(propName); + } + else { + String emsg = "bad filterType passed: [" + filterType + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + } + } + } + if( (tgQ != null) && (tgQ instanceof TitanGraphQuery) ){ + Iterable <?> targetNodeIterable = (Iterable<TitanVertex>) tgQ.vertices(); + Iterator <?> targetNodeIterator = targetNodeIterable.iterator(); + + if (!edgeFilterParams.isEmpty()) { + // edge-filter=pserver:EXISTS: OR pserver:EXISTS:hostname:XXX + // edge-filter=pserver:DOES-NOT-EXIST: OR pserver:DOES-NOT-EXIST:hostname:XXX + String filter = edgeFilterParams.get(0); // we process and allow only one edge filter for now + String [] pieces = filter.split(":"); + if( pieces.length < 2 || pieces.length == 3 || pieces.length > 4){ + String emsg = "bad edge-filter passed: [" + filter + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } else { + String nodeType = pieces[0].toLowerCase(); + String filterType = pieces[1].toUpperCase(); + if (!filterType.equals("EXISTS") && !filterType.equals("DOES-NOT-EXIST")) { + String emsg = "bad filterType passed: [" + filterType + "]"; + logline.add("emsg", emsg); + throw new AAIException("AAI_6120", emsg); + } + String propName = null, propValue = null; + if( pieces.length >= 3) { + propName = pieces[2].toLowerCase(); + propValue = pieces[3]; + } + String edgeLabel = getEdgeLabel(targetNodeType, nodeType); + Iterator<Vertex> relatedToIterable = null; + while( targetNodeIterator.hasNext() ){ + TitanVertex targetNodeVertex = (TitanVertex)targetNodeIterator.next(); + relatedToIterable = targetNodeVertex.vertices(Direction.BOTH, edgeLabel); + Iterator <?> relatedToIterator = relatedToIterable; + if( filterType.equals("DOES-NOT-EXIST") && propName == null){ + if (!relatedToIterator.hasNext()) { + resultSetVertices.add(targetNodeVertex); + } + } else { + while (relatedToIterator.hasNext()) { + TitanVertex relatedToVertex = (TitanVertex)relatedToIterator.next(); + if (filterType.equals("EXISTS")) { + if (propName == null) + resultSetVertices.add(targetNodeVertex); + else { + // check for matching property + if (relatedToVertex.<String>property(propName).orElse(null) != null && relatedToVertex.<String>property(propName).equals(propValue)) + resultSetVertices.add(targetNodeVertex); + } + } else if (filterType.equals("DOES-NOT-EXIST")) { + // check for matching property + if (relatedToVertex.<String>property(propName).orElse(null) != null && !relatedToVertex.<String>property(propName).equals(propValue)) + resultSetVertices.add(targetNodeVertex); + } + } + } + } + } + } else { + while( targetNodeIterator.hasNext() ){ + TitanVertex targetNodeVertex = (TitanVertex)targetNodeIterator.next(); + resultSetVertices.add(targetNodeVertex); + } + } + + AAIResources aaiResources = org.openecomp.aai.ingestModel.IngestModelMoxyOxm.aaiResourceContainer + .get(aaiExtMap.getApiVersion()); + DynamicJAXBContext jaxbContext = aaiResources.getJaxbContext(); + if (aaiExtMap.getApiVersion().equals("v2")) { + searchResults = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.SearchResults"); + } else { + searchResults = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + + ".SearchResults"); + } + ArrayList <DynamicEntity> resultDataList = new ArrayList<DynamicEntity>(); + for (TitanVertex thisNode: resultSetVertices){ + resCount++; + String nodeType = thisNode.<String>property("aai-node-type").orElse(null); + String thisNodeURL = RestURL.getSearchUrl(g, thisNode, aaiExtMap.getApiVersion()); + DynamicEntity resultData = null; + if (aaiExtMap.getApiVersion().equals("v2")) { + resultData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.ResultData"); + + } else { + resultData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + ".ResultData"); + } + resultData.set("resourceType", nodeType); + resultData.set("resourceLink", thisNodeURL); + resultDataList.add(resultData); + } + searchResults.set("resultData", resultDataList); + response = getResponseFromDynamicEntity(searchResults, jaxbContext, aaiExtMap); + } + logline.add("count", resCount); + success = true; + } catch (AAIException e) { + success = false; + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + throw e; + } catch (Exception e) { + success = false; + aaiLogger.info(logline, false, "AAI_5105"); + throw new AAIException("AAI_5105", e); + } finally { + if (g != null) { + if (success) { + g.commit(); + } else { + g.rollback(); + } + } + } + + aaiLogger.info(logline, true, "0"); + return response; + } + + /** + * Map result. + * + * @param g the g + * @param logline the logline + * @param jaxbContext the jaxb context + * @param aaiExtMap the aai ext map + * @param resultDetail the result detail + * @param includeNodeTypes the include node types + * @param resultSet the result set + * @param invItemCount the inv item count + * @param levelCount the level count + * @return the dynamic entity + * @throws UnsupportedEncodingException the unsupported encoding exception + * @throws AAIException the AAI exception + */ + public DynamicEntity mapResult(TitanTransaction g, LogLine logline, + DynamicJAXBContext jaxbContext, + AAIExtensionMap aaiExtMap, + String resultDetail, + ArrayList<String> includeNodeTypes, + ResultSet resultSet, + int invItemCount, + int levelCount ) + throws UnsupportedEncodingException, AAIException { + + ArrayList <String> retArr = new ArrayList <String> (); + DynamicEntity item = null; + + if (aaiExtMap.getApiVersion().equals("v2")) { + item = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.InventoryItem"); + } else { + item = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryItem"); + } + + levelCount++; + TitanVertex node = resultSet.getVert(); + if( node == null ){ + retArr.add("null Node object returned"); + } + else { + String nt = node.<String>property("aai-node-type").orElse(null); + + if ((includeNodeTypes.contains("all")) || + (includeNodeTypes.contains(nt.toLowerCase()))) { // include this node in resultSet only if its one of + // the included node types or its include "all" + + retArr.add( levelCount + " " + nt + ", " + node.id().toString() + ";"); + item.set("inventoryItemType", nt); + + String thisNodeURL = node.<String>property("aai-unique-key").orElse(null); + String permanentURL = aaiExtMap.getUriInfo().getQueryParameters().getFirst("permanenturl"); + if (thisNodeURL != null && !thisNodeURL.equals("")) { + thisNodeURL = AAIApiServerURLBase.get() + AAIApiVersion.get() + "/" + thisNodeURL; + } else if ("true".equals(permanentURL)) { + thisNodeURL = RestURL.getSearchUrl(g, node, aaiExtMap.getApiVersion()); + } + else { + thisNodeURL = AAIApiServerURLBase.get() + AAIApiVersion.get() + "/resources/id/" + node.id(); + } + item.set("inventoryItemLink", thisNodeURL); + + DbMaps dbMaps = IngestModelMoxyOxm.dbMapsContainer.get(AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP)); + Collection <String> indexProperties = dbMaps.NodeMapIndexedProps.get(nt); + + ArrayList <DynamicEntity> itemDataList = new ArrayList<DynamicEntity>(); + + Iterator<VertexProperty<Object>> pI = node.properties(); + + ArrayList<String> defB = new ArrayList<String>(); + + if (AAIConfig.getDefaultBools().containsKey(nt)) { + for (String db : AAIConfig.getDefaultBools().get(nt)) { + defB.add(db); + } + } + + while( pI.hasNext() ){ + VertexProperty<Object> tp = pI.next(); + String propKey = tp.key(); + if (!propKey.equals("aai-node-type") && + (!dbMaps.ReservedPropNames.containsKey((String)propKey)) && // do not return internal properties + ((resultDetail.equalsIgnoreCase("all") || + ((resultDetail.equalsIgnoreCase("summary") && // only include indexed properties + // if summary detail required + indexProperties.contains(propKey))) ))){ + if (defB.contains(propKey)) { + defB.remove(propKey); + } + DynamicEntity invItemData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + + ".InventoryItemData"); + invItemData.set("propertyName", tp.key()); + String propVal = ""; + if( tp.value() != null ){ + propVal = tp.value().toString(); + } + invItemData.set("propertyValue", propVal); + itemDataList.add(invItemData); + } + } + + for (String db : defB) { + if ((resultDetail.equalsIgnoreCase("all") || + ((resultDetail.equalsIgnoreCase("summary") && // only include indexed properties + // if summary detail required + indexProperties.contains(db))) )) { + DynamicEntity invItemData = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + + aaiExtMap.getApiVersion() + + ".InventoryItemData"); + invItemData.set("propertyName", db); + invItemData.set("propertyValue", "false"); + itemDataList.add(invItemData); + } + } + + item.set("inventoryItemData", itemDataList); + } + + if( !resultSet.getSubResultSet().isEmpty() ){ + DynamicEntity taggedInventoryItemList = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".TaggedInventoryItemList"); + + ListIterator<ResultSet> listItr = resultSet.getSubResultSet().listIterator(); + ArrayList<DynamicEntity> inventoryItemList = new ArrayList<DynamicEntity>(); + + boolean hasItems = false; + while( listItr.hasNext() ){ + + DynamicEntity invItem = mapResult(g, logline, + jaxbContext, + aaiExtMap, + resultDetail, + includeNodeTypes, + listItr.next(), + invItemCount, + levelCount ); + if (invItem != null) { + hasItems = true; + inventoryItemList.add(invItem); // dont add if excluded nodes + } + } + + if (item != null && hasItems == true) { + taggedInventoryItemList.set("inventoryItem", inventoryItemList); + ArrayList<DynamicEntity> til = new ArrayList<DynamicEntity>(); + til.add(taggedInventoryItemList); + item.set("taggedInventoryItemList", til); + } + } + } + if (!retArr.isEmpty()) + logline.add("msg" + invItemCount, retArr.toString()); + return item; + + }// end of mapResult() + + + /** + * Gets the edge label. + * + * @param targetNodeType the target node type + * @param nodeType the node type + * @return the edge label + * @throws AAIException the AAI exception + */ + public static String getEdgeLabel(String targetNodeType, String nodeType) throws AAIException{ + String edRule = ""; + String edgeLabel = "???"; + Collection <String> edRuleColl = DbEdgeRules.EdgeRules.get(targetNodeType + "|" + nodeType); + Iterator <String> ruleItr = edRuleColl.iterator(); + if( ruleItr.hasNext() ){ + // For now, we only look for one type of edge between two nodes. + // We're just pulling off the edgeLabel which is the first thing on the list. + edRule = ruleItr.next(); + String [] rules = edRule.split(","); + edgeLabel = rules[0]; + } + else { + edRuleColl = DbEdgeRules.EdgeRules.get(nodeType + "|" + targetNodeType); + ruleItr = edRuleColl.iterator(); + if( ruleItr.hasNext() ){ + edRule = ruleItr.next(); + String [] rules = edRule.split(","); + edgeLabel = rules[0]; + } else { + // No edge rule found for this + String detail = "No EdgeRule found for passed nodeTypes: " + nodeType + ", " + targetNodeType + "."; + throw new AAIException("AAI_6120", detail); + } + } + return edgeLabel; + } + + + /** + * Run named query. + * + * @param fromAppId the from app id + * @param transId the trans id + * @param queryParameters the query parameters + * @param aaiExtMap the aai ext map + * @return the response + * @throws JAXBException the JAXB exception + * @throws AAIException the AAI exception + */ + public Response runNamedQuery(String fromAppId, String transId, String queryParameters, + AAIExtensionMap aaiExtMap) throws JAXBException, AAIException { + // TODO Auto-generated method stub + AAIResources aaiResources = org.openecomp.aai.ingestModel.IngestModelMoxyOxm.aaiResourceContainer + .get(aaiExtMap.getApiVersion()); + DynamicJAXBContext jaxbContext = aaiResources.getJaxbContext(); + JAXBUnmarshaller unmarshaller = jaxbContext.createUnmarshaller(); + + //String dynamicClass = aaiRes.getResourceClassName(); + + DynamicEntity inventoryItems; + boolean success = true; + TitanTransaction g = null; + try { + g = AAIGraph.getInstance().getGraph().newTransaction(); + if (aaiExtMap.getHttpServletRequest().getContentType() == null || // default to json + aaiExtMap.getHttpServletRequest().getContentType().contains("application/json")) { + unmarshaller.setProperty("eclipselink.media-type", "application/json"); + unmarshaller.setProperty("eclipselink.json.include-root", false); + } + + if (queryParameters.length() == 0) { + queryParameters = "{}"; + unmarshaller.setProperty("eclipselink.media-type", "application/json"); + unmarshaller.setProperty("eclipselink.json.include-root", false); + } + String dynamicClass = "inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".ModelAndNamedQuerySearch"; + Class<? extends DynamicEntity> resultClass = jaxbContext.newDynamicEntity(dynamicClass).getClass(); + + StringReader reader = new StringReader(queryParameters); + + DynamicEntity modelAndNamedQuerySearch = (DynamicEntity) unmarshaller.unmarshal(new StreamSource(reader), resultClass).getValue(); + + if (modelAndNamedQuerySearch == null) { + throw new AAIException("AAI_5105"); + } + + HashMap<String,Object> namedQueryLookupHash = new HashMap<String,Object>(); + + DynamicEntity qp = modelAndNamedQuerySearch.get("queryParameters"); + + String namedQueryUuid = null; + if (qp.isSet("namedQuery")) { + DynamicEntity namedQuery = (DynamicEntity) qp.get("namedQuery"); + + if (namedQuery.isSet("namedQueryUuid")) { + namedQueryUuid = namedQuery.get("namedQueryUuid"); + } + if (namedQuery.isSet("namedQueryName")) { + namedQueryLookupHash.put("named-query-name", namedQuery.get("namedQueryName")); + } + if (namedQuery.isSet("namedQueryVersion")) { + namedQueryLookupHash.put("named-query-version", namedQuery.get("namedQueryVersion")); + } + } + + if (namedQueryUuid == null) { + ArrayList<TitanVertex> namedQueryVertices = DbMeth.getNodes(transId, fromAppId, g, "named-query", namedQueryLookupHash, false); + + for (TitanVertex vert : namedQueryVertices) { + namedQueryUuid = vert.<String>property("named-query-uuid").orElse(null); + // there should only be one, we'll pick the first if not + break; + } + } + + ArrayList<HashMap<String,Object>> startNodeFilterHash = new ArrayList<HashMap<String,Object>>(); + + mapInstanceFilters((DynamicEntity)modelAndNamedQuerySearch.get("instanceFilters"), + startNodeFilterHash, jaxbContext); + + ArrayList<ResultSet> resultSet = ModelBasedProcessing.queryByNamedQuery(transId, fromAppId, g, + namedQueryUuid, startNodeFilterHash, aaiExtMap.getApiVersion() ); + + inventoryItems = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItems"); + + HashMap<Object,String> objectToVertMap = new HashMap<Object,String>(); + ArrayList<DynamicEntity> invItemList = unpackResultSet(g, resultSet, jaxbContext, aaiResources, objectToVertMap, aaiExtMap); + + inventoryItems.set("inventoryResponseItem", invItemList); + success = true; + } catch (AAIException e) { + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + success = false; + throw e; + } catch (Exception e) { + aaiLogger.info(logline, false, "AAI_5105"); + success = false; + throw new AAIException("AAI_5105", e); + } finally { + if (g != null) { + if (success) { + g.commit(); + } else { + g.rollback(); + } + } + } + + aaiLogger.info(logline, true, "0"); + + return getResponseFromDynamicEntity(inventoryItems, jaxbContext, aaiExtMap); + } + + /** + * Execute model operation. + * + * @param fromAppId the from app id + * @param transId the trans id + * @param queryParameters the query parameters + * @param isDelete the is delete + * @param aaiExtMap the aai ext map + * @return the response + * @throws JAXBException the JAXB exception + * @throws AAIException the AAI exception + * @throws DynamicException the dynamic exception + * @throws UnsupportedEncodingException the unsupported encoding exception + */ + public Response executeModelOperation(String fromAppId, String transId, String queryParameters, boolean isDelete, + AAIExtensionMap aaiExtMap) throws JAXBException, AAIException, DynamicException, UnsupportedEncodingException { + // TODO Auto-generated method stub + AAIResources aaiResources = org.openecomp.aai.ingestModel.IngestModelMoxyOxm.aaiResourceContainer + .get(aaiExtMap.getApiVersion()); + DynamicJAXBContext jaxbContext = aaiResources.getJaxbContext(); + JAXBUnmarshaller unmarshaller = jaxbContext.createUnmarshaller(); + + //String dynamicClass = aaiRes.getResourceClassName(); + Response response; + boolean success = true; + TitanTransaction g = null; + try { + + g = AAIGraph.getInstance().getGraph().newTransaction(); + + + if (aaiExtMap.getHttpServletRequest().getContentType() == null || // default to json + aaiExtMap.getHttpServletRequest().getContentType().contains("application/json")) { + unmarshaller.setProperty("eclipselink.media-type", "application/json"); + unmarshaller.setProperty("eclipselink.json.include-root", false); + } + + if (queryParameters.length() == 0) { + queryParameters = "{}"; + unmarshaller.setProperty("eclipselink.media-type", "application/json"); + unmarshaller.setProperty("eclipselink.json.include-root", false); + } + String dynamicClass = "inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".ModelAndNamedQuerySearch"; + Class<? extends DynamicEntity> resultClass = jaxbContext.newDynamicEntity(dynamicClass).getClass(); + + StringReader reader = new StringReader(queryParameters); + + DynamicEntity modelAndNamedQuerySearch = (DynamicEntity) unmarshaller.unmarshal(new StreamSource(reader), resultClass).getValue(); + + if (modelAndNamedQuerySearch == null) { + throw new AAIException("AAI_5105"); + } + + HashMap<String,Object> modelQueryLookupHash = new HashMap<String,Object>(); + + String modelNameVersionId = null; + String modelName = null; + String modelId = null; + String modelVersion = null; + String topNodeType = null; + + if (modelAndNamedQuerySearch.isSet("topNodeType")) { + topNodeType = modelAndNamedQuerySearch.get("topNodeType"); + } + if (modelAndNamedQuerySearch.isSet("queryParameters")) { + DynamicEntity qp = modelAndNamedQuerySearch.get("queryParameters"); + + if (qp.isSet("model")) { + DynamicEntity model = (DynamicEntity) qp.get("model"); + + if (model.isSet("modelNameVersionId")) { + modelNameVersionId = model.get("modelNameVersionId"); + } + if (model.isSet("modelName")) { + modelName = model.get("modelName"); + modelQueryLookupHash.put("model-name", modelName); + } + if (model.isSet("modelId")) { + modelId = model.get("modelId"); + modelQueryLookupHash.put("model-id", modelId); + } + if (model.isSet("modelVersion")) { + modelVersion = model.get("modelVersion"); + modelQueryLookupHash.put("model-version", modelVersion); + } + } + + if (modelNameVersionId == null ) { + if (modelId != null || modelName != null) { + ArrayList<TitanVertex> modelVertices = DbMeth.getNodes(transId, fromAppId, g, "model", modelQueryLookupHash, false); + for (TitanVertex vert : modelVertices) { + modelNameVersionId = vert.<String>property("model-name-version-id").orElse(null); + // there should only be one, we'll pick the first if not + break; + } + } else { + throw new AAIException("AAI_6132", "Could not determine model to use."); + } + } + } + ArrayList< HashMap<String,Object> > startNodeFilterHash = new ArrayList< HashMap<String,Object> >(); + + String resourceVersion = mapInstanceFilters((DynamicEntity)modelAndNamedQuerySearch.get("instanceFilters"), + startNodeFilterHash, jaxbContext); + + if (isDelete) { + + ArrayList<ResultSet> resultSet = ModelBasedProcessing.queryByModel(transId, fromAppId, g, + modelNameVersionId, modelId, modelName, topNodeType, startNodeFilterHash, aaiExtMap.getApiVersion() ); + + new ArrayList<DynamicEntity>(); + + HashMap<Object,String> objectToVertMap = new HashMap<Object,String>(); + ArrayList<DynamicEntity> invItemList = unpackResultSet(g, resultSet, jaxbContext, aaiResources, objectToVertMap, aaiExtMap); + + ResultSet rs = resultSet.get(0); + + TitanVertex firstVert = rs.getVert(); + String restURL = RestURL.get(g, firstVert); + + HashMap<String,String> delResult = ModelBasedProcessing.runDeleteByModel( transId, fromAppId, g, + modelNameVersionId, topNodeType, startNodeFilterHash.get(0), aaiExtMap.getApiVersion(), resourceVersion ); + + String resultStr = ""; + for (Map.Entry<String,String> ent : delResult.entrySet()) { + resultStr += "v[" + ent.getKey() + "] " + ent.getValue() + ",\n"; + } + resultStr.trim(); + + DynamicEntity inventoryItems = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItems"); + DynamicEntity topInvItem = remapInventoryItems(invItemList.get(0), jaxbContext, delResult, objectToVertMap, aaiExtMap); + + List<DynamicEntity> newInvItemList = new ArrayList<DynamicEntity>(); + newInvItemList.add(topInvItem); + inventoryItems.set("inventoryResponseItem", newInvItemList); + + // put the inventoryItems in a UEB notification object + String notificationVersion = AAIConfig.get("aai.notification.current.version"); + + AAIResources aaiNotificationResources = org.openecomp.aai.ingestModel.IngestModelMoxyOxm.aaiResourceContainer + .get(notificationVersion); + + DynamicJAXBContext notificationJaxbContext = aaiNotificationResources.getJaxbContext(); + + DynamicEntity notificationHeader = notificationJaxbContext + .getDynamicType("inventory.aai.openecomp.org." + notificationVersion + ".NotificationEventHeader") + .newDynamicEntity(); + + notificationHeader.set("entityLink", restURL); + notificationHeader.set("action", "DELETE"); + + notificationHeader.set("entityType", "inventory-response-items"); + notificationHeader.set("topEntityType", "inventory-response-items"); + notificationHeader.set("sourceName", aaiExtMap.getFromAppId()); + notificationHeader.set("version", notificationVersion); + + StoreNotificationEvent sne = new StoreNotificationEvent(); + + sne.storeDynamicEvent(notificationJaxbContext, notificationVersion, notificationHeader, inventoryItems); + + response = Response.ok(resultStr).build(); + + } else { + ArrayList<ResultSet> resultSet = ModelBasedProcessing.queryByModel( transId, fromAppId, g, + modelNameVersionId, null, modelName, topNodeType, startNodeFilterHash, aaiExtMap.getApiVersion() ); + + DynamicEntity inventoryItems = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItems"); + + new ArrayList<DynamicEntity>(); + HashMap<Object,String> objectToVertMap = new HashMap<Object,String>(); + ArrayList<DynamicEntity> invItemList = unpackResultSet(g, resultSet, jaxbContext, aaiResources, objectToVertMap, aaiExtMap); + + inventoryItems.set("inventoryResponseItem", invItemList); + + response = getResponseFromDynamicEntity(inventoryItems, jaxbContext, aaiExtMap); + } + success = true; + } catch (AAIException e) { + success = false; + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + throw e; + } catch (Exception e) { + success = false; + aaiLogger.info(logline, false, "AAI_5105"); + throw new AAIException("AAI_5105", e); + } finally { + if (g != null) { + if (success) { + g.commit(); + } else { + g.rollback(); + } + } + } + + aaiLogger.info(logline, true, "0"); + return response; + } + + /** + * + * + * @param g the g + * @param fromAppId the from app id + * @param transId the trans id + * @param avZoVtx the av zo vtx + * @param jaxbContext the jaxb context + * @param aaiExtMap the aai ext map + * @return zone type of AvailabilityZone + * @throws AAIException the AAI exception + */ + private DynamicEntity getAvailabilityZone(TitanTransaction g, String fromAppId, + String transId, + TitanVertex avZoVtx, + DynamicJAXBContext jaxbContext, + AAIExtensionMap aaiExtMap) throws AAIException { + logline.init(COMPONENT, transId, fromAppId, "getAvailabilityZone"); + String azName = avZoVtx.<String>property("availability-zone-name").toString(); + logline.add("availability-zone-name", avZoVtx.<String>property("availability-zone-name").toString()); + + DynamicEntity zone = null; + + if (aaiExtMap.getApiVersion().equals("v2")) + zone = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.AvailabilityZone"); + else + zone = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".AvailabilityZone"); + + try { + zone.set("availabilityZoneName", azName); + if (avZoVtx.<String>property("hypervisor-type") != null) { + zone.set("hypervisorType", avZoVtx.<String>property("hypervisor-type").orElse(null)); + } + if (avZoVtx.<String>property("operational-state") != null) { + zone.set("operationalState", (avZoVtx.<String>property("operational-state").orElse(null))); + } + + String defaultApiVersion = AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP); + + zone.set("relationshipList", RelationshipGraph.getRelationships(g, avZoVtx, defaultApiVersion, aaiExtMap)); + + } catch (AAIException e) { + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + throw e; + } catch (Exception e) { + aaiLogger.info(logline, false, "AAI_5105"); + throw new AAIException("AAI_5105", e); + } + + aaiLogger.info(logline, true, "0"); + return zone; + } + + + /** + * + * + * @param g the g + * @param fromAppId the from app id + * @param transId the trans id + * @param swVtx the sw vtx + * @param jaxbContext the jaxb context + * @param aaiExtMap the aai ext map + * @return DvsSwitch + * @throws AAIException the AAI exception + */ + private DynamicEntity getDvsSwitch(TitanTransaction g, String fromAppId, + String transId, + TitanVertex swVtx, + DynamicJAXBContext jaxbContext, + AAIExtensionMap aaiExtMap) throws AAIException { + logline.init(COMPONENT, transId, fromAppId, "getDvsSwitch"); + logline.add("switch-name", swVtx.<String>property("switch-name").toString()); + DynamicEntity dvs = null; + if (aaiExtMap.getApiVersion().equals("v2")) + dvs = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.DvsSwitch"); + else + dvs = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".DvsSwitch"); + + try { + if (swVtx.<String>property("switch-name") != null) { + dvs.set("switchName", swVtx.<String>property("switch-name").orElse(null)); + } + if (swVtx.<String>property("vcenter-url") != null) { + dvs.set("vcenterUrl", swVtx.<String>property("vcenter-url").orElse(null)); + } + String defaultApiVersion = AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP); + + dvs.set("relationshipList", RelationshipGraph.getRelationships(g, swVtx, defaultApiVersion, aaiExtMap)); + + + } catch (AAIException e) { + aaiLogger.info(logline, false, e.getErrorObject().getErrorCodeString()); + throw e; + } catch (Exception e) { + aaiLogger.info(logline, false, "AAI_5105"); + throw new AAIException("AAI_5105", e); + } + + aaiLogger.info(logline, true, "0"); + return dvs; + } + + + /** + * + * + * @param g the g + * @param fromAppId the from app id + * @param transId the trans id + * @param oamVtx the oam vtx + * @param jaxbContext the jaxb context + * @param aaiExtMap the aai ext map + * @return oam type of OamNetwork + * @throws AAIException the AAI exception + */ + private DynamicEntity getOamNetwork(TitanTransaction g, String fromAppId, + String transId, + TitanVertex oamVtx, + DynamicJAXBContext jaxbContext, + AAIExtensionMap aaiExtMap) throws AAIException { + logline.init(COMPONENT, transId, fromAppId, "getOamNetwork"); + String networkUuid = oamVtx.<String>property("network-uuid").toString(); + logline.add("oam-network", networkUuid ); + + DynamicEntity oam = null; + if (aaiExtMap.getApiVersion().equals("v2")) + oam = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org.OamNetwork"); + else + oam = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".OamNetwork"); + + try { + oam.set("networkUuid", networkUuid); + if (oamVtx.<String>property("network-name") != null) { + oam.set("networkName", oamVtx.<String>property("network-name").orElse(null)); + } + + Object cvt = oamVtx.<String>property("cvlan-tag"); + if (cvt instanceof Long) { + oam.set("cvlanTag", (Long) cvt); + } + if (cvt instanceof Integer) { + Integer tmp = (Integer) cvt; + oam.set("cvlanTag", (Long) tmp.longValue()); + } + if (oamVtx.<String>property("ipv4-oam-gateway-address") != null) { + oam.set("ipv4OamGatewayAddress", oamVtx.<String>property("ipv4-oam-gateway-address").orElse(null)); + } + Object len = oamVtx.<String>property("ipv4-oam-gateway-address-prefix-length"); + if (len instanceof Integer) { + oam.set("ipv4OamGatewayAddressPrefixLength", (Integer) len); + } + + String defaultApiVersion = AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP); + + DynamicEntity relationships = RelationshipGraph.getRelationships(g, oamVtx, defaultApiVersion, aaiExtMap); + oam.set("relationshipList", relationships); + + } catch (AAIException e) { + throw e; + } catch (Exception e) { + throw new AAIException("AAI_5105", e); + } + aaiLogger.info(logline, true, "0"); + return oam; + } + + + + /** + * Gets the response from dynamic entity. + * + * @param searchResult the search result + * @param jaxbContext the jaxb context + * @param aaiExtMap the aai ext map + * @return the response from dynamic entity + * @throws JAXBException the JAXB exception + */ + private Response getResponseFromDynamicEntity(DynamicEntity searchResult, + DynamicJAXBContext jaxbContext, + AAIExtensionMap aaiExtMap) throws JAXBException { + Response response = null; + JAXBMarshaller marshaller = jaxbContext.createMarshaller(); + marshaller.setProperty(JAXBMarshaller.JAXB_FORMATTED_OUTPUT, false); + + for (MediaType mt : aaiExtMap.getHttpHeaders().getAcceptableMediaTypes()) { + if (MediaType.APPLICATION_JSON_TYPE.isCompatible(mt)) { + marshaller.setProperty("eclipselink.media-type", "application/json"); + marshaller.setProperty("eclipselink.json.include-root", false); + marshaller.setProperty(MarshallerProperties.JSON_VALUE_WRAPPER, "property-value"); + marshaller.setProperty(MarshallerProperties.JSON_MARSHAL_EMPTY_COLLECTIONS, Boolean.FALSE) ; + } + } + + StringWriter writer = new StringWriter(); + marshaller.marshal(searchResult, writer); + + response = Response.ok(searchResult).entity(writer.toString()).build(); + return response; + } + + /** + * Map instance filters. + * + * @param instanceFilters the instance filters + * @param startNodeFilterHash the start node filter hash + * @param jaxbContext the jaxb context + * @return the string + */ + private String mapInstanceFilters(DynamicEntity instanceFilters, ArrayList<HashMap<String,Object>> startNodeFilterHash, DynamicJAXBContext jaxbContext) { + + if (instanceFilters == null || !instanceFilters.isSet("instanceFilter")) { + return null; + } + @SuppressWarnings("unchecked") + List<DynamicEntity> instanceFilter = (ArrayList<DynamicEntity>)instanceFilters.get("instanceFilter"); + String resourceVersion = null; + + for (DynamicEntity instFilt : instanceFilter) { + List<DynamicEntity> any = instFilt.get("any"); + HashMap<String,Object> thisNodeFilterHash = new HashMap<String,Object>(); + for (DynamicEntity anyEnt : any) { + String clazz = anyEnt.getClass().getCanonicalName(); + String simpleClazz = anyEnt.getClass().getSimpleName(); + + String nodeType = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, simpleClazz); + + DynamicType anyEntType = jaxbContext.getDynamicType(clazz); + + for (String propName : anyEntType.getPropertiesNames()) { + // hyphencase the prop and throw it on the hash + if (anyEnt.isSet(propName)) { + thisNodeFilterHash.put(nodeType + "." + CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, propName), anyEnt.get(propName)); + if (propName.equals("resourceVersion") && resourceVersion == null) { + resourceVersion = (String)anyEnt.get(propName); + } + } + } + } + startNodeFilterHash.add(thisNodeFilterHash); + } + return resourceVersion; + } + + /** + * Remap inventory items. + * + * @param invResultItem the inv result item + * @param jaxbContext the jaxb context + * @param includeTheseVertices the include these vertices + * @param objectToVertMap the object to vert map + * @param aaiExtMap the aai ext map + * @return the dynamic entity + */ + private DynamicEntity remapInventoryItems(DynamicEntity invResultItem, DynamicJAXBContext jaxbContext, + HashMap<String,String> includeTheseVertices, HashMap<Object,String> objectToVertMap, AAIExtensionMap aaiExtMap) { + + + DynamicEntity inventoryItem = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItem"); + Object item = invResultItem.get("item"); + inventoryItem.set("modelName", invResultItem.get("modelName")); + inventoryItem.set("item", item); + inventoryItem.set("extraProperties", invResultItem.get("extraProperties")); + + String vertexId = ""; + + if (objectToVertMap.containsKey(item)) { + vertexId = objectToVertMap.get(item); + } + + if (includeTheseVertices.containsKey(vertexId)) { + if (invResultItem.isSet("inventoryResponseItems")) { + List<DynamicEntity> invItemList = new ArrayList<DynamicEntity>(); + DynamicEntity inventoryItems = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItems"); + DynamicEntity subInventoryResponseItems = invResultItem.get("inventoryResponseItems"); + List<DynamicEntity> subInventoryResponseItemList = subInventoryResponseItems.get("inventoryResponseItem"); + for (DynamicEntity ent : subInventoryResponseItemList) { + DynamicEntity invItem = remapInventoryItems(ent, jaxbContext, includeTheseVertices, objectToVertMap, aaiExtMap); + if (invItem != null) { + invItemList.add(invItem); + } + } + if (invItemList != null) { + inventoryItems.set("inventoryResponseItem", invItemList); + inventoryItem.set("inventoryResponseItems", inventoryItems); + } + } + } + return inventoryItem; + } + + /** + * Unpack result set. + * + * @param g the g + * @param resultSetList the result set list + * @param jaxbContext the jaxb context + * @param aaiResources the aai resources + * @param objectToVertMap the object to vert map + * @param aaiExtMap the aai ext map + * @return the array list + * @throws AAIException the AAI exception + */ + // this should return an inventoryItem + private ArrayList<DynamicEntity> unpackResultSet(TitanTransaction g, ArrayList<ResultSet> resultSetList, + DynamicJAXBContext jaxbContext, + AAIResources aaiResources, + HashMap<Object,String> objectToVertMap, + AAIExtensionMap aaiExtMap) throws AAIException { + + ArrayList<DynamicEntity> resultList = new ArrayList<DynamicEntity>(); + + for (ResultSet resultSet : resultSetList) { + + DynamicEntity inventoryItem = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItem"); + DynamicEntity inventoryItems = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".InventoryResponseItems"); + + // add this inventoryItem to the resultList for this level + resultList.add(inventoryItem); + + TitanVertex vert = resultSet.getVert(); + + Long vertId = (Long)vert.longId(); + + String aaiNodeType = vert.<String>property("aai-node-type").orElse(null); + + String simpleName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL,aaiNodeType); + // find an aaiResource with this node as the last element + + AAIResource aaiRes = null; + for (Map.Entry<String,AAIResource> ent: aaiResources.getAaiResources().entrySet()) { + AAIResource res = ent.getValue(); + if (res.getSimpleName().equals(simpleName)) { + aaiRes = res; + break; + } + } + + if (aaiRes != null) { + PojoUtils pu = new PojoUtils(); + DynamicEntity thisObj = jaxbContext.newDynamicEntity(aaiRes.getResourceClassName()); + + if (resultSet.getExtraPropertyHash() != null) { + HashMap<String,Object> extraProperties = resultSet.getExtraPropertyHash(); + + DynamicEntity extraPropertiesEntity = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".ExtraProperties"); + + List<DynamicEntity> extraPropsList = new ArrayList<DynamicEntity>(); + + for (Map.Entry<String,Object> ent : extraProperties.entrySet()) { + String propName = ent.getKey(); + Object propVal = ent.getValue(); + + DynamicEntity extraPropEntity = jaxbContext.newDynamicEntity("inventory.aai.openecomp.org." + aaiExtMap.getApiVersion() + ".ExtraProperty"); + + extraPropEntity.set("propertyName", propName); + extraPropEntity.set("propertyValue", propVal); + + extraPropsList.add(extraPropEntity); + + } + extraPropertiesEntity.set("extraProperty", extraPropsList); + inventoryItem.set("extraProperties", extraPropertiesEntity); + } + String propertyLimitDesc = resultSet.getPropertyLimitDesc(); + + if (propertyLimitDesc != null && propertyLimitDesc.length() > 0) { + + if ("SHOW-NONE".equalsIgnoreCase(propertyLimitDesc)) { + HashMap<String,Object> emptyPropertyOverRideHash = new HashMap<String,Object>(); + pu.getAaiDynamicObjectFromVertex(aaiRes, thisObj, vert, aaiRes.getPropertyDataTypeMap(), emptyPropertyOverRideHash); + } else if ("SHOW-ALL".equalsIgnoreCase(propertyLimitDesc)) { + pu.getAaiDynamicObjectFromVertex(aaiRes, thisObj, vert, aaiRes.getPropertyDataTypeMap()); + } else if ("NAME-AND-KEYS-ONLY".equalsIgnoreCase(propertyLimitDesc)) { + AAIResourceKeys aaiResKeys = aaiRes.getAaiResourceKeys(); + HashMap<String,Object> keysAndNamesPropHash = new HashMap<String,Object>(); + for (AAIResourceKey aaiResKey : aaiResKeys.getAaiResourceKey()) { + keysAndNamesPropHash.put(aaiResKey.getKeyName(), "dummy"); + } + for (String nodeNameProp : aaiRes.getNodeNameProps().get(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,simpleName))) { + keysAndNamesPropHash.put(nodeNameProp, "dummy"); + } + pu.getAaiDynamicObjectFromVertex(aaiRes, thisObj, vert, aaiRes.getPropertyDataTypeMap(), keysAndNamesPropHash); + } + } else { + if (resultSet.getPropertyOverRideHash() != null && resultSet.getPropertyOverRideHash().size() > 0) { + HashMap<String,Object> propertyOverRideHash = resultSet.getPropertyOverRideHash(); + pu.getAaiDynamicObjectFromVertex(aaiRes, thisObj, vert, aaiRes.getPropertyDataTypeMap(), propertyOverRideHash); + } else { + pu.getAaiDynamicObjectFromVertex(aaiRes, thisObj, vert, aaiRes.getPropertyDataTypeMap()); + } + } + + if (thisObj != null) { + inventoryItem.set("item", thisObj); + + objectToVertMap.put(thisObj, vertId.toString()); + + String modelName = null; + try { + String personaModelId = (String)vert.<String>property("persona-model-id").orElse(null); + String personaModelVersion = (String)vert.<String>property("persona-model-version").orElse(null); + + if ( (personaModelId != null && personaModelVersion != null) + && (personaModelId.length() > 0 && personaModelVersion.length() > 0) ) { + HashMap<String,Object> modelLookupHash = new HashMap<String,Object>(); + + modelLookupHash.put("model-id", personaModelId); + modelLookupHash.put("model-version", personaModelVersion); + + TitanVertex modelVert = DbMeth.getUniqueNode(aaiExtMap.getTransId(), + aaiExtMap.getFromAppId(), g, "model", modelLookupHash, null); + + modelName = modelVert.<String>property("model-name").orElse(null); + // there should only be one, we'll pick the first if not + if (modelName.length() > 0) { + inventoryItem.set("modelName", modelName); + } + } + } catch (DynamicException e) { + ; // it's ok, dynamic object might not have these fields + } catch (AAIException e) { + if (e.getErrorObject().getErrorCode().equals("6114")) { + // it's ok, couldn't find a matching model + } else { + throw e; + } + } + + if (resultSet.getSubResultSet() != null) { + ArrayList<ResultSet> subResultSet = resultSet.getSubResultSet(); + if (subResultSet != null) { + ArrayList<DynamicEntity> res = unpackResultSet(g, subResultSet, jaxbContext, aaiResources, objectToVertMap, aaiExtMap); + if (res.size() > 0) { + inventoryItems.set("inventoryResponseItem", res); + inventoryItem.set("inventoryResponseItems", inventoryItems); + } + } + } + } + } + } + + return resultList; + } + +} |