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     if(Objects.isNull(orchestrationTemplate.getValidationData())
  52         || !JsonUtil.isValidJson(orchestrationTemplate.getValidationData())){
  53       return Optional.empty();
  54     }
  55
  56     OldValidationStructureTree oldValidationStructureTree;
  57     try{
  58       oldValidationStructureTree =
  59           JsonUtil.json2Object(orchestrationTemplate.getValidationData(), OldValidationStructureTree
  60               .class);
  61     } catch (Exception e){
  62       logger.debug("",e);
  63       return Optional.empty();
  64     }
  65
  66     Optional<HeatStructureTree> newHeatStructureTreeFromOldStructureTree =
  67         createNewHeatStructureTreeFromOldStructureTree(oldValidationStructureTree.getImportStructure());
  68
  69     if(newHeatStructureTreeFromOldStructureTree.isPresent()){
  70       ValidationStructureList validationData = new ValidationStructureList
  71           (newHeatStructureTreeFromOldStructureTree.get());
  72       vspDetails.setValidationDataStructure(validationData);
  73
  74       updateValuesInDb(vspId, vspDetails, orchestrationTemplate, validationData);
  75     }
  76     return newHeatStructureTreeFromOldStructureTree;
  77
  78   }
  79
  80   private void updateValuesInDb(String vspId, VspDetails vspDetails,
  81                                 UploadDataEntity orchestrationTemplate,
  82                                 ValidationStructureList validationData) {
  83     vspInfoDao.update(vspDetails);
  84     UploadData uploadData = getUpdatedUploadData(orchestrationTemplate, validationData);
  85     orchestrationTemplateDao.updateOrchestrationTemplateData(vspId, uploadData);
  86   }
  87
  88   private UploadData getUpdatedUploadData(UploadDataEntity orchestrationTemplate,
  89                                           ValidationStructureList validationData) {
  90     UploadData uploadData = new UploadData();
  91     uploadData.setValidationDataStructure(validationData);
  92     uploadData.setValidationData(JsonUtil.object2Json(validationData));
  93     uploadData.setContentData(orchestrationTemplate.getContentData());
  94     uploadData.setId(orchestrationTemplate.getId());
  95     uploadData.setPackageName(orchestrationTemplate.getPackageName());
  96     uploadData.setPackageVersion(orchestrationTemplate.getPackageVersion());
  97     return uploadData;
  98   }
  99
 100
 101   private Optional<HeatStructureTree> createNewHeatStructureTreeFromOldStructureTree(OldHeatStructureTree
 102                                                                oldHeatStructureTree){
 103
 104     HeatStructureTree heatStructureTree = new HeatStructureTree();
 105
 106     if(Objects.isNull(oldHeatStructureTree)){
 107       return Optional.empty();
 108     }
 109
 110     mapOldHeatStructureTreeValues(oldHeatStructureTree, heatStructureTree);
 111
 112     Set<OldHeatStructureTree> heat =
 113         oldHeatStructureTree.getHeat() == null ? new HashSet<>() : oldHeatStructureTree.getHeat();
 114     Set<OldHeatStructureTree> volume =
 115         oldHeatStructureTree.getVolume() == null ? new HashSet<>() : oldHeatStructureTree.getVolume();
 116     Set<OldHeatStructureTree> nested =
 117         oldHeatStructureTree.getNested() == null ? new HashSet<>() : oldHeatStructureTree.getNested();
 118     Set<OldHeatStructureTree> network =
 119         oldHeatStructureTree.getNetwork() == null ? new HashSet<>() : oldHeatStructureTree.getNetwork();
 120
 121
 122     heatStructureTree.setHeat(createHeatStructureTreeSetFromOld(heat));
 123     heatStructureTree.setVolume(createHeatStructureTreeSetFromOld(volume));
 124     heatStructureTree.setNested(createHeatStructureTreeSetFromOld(nested));
 125     heatStructureTree.setNetwork(createHeatStructureTreeSetFromOld(network));
 126
 127
 128     return Optional.of(heatStructureTree);
 129
 130   }
 131
 132   private void mapOldHeatStructureTreeValues(
 133       OldHeatStructureTree oldHeatStructureTree,
 134       HeatStructureTree heatStructureTree) {
 135     heatStructureTree.setFileName(oldHeatStructureTree.getFileName());
 136     heatStructureTree.setBase(oldHeatStructureTree.getBase());
 137     heatStructureTree.setType(oldHeatStructureTree.getType());
 138     heatStructureTree.setArtifacts(oldHeatStructureTree.getArtifacts());
 139     heatStructureTree.setErrors(oldHeatStructureTree.getErrors());
 140
 141     if(Objects.nonNull(oldHeatStructureTree.getEnv())) {
 142       heatStructureTree.setEnv(new HeatStructureTree(oldHeatStructureTree.getEnv(), false));
 143     }
 144   }
 145
 146   private Set<HeatStructureTree> createHeatStructureTreeSetFromOld(Set<OldHeatStructureTree>
 147                                                                         oldHeatStructureTreeSet){
 148     if(CollectionUtils.isEmpty(oldHeatStructureTreeSet)){
 149       return null;
 150     }
 151     Set<HeatStructureTree> newHeatStructureSet = new HashSet<>();
 152
 153     for(OldHeatStructureTree old : oldHeatStructureTreeSet){
 154       Optional<HeatStructureTree> newHeatStructureTree =
 155           createNewHeatStructureTreeFromOldStructureTree(old);
 156       if(newHeatStructureTree.isPresent()){
 157         newHeatStructureSet.add(newHeatStructureTree.get());
 158       }
 159     }
 160
 161     return newHeatStructureSet;
 162   }
 163
 164   private class OldValidationStructureTree{
 165     private OldHeatStructureTree importStructure;
 166
 167     public OldHeatStructureTree getImportStructure() {
 168       return importStructure;
 169     }
 170
 171     public void setImportStructure(
 172         OldHeatStructureTree importStructure) {
 173       this.importStructure = importStructure;
 174     }
 175   }
 176
 177   private class OldHeatStructureTree{
 178     private String fileName;
 179     private FileData.Type type;
 180     private Boolean isBase;
 181     private String env;
 182     private List<ErrorMessage> errors;
 183     private Set<OldHeatStructureTree> heat;
 184     private Set<OldHeatStructureTree> volume;
 185     private Set<OldHeatStructureTree> network;
 186     private Set<OldHeatStructureTree> nested;
 187     private Set<OldHeatStructureTree> other;
 188     private Set<Artifact> artifacts;
 189
 190     public OldHeatStructureTree() {
 191     }
 192
 193   public String getFileName() {
 194     return fileName;
 195   }
 196
 197   public void setFileName(String fileName) {
 198     this.fileName = fileName;
 199   }
 200
 201   public FileData.Type getType() {
 202     return type;
 203   }
 204
 205   public void setType(FileData.Type type) {
 206     this.type = type;
 207   }
 208
 209   public Boolean getBase() {
 210     return isBase;
 211   }
 212
 213   public void setBase(Boolean base) {
 214     isBase = base;
 215   }
 216
 217   public String getEnv() {
 218     return env;
 219   }
 220
 221   public void setEnv(String env) {
 222     this.env = env;
 223   }
 224
 225   public List<ErrorMessage> getErrors() {
 226     return errors;
 227   }
 228
 229   public void setErrors(List<ErrorMessage> errors) {
 230     this.errors = errors;
 231   }
 232
 233   public Set<OldHeatStructureTree> getHeat() {
 234     return heat;
 235   }
 236
 237   public void setHeat(Set<OldHeatStructureTree> heat) {
 238     this.heat = heat;
 239   }
 240
 241   public Set<OldHeatStructureTree> getVolume() {
 242     return volume;
 243   }
 244
 245   public void setVolume(Set<OldHeatStructureTree> volume) {
 246     this.volume = volume;
 247   }
 248
 249   public Set<OldHeatStructureTree> getNetwork() {
 250     return network;
 251   }
 252
 253   public void setNetwork(
 254       Set<OldHeatStructureTree> network) {
 255     this.network = network;
 256   }
 257
 258   public Set<OldHeatStructureTree> getNested() {
 259     return nested;
 260   }
 261
 262   public void setNested(Set<OldHeatStructureTree> nested) {
 263     this.nested = nested;
 264   }
 265
 266   public Set<OldHeatStructureTree> getOther() {
 267     return other;
 268   }
 269
 270   public void setOther(Set<OldHeatStructureTree> other) {
 271     this.other = other;
 272   }
 273
 274   public Set<Artifact> getArtifacts() {
 275     return artifacts;
 276   }
 277
 278   public void setArtifacts(Set<Artifact> artifacts) {
 279     this.artifacts = artifacts;
 280   }
 281 }
 282 }