summaryrefslogtreecommitdiffstats
path: root/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src
diff options
context:
space:
mode:
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-vendor-license-manager/src')
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java86
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManagerFactory.java14
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java48
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java35
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java1061
5 files changed, 556 insertions, 688 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
index 60288b53c3..c5c93ae00c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
@@ -7,9 +7,9 @@
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,82 +17,80 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.vendorlicense;
-import org.openecomp.sdc.vendorlicense.dao.types.*;
-import org.openecomp.sdc.versioning.dao.types.Version;
-
import java.util.Collection;
import java.util.Set;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
+import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
+import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
+import org.openecomp.sdc.versioning.dao.types.Version;
public interface VendorLicenseManager {
- void validate(String vendorLicenseModelId, Version version);
-
- VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity licenseModel);
-
- void updateVendorLicenseModel(VendorLicenseModelEntity licenseModel);
-
- VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version);
-
- void deleteVendorLicenseModel(String vlmId, Version version);
+ void validate(String vendorLicenseModelId, Version version);
+ VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity licenseModel);
- Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version);
+ void updateVendorLicenseModel(VendorLicenseModelEntity licenseModel);
- LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement);
+ VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version);
- void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
- Set<String> addedFeatureGroupIds, Set<String> removedFeatureGroupIds);
+ void deleteVendorLicenseModel(String vlmId, Version version);
- LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
- String licenseAgreementId);
+ Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version);
- void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId);
+ LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement);
+ void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement, Set<String> addedFeatureGroupIds, Set<String> removedFeatureGroupIds);
- Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version);
+ LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version, String licenseAgreementId);
- FeatureGroupEntity createFeatureGroup(FeatureGroupEntity fg);
+ void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId);
- void updateFeatureGroup(FeatureGroupEntity featureGroup,
- Set<String> addedLicenseKeyGroups, Set<String> removedLicenseKeyGroups,
- Set<String> addedEntitlementPools, Set<String> removedEntitlementPools);
+ Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version);
- FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup);
+ FeatureGroupEntity createFeatureGroup(FeatureGroupEntity fg);
- void deleteFeatureGroup(FeatureGroupEntity featureGroup);
+ void updateFeatureGroup(FeatureGroupEntity featureGroup, Set<String> addedLicenseKeyGroups, Set<String> removedLicenseKeyGroups,
+ Set<String> addedEntitlementPools, Set<String> removedEntitlementPools);
+ FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup);
- Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version);
+ void deleteFeatureGroup(FeatureGroupEntity featureGroup);
- EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool);
+ Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version);
- void updateEntitlementPool(EntitlementPoolEntity entitlementPool);
+ EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool);
- EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool);
+ void updateEntitlementPool(EntitlementPoolEntity entitlementPool);
- void deleteEntitlementPool(EntitlementPoolEntity entitlementPool);
+ EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool);
+ void deleteEntitlementPool(EntitlementPoolEntity entitlementPool);
- Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version);
+ Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version);
- LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
+ LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
- void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
+ void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
- LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
+ LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
- void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
+ void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
- LimitEntity createLimit(LimitEntity limitEntity);
+ LimitEntity createLimit(LimitEntity limitEntity);
- Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId);
+ Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId);
- void deleteLimit(LimitEntity limitEntity);
+ void deleteLimit(LimitEntity limitEntity);
- void updateLimit(LimitEntity limitEntity);
+ void updateLimit(LimitEntity limitEntity);
- LimitEntity getLimit(LimitEntity entitlementPool);
+ LimitEntity getLimit(LimitEntity entitlementPool);
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManagerFactory.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManagerFactory.java
index 68ea919d22..fa05c03b5e 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManagerFactory.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManagerFactory.java
@@ -7,9 +7,9 @@
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,7 +17,6 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.vendorlicense;
import org.openecomp.core.factory.api.AbstractComponentFactory;
@@ -26,10 +25,9 @@ import org.openecomp.core.factory.api.AbstractFactory;
/**
* Created by ayalaben on 8/3/2017
*/
-public abstract class VendorLicenseManagerFactory extends
- AbstractComponentFactory<VendorLicenseManager> {
+public abstract class VendorLicenseManagerFactory extends AbstractComponentFactory<VendorLicenseManager> {
- public static VendorLicenseManagerFactory getInstance() {
- return AbstractFactory.getInstance(VendorLicenseManagerFactory.class);
- }
+ public static VendorLicenseManagerFactory getInstance() {
+ return AbstractFactory.getInstance(VendorLicenseManagerFactory.class);
+ }
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java
index b2a155dc21..3c0463596a 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java
@@ -13,38 +13,32 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
package org.openecomp.sdc.vendorlicense.errors;
-
import org.openecomp.sdc.common.errors.ErrorCategory;
import org.openecomp.sdc.common.errors.ErrorCode;
public class LimitErrorBuilder {
- private static final String LIMIT_INVALID_ATTR_VALUE_MSG = "The %s value doesn't meet the "
- + "expected attribute value.";
-
- private static final String DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG =
- "Invalid request, Limit with name %s already exists for type %s.";
-
- private LimitErrorBuilder(){
-
- }
-
- public static ErrorCode getInvalidValueErrorBuilder(String attribute, String errorCode) {
- ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
- builder.withId(errorCode);
- builder.withCategory(ErrorCategory.APPLICATION);
- builder.withMessage(String.format(LIMIT_INVALID_ATTR_VALUE_MSG, attribute));
- return builder.build();
- }
-
- public static ErrorCode getDuplicateNameErrorbuilder(String name, String type) {
- ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
- builder.withId(VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED);
- builder.withCategory(ErrorCategory.APPLICATION);
- builder.withMessage(String.format (DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG, name, type ));
- return builder.build();
- }
+ private static final String LIMIT_INVALID_ATTR_VALUE_MSG = "The %s value doesn't meet the " + "expected attribute value.";
+ private static final String DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG = "Invalid request, Limit with name %s already exists for type %s.";
+
+ private LimitErrorBuilder() {
+ }
+
+ public static ErrorCode getInvalidValueErrorBuilder(String attribute, String errorCode) {
+ ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+ builder.withId(errorCode);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(String.format(LIMIT_INVALID_ATTR_VALUE_MSG, attribute));
+ return builder.build();
+ }
+
+ public static ErrorCode getDuplicateNameErrorbuilder(String name, String type) {
+ ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+ builder.withId(VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(String.format(DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG, name, type));
+ return builder.build();
+ }
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
index ac7eb115b1..16a789bd8d 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
@@ -7,9 +7,9 @@
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,33 +17,32 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.vendorlicense.impl;
import org.openecomp.core.dao.UniqueValueDaoFactory;
import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
import org.openecomp.sdc.vendorlicense.VendorLicenseManagerFactory;
-import org.openecomp.sdc.vendorlicense.dao.*;
+import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.LimitDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
/**
* Created by ayalaben on 8/3/2017
*/
public class VendorLicenseManagerFactoryImpl extends VendorLicenseManagerFactory {
- private static final VendorLicenseManager INSTANCE =
- new VendorLicenseManagerImpl(
- VendorLicenseFacadeFactory.getInstance().createInterface(),
- VendorLicenseModelDaoFactory.getInstance().createInterface(),
- LicenseAgreementDaoFactory.getInstance().createInterface(),
- FeatureGroupDaoFactory.getInstance().createInterface(),
- EntitlementPoolDaoFactory.getInstance().createInterface(),
- LicenseKeyGroupDaoFactory.getInstance().createInterface(),
- LimitDaoFactory.getInstance().createInterface(),
- UniqueValueDaoFactory.getInstance().createInterface());
- @Override
- public VendorLicenseManager createInterface() {
- return INSTANCE;
- }
+ private static final VendorLicenseManager INSTANCE = new VendorLicenseManagerImpl(VendorLicenseFacadeFactory.getInstance().createInterface(),
+ VendorLicenseModelDaoFactory.getInstance().createInterface(), LicenseAgreementDaoFactory.getInstance().createInterface(),
+ FeatureGroupDaoFactory.getInstance().createInterface(), EntitlementPoolDaoFactory.getInstance().createInterface(),
+ LicenseKeyGroupDaoFactory.getInstance().createInterface(), LimitDaoFactory.getInstance().createInterface(),
+ UniqueValueDaoFactory.getInstance().createInterface());
+ @Override
+ public VendorLicenseManager createInterface() {
+ return INSTANCE;
+ }
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
index 6939eeed32..0fb5f58507 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
@@ -13,9 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
package org.openecomp.sdc.vendorlicense.impl;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.openecomp.core.dao.UniqueValueDao;
import org.openecomp.core.util.UniqueValueUtil;
@@ -45,596 +49,471 @@ import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
import org.openecomp.sdc.versioning.VersioningUtil;
import org.openecomp.sdc.versioning.dao.types.Version;
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.Collection;
-import java.util.Optional;
-import java.util.Set;
-
public class VendorLicenseManagerImpl implements VendorLicenseManager {
- private UniqueValueUtil uniqueValueUtil;
- private VendorLicenseFacade vendorLicenseFacade;
- private VendorLicenseModelDao vendorLicenseModelDao;
- private LicenseAgreementDao licenseAgreementDao;
- private FeatureGroupDao featureGroupDao;
- private EntitlementPoolDao entitlementPoolDao;
- private LicenseKeyGroupDao licenseKeyGroupDao;
- private LimitDao limitDao;
-
- private static final String EP_POOL_START_TIME = "T00:00:00Z";
- private static final String EP_POOL_EXPIRY_TIME = "T23:59:59Z";
- private static final DateTimeFormatter FORMATTER
- = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
- public VendorLicenseManagerImpl(VendorLicenseFacade vendorLicenseFacade,
- VendorLicenseModelDao vendorLicenseModelDao,
- LicenseAgreementDao licenseAgreementDao,
- FeatureGroupDao featureGroupDao,
- EntitlementPoolDao entitlementPoolDao,
- LicenseKeyGroupDao licenseKeyGroupDao,
- LimitDao limitDao,
- UniqueValueDao uniqueValueDao) {
- this.vendorLicenseFacade = vendorLicenseFacade;
- this.vendorLicenseModelDao = vendorLicenseModelDao;
- this.licenseAgreementDao = licenseAgreementDao;
- this.featureGroupDao = featureGroupDao;
- this.entitlementPoolDao = entitlementPoolDao;
- this.licenseKeyGroupDao = licenseKeyGroupDao;
- this.limitDao = limitDao;
- this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
- }
-
-
- @Override
- public void validate(String vendorLicenseModelId, Version version) {
- vendorLicenseFacade.validate(vendorLicenseModelId, version);
- }
-
- @Override
- public VendorLicenseModelEntity createVendorLicenseModel(
- VendorLicenseModelEntity vendorLicenseModelEntity) {
- vendorLicenseModelDao.create(vendorLicenseModelEntity);
- return vendorLicenseModelEntity;
- }
-
- @Override
- public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity) {
- VendorLicenseModelEntity retrieved = vendorLicenseModelDao.get(vendorLicenseModelEntity);
- if (retrieved == null){
- throw new CoreException((new ErrorCode.ErrorCodeBuilder()
- .withMessage(String.format("Vlm with id %s and version %s does not exist.",
- vendorLicenseModelEntity.getId(), vendorLicenseModelEntity.getVersion().getId()))).build());
- }
-
- String existingVendorName = retrieved.getVendorName();
-
- updateUniqueName(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName,
- vendorLicenseModelEntity.getVendorName());
- vendorLicenseModelDao.update(vendorLicenseModelEntity);
- }
-
- @Override
- public VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version) {
- return vendorLicenseFacade.getVendorLicenseModel(vlmId, version);
- }
-
- @Override
- public void deleteVendorLicenseModel(String vlmId, Version version) {
- throw new UnsupportedOperationException(VendorLicenseConstants.UNSUPPORTED_OPERATION_ERROR);
- }
-
- @Override
- public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version) {
- return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, version, null));
- }
-
- @Override
- public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement) {
- return vendorLicenseFacade.createLicenseAgreement(licenseAgreement);
- }
-
- @Override
- public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
- Set<String> addedFeatureGroupIds,
- Set<String> removedFeatureGroupIds) {
- LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement);
- VersioningUtil
- .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
- VersioningUtil.validateContainedEntitiesExistence(new FeatureGroupEntity().getEntityType(),
- removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds());
- VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds,
- new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
- licenseAgreement.getVersion(),
- null),
- featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
-
- updateUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
- retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(),
- licenseAgreement.getVersion().getId());
- licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds,
- removedFeatureGroupIds);
-
- addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement);
- removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement);
- }
-
- @Override
- public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
- String licenseAgreementId) {
- return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId);
- }
-
- @Override
- public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId) {
- LicenseAgreementEntity input =
- new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
- LicenseAgreementEntity retrieved = licenseAgreementDao.get(input);
- VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE);
-
- removeFeatureGroupsToLicenseAgreementRef(retrieved.getFeatureGroupIds(), retrieved);
-
- licenseAgreementDao.delete(retrieved);
-
- deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
- retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
- retrieved.getName());
- }
-
- @Override
- public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version) {
- return vendorLicenseFacade.listFeatureGroups(vlmId, version);
- }
-
- @Override
- public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup) {
- return vendorLicenseFacade.createFeatureGroup(featureGroup);
- }
-
- @Override
- public void updateFeatureGroup(FeatureGroupEntity featureGroup,
- Set<String> addedLicenseKeyGroups,
- Set<String> removedLicenseKeyGroups,
- Set<String> addedEntitlementPools,
- Set<String> removedEntitlementPools) {
- FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
- VersioningUtil
- .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
-
- VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(),
- removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds());
- VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(),
- removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds());
-
- VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups,
- new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(),
- null),
- licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
- VersioningUtil.validateEntitiesExistence(addedEntitlementPools,
- new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(),
- null),
- entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE);
-
- updateUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
- retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion().getId());
-
- addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup);
- removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup);
- addEntitlementPoolsToFeatureGroupsRef(addedEntitlementPools, featureGroup);
- removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup);
-
- featureGroupDao.updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools,
- addedLicenseKeyGroups, removedLicenseKeyGroups);
-
- }
-
- @Override
- public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup) {
- return vendorLicenseFacade.getFeatureGroupModel(featureGroup);
- }
-
- @Override
- public void deleteFeatureGroup(FeatureGroupEntity featureGroup) {
- FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
- VersioningUtil
- .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
-
- removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup);
- removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup);
-
- for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) {
- licenseAgreementDao.removeFeatureGroup(
- new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion(),
- licenceAgreementId), featureGroup.getId());
- }
-
- featureGroupDao.delete(featureGroup);
-
- deleteUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
- retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
- retrieved.getName());
- }
-
- @Override
- public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version) {
- return vendorLicenseFacade.listEntitlementPools(vlmId, version);
- }
-
- @Override
- public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool) {
- entitlementPool.setStartDate(getDate(entitlementPool.getStartDate(), EP_POOL_START_TIME));
- entitlementPool.setExpiryDate(getDate(entitlementPool.getExpiryDate(), EP_POOL_EXPIRY_TIME));
- validateCreateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
- entitlementPool.getVendorLicenseModelId());
- return vendorLicenseFacade.createEntitlementPool(entitlementPool);
- }
-
- private String getDate(String date, String poolTime){
- return date != null ? (!date.trim().isEmpty() ? date + poolTime: null) : null;
- }
-
- private void validateCreateDate(String startDate, String expiryDate,
- String vendorLicenseModelId) {
- //original logic allows both nulls
- if(StringUtils.isEmpty(startDate) && StringUtils.isEmpty(expiryDate)){
- return;
- }
-
- Optional<LocalDate> parsedStartDate = parseLocalDate(startDate);
- Optional<LocalDate> parsedExpiryDate = parseLocalDate(expiryDate);
- if (!parsedStartDate.isPresent()) {
- throw new CoreException(
- new InvalidDateErrorBuilder(vendorLicenseModelId)
- .build());
- }
-
- if (!parsedExpiryDate.isPresent()
- && parsedStartDate.get().atStartOfDay().isBefore
- (LocalDate.now().atStartOfDay())) {
- throw new CoreException(
- new InvalidDateErrorBuilder(vendorLicenseModelId)
- .build());
- }
-
- if(parsedExpiryDate.isPresent() && isNotValidatStartAndExpiryDate(parsedStartDate.get(), parsedExpiryDate.get())){
- throw new CoreException(
- new InvalidDateErrorBuilder(vendorLicenseModelId)
- .build());
- }
- }
-
- private boolean isNotValidatStartAndExpiryDate(LocalDate parsedStartDate,
- LocalDate parsedExpiryDate) {
- return parsedStartDate.atStartOfDay().isBefore(LocalDate.now().atStartOfDay())
- || parsedExpiryDate.atStartOfDay().isEqual(parsedStartDate.atStartOfDay())
- || parsedExpiryDate.isBefore(parsedStartDate);
- }
-
- private static Optional<LocalDate> parseLocalDate(String date) {
- if (StringUtils.isEmpty(date)) {
- return Optional.empty();
- }
-
- return Optional.of(LocalDate.parse(date, FORMATTER ));
- }
-
- private void validateUpdateDate(String startDate, String expiryDate,
- String vendorLicenseModelId) {
- Optional<LocalDate> parsedStartDate = parseLocalDate(startDate);
- Optional<LocalDate> parsedExpiryDate = parseLocalDate(expiryDate);
-
- if (parsedStartDate.isPresent() && parsedExpiryDate.isPresent()
- && (parsedExpiryDate.get().atStartOfDay()
- .isEqual(parsedStartDate.get().atStartOfDay())
- || parsedExpiryDate.get().isBefore(parsedStartDate.get() ))) {
- throw new CoreException(
- new InvalidDateErrorBuilder(vendorLicenseModelId)
- .build());
- }
-
- if (startDate == null && expiryDate != null) {
- throw new CoreException(
- new InvalidDateErrorBuilder(vendorLicenseModelId)
- .build());
- }
- }
-
- @Override
- public void updateEntitlementPool(EntitlementPoolEntity entitlementPool) {
- entitlementPool.setStartDate(getDate(entitlementPool.getStartDate(), EP_POOL_START_TIME));
- entitlementPool.setExpiryDate(getDate(entitlementPool.getExpiryDate(), EP_POOL_EXPIRY_TIME));
- validateUpdateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
- entitlementPool.getVendorLicenseModelId());
- vendorLicenseFacade.updateEntitlementPool(entitlementPool);
- }
-
- @Override
- public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool) {
- EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
- VersioningUtil
- .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
- DateTimeFormatter targetFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
- if (retrieved.getStartDate() != null) {
- retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(), FORMATTER ).format
- (targetFormatter));
- }
-
- if (retrieved.getExpiryDate() != null) {
- retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(), FORMATTER ).format
- (targetFormatter));
- }
- return retrieved;
- }
-
- @Override
- public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool) {
- EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
- VersioningUtil
- .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
-
- for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
- featureGroupDao.removeEntitlementPool(
- new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(),
- entitlementPool.getVersion(),
- referencingFeatureGroupId), entitlementPool.getId());
- }
-
- deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(),
- entitlementPool.getId());
-
- entitlementPoolDao.delete(entitlementPool);
-
- deleteUniqueName(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME,
- retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
- retrieved.getName());
- }
-
- protected void deleteChildLimits(String vlmId, Version version, String epLkgId) {
- Optional<Collection<LimitEntity>> limitEntities = Optional.ofNullable(
- listLimits(vlmId, version, epLkgId));
- limitEntities.ifPresent(entities -> entities.forEach(this::deleteLimit));
- }
-
- @Override
- public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version) {
- return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version);
- }
-
- @Override
- public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
- licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
- .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate() + EP_POOL_START_TIME
- : null) : null);
- licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
- .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate() + EP_POOL_EXPIRY_TIME
- : null) : null);
-
- validateCreateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
- licenseKeyGroup.getVendorLicenseModelId());
- return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup);
- }
-
- @Override
- public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
- licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
- .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate() + EP_POOL_START_TIME
- : null) : null);
- licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
- .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate() + EP_POOL_EXPIRY_TIME
- : null) : null);
-
- validateUpdateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
- licenseKeyGroup.getVendorLicenseModelId());
- vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup);
- }
-
- @Override
- public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
- LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
- VersioningUtil
- .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
- return retrieved;
- }
-
- @Override
- public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
- LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
- VersioningUtil
- .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
-
- for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
- featureGroupDao.removeLicenseKeyGroup(
- new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(),
- licenseKeyGroup.getVersion(),
- referencingFeatureGroupId), licenseKeyGroup.getId());
- }
-
- deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(),
- licenseKeyGroup.getId());
-
- licenseKeyGroupDao.delete(licenseKeyGroup);
-
- deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME,
- retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
- retrieved.getName());
- }
-
- @Override
- public LimitEntity createLimit(LimitEntity limit) {
- validateLimit(limit);
- LimitEntity createdLimit = vendorLicenseFacade.createLimit(limit);
- updateParentForLimit(limit);
- return createdLimit;
- }
-
- private void validateLimit(LimitEntity limit) {
- Collection<LimitEntity> limitList =
- listLimits(limit.getVendorLicenseModelId(), limit.getVersion()
- , limit.getEpLkgId());
-
- if (!isLimitNameUnique(limitList, limit.getName(), limit.getType(), limit.getId())) {
- final ErrorCode duplicateLimitNameErrorBuilder =
- LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
- throw new CoreException(duplicateLimitNameErrorBuilder);
- }
- }
-
- private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType
- type, String id) {
- for (LimitEntity limit : limitList) {
- if (limit.getName().equalsIgnoreCase(name) &&
- limit.getType().name().equalsIgnoreCase(type.name())) {
- if (id != null && limit.getId().equals(id)) {
- continue;
+
+ private static final String EP_POOL_START_TIME = "T00:00:00Z";
+ private static final String EP_POOL_EXPIRY_TIME = "T23:59:59Z";
+ private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
+ private UniqueValueUtil uniqueValueUtil;
+ private VendorLicenseFacade vendorLicenseFacade;
+ private VendorLicenseModelDao vendorLicenseModelDao;
+ private LicenseAgreementDao licenseAgreementDao;
+ private FeatureGroupDao featureGroupDao;
+ private EntitlementPoolDao entitlementPoolDao;
+ private LicenseKeyGroupDao licenseKeyGroupDao;
+ private LimitDao limitDao;
+
+ public VendorLicenseManagerImpl(VendorLicenseFacade vendorLicenseFacade, VendorLicenseModelDao vendorLicenseModelDao,
+ LicenseAgreementDao licenseAgreementDao, FeatureGroupDao featureGroupDao, EntitlementPoolDao entitlementPoolDao,
+ LicenseKeyGroupDao licenseKeyGroupDao, LimitDao limitDao, UniqueValueDao uniqueValueDao) {
+ this.vendorLicenseFacade = vendorLicenseFacade;
+ this.vendorLicenseModelDao = vendorLicenseModelDao;
+ this.licenseAgreementDao = licenseAgreementDao;
+ this.featureGroupDao = featureGroupDao;
+ this.entitlementPoolDao = entitlementPoolDao;
+ this.licenseKeyGroupDao = licenseKeyGroupDao;
+ this.limitDao = limitDao;
+ this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
+ }
+
+ private static Optional<LocalDate> parseLocalDate(String date) {
+ if (StringUtils.isEmpty(date)) {
+ return Optional.empty();
+ }
+ return Optional.of(LocalDate.parse(date, FORMATTER));
+ }
+
+ @Override
+ public void validate(String vendorLicenseModelId, Version version) {
+ vendorLicenseFacade.validate(vendorLicenseModelId, version);
+ }
+
+ @Override
+ public VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity) {
+ vendorLicenseModelDao.create(vendorLicenseModelEntity);
+ return vendorLicenseModelEntity;
+ }
+
+ @Override
+ public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity) {
+ VendorLicenseModelEntity retrieved = vendorLicenseModelDao.get(vendorLicenseModelEntity);
+ if (retrieved == null) {
+ throw new CoreException((new ErrorCode.ErrorCodeBuilder().withMessage(String
+ .format("Vlm with id %s and version %s does not exist.", vendorLicenseModelEntity.getId(),
+ vendorLicenseModelEntity.getVersion().getId()))).build());
+ }
+ String existingVendorName = retrieved.getVendorName();
+ updateUniqueName(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName, vendorLicenseModelEntity.getVendorName());
+ vendorLicenseModelDao.update(vendorLicenseModelEntity);
+ }
+
+ @Override
+ public VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version) {
+ return vendorLicenseFacade.getVendorLicenseModel(vlmId, version);
+ }
+
+ @Override
+ public void deleteVendorLicenseModel(String vlmId, Version version) {
+ throw new UnsupportedOperationException(VendorLicenseConstants.UNSUPPORTED_OPERATION_ERROR);
+ }
+
+ @Override
+ public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version) {
+ return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, version, null));
+ }
+
+ @Override
+ public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement) {
+ return vendorLicenseFacade.createLicenseAgreement(licenseAgreement);
+ }
+
+ @Override
+ public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement, Set<String> addedFeatureGroupIds,
+ Set<String> removedFeatureGroupIds) {
+ LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement);
+ VersioningUtil.validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
+ VersioningUtil.validateContainedEntitiesExistence(new FeatureGroupEntity().getEntityType(), removedFeatureGroupIds, retrieved,
+ retrieved.getFeatureGroupIds());
+ VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds,
+ new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), licenseAgreement.getVersion(), null), featureGroupDao,
+ VendorLicenseModelEntity.ENTITY_TYPE);
+ updateUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME, retrieved.getName(), licenseAgreement.getName(),
+ licenseAgreement.getVendorLicenseModelId(), licenseAgreement.getVersion().getId());
+ licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds, removedFeatureGroupIds);
+ addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement);
+ removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement);
+ }
+
+ @Override
+ public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version, String licenseAgreementId) {
+ return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId);
+ }
+
+ @Override
+ public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId) {
+ LicenseAgreementEntity input = new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
+ LicenseAgreementEntity retrieved = licenseAgreementDao.get(input);
+ VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE);
+ removeFeatureGroupsToLicenseAgreementRef(retrieved.getFeatureGroupIds(), retrieved);
+ licenseAgreementDao.delete(retrieved);
+ deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME, retrieved.getVendorLicenseModelId(),
+ retrieved.getVersion().toString(), retrieved.getName());
+ }
+
+ @Override
+ public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version) {
+ return vendorLicenseFacade.listFeatureGroups(vlmId, version);
+ }
+
+ @Override
+ public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup) {
+ return vendorLicenseFacade.createFeatureGroup(featureGroup);
+ }
+
+ @Override
+ public void updateFeatureGroup(FeatureGroupEntity featureGroup, Set<String> addedLicenseKeyGroups, Set<String> removedLicenseKeyGroups,
+ Set<String> addedEntitlementPools, Set<String> removedEntitlementPools) {
+ FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
+ VersioningUtil.validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+ VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(), removedLicenseKeyGroups, retrieved,
+ retrieved.getLicenseKeyGroupIds());
+ VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(), removedEntitlementPools, retrieved,
+ retrieved.getEntitlementPoolIds());
+ VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups,
+ new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), null), licenseKeyGroupDao,
+ VendorLicenseModelEntity.ENTITY_TYPE);
+ VersioningUtil.validateEntitiesExistence(addedEntitlementPools,
+ new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), null), entitlementPoolDao,
+ VendorLicenseModelEntity.ENTITY_TYPE);
+ updateUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME, retrieved.getName(), featureGroup.getName(),
+ featureGroup.getVendorLicenseModelId(), featureGroup.getVersion().getId());
+ addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup);
+ removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup);
+ addEntitlementPoolsToFeatureGroupsRef(addedEntitlementPools, featureGroup);
+ removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup);
+ featureGroupDao
+ .updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools, addedLicenseKeyGroups, removedLicenseKeyGroups);
+ }
+
+ @Override
+ public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup) {
+ return vendorLicenseFacade.getFeatureGroupModel(featureGroup);
+ }
+
+ @Override
+ public void deleteFeatureGroup(FeatureGroupEntity featureGroup) {
+ FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
+ VersioningUtil.validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+ removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup);
+ removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup);
+ for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) {
+ licenseAgreementDao
+ .removeFeatureGroup(new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), licenceAgreementId),
+ featureGroup.getId());
+ }
+ featureGroupDao.delete(featureGroup);
+ deleteUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME, retrieved.getVendorLicenseModelId(),
+ retrieved.getVersion().toString(), retrieved.getName());
+ }
+
+ @Override
+ public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version) {
+ return vendorLicenseFacade.listEntitlementPools(vlmId, version);
+ }
+
+ @Override
+ public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool) {
+ entitlementPool.setStartDate(getDate(entitlementPool.getStartDate(), EP_POOL_START_TIME));
+ entitlementPool.setExpiryDate(getDate(entitlementPool.getExpiryDate(), EP_POOL_EXPIRY_TIME));
+ validateCreateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(), entitlementPool.getVendorLicenseModelId());
+ return vendorLicenseFacade.createEntitlementPool(entitlementPool);
+ }
+
+ private String getDate(String date, String poolTime) {
+ return date != null ? (!date.trim().isEmpty() ? date + poolTime : null) : null;
+ }
+
+ private void validateCreateDate(String startDate, String expiryDate, String vendorLicenseModelId) {
+ //original logic allows both nulls
+ if (StringUtils.isEmpty(startDate) && StringUtils.isEmpty(expiryDate)) {
+ return;
}
- return false;
- }
- }
- return true;
- }
-
- @Override
- public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId) {
- return vendorLicenseFacade.listLimits(vlmId, version, epLkgId);
- }
-
- @Override
- public void deleteLimit(LimitEntity limitEntity) {
- if (!isLimitPresent(limitEntity)) {
- VersioningUtil
- .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
- }
- LimitEntity retrieved = limitDao.get(limitEntity);
- VersioningUtil
- .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
-
- limitDao.delete(limitEntity);
-
- updateParentForLimit(limitEntity);
- }
-
- @Override
- public void updateLimit(LimitEntity limit) {
- getLimit(limit);
- validateLimit(limit);
- LimitEntity retrieved = limitDao.get(limit);
- if(!retrieved.equals(limit)){
- vendorLicenseFacade.updateLimit(limit);
- updateParentForLimit(limit);
- }
- }
-
- private boolean isLimitPresent(LimitEntity limit) {
- return limitDao.isLimitPresent(limit);
- }
-
- @Override
- public LimitEntity getLimit(LimitEntity limitEntity) {
- if (!isLimitPresent(limitEntity)) {
- VersioningUtil
- .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
- }
- LimitEntity retrieved = limitDao.get(limitEntity);
- VersioningUtil
- .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
- return retrieved;
- }
-
- /**
- * update Parent of limit (EP/LKG) versionuuid when limit is modified so that limit updates are
- * captured in VLM XML
- */
- private void updateParentForLimit(LimitEntity limit) {
- if ("EntitlementPool".equals(limit.getParent())) {
- EntitlementPoolEntity entitlementPoolEntity =
- entitlementPoolDao.get(new EntitlementPoolEntity(limit.getVendorLicenseModelId(),
- limit.getVersion(), limit.getEpLkgId()));
- entitlementPoolEntity.setVersionUuId(CommonMethods.nextUuId());
- entitlementPoolDao.update(entitlementPoolEntity);
- }
-
- if ("LicenseKeyGroup".equals(limit.getParent())) {
- LicenseKeyGroupEntity licenseKeyGroupEntity = licenseKeyGroupDao.get(
- new LicenseKeyGroupEntity(limit.getVendorLicenseModelId(), limit.getVersion(),
- limit.getEpLkgId()));
- licenseKeyGroupEntity.setVersionUuId(CommonMethods.nextUuId());
- licenseKeyGroupDao.update(licenseKeyGroupEntity);
- }
- }
-
- protected void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
- LicenseAgreementEntity licenseAgreement) {
- if (featureGroupIds != null) {
- for (String featureGroupId : featureGroupIds) {
- featureGroupDao.addReferencingLicenseAgreement(
- new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
- licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
- }
- }
- }
-
- protected void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
- LicenseAgreementEntity licenseAgreement) {
- if (featureGroupIds != null) {
- for (String featureGroupId : featureGroupIds) {
- featureGroupDao.removeReferencingLicenseAgreement(
- new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
- licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
- }
- }
- }
-
- protected void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
- FeatureGroupEntity featureGroup) {
- if (licenseKeyGroupIds != null) {
- for (String licenseKeyGroupId : licenseKeyGroupIds) {
- licenseKeyGroupDao.addReferencingFeatureGroup(
- new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
- }
- }
- }
-
- protected void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds,
- FeatureGroupEntity featureGroup) {
- if (licenseKeyGroupIds != null) {
- for (String licenseKeyGroupId : licenseKeyGroupIds) {
- licenseKeyGroupDao.removeReferencingFeatureGroup(
- new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
- }
- }
- }
-
- protected void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
- FeatureGroupEntity featureGroup) {
- if (entitlementPoolIds != null) {
- for (String entitlementPoolId : entitlementPoolIds) {
- entitlementPoolDao.addReferencingFeatureGroup(
- new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
- }
- }
- }
-
- protected void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds,
- FeatureGroupEntity featureGroup) {
- if (entitlementPoolIds != null) {
- for (String entitlementPoolId : entitlementPoolIds) {
- entitlementPoolDao.removeReferencingFeatureGroup(
- new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
- featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
- }
- }
- }
-
- protected void updateUniqueName(String uniqueValueType, String oldName, String newName, String...
- context) {
- uniqueValueUtil
- .updateUniqueValue(uniqueValueType, oldName, newName, context);
- }
-
- protected void deleteUniqueName(String uniqueValueType, String... uniqueCombination) {
- uniqueValueUtil.deleteUniqueValue(uniqueValueType, uniqueCombination);
- }
+ Optional<LocalDate> parsedStartDate = parseLocalDate(startDate);
+ Optional<LocalDate> parsedExpiryDate = parseLocalDate(expiryDate);
+ if (!parsedStartDate.isPresent()) {
+ throw new CoreException(new InvalidDateErrorBuilder(vendorLicenseModelId).build());
+ }
+ if (!parsedExpiryDate.isPresent() && parsedStartDate.get().atStartOfDay().isBefore(LocalDate.now().atStartOfDay())) {
+ throw new CoreException(new InvalidDateErrorBuilder(vendorLicenseModelId).build());
+ }
+ if (parsedExpiryDate.isPresent() && isNotValidatStartAndExpiryDate(parsedStartDate.get(), parsedExpiryDate.get())) {
+ throw new CoreException(new InvalidDateErrorBuilder(vendorLicenseModelId).build());
+ }
+ }
+
+ private boolean isNotValidatStartAndExpiryDate(LocalDate parsedStartDate, LocalDate parsedExpiryDate) {
+ return parsedStartDate.atStartOfDay().isBefore(LocalDate.now().atStartOfDay()) || parsedExpiryDate.atStartOfDay()
+ .isEqual(parsedStartDate.atStartOfDay()) || parsedExpiryDate.isBefore(parsedStartDate);
+ }
+
+ private void validateUpdateDate(String startDate, String expiryDate, String vendorLicenseModelId) {
+ Optional<LocalDate> parsedStartDate = parseLocalDate(startDate);
+ Optional<LocalDate> parsedExpiryDate = parseLocalDate(expiryDate);
+ if (parsedStartDate.isPresent() && parsedExpiryDate.isPresent() && (
+ parsedExpiryDate.get().atStartOfDay().isEqual(parsedStartDate.get().atStartOfDay()) || parsedExpiryDate.get()
+ .isBefore(parsedStartDate.get()))) {
+ throw new CoreException(new InvalidDateErrorBuilder(vendorLicenseModelId).build());
+ }
+ if (startDate == null && expiryDate != null) {
+ throw new CoreException(new InvalidDateErrorBuilder(vendorLicenseModelId).build());
+ }
+ }
+
+ @Override
+ public void updateEntitlementPool(EntitlementPoolEntity entitlementPool) {
+ entitlementPool.setStartDate(getDate(entitlementPool.getStartDate(), EP_POOL_START_TIME));
+ entitlementPool.setExpiryDate(getDate(entitlementPool.getExpiryDate(), EP_POOL_EXPIRY_TIME));
+ validateUpdateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(), entitlementPool.getVendorLicenseModelId());
+ vendorLicenseFacade.updateEntitlementPool(entitlementPool);
+ }
+
+ @Override
+ public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool) {
+ EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
+ VersioningUtil.validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
+ DateTimeFormatter targetFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ if (retrieved.getStartDate() != null) {
+ retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(), FORMATTER).format(targetFormatter));
+ }
+ if (retrieved.getExpiryDate() != null) {
+ retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(), FORMATTER).format(targetFormatter));
+ }
+ return retrieved;
+ }
+
+ @Override
+ public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool) {
+ EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
+ VersioningUtil.validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
+ for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
+ featureGroupDao.removeEntitlementPool(
+ new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(), referencingFeatureGroupId),
+ entitlementPool.getId());
+ }
+ deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(), entitlementPool.getId());
+ entitlementPoolDao.delete(entitlementPool);
+ deleteUniqueName(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME, retrieved.getVendorLicenseModelId(),
+ retrieved.getVersion().toString(), retrieved.getName());
+ }
+
+ protected void deleteChildLimits(String vlmId, Version version, String epLkgId) {
+ Optional<Collection<LimitEntity>> limitEntities = Optional.ofNullable(listLimits(vlmId, version, epLkgId));
+ limitEntities.ifPresent(entities -> entities.forEach(this::deleteLimit));
+ }
+
+ @Override
+ public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version) {
+ return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version);
+ }
+
+ @Override
+ public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
+ licenseKeyGroup.setStartDate(
+ licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup.getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()
+ + EP_POOL_START_TIME : null) : null);
+ licenseKeyGroup.setExpiryDate(
+ licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup.getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()
+ + EP_POOL_EXPIRY_TIME : null) : null);
+ validateCreateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(), licenseKeyGroup.getVendorLicenseModelId());
+ return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup);
+ }
+
+ @Override
+ public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
+ licenseKeyGroup.setStartDate(
+ licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup.getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()
+ + EP_POOL_START_TIME : null) : null);
+ licenseKeyGroup.setExpiryDate(
+ licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup.getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()
+ + EP_POOL_EXPIRY_TIME : null) : null);
+ validateUpdateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(), licenseKeyGroup.getVendorLicenseModelId());
+ vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup);
+ }
+
+ @Override
+ public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
+ LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
+ VersioningUtil.validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+ return retrieved;
+ }
+
+ @Override
+ public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
+ LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
+ VersioningUtil.validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+ for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
+ featureGroupDao.removeLicenseKeyGroup(
+ new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(), referencingFeatureGroupId),
+ licenseKeyGroup.getId());
+ }
+ deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(), licenseKeyGroup.getId());
+ licenseKeyGroupDao.delete(licenseKeyGroup);
+ deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME, retrieved.getVendorLicenseModelId(),
+ retrieved.getVersion().toString(), retrieved.getName());
+ }
+
+ @Override
+ public LimitEntity createLimit(LimitEntity limit) {
+ validateLimit(limit);
+ LimitEntity createdLimit = vendorLicenseFacade.createLimit(limit);
+ updateParentForLimit(limit);
+ return createdLimit;
+ }
+
+ private void validateLimit(LimitEntity limit) {
+ Collection<LimitEntity> limitList = listLimits(limit.getVendorLicenseModelId(), limit.getVersion(), limit.getEpLkgId());
+ if (!isLimitNameUnique(limitList, limit.getName(), limit.getType(), limit.getId())) {
+ final ErrorCode duplicateLimitNameErrorBuilder = LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
+ throw new CoreException(duplicateLimitNameErrorBuilder);
+ }
+ }
+
+ private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType type, String id) {
+ for (LimitEntity limit : limitList) {
+ if (limit.getName().equalsIgnoreCase(name) && limit.getType().name().equalsIgnoreCase(type.name())) {
+ if (id != null && limit.getId().equals(id)) {
+ continue;
+ }
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId) {
+ return vendorLicenseFacade.listLimits(vlmId, version, epLkgId);
+ }
+
+ @Override
+ public void deleteLimit(LimitEntity limitEntity) {
+ if (!isLimitPresent(limitEntity)) {
+ VersioningUtil.validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ }
+ LimitEntity retrieved = limitDao.get(limitEntity);
+ VersioningUtil.validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ limitDao.delete(limitEntity);
+ updateParentForLimit(limitEntity);
+ }
+
+ @Override
+ public void updateLimit(LimitEntity limit) {
+ getLimit(limit);
+ validateLimit(limit);
+ LimitEntity retrieved = limitDao.get(limit);
+ if (!retrieved.equals(limit)) {
+ vendorLicenseFacade.updateLimit(limit);
+ updateParentForLimit(limit);
+ }
+ }
+
+ private boolean isLimitPresent(LimitEntity limit) {
+ return limitDao.isLimitPresent(limit);
+ }
+
+ @Override
+ public LimitEntity getLimit(LimitEntity limitEntity) {
+ if (!isLimitPresent(limitEntity)) {
+ VersioningUtil.validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ }
+ LimitEntity retrieved = limitDao.get(limitEntity);
+ VersioningUtil.validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ return retrieved;
+ }
+
+ /**
+ * update Parent of limit (EP/LKG) versionuuid when limit is modified so that limit updates are captured in VLM XML
+ */
+ private void updateParentForLimit(LimitEntity limit) {
+ if ("EntitlementPool".equals(limit.getParent())) {
+ EntitlementPoolEntity entitlementPoolEntity = entitlementPoolDao
+ .get(new EntitlementPoolEntity(limit.getVendorLicenseModelId(), limit.getVersion(), limit.getEpLkgId()));
+ entitlementPoolEntity.setVersionUuId(CommonMethods.nextUuId());
+ entitlementPoolDao.update(entitlementPoolEntity);
+ }
+ if ("LicenseKeyGroup".equals(limit.getParent())) {
+ LicenseKeyGroupEntity licenseKeyGroupEntity = licenseKeyGroupDao
+ .get(new LicenseKeyGroupEntity(limit.getVendorLicenseModelId(), limit.getVersion(), limit.getEpLkgId()));
+ licenseKeyGroupEntity.setVersionUuId(CommonMethods.nextUuId());
+ licenseKeyGroupDao.update(licenseKeyGroupEntity);
+ }
+ }
+
+ protected void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds, LicenseAgreementEntity licenseAgreement) {
+ if (featureGroupIds != null) {
+ for (String featureGroupId : featureGroupIds) {
+ featureGroupDao.addReferencingLicenseAgreement(
+ new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), licenseAgreement.getVersion(), featureGroupId),
+ licenseAgreement.getId());
+ }
+ }
+ }
+
+ protected void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds, LicenseAgreementEntity licenseAgreement) {
+ if (featureGroupIds != null) {
+ for (String featureGroupId : featureGroupIds) {
+ featureGroupDao.removeReferencingLicenseAgreement(
+ new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), licenseAgreement.getVersion(), featureGroupId),
+ licenseAgreement.getId());
+ }
+ }
+ }
+
+ protected void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds, FeatureGroupEntity featureGroup) {
+ if (licenseKeyGroupIds != null) {
+ for (String licenseKeyGroupId : licenseKeyGroupIds) {
+ licenseKeyGroupDao.addReferencingFeatureGroup(
+ new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), licenseKeyGroupId),
+ featureGroup.getId());
+ }
+ }
+ }
+
+ protected void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds, FeatureGroupEntity featureGroup) {
+ if (licenseKeyGroupIds != null) {
+ for (String licenseKeyGroupId : licenseKeyGroupIds) {
+ licenseKeyGroupDao.removeReferencingFeatureGroup(
+ new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), licenseKeyGroupId),
+ featureGroup.getId());
+ }
+ }
+ }
+
+ protected void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds, FeatureGroupEntity featureGroup) {
+ if (entitlementPoolIds != null) {
+ for (String entitlementPoolId : entitlementPoolIds) {
+ entitlementPoolDao.addReferencingFeatureGroup(
+ new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), entitlementPoolId),
+ featureGroup.getId());
+ }
+ }
+ }
+
+ protected void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds, FeatureGroupEntity featureGroup) {
+ if (entitlementPoolIds != null) {
+ for (String entitlementPoolId : entitlementPoolIds) {
+ entitlementPoolDao.removeReferencingFeatureGroup(
+ new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(), entitlementPoolId),
+ featureGroup.getId());
+ }
+ }
+ }
+
+ protected void updateUniqueName(String uniqueValueType, String oldName, String newName, String... context) {
+ uniqueValueUtil.updateUniqueValue(uniqueValueType, oldName, newName, context);
+ }
+
+ protected void deleteUniqueName(String uniqueValueType, String... uniqueCombination) {
+ uniqueValueUtil.deleteUniqueValue(uniqueValueType, uniqueCombination);
+ }
}