openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorlicense.impl;
  22
  23 import org.openecomp.core.util.UniqueValueUtil;
  24 import org.openecomp.sdc.activityLog.ActivityLogManager;
  25 import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
  26 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
  27 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  28 import org.openecomp.sdc.logging.api.Logger;
  29 import org.openecomp.sdc.logging.api.LoggerFactory;
  30 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  31 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  32 import org.openecomp.sdc.logging.types.LoggerConstants;
  33 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  34 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  35 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  36 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
  37 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
  38 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
  39 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory;
  40 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
  41 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory;
  42 import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
  43 import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory;
  44 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
  45 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
  46 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
  47 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
  48 import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
  49 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  50 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
  51 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
  52 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
  53 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
  54 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
  55 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  56 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
  57 import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
  58 import org.openecomp.sdc.versioning.VersioningManager;
  59 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  60 import org.openecomp.sdc.versioning.VersioningUtil;
  61 import org.openecomp.sdc.versioning.dao.types.Version;
  62 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  63 import org.openecomp.sdc.versioning.types.VersionInfo;
  64 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  65 import org.openecomp.sdcrests.activitylog.types.ActivityType;
  66
  67 import java.util.ArrayList;
  68 import java.util.Collection;
  69 import java.util.List;
  70 import java.util.Map;
  71 import java.util.Set;
  72
  73 import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
  74
  75 public class VendorLicenseManagerImpl implements VendorLicenseManager {
  76   private static final VersioningManager versioningManager =
  77       VersioningManagerFactory.getInstance().createInterface();
  78   private static final VendorLicenseFacade vendorLicenseFacade =
  79       VendorLicenseFacadeFactory.getInstance().createInterface();
  80   private static final VendorLicenseModelDao vendorLicenseModelDao =
  81       VendorLicenseModelDaoFactory.getInstance().createInterface();
  82   private static final LicenseAgreementDao licenseAgreementDao =
  83       LicenseAgreementDaoFactory.getInstance().createInterface();
  84   private static final FeatureGroupDao featureGroupDao =
  85       FeatureGroupDaoFactory.getInstance().createInterface();
  86   private static final EntitlementPoolDao entitlementPoolDao =
  87       EntitlementPoolDaoFactory.getInstance().createInterface();
  88   private static final LicenseKeyGroupDao licenseKeyGroupDao =
  89       LicenseKeyGroupDaoFactory.getInstance().createInterface();
  90   private ActivityLogManager activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
  91   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  92   private static final Logger logger =
  93       LoggerFactory.getLogger(VendorLicenseManagerImpl.class);
  94
  95   private static void sortVlmListByModificationTimeDescOrder(
  96       List<VersionedVendorLicenseModel> vendorLicenseModels) {
  97     vendorLicenseModels.sort((o1, o2) -> o2.getVendorLicenseModel().getWritetimeMicroSeconds()
  98         .compareTo(o1.getVendorLicenseModel().getWritetimeMicroSeconds()));
  99   }
 100
 101   @Override
 102   public void checkout(String vendorLicenseModelId, String user) {
 103
 104     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 105
 106     Version newVersion = versioningManager
 107         .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
 108
 109     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()+1),
 110             ActivityType.CHECKOUT.toString(), user, true, "", "");
 111     activityLogManager.addActionLog(activityLogEntity, user);
 112
 113     newVersion.setStatus(VersionStatus.Locked);
 114     vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
 115
 116     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 117   }
 118
 119   @Override
 120   public void undoCheckout(String vendorLicenseModelId, String user) {
 121
 122     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 123
 124     Version newVersion = versioningManager
 125         .undoCheckout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
 126     vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
 127
 128     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 129   }
 130
 131   @Override
 132   public void checkin(String vendorLicenseModelId, String user) {
 133
 134     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 135
 136     Version newVersion = vendorLicenseFacade.checkin(vendorLicenseModelId, user);
 137
 138     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId,
 139             String.valueOf(newVersion.getMajor()+1), ActivityType.CHECKIN.toString(), user, true, "", "");
 140     activityLogManager.addActionLog(activityLogEntity, user);
 141
 142     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 143   }
 144
 145   @Override
 146   public void submit(String vendorLicenseModelId, String user) {
 147
 148     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 149
 150     Version newVersion = vendorLicenseFacade.submit(vendorLicenseModelId, user);
 151
 152     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()),
 153             ActivityType.SUBMIT.toString(), user, true, "", "");
 154     activityLogManager.addActionLog(activityLogEntity, user);
 155
 156     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 157   }
 158
 159   @Override
 160   public Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter,
 161                                                                          String user) {
 162     mdcDataDebugMessage.debugEntryMessage(null);
 163
 164     Map<String, VersionInfo> idToVersionsInfo = versioningManager
 165         .listEntitiesVersionInfo(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, user,
 166             VersionableEntityAction.Read);
 167
 168     List<VersionedVendorLicenseModel> vendorLicenseModels = new ArrayList<>();
 169     for (Map.Entry<String, VersionInfo> entry : idToVersionsInfo.entrySet()) {
 170       VersionInfo versionInfo = entry.getValue();
 171       if (versionFilter != null && versionFilter.equals(VersionStatus.Final.name())) {
 172         if (versionInfo.getLatestFinalVersion() == null) {
 173           continue;
 174         }
 175         versionInfo.setActiveVersion(versionInfo.getLatestFinalVersion());
 176         versionInfo.setStatus(VersionStatus.Final);
 177         versionInfo.setLockingUser(null);
 178       }
 179
 180       Version version = versionInfo.getActiveVersion();
 181       if (user.equals(versionInfo.getLockingUser())) {
 182         version.setStatus(VersionStatus.Locked);
 183       }
 184
 185       try {
 186         VendorLicenseModelEntity vlm =
 187             vendorLicenseModelDao.get(new VendorLicenseModelEntity(entry.getKey(), version));
 188         if (vlm != null) {
 189           VersionedVendorLicenseModel versionedVlm = new VersionedVendorLicenseModel();
 190           versionedVlm.setVendorLicenseModel(vlm);
 191           versionedVlm.setVersionInfo(versionInfo);
 192           vendorLicenseModels.add(versionedVlm);
 193         }
 194       }catch(RuntimeException rte){
 195       logger.error("Error trying to retrieve vlm["+entry.getKey()+"] version["+version.toString
 196           ()+"] " +
 197           "message:"+rte
 198           .getMessage());
 199     }
 200     }
 201
 202     sortVlmListByModificationTimeDescOrder(vendorLicenseModels);
 203
 204     mdcDataDebugMessage.debugExitMessage(null);
 205     return vendorLicenseModels;
 206   }
 207
 208   @Override
 209   public VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity, String user) {
 210
 211     VendorLicenseModelEntity vendorLicenseModelCreated = vendorLicenseFacade.createVendorLicenseModel(vendorLicenseModelEntity, user);
 212
 213     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelCreated.getId(),
 214             String.valueOf(vendorLicenseModelCreated.getVersion().getMajor()+1),
 215             ActivityType.CREATE_NEW.toString(), user, true, "", "");
 216     activityLogManager.addActionLog(activityLogEntity, user);
 217
 218     return vendorLicenseModelCreated;
 219   }
 220
 221   @Override
 222   public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity,
 223                                        String user) {
 224     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelEntity.getId());
 225
 226     Version version = VersioningUtil.resolveVersion(null,
 227         getVersionInfo(vendorLicenseModelEntity.getId(), VersionableEntityAction.Write, user),
 228         user);
 229     vendorLicenseModelEntity.setVersion(version);
 230
 231     String existingVendorName = vendorLicenseModelDao.get(vendorLicenseModelEntity).getVendorName();
 232     UniqueValueUtil
 233         .updateUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName,
 234             vendorLicenseModelEntity.getVendorName());
 235     vendorLicenseModelDao.update(vendorLicenseModelEntity);
 236
 237     vendorLicenseFacade
 238         .updateVlmLastModificationTime(vendorLicenseModelEntity.getId(), version);
 239
 240     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelEntity.getId());
 241   }
 242
 243   @Override
 244   public VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version,
 245                                                            String user) {
 246     return vendorLicenseFacade.getVendorLicenseModel(vlmId, version, user);
 247   }
 248
 249   @Override
 250   public void deleteVendorLicenseModel(String vlmId, String user) {
 251     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 252         LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
 253         LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.UNSUPPORTED_OPERATION);
 254     throw new UnsupportedOperationException(VendorLicenseConstants.UNSUPPORTED_OPERATION_ERROR);
 255   }
 256
 257   @Override
 258   public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version,
 259                                                                   String user) {
 260     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 261     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 262     return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, VersioningUtil
 263         .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
 264         null));
 265   }
 266
 267   @Override
 268   public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement,
 269                                                        String user) {
 270     mdcDataDebugMessage
 271         .debugEntryMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
 272     mdcDataDebugMessage
 273         .debugExitMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
 274     return vendorLicenseFacade.createLicenseAgreement(licenseAgreement, user);
 275   }
 276
 277   @Override
 278   public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
 279                                      Set<String> addedFeatureGroupIds,
 280                                      Set<String> removedFeatureGroupIds, String user) {
 281     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", licenseAgreement
 282         .getVendorLicenseModelId(), licenseAgreement.getId());
 283
 284     Version version = VersioningUtil.resolveVersion(licenseAgreement.getVersion(),
 285         getVersionInfo(licenseAgreement.getVendorLicenseModelId(), VersionableEntityAction.Write,
 286             user), user);
 287     licenseAgreement.setVersion(version);
 288     LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement);
 289     VersioningUtil
 290         .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
 291     VersioningUtil.validateContainedEntitiesExistence(new FeatureGroupEntity().getEntityType(),
 292         removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds());
 293     VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds,
 294         new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), version, null),
 295         featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
 296
 297     UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
 298         retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(),
 299         licenseAgreement.getVersion().toString());
 300     licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds,
 301         removedFeatureGroupIds);
 302
 303     addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement);
 304     removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement);
 305
 306     vendorLicenseFacade
 307         .updateVlmLastModificationTime(licenseAgreement.getVendorLicenseModelId(), version);
 308
 309     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", licenseAgreement
 310         .getVendorLicenseModelId(), licenseAgreement.getId());
 311   }
 312
 313   @Override
 314   public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
 315                                                         String licenseAgreementId, String user) {
 316
 317     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
 318     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
 319     return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId, user);
 320   }
 321
 322   @Override
 323   public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId,
 324                                      String user) {
 325     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
 326
 327     version = VersioningUtil
 328         .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Write, user), user);
 329     LicenseAgreementEntity input =
 330         new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
 331     LicenseAgreementEntity retrieved = licenseAgreementDao.get(input);
 332     VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE);
 333
 334     removeFeatureGroupsToLicenseAgreementRef(retrieved.getFeatureGroupIds(), retrieved);
 335
 336     licenseAgreementDao.delete(input);
 337     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
 338         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 339         retrieved.getName());
 340
 341     vendorLicenseFacade
 342         .updateVlmLastModificationTime(input.getVendorLicenseModelId(), input.getVersion());
 343
 344     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
 345   }
 346
 347   @Override
 348   public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version,
 349                                                           String user) {
 350     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 351     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 352     return featureGroupDao.list(new FeatureGroupEntity(vlmId, VersioningUtil
 353         .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
 354         null));
 355   }
 356
 357   @Override
 358   public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup, String user) {
 359     mdcDataDebugMessage
 360         .debugEntryMessage("VLM id", featureGroup.getVendorLicenseModelId());
 361     mdcDataDebugMessage.debugExitMessage("VLM id", featureGroup.getId());
 362     return vendorLicenseFacade.createFeatureGroup(featureGroup, user);
 363   }
 364
 365   @Override
 366   public void updateFeatureGroup(FeatureGroupEntity featureGroup,
 367                                  Set<String> addedLicenseKeyGroups,
 368                                  Set<String> removedLicenseKeyGroups,
 369                                  Set<String> addedEntitlementPools,
 370                                  Set<String> removedEntitlementPools,
 371                                  String user) {
 372     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id", featureGroup
 373         .getVendorLicenseModelId(), featureGroup.getId());
 374
 375     Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
 376         getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, user),
 377         user);
 378     featureGroup.setVersion(version);
 379
 380     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
 381     VersioningUtil
 382         .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 383
 384     VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(),
 385         removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds());
 386     VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(),
 387         removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds());
 388
 389     VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups,
 390         new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), version, null),
 391         licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
 392     VersioningUtil.validateEntitiesExistence(addedEntitlementPools,
 393         new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), version, null),
 394         entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE);
 395     UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
 396         retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(),
 397         featureGroup.getVersion().toString());
 398
 399     addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup);
 400     removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup);
 401     addEntitlementPoolsToFeatureGroupsRef(addedEntitlementPools, featureGroup);
 402     removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup);
 403
 404     featureGroupDao.updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools,
 405         addedLicenseKeyGroups, removedLicenseKeyGroups);
 406
 407     vendorLicenseFacade
 408         .updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(), version);
 409
 410     mdcDataDebugMessage.debugExitMessage("VLM id, FG id", featureGroup
 411         .getVendorLicenseModelId(), featureGroup.getId());
 412   }
 413
 414   @Override
 415   public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup, String user) {
 416     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
 417         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 418
 419     mdcDataDebugMessage.debugExitMessage("VLM id, FG id",
 420         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 421     return vendorLicenseFacade.getFeatureGroupModel(featureGroup, user);
 422   }
 423
 424   @Override
 425   public void deleteFeatureGroup(FeatureGroupEntity featureGroup, String user) {
 426     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
 427         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 428
 429     Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
 430         getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 431             user), user);
 432     featureGroup.setVersion(version);
 433     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
 434     VersioningUtil
 435         .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 436
 437     removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup);
 438     removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup);
 439
 440     for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) {
 441       licenseAgreementDao.removeFeatureGroup(
 442           new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(), version,
 443               licenceAgreementId), featureGroup.getId());
 444     }
 445
 446     featureGroupDao.delete(featureGroup);
 447     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
 448         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 449         retrieved.getName());
 450
 451     vendorLicenseFacade.updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(),
 452         featureGroup.getVersion());
 453
 454     mdcDataDebugMessage
 455         .debugExitMessage("VLM id, FG id",
 456             featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 457   }
 458
 459   @Override
 460   public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version,
 461                                                                 String user) {
 462     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 463     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 464     return vendorLicenseFacade.listEntitlementPools(vlmId, version, user);
 465   }
 466
 467   @Override
 468   public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool,
 469                                                      String user) {
 470     mdcDataDebugMessage
 471         .debugEntryMessage("VLM id", entitlementPool.getVendorLicenseModelId());
 472     mdcDataDebugMessage
 473         .debugExitMessage("VLM id", entitlementPool.getVendorLicenseModelId());
 474     return vendorLicenseFacade.createEntitlementPool(entitlementPool, user);
 475   }
 476
 477   @Override
 478   public void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
 479     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 480         .getVendorLicenseModelId(), entitlementPool.getId());
 481
 482     Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 483         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
 484             user), user);
 485     vendorLicenseFacade
 486         .updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(), version);
 487     vendorLicenseFacade.updateEntitlementPool(entitlementPool, user);
 488
 489     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 490         .getVendorLicenseModelId(), entitlementPool.getId());
 491   }
 492
 493   @Override
 494   public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool,
 495                                                   String user) {
 496     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 497         .getVendorLicenseModelId(), entitlementPool.getId());
 498
 499     entitlementPool.setVersion(VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 500         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Read,
 501             user), user));
 502
 503     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
 504     VersioningUtil
 505         .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 506
 507     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 508         .getVendorLicenseModelId(), entitlementPool.getId());
 509     return retrieved;
 510   }
 511
 512   @Override
 513   public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
 514     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 515         .getVendorLicenseModelId(), entitlementPool.getId());
 516
 517     Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 518         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
 519             user), user);
 520     entitlementPool.setVersion(version);
 521
 522     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
 523     VersioningUtil
 524         .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 525
 526     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
 527       featureGroupDao.removeEntitlementPool(
 528           new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(), version,
 529               referencingFeatureGroupId), entitlementPool.getId());
 530     }
 531
 532     entitlementPoolDao.delete(entitlementPool);
 533
 534     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME,
 535         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 536         retrieved.getName());
 537
 538     vendorLicenseFacade.updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(),
 539         entitlementPool.getVersion());
 540
 541     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 542         .getVendorLicenseModelId(), entitlementPool.getId());
 543   }
 544
 545   @Override
 546   public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version,
 547                                                                 String user) {
 548     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 549     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 550     return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version, user);
 551   }
 552
 553   @Override
 554   public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
 555                                                      String user) {
 556     mdcDataDebugMessage
 557         .debugEntryMessage("VLM id", licenseKeyGroup.getVendorLicenseModelId());
 558
 559     mdcDataDebugMessage.debugExitMessage("VLM id", licenseKeyGroup
 560         .getVendorLicenseModelId());
 561     return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup, user);
 562   }
 563
 564   @Override
 565   public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
 566     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 567         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 568
 569     Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 570         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 571             user), user);
 572     vendorLicenseFacade
 573         .updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(), version);
 574
 575     vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup, user);
 576
 577     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 578         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 579   }
 580
 581   @Override
 582   public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
 583                                                   String user) {
 584     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 585         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 586
 587     licenseKeyGroup.setVersion(VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 588         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Read,
 589             user), user));
 590
 591     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
 592     VersioningUtil
 593         .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 594
 595     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 596         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 597     return retrieved;
 598   }
 599
 600   @Override
 601   public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
 602     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 603         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 604
 605     Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 606         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 607             user), user);
 608     licenseKeyGroup.setVersion(version);
 609
 610     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
 611     VersioningUtil
 612         .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 613
 614     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
 615       featureGroupDao.removeLicenseKeyGroup(
 616           new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(), version,
 617               referencingFeatureGroupId), licenseKeyGroup.getId());
 618     }
 619
 620     licenseKeyGroupDao.delete(licenseKeyGroup);
 621
 622     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME,
 623         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 624         retrieved.getName());
 625
 626     vendorLicenseFacade.updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(),
 627         licenseKeyGroup.getVersion());
 628
 629     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 630         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 631   }
 632
 633   private void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 634                                                      LicenseAgreementEntity licenseAgreement) {
 635     if (featureGroupIds != null) {
 636       for (String featureGroupId : featureGroupIds) {
 637         featureGroupDao.addReferencingLicenseAgreement(
 638             new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 639                 licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 640       }
 641     }
 642   }
 643
 644   private void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 645                                                         LicenseAgreementEntity licenseAgreement) {
 646     if (featureGroupIds != null) {
 647       for (String featureGroupId : featureGroupIds) {
 648         featureGroupDao.removeReferencingLicenseAgreement(
 649             new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 650                 licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 651       }
 652     }
 653   }
 654
 655   private void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 656                                                      FeatureGroupEntity featureGroup) {
 657     if (licenseKeyGroupIds != null) {
 658       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 659         licenseKeyGroupDao.addReferencingFeatureGroup(
 660             new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 661                 featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 662       }
 663     }
 664   }
 665
 666   private void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 667                                                         FeatureGroupEntity featureGroup) {
 668     if (licenseKeyGroupIds != null) {
 669       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 670         licenseKeyGroupDao.removeReferencingFeatureGroup(
 671             new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 672                 featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 673       }
 674     }
 675   }
 676
 677   private void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
 678                                                      FeatureGroupEntity featureGroup) {
 679     if (entitlementPoolIds != null) {
 680       for (String entitlementPoolId : entitlementPoolIds) {
 681         entitlementPoolDao.addReferencingFeatureGroup(
 682             new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
 683                 featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
 684       }
 685     }
 686   }
 687
 688   private void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
 689                                                         FeatureGroupEntity featureGroup) {
 690     if (entitlementPoolIds != null) {
 691       for (String entitlementPoolId : entitlementPoolIds) {
 692         entitlementPoolDao.removeReferencingFeatureGroup(
 693             new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
 694                 featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
 695       }
 696     }
 697   }
 698
 699   private VersionInfo getVersionInfo(String vendorLicenseModelId, VersionableEntityAction action,
 700                                      String user) {
 701     return vendorLicenseFacade.getVersionInfo(vendorLicenseModelId, action, user);
 702   }
 703 }