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       zusammenAdaptor
 208           .saveElement(context, elementContext, featureGroupElement, "update feature group");
 209     }
 210   }
 211
 212   @Override
 213   public void deleteAll(FeatureGroupEntity featureGroup) {
 214     //not supported
 215   }
 216
 217
 218   @Override
 219   public void addReferencingLicenseAgreement(FeatureGroupEntity featureGroup,
 220                                              String licenseAgreementId) {
 221     SessionContext context = ZusammenUtil.createSessionContext();
 222     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 223     ElementContext elementContext = new ElementContext(itemId,
 224         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 225
 226     Optional<ElementInfo> elementInfo =
 227         zusammenAdaptor.getElementInfo(context, elementContext, new Id(featureGroup.getId()));
 228     if (elementInfo.isPresent()) {
 229       ZusammenElement zusammenElement = VlmZusammenUtil.getZusammenElement(elementInfo.get());
 230       zusammenElement.setAction(Action.UPDATE);
 231       zusammenElement.getRelations().add(VlmZusammenUtil
 232           .createRelation(RelationType.FeatureGroupToReferencingLicenseAgreement,
 233               licenseAgreementId));
 234       zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 235           "add referencing license agreement");
 236     }
 237   }
 238
 239   @Override
 240   public void removeReferencingLicenseAgreement(FeatureGroupEntity featureGroup,
 241                                                 String licenseAgreementId) {
 242     SessionContext context = ZusammenUtil.createSessionContext();
 243     Id itemId = new Id(featureGroup.getVendorLicenseModelId());
 244     ElementContext elementContext = new ElementContext(itemId,
 245         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 246
 247     Optional<ElementInfo> elementInfo =
 248         zusammenAdaptor.getElementInfo(context, elementContext, new Id(featureGroup.getId()));
 249     if (elementInfo.isPresent()) {
 250       ZusammenElement zusammenElement = VlmZusammenUtil.getZusammenElement(elementInfo.get());
 251       zusammenElement.setAction(Action.UPDATE);
 252       zusammenElement.setRelations(elementInfo.get().getRelations().stream()
 253           .filter(
 254               relation -> !licenseAgreementId.equals(relation.getEdge2().getElementId().getValue()))
 255           .collect(Collectors.toList()));
 256
 257       zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 258           "remove referencing license agreement");
 259     }
 260   }
 261
 262   private ZusammenElement buildFeatureGroupElement(FeatureGroupEntity featureGroup, Action action) {
 263     ZusammenElement featureGroupElement = new ZusammenElement();
 264     featureGroupElement.setAction(action);
 265     if (featureGroup.getId() != null) {
 266       featureGroupElement.setElementId(new Id(featureGroup.getId()));
 267     }
 268     Info info = new Info();
 269     info.setName(featureGroup.getName());
 270     info.setDescription(featureGroup.getDescription());
 271     info.addProperty("partNumber", featureGroup.getPartNumber());
 272     featureGroupElement.setInfo(info);
 273
 274     featureGroupElement.setRelations(new ArrayList<>());
 275
 276     if (featureGroup.getEntitlementPoolIds() != null &&
 277         featureGroup.getEntitlementPoolIds().size() > 0) {
 278       featureGroupElement.getRelations().addAll(featureGroup.getEntitlementPoolIds().stream()
 279           .map(rel -> VlmZusammenUtil
 280               .createRelation(RelationType.FeatureGroupToEntitlmentPool, rel))
 281           .collect(Collectors.toList()));
 282     }
 283
 284     if (featureGroup.getLicenseKeyGroupIds() != null &&
 285         featureGroup.getLicenseKeyGroupIds().size() > 0) {
 286       featureGroupElement.getRelations()
 287           .addAll(featureGroup.getLicenseKeyGroupIds().stream()
 288               .map(rel -> VlmZusammenUtil
 289                   .createRelation(RelationType.FeatureGroupToLicenseKeyGroup, rel))
 290               .collect(Collectors.toList()));
 291     }
 292
 293     if (featureGroup.getReferencingLicenseAgreements() != null &&
 294         featureGroup.getReferencingLicenseAgreements().size() > 0) {
 295       featureGroupElement.getRelations()
 296           .addAll(featureGroup.getReferencingLicenseAgreements().stream()
 297               .map(rel -> VlmZusammenUtil
 298                   .createRelation(RelationType.FeatureGroupToReferencingLicenseAgreement,
 299                       rel))
 300               .collect(Collectors.toList()));
 301     }
 302     return featureGroupElement;
 303   }
 304
 305   private FeatureGroupEntity mapElementInfoToFeatureGroup(String vlmId, Version version,
 306                                                           ElementInfo elementInfo) {
 307     FeatureGroupEntity featureGroup =
 308         new FeatureGroupEntity(vlmId, version, elementInfo.getId().getValue());
 309     featureGroup.setName(elementInfo.getInfo().getName());
 310     featureGroup.setDescription(elementInfo.getInfo().getDescription());
 311     featureGroup.setPartNumber(elementInfo.getInfo().getProperty("partNumber"));
 312
 313     Set<String> entitlementPoolIds = new HashSet<>();
 314     Set<String> licenseAgreements = new HashSet<>();
 315     Set<String> licenseKeyGroupIds = new HashSet<>();
 316
 317     if (elementInfo.getRelations() != null) {
 318       for (Relation relation : elementInfo.getRelations()) {
 319         if (RelationType.FeatureGroupToEntitlmentPool.name().equals(relation.getType())) {
 320           entitlementPoolIds.add(relation.getEdge2().getElementId().getValue());
 321         } else if (RelationType.FeatureGroupToLicenseKeyGroup.name().equals(relation.getType())) {
 322           licenseKeyGroupIds.add(relation.getEdge2().getElementId().getValue());
 323         } else if (RelationType.FeatureGroupToReferencingLicenseAgreement.name()
 324             .equals(relation.getType())) {
 325           licenseAgreements.add(relation.getEdge2().getElementId().getValue());
 326         }
 327       }
 328     }
 329     featureGroup.setEntitlementPoolIds(entitlementPoolIds);
 330     featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
 331     featureGroup.setReferencingLicenseAgreements(licenseAgreements);
 332
 333     return featureGroup;
 334   }
 335 }