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

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