gerrit.onap Code Review - ccsdk/cds.git/blob

   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.service.validator;\r
  18 \r
  19 import org.apache.commons.lang3.StringUtils;\r
  20 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants;\r
  21 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException;\r
  22 import org.onap.ccsdk.apps.controllerblueprints.core.ConfigModelConstant;\r
  23 import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType;\r
  24 import org.onap.ccsdk.apps.controllerblueprints.core.data.CapabilityDefinition;\r
  25 import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType;\r
  26 import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType;\r
  27 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils;\r
  28 import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType;\r
  29 \r
  30 import java.util.ArrayList;\r
  31 import java.util.List;\r
  32 \r
  33 /**\r
  34  * ModelTypeValidation.java Purpose: Provide Validation Service for Model Type ModelTypeValidation\r
  35  *\r
  36  * @author Brinda Santh\r
  37  * @version 1.0\r
  38  */\r
  39 \r
  40 public class ModelTypeValidator {\r
  41 \r
  42     private ModelTypeValidator() {\r
  43 \r
  44     }\r
  45 \r
  46     private static List<String> getValidModelDefinitionType() {\r
  47         List<String> validTypes = new ArrayList<>();\r
  48         validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE);\r
  49         validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE);\r
  50         validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE);\r
  51         validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE);\r
  52         validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE);\r
  53         return validTypes;\r
  54     }\r
  55 \r
  56     @Deprecated\r
  57     private static List<String> getValidModelDerivedFrom(String definitionType) {\r
  58         List<String> validTypes = new ArrayList<>();\r
  59         if (StringUtils.isNotBlank(definitionType)) {\r
  60             if (BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE.equalsIgnoreCase(definitionType)) {\r
  61                 validTypes.add(ConfigModelConstant.MODEL_TYPE_NODE_DG);\r
  62                 validTypes.add(ConfigModelConstant.MODEL_TYPE_NODE_COMPONENT);\r
  63                 validTypes.add(ConfigModelConstant.MODEL_TYPE_NODE_VNF);\r
  64                 validTypes.add(ConfigModelConstant.MODEL_TYPE_NODE_ARTIFACT);\r
  65             } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE.equalsIgnoreCase(definitionType)) {\r
  66                 validTypes.add(ConfigModelConstant.MODEL_TYPE_CAPABILITY_NETCONF);\r
  67                 validTypes.add(ConfigModelConstant.MODEL_TYPE_CAPABILITY_SSH);\r
  68                 validTypes.add(ConfigModelConstant.MODEL_TYPE_CAPABILITY_SFTP);\r
  69                 validTypes.add(ConfigModelConstant.MODEL_TYPE_CAPABILITY_CHEF);\r
  70                 validTypes.add(ConfigModelConstant.MODEL_TYPE_CAPABILITY_ANSIBLEF);\r
  71             } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE.equalsIgnoreCase(definitionType)) {\r
  72                 validTypes.add(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_DEPENDS_ON);\r
  73                 validTypes.add(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_HOSTED_ON);\r
  74                 validTypes.add(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO);\r
  75                 validTypes.add(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ATTACH_TO);\r
  76                 validTypes.add(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROUTES_TO);\r
  77             }\r
  78 \r
  79         }\r
  80         return validTypes;\r
  81     }\r
  82 \r
  83     /**\r
  84      * This is a validateNodeType\r
  85      * \r
  86      * @param definitionType\r
  87      * @param derivedFrom\r
  88      * @return boolean\r
  89      * @throws BluePrintException\r
  90      */\r
  91     public static boolean validateNodeType(String definitionType, String derivedFrom) throws BluePrintException {\r
  92         boolean valid = true;\r
  93         if (!BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE.equalsIgnoreCase(definitionType)\r
  94                 && !BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE.equalsIgnoreCase(definitionType)) {\r
  95             List<String> validTypes = getValidModelDerivedFrom(definitionType);\r
  96             if (!validTypes.contains(derivedFrom)) {\r
  97                 throw new BluePrintException(\r
  98                         "Not Valid Model Type (" + derivedFrom + "), It sould be " + validTypes);\r
  99             }\r
 100         }\r
 101         return valid;\r
 102     }\r
 103 \r
 104     /**\r
 105      * This is a validateModelTypeDefinition\r
 106      * \r
 107      * @param definitionType\r
 108      * @param definitionContent\r
 109      * @return boolean\r
 110      * @throws BluePrintException\r
 111      */\r
 112     public static boolean validateModelTypeDefinition(String definitionType, String definitionContent)\r
 113             throws BluePrintException {\r
 114         boolean valid = true;\r
 115         if (StringUtils.isNotBlank(definitionContent)) {\r
 116             if (BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE.equalsIgnoreCase(definitionType)) {\r
 117                 DataType dataType = JacksonUtils.readValue(definitionContent, DataType.class);\r
 118                 if (dataType == null) {\r
 119                     throw new BluePrintException(\r
 120                             "Model type definition is not DataType valid content " + definitionContent);\r
 121                 }\r
 122             } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE.equalsIgnoreCase(definitionType)) {\r
 123                 NodeType nodeType = JacksonUtils.readValue(definitionContent, NodeType.class);\r
 124                 if (nodeType == null) {\r
 125                     throw new BluePrintException(\r
 126                             "Model type definition is not NodeType valid content " + definitionContent);\r
 127                 }\r
 128             } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE.equalsIgnoreCase(definitionType)) {\r
 129                 ArtifactType artifactType = JacksonUtils.readValue(definitionContent, ArtifactType.class);\r
 130                 if (artifactType == null) {\r
 131                     throw new BluePrintException(\r
 132                             "Model type definition is not ArtifactType valid content " + definitionContent);\r
 133                 }\r
 134             }else if (BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE.equalsIgnoreCase(definitionType)) {\r
 135                 CapabilityDefinition capabilityDefinition =\r
 136                         JacksonUtils.readValue(definitionContent, CapabilityDefinition.class);\r
 137                 if (capabilityDefinition == null) {\r
 138                     throw new BluePrintException(\r
 139                             "Model type definition is not CapabilityDefinition valid content " + definitionContent);\r
 140                 }\r
 141             }\r
 142 \r
 143         }\r
 144         return valid;\r
 145     }\r
 146 \r
 147     /**\r
 148      * This is a validateModelType method\r
 149      * \r
 150      * @param modelType\r
 151      * @return boolean\r
 152      */\r
 153     public static boolean validateModelType(ModelType modelType) throws BluePrintException {\r
 154         if (modelType != null) {\r
 155 \r
 156             if (StringUtils.isBlank(modelType.getModelName())) {\r
 157                 throw new BluePrintException("Model Name Information is missing.");\r
 158             }\r
 159 \r
 160             if (StringUtils.isBlank(modelType.getDefinitionType())) {\r
 161                 throw new BluePrintException("Model Root Type Information is missing.");\r
 162             }\r
 163             if (StringUtils.isBlank(modelType.getDerivedFrom())) {\r
 164                 throw new BluePrintException("Model Type Information is missing.");\r
 165             }\r
 166 \r
 167             if (StringUtils.isBlank(modelType.getDefinition())) {\r
 168                 throw new BluePrintException("Model Definition Information is missing.");\r
 169             }\r
 170             if (StringUtils.isBlank(modelType.getDescription())) {\r
 171                 throw new BluePrintException("Model Description Information is missing.");\r
 172             }\r
 173 \r
 174             if (StringUtils.isBlank(modelType.getVersion())) {\r
 175                 throw new BluePrintException("Model Version Information is missing.");\r
 176             }\r
 177 \r
 178             if (StringUtils.isBlank(modelType.getUpdatedBy())) {\r
 179                 throw new BluePrintException("Model Updated By Information is missing.");\r
 180             }\r
 181 \r
 182             List<String> validRootTypes = getValidModelDefinitionType();\r
 183             if (!validRootTypes.contains(modelType.getDefinitionType())) {\r
 184                 throw new BluePrintException("Not Valid Model Root Type(" + modelType.getDefinitionType()\r
 185                         + "), It sould be " + validRootTypes);\r
 186             }\r
 187 \r
 188             validateModelTypeDefinition(modelType.getDefinitionType(), modelType.getDefinition());\r
 189 \r
 190             validateNodeType(modelType.getDefinitionType(), modelType.getDerivedFrom());\r
 191 \r
 192         } else {\r
 193             throw new BluePrintException("Model Type Information is missing.");\r
 194         }\r
 195 \r
 196         return true;\r
 197 \r
 198     }\r
 199 \r
 200 }\r