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