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