openecomp-be/lib/openecomp-sdc-vendor-license-lib/openecomp-sdc-vendor-license-core/src/main/java/org/openecomp/sdc/vendorlicense/dao/impl/zusammen/FeatureGroupDaoZusammenImpl.java

   1 package org.openecomp.sdc.vendorlicense.dao.impl.zusammen;
   2
   3 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
   4 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
   5 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
   6 import com.amdocs.zusammen.datatypes.Id;
   7 import com.amdocs.zusammen.datatypes.SessionContext;
   8 import com.amdocs.zusammen.datatypes.item.Action;
   9 import com.amdocs.zusammen.datatypes.item.ElementContext;
  10 import com.amdocs.zusammen.datatypes.item.Info;
  11 import com.amdocs.zusammen.datatypes.item.Relation;
  12 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  13 import org.openecomp.core.zusammen.api.ZusammenUtil;
  14 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
  15 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  16 import org.openecomp.sdc.versioning.dao.types.Version;
  17
  18 import java.util.ArrayList;
  19 import java.util.Collection;
  20 import java.util.HashSet;
  21 import java.util.Optional;
  22 import java.util.Set;
  23 import java.util.stream.Collectors;
  24
  25 /**
  26  * Created by ayalaben on 3/27/2017.
  27  */
  28 public class FeatureGroupDaoZusammenImpl implements FeatureGroupDao {
  29
  30   private ZusammenAdaptor zusammenAdaptor;
  31
  32   public FeatureGroupDaoZusammenImpl(ZusammenAdaptor zusammenAdaptor) {
  33     this.zusammenAdaptor = zusammenAdaptor;
  34   }
  35
  36   @Override
  37   public void registerVersioning(String versionableEntityType) {
  38     //no need
  39   }
  40
  41   @Override
  42   public void create(FeatureGroupEntity featureGroup) {
  43     ZusammenElement featureGroupElement =
  44         buildFeatureGroupElement(featureGroup, Action.CREATE);
  45
  46     ZusammenElement featureGroupsElement =
  47         VlmZusammenUtil.buildStructuralElement(StructureElement.FeatureGroups, null);
  48
  49     featureGroupsElement.addSubElement(featureGroupElement);
  50
  51     SessionContext context = ZusammenUtil.createSessionContext();
  52     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
  53     Optional<Element> savedElement = zusammenAdaptor.saveElement(context, new ElementContext(itemId,
  54             VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor)),
  55         featureGroupsElement, "Create feature group");
  56
  57     savedElement.ifPresent(element -> featureGroup
  58         .setId(element.getSubElements().iterator().next().getElementId().getValue()));
  59   }
  60
  61   @Override
  62   public void update(FeatureGroupEntity featureGroup) {
  63     ZusammenElement featureGroupElement = buildFeatureGroupElement(featureGroup, Action.UPDATE);
  64
  65     SessionContext context = ZusammenUtil.createSessionContext();
  66     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
  67     zusammenAdaptor.saveElement(context, new ElementContext(itemId,
  68             VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor)), featureGroupElement,
  69         String.format("Update feature group with id %s", featureGroup.getId()));
  70   }
  71
  72   @Override
  73   public FeatureGroupEntity get(FeatureGroupEntity featureGroup) {
  74     SessionContext context = ZusammenUtil.createSessionContext();
  75     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
  76     ElementContext elementContext = new ElementContext(itemId,
  77         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
  78         VlmZusammenUtil.getVersionTag(featureGroup.getVersion()));
  79
  80     return zusammenAdaptor.getElementInfo(context, elementContext, new Id(featureGroup.getId()))
  81         .map(elementInfo -> mapElementInfoToFeatureGroup(
  82             featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), elementInfo))
  83         .orElse(null);
  84   }
  85
  86   @Override
  87   public void delete(FeatureGroupEntity featureGroup) {
  88     SessionContext context = ZusammenUtil.createSessionContext();
  89     ZusammenElement zusammenElement = new ZusammenElement();
  90     zusammenElement.setAction(Action.DELETE);
  91     zusammenElement.setElementId(new Id(featureGroup.getId()));
  92
  93     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
  94     ElementContext elementContext = new ElementContext(itemId,
  95         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
  96     zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
  97         "delete feature group. id:" + featureGroup.getId() + ".");
  98   }
  99
 100   @Override
 101   public Collection<FeatureGroupEntity> list(FeatureGroupEntity featureGroup) {
 102     SessionContext context = ZusammenUtil.createSessionContext();
 103     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 104     ElementContext elementContext = new ElementContext(itemId,
 105         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
 106         VlmZusammenUtil.getVersionTag(featureGroup.getVersion()));
 107
 108     return zusammenAdaptor
 109         .listElementsByName(context, elementContext, null, StructureElement.FeatureGroups.name())
 110         .stream().map(elementInfo -> mapElementInfoToFeatureGroup(
 111             featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), elementInfo))
 112         .collect(Collectors.toList());
 113   }
 114
 115   @Override
 116   public long count(FeatureGroupEntity featureGroup) {
 117     SessionContext context = ZusammenUtil.createSessionContext();
 118     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 119     ElementContext elementContext = new ElementContext(itemId,
 120         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
 121         VlmZusammenUtil.getVersionTag(featureGroup.getVersion()));
 122
 123     return zusammenAdaptor
 124         .listElementsByName(context, elementContext, null, StructureElement.FeatureGroups.name())
 125         .size();
 126   }
 127
 128   @Override
 129   public void removeEntitlementPool(FeatureGroupEntity featureGroup, String entitlementPoolId) {
 130     removeRelationToContainedEntity(featureGroup, entitlementPoolId, "entitlement pool");
 131   }
 132
 133   @Override
 134   public void removeLicenseKeyGroup(FeatureGroupEntity featureGroup, String licenseKeyGroupId) {
 135     removeRelationToContainedEntity(featureGroup, licenseKeyGroupId, "license Key Group");
 136   }
 137
 138   private void removeRelationToContainedEntity(FeatureGroupEntity featureGroup,
 139                                                String containedEntityId,
 140                                                String containedEntityType) {
 141     SessionContext context = ZusammenUtil.createSessionContext();
 142     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 143     ElementContext elementContext = new ElementContext(itemId,
 144         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 145
 146     Optional<ElementInfo> elementInfo = zusammenAdaptor.getElementInfo(context,
 147         elementContext, new Id(featureGroup.getId()));
 148     if (elementInfo.isPresent()) {
 149       ZusammenElement zusammenElement = VlmZusammenUtil.getZusammenElement(elementInfo.get());
 150       zusammenElement.setAction(Action.UPDATE);
 151       zusammenElement.setRelations(elementInfo.get().getRelations().stream()
 152           .filter(
 153               relation -> !containedEntityId.equals(relation.getEdge2().getElementId().getValue()))
 154           .collect(Collectors.toList()));
 155       zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 156           String.format("remove %s", containedEntityType));
 157     }
 158   }
 159
 160   @Override
 161   public void updateFeatureGroup(FeatureGroupEntity
 162                                      featureGroup, Set<String> addedEntitlementPools,
 163                                  Set<String> removedEntitlementPools,
 164                                  Set<String> addedLicenseKeyGroups,
 165                                  Set<String> removedLicenseKeyGroups) {
 166     ZusammenElement featureGroupElement = buildFeatureGroupElement(featureGroup, Action.UPDATE);
 167     SessionContext context = ZusammenUtil.createSessionContext();
 168     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 169     ElementContext elementContext = new ElementContext(itemId,
 170         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 171
 172     Optional<ElementInfo> elementInfo = zusammenAdaptor.getElementInfo(context,
 173         elementContext, new Id(featureGroup.getId()));
 174     if (elementInfo.isPresent()) {
 175       FeatureGroupEntity currentFeatureGroup =
 176           mapElementInfoToFeatureGroup(featureGroup.getId(), featureGroup.getVersion(),
 177               elementInfo.get());
 178
 179       if (!(removedEntitlementPools == null)) {
 180         currentFeatureGroup.getEntitlementPoolIds().removeAll(removedEntitlementPools);
 181       }
 182       if (!(addedEntitlementPools == null)) {
 183         currentFeatureGroup.getEntitlementPoolIds().addAll(addedEntitlementPools);
 184       }
 185       if (featureGroupElement.getRelations() == null) {
 186         featureGroupElement.setRelations(new ArrayList<>());
 187       }
 188       featureGroupElement.getRelations()
 189           .addAll(currentFeatureGroup.getEntitlementPoolIds().stream()
 190               .map(relation -> VlmZusammenUtil
 191                   .createRelation(RelationType.FeatureGroupToEntitlmentPool, relation))
 192               .collect(Collectors.toList()));
 193
 194       if (!(removedLicenseKeyGroups == null)) {
 195         currentFeatureGroup.getLicenseKeyGroupIds().removeAll(removedLicenseKeyGroups);
 196       }
 197       if (!(addedLicenseKeyGroups == null)) {
 198         currentFeatureGroup.getLicenseKeyGroupIds().addAll(addedLicenseKeyGroups);
 199       }
 200       currentFeatureGroup.getLicenseKeyGroupIds().addAll(addedLicenseKeyGroups);
 201       featureGroupElement.getRelations()
 202           .addAll(currentFeatureGroup.getLicenseKeyGroupIds().stream()
 203               .map(relation -> VlmZusammenUtil
 204                   .createRelation(RelationType.FeatureGroupToLicenseKeyGroup, relation))
 205               .collect(Collectors.toList()));
 206
 207       Collection<Relation> LaRelations =  elementInfo.get().getRelations().stream().filter
 208           (rel->rel.getType().equals(RelationType.FeatureGroupToReferencingLicenseAgreement.name()))
 209           .map(rel ->VlmZusammenUtil.createRelation(RelationType
 210           .FeatureGroupToReferencingLicenseAgreement,rel.getEdge2().getElementId().toString()))
 211           .collect(Collectors.toList());
 212
 213       featureGroupElement.getRelations().addAll(LaRelations);
 214
 215       zusammenAdaptor
 216           .saveElement(context, elementContext, featureGroupElement, "update feature group");
 217     }
 218   }
 219
 220   @Override
 221   public void deleteAll(FeatureGroupEntity featureGroup) {
 222     //not supported
 223   }
 224
 225
 226   @Override
 227   public void addReferencingLicenseAgreement(FeatureGroupEntity featureGroup,
 228                                              String licenseAgreementId) {
 229     SessionContext context = ZusammenUtil.createSessionContext();
 230     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 231     ElementContext elementContext = new ElementContext(itemId,
 232         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 233
 234     Optional<ElementInfo> elementInfo =
 235         zusammenAdaptor.getElementInfo(context, elementContext, new Id(featureGroup.getId()));
 236     if (elementInfo.isPresent()) {
 237       ZusammenElement zusammenElement = VlmZusammenUtil.getZusammenElement(elementInfo.get());
 238       zusammenElement.setAction(Action.UPDATE);
 239       zusammenElement.getRelations().add(VlmZusammenUtil
 240           .createRelation(RelationType.FeatureGroupToReferencingLicenseAgreement,
 241               licenseAgreementId));
 242       zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 243           "add referencing license agreement");
 244     }
 245   }
 246
 247   @Override
 248   public void removeReferencingLicenseAgreement(FeatureGroupEntity featureGroup,
 249                                                 String licenseAgreementId) {
 250     SessionContext context = ZusammenUtil.createSessionContext();
 251     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 252     ElementContext elementContext = new ElementContext(itemId,
 253         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 254
 255     Optional<ElementInfo> elementInfo =
 256         zusammenAdaptor.getElementInfo(context, elementContext, new Id(featureGroup.getId()));
 257     if (elementInfo.isPresent()) {
 258       ZusammenElement zusammenElement = VlmZusammenUtil.getZusammenElement(elementInfo.get());
 259       zusammenElement.setAction(Action.UPDATE);
 260       zusammenElement.setRelations(elementInfo.get().getRelations().stream()
 261           .filter(
 262               relation -> !licenseAgreementId.equals(relation.getEdge2().getElementId().getValue()))
 263           .collect(Collectors.toList()));
 264
 265       zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 266           "remove referencing license agreement");
 267     }
 268   }
 269
 270   private ZusammenElement buildFeatureGroupElement(FeatureGroupEntity featureGroup, Action action) {
 271     ZusammenElement featureGroupElement = new ZusammenElement();
 272     featureGroupElement.setAction(action);
 273     if (featureGroup.getId() != null) {
 274       featureGroupElement.setElementId(new Id(featureGroup.getId()));
 275     }
 276     Info info = new Info();
 277     info.setName(featureGroup.getName());
 278     info.setDescription(featureGroup.getDescription());
 279     info.addProperty("partNumber", featureGroup.getPartNumber());
 280     featureGroupElement.setInfo(info);
 281
 282     featureGroupElement.setRelations(new ArrayList<>());
 283
 284     if (featureGroup.getEntitlementPoolIds() != null &&
 285         featureGroup.getEntitlementPoolIds().size() > 0) {
 286       featureGroupElement.getRelations().addAll(featureGroup.getEntitlementPoolIds().stream()
 287           .map(rel -> VlmZusammenUtil
 288               .createRelation(RelationType.FeatureGroupToEntitlmentPool, rel))
 289           .collect(Collectors.toList()));
 290     }
 291
 292     if (featureGroup.getLicenseKeyGroupIds() != null &&
 293         featureGroup.getLicenseKeyGroupIds().size() > 0) {
 294       featureGroupElement.getRelations()
 295           .addAll(featureGroup.getLicenseKeyGroupIds().stream()
 296               .map(rel -> VlmZusammenUtil
 297                   .createRelation(RelationType.FeatureGroupToLicenseKeyGroup, rel))
 298               .collect(Collectors.toList()));
 299     }
 300
 301     if (featureGroup.getReferencingLicenseAgreements() != null &&
 302         featureGroup.getReferencingLicenseAgreements().size() > 0) {
 303       featureGroupElement.getRelations()
 304           .addAll(featureGroup.getReferencingLicenseAgreements().stream()
 305               .map(rel -> VlmZusammenUtil
 306                   .createRelation(RelationType.FeatureGroupToReferencingLicenseAgreement,
 307                       rel))
 308               .collect(Collectors.toList()));
 309     }
 310     return featureGroupElement;
 311   }
 312
 313   private FeatureGroupEntity mapElementInfoToFeatureGroup(String vlmId, Version version,
 314                                                           ElementInfo elementInfo) {
 315     FeatureGroupEntity featureGroup =
 316         new FeatureGroupEntity(vlmId, version, elementInfo.getId().getValue());
 317     featureGroup.setName(elementInfo.getInfo().getName());
 318     featureGroup.setDescription(elementInfo.getInfo().getDescription());
 319     featureGroup.setPartNumber(elementInfo.getInfo().getProperty("partNumber"));
 320
 321     Set<String> entitlementPoolIds = new HashSet<>();
 322     Set<String> licenseAgreements = new HashSet<>();
 323     Set<String> licenseKeyGroupIds = new HashSet<>();
 324
 325     if (elementInfo.getRelations() != null) {
 326       for (Relation relation : elementInfo.getRelations()) {
 327         if (RelationType.FeatureGroupToEntitlmentPool.name().equals(relation.getType())) {
 328           entitlementPoolIds.add(relation.getEdge2().getElementId().getValue());
 329         } else if (RelationType.FeatureGroupToLicenseKeyGroup.name().equals(relation.getType())) {
 330           licenseKeyGroupIds.add(relation.getEdge2().getElementId().getValue());
 331         } else if (RelationType.FeatureGroupToReferencingLicenseAgreement.name()
 332             .equals(relation.getType())) {
 333           licenseAgreements.add(relation.getEdge2().getElementId().getValue());
 334         }
 335       }
 336     }
 337     featureGroup.setEntitlementPoolIds(entitlementPoolIds);
 338     featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
 339     featureGroup.setReferencingLicenseAgreements(licenseAgreements);
 340
 341     return featureGroup;
 342   }
 343 }