openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementStageStoreImpl.java

   1 package org.openecomp.core.zusammen.plugin.collaboration.impl;
   2
   3 import com.amdocs.zusammen.datatypes.SessionContext;
   4 import com.amdocs.zusammen.datatypes.item.Action;
   5 import com.amdocs.zusammen.datatypes.item.ElementContext;
   6 import com.amdocs.zusammen.datatypes.item.Resolution;
   7 import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
   8 import org.openecomp.core.zusammen.plugin.collaboration.ElementStageStore;
   9 import org.openecomp.core.zusammen.plugin.dao.ElementStageRepository;
  10 import org.openecomp.core.zusammen.plugin.dao.ElementStageRepositoryFactory;
  11 import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
  12 import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
  13
  14 import java.util.Collection;
  15 import java.util.Optional;
  16 import java.util.stream.Collectors;
  17
  18 import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateElementContext;
  19 import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateSpaceName;
  20
  21 public class ElementStageStoreImpl implements ElementStageStore {
  22
  23   @Override
  24   public Collection<ElementEntity> listIds(SessionContext context, ElementContext elementContext) {
  25     return getElementStageRepository(context)
  26         .listIds(context, new ElementEntityContext(getPrivateSpaceName(context),
  27             getPrivateElementContext(elementContext)));
  28   }
  29
  30   @Override
  31   public Optional<StageEntity<ElementEntity>> get(SessionContext context,
  32                                                   ElementContext elementContext,
  33                                                   ElementEntity element) {
  34     return getElementStageRepository(context).get(context,
  35         new ElementEntityContext(getPrivateSpaceName(context),
  36             getPrivateElementContext(elementContext)),
  37         element);
  38   }
  39
  40   @Override
  41   public Optional<StageEntity<ElementEntity>> getConflicted(SessionContext context,
  42                                                             ElementContext elementContext,
  43                                                             ElementEntity element) {
  44     return get(context, elementContext, element).filter(StageEntity::isConflicted);
  45   }
  46
  47   @Override
  48   public boolean hasConflicts(SessionContext context, ElementContext elementContext) {
  49     return !getElementStageRepository(context).listConflictedIds(context,
  50         new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext))).isEmpty();
  51   }
  52
  53   @Override
  54   public Collection<StageEntity<ElementEntity>> listConflictedDescriptors(SessionContext context,
  55                                                                           ElementContext elementContext) {
  56     ElementEntityContext privateContext =
  57         new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
  58             (elementContext));
  59     ElementStageRepository elementStageRepository = getElementStageRepository(context);
  60
  61     return elementStageRepository.listConflictedIds(context, privateContext).stream()
  62         .map(conflictedElement -> elementStageRepository
  63             .getDescriptor(context, privateContext, conflictedElement).get())
  64         .collect(Collectors.toList());
  65   }
  66
  67   @Override
  68   public void create(SessionContext context, ElementContext elementContext,
  69                      StageEntity<ElementEntity> elementStage) {
  70     getElementStageRepository(context)
  71         .create(context,
  72             new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext)),
  73             elementStage);
  74   }
  75
  76   @Override
  77   public void delete(SessionContext context, ElementContext elementContext, ElementEntity element) {
  78     getElementStageRepository(context)
  79         .delete(context,
  80             new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext)),
  81             element);
  82   }
  83
  84
  85   @Override
  86   public void resolveConflict(SessionContext context, ElementContext elementContext,
  87                               ElementEntity element, Resolution resolution) {
  88     Optional<StageEntity<ElementEntity>> stagedElement =
  89         getConflicted(context, elementContext, element);
  90     if (!stagedElement.isPresent()) {
  91       return;
  92     }
  93
  94     ElementEntityContext privateContext =
  95         new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
  96             (elementContext));
  97
  98     switch (resolution) {
  99       case YOURS:
 100         resolveConflictByYours(context, privateContext, stagedElement.get());
 101         break;
 102       case THEIRS:
 103         resolveConflictByTheirs(context, privateContext, stagedElement.get());
 104         break;
 105       case OTHER: // other = data updates only? no data deletions? if so, then:
 106         // conflicted = false
 107         // element = the input of resolve
 108         // action = update
 109         throw new UnsupportedOperationException("'Other' conflict resolution is not yet supported");
 110       default:
 111         break;
 112     }
 113   }
 114
 115   private void resolveConflictByYours(SessionContext context, ElementEntityContext privateContext,
 116                                       StageEntity<ElementEntity> stagedElement) {
 117     getElementStageRepository(context)
 118         .markAsNotConflicted(context, privateContext, stagedElement.getEntity(), Action.IGNORE);
 119     stagedElement.getConflictDependents().forEach(conflictDependant ->
 120         getElementStageRepository(context)
 121             .markAsNotConflicted(context, privateContext, conflictDependant, Action.IGNORE));
 122   }
 123
 124   private void resolveConflictByTheirs(SessionContext context, ElementEntityContext privateContext,
 125                                        StageEntity<ElementEntity> stagedElement) {
 126     getElementStageRepository(context)
 127         .markAsNotConflicted(context, privateContext, stagedElement.getEntity());
 128   }
 129
 130   protected ElementStageRepository getElementStageRepository(SessionContext context) {
 131     return ElementStageRepositoryFactory.getInstance().createInterface(context);
 132   }
 133 }