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