components/core/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/core/service/BluePrintExpressionService.kt

   1 /*\r
   2  * Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  *\r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *     http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 package org.onap.ccsdk.apps.controllerblueprints.core.service\r
  18 \r
  19 import com.att.eelf.configuration.EELFLogger\r
  20 import com.att.eelf.configuration.EELFManager\r
  21 import com.fasterxml.jackson.databind.JsonNode\r
  22 import com.fasterxml.jackson.databind.node.ArrayNode\r
  23 import com.fasterxml.jackson.databind.node.ObjectNode\r
  24 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants\r
  25 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
  26 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes\r
  27 import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
  28 \r
  29 /**\r
  30  *\r
  31  *\r
  32  * @author Brinda Santh\r
  33  */\r
  34 object BluePrintExpressionService {\r
  35     val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())\r
  36 \r
  37     @JvmStatic\r
  38     fun getExpressionData(propertyAssignmentNode: JsonNode): ExpressionData {\r
  39         log.trace("Assignment Data/Expression : {}", propertyAssignmentNode)\r
  40         val expressionData = ExpressionData(valueNode = propertyAssignmentNode)\r
  41         if (propertyAssignmentNode is ObjectNode) {\r
  42 \r
  43             val commands: Set<String> = propertyAssignmentNode.fieldNames().asSequence().toList().intersect(BluePrintTypes.validCommands())\r
  44             if (commands.isNotEmpty()) {\r
  45                 expressionData.isExpression = true\r
  46                 expressionData.command = commands.first()\r
  47                 expressionData.expressionNode = propertyAssignmentNode\r
  48 \r
  49                 when (expressionData.command) {\r
  50                     BluePrintConstants.EXPRESSION_GET_INPUT -> {\r
  51                         expressionData.inputExpression = populateInputExpression(propertyAssignmentNode)\r
  52                     }\r
  53                     BluePrintConstants.EXPRESSION_GET_ATTRIBUTE -> {\r
  54                         expressionData.attributeExpression = populateAttributeExpression(propertyAssignmentNode)\r
  55                     }\r
  56                     BluePrintConstants.EXPRESSION_GET_PROPERTY -> {\r
  57                         expressionData.propertyExpression = populatePropertyExpression(propertyAssignmentNode)\r
  58                     }\r
  59                     BluePrintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {\r
  60                         expressionData.operationOutputExpression = populateOperationOutputExpression(propertyAssignmentNode)\r
  61                     }\r
  62                     BluePrintConstants.EXPRESSION_GET_ARTIFACT -> {\r
  63                         expressionData.artifactExpression = populateArtifactExpression(propertyAssignmentNode)\r
  64                     }\r
  65                 }\r
  66             }\r
  67         }\r
  68         return expressionData\r
  69     }\r
  70 \r
  71     @JvmStatic\r
  72     fun populateInputExpression(jsonNode: JsonNode): InputExpression {\r
  73         return InputExpression(propertyName = jsonNode.first().textValue())\r
  74     }\r
  75 \r
  76     @JvmStatic\r
  77     fun populatePropertyExpression(jsonNode: JsonNode): PropertyExpression {\r
  78         val arrayNode: ArrayNode = jsonNode.first() as ArrayNode\r
  79         check(arrayNode.size() >= 2) {\r
  80             throw BluePrintException(String.format("missing property expression, " +\r
  81                     "it should be [ <modelable_entity_name>, <optional_req_or_cap_name>, <property_name>, " +\r
  82                     "<nested_property_name_or_index_1>, ..., <nested_property_name_or_index_n> ] , but present {}", jsonNode))\r
  83         }\r
  84         var reqOrCapEntityName: String? = null\r
  85         var propertyName = ""\r
  86         var subProperty: String? = null\r
  87         when {\r
  88             arrayNode.size() == 2 -> propertyName = arrayNode[1].textValue()\r
  89             arrayNode.size() == 3 -> {\r
  90                 reqOrCapEntityName = arrayNode[1].textValue()\r
  91                 propertyName = arrayNode[2].textValue()\r
  92             }\r
  93             arrayNode.size() > 3 -> {\r
  94                 reqOrCapEntityName = arrayNode[1].textValue()\r
  95                 propertyName = arrayNode[2].textValue()\r
  96                 val propertyPaths: List<String> = arrayNode.filterIndexed { index, _ ->\r
  97                     index >= 3\r
  98                 }.map { it.textValue() }\r
  99                 subProperty = propertyPaths.joinToString("/")\r
 100             }\r
 101         }\r
 102 \r
 103         return PropertyExpression(modelableEntityName = arrayNode[0].asText(),\r
 104                 reqOrCapEntityName = reqOrCapEntityName,\r
 105                 propertyName = propertyName,\r
 106                 subPropertyName = subProperty\r
 107         )\r
 108     }\r
 109 \r
 110     @JvmStatic\r
 111     fun populateAttributeExpression(jsonNode: JsonNode): AttributeExpression {\r
 112         val arrayNode: ArrayNode = jsonNode.first() as ArrayNode\r
 113         check(arrayNode.size() >= 2) {\r
 114             throw BluePrintException(String.format("missing attribute expression, " +\r
 115                     "it should be [ <modelable_entity_name>, <optional_req_or_cap_name>, <attribute_name>," +\r
 116                     " <nested_attribute_name_or_index_1>, ..., <nested_attribute_name_or_index_n> ] , but present {}", jsonNode))\r
 117         }\r
 118 \r
 119         var reqOrCapEntityName: String? = null\r
 120         var attributeName = ""\r
 121         var subAttributeName: String? = null\r
 122         when {\r
 123             arrayNode.size() == 2 -> attributeName = arrayNode[1].textValue()\r
 124             arrayNode.size() == 3 -> {\r
 125                 reqOrCapEntityName = arrayNode[1].textValue()\r
 126                 attributeName = arrayNode[2].textValue()\r
 127             }\r
 128             arrayNode.size() > 3 -> {\r
 129                 reqOrCapEntityName = arrayNode[1].textValue()\r
 130                 attributeName = arrayNode[2].textValue()\r
 131                 val propertyPaths: List<String> = arrayNode.filterIndexed { index, _ ->\r
 132                     index >= 3\r
 133                 }.map { it.textValue() }\r
 134                 subAttributeName = propertyPaths.joinToString("/")\r
 135             }\r
 136         }\r
 137         return AttributeExpression(modelableEntityName = arrayNode[0].asText(),\r
 138                 reqOrCapEntityName = reqOrCapEntityName,\r
 139                 attributeName = attributeName,\r
 140                 subAttributeName = subAttributeName\r
 141         )\r
 142     }\r
 143 \r
 144     @JvmStatic\r
 145     fun populateOperationOutputExpression(jsonNode: JsonNode): OperationOutputExpression {\r
 146         val arrayNode: ArrayNode = jsonNode.first() as ArrayNode\r
 147 \r
 148         check(arrayNode.size() >= 4) {\r
 149             throw BluePrintException(String.format("missing operation output expression, " +\r
 150                     "it should be (<modelable_entity_name>, <interface_name>, <operation_name>, <output_variable_name>) , but present {}", jsonNode))\r
 151         }\r
 152         return OperationOutputExpression(modelableEntityName = arrayNode[0].asText(),\r
 153                 interfaceName = arrayNode[1].asText(),\r
 154                 operationName = arrayNode[2].asText(),\r
 155                 propertyName = arrayNode[3].asText()\r
 156         )\r
 157     }\r
 158 \r
 159     @JvmStatic\r
 160     fun populateArtifactExpression(jsonNode: JsonNode): ArtifactExpression {\r
 161         val arrayNode: ArrayNode = jsonNode.first() as ArrayNode\r
 162 \r
 163         check(arrayNode.size() >= 2) {\r
 164             throw BluePrintException(String.format("missing artifact expression, " +\r
 165                     "it should be [ <modelable_entity_name>, <artifact_name>, <location>, <remove> ] , but present {}", jsonNode))\r
 166         }\r
 167         return ArtifactExpression(modelableEntityName = arrayNode[0].asText(),\r
 168                 artifactName = arrayNode[1].asText(),\r
 169                 location = arrayNode[2]?.asText() ?: "LOCAL_FILE",\r
 170                 remove = arrayNode[3]?.asBoolean() ?: false\r
 171         )\r
 172     }\r
 173 }