openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-impl/src/main/java/org/openecomp/sdc/healing/healers/ValidationStructureHealer.java

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