gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.core.zusammen.plugin.collaboration.impl;
   2
   3 import com.amdocs.zusammen.datatypes.Id;
   4 import com.amdocs.zusammen.datatypes.SessionContext;
   5 import com.amdocs.zusammen.datatypes.Space;
   6 import com.amdocs.zusammen.datatypes.item.ElementContext;
   7 import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
   8 import org.openecomp.core.zusammen.plugin.collaboration.ElementPublicStore;
   9 import org.openecomp.core.zusammen.plugin.dao.ElementRepository;
  10 import org.openecomp.core.zusammen.plugin.dao.ElementRepositoryFactory;
  11 import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepository;
  12 import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepositoryFactory;
  13 import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
  14 import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
  15
  16 import java.util.Collection;
  17 import java.util.Date;
  18 import java.util.HashSet;
  19 import java.util.Map;
  20 import java.util.Optional;
  21
  22 import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getSpaceName;
  23
  24 public class ElementPublicStoreImpl implements ElementPublicStore {
  25
  26   @Override
  27   public Optional<ElementEntity> get(SessionContext context,
  28                                      ElementContext elementContext, Id elementId) {
  29     return getElementRepository(context)
  30         .get(context, new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext),
  31             new ElementEntity(elementId));
  32   }
  33
  34   @Override
  35   public Optional<ElementEntity> getDescriptor(SessionContext context,
  36                                                ElementContext elementContext, Id elementId) {
  37     return getElementRepository(context).getDescriptor(context,
  38         new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext),
  39         new ElementEntity(elementId));
  40   }
  41
  42   @Override
  43   public Collection<SynchronizationStateEntity> listSynchronizationStates(
  44       SessionContext context, ElementContext elementContext) {
  45     ElementEntityContext entityContext = new ElementEntityContext(getSpaceName
  46         (context, Space.PUBLIC), elementContext);
  47
  48     ElementSynchronizationStateRepository elementSyncStateRepository =
  49         getElementSyncStateRepository(context);
  50     Map<Id, Id> ids = getElementRepository(context).listIds(context, entityContext);
  51
  52     Collection<SynchronizationStateEntity> synchronizationStateEntities = new HashSet<>();
  53     for (Map.Entry<Id, Id> elementEntry : ids.entrySet()) {
  54       Optional<SynchronizationStateEntity> synchronizationStateEntity = elementSyncStateRepository.
  55           get(context, entityContext, new SynchronizationStateEntity(elementEntry.getKey(),
  56               elementEntry.getValue()));
  57       if (synchronizationStateEntity.isPresent()) {
  58         synchronizationStateEntities.add(synchronizationStateEntity.get());
  59       } else {
  60         /*throw new IllegalStateException(String.format(
  61             "list Synchronization States error: " + "element %s revision %s, which appears as an " +
  62                 "element of " +
  63                 "item" +
  64                 " %s version %s, does not exist",
  65             elementEntry.getKey(), elementEntry.getValue(), elementContext.getItemId().getValue(),
  66             elementContext.getVersionId().getValue()));*/
  67       }
  68     }
  69
  70     return synchronizationStateEntities;
  71   }
  72
  73   @Override
  74   public void create(SessionContext context, ElementContext elementContext,
  75                      ElementEntity element, Date publishTime) {
  76     ElementEntityContext publicContext =
  77         new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
  78
  79
  80     if (element.getParentId() != null) {
  81       createParentElement(context, elementContext, element.getParentId(), publishTime);
  82     }
  83     getElementRepository(context).create(context, publicContext, element);
  84     getElementSyncStateRepository(context).create(context, publicContext,
  85         new SynchronizationStateEntity(element.getId(), elementContext.getRevisionId(),
  86             publishTime, false));
  87   }
  88
  89   @Override
  90   public void update(SessionContext context, ElementContext elementContext,
  91                      ElementEntity element, Date publishTime) {
  92     //todo - update in public should be create new entry with new revision_id in public - this is a
  93     // new revision
  94     ElementEntityContext publicContext =
  95         new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
  96
  97     Optional<ElementEntity> publicElement = getElementRepository(context).get(context,
  98         publicContext, new ElementEntity(element.getId()));
  99     if (publicElement.isPresent()) {
 100       getElementRepository(context).update(context, publicContext, element);
 101     } else {
 102        publicElement = get(context,new ElementContext(publicContext.getItemId(),publicContext
 103            .getVersionId()),element.getId());
 104        element.setSubElementIds(publicElement.get().getSubElementIds());
 105       getElementRepository(context).create(context, publicContext, element);
 106     }
 107     getElementSyncStateRepository(context).update(context, publicContext,
 108         new SynchronizationStateEntity(element.getId(), elementContext.getRevisionId(), publishTime,
 109             false));
 110   }
 111
 112   @Override
 113   public void delete(SessionContext context, ElementContext elementContext,
 114                      ElementEntity element, Date publishTime) {
 115     ElementEntityContext publicContext =
 116         new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
 117
 118     if (element.getParentId() != null) {
 119       Optional<ElementEntity> parentElement = get(context, elementContext, element.getParentId());
 120       if (parentElement.isPresent()) {
 121         createParentElement(context, elementContext, element.getParentId(), publishTime);
 122       }
 123     }
 124
 125     getElementRepository(context).delete(context, publicContext, element);
 126     getElementSyncStateRepository(context)
 127         .delete(context, publicContext, new SynchronizationStateEntity(element.getId(),
 128             elementContext.getRevisionId()));
 129   }
 130
 131   @Override
 132   public Map<Id, Id> listIds(SessionContext context, ElementContext elementContext) {
 133
 134     return getElementRepository(context)
 135         .listIds(context,
 136             new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext));
 137
 138   }
 139
 140   private void createParentElement(SessionContext context, ElementContext elementContext,
 141                                    Id parentElementId, Date publishTime
 142   ) {
 143     ElementEntityContext publicContext =
 144         new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
 145
 146     Optional<ElementEntity> parentElement =
 147         getElementRepository(context).get(context, new ElementEntityContext
 148                 (publicContext.getSpace(), publicContext.getItemId(), publicContext.getVersionId(),
 149                     elementContext.getRevisionId()),
 150             new ElementEntity(parentElementId));
 151     if(parentElement.isPresent()) {
 152       update(context, elementContext, parentElement.get(), publishTime);
 153     }
 154
 155
 156    /* Id elementRevisionId = getElementRevision(context, publicContext, elementContext.getRevisionId()
 157         , parentElementId);
 158
 159     if (elementRevisionId != null && !elementRevisionId.equals(elementContext.getRevisionId())) {
 160       Optional<ElementEntity> parentElement =
 161           getElementRepository(context).get(context, new ElementEntityContext
 162                   (publicContext.getSpace(), publicContext.getItemId(), publicContext.getVersionId(),
 163                       elementContext.getRevisionId()),
 164               new ElementEntity(parentElementId));
 165       elementRevisionId = getElementRevision(context, publicContext, elementContext.getRevisionId()
 166           , parentElement.get().getId());
 167       if (elementRevisionId != null) {
 168         update(context, elementContext, parentElement.get(), publishTime);
 169       } else {
 170         create(context, elementContext, parentElement.get(), publishTime);
 171       }
 172
 173     }*/
 174   }
 175
 176
 177
 178
 179   protected ElementRepository getElementRepository(SessionContext context) {
 180     return ElementRepositoryFactory.getInstance().createInterface(context);
 181   }
 182
 183   protected ElementSynchronizationStateRepository getElementSyncStateRepository(
 184       SessionContext context) {
 185     return ElementSynchronizationStateRepositoryFactory.getInstance().createInterface(context);
 186   }
 187
 188
 189 }