vid-app-common/src/main/java/org/onap/vid/job/command/MsoRequestBuilder.kt

   1 package org.onap.vid.job.command
   2
   3 import com.google.common.collect.ImmutableList
   4 import org.apache.commons.lang3.ObjectUtils.defaultIfNull
   5 import org.apache.commons.lang3.StringUtils
   6 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate
   7 import org.onap.vid.aai.AaiClientInterface
   8 import org.onap.vid.aai.ExceptionWithRequestInfo
   9 import org.onap.vid.aai.model.ResourceType
  10 import org.onap.vid.changeManagement.RequestDetailsWrapper
  11 import org.onap.vid.model.serviceInstantiation.*
  12 import org.onap.vid.mso.model.*
  13 import org.onap.vid.mso.model.BaseResourceInstantiationRequestDetails.*
  14 import org.onap.vid.mso.rest.SubscriberInfo
  15 import org.onap.vid.properties.Features
  16 import org.onap.vid.services.AsyncInstantiationBusinessLogic
  17 import org.onap.vid.services.CloudOwnerService
  18 import org.onap.vid.utils.JACKSON_OBJECT_MAPPER
  19 import org.springframework.beans.factory.annotation.Autowired
  20 import org.springframework.stereotype.Service
  21 import org.togglz.core.manager.FeatureManager
  22 import java.util.*
  23 import java.util.Collections.emptyList
  24 import java.util.stream.Collectors
  25
  26 @Service
  27 class MsoRequestBuilder
  28 @Autowired constructor(private val asyncInstantiationBL: AsyncInstantiationBusinessLogic,
  29                        private val cloudOwnerService: CloudOwnerService,
  30                        private val aaiClient: AaiClientInterface,
  31                        private val featureManager: FeatureManager) {
  32
  33     companion object {
  34         private val LOGGER = EELFLoggerDelegate.getLogger(MsoRequestBuilder::class.java)
  35         private const val VID_SOURCE = "VID"
  36         private const val DISABLED_HOMING_VALUE = "none"
  37     }
  38
  39     fun generateALaCarteServiceInstantiationRequest(payload: ServiceInstantiation, optimisticUniqueServiceInstanceName: String, userId: String): RequestDetailsWrapper<ServiceInstantiationRequestDetails> {
  40         val userParams = generateUserParamList()
  41
  42         val requestParameters = ServiceInstantiationRequestDetails.RequestParameters(payload.subscriptionServiceType, true, userParams, payload.testApi)
  43
  44         val requestDetails = generateServiceInstantiationRequestDetails(payload, requestParameters, optimisticUniqueServiceInstanceName, userId)
  45
  46         return RequestDetailsWrapper(requestDetails)
  47     }
  48
  49     fun generateServiceDeletionRequest(payload: ServiceInstantiation, userId: String): RequestDetailsWrapper<ServiceDeletionRequestDetails> {
  50
  51         val requestParameters = ServiceDeletionRequestDetails.RequestParameters(payload.isALaCarte, payload.testApi)
  52
  53         val requestInfo = ServiceDeletionRequestDetails.RequestInfo(
  54                 VID_SOURCE,
  55                 userId)
  56
  57         val requestDetails = ServiceDeletionRequestDetails(payload.modelInfo, requestInfo, requestParameters)
  58
  59         return RequestDetailsWrapper(requestDetails)
  60     }
  61
  62     fun generateMacroServiceInstantiationRequest(jobId: UUID?, payload: ServiceInstantiation, optimisticUniqueServiceInstanceName: String, userId: String): RequestDetailsWrapper<ServiceInstantiationRequestDetails> {
  63         val serviceInstanceName = generateServiceName(jobId, payload, optimisticUniqueServiceInstanceName)
  64
  65         val serviceInstantiationServiceList = generateMacroServiceInstantiationRequestParams(payload, serviceInstanceName, jobId)
  66
  67
  68         val requestParameters = ServiceInstantiationRequestDetails.RequestParameters(payload.subscriptionServiceType, false, serviceInstantiationServiceList)
  69
  70         val requestDetails = generateServiceInstantiationRequestDetails(payload, requestParameters, serviceInstanceName, userId)
  71
  72         return RequestDetailsWrapper(requestDetails)
  73     }
  74
  75     fun generateNetworkInstantiationRequest(networkDetails: Network, serviceModelInfo: ModelInfo, serviceInstanceId: String, userId: String, testApi: String?): RequestDetailsWrapper<NetworkInstantiationRequestDetails> {
  76         val requestInfo = generateRequestInfo(networkDetails.instanceName, ResourceType.L3_NETWORK, networkDetails.isRollbackOnFailure, networkDetails.productFamilyId, userId)
  77         val cloudConfiguration = generateCloudConfiguration(networkDetails.lcpCloudRegionId, networkDetails.tenantId)
  78         val platform = Platform(networkDetails.platformName)
  79         val lineOfBusiness = LineOfBusiness.of(networkDetails.lineOfBusiness)
  80         val requestParameters = BaseResourceInstantiationRequestDetails.RequestParameters(generateUserParamList(), testApi)
  81         val relatedInstanceList = generateRelatedInstances(mapOf(serviceInstanceId to serviceModelInfo))
  82         return RequestDetailsWrapper(NetworkInstantiationRequestDetails(networkDetails.modelInfo, cloudConfiguration, requestInfo, platform, lineOfBusiness, relatedInstanceList, requestParameters))
  83     }
  84
  85     fun generateVnfInstantiationRequest(vnfDetails: Vnf, serviceModelInfo: ModelInfo, serviceInstanceId: String, userId: String, testApi: String?): RequestDetailsWrapper<VnfInstantiationRequestDetails> {
  86         val requestInfo = generateRequestInfo(vnfDetails.instanceName, ResourceType.GENERIC_VNF, vnfDetails.isRollbackOnFailure, vnfDetails.productFamilyId, userId)
  87         val cloudConfiguration = generateCloudConfiguration(vnfDetails.lcpCloudRegionId, vnfDetails.tenantId)
  88         val platform = Platform(vnfDetails.platformName)
  89         val lineOfBusiness = LineOfBusiness.of(vnfDetails.lineOfBusiness)
  90         val requestParameters = BaseResourceInstantiationRequestDetails.RequestParameters(generateUserParamList(), testApi)
  91         val relatedInstanceList = generateRelatedInstances(mapOf(serviceInstanceId to serviceModelInfo))
  92         return RequestDetailsWrapper(VnfInstantiationRequestDetails(vnfDetails.modelInfo, cloudConfiguration, requestInfo, platform, lineOfBusiness, relatedInstanceList, requestParameters))
  93     }
  94
  95     fun generateDeleteVnfRequest(vnfDetails: Vnf, userId: String): RequestDetailsWrapper<VnfInstantiationRequestDetails> {
  96         val requestInfo = generateRequestInfo(null, null, null, null, userId)
  97         val cloudConfiguration = generateCloudConfiguration(vnfDetails.lcpCloudRegionId, vnfDetails.tenantId)
  98         return RequestDetailsWrapper(VnfInstantiationRequestDetails(vnfDetails.modelInfo, cloudConfiguration, requestInfo, null, null, null, null))
  99     }
 100
 101     protected fun generateVfModuleRequestWithRequestParams(
 102             vfModuleDetails: VfModule, serviceModelInfo: ModelInfo,
 103             serviceInstanceId: String, vnfModelInfo: ModelInfo, vnfInstanceId: String, vgInstanceId: String?, userId: String,
 104             requestParameters: (userParams: List<UserParamTypes>) -> RequestParametersVfModuleOrVolumeGroup
 105     ): RequestDetailsWrapper<VfModuleOrVolumeGroupRequestDetails> {
 106         val requestInfo = generateRequestInfo(vfModuleDetails.instanceName, ResourceType.VF_MODULE, vfModuleDetails.isRollbackOnFailure, null, userId)
 107
 108         //cloud configuration
 109         val cloudConfiguration = generateCloudConfiguration(vfModuleDetails.lcpCloudRegionId, vfModuleDetails.tenantId)
 110
 111         val userParams = aggregateAllInstanceParams(extractActualInstanceParams(vfModuleDetails.instanceParams), vfModuleDetails.supplementaryParams)
 112
 113         //related instance list
 114         val relatedInstanceList = generateRelatedInstances(mapOf(serviceInstanceId to serviceModelInfo, vnfInstanceId to vnfModelInfo))
 115         if (StringUtils.isNotEmpty(vgInstanceId)) {
 116             val volumeGroupModel = ModelInfo()
 117             volumeGroupModel.modelType = "volumeGroup"
 118             relatedInstanceList.add(RelatedInstance(volumeGroupModel, vgInstanceId, vfModuleDetails.volumeGroupInstanceName))
 119         }
 120
 121         return RequestDetailsWrapper(VfModuleOrVolumeGroupRequestDetails(vfModuleDetails.modelInfo, cloudConfiguration, requestInfo, relatedInstanceList, requestParameters(userParams)))
 122     }
 123
 124     fun generateVfModuleInstantiationRequest(
 125             vfModuleDetails: VfModule, serviceModelInfo: ModelInfo,
 126             serviceInstanceId: String, vnfModelInfo: ModelInfo, vnfInstanceId: String,
 127             vgInstanceId: String?, userId: String, testApi: String?
 128     ): RequestDetailsWrapper<VfModuleOrVolumeGroupRequestDetails> {
 129         val requestParameters = { userParams: List<UserParamTypes> ->
 130             RequestParametersVfModuleOrVolumeGroupInstantiation(userParams, vfModuleDetails.isUsePreload, testApi)
 131         }
 132
 133         return generateVfModuleRequestWithRequestParams(vfModuleDetails, serviceModelInfo, serviceInstanceId,
 134                 vnfModelInfo, vnfInstanceId, vgInstanceId, userId, requestParameters)
 135     }
 136
 137     fun generateVfModuleReplaceRequest(
 138             vfModuleDetails: VfModule, serviceModelInfo: ModelInfo,
 139             serviceInstanceId: String, vnfModelInfo: ModelInfo, vnfInstanceId: String,
 140             vgInstanceId: String?, userId: String, testApi: String?
 141     ): RequestDetailsWrapper<VfModuleOrVolumeGroupRequestDetails> {
 142         val requestParameters = { userParams: List<UserParamTypes> ->
 143             RequestParametersVfModuleUpgrade(userParams, vfModuleDetails.isUsePreload, testApi,
 144                     vfModuleDetails.isRetainAssignments, nullSafeNegate(vfModuleDetails.isRetainVolumeGroups))
 145         }
 146
 147         return generateVfModuleRequestWithRequestParams(vfModuleDetails, serviceModelInfo, serviceInstanceId,
 148                 vnfModelInfo, vnfInstanceId, vgInstanceId, userId, requestParameters)
 149     }
 150
 151     private fun nullSafeNegate(booleanValue: Boolean?): Boolean? = booleanValue?.not()
 152
 153     fun generateVolumeGroupInstantiationRequest(vfModuleDetails: VfModule, serviceModelInfo: ModelInfo, serviceInstanceId: String, vnfModelInfo: ModelInfo, vnfInstanceId: String, userId: String, testApi: String?): RequestDetailsWrapper<VolumeGroupRequestDetails> {
 154         val requestInfo = generateRequestInfo(vfModuleDetails.volumeGroupInstanceName, ResourceType.VOLUME_GROUP, vfModuleDetails.isRollbackOnFailure, null, userId)
 155         val cloudConfiguration = generateCloudConfiguration(vfModuleDetails.lcpCloudRegionId, vfModuleDetails.tenantId)
 156         val userParams = aggregateAllInstanceParams(extractActualInstanceParams(vfModuleDetails.instanceParams), vfModuleDetails.supplementaryParams)
 157         val requestParameters = RequestParametersVfModuleOrVolumeGroupInstantiation(userParams, vfModuleDetails.isUsePreload, testApi)
 158         val relatedInstances = generateRelatedInstances(mapOf(serviceInstanceId to serviceModelInfo, vnfInstanceId to vnfModelInfo))
 159
 160         vfModuleDetails.modelInfo.modelType = "volumeGroup"
 161         return RequestDetailsWrapper(VolumeGroupRequestDetails(vfModuleDetails.modelInfo, cloudConfiguration, requestInfo, relatedInstances, requestParameters))
 162     }
 163
 164     fun generateInstanceGroupInstantiationRequest(instanceGroupDetails: InstanceGroup, serviceModelInfo: ModelInfo, serviceInstanceId: String, userId: String, testApi: String?): RequestDetailsWrapper<InstanceGroupInstantiationRequestDetails> {
 165         val requestInfo = generateRequestInfo(instanceGroupDetails.instanceName, ResourceType.INSTANCE_GROUP, instanceGroupDetails.isRollbackOnFailure, null, userId)
 166         val requestParameters = BaseResourceInstantiationRequestDetails.RequestParameters(generateUserParamList(), testApi)
 167         val relatedInstanceList = generateRelatedInstances(mapOf(serviceInstanceId to serviceModelInfo))
 168         return RequestDetailsWrapper(InstanceGroupInstantiationRequestDetails(instanceGroupDetails.modelInfo, requestInfo, relatedInstanceList, requestParameters))
 169     }
 170
 171     fun generateInstanceGroupMemberRequest(instanceGroupMemberId: String, userId: String): RequestDetailsWrapper<AddOrRemoveInstanceGroupMemberRequestDetails> {
 172         val requestInfo = generateRequestInfo(null, null, null, null, userId)
 173         val modelInfo = ModelInfo()
 174         modelInfo.modelType = "vnf"
 175         val relatedInstanceList = generateRelatedInstances(mapOf(instanceGroupMemberId to modelInfo))
 176         return RequestDetailsWrapper(AddOrRemoveInstanceGroupMemberRequestDetails(requestInfo, relatedInstanceList))
 177     }
 178
 179     fun generateDeleteNetworkRequest(networkDetails: Network, userId: String): RequestDetailsWrapper<NetworkInstantiationRequestDetails> {
 180         val requestInfo = generateRequestInfo(null, null, null, null, userId)
 181         val cloudConfiguration = generateCloudConfiguration(networkDetails.lcpCloudRegionId, networkDetails.tenantId)
 182         return RequestDetailsWrapper(NetworkInstantiationRequestDetails(networkDetails.modelInfo, cloudConfiguration, requestInfo, null, null, null, null))
 183     }
 184
 185     fun generateDeleteVfModuleRequest(vfModuleDetails: VfModule, userId: String): RequestDetailsWrapper<VfModuleOrVolumeGroupRequestDetails> {
 186         val requestInfo = generateRequestInfo(null, null, null, null, userId)
 187         val cloudConfiguration = generateCloudConfiguration(vfModuleDetails.lcpCloudRegionId, vfModuleDetails.tenantId)
 188         return RequestDetailsWrapper(VfModuleOrVolumeGroupRequestDetails(vfModuleDetails.modelInfo, cloudConfiguration, requestInfo, null, null))
 189     }
 190
 191     private fun generateServiceName(jobId: UUID?, payload: ServiceInstantiation, optimisticUniqueServiceInstanceName: String): String? {
 192         var serviceInstanceName: String? = null
 193         if (StringUtils.isNotEmpty(optimisticUniqueServiceInstanceName)) {
 194             serviceInstanceName = peekServiceName(jobId, payload, optimisticUniqueServiceInstanceName)
 195         }
 196         return serviceInstanceName
 197     }
 198
 199     private fun peekServiceName(jobId: UUID?, payload: ServiceInstantiation, optimisticUniqueServiceInstanceName: String): String {
 200         val serviceInstanceName: String
 201         // unique name already exist in service info. If it's free in AAI we use it
 202         if (isNameFreeInAai(optimisticUniqueServiceInstanceName, ResourceType.SERVICE_INSTANCE)) {
 203             serviceInstanceName = optimisticUniqueServiceInstanceName
 204         } else {
 205             serviceInstanceName = asyncInstantiationBL.getUniqueName(payload.instanceName, ResourceType.SERVICE_INSTANCE)
 206         }//otherwise we used the original service instance name (from payload) to get a new unique name from DB and AAI
 207
 208         //update serviceInfo with new name if needed
 209         try {
 210             asyncInstantiationBL.updateServiceInfo(jobId) { x -> x.serviceInstanceName = serviceInstanceName }
 211         } catch (e: Exception) {
 212             LOGGER.error(EELFLoggerDelegate.errorLogger, "Failed updating service name {} in serviceInfo", serviceInstanceName, e)
 213         }
 214
 215         return serviceInstanceName
 216     }
 217
 218     @Throws(ExceptionWithRequestInfo::class)
 219     private fun isNameFreeInAai(name: String, resourceType: ResourceType): Boolean {
 220         return !aaiClient.isNodeTypeExistsByName(name, resourceType)
 221     }
 222
 223     private fun generateServiceInstantiationServicesList(payload: ServiceInstantiation, serviceInstanceName: String?, vnfList: ServiceInstantiationRequestDetails.ServiceInstantiationVnfList): List<ServiceInstantiationRequestDetails.ServiceInstantiationService> {
 224         val serviceInstantiationServiceList = LinkedList<ServiceInstantiationRequestDetails.ServiceInstantiationService>()
 225         val unFilteredInstanceParams = defaultIfNull<List<MutableMap<String, String>>>(payload.instanceParams, emptyList())
 226         val filteredInstanceParams = removeUnNeededParams(unFilteredInstanceParams)
 227         val serviceInstantiationService = ServiceInstantiationRequestDetails.ServiceInstantiationService(
 228                 payload.modelInfo,
 229                 serviceInstanceName,
 230                 filteredInstanceParams,
 231                 vnfList
 232         )
 233         serviceInstantiationServiceList.add(serviceInstantiationService)
 234         return serviceInstantiationServiceList
 235     }
 236
 237     private fun removeUnNeededParams(instanceParams: List<MutableMap<String, String>>?): List<MutableMap<String, String>> {
 238         val keysToRemove = mutableListOf<String>()
 239         if (instanceParams.isNullOrEmpty()) {
 240             return emptyList()
 241         }
 242
 243         for (key in instanceParams[0].keys) {
 244             for (paramToIgnore in AsyncInstantiationBusinessLogic.PARAMS_TO_IGNORE)
 245                 if (key.equals(paramToIgnore, ignoreCase = true)) {
 246                     keysToRemove.add(key)
 247                 }
 248         }
 249
 250         val result: MutableMap<String, String> = instanceParams[0].entries.stream()
 251                 .filter { entry -> !keysToRemove.contains(entry.key) }
 252                 .collect(Collectors.toMap({ it.key }, { it.value }))
 253
 254         return if (result.isEmpty()) emptyList() else listOf(result)
 255     }
 256
 257     private fun createServiceInstantiationVnfList(jobId: UUID?, payload: ServiceInstantiation): ServiceInstantiationRequestDetails.ServiceInstantiationVnfList {
 258         val cloudConfiguration = generateCloudConfiguration(payload.lcpCloudRegionId, payload.tenantId)
 259         val isBulk = asyncInstantiationBL.isPartOfBulk(jobId)
 260
 261         val vnfs = payload.vnfs
 262         val vnfList = mutableListOf<ServiceInstantiationRequestDetails.ServiceInstantiationVnf>()
 263         for (vnf in vnfs.values) {
 264             val vfModules = vnf.vfModules
 265             val convertedUnFilteredVfModules = convertVfModuleMapToList(vfModules)
 266             val filteredVfModules = filterInstanceParamsFromVfModuleAndUniqueNames(convertedUnFilteredVfModules, isBulk)
 267             val serviceInstantiationVnf = ServiceInstantiationRequestDetails.ServiceInstantiationVnf(
 268                     vnf.modelInfo,
 269                     cloudConfiguration,
 270                     vnf.platformName,
 271                     vnf.lineOfBusiness,
 272                     payload.productFamilyId,
 273                     buildVnfInstanceParams(vnf.instanceParams, filteredVfModules),
 274                     filteredVfModules,
 275                     getUniqueNameIfNeeded(vnf.instanceName, ResourceType.GENERIC_VNF, isBulk)
 276             )
 277             vnfList.add(serviceInstantiationVnf)
 278         }
 279
 280         return ServiceInstantiationRequestDetails.ServiceInstantiationVnfList(vnfList)
 281     }
 282
 283     private fun convertVfModuleMapToList(vfModules: Map<String, Map<String, VfModule>>): List<VfModuleMacro> {
 284         return vfModules.values.stream().flatMap { vfModule ->
 285             vfModule.values.stream().map { item ->
 286                 val aggregatedParams = aggregateAllInstanceParams(extractActualInstanceParams(item.instanceParams), item.supplementaryParams)
 287                 val aggregatedParamsConverted = JACKSON_OBJECT_MAPPER.convertValue(aggregatedParams, List::class.java)
 288
 289                 VfModuleMacro(
 290                         item.modelInfo,
 291                         item.instanceName,
 292                         item.volumeGroupInstanceName,
 293                         aggregatedParamsConverted as List<Map<String, String>>)
 294             }
 295         }.collect(Collectors.toList<VfModuleMacro>())
 296     }
 297
 298     fun aggregateAllInstanceParams(instanceParams: Map<String, String>?, supplementaryParams: Map<String, String>?): List<UserParamMap<String, String>> {
 299         var instanceParamsFinal: Map<String, String> = instanceParams ?: emptyMap()
 300         val supplementaryParamsFinal: Map<String, String> = supplementaryParams ?: emptyMap()
 301
 302         if (!(instanceParamsFinal.isEmpty() && supplementaryParamsFinal.isEmpty())) {
 303             //remove duplicate keys from instanceParams if exist in supplementaryParams
 304             instanceParamsFinal = instanceParamsFinal.entries.stream()
 305                     .filter { m -> !supplementaryParamsFinal.containsKey(m.key) }
 306                     .collect(Collectors.toMap({ it.key }, { it.value }))
 307
 308             //aggregate the 2 collections and format them as UserParamMap
 309             val aggregatedParams = UserParamMap<String, String>()
 310             aggregatedParams.putAll(instanceParamsFinal)
 311             aggregatedParams.putAll(supplementaryParamsFinal)
 312
 313             return mutableListOf(aggregatedParams)
 314         }
 315
 316         return emptyList()
 317     }
 318
 319     //Make sure we always get a one Map from InstanceParams
 320     private fun extractActualInstanceParams(originalInstanceParams: List<MutableMap<String, String>>?): MutableMap<String, String> {
 321         return if (originalInstanceParams.isNullOrEmpty() || originalInstanceParams[0].isNullOrEmpty()) {
 322             mutableMapOf()
 323         } else originalInstanceParams[0]
 324     }
 325
 326     private fun filterInstanceParamsFromVfModuleAndUniqueNames(unFilteredVfModules: List<VfModuleMacro>, isBulk: Boolean): List<VfModuleMacro> {
 327         return unFilteredVfModules.stream().map { vfModule ->
 328             VfModuleMacro(
 329                     vfModule.modelInfo,
 330                     getUniqueNameIfNeeded(vfModule.instanceName, ResourceType.VF_MODULE, isBulk),
 331                     getUniqueNameIfNeeded(vfModule.volumeGroupInstanceName, ResourceType.VOLUME_GROUP, isBulk),
 332                     removeUnNeededParams(vfModule.instanceParams))
 333         }
 334                 .collect(Collectors.toList<VfModuleMacro>())
 335     }
 336
 337     fun buildVnfInstanceParams(currentVnfInstanceParams: List<MutableMap<String, String>>, vfModules: List<VfModuleMacro>): List<Map<String, String>> {
 338         val filteredVnfInstanceParams = removeUnNeededParams(currentVnfInstanceParams)
 339
 340         val vnfInstanceParams = extractActualInstanceParams(filteredVnfInstanceParams)
 341         vfModules.stream()
 342                 .map { x -> extractActualInstanceParams(x.instanceParams) }
 343                 .forEach { vnfInstanceParams.putAll(it) }
 344         return if (vnfInstanceParams.isEmpty()) emptyList() else ImmutableList.of(vnfInstanceParams)
 345     }
 346
 347     private fun generateServiceInstantiationRequestDetails(payload: ServiceInstantiation, requestParameters: ServiceInstantiationRequestDetails.RequestParameters, serviceInstanceName: String?, userId: String): ServiceInstantiationRequestDetails {
 348         val requestInfo = ServiceInstantiationRequestDetails.RequestInfo(serviceInstanceName,
 349                 payload.productFamilyId,
 350                 VID_SOURCE,
 351                 payload.isRollbackOnFailure,
 352                 userId)
 353         val owningEntity = ServiceInstantiationRequestDetails.ServiceInstantiationOwningEntity(payload.owningEntityId, payload.owningEntityName)
 354         val subscriberInfo = generateSubscriberInfo(payload)
 355         val project = if (payload.projectName != null) ServiceInstantiationRequestDetails.Project(payload.projectName) else null
 356         return ServiceInstantiationRequestDetails(payload.modelInfo, owningEntity, subscriberInfo, project, requestInfo, requestParameters)
 357     }
 358
 359     private fun generateSubscriberInfo(payload: ServiceInstantiation): SubscriberInfo {
 360         val subscriberInfo = SubscriberInfo()
 361         subscriberInfo.globalSubscriberId = payload.globalSubscriberId
 362         return subscriberInfo
 363     }
 364
 365     private fun generateCloudConfiguration(lcpCloudRegionId: String?, tenantId: String?): CloudConfiguration {
 366         val cloudConfiguration = CloudConfiguration(lcpCloudRegionId, tenantId)
 367         if (lcpCloudRegionId != null) {
 368             cloudOwnerService.enrichCloudConfigurationWithCloudOwner(cloudConfiguration, lcpCloudRegionId)
 369         }
 370         return cloudConfiguration
 371     }
 372
 373     private fun generateRelatedInstances(relatedInstances: Map<String, ModelInfo>): MutableList<RelatedInstance> {
 374         return relatedInstances.entries.stream()
 375                 .map { RelatedInstance(it.value, it.key) }
 376                 .collect(Collectors.toList())
 377     }
 378
 379     private fun generateRequestInfo(instanceName: String?, resourceType: ResourceType?, rollbackOnFailure: Boolean?, productFamilyId: String?, userId: String): BaseResourceInstantiationRequestDetails.RequestInfo {
 380         return BaseResourceInstantiationRequestDetails.RequestInfo(
 381                 if (resourceType == null) null else getUniqueNameIfNeeded(instanceName, resourceType, false),
 382                 productFamilyId,
 383                 VID_SOURCE,
 384                 rollbackOnFailure,
 385                 userId)
 386
 387     }
 388
 389     private fun getUniqueNameIfNeeded(name: String?, resourceType: ResourceType, isBulk: Boolean): String? {
 390         return if (StringUtils.isNotEmpty(name)) {
 391             if (isBulk) asyncInstantiationBL.getUniqueName(name, resourceType) else name
 392         } else {
 393             null
 394         }
 395     }
 396
 397     private fun generateUserParamList(): List<ServiceInstantiationRequestDetails.UserParamNameAndValue> {
 398         return emptyList()
 399     }
 400
 401     fun generateMacroServicePre1806InstantiationRequest(payload: ServiceInstantiation, userId: String): RequestDetailsWrapper<ServiceInstantiationRequestDetails> {
 402         val requestInfo = ServiceInstantiationRequestDetails.RequestInfo(payload.instanceName, payload.productFamilyId, VID_SOURCE, payload.isRollbackOnFailure, userId)
 403         val userParams = generateUserParamsNameAndValue(payload.instanceParams)
 404         val requestParameters = ServiceInstantiationRequestDetails.RequestParameters(payload.subscriptionServiceType, false, userParams)
 405         val subscriberInfo = generateSubscriberInfoPre1806(payload)
 406         val project = if (payload.projectName != null) ServiceInstantiationRequestDetails.Project(payload.projectName) else null
 407         val owningEntity = ServiceInstantiationRequestDetails.ServiceInstantiationOwningEntity(payload.owningEntityId, payload.owningEntityName)
 408         val cloudConfiguration = generateCloudConfiguration(payload.lcpCloudRegionId, payload.tenantId)
 409         val relatedInstanceList = generateRelatedInstanceListForVrfEntry(payload.vrfs)
 410
 411         return RequestDetailsWrapper(ServiceInstantiationPre1806RequestDetails(
 412                 payload.modelInfo,
 413                 owningEntity,
 414                 subscriberInfo,
 415                 project,
 416                 requestInfo,
 417                 requestParameters,
 418                 cloudConfiguration,
 419                 relatedInstanceList))
 420     }
 421
 422     private fun generateUserParamsNameAndValue(instanceParams: List<Map<String, String>>): List<ServiceInstantiationRequestDetails.UserParamNameAndValue> {
 423         return instanceParams.getOrElse(0) {emptyMap()}.map{ x-> ServiceInstantiationRequestDetails.UserParamNameAndValue(x.key, x.value)}
 424     }
 425
 426     private fun generateSubscriberInfoPre1806(payload: ServiceInstantiation): SubscriberInfo {
 427         val subscriberInfo = SubscriberInfo()
 428         subscriberInfo.globalSubscriberId = payload.globalSubscriberId
 429         subscriberInfo.subscriberName = payload.subscriberName
 430         return subscriberInfo
 431     }
 432
 433     private fun generateRelatedInstanceListForVrfEntry(vrfEntries: MutableMap<String, VrfEntry>): List<RelatedInstance> {
 434         //fe send map of vrfs, with maps of networks and vpns, but actually we expect to only one vpn and one network
 435         return if (vrfEntries.isEmpty() || vrfEntries.values.first().vpns.isEmpty() || vrfEntries.values.first().networks.isEmpty()) emptyList()
 436         else {
 437             val vpn = vrfEntries.values.first().vpns.values.first()
 438             val network = vrfEntries.values.first().networks.values.first()
 439             listOf(vpn, network).map { RelatedInstance(it.modelInfo, it.instanceId, it.instanceName) }
 440         }
 441     }
 442
 443     private fun generateMacroServiceInstantiationRequestParams(payload: ServiceInstantiation, serviceInstanceName: String?, jobId: UUID?): List<UserParamTypes> {
 444         val userParams = generateServiceInstantiationServicesList(payload, serviceInstanceName, createServiceInstantiationVnfList(jobId, payload))
 445
 446         return userParams.plus(homingSolution())
 447     }
 448
 449     private fun homingSolution(): List<UserParamTypes> {
 450         return if (featureManager.isActive(Features.FLAG_DISABLE_HOMING)) {
 451             listOf(ServiceInstantiationRequestDetails.HomingSolution(DISABLED_HOMING_VALUE))
 452         } else {
 453             listOf()
 454         }
 455     }
 456 }