gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.healing.healers;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4 import org.openecomp.core.utilities.json.JsonUtil;
   5 import org.openecomp.sdc.common.utils.SdcCommon;
   6 import org.openecomp.sdc.datatypes.error.ErrorMessage;
   7 import org.openecomp.sdc.healing.interfaces.Healer;
   8 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
   9 import org.openecomp.sdc.heat.datatypes.structure.Artifact;
  10 import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree;
  11 import org.openecomp.sdc.heat.datatypes.structure.ValidationStructureList;
  12 import org.openecomp.sdc.logging.api.Logger;
  13 import org.openecomp.sdc.logging.api.LoggerFactory;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDaoFactory;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadData;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadDataEntity;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  21 import org.openecomp.sdc.versioning.dao.types.Version;
  22
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Objects;
  27 import java.util.Optional;
  28 import java.util.Set;
  29
  30 /**
  31  * Created by Talio on 7/30/2017.
  32  */
  33 public class ValidationStructureHealer implements Healer {
  34
  35   private static final VendorSoftwareProductInfoDao vspInfoDao =
  36       VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
  37   private static final OrchestrationTemplateDao orchestrationTemplateDao =
  38       OrchestrationTemplateDaoFactory.getInstance().createInterface();
  39   private static final Logger logger = LoggerFactory.getLogger(JsonUtil.class);
  40
  41   @Override
  42   public Object heal(Map<String, Object> healingParams) throws Exception {
  43
  44     String vspId = (String) healingParams.get(SdcCommon.VSP_ID);
  45     Version version = (Version) healingParams.get(SdcCommon.VERSION);
  46
  47     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
  48     UploadDataEntity orchestrationTemplate =
  49         orchestrationTemplateDao.getOrchestrationTemplate(vspId, version);
  50
  51     OldValidationStructureTree oldValidationStructureTree;
  52     try{
  53       oldValidationStructureTree =
  54           JsonUtil.json2Object(orchestrationTemplate.getValidationData(), OldValidationStructureTree
  55               .class);
  56     } catch (Exception e){
  57       logger.debug("",e);
  58       return Optional.empty();
  59     }
  60
  61     Optional<HeatStructureTree> newHeatStructureTreeFromOldStructureTree =
  62         createNewHeatStructureTreeFromOldStructureTree(oldValidationStructureTree.getImportStructure());
  63
  64     if(newHeatStructureTreeFromOldStructureTree.isPresent()){
  65       ValidationStructureList validationData = new ValidationStructureList
  66           (newHeatStructureTreeFromOldStructureTree.get());
  67       vspDetails.setValidationDataStructure(validationData);
  68
  69       updateValuesInDb(vspId, vspDetails, orchestrationTemplate, validationData);
  70     }
  71     return newHeatStructureTreeFromOldStructureTree;
  72
  73   }
  74
  75   private void updateValuesInDb(String vspId, VspDetails vspDetails,
  76                                 UploadDataEntity orchestrationTemplate,
  77                                 ValidationStructureList validationData) {
  78     vspInfoDao.update(vspDetails);
  79     UploadData uploadData = getUpdatedUploadData(orchestrationTemplate, validationData);
  80     orchestrationTemplateDao.updateOrchestrationTemplateData(vspId, uploadData);
  81   }
  82
  83   private UploadData getUpdatedUploadData(UploadDataEntity orchestrationTemplate,
  84                                           ValidationStructureList validationData) {
  85     UploadData uploadData = new UploadData();
  86     uploadData.setValidationDataStructure(validationData);
  87     uploadData.setValidationData(JsonUtil.object2Json(validationData));
  88     uploadData.setContentData(orchestrationTemplate.getContentData());
  89     uploadData.setId(orchestrationTemplate.getId());
  90     uploadData.setPackageName(orchestrationTemplate.getPackageName());
  91     uploadData.setPackageVersion(orchestrationTemplate.getPackageVersion());
  92     return uploadData;
  93   }
  94
  95
  96   private Optional<HeatStructureTree> createNewHeatStructureTreeFromOldStructureTree(OldHeatStructureTree
  97                                                                oldHeatStructureTree){
  98
  99     HeatStructureTree heatStructureTree = new HeatStructureTree();
 100
 101     if(Objects.isNull(oldHeatStructureTree)){
 102       return Optional.empty();
 103     }
 104
 105     mapOldHeatStructureTreeValues(oldHeatStructureTree, heatStructureTree);
 106
 107     Set<OldHeatStructureTree> heat =
 108         oldHeatStructureTree.getHeat() == null ? new HashSet<>() : oldHeatStructureTree.getHeat();
 109     Set<OldHeatStructureTree> volume =
 110         oldHeatStructureTree.getVolume() == null ? new HashSet<>() : oldHeatStructureTree.getVolume();
 111     Set<OldHeatStructureTree> nested =
 112         oldHeatStructureTree.getNested() == null ? new HashSet<>() : oldHeatStructureTree.getNested();
 113     Set<OldHeatStructureTree> network =
 114         oldHeatStructureTree.getNetwork() == null ? new HashSet<>() : oldHeatStructureTree.getNetwork();
 115
 116
 117     heatStructureTree.setHeat(createHeatStructureTreeSetFromOld(heat));
 118     heatStructureTree.setVolume(createHeatStructureTreeSetFromOld(volume));
 119     heatStructureTree.setNested(createHeatStructureTreeSetFromOld(nested));
 120     heatStructureTree.setNetwork(createHeatStructureTreeSetFromOld(network));
 121
 122
 123     return Optional.of(heatStructureTree);
 124
 125   }
 126
 127   private void mapOldHeatStructureTreeValues(
 128       OldHeatStructureTree oldHeatStructureTree,
 129       HeatStructureTree heatStructureTree) {
 130     heatStructureTree.setFileName(oldHeatStructureTree.getFileName());
 131     heatStructureTree.setBase(oldHeatStructureTree.getBase());
 132     heatStructureTree.setType(oldHeatStructureTree.getType());
 133     heatStructureTree.setArtifacts(oldHeatStructureTree.getArtifacts());
 134     heatStructureTree.setErrors(oldHeatStructureTree.getErrors());
 135
 136     if(Objects.nonNull(oldHeatStructureTree.getEnv())) {
 137       heatStructureTree.setEnv(new HeatStructureTree(oldHeatStructureTree.getEnv(), false));
 138     }
 139   }
 140
 141   private Set<HeatStructureTree> createHeatStructureTreeSetFromOld(Set<OldHeatStructureTree>
 142                                                                         oldHeatStructureTreeSet){
 143     if(CollectionUtils.isEmpty(oldHeatStructureTreeSet)){
 144       return null;
 145     }
 146     Set<HeatStructureTree> newHeatStructureSet = new HashSet<>();
 147
 148     for(OldHeatStructureTree old : oldHeatStructureTreeSet){
 149       Optional<HeatStructureTree> newHeatStructureTree =
 150           createNewHeatStructureTreeFromOldStructureTree(old);
 151       if(newHeatStructureTree.isPresent()){
 152         newHeatStructureSet.add(newHeatStructureTree.get());
 153       }
 154     }
 155
 156     return newHeatStructureSet;
 157   }
 158
 159   private class OldValidationStructureTree{
 160     private OldHeatStructureTree importStructure;
 161
 162     public OldHeatStructureTree getImportStructure() {
 163       return importStructure;
 164     }
 165
 166     public void setImportStructure(
 167         OldHeatStructureTree importStructure) {
 168       this.importStructure = importStructure;
 169     }
 170   }
 171
 172   private class OldHeatStructureTree{
 173     private String fileName;
 174     private FileData.Type type;
 175     private Boolean isBase;
 176     private String env;
 177     private List<ErrorMessage> errors;
 178     private Set<OldHeatStructureTree> heat;
 179     private Set<OldHeatStructureTree> volume;
 180     private Set<OldHeatStructureTree> network;
 181     private Set<OldHeatStructureTree> nested;
 182     private Set<OldHeatStructureTree> other;
 183     private Set<Artifact> artifacts;
 184
 185     public OldHeatStructureTree() {
 186     }
 187
 188   public String getFileName() {
 189     return fileName;
 190   }
 191
 192   public void setFileName(String fileName) {
 193     this.fileName = fileName;
 194   }
 195
 196   public FileData.Type getType() {
 197     return type;
 198   }
 199
 200   public void setType(FileData.Type type) {
 201     this.type = type;
 202   }
 203
 204   public Boolean getBase() {
 205     return isBase;
 206   }
 207
 208   public void setBase(Boolean base) {
 209     isBase = base;
 210   }
 211
 212   public String getEnv() {
 213     return env;
 214   }
 215
 216   public void setEnv(String env) {
 217     this.env = env;
 218   }
 219
 220   public List<ErrorMessage> getErrors() {
 221     return errors;
 222   }
 223
 224   public void setErrors(List<ErrorMessage> errors) {
 225     this.errors = errors;
 226   }
 227
 228   public Set<OldHeatStructureTree> getHeat() {
 229     return heat;
 230   }
 231
 232   public void setHeat(Set<OldHeatStructureTree> heat) {
 233     this.heat = heat;
 234   }
 235
 236   public Set<OldHeatStructureTree> getVolume() {
 237     return volume;
 238   }
 239
 240   public void setVolume(Set<OldHeatStructureTree> volume) {
 241     this.volume = volume;
 242   }
 243
 244   public Set<OldHeatStructureTree> getNetwork() {
 245     return network;
 246   }
 247
 248   public void setNetwork(
 249       Set<OldHeatStructureTree> network) {
 250     this.network = network;
 251   }
 252
 253   public Set<OldHeatStructureTree> getNested() {
 254     return nested;
 255   }
 256
 257   public void setNested(Set<OldHeatStructureTree> nested) {
 258     this.nested = nested;
 259   }
 260
 261   public Set<OldHeatStructureTree> getOther() {
 262     return other;
 263   }
 264
 265   public void setOther(Set<OldHeatStructureTree> other) {
 266     this.other = other;
 267   }
 268
 269   public Set<Artifact> getArtifacts() {
 270     return artifacts;
 271   }
 272
 273   public void setArtifacts(Set<Artifact> artifacts) {
 274     this.artifacts = artifacts;
 275   }
 276 }
 277 }