gerrit.onap Code Review - vfc/nfvo/catalog.git/blob

   1 /**
   2  * Copyright 2016 ZTE Corporation.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openo.commontosca.catalog.model.common;
  17
  18 import com.google.gson.Gson;
  19 import com.google.gson.JsonElement;
  20 import com.google.gson.JsonObject;
  21 import com.google.gson.JsonPrimitive;
  22
  23 import org.openo.commontosca.catalog.common.ToolUtil;
  24 import org.openo.commontosca.catalog.db.entity.NodeTemplateData;
  25 import org.openo.commontosca.catalog.db.entity.ServiceTemplateData;
  26 import org.openo.commontosca.catalog.db.entity.ServiceTemplateMappingData;
  27 import org.openo.commontosca.catalog.db.entity.TemplateData;
  28 import org.openo.commontosca.catalog.model.entity.NodeTemplate;
  29 import org.openo.commontosca.catalog.model.entity.Parameters;
  30 import org.openo.commontosca.catalog.model.entity.RelationShip;
  31 import org.openo.commontosca.catalog.model.entity.ServiceTemplate;
  32 import org.openo.commontosca.catalog.model.entity.ServiceTemplateOperation;
  33 import org.openo.commontosca.catalog.model.entity.SubstitutionMapping;
  34
  35 import java.util.ArrayList;
  36 import java.util.Arrays;
  37 import java.util.HashMap;
  38 import java.util.Iterator;
  39 import java.util.List;
  40 import java.util.Map;
  41 import java.util.Map.Entry;
  42
  43
  44
  45 public class TemplateDataHelper {
  46
  47   /**
  48    * convert to template data.
  49    * @param st ServiceTemplate
  50    * @param ntList NodeTemplate list
  51    * @return TemplateData
  52    */
  53   public static TemplateData convert2TemplateData(ServiceTemplate st, String rawData,
  54       List<NodeTemplate> ntList) {
  55     TemplateData td = new TemplateData();
  56     td.setServiceTemplate(convert2ServiceTemplateData(st, rawData));
  57     td.setNodeTemplates(convert2NodeTemplateDataList(ntList, st.getServiceTemplateId()));
  58     return td;
  59   }
  60
  61   /**
  62    * convert to service template data.
  63    * @param st ServiceTemplate
  64    * @return ServiceTemplateData
  65    */
  66   private static ServiceTemplateData convert2ServiceTemplateData(ServiceTemplate st,
  67       String rawData) {
  68     ServiceTemplateData std = new ServiceTemplateData();
  69     std.setServiceTemplateId(st.getServiceTemplateId());
  70     std.setTemplateName(st.getTemplateName());
  71     std.setVendor(st.getVendor());
  72     std.setVersion(st.getVersion());
  73     std.setCsarId(st.getCsarid());
  74     std.setType(st.getType());
  75     std.setDownloadUri(st.getDownloadUri());
  76     Parameters parameters = new Parameters(st.getInputs(), st.getOutputs());
  77     std.setInputs(ToolUtil.toJson(parameters));
  78     std.setOperations(ToolUtil.toJson(st.getOperations()));
  79     std.setRowData(rawData);
  80     return std;
  81   }
  82
  83   /**
  84    * convert to nodeTemplate data list.
  85    * @param ntList NodeTemplate list
  86    * @param serviceTemplateId service template id
  87    * @return NodeTemplateData list
  88    */
  89   private static ArrayList<NodeTemplateData> convert2NodeTemplateDataList(List<NodeTemplate> ntList,
  90       String serviceTemplateId) {
  91     ArrayList<NodeTemplateData> ntdList = new ArrayList<>();
  92     for (NodeTemplate nt : ntList) {
  93       ntdList.add(convert2NodeTemplateData(nt, serviceTemplateId));
  94
  95     }
  96     return ntdList;
  97   }
  98
  99
 100   /**
 101    * convert to nodeTemplate data.
 102    * @param nt NodeTemplate
 103    * @param serviceTemplateId service template id
 104    * @return NodeTemplateData
 105    */
 106   private static NodeTemplateData convert2NodeTemplateData(NodeTemplate nt,
 107       String serviceTemplateId) {
 108     NodeTemplateData ntd = new NodeTemplateData();
 109
 110     ntd.setNodeTemplateId(nt.getId());
 111     ntd.setName(nt.getName());
 112     ntd.setType(nt.getType());
 113     ntd.setServiceTemplateId(serviceTemplateId);
 114     ntd.setProperties(ToolUtil.toJson(nt.getProperties()));
 115     ntd.setRelationShips(ToolUtil.toJson(nt.getRelationShips()));
 116
 117     return ntd;
 118   }
 119
 120
 121   /**
 122    * convert to service templates.
 123    * @param stdList ServiceTemplateData list
 124    * @return ServiceTemplate list
 125    */
 126   public static ServiceTemplate[] convert2ServiceTemplates(List<ServiceTemplateData> stdList) {
 127     List<ServiceTemplate> stList = new ArrayList<>();
 128     for (ServiceTemplateData std : stdList) {
 129       stList.add(convert2ServiceTemplate(std));
 130     }
 131
 132     return stList.toArray(new ServiceTemplate[0]);
 133   }
 134
 135   /**
 136    * covert to service template.
 137    * @param std ServiceTemplateData
 138    * @return ServiceTemplate
 139    */
 140   public static ServiceTemplate convert2ServiceTemplate(ServiceTemplateData std) {
 141     Parameters parameters = ToolUtil.fromJson(std.getInputs(), Parameters.class);
 142     ServiceTemplateOperation[] operations =
 143         ToolUtil.fromJson(std.getOperations(), ServiceTemplateOperation[].class);
 144
 145     return new ServiceTemplate(std.getServiceTemplateId(), std.getTemplateName(), std.getVendor(),
 146         std.getVersion(), std.getCsarId(), std.getType(), std.getDownloadUri(),
 147         parameters.getInputs(), parameters.getOutputs(), operations);
 148   }
 149
 150   /**
 151    * covert to nodeTemplates.
 152    * @param ntdList NodeTemplateData list
 153    * @return NodeTemplate list
 154    */
 155   public static NodeTemplate[] convert2NodeTemplates(List<NodeTemplateData> ntdList) {
 156     List<NodeTemplate> ntList = new ArrayList<>();
 157     for (NodeTemplateData ntd : ntdList) {
 158       ntList.add(convert2NodeTemplate(ntd));
 159     }
 160     return ntList.toArray(new NodeTemplate[0]);
 161   }
 162
 163   /**
 164    * covert to nodeTemplate.
 165    * @param ntd NodeTemplateData
 166    * @return NodeTemplate
 167    */
 168   public static NodeTemplate convert2NodeTemplate(NodeTemplateData ntd) {
 169     List<RelationShip> relationShips = convert2RelationShipList(ntd.getRelationShips());
 170     return new NodeTemplate(ntd.getNodeTemplateId(), ntd.getName(), ntd.getType(),
 171         convert2Property(ntd.getProperties()), relationShips);
 172   }
 173
 174   /**
 175    * covert to relationship list.
 176    * @param sRelationShips relationships
 177    * @return RelationShip list
 178    */
 179   private static List<RelationShip> convert2RelationShipList(String srelationShips) {
 180     RelationShip[] relationShips = ToolUtil.fromJson(srelationShips, RelationShip[].class);
 181     return Arrays.asList(relationShips);
 182   }
 183
 184   /**
 185    * convert to propterty.
 186    * @param properties properties to covert
 187    * @return map
 188    */
 189   private static Map<String, Object> convert2Property(String properties) {
 190     JsonObject jsonObject = new Gson().fromJson(properties, JsonObject.class);
 191     return parseMapValue(jsonObject);
 192   }
 193
 194   private static Map<String, Object> parseMapValue(JsonObject jsonObject) {
 195     Map<String, Object> map = new HashMap<>();
 196
 197     Iterator<Entry<String, JsonElement>> iterator = jsonObject.entrySet().iterator();
 198     while (iterator.hasNext()) {
 199       Entry<String, JsonElement> next = iterator.next();
 200       if (next.getValue() instanceof JsonPrimitive) {
 201         map.put(next.getKey(), next.getValue().getAsString());
 202         continue;
 203       }
 204
 205       if (next.getValue() instanceof JsonObject) {
 206         map.put(next.getKey(), parseMapValue((JsonObject) next.getValue()));
 207         continue;
 208       }
 209     }
 210     return map;
 211   }
 212
 213
 214   /**
 215    * covert to template mapping data.
 216    * @param stm data to convert
 217    * @return ServiceTemplateMappingData
 218    */
 219   public static ServiceTemplateMappingData convert2TemplateMappingData(SubstitutionMapping stm) {
 220     ServiceTemplateMappingData stmd = new ServiceTemplateMappingData();
 221
 222     stmd.setMappingId(ToolUtil.generateId());
 223     stmd.setServiceTemplateId(stm.getServiceTemplateId());
 224     stmd.setNodeType(stm.getNodeType());
 225     stmd.setRequirements(ToolUtil.toJson(stm.getRequirements()));
 226     stmd.setCapabilities(ToolUtil.toJson(stm.getCapabilities()));
 227
 228     return stmd;
 229   }
 230
 231   /**
 232    * convert to substitution mapping.
 233    * @param stmData data to covert
 234    * @return SubstitutionMapping
 235    */
 236   public static SubstitutionMapping convert2SubstitutionMapping(
 237       ServiceTemplateMappingData stmData) {
 238     return new SubstitutionMapping(stmData.getServiceTemplateId(), stmData.getNodeType());
 239   }
 240
 241 }