gerrit.onap Code Review - sdc.git/blob

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