openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java

   1 package org.openecomp.conflicts.impl;
   2
   3 import org.openecomp.conflicts.ItemMergeHandler;
   4 import org.openecomp.conflicts.dao.ConflictsDao;
   5 import org.openecomp.conflicts.types.*;
   6 import org.openecomp.sdc.common.errors.CoreException;
   7 import org.openecomp.sdc.common.errors.ErrorCategory;
   8 import org.openecomp.sdc.common.errors.ErrorCode;
   9 import org.openecomp.sdc.datatypes.model.ElementType;
  10 import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao;
  11 import org.openecomp.sdc.versioning.dao.types.Version;
  12
  13 import java.util.*;
  14 import java.util.stream.Collectors;
  15 import java.util.stream.Stream;
  16
  17 import static org.openecomp.sdc.datatypes.model.ElementType.*;
  18
  19 public class VspMergeHandler implements ItemMergeHandler {
  20
  21   private static final String VSP_MODEL_CONFLICT_ID = "vspModelConflictId";
  22   private static final String ELEMENT_CONFLICT_NOT_EXIST_ERR_ID = "ELEMENT_CONFLICT_NOT_EXIST";
  23   private static final String ELEMENT_CONFLICT_NOT_EXISTS_MSG =
  24       "Item Id %s, version Id %s, element conflict with Id %s does not exists.";
  25   private static final Set<ElementType> FILTERED_OUT_TYPES = Stream
  26       .of(OrchestrationTemplateCandidateContent, OrchestrationTemplateValidationData)
  27       .collect(Collectors.toSet());
  28   private static final Map<ElementType, Set<ElementType>> ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES =
  29           new EnumMap<>(ElementType.class);
  30
  31   static {
  32     ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplateCandidate,
  33         Collections.singleton(OrchestrationTemplateCandidateContent));
  34     ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplate,
  35         Collections.singleton(OrchestrationTemplateValidationData));
  36   }
  37
  38   private ConflictsDao conflictsDao;
  39   private VspMergeDao vspMergeDao;
  40
  41   public VspMergeHandler(ConflictsDao conflictsDao, VspMergeDao vspMergeDao) {
  42     this.conflictsDao = conflictsDao;
  43     this.vspMergeDao = vspMergeDao;
  44   }
  45
  46   @Override
  47   public boolean isConflicted(String itemId, Version version) {
  48     return vspMergeDao.isConflicted(itemId, version);
  49   }
  50
  51   @Override
  52   public void finalizeMerge(String itemId, Version version) {
  53     if (!conflictsDao.isConflicted(itemId, version)) {
  54       vspMergeDao.applyConflictResolution(itemId, version);
  55     }
  56   }
  57
  58   @Override
  59   public void postListConflicts(String itemId, Version version, ItemVersionConflict conflicts) {
  60     List<ConflictInfo> elementConflicts = new ArrayList<>();
  61
  62     boolean vspModelConflicted = false;
  63     for (ConflictInfo elementConflict : conflicts.getElementConflicts()) {
  64       if (elementConflict.getType() == VspModel) {
  65         elementConflicts.add(
  66             new ConflictInfo(elementConflict.getId(), NetworkPackage, NetworkPackage.name()));
  67         vspModelConflicted = true;
  68         continue;
  69       }
  70       if (!FILTERED_OUT_TYPES.contains(elementConflict.getType())) {
  71         elementConflicts.add(elementConflict);
  72       }
  73     }
  74
  75     if (!vspModelConflicted && vspMergeDao.isConflicted(itemId, version)) {
  76       elementConflicts
  77           .add(new ConflictInfo(VSP_MODEL_CONFLICT_ID, NetworkPackage, NetworkPackage.name()));
  78     }
  79
  80     conflicts.setElementConflicts(elementConflicts);
  81   }
  82
  83   @Override
  84   public Optional<Conflict> getConflict(String itemId, Version version, String conflictId) {
  85     return VSP_MODEL_CONFLICT_ID.equals(conflictId)
  86         ? Optional.of(buildVspModelConflict(conflictId))
  87         : Optional.empty();
  88   }
  89
  90   @Override
  91   public void postGetConflict(String itemId, Version version, Conflict conflict) {
  92     if (conflict.getType() == VspModel) {
  93       Conflict vspModelConflict = buildVspModelConflict(null);
  94       conflict.setType(vspModelConflict.getType());
  95       conflict.setName(vspModelConflict.getName());
  96       conflict.setYours(vspModelConflict.getYours());
  97       conflict.setTheirs(vspModelConflict.getTheirs());
  98     }
  99   }
 100
 101   @Override
 102   public void preResolveConflict(String itemId, Version version, String conflictId,
 103                                  ConflictResolution resolution) {
 104     if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) {
 105       return;
 106     }
 107     resolveDependantConflicts(itemId, version, conflictId, resolution);
 108   }
 109
 110   @Override
 111   public boolean resolveConflict(String itemId, Version version, String conflictId,
 112                                  ConflictResolution resolution) {
 113     if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) {
 114       vspMergeDao.updateConflictResolution(itemId, version,
 115           com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name()));
 116       return true;
 117     }
 118     Conflict conflict = conflictsDao.getConflict(itemId, version, conflictId);
 119     if (conflict == null) {
 120       throw getConflictNotExistException(itemId, version, conflictId);
 121     }
 122     if (conflict.getType() == VspModel) {
 123       vspMergeDao.updateConflictResolution(itemId, version,
 124           com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name()));
 125
 126       conflictsDao.resolveConflict(itemId, version, conflictId, new ConflictResolution(
 127           conflict.getTheirs() == null ? Resolution.YOURS : Resolution.THEIRS));
 128       return true;
 129     }
 130     return false;
 131   }
 132
 133   private void resolveDependantConflicts(String itemId, Version version, String conflictId,
 134                                          ConflictResolution resolution) {
 135     ItemVersionConflict conflicts = conflictsDao.getConflict(itemId, version);
 136
 137     Set<ElementType> conflictDependantTypes =
 138         ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES
 139             .get(findConflictById(conflicts, conflictId).getType());
 140
 141     if (conflictDependantTypes == null) {
 142       return;
 143     }
 144
 145     findConflictsByTypes(conflicts, conflictDependantTypes)
 146         .forEach(dependantConflict ->
 147             conflictsDao.resolveConflict(itemId, version, dependantConflict.getId(), resolution));
 148   }
 149
 150   private ConflictInfo findConflictById(ItemVersionConflict versionConflicts,
 151                                         String conflictId) {
 152     return versionConflicts.getElementConflicts().stream()
 153         .filter(elementConflict -> conflictId.equals(elementConflict.getId()))
 154         .findFirst()
 155         .orElseThrow(() -> new IllegalStateException(
 156             String.format("Conflict Id %s does not exist on conflicts list", conflictId)));
 157   }
 158
 159   private Collection<ConflictInfo> findConflictsByTypes(ItemVersionConflict versionConflicts,
 160                                                         Set<ElementType> elementTypes) {
 161     return versionConflicts.getElementConflicts().stream()
 162         .filter(elementConflict -> elementTypes.contains(elementConflict.getType()))
 163         .collect(Collectors.toList());
 164   }
 165
 166   private Conflict buildVspModelConflict(String conflictId) {
 167     Conflict conflict = new Conflict(conflictId, NetworkPackage, NetworkPackage.name());
 168
 169     Map<String, String> yours = new HashMap<>();
 170     yours.put("File", "Local (Me)");
 171     conflict.setYours(yours);
 172
 173     Map<String, String> theirs = new HashMap<>();
 174     theirs.put("File", "Last Committed");
 175     conflict.setTheirs(theirs);
 176     return conflict;
 177   }
 178
 179   private CoreException getConflictNotExistException(String itemId, Version version,
 180                                                      String conflictId) {
 181     return new CoreException(new ErrorCode.ErrorCodeBuilder()
 182         .withCategory(ErrorCategory.APPLICATION)
 183         .withId(ELEMENT_CONFLICT_NOT_EXIST_ERR_ID)
 184         .withMessage(
 185             String.format(ELEMENT_CONFLICT_NOT_EXISTS_MSG, itemId, version.getId(), conflictId))
 186         .build());
 187   }
 188 }