ms/blueprintsprocessor/modules/inbounds/designer-api/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/designer/api/service/AutoResourceMappingService.kt

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2019 Huawei.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.service
  19
  20 import com.google.common.base.Preconditions
  21 import org.apache.commons.collections.CollectionUtils
  22 import org.apache.commons.lang3.StringUtils
  23 import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.AutoMapResponse
  24 import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ResourceDictionary
  25 import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.repository.ResourceDictionaryRepository
  26 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
  27 import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
  28 import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
  29 import org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils.ResourceDictionaryUtils
  30 import org.slf4j.LoggerFactory
  31 import org.springframework.stereotype.Service
  32 import java.util.*
  33
  34 @Service
  35 open class AutoResourceMappingService(private val dataDictionaryRepository: ResourceDictionaryRepository) {
  36
  37     private val log = LoggerFactory.getLogger(AutoResourceMappingService::class.java)
  38
  39     @Throws(BluePrintException::class)
  40     fun autoMap(resourceAssignments: MutableList<ResourceAssignment>):
  41             AutoMapResponse {
  42         val autoMapResponse = AutoMapResponse()
  43         try {
  44             if (CollectionUtils.isNotEmpty(resourceAssignments)) {
  45                 // Create the Dictionary definitions for the ResourceAssignment Names
  46                 val dictionaryMap = getDictionaryDefinitions(resourceAssignments)
  47
  48                 for (resourceAssignment in resourceAssignments) {
  49                     if (StringUtils.isNotBlank(resourceAssignment.name)
  50                             && StringUtils.isBlank(resourceAssignment.dictionaryName)) {
  51                         populateDictionaryMapping(dictionaryMap, resourceAssignment)
  52                         log.info("Mapped Resource : {}", resourceAssignment)
  53                     }
  54                 }
  55             }
  56             val dictionaries = getDictionaryDefinitionsList(resourceAssignments)
  57             val resourceAssignmentsFinal = getAllAutoMapResourceAssignments(resourceAssignments)
  58             autoMapResponse.dataDictionaries = dictionaries
  59             autoMapResponse.resourceAssignments = resourceAssignmentsFinal
  60         } catch (e: Exception) {
  61             log.error(String.format("Failed in auto process %s", e.message))
  62             throw BluePrintException(e, e.message!!)
  63         }
  64
  65         return autoMapResponse
  66     }
  67
  68     private fun populateDictionaryMapping(dictionaryMap: Map<String, ResourceDictionary>, resourceAssignment: ResourceAssignment) {
  69         val dbDataDictionary = dictionaryMap[resourceAssignment.name]
  70         if (dbDataDictionary != null && dbDataDictionary.definition != null) {
  71
  72             val dictionaryDefinition = dbDataDictionary.definition
  73
  74             if (dictionaryDefinition != null && StringUtils.isNotBlank(dictionaryDefinition.name)
  75                     && StringUtils.isBlank(resourceAssignment.dictionaryName)) {
  76
  77                 resourceAssignment.dictionaryName = dbDataDictionary.name
  78                 ResourceDictionaryUtils.populateSourceMapping(resourceAssignment, dictionaryDefinition)
  79             }
  80         }
  81     }
  82
  83     private fun getDictionaryDefinitions(resourceAssignments: List<ResourceAssignment>): Map<String, ResourceDictionary> {
  84         val dictionaryMap = HashMap<String, ResourceDictionary>()
  85         val names = ArrayList<String>()
  86         for (resourceAssignment in resourceAssignments) {
  87             if (StringUtils.isNotBlank(resourceAssignment.name)) {
  88                 names.add(resourceAssignment.name)
  89             }
  90         }
  91         if (CollectionUtils.isNotEmpty(names)) {
  92
  93             val dictionaries = dataDictionaryRepository.findByNameIn(names)
  94             if (CollectionUtils.isNotEmpty(dictionaries)) {
  95                 for (dataDictionary in dictionaries) {
  96                     if (StringUtils.isNotBlank(dataDictionary.name)) {
  97                         dictionaryMap[dataDictionary.name] = dataDictionary
  98                     }
  99                 }
 100             }
 101         }
 102         return dictionaryMap
 103
 104     }
 105     private fun getDictionaryDefinitionsList(resourceAssignments: List<ResourceAssignment>): List<ResourceDictionary>? {
 106         var dictionaries: List<ResourceDictionary>? = null
 107         val names = ArrayList<String>()
 108         for (resourceAssignment in resourceAssignments) {
 109             if (StringUtils.isNotBlank(resourceAssignment.dictionaryName)) {
 110
 111                 if (!names.contains(resourceAssignment.dictionaryName)) {
 112                     names.add(resourceAssignment.dictionaryName!!)
 113                 }
 114
 115                 if (resourceAssignment.dependencies != null && !resourceAssignment.dependencies!!.isEmpty()) {
 116                     val dependencyNames = resourceAssignment.dependencies
 117                     for (dependencyName in dependencyNames!!) {
 118                         if (StringUtils.isNotBlank(dependencyName) && !names.contains(dependencyName)) {
 119                             names.add(dependencyName)
 120                         }
 121                     }
 122                 }
 123             }
 124         }
 125         if (CollectionUtils.isNotEmpty(names)) {
 126             dictionaries = dataDictionaryRepository.findByNameIn(names)
 127         }
 128         return dictionaries
 129
 130     }
 131
 132     private fun getAllAutoMapResourceAssignments(resourceAssignments: MutableList<ResourceAssignment>): List<ResourceAssignment> {
 133         var dictionaries: List<ResourceDictionary>? = null
 134         val names = ArrayList<String>()
 135         for (resourceAssignment in resourceAssignments) {
 136             if (StringUtils.isNotBlank(resourceAssignment.dictionaryName)) {
 137                 if (resourceAssignment.dependencies != null && !resourceAssignment.dependencies!!.isEmpty()) {
 138                     val dependencyNames = resourceAssignment.dependencies
 139                     for (dependencyName in dependencyNames!!) {
 140                         if (StringUtils.isNotBlank(dependencyName) && !names.contains(dependencyName)
 141                                 && !checkAssignmentsExists(resourceAssignments, dependencyName)) {
 142                             names.add(dependencyName)
 143                         }
 144                     }
 145                 }
 146             }
 147         }
 148
 149         if (!names.isEmpty()) {
 150             dictionaries = dataDictionaryRepository.findByNameIn(names)
 151         }
 152         if (dictionaries != null) {
 153             for (rscDictionary in dictionaries) {
 154                 val dictionaryDefinition = rscDictionary.definition
 155                 Preconditions.checkNotNull(dictionaryDefinition, "failed to get Resource Definition from dictionary definition")
 156                 val property = PropertyDefinition()
 157                 property.required = true
 158                 val resourceAssignment = ResourceAssignment()
 159                 resourceAssignment.name = rscDictionary.name
 160                 resourceAssignment.dictionaryName = rscDictionary.name
 161                 resourceAssignment.version = 0
 162                 resourceAssignment.property = property
 163                 ResourceDictionaryUtils.populateSourceMapping(resourceAssignment, dictionaryDefinition)
 164                 resourceAssignments.add(resourceAssignment)
 165             }
 166         }
 167         return resourceAssignments
 168     }
 169
 170
 171     private fun checkAssignmentsExists(resourceAssignmentsWithDepencies: List<ResourceAssignment>, resourceName: String): Boolean {
 172         return resourceAssignmentsWithDepencies.stream().anyMatch { names -> names.name.equals(resourceName, ignoreCase = true) }
 173     }
 174 }