path: root/openecomp-be/lib/openecomp-sdc-vendor-software-product-lib/openecomp-sdc-vendor-software-product-core/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/services/ManualVspDataCollectionService.java

/*
 * Copyright © 2018 European Support Limited
 *
 * 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.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/

package org.openecomp.sdc.vendorsoftwareproduct.services;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.openecomp.core.utilities.json.JsonUtil;
import org.openecomp.sdc.generator.datatypes.tosca.*;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.*;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.*;
import org.openecomp.sdc.vendorsoftwareproduct.types.composition.*;
import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.compute.Compute;
import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.image.ImageDetails;
import org.openecomp.sdc.versioning.dao.types.Version;

import java.util.*;


public class ManualVspDataCollectionService {

  private static final VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao =
      VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
  private static final DeploymentFlavorDao deploymentFlavorDao =
      DeploymentFlavorDaoFactory.getInstance().createInterface();
  private static final ComputeDao computeDao =
      ComputeDaoFactory.getInstance().createInterface();
  private static final ImageDao imageDao =
      ImageDaoFactory.getInstance().createInterface();
  private static final ComponentDao componentDao =
      ComponentDaoFactory.getInstance().createInterface();

  private static final NicDao nicDao =
      NicDaoFactory.getInstance().createInterface();
  private static final VendorLicenseFacade vendorLicenseFacade =
      VendorLicenseFacadeFactory.getInstance().createInterface();

  private final Logger log = LoggerFactory.getLogger(this.getClass().getName());

  /**
   * Gets vendor name for the vsp.
   *
   * @param vspId   the vsp id
   * @param version the version
   * @return the release vendor name
   */
  public Optional<String> getReleaseVendor(String vspId, Version version) {
    String vendorName = null;
    VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
    if (Objects.nonNull(vspDetails)) {
      vendorName = vspDetails.getVendorName();
    }
    return Optional.ofNullable(vendorName);
  }

  /**
   * Gets the deployment flavor data for manually onboarded VSPs.
   *
   * @param vspId   the vsp id
   * @param version the version
   * @return the allowed flavors
   */
  public Map<String, DeploymentFlavorModel> getAllowedFlavors(String vspId, Version version) {
    Map<String, DeploymentFlavorModel> allowedFlavors = new HashMap<>();
    Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
    if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
      for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
        DeploymentFlavor deploymentFlavorCompositionData =
            deploymentFlavorEntity.getDeploymentFlavorCompositionData();

        VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
        String vspVlmId;
        Version vlmVersion;
        if (Objects.nonNull(vspDetails)) {
          vspVlmId = vspDetails.getVendorId();
          vlmVersion = vspDetails.getVlmVersion();
          if (StringUtils.isNotEmpty(vspVlmId)) {
            DeploymentFlavorModel deploymentFlavorModel = new DeploymentFlavorModel();
            String featureGroupId = deploymentFlavorCompositionData.getFeatureGroupId();
            if (Objects.isNull(featureGroupId)) {
              //No feature group associated with deployment flavor. So excluding this deployment
              // flavor for Tosca model
              continue;
            }
            //Gather and set License flavor info
            LicenseFlavor licenseFlavor = getLicenseFlavor(featureGroupId);
            deploymentFlavorModel.setLicense_flavor(licenseFlavor);
            //Get sp_part_number
            Optional<String> partNumber = getPartNumber(vspVlmId, vlmVersion, featureGroupId);
            partNumber.ifPresent(deploymentFlavorModel::setSp_part_number);
            //Gather and set Vendor Info
            String vendorModel = deploymentFlavorCompositionData.getModel();
            Optional<VendorInfo> vendorInfo = getVendorInfo(vspVlmId, vendorModel, vlmVersion,
                featureGroupId);
            vendorInfo.ifPresent(deploymentFlavorModel::setVendor_info);
            //Gather and set Compute info
            List<ComponentComputeAssociation> componentComputeAssociations =
                deploymentFlavorCompositionData.getComponentComputeAssociations();
            if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
              for (ComponentComputeAssociation componentComputeAssociation :
                  componentComputeAssociations) {
                String componentId = componentComputeAssociation.getComponentId();
                String computeFlavorId = componentComputeAssociation.getComputeFlavorId();
                Optional<ComputeFlavor> computeFlavor =
                    getComputeFlavor(vspId, version, componentId, computeFlavorId);
                computeFlavor.ifPresent(deploymentFlavorModel::setCompute_flavor);
              }
            }
            partNumber.ifPresent(spPartNumber -> allowedFlavors.put(spPartNumber,
                deploymentFlavorModel));
          }
        }
      }
    }
    return allowedFlavors;
  }

  /**
   * Gets the component image data for manually onboarded VSPs.
   *
   * @param vspId   the vsp id
   * @param version the version
   * @return the vsp component images
   */
  public Map<String, List<MultiFlavorVfcImage>> getVspComponentImages(String vspId,
                                                                      Version version) {
    Map<String, List<MultiFlavorVfcImage>> vspComponentImages = new HashMap<>();
    Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
    for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
      DeploymentFlavor deploymentFlavorCompositionData =
          deploymentFlavorEntity.getDeploymentFlavorCompositionData();

      List<ComponentComputeAssociation> componentComputeAssociations =
          deploymentFlavorCompositionData.getComponentComputeAssociations();
      if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
        for (ComponentComputeAssociation componentComputeAssociation :
            componentComputeAssociations) {
          String componentId = componentComputeAssociation.getComponentId();
          List<MultiFlavorVfcImage> componentImages =
              getComponentImages(vspId, version, componentId);
          if (CollectionUtils.isNotEmpty(componentImages)) {
            vspComponentImages.put(componentId, componentImages);
          }
        }
      }
    }
    return vspComponentImages;
  }

  /**
   * Gets the component data for manually onboarded VSPs.
   *
   * @param vspId   the vsp id
   * @param version the version
   * @return the vsp components
   */
  public Map<String, String> getVspComponents(String vspId, Version version) {
    Map<String, String> componentIdNameMap = new HashMap<>();
    Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
    for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
      DeploymentFlavor deploymentFlavorCompositionData =
          deploymentFlavorEntity.getDeploymentFlavorCompositionData();

      List<ComponentComputeAssociation> componentComputeAssociations =
          deploymentFlavorCompositionData.getComponentComputeAssociations();
      if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
        for (ComponentComputeAssociation componentComputeAssociation :
            componentComputeAssociations) {
          String componentId = componentComputeAssociation.getComponentId();
          Optional<String> componentName = getComponentName(vspId, version, componentId);
          componentName.ifPresent(name -> componentIdNameMap.put(componentId, name));
        }
      }
    }
    return componentIdNameMap;
  }

  /**
   * Gets the NIC data for manually onboarded VSPs.
   *
   * @param vspId   the vsp id
   * @param version the version
   * @return the vsp component nics
   */
  public Map<String, List<Nic>> getVspComponentNics(String vspId, Version version) {
    Map<String, List<Nic>> vspComponentNics = new HashMap<>();
    Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
    if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
      for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
        DeploymentFlavor deploymentFlavorCompositionData =
            deploymentFlavorEntity.getDeploymentFlavorCompositionData();
        if (Objects.nonNull(deploymentFlavorCompositionData)) {
          List<ComponentComputeAssociation> componentComputeAssociations =
              deploymentFlavorCompositionData.getComponentComputeAssociations();
          if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
            for (ComponentComputeAssociation componentComputeAssociation :
                componentComputeAssociations) {
              String componentId = componentComputeAssociation.getComponentId();
              List<Nic> componentNics = getComponentNics(vspId, version, componentId);
              if (CollectionUtils.isNotEmpty(componentNics)) {
                vspComponentNics.put(componentId, componentNics);
              }
            }
          }
        }
      }
    }
    return vspComponentNics;
  }

  private List<Nic> getComponentNics(String vspId, Version version, String componentId) {
    List<Nic> componentNics = new ArrayList<>();
    Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
    if (Objects.nonNull(nics)) {
      for (NicEntity nic : nics) {
        String nicId = nic.getId();
        NicEntity nicEntity = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
        if (Objects.nonNull(nicEntity)
            && Objects.nonNull(nicEntity.getCompositionData())) {
          componentNics.add(nicEntity.getNicCompositionData());
        }
      }
    }
    return componentNics;
  }

  private LicenseFlavor getLicenseFlavor(String featureGroupId) {
    LicenseFlavor licenseFlavor = new LicenseFlavor();
    licenseFlavor.setFeature_group_uuid(featureGroupId);
    return licenseFlavor;
  }

  private Optional<String> getPartNumber(String vlmId, Version version,
                                         String featureGroupId) {
    FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId);
    if (Objects.nonNull(featureGroup)) {
      return Optional.ofNullable(featureGroup.getFeatureGroup().getPartNumber());
    }
    return Optional.empty();
  }

  private Optional<VendorInfo> getVendorInfo(String vlmId, String vendorModel, Version version,
                                             String featureGroupId) {
    VendorInfo vendorInfo = null;
    FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId);
    if (Objects.nonNull(featureGroup)) {
      //Process Feature group to get Manufacturer ref no.
      String manufacturerReferenceNumber = featureGroup.getEntityManufacturerReferenceNumber();
      vendorInfo = new VendorInfo();
      vendorInfo.setVendor_model(vendorModel);
      if (Objects.nonNull(manufacturerReferenceNumber)) {
        vendorInfo.setManufacturer_reference_number(manufacturerReferenceNumber);
      }
    }
    return Optional.ofNullable(vendorInfo);
  }

  private Optional<ComputeFlavor> getComputeFlavor(String vspId, Version version,
                                                   String componentId, String computeFlavorId) {
    ComputeFlavor computeFlavor = null;
    ComputeEntity computeQuestionnaire;
    try {
      computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId,
          computeFlavorId);
    } catch (Exception ex) {
      log.warn("Failed to get QuestionnaireData from computeDao," +
              " initializing computeQuestionnaire to null", ex);
      computeQuestionnaire = null;
    }
    if (Objects.nonNull(computeQuestionnaire)) {
      String computeQuestionnaireData = computeQuestionnaire.getQuestionnaireData();
      if (Objects.nonNull(computeQuestionnaireData)) {
        Compute compute;
        try {
          compute = JsonUtil.json2Object(computeQuestionnaireData, Compute.class);
        } catch (Exception ex) {
          log.warn("Failed to convert json value to compute object," +
                  "initializing compute to null", ex);
          compute = null;
        }
        if (compute != null && Objects.nonNull(compute.getVmSizing())) {
          computeFlavor = new ComputeFlavor();
          if (Objects.nonNull(compute.getVmSizing().getNumOfCPUs())) {
            computeFlavor.setNum_cpus(compute.getVmSizing().getNumOfCPUs());
          }
          if (Objects.nonNull(compute.getVmSizing().getFileSystemSizeGB())) {
            computeFlavor.setDisk_size(compute.getVmSizing().getFileSystemSizeGB() + " GB");
          }
          if (Objects.nonNull(compute.getVmSizing().getMemoryRAM())) {
            computeFlavor.setMem_size(compute.getVmSizing().getMemoryRAM());
          }
        }
      }
    }
    return Optional.ofNullable(computeFlavor);
  }

  private FeatureGroupModel getFeatureGroup(String vlmId, Version version, String featureGroupId) {
    FeatureGroupEntity fgInput = new FeatureGroupEntity();
    fgInput.setVendorLicenseModelId(vlmId);
    fgInput.setVersion(version);
    fgInput.setId(featureGroupId);
    return vendorLicenseFacade.getFeatureGroupModel(fgInput);
  }

  private Optional<String> getComponentName(String vspId, Version version, String componentId) {

    ComponentEntity componentEntity =
        componentDao.get(new ComponentEntity(vspId, version, componentId));
    if (Objects.nonNull(componentEntity)
        && Objects.nonNull(componentEntity.getComponentCompositionData())) {
      ComponentData componentCompositionData = componentEntity.getComponentCompositionData();
      return Optional.ofNullable(componentCompositionData.getDisplayName());
    }
    return Optional.empty();
  }

  private List<MultiFlavorVfcImage> getComponentImages(String vspId, Version version,
                                                       String componentId) {
    List<MultiFlavorVfcImage> multiFlavorVfcImages = new ArrayList<>();
    MultiFlavorVfcImage multiFlavorVfcImage;
    Collection<ImageEntity> componentImages =
        imageDao.list(new ImageEntity(vspId, version, componentId, null));
    if (Objects.nonNull(componentImages)) {
      for (ImageEntity componentImage : componentImages) {
        ImageEntity imageEntity = imageDao.get(componentImage);
        ImageEntity imageQuestionnaireDataEntity = imageDao.getQuestionnaireData(vspId, version,
            componentId, componentImage.getId());
        Image imageCompositionData = imageEntity.getImageCompositionData();
        if (Objects.nonNull(imageEntity)
            && Objects.nonNull(imageQuestionnaireDataEntity)
            && Objects.nonNull(imageCompositionData)) {
          ImageDetails imageDetails;
          try {
            imageDetails = JsonUtil.json2Object(imageQuestionnaireDataEntity
                .getQuestionnaireData(), ImageDetails.class);
          } catch (Exception ex) {
            log.warn("Failed to convert json value to ImageDetails object," +
                    "initializing imageDetails to null", ex);
            imageDetails = null;
          }
          if (Objects.nonNull(imageDetails)
              && Objects.nonNull(imageDetails.getVersion())) {
            //Image version is used as a key for the image block
            //So excluding the population if questionnaire data is absent or invalid
            multiFlavorVfcImage = new MultiFlavorVfcImage();
            multiFlavorVfcImage.setSoftware_version(imageDetails.getVersion());
            if (Objects.nonNull(imageCompositionData.getFileName())) {
              multiFlavorVfcImage.setFile_name(imageCompositionData.getFileName());
            }
            if (Objects.nonNull(imageDetails.getMd5())) {
              multiFlavorVfcImage.setFile_hash(imageDetails.getMd5());
            }
            multiFlavorVfcImage.setFile_hash_type("md5");
            multiFlavorVfcImages.add(multiFlavorVfcImage);
          }
        }
      }
    }
    return multiFlavorVfcImages;
  }
}