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