openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerImpl.java

   1 package org.openecomp.sdc.conflicts.impl;
   2
   3 import org.openecomp.conflicts.ItemMergeHandler;
   4 import org.openecomp.conflicts.ItemMergeHandlerFactory;
   5 import org.openecomp.conflicts.dao.ConflictsDao;
   6 import org.openecomp.conflicts.types.Conflict;
   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.conflicts.ConflictsManager;
  14 import org.openecomp.sdc.versioning.dao.types.Version;
  15
  16 import java.util.Optional;
  17
  18 public class ConflictsManagerImpl implements ConflictsManager {
  19
  20   private static final String ELEMENT_CONFLICT_NOT_EXIST_ERR_ID = "ELEMENT_CONFLICT_NOT_EXIST";
  21   private static final String ELEMENT_CONFLICT_NOT_EXISTS_MSG =
  22       "Item Id %s, version Id %s, element conflict with Id %s does not exists.";
  23
  24   private final ConflictsDao conflictsDao;
  25
  26   public ConflictsManagerImpl(ConflictsDao conflictsDao) {
  27     this.conflictsDao = conflictsDao;
  28   }
  29
  30   @Override
  31   public boolean isConflicted(String itemId, Version version) {
  32     Optional<ItemMergeHandler> itemMergeHandler =
  33         ItemMergeHandlerFactory.getInstance().createInterface(itemId);
  34
  35     return conflictsDao.isConflicted(itemId, version) ||
  36         (itemMergeHandler.isPresent() &&
  37             itemMergeHandler.get().isConflicted(itemId, version));
  38   }
  39
  40   @Override
  41   public ItemVersionConflict getConflict(String itemId, Version version) {
  42     ItemVersionConflict conflicts = conflictsDao.getConflict(itemId, version);
  43
  44     ItemMergeHandlerFactory.getInstance().createInterface(itemId)
  45         .ifPresent(itemMergeHandler -> itemMergeHandler
  46             .postListConflicts(itemId, version, conflicts));
  47
  48     return conflicts;
  49   }
  50
  51   @Override
  52   public void finalizeMerge(String itemId, Version version) {
  53     ItemMergeHandlerFactory.getInstance().createInterface(itemId)
  54         .ifPresent(mergeHandler -> mergeHandler.finalizeMerge(itemId, version));
  55   }
  56
  57   @Override
  58   public Conflict getConflict(String itemId, Version version, String conflictId) {
  59     Optional<ItemMergeHandler> itemMergeHandler =
  60         ItemMergeHandlerFactory.getInstance().createInterface(itemId);
  61     if (itemMergeHandler.isPresent()) {
  62       Optional<Conflict> conflict =
  63           itemMergeHandler.get().getConflict(itemId, version, conflictId);
  64       if (conflict.isPresent()) {
  65         return conflict.get();
  66       }
  67     }
  68
  69     Conflict conflict = conflictsDao.getConflict(itemId, version, conflictId);
  70
  71     itemMergeHandler.ifPresent(mergeHandler ->
  72         mergeHandler.postGetConflict(itemId, version, conflict));
  73
  74     if (conflict == null) {
  75       throw getConflictNotExistException(itemId, version, conflictId);
  76     }
  77     return conflict;
  78   }
  79
  80   @Override
  81   public void resolveConflict(String itemId, Version version, String conflictId,
  82                               ConflictResolution resolution) {
  83     if (Resolution.OTHER.equals(resolution.getResolution())) {
  84       throw new UnsupportedOperationException(
  85           "Resolution other than 'THEIRS' or 'YOURS' is not supported.");
  86     }
  87
  88     Optional<ItemMergeHandler> itemMergeHandler =
  89         ItemMergeHandlerFactory.getInstance().createInterface(itemId);
  90     if (!itemMergeHandler.isPresent() ||
  91         !itemMergeHandler.get()
  92             .resolveConflict(itemId, version, conflictId, resolution)) {
  93
  94       getConflict(itemId, version, conflictId); // validate that the conflict exist
  95       itemMergeHandler.ifPresent(mergeHandler ->
  96           mergeHandler.preResolveConflict(itemId, version, conflictId, resolution));
  97
  98       conflictsDao.resolveConflict(itemId, version, conflictId, resolution);
  99     }
 100   }
 101
 102   private CoreException getConflictNotExistException(String itemId, Version version,
 103                                                      String conflictId) {
 104     return new CoreException(new ErrorCode.ErrorCodeBuilder()
 105         .withCategory(ErrorCategory.APPLICATION)
 106         .withId(ELEMENT_CONFLICT_NOT_EXIST_ERR_ID)
 107         .withMessage(
 108             String.format(ELEMENT_CONFLICT_NOT_EXISTS_MSG, itemId, version.getId(), conflictId))
 109         .build());
 110   }
 111
 112 }