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 org.openo.commontosca.catalog.common.ToolUtil;
  19 import org.openo.commontosca.catalog.db.entity.NodeTemplateData;
  20 import org.openo.commontosca.catalog.db.entity.ServiceTemplateData;
  21 import org.openo.commontosca.catalog.db.entity.ServiceTemplateMappingData;
  22 import org.openo.commontosca.catalog.db.entity.TemplateData;
  23 import org.openo.commontosca.catalog.db.exception.CatalogResourceException;
  24 import org.openo.commontosca.catalog.entity.response.CsarFileUriResponse;
  25 import org.openo.commontosca.catalog.model.entity.NodeTemplate;
  26 import org.openo.commontosca.catalog.model.entity.Parameters;
  27 import org.openo.commontosca.catalog.model.entity.RelationShip;
  28 import org.openo.commontosca.catalog.model.entity.ServiceTemplate;
  29 import org.openo.commontosca.catalog.model.entity.ServiceTemplateOperation;
  30 import org.openo.commontosca.catalog.model.entity.SubstitutionMapping;
  31 import org.openo.commontosca.catalog.wrapper.PackageWrapper;
  32
  33 import com.google.gson.Gson;
  34 import com.google.gson.JsonElement;
  35 import com.google.gson.JsonObject;
  36 import com.google.gson.JsonPrimitive;
  37
  38 import java.util.ArrayList;
  39 import java.util.Arrays;
  40 import java.util.HashMap;
  41 import java.util.Iterator;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.Map.Entry;
  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    * @throws CatalogResourceException
 127    */
 128   public static ServiceTemplate[] convert2ServiceTemplates(List<ServiceTemplateData> stdList) throws CatalogResourceException {
 129     List<ServiceTemplate> stList = new ArrayList<>();
 130     for (ServiceTemplateData std : stdList) {
 131       stList.add(convert2ServiceTemplate(std));
 132     }
 133
 134     return stList.toArray(new ServiceTemplate[0]);
 135   }
 136
 137   /**
 138    * covert to service template.
 139    * @param std ServiceTemplateData
 140    * @return ServiceTemplate
 141    * @throws CatalogResourceException
 142    */
 143   public static ServiceTemplate convert2ServiceTemplate(ServiceTemplateData std) throws CatalogResourceException {
 144     Parameters parameters = ToolUtil.fromJson(std.getInputs(), Parameters.class);
 145     ServiceTemplateOperation[] operations =
 146         ToolUtil.fromJson(std.getOperations(), ServiceTemplateOperation[].class);
 147     String downloadUri = buildSTDownloadUri(std.getCsarId(), std.getDownloadUri());
 148
 149     return new ServiceTemplate(std.getServiceTemplateId(), std.getTemplateName(), std.getVendor(),
 150         std.getVersion(), std.getCsarId(), std.getType(), downloadUri,
 151         parameters.getInputs(), parameters.getOutputs(), operations);
 152   }
 153
 154   private static String buildSTDownloadUri(String packageId, String stFileName)
 155       throws CatalogResourceException {
 156     CsarFileUriResponse stDownloadUri =
 157         PackageWrapper.getInstance().getCsarFileDownloadUri(packageId, stFileName);
 158     return stDownloadUri.getDownloadUri();
 159   }
 160
 161   /**
 162    * covert to nodeTemplates.
 163    * @param ntdList NodeTemplateData list
 164    * @return NodeTemplate list
 165    */
 166   public static NodeTemplate[] convert2NodeTemplates(List<NodeTemplateData> ntdList) {
 167     List<NodeTemplate> ntList = new ArrayList<>();
 168     for (NodeTemplateData ntd : ntdList) {
 169       ntList.add(convert2NodeTemplate(ntd));
 170     }
 171     return ntList.toArray(new NodeTemplate[0]);
 172   }
 173
 174   /**
 175    * covert to nodeTemplate.
 176    * @param ntd NodeTemplateData
 177    * @return NodeTemplate
 178    */
 179   public static NodeTemplate convert2NodeTemplate(NodeTemplateData ntd) {
 180     List<RelationShip> relationShips = convert2RelationShipList(ntd.getRelationShips());
 181     return new NodeTemplate(ntd.getNodeTemplateId(), ntd.getName(), ntd.getType(),
 182         convert2Property(ntd.getProperties()), relationShips);
 183   }
 184
 185   /**
 186    * covert to relationship list.
 187    * @param sRelationShips relationships
 188    * @return RelationShip list
 189    */
 190   private static List<RelationShip> convert2RelationShipList(String srelationShips) {
 191     RelationShip[] relationShips = ToolUtil.fromJson(srelationShips, RelationShip[].class);
 192     return Arrays.asList(relationShips);
 193   }
 194
 195   /**
 196    * convert to propterty.
 197    * @param properties properties to covert
 198    * @return map
 199    */
 200   private static Map<String, Object> convert2Property(String properties) {
 201     JsonObject jsonObject = new Gson().fromJson(properties, JsonObject.class);
 202     return parseMapValue(jsonObject);
 203   }
 204
 205   private static Map<String, Object> parseMapValue(JsonObject jsonObject) {
 206     Map<String, Object> map = new HashMap<>();
 207
 208     Iterator<Entry<String, JsonElement>> iterator = jsonObject.entrySet().iterator();
 209     while (iterator.hasNext()) {
 210       Entry<String, JsonElement> next = iterator.next();
 211       if (next.getValue() instanceof JsonPrimitive) {
 212         map.put(next.getKey(), next.getValue().getAsString());
 213         continue;
 214       }
 215
 216       if (next.getValue() instanceof JsonObject) {
 217         map.put(next.getKey(), parseMapValue((JsonObject) next.getValue()));
 218         continue;
 219       }
 220     }
 221     return map;
 222   }
 223
 224
 225   /**
 226    * covert to template mapping data.
 227    * @param stm data to convert
 228    * @return ServiceTemplateMappingData
 229    */
 230   public static ServiceTemplateMappingData convert2TemplateMappingData(SubstitutionMapping stm) {
 231     ServiceTemplateMappingData stmd = new ServiceTemplateMappingData();
 232
 233     stmd.setMappingId(ToolUtil.generateId());
 234     stmd.setServiceTemplateId(stm.getServiceTemplateId());
 235     stmd.setNodeType(stm.getNodeType());
 236     stmd.setRequirements(ToolUtil.toJson(stm.getRequirements()));
 237     stmd.setCapabilities(ToolUtil.toJson(stm.getCapabilities()));
 238
 239     return stmd;
 240   }
 241
 242   /**
 243    * convert to substitution mapping.
 244    * @param stmData data to covert
 245    * @return SubstitutionMapping
 246    */
 247   public static SubstitutionMapping convert2SubstitutionMapping(
 248       ServiceTemplateMappingData stmData) {
 249     return new SubstitutionMapping(stmData.getServiceTemplateId(), stmData.getNodeType());
 250   }
 251
 252 }