gerrit.onap Code Review - sdc.git/blob

   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.common.errors.CoreException;
  28 import org.openecomp.sdc.common.errors.ErrorCode;
  29 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  30 import org.openecomp.sdc.logging.api.Logger;
  31 import org.openecomp.sdc.logging.api.LoggerFactory;
  32 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  33 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  34 import org.openecomp.sdc.logging.types.LoggerConstants;
  35 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  36 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  37 import org.openecomp.sdc.logging.types.LoggerServiceName;
  38 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  39 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
  40 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
  41 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
  42 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory;
  43 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
  44 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory;
  45 import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
  46 import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory;
  47 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
  48 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
  49 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
  50 import org.openecomp.sdc.vendorlicense.dao.LimitDaoFactory;
  51 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
  52 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
  53 import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
  54 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  55 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
  56 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
  57 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
  58 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
  59 import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
  60 import org.openecomp.sdc.vendorlicense.dao.types.LimitType;
  61 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
  62 import org.openecomp.sdc.vendorlicense.errors.InvalidDateErrorBuilder;
  63 import org.openecomp.sdc.vendorlicense.errors.LimitErrorBuilder;
  64 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  65 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
  66 import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
  67 import org.openecomp.sdc.versioning.VersioningManager;
  68 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  69 import org.openecomp.sdc.versioning.VersioningUtil;
  70 import org.openecomp.sdc.versioning.dao.types.Version;
  71 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  72 import org.openecomp.sdc.versioning.types.VersionInfo;
  73 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  74 import org.openecomp.sdcrests.activitylog.types.ActivityType;
  75
  76 import java.time.LocalDate;
  77 import java.time.format.DateTimeFormatter;
  78 import java.util.ArrayList;
  79 import java.util.Collection;
  80 import java.util.Iterator;
  81 import java.util.List;
  82 import java.util.Map;
  83 import java.util.Optional;
  84 import java.util.Set;
  85
  86 import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
  87
  88 public class VendorLicenseManagerImpl implements VendorLicenseManager {
  89   private static final VersioningManager versioningManager =
  90       VersioningManagerFactory.getInstance().createInterface();
  91   private VendorLicenseFacade vendorLicenseFacade =
  92       VendorLicenseFacadeFactory.getInstance().createInterface();
  93   private static final VendorLicenseModelDao vendorLicenseModelDao =
  94       VendorLicenseModelDaoFactory.getInstance().createInterface();
  95   private static final LicenseAgreementDao licenseAgreementDao =
  96       LicenseAgreementDaoFactory.getInstance().createInterface();
  97   private static final FeatureGroupDao featureGroupDao =
  98       FeatureGroupDaoFactory.getInstance().createInterface();
  99   private static final EntitlementPoolDao entitlementPoolDao =
 100       EntitlementPoolDaoFactory.getInstance().createInterface();
 101   private static final LicenseKeyGroupDao licenseKeyGroupDao =
 102       LicenseKeyGroupDaoFactory.getInstance().createInterface();
 103   private static final LimitDao limitDao =
 104       LimitDaoFactory.getInstance().createInterface();
 105
 106   private ActivityLogManager activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
 107   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
 108   private static final Logger logger =
 109       LoggerFactory.getLogger(VendorLicenseManagerImpl.class);
 110
 111   private static void sortVlmListByModificationTimeDescOrder(
 112       List<VersionedVendorLicenseModel> vendorLicenseModels) {
 113     vendorLicenseModels.sort((o1, o2) -> o2.getVendorLicenseModel().getWritetimeMicroSeconds()
 114         .compareTo(o1.getVendorLicenseModel().getWritetimeMicroSeconds()));
 115   }
 116
 117   @Override
 118   public void checkout(String vendorLicenseModelId, String user) {
 119
 120     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 121
 122     Version newVersion = versioningManager
 123         .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
 124
 125     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()+1),
 126             ActivityType.CHECKOUT.toString(), user, true, "", "");
 127     activityLogManager.addActionLog(activityLogEntity, user);
 128
 129     newVersion.setStatus(VersionStatus.Locked);
 130     vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
 131
 132     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 133   }
 134
 135   @Override
 136   public void undoCheckout(String vendorLicenseModelId, String user) {
 137
 138     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 139
 140     Version newVersion = versioningManager
 141         .undoCheckout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
 142     vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
 143
 144     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 145   }
 146
 147   @Override
 148   public void checkin(String vendorLicenseModelId, String user) {
 149
 150     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 151
 152     Version newVersion = vendorLicenseFacade.checkin(vendorLicenseModelId, user);
 153
 154     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId,
 155             String.valueOf(newVersion.getMajor()+1), ActivityType.CHECKIN.toString(), user, true, "", "");
 156     activityLogManager.addActionLog(activityLogEntity, user);
 157
 158     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 159   }
 160
 161   @Override
 162   public void submit(String vendorLicenseModelId, String user) {
 163
 164     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 165
 166     Version newVersion = vendorLicenseFacade.submit(vendorLicenseModelId, user);
 167
 168     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()),
 169             ActivityType.SUBMIT.toString(), user, true, "", "");
 170     activityLogManager.addActionLog(activityLogEntity, user);
 171
 172     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
 173   }
 174
 175   @Override
 176   public Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter,
 177                                                                          String user) {
 178     mdcDataDebugMessage.debugEntryMessage(null);
 179
 180     Map<String, VersionInfo> idToVersionsInfo = versioningManager
 181         .listEntitiesVersionInfo(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, user,
 182             VersionableEntityAction.Read);
 183
 184     List<VersionedVendorLicenseModel> vendorLicenseModels = new ArrayList<>();
 185     for (Map.Entry<String, VersionInfo> entry : idToVersionsInfo.entrySet()) {
 186       VersionInfo versionInfo = entry.getValue();
 187       if (versionFilter != null && versionFilter.equals(VersionStatus.Final.name())) {
 188         if (versionInfo.getLatestFinalVersion() == null) {
 189           continue;
 190         }
 191         versionInfo.setActiveVersion(versionInfo.getLatestFinalVersion());
 192         versionInfo.setStatus(VersionStatus.Final);
 193         versionInfo.setLockingUser(null);
 194       }
 195
 196       Version version = versionInfo.getActiveVersion();
 197       if (user.equals(versionInfo.getLockingUser())) {
 198         version.setStatus(VersionStatus.Locked);
 199       }
 200
 201       try {
 202         VendorLicenseModelEntity vlm =
 203             vendorLicenseModelDao.get(new VendorLicenseModelEntity(entry.getKey(), version));
 204         if (vlm != null) {
 205           VersionedVendorLicenseModel versionedVlm = new VersionedVendorLicenseModel();
 206           versionedVlm.setVendorLicenseModel(vlm);
 207           versionedVlm.setVersionInfo(versionInfo);
 208           vendorLicenseModels.add(versionedVlm);
 209         }
 210       }catch(RuntimeException rte){
 211       logger.error("Error trying to retrieve vlm["+entry.getKey()+"] version["+version.toString
 212           ()+"] " +
 213           "message:"+rte
 214           .getMessage());
 215     }
 216     }
 217
 218     sortVlmListByModificationTimeDescOrder(vendorLicenseModels);
 219
 220     mdcDataDebugMessage.debugExitMessage(null);
 221     return vendorLicenseModels;
 222   }
 223
 224   @Override
 225   public VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity, String user) {
 226
 227     VendorLicenseModelEntity vendorLicenseModelCreated = vendorLicenseFacade.createVendorLicenseModel(vendorLicenseModelEntity, user);
 228
 229     ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelCreated.getId(),
 230             String.valueOf(vendorLicenseModelCreated.getVersion().getMajor()+1),
 231             ActivityType.CREATE_NEW.toString(), user, true, "", "");
 232     activityLogManager.addActionLog(activityLogEntity, user);
 233
 234     return vendorLicenseModelCreated;
 235   }
 236
 237   @Override
 238   public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity,
 239                                        String user) {
 240     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelEntity.getId());
 241
 242     Version version = VersioningUtil.resolveVersion(null,
 243         getVersionInfo(vendorLicenseModelEntity.getId(), VersionableEntityAction.Write, user),
 244         user);
 245     vendorLicenseModelEntity.setVersion(version);
 246
 247     String existingVendorName = vendorLicenseModelDao.get(vendorLicenseModelEntity).getVendorName();
 248     UniqueValueUtil
 249         .updateUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName,
 250             vendorLicenseModelEntity.getVendorName());
 251     vendorLicenseModelDao.update(vendorLicenseModelEntity);
 252
 253     vendorLicenseFacade
 254         .updateVlmLastModificationTime(vendorLicenseModelEntity.getId(), version);
 255
 256     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelEntity.getId());
 257   }
 258
 259   @Override
 260   public VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version,
 261                                                            String user) {
 262     return vendorLicenseFacade.getVendorLicenseModel(vlmId, version, user);
 263   }
 264
 265   @Override
 266   public void deleteVendorLicenseModel(String vlmId, String user) {
 267     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 268         LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
 269         LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.UNSUPPORTED_OPERATION);
 270     throw new UnsupportedOperationException(VendorLicenseConstants.UNSUPPORTED_OPERATION_ERROR);
 271   }
 272
 273   @Override
 274   public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version,
 275                                                                   String user) {
 276     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 277     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 278     return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, VersioningUtil
 279         .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
 280         null));
 281   }
 282
 283   @Override
 284   public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement,
 285                                                        String user) {
 286     mdcDataDebugMessage
 287         .debugEntryMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
 288     mdcDataDebugMessage
 289         .debugExitMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
 290     return vendorLicenseFacade.createLicenseAgreement(licenseAgreement, user);
 291   }
 292
 293   @Override
 294   public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
 295                                      Set<String> addedFeatureGroupIds,
 296                                      Set<String> removedFeatureGroupIds, String user) {
 297     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", licenseAgreement
 298         .getVendorLicenseModelId(), licenseAgreement.getId());
 299
 300     Version version = VersioningUtil.resolveVersion(licenseAgreement.getVersion(),
 301         getVersionInfo(licenseAgreement.getVendorLicenseModelId(), VersionableEntityAction.Write,
 302             user), user);
 303     licenseAgreement.setVersion(version);
 304     LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement);
 305     VersioningUtil
 306         .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
 307     VersioningUtil.validateContainedEntitiesExistence(new FeatureGroupEntity().getEntityType(),
 308         removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds());
 309     VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds,
 310         new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), version, null),
 311         featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
 312
 313     UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
 314         retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(),
 315         licenseAgreement.getVersion().toString());
 316     licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds,
 317         removedFeatureGroupIds);
 318
 319     addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement);
 320     removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement);
 321
 322     vendorLicenseFacade
 323         .updateVlmLastModificationTime(licenseAgreement.getVendorLicenseModelId(), version);
 324
 325     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", licenseAgreement
 326         .getVendorLicenseModelId(), licenseAgreement.getId());
 327   }
 328
 329   @Override
 330   public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
 331                                                         String licenseAgreementId, String user) {
 332
 333     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
 334     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
 335     return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId, user);
 336   }
 337
 338   @Override
 339   public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId,
 340                                      String user) {
 341     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
 342
 343     version = VersioningUtil
 344         .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Write, user), user);
 345     LicenseAgreementEntity input =
 346         new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
 347     LicenseAgreementEntity retrieved = licenseAgreementDao.get(input);
 348     VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE);
 349
 350     removeFeatureGroupsToLicenseAgreementRef(retrieved.getFeatureGroupIds(), retrieved);
 351
 352     licenseAgreementDao.delete(input);
 353     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
 354         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 355         retrieved.getName());
 356
 357     vendorLicenseFacade
 358         .updateVlmLastModificationTime(input.getVendorLicenseModelId(), input.getVersion());
 359
 360     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
 361   }
 362
 363   @Override
 364   public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version,
 365                                                           String user) {
 366     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 367     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 368     return vendorLicenseFacade.listFeatureGroups(vlmId, version, user);
 369   }
 370
 371   @Override
 372   public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup, String user) {
 373     mdcDataDebugMessage
 374         .debugEntryMessage("VLM id", featureGroup.getVendorLicenseModelId());
 375     mdcDataDebugMessage.debugExitMessage("VLM id", featureGroup.getId());
 376     return vendorLicenseFacade.createFeatureGroup(featureGroup, user);
 377   }
 378
 379   @Override
 380   public void updateFeatureGroup(FeatureGroupEntity featureGroup,
 381                                  Set<String> addedLicenseKeyGroups,
 382                                  Set<String> removedLicenseKeyGroups,
 383                                  Set<String> addedEntitlementPools,
 384                                  Set<String> removedEntitlementPools,
 385                                  String user) {
 386     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id", featureGroup
 387         .getVendorLicenseModelId(), featureGroup.getId());
 388
 389     Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
 390         getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, user),
 391         user);
 392     featureGroup.setVersion(version);
 393
 394     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
 395     VersioningUtil
 396         .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 397
 398     VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(),
 399         removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds());
 400     VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(),
 401         removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds());
 402
 403     VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups,
 404         new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), version, null),
 405         licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
 406     VersioningUtil.validateEntitiesExistence(addedEntitlementPools,
 407         new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), version, null),
 408         entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE);
 409     UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
 410         retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(),
 411         featureGroup.getVersion().toString());
 412
 413     addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup);
 414     removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup);
 415     addEntitlementPoolsToFeatureGroupsRef(addedEntitlementPools, featureGroup);
 416     removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup);
 417
 418     featureGroupDao.updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools,
 419         addedLicenseKeyGroups, removedLicenseKeyGroups);
 420
 421     vendorLicenseFacade
 422         .updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(), version);
 423
 424     mdcDataDebugMessage.debugExitMessage("VLM id, FG id", featureGroup
 425         .getVendorLicenseModelId(), featureGroup.getId());
 426   }
 427
 428   @Override
 429   public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup, String user) {
 430     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
 431         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 432
 433     mdcDataDebugMessage.debugExitMessage("VLM id, FG id",
 434         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 435     return vendorLicenseFacade.getFeatureGroupModel(featureGroup, user);
 436   }
 437
 438   @Override
 439   public void deleteFeatureGroup(FeatureGroupEntity featureGroup, String user) {
 440     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
 441         featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 442
 443     Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
 444         getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 445             user), user);
 446     featureGroup.setVersion(version);
 447     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
 448     VersioningUtil
 449         .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 450
 451     removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup);
 452     removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup);
 453
 454     for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) {
 455       licenseAgreementDao.removeFeatureGroup(
 456           new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(), version,
 457               licenceAgreementId), featureGroup.getId());
 458     }
 459
 460     featureGroupDao.delete(featureGroup);
 461     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
 462         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 463         retrieved.getName());
 464
 465     vendorLicenseFacade.updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(),
 466         featureGroup.getVersion());
 467
 468     mdcDataDebugMessage
 469         .debugExitMessage("VLM id, FG id",
 470             featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 471   }
 472
 473   @Override
 474   public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version,
 475                                                                 String user) {
 476     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 477     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 478     return vendorLicenseFacade.listEntitlementPools(vlmId, version, user);
 479   }
 480
 481   @Override
 482   public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool,
 483                                                      String user) {
 484     mdcDataDebugMessage
 485         .debugEntryMessage("VLM id", entitlementPool.getVendorLicenseModelId());
 486     mdcDataDebugMessage
 487         .debugExitMessage("VLM id", entitlementPool.getVendorLicenseModelId());
 488
 489     entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
 490         .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
 491         : null) : null);
 492     entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
 493         .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
 494         : null) : null);
 495
 496     validateCreateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
 497         entitlementPool.getVendorLicenseModelId());
 498     return vendorLicenseFacade.createEntitlementPool(entitlementPool, user);
 499   }
 500
 501   private void validateCreateDate(String startDate, String expiryDate, String vendorLicenseModelId){
 502     mdcDataDebugMessage.debugEntryMessage("Start date and end date", startDate
 503         +"   "+expiryDate);
 504
 505     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 506
 507     if(startDate != null && expiryDate != null) {
 508       if (LocalDate.parse(startDate, formatter).atStartOfDay().isBefore
 509           (LocalDate.now().atStartOfDay()) || LocalDate.parse(expiryDate, formatter).atStartOfDay()
 510               .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) || LocalDate
 511           .parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
 512         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 513             LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
 514             LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
 515         throw new CoreException(
 516             new InvalidDateErrorBuilder(vendorLicenseModelId)
 517                 .build());
 518       }
 519     }
 520
 521     if(startDate != null && expiryDate == null) {
 522       if (LocalDate.parse(startDate, formatter).atStartOfDay().isBefore
 523           (LocalDate.now().atStartOfDay())) {
 524         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 525             LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
 526             LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
 527         throw new CoreException(
 528             new InvalidDateErrorBuilder(vendorLicenseModelId)
 529                 .build());
 530       }
 531     }
 532
 533     if(startDate == null && expiryDate != null) {
 534       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 535           LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
 536           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
 537       throw new CoreException(
 538           new InvalidDateErrorBuilder(vendorLicenseModelId)
 539               .build());
 540
 541     }
 542
 543     mdcDataDebugMessage.debugExitMessage(null,null);
 544   }
 545
 546   private void validateUpdateDate(String startDate, String expiryDate, String vendorLicenseModelId){
 547     mdcDataDebugMessage.debugEntryMessage("Start date and end date", startDate
 548         +"   "+ expiryDate);
 549
 550     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 551
 552     if(startDate != null && expiryDate != null) {
 553       if (LocalDate.parse(expiryDate, formatter).atStartOfDay()
 554           .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) ||
 555           LocalDate.parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
 556         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 557             LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
 558             LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
 559         throw new CoreException(
 560             new InvalidDateErrorBuilder(vendorLicenseModelId)
 561                 .build());
 562       }
 563     }
 564
 565     if(startDate == null && expiryDate != null) {
 566       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 567           LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
 568           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
 569       throw new CoreException(
 570           new InvalidDateErrorBuilder(vendorLicenseModelId)
 571               .build());
 572
 573     }
 574
 575     mdcDataDebugMessage.debugExitMessage(null,null);
 576   }
 577
 578   @Override
 579   public void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
 580     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 581         .getVendorLicenseModelId(), entitlementPool.getId());
 582
 583     entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
 584         .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
 585         : null) : null);
 586     entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
 587         .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
 588         : null) : null);
 589
 590     validateUpdateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
 591         entitlementPool.getVendorLicenseModelId());
 592     Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 593         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
 594             user), user);
 595     vendorLicenseFacade
 596         .updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(), version);
 597     vendorLicenseFacade.updateEntitlementPool(entitlementPool, user);
 598
 599     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 600         .getVendorLicenseModelId(), entitlementPool.getId());
 601   }
 602
 603   @Override
 604   public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool,
 605                                                   String user) {
 606     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 607         .getVendorLicenseModelId(), entitlementPool.getId());
 608
 609     entitlementPool.setVersion(VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 610         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Read,
 611             user), user));
 612
 613     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
 614     VersioningUtil
 615         .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 616
 617     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 618     DateTimeFormatter targetFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
 619     if(retrieved.getStartDate() != null){
 620       retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(),formatter).format
 621           (targetFormatter));
 622     }
 623
 624     if(retrieved.getExpiryDate() != null){
 625       retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(),formatter).format
 626           (targetFormatter));
 627     }
 628
 629     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 630         .getVendorLicenseModelId(), entitlementPool.getId());
 631     return retrieved;
 632   }
 633
 634   @Override
 635   public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
 636     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
 637         .getVendorLicenseModelId(), entitlementPool.getId());
 638
 639     Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
 640         getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
 641             user), user);
 642     entitlementPool.setVersion(version);
 643
 644     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
 645     VersioningUtil
 646         .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 647
 648     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
 649       featureGroupDao.removeEntitlementPool(
 650           new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(), version,
 651               referencingFeatureGroupId), entitlementPool.getId());
 652     }
 653
 654     deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(), entitlementPool.getId(), user);
 655
 656     entitlementPoolDao.delete(entitlementPool);
 657
 658     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME,
 659         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 660         retrieved.getName());
 661
 662     vendorLicenseFacade.updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(),
 663         entitlementPool.getVersion());
 664
 665     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
 666         .getVendorLicenseModelId(), entitlementPool.getId());
 667   }
 668
 669   private void deleteChildLimits(String vlmId, Version version, String epLkgId, String user) {
 670       Optional<Collection<LimitEntity>> limitEntities = Optional.ofNullable(
 671               listLimits(vlmId, version, epLkgId, user));
 672       limitEntities.ifPresent(entities->
 673               entities.forEach(entity->
 674                       deleteLimit(entity, user)));
 675   }
 676
 677   @Override
 678   public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version,
 679                                                                 String user) {
 680     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
 681     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
 682     return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version, user);
 683   }
 684
 685   @Override
 686   public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
 687                                                      String user) {
 688     mdcDataDebugMessage
 689         .debugEntryMessage("VLM id", licenseKeyGroup.getVendorLicenseModelId());
 690
 691     mdcDataDebugMessage.debugExitMessage("VLM id", licenseKeyGroup
 692         .getVendorLicenseModelId());
 693
 694     licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
 695         .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()+"T00:00:00Z"
 696         : null) : null);
 697     licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
 698         .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()+"T23:59:59Z"
 699         : null) : null);
 700
 701     validateCreateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
 702         licenseKeyGroup.getVendorLicenseModelId());
 703     return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup, user);
 704   }
 705
 706   @Override
 707   public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
 708     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 709         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 710
 711     licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
 712         .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()+"T00:00:00Z"
 713         : null) : null);
 714     licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
 715         .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()+"T23:59:59Z"
 716         : null) : null);
 717
 718     validateUpdateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
 719         licenseKeyGroup.getVendorLicenseModelId());
 720
 721     Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 722         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 723             user), user);
 724     vendorLicenseFacade
 725         .updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(), version);
 726
 727     vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup, user);
 728
 729     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 730         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 731   }
 732
 733   @Override
 734   public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
 735                                                   String user) {
 736     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 737         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 738
 739     licenseKeyGroup.setVersion(VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 740         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Read,
 741             user), user));
 742
 743     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
 744     VersioningUtil
 745         .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 746
 747     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 748         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 749     return retrieved;
 750   }
 751
 752   @Override
 753   public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
 754     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
 755         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 756
 757     Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
 758         getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
 759             user), user);
 760     licenseKeyGroup.setVersion(version);
 761
 762     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
 763     VersioningUtil
 764         .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 765
 766     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
 767       featureGroupDao.removeLicenseKeyGroup(
 768           new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(), version,
 769               referencingFeatureGroupId), licenseKeyGroup.getId());
 770     }
 771
 772     deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(), licenseKeyGroup.getId(), user);
 773
 774     licenseKeyGroupDao.delete(licenseKeyGroup);
 775
 776     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME,
 777         retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
 778         retrieved.getName());
 779
 780     vendorLicenseFacade.updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(),
 781         licenseKeyGroup.getVersion());
 782
 783     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
 784         .getVendorLicenseModelId(), licenseKeyGroup.getId());
 785   }
 786
 787   @Override
 788   public LimitEntity createLimit(LimitEntity limit, String user) {
 789     mdcDataDebugMessage
 790         .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 791             .getEpLkgId());
 792     mdcDataDebugMessage
 793         .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 794             .getEpLkgId());
 795     validateLimit(limit, user);
 796     return vendorLicenseFacade.createLimit(limit, user);
 797   }
 798
 799   private void validateLimit(LimitEntity limit, String user) {
 800     Version version = VersioningUtil.resolveVersion(limit.getVersion(),
 801         getVersionInfo(limit.getVendorLicenseModelId(), VersionableEntityAction.Write,
 802             user), user);
 803     Collection<LimitEntity> limitList = listLimits(limit.getVendorLicenseModelId(),version
 804         ,limit.getEpLkgId(), user);
 805
 806     if (!isLimitNameUnique(limitList,limit.getName(), limit.getType(), limit.getId())) {
 807       final ErrorCode duplicateLimitNameErrorBuilder =
 808            LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
 809       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 810           LoggerServiceName.Create_LIMIT.toString(), ErrorLevel.ERROR.name(),
 811           LoggerErrorCode.DATA_ERROR.getErrorCode(),
 812           duplicateLimitNameErrorBuilder.message());
 813       throw new CoreException(duplicateLimitNameErrorBuilder);
 814     }
 815   }
 816
 817   private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType
 818       type, String id) {
 819     for (LimitEntity limit : limitList) {
 820       if(limit.getName().equalsIgnoreCase(name) &&
 821           limit.getType().name().equalsIgnoreCase(type.name())) {
 822         if(id != null && limit.getId().equals(id)){
 823           continue;
 824         }
 825         return false;
 826       }
 827     }
 828     return true;
 829   }
 830
 831   @Override
 832   public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId,
 833                                             String user) {
 834     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
 835     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
 836     return vendorLicenseFacade.listLimits(vlmId, version, epLkgId, user);
 837   }
 838
 839   @Override
 840   public void deleteLimit(LimitEntity limitEntity, String user) {
 841     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id, Limit Id", limitEntity
 842             .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
 843
 844     Version version = VersioningUtil.resolveVersion(limitEntity.getVersion(),
 845             getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Write,
 846                     user), user);
 847     limitEntity.setVersion(version);
 848
 849     if(!isLimitPresent(limitEntity)){
 850       VersioningUtil
 851           .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 852     }
 853     LimitEntity retrieved = limitDao.get(limitEntity);
 854     VersioningUtil
 855             .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 856
 857     limitDao.delete(limitEntity);
 858
 859     vendorLicenseFacade.updateVlmLastModificationTime(limitEntity.getVendorLicenseModelId(),
 860             limitEntity.getVersion());
 861
 862     mdcDataDebugMessage.debugExitMessage("VLM id, EP id, Limit Id", limitEntity
 863             .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
 864   }
 865
 866   @Override
 867   public void updateLimit(LimitEntity limit, String user) {
 868     mdcDataDebugMessage
 869         .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 870             .getEpLkgId());
 871     getLimit(limit,user);
 872     validateLimit(limit, user);
 873     vendorLicenseFacade.updateLimit(limit, user);
 874     mdcDataDebugMessage
 875         .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 876             .getEpLkgId());
 877   }
 878
 879   private boolean isLimitPresent(LimitEntity limit) {
 880     return limitDao.isLimitPresent(limit);
 881   }
 882
 883   @Override
 884   public LimitEntity getLimit(LimitEntity limitEntity,
 885                                                   String user) {
 886     mdcDataDebugMessage.debugEntryMessage("VLM id", limitEntity.getVendorLicenseModelId(),
 887         "EP/LKGId", limitEntity.getEpLkgId());
 888
 889     limitEntity.setVersion(VersioningUtil.resolveVersion(limitEntity.getVersion(),
 890         getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Read,
 891             user), user));
 892     if(!isLimitPresent(limitEntity)){
 893       VersioningUtil
 894           .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 895     }
 896     LimitEntity retrieved = limitDao.get(limitEntity);
 897     VersioningUtil
 898         .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 899
 900     mdcDataDebugMessage.debugExitMessage("VLM id", limitEntity.getVendorLicenseModelId(),
 901         "EP/LKGId", limitEntity.getEpLkgId());
 902     return retrieved;
 903   }
 904
 905   private void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 906                                                      LicenseAgreementEntity licenseAgreement) {
 907     if (featureGroupIds != null) {
 908       for (String featureGroupId : featureGroupIds) {
 909         featureGroupDao.addReferencingLicenseAgreement(
 910             new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 911                 licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 912       }
 913     }
 914   }
 915
 916   private void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 917                                                         LicenseAgreementEntity licenseAgreement) {
 918     if (featureGroupIds != null) {
 919       for (String featureGroupId : featureGroupIds) {
 920         featureGroupDao.removeReferencingLicenseAgreement(
 921             new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 922                 licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 923       }
 924     }
 925   }
 926
 927   private void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 928                                                      FeatureGroupEntity featureGroup) {
 929     if (licenseKeyGroupIds != null) {
 930       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 931         licenseKeyGroupDao.addReferencingFeatureGroup(
 932             new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 933                 featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 934       }
 935     }
 936   }
 937
 938   private void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 939                                                         FeatureGroupEntity featureGroup) {
 940     if (licenseKeyGroupIds != null) {
 941       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 942         licenseKeyGroupDao.removeReferencingFeatureGroup(
 943             new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 944                 featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 945       }
 946     }
 947   }
 948
 949   private void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
 950                                                      FeatureGroupEntity featureGroup) {
 951     if (entitlementPoolIds != null) {
 952       for (String entitlementPoolId : entitlementPoolIds) {
 953         entitlementPoolDao.addReferencingFeatureGroup(
 954             new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
 955                 featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
 956       }
 957     }
 958   }
 959
 960   private void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
 961                                                         FeatureGroupEntity featureGroup) {
 962     if (entitlementPoolIds != null) {
 963       for (String entitlementPoolId : entitlementPoolIds) {
 964         entitlementPoolDao.removeReferencingFeatureGroup(
 965             new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
 966                 featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
 967       }
 968     }
 969   }
 970
 971   private VersionInfo getVersionInfo(String vendorLicenseModelId, VersionableEntityAction action,
 972                                      String user) {
 973     return vendorLicenseFacade.getVersionInfo(vendorLicenseModelId, action, user);
 974   }
 975 }