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     LimitEntity createdLimit = vendorLicenseFacade.createLimit(limit, user);
 816     updateParentForLimit(limit,user);
 817     return createdLimit;
 818   }
 819
 820   private void validateLimit(LimitEntity limit, String user) {
 821     Version version = VersioningUtil.resolveVersion(limit.getVersion(),
 822             getVersionInfo(limit.getVendorLicenseModelId(), VersionableEntityAction.Write,
 823                     user), user);
 824     Collection<LimitEntity> limitList = listLimits(limit.getVendorLicenseModelId(),version
 825             ,limit.getEpLkgId(), user);
 826
 827     if (!isLimitNameUnique(limitList,limit.getName(), limit.getType(), limit.getId())) {
 828       final ErrorCode duplicateLimitNameErrorBuilder =
 829               LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
 830       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 831               LoggerServiceName.Create_LIMIT.toString(), ErrorLevel.ERROR.name(),
 832               LoggerErrorCode.DATA_ERROR.getErrorCode(),
 833               duplicateLimitNameErrorBuilder.message());
 834       throw new CoreException(duplicateLimitNameErrorBuilder);
 835     }
 836   }
 837
 838   private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType
 839           type, String id) {
 840     for (LimitEntity limit : limitList) {
 841       if(limit.getName().equalsIgnoreCase(name) &&
 842               limit.getType().name().equalsIgnoreCase(type.name())) {
 843         if(id != null && limit.getId().equals(id)){
 844           continue;
 845         }
 846         return false;
 847       }
 848     }
 849     return true;
 850   }
 851
 852   @Override
 853   public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId,
 854                                             String user) {
 855     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
 856     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
 857     return vendorLicenseFacade.listLimits(vlmId, version, epLkgId, user);
 858   }
 859
 860   @Override
 861   public void deleteLimit(LimitEntity limitEntity, String user) {
 862     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id, Limit Id", limitEntity
 863             .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
 864
 865     Version version = VersioningUtil.resolveVersion(limitEntity.getVersion(),
 866             getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Write,
 867                     user), user);
 868     limitEntity.setVersion(version);
 869
 870     if ( !isLimitPresent(limitEntity)) {
 871       VersioningUtil
 872               .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 873     }
 874     LimitEntity retrieved = limitDao.get(limitEntity);
 875     VersioningUtil
 876             .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 877
 878     limitDao.delete(limitEntity);
 879
 880     vendorLicenseFacade.updateVlmLastModificationTime(limitEntity.getVendorLicenseModelId(),
 881             limitEntity.getVersion());
 882
 883     updateParentForLimit(limitEntity,user);
 884
 885     mdcDataDebugMessage.debugExitMessage("VLM id, EP id, Limit Id", limitEntity
 886             .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
 887   }
 888
 889   @Override
 890   public void updateLimit(LimitEntity limit, String user) {
 891     mdcDataDebugMessage
 892             .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 893                     .getEpLkgId());
 894     getLimit(limit,user);
 895     validateLimit(limit, user);
 896     vendorLicenseFacade.updateLimit(limit, user);
 897     updateParentForLimit(limit,user);
 898     mdcDataDebugMessage
 899             .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
 900                     .getEpLkgId());
 901   }
 902
 903   private boolean isLimitPresent(LimitEntity limit) {
 904     return limitDao.isLimitPresent(limit);
 905   }
 906
 907   @Override
 908   public LimitEntity getLimit(LimitEntity limitEntity,
 909                               String user) {
 910     mdcDataDebugMessage.debugEntryMessage("VLM id", limitEntity.getVendorLicenseModelId(),
 911             "EP/LKGId", limitEntity.getEpLkgId());
 912
 913     limitEntity.setVersion(VersioningUtil.resolveVersion(limitEntity.getVersion(),
 914             getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Read,
 915                     user), user));
 916     if(!isLimitPresent(limitEntity)){
 917       VersioningUtil
 918               .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 919     }
 920     LimitEntity retrieved = limitDao.get(limitEntity);
 921     VersioningUtil
 922             .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 923
 924     mdcDataDebugMessage.debugExitMessage("VLM id", limitEntity.getVendorLicenseModelId(),
 925             "EP/LKGId", limitEntity.getEpLkgId());
 926     return retrieved;
 927   }
 928
 929   /**
 930    * update Parent of limit (EP/LKG) versionuuid when limit is modified so that limit updates are
 931    * captured in VLM XML
 932    * @param limit
 933    * @param user
 934    */
 935   private void updateParentForLimit(LimitEntity limit, String user) {
 936     mdcDataDebugMessage.debugEntryMessage("VLM id", limit.getVendorLicenseModelId(),
 937             "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
 938     if ("EntitlementPool".equals(limit.getParent()) ) {
 939       EntitlementPoolEntity entitlementPoolEntity =
 940               entitlementPoolDao.get(new EntitlementPoolEntity(limit.getVendorLicenseModelId(),
 941                       limit.getVersion(), limit.getEpLkgId()));
 942       vendorLicenseFacade.updateEntitlementPool(entitlementPoolEntity, user);
 943     }
 944
 945     if ("LicenseKeyGroup".equals(limit.getParent())) {
 946       LicenseKeyGroupEntity licenseKeyGroupEntity = licenseKeyGroupDao.get(
 947               new LicenseKeyGroupEntity(limit.getVendorLicenseModelId(), limit.getVersion(),
 948                       limit.getEpLkgId()));
 949       vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroupEntity, user);
 950     }
 951
 952     mdcDataDebugMessage.debugEntryMessage("VLM id", limit.getVendorLicenseModelId(),
 953             "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
 954   }
 955
 956   protected void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 957                                                        LicenseAgreementEntity licenseAgreement) {
 958     if (featureGroupIds != null) {
 959       for (String featureGroupId : featureGroupIds) {
 960         featureGroupDao.addReferencingLicenseAgreement(
 961                 new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 962                         licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 963       }
 964     }
 965   }
 966
 967   protected void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
 968                                                           LicenseAgreementEntity licenseAgreement) {
 969     if (featureGroupIds != null) {
 970       for (String featureGroupId : featureGroupIds) {
 971         featureGroupDao.removeReferencingLicenseAgreement(
 972                 new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
 973                         licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
 974       }
 975     }
 976   }
 977
 978   protected void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 979                                                        FeatureGroupEntity featureGroup) {
 980     if (licenseKeyGroupIds != null) {
 981       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 982         licenseKeyGroupDao.addReferencingFeatureGroup(
 983                 new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 984                         featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 985       }
 986     }
 987   }
 988
 989   protected void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
 990                                                           FeatureGroupEntity featureGroup) {
 991     if (licenseKeyGroupIds != null) {
 992       for (String licenseKeyGroupId : licenseKeyGroupIds) {
 993         licenseKeyGroupDao.removeReferencingFeatureGroup(
 994                 new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
 995                         featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
 996       }
 997     }
 998   }
 999
1000   protected void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
1001                                                        FeatureGroupEntity featureGroup) {
1002     if (entitlementPoolIds != null) {
1003       for (String entitlementPoolId : entitlementPoolIds) {
1004         entitlementPoolDao.addReferencingFeatureGroup(
1005                 new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
1006                         featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
1007       }
1008     }
1009   }
1010
1011   protected void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
1012                                                           FeatureGroupEntity featureGroup) {
1013     if (entitlementPoolIds != null) {
1014       for (String entitlementPoolId : entitlementPoolIds) {
1015         entitlementPoolDao.removeReferencingFeatureGroup(
1016                 new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
1017                         featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
1018       }
1019     }
1020   }
1021
1022   protected VersionInfo getVersionInfo(String vendorLicenseModelId, VersionableEntityAction action,
1023                                        String user) {
1024     return vendorLicenseFacade.getVersionInfo(vendorLicenseModelId, action, user);
1025   }
1026
1027   protected LicenseAgreementEntity createLicenseAgreementForList(String vlmId, Version version,
1028                                                                  String user) {
1029     return new LicenseAgreementEntity(vlmId, VersioningUtil
1030             .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
1031             null);
1032   }
1033
1034   protected void updateUniqueName(String uniqueValueType ,String oldName, String newName,String ...
1035           context) {
1036     UniqueValueUtil
1037             .updateUniqueValue(uniqueValueType, oldName, newName,context);
1038   }
1039
1040   protected void deleteUniqueName(String uniqueValueType,String ... uniqueCombination) {
1041     UniqueValueUtil.deleteUniqueValue(uniqueValueType, uniqueCombination);
1042   }
1043
1044   protected Version resloveVersion(String vlmId,Version requestedVersion, VersionInfo versionInfo,
1045                                    String user){
1046     return VersioningUtil.resolveVersion(null,
1047             getVersionInfo(vlmId, VersionableEntityAction.Write, user), user);
1048   }
1049
1050 }