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