import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
import org.openecomp.sdc.vendorlicense.healing.HealingService;
import org.openecomp.sdc.vendorlicense.licenseartifacts.impl.VendorLicenseArtifactsServiceImpl;
+import org.openecomp.sdc.versioning.ItemManagerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
import org.openecomp.sdc.versioning.dao.types.VersionableEntity;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
/**
* @author katyr
public class VendorLicenseArtifactsServiceUtils {
private static final HealingService healingService =
- HealingServiceFactory.getInstance().createInterface();
+ HealingServiceFactory.getInstance().createInterface();
/**
* maps the entities by id
* @return a Map of id -> list of versionable entities with that id
*/
private static MultiValuedMap<String, VersionableEntity> mapById(
- Collection<? extends VersionableEntity> versionableEntities) {
+ Collection<? extends VersionableEntity> versionableEntities) {
MultiValuedMap<String, VersionableEntity> mappedById = new ArrayListValuedHashMap<>();
for (VersionableEntity ve : versionableEntities) {
mappedById.put(ve.getId(), ve);
}
/**
- * For all entities with same id, only entities that differ from one another will be returned.
- * If no change has occured, the entity with the earlier VLM version will be returned.
- * If only one version of said entities exists it will be returned
+ * For all entities with same id, only entities that differ from one another will be returned.
+ * If no change has occured, the entity with the earlier VLM version will be returned.
+ * If only one version of said entities exists it will be returned
+ *
* @return a list of entities that has been changed
*/
public static List<VersionableEntity> filterChangedEntities(
- Collection<? extends VersionableEntity> versionableEntities) {
+ Collection<? extends VersionableEntity> versionableEntities) {
MultiValuedMap<String, VersionableEntity> entitiesById = mapById(
- versionableEntities);
+ versionableEntities);
MultiValuedMap<String, VersionableEntity> entitiesByVersionUuId =
- new ArrayListValuedHashMap<>();
+ new ArrayListValuedHashMap<>();
List<VersionableEntity> changedOnly = new ArrayList<>();
for (String epId : entitiesById.keySet()) {
//for every list of eps which have the same uuid, get the one with the earliest vlm version.
for (String versionUid : entitiesByVersionUuId.keySet()) {
List<VersionableEntity> versionableEntitiesForUuid =
- (List<VersionableEntity>) entitiesByVersionUuId.get(versionUid);
+ (List<VersionableEntity>) entitiesByVersionUuId.get(versionUid);
versionableEntitiesForUuid.sort(new VersionableEntitySortByVlmMajorVersion());
changedOnly.add(versionableEntitiesForUuid.get(0));
}
return changedOnly;
}
- public static Set<LicenseKeyGroupEntity> healLkgs(String user,
- Collection<? extends VersionableEntity> licenseKeyGroupEntities) {
+ public static Set<LicenseKeyGroupEntity> healLkgs(
+ Collection<? extends VersionableEntity> licenseKeyGroupEntities) {
Set<LicenseKeyGroupEntity> healed = new HashSet<>();
for (VersionableEntity licenseKeyGroupEntity : licenseKeyGroupEntities) {
healed.add((LicenseKeyGroupEntity) VendorLicenseArtifactsServiceImpl.healingService
- .heal(licenseKeyGroupEntity, user));
+ .heal(licenseKeyGroupEntity));
}
return healed;
}
- public static Set<EntitlementPoolEntity> healEPs(String user,
- Collection<? extends VersionableEntity> entitlementPoolEntities) {
+ public static Set<EntitlementPoolEntity> healEPs(
+ Collection<? extends VersionableEntity> entitlementPoolEntities) {
Set<EntitlementPoolEntity> healed = new HashSet<>();
for (VersionableEntity entitlementPoolEntity : entitlementPoolEntities) {
healed.add((EntitlementPoolEntity) VendorLicenseArtifactsServiceImpl.healingService
- .heal(entitlementPoolEntity, user));
+ .heal(entitlementPoolEntity));
}
return healed;
}
public static List<Version> getFinalVersionsForVlm(String vlmId) {
- VersionInfo versionInfo =
- VendorLicenseArtifactsServiceImpl.vendorLicenseFacade
- .getVersionInfo(vlmId, VersionableEntityAction.Read, "");
- return versionInfo.getFinalVersions();
-
+ VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
+ return versioningManager.list(vlmId).stream()
+ .filter(version -> VersionStatus.Certified == version.getStatus())
+ .map(certifiedVersion -> versioningManager.get(vlmId, certifiedVersion)) //sync to private
+ .collect(Collectors.toList());
}
- public static String getVendorName(String vendorLicenseModelId, String user) {
- return VendorLicenseArtifactsServiceImpl.vendorLicenseFacade
- .getVendorLicenseModel(vendorLicenseModelId, null, user)
- .getVendorLicenseModel().getVendorName();
+ public static String getVendorName(String vendorLicenseModelId) {
+ return ItemManagerFactory.getInstance().createInterface().get(vendorLicenseModelId).getName();
}
* to healing as before. For VLMs created post-bugfix this code should not update any element
*/
public static Collection<? extends VersionableEntity> prepareForFiltering(Collection<? extends
- VersionableEntity> versionableEntities, String user, boolean isEP) {
+ VersionableEntity> versionableEntities, boolean isEP) {
MultiValuedMap<String, VersionableEntity> entitiesById = mapById(
- versionableEntities);
+ versionableEntities);
for (String epId : entitiesById.keySet()) {
List<VersionableEntity> versionableEntitiesForId = new ArrayList<>();
versionableEntitiesForId.addAll(entitiesById.get(epId));
versionableEntitiesForId.sort(new VersionableEntitySortByVlmMajorVersion());
- healingService.heal(versionableEntitiesForId.get(0), user);
+ healingService.heal(versionableEntitiesForId.get(0));
for (int i = 1; i < versionableEntitiesForId.size(); i++) {
if (isEP) {
EntitlementPoolEntity current = (EntitlementPoolEntity) versionableEntitiesForId.get(i);
EntitlementPoolEntity previous = (EntitlementPoolEntity) versionableEntitiesForId
- .get(i - 1);
+ .get(i - 1);
if (current.equals(previous) && current.getVersionUuId() == null) {
current.setVersionUuId(previous.getVersionUuId());
healingService.persistNoHealing(current);
} else {
- versionableEntitiesForId.set(i, healingService.heal(versionableEntitiesForId.get(i),
- user));
+ versionableEntitiesForId.set(i, healingService.heal(versionableEntitiesForId.get(i)));
}
} else {
LicenseKeyGroupEntity current = (LicenseKeyGroupEntity) versionableEntitiesForId.get(i);
LicenseKeyGroupEntity previous = (LicenseKeyGroupEntity) versionableEntitiesForId
- .get(i - 1);
+ .get(i - 1);
if (current.equals(previous) && current.getVersionUuId() == null) {
current.setVersionUuId(previous.getVersionUuId());
healingService.persistNoHealing(current);
} else {
- versionableEntitiesForId.set(i, healingService.heal(versionableEntitiesForId.get(i),
- user));
+ versionableEntitiesForId.set(i, healingService.heal(versionableEntitiesForId.get(i)));
}
Code Review / sdc.git / blobdiff