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