Migrate "ms/controllerblueprints" from ccsdk/apps

Migrate code from ccsdk/apps ms/controllerblueprints
subfolder into ccsdk/cds

Issue-ID: CIMAN-245
Signed-off-by: Jessica Wagantall <jwagantall@linuxfoundation.org>

34 files changed, 3290 insertions, 0 deletions

diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoServiceImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoServiceImpl.kt
new file mode 100644
index 000000000..88589eb7d
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoServiceImpl.kt
@@ -0,0 +1,105 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.google.common.base.Preconditions
+import org.apache.commons.lang3.StringUtils
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ModelTypeRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ResourceDictionaryRepository
+import org.springframework.stereotype.Service
+
+interface ResourceDefinitionRepoService : BluePrintRepoService {
+
+    @Throws(BluePrintException::class)
+    fun getResourceDefinition(resourceDefinitionName: String): ResourceDefinition
+}
+
+@Service
+open class BluePrintRepoFileService(private val modelTypeRepository: ModelTypeRepository,
+                                    private val resourceDictionaryRepository: ResourceDictionaryRepository) : ResourceDefinitionRepoService {
+
+    @Throws(BluePrintException::class)
+    override fun getNodeType(nodeTypeName: String): NodeType {
+        return getModelType(nodeTypeName, NodeType::class.java)
+                ?: throw BluePrintException("couldn't get NodeType($nodeTypeName)")
+    }
+
+    @Throws(BluePrintException::class)
+    override fun getDataType(dataTypeName: String): DataType {
+        return getModelType(dataTypeName, DataType::class.java)
+                ?: throw BluePrintException("couldn't get DataType($dataTypeName)")
+    }
+
+    @Throws(BluePrintException::class)
+    override fun getArtifactType(artifactTypeName: String): ArtifactType {
+        return getModelType(artifactTypeName, ArtifactType::class.java)
+                ?: throw BluePrintException("couldn't get ArtifactType($artifactTypeName)")
+    }
+
+    @Throws(BluePrintException::class)
+    override fun getRelationshipType(relationshipTypeName: String): RelationshipType {
+        return getModelType(relationshipTypeName, RelationshipType::class.java)
+                ?: throw BluePrintException("couldn't get RelationshipType($relationshipTypeName)")
+    }
+
+    @Throws(BluePrintException::class)
+    override fun getCapabilityDefinition(capabilityDefinitionName: String): CapabilityDefinition {
+        return getModelType(capabilityDefinitionName, CapabilityDefinition::class.java)
+                ?: throw BluePrintException("couldn't get CapabilityDefinition($capabilityDefinitionName)")
+    }
+
+    @Throws(BluePrintException::class)
+    override fun getResourceDefinition(resourceDefinitionName: String): ResourceDefinition {
+        val dbResourceDictionary = resourceDictionaryRepository.findByName(resourceDefinitionName)
+        return if (dbResourceDictionary.isPresent) {
+            dbResourceDictionary.get().definition
+        } else {
+            throw BluePrintException(String.format("failed to get resource dictionary (%s) from repo", resourceDefinitionName))
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    private fun <T> getModelType(modelName: String, valueClass: Class<T>): T? {
+        Preconditions.checkArgument(StringUtils.isNotBlank(modelName),
+                "Failed to get model from repo, model name is missing")
+
+        val modelDefinition = getModelDefinition(modelName)
+        Preconditions.checkNotNull(modelDefinition,
+                String.format("Failed to get model content for model name (%s)", modelName))
+
+        return JacksonUtils.readValue(modelDefinition, valueClass)
+    }
+
+    @Throws(BluePrintException::class)
+    private fun getModelDefinition(modelName: String): JsonNode {
+        val modelDefinition: JsonNode
+        val modelTypeDb = modelTypeRepository.findByModelName(modelName)
+        if (modelTypeDb != null) {
+            modelDefinition = modelTypeDb.definition
+        } else {
+            throw BluePrintException(String.format("failed to get model definition (%s) from repo", modelName))
+        }
+        return modelDefinition
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/ControllerBluePrintCoreConfiguration.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/ControllerBluePrintCoreConfiguration.kt
new file mode 100644
index 000000000..2c4ee746a
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/ControllerBluePrintCoreConfiguration.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service
+
+import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.context.properties.bind.Bindable
+import org.springframework.boot.context.properties.bind.Binder
+import org.springframework.boot.context.properties.source.ConfigurationPropertySources
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.core.env.Environment
+import org.springframework.stereotype.Service
+
+@Configuration
+open class ControllerBluePrintCoreConfiguration(private val bluePrintProperties: ControllerBlueprintProperties) {
+
+    companion object {
+        const val PREFIX_BLUEPRINT_LOAD_CONFIGURATION = "controllerblueprints"
+    }
+
+    @Bean
+    open fun controlelrBlueprintLoadConfiguration(): BluePrintLoadConfiguration {
+        return bluePrintProperties
+                .propertyBeanType(PREFIX_BLUEPRINT_LOAD_CONFIGURATION, BluePrintLoadConfiguration::class.java)
+    }
+}
+
+@Configuration
+open class ControllerBlueprintPropertyConfiguration {
+    @Autowired
+    lateinit var environment: Environment
+
+    @Bean
+    open fun controllerBluePrintPropertyBinder(): Binder {
+        val configurationPropertySource = ConfigurationPropertySources.get(environment)
+        return Binder(configurationPropertySource)
+    }
+}
+
+@Service
+open class ControllerBlueprintProperties(var bluePrintPropertyBinder: Binder) {
+    fun <T> propertyBeanType(prefix: String, type: Class<T>): T {
+        return bluePrintPropertyBinder.bind(prefix, Bindable.of(type)).get()
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/BlueprintModelController.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/BlueprintModelController.kt
new file mode 100644
index 000000000..4974bcd12
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/BlueprintModelController.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright © 2019 Bell Canada Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.controller
+
+import kotlinx.coroutines.runBlocking
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModelSearch
+import org.onap.ccsdk.apps.controllerblueprints.service.handler.BluePrintModelHandler
+import org.springframework.core.io.Resource
+import org.springframework.http.MediaType
+import org.springframework.http.ResponseEntity
+import org.springframework.http.codec.multipart.FilePart
+import org.springframework.web.bind.annotation.*
+import reactor.core.publisher.Mono
+
+/**
+ * BlueprintModelController Purpose: Handle controllerBlueprint API request
+ *
+ * @author Vinal Patel
+ * @version 1.0
+ */
+@RestController
+@RequestMapping("/api/v1/blueprint-model")
+open class BlueprintModelController(private val bluePrintModelHandler: BluePrintModelHandler) {
+
+    @PostMapping("", produces = [MediaType.APPLICATION_JSON_VALUE], consumes = [MediaType.MULTIPART_FORM_DATA_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun saveBlueprint(@RequestPart("file") file: FilePart): Mono<BlueprintModelSearch> {
+        return bluePrintModelHandler.saveBlueprintModel(file)
+    }
+
+    @GetMapping("", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    fun allBlueprintModel(): List<BlueprintModelSearch> {
+        return this.bluePrintModelHandler.allBlueprintModel()
+    }
+
+    @DeleteMapping("/{id}")
+    @Throws(BluePrintException::class)
+    fun deleteBlueprint(@PathVariable(value = "id") id: String) {
+        this.bluePrintModelHandler.deleteBlueprintModel(id)
+    }
+
+    @GetMapping("/by-name/{name}/version/{version}", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun getBlueprintByNameAndVersion(@PathVariable(value = "name") name: String,
+                                     @PathVariable(value = "version") version: String): BlueprintModelSearch {
+        return this.bluePrintModelHandler.getBlueprintModelSearchByNameAndVersion(name, version)
+    }
+
+    @GetMapping("/download/by-name/{name}/version/{version}", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun downloadBlueprintByNameAndVersion(@PathVariable(value = "name") name: String,
+                                          @PathVariable(value = "version") version: String): ResponseEntity<Resource> {
+        return this.bluePrintModelHandler.downloadBlueprintModelFileByNameAndVersion(name, version)
+    }
+
+    @GetMapping("/{id}", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun getBlueprintModel(@PathVariable(value = "id") id: String): BlueprintModelSearch {
+        return this.bluePrintModelHandler.getBlueprintModelSearch(id)
+    }
+
+    @GetMapping("/download/{id}", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun downloadBluePrint(@PathVariable(value = "id") id: String): ResponseEntity<Resource> {
+        return this.bluePrintModelHandler.downloadBlueprintModelFile(id)
+    }
+
+    @PostMapping("/enrich", produces = [MediaType.APPLICATION_JSON_VALUE], consumes = [MediaType
+            .MULTIPART_FORM_DATA_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun enrichBlueprint(@RequestPart("file") file: FilePart): ResponseEntity<Resource> = runBlocking {
+        bluePrintModelHandler.enrichBlueprint(file)
+    }
+
+    @PostMapping("/publish", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun publishBlueprint(@RequestPart("file") file: FilePart): BlueprintModelSearch = runBlocking {
+        bluePrintModelHandler.publishBlueprint(file)
+    }
+
+    @GetMapping("/search/{tags}", produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    fun searchBlueprintModels(@PathVariable(value = "tags") tags: String): List<BlueprintModelSearch> {
+        return this.bluePrintModelHandler.searchBlueprintModels(tags)
+    }
+}
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ControllerBlueprintExeptionHandler.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ControllerBlueprintExeptionHandler.kt
new file mode 100644
index 000000000..04753391f
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ControllerBlueprintExeptionHandler.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2018-2019 Bell Canada Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.controller
+
+import org.springframework.web.bind.annotation.RestControllerAdvice
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.data.ErrorCode
+import org.onap.ccsdk.apps.controllerblueprints.service.common.ErrorMessage
+import org.springframework.http.HttpStatus
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.ExceptionHandler
+
+/**
+ * ControllerBlueprintExceptionHandler Purpose: Handle exceptions in controllerBlueprint API and provide the right
+ * HTTP code status
+ *
+ * @author Vinal Patel
+ * @version 1.0
+ */
+@RestControllerAdvice("org.onap.ccsdk.apps.controllerblueprints")
+open class ControllerBlueprintExeptionHandler {
+
+    @ExceptionHandler
+    fun ControllerBlueprintException(e: BluePrintException): ResponseEntity<ErrorMessage> {
+        var errorCode = ErrorCode.valueOf(e.code)
+        val errorMessage = ErrorMessage(errorCode?.message(e.message!!), errorCode?.value, "ControllerBluePrint_Error_Message")
+        return ResponseEntity(errorMessage, HttpStatus.resolve(errorCode!!.httpCode))
+    }
+
+    @ExceptionHandler
+    fun ControllerBlueprintException(e: Exception): ResponseEntity<ErrorMessage> {
+        var errorCode = ErrorCode.GENERIC_FAILURE
+        val errorMessage = ErrorMessage(errorCode?.message(e.message!!), errorCode?.value, "ControllerBluePrint_Error_Message")
+        return ResponseEntity(errorMessage, HttpStatus.resolve(errorCode!!.httpCode))
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ModelTypeController.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ModelTypeController.kt
new file mode 100644
index 000000000..db82849e8
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ModelTypeController.kt
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.controller
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+import org.onap.ccsdk.apps.controllerblueprints.service.handler.ModelTypeHandler
+import org.springframework.http.MediaType
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping(value = arrayOf("/api/v1/model-type"))
+open class ModelTypeController(private val modelTypeHandler: ModelTypeHandler) {
+
+    @GetMapping(path = arrayOf("/{name}"), produces = arrayOf(MediaType.APPLICATION_JSON_VALUE))
+    fun getModelTypeByName(@PathVariable(value = "name") name: String): ModelType? {
+        return modelTypeHandler.getModelTypeByName(name)
+    }
+
+    @GetMapping(path = arrayOf("/search/{tags}"), produces = arrayOf(MediaType.APPLICATION_JSON_VALUE))
+    fun searchModelTypes(@PathVariable(value = "tags") tags: String): List<ModelType> {
+        return modelTypeHandler.searchModelTypes(tags)
+    }
+
+    @GetMapping(path = arrayOf("/by-definition/{definitionType}"), produces = arrayOf(MediaType.APPLICATION_JSON_VALUE))
+    @ResponseBody
+    fun getModelTypeByDefinitionType(@PathVariable(value = "definitionType") definitionType: String): List<ModelType> {
+        return modelTypeHandler.getModelTypeByDefinitionType(definitionType)
+    }
+
+    @PostMapping(path = arrayOf(""), produces = arrayOf(MediaType.APPLICATION_JSON_VALUE), consumes = arrayOf(MediaType.APPLICATION_JSON_VALUE))
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun saveModelType(@RequestBody modelType: ModelType): ModelType {
+        return modelTypeHandler.saveModel(modelType)
+    }
+
+    @DeleteMapping(path = arrayOf("/{name}"))
+    fun deleteModelTypeByName(@PathVariable(value = "name") name: String) {
+        modelTypeHandler.deleteByModelName(name)
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ResourceDictionaryController.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ResourceDictionaryController.kt
new file mode 100644
index 000000000..38397faa0
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/controller/ResourceDictionaryController.kt
@@ -0,0 +1,68 @@
+/*
+ *  Copyright © 2019 IBM.
+ *
+ *  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.onap.ccsdk.apps.controllerblueprints.service.controller
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceSourceMapping
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary
+import org.onap.ccsdk.apps.controllerblueprints.service.handler.ResourceDictionaryHandler
+import org.springframework.http.MediaType
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping(value = ["/api/v1/dictionary"])
+open class ResourceDictionaryController(private val resourceDictionaryHandler: ResourceDictionaryHandler) {
+
+    @GetMapping(path = ["/{name}"], produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun getResourceDictionaryByName(@PathVariable(value = "name") name: String): ResourceDictionary {
+        return resourceDictionaryHandler.getResourceDictionaryByName(name)
+    }
+
+    @PostMapping(path = [""], produces = [MediaType.APPLICATION_JSON_VALUE], consumes = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    @Throws(BluePrintException::class)
+    fun saveResourceDictionary(@RequestBody dataDictionary: ResourceDictionary): ResourceDictionary {
+        return resourceDictionaryHandler.saveResourceDictionary(dataDictionary)
+    }
+
+    @DeleteMapping(path = ["/{name}"])
+    fun deleteResourceDictionaryByName(@PathVariable(value = "name") name: String) {
+        resourceDictionaryHandler.deleteResourceDictionary(name)
+    }
+
+    @PostMapping(path = ["/by-names"], produces = [MediaType.APPLICATION_JSON_VALUE], consumes = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    fun searchResourceDictionaryByNames(@RequestBody names: List<String>): List<ResourceDictionary> {
+        return resourceDictionaryHandler.searchResourceDictionaryByNames(names)
+    }
+
+    @GetMapping(path = ["/search/{tags}"], produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    fun searchResourceDictionaryByTags(@PathVariable(value = "tags") tags: String): List<ResourceDictionary> {
+        return resourceDictionaryHandler.searchResourceDictionaryByTags(tags)
+
+    }
+
+    @GetMapping(path = ["/source-mapping"], produces = [MediaType.APPLICATION_JSON_VALUE])
+    @ResponseBody
+    fun getResourceSourceMapping(): ResourceSourceMapping {
+        return resourceDictionaryHandler.getResourceSourceMapping()
+    }
+
+}
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintArtifactDefinitionEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintArtifactDefinitionEnhancerImpl.kt
new file mode 100644
index 000000000..3b14d82ff
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintArtifactDefinitionEnhancerImpl.kt
@@ -0,0 +1,93 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.apps.controllerblueprints.core.asJsonPrimitive
+import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.stereotype.Service
+
+@Service
+open class BluePrintArtifactDefinitionEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                                   private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+                                                   private val resourceAssignmentEnhancerService: ResourceAssignmentEnhancerService)
+    : BluePrintArtifactDefinitionEnhancer {
+
+    companion object {
+        const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
+    }
+
+
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintArtifactDefinitionEnhancerImpl::class.toString())
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, artifactDefinition: ArtifactDefinition) {
+        log.info("enhancing ArtifactDefinition($name)")
+
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        val artifactTypeName = artifactDefinition.type
+                ?: throw BluePrintException("artifact type is missing for ArtifactDefinition($name)")
+
+        // Populate Artifact Type
+        BluePrintEnhancerUtils.populateArtifactType(bluePrintContext, bluePrintRepoService, artifactTypeName)
+
+        when (artifactTypeName) {
+            ARTIFACT_TYPE_MAPPING_SOURCE -> {
+                enhanceMappingType(name, artifactDefinition)
+            }
+        }
+    }
+
+    // Enhance Resource Mapping
+    open fun enhanceMappingType(name: String, artifactDefinition: ArtifactDefinition) {
+
+        val artifactFilePath = "${bluePrintContext.rootPath}/${artifactDefinition.file}"
+
+        val alreadyEnhancedKey = "enhanced-${artifactDefinition.file}"
+        val alreadyEnhanced = bluePrintRuntimeService.check(alreadyEnhancedKey)
+
+        log.info("enhancing resource mapping file(${artifactDefinition.file}) already enhanced($alreadyEnhanced)")
+
+        if (!alreadyEnhanced) {
+            val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromFile(artifactFilePath, ResourceAssignment::class.java)
+                    as? MutableList<ResourceAssignment>
+                    ?: throw BluePrintProcessorException("couldn't get ResourceAssignment definitions for the file($artifactFilePath)")
+
+            // Call Resource Assignment Enhancer
+            resourceAssignmentEnhancerService.enhanceBluePrint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
+
+            bluePrintRuntimeService.put(alreadyEnhancedKey, true.asJsonPrimitive())
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintAttributeDefinitionEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintAttributeDefinitionEnhancerImpl.kt
new file mode 100644
index 000000000..f69e344f8
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintAttributeDefinitionEnhancerImpl.kt
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.data.AttributeDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+
+class BluePrintAttributeDefinitionEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                               private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+    : BluePrintAttributeDefinitionEnhancer {
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, attributeDefinition: AttributeDefinition) {
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        val propertyType = attributeDefinition.type
+        if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {
+
+        } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+            val entrySchema = attributeDefinition.entrySchema
+                    ?: throw BluePrintException("Entry Schema is missing for collection property($name)")
+
+            if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
+                BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
+            }
+        } else {
+            BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerServiceImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerServiceImpl.kt
new file mode 100644
index 000000000..da755d166
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerServiceImpl.kt
@@ -0,0 +1,80 @@
+/*

+ * Copyright © 2017-2018 AT&T Intellectual Property.

+ * Modifications Copyright © 2018 IBM.

+ *

+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer

+

+import com.att.eelf.configuration.EELFLogger

+import com.att.eelf.configuration.EELFManager

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException

+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintEnhancerService

+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService

+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext

+import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintFileUtils

+import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintMetadataUtils

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.ResourceDictionaryUtils

+import org.springframework.stereotype.Service

+import java.util.*

+

+@Service

+open class BluePrintEnhancerServiceImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,

+                                        private val resourceDefinitionEnhancerService: ResourceDefinitionEnhancerService) : BluePrintEnhancerService {

+

+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerServiceImpl::class.toString())

+

+    override suspend fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext {

+

+        // Copy the Blueprint Content to Target Location

+        BluePrintFileUtils.copyBluePrint(basePath, enrichedBasePath)

+

+        // Enhance the Blueprint

+        return enhance(enrichedBasePath)

+    }

+

+    @Throws(BluePrintException::class)

+    override suspend fun enhance(basePath: String): BluePrintContext {

+

+        log.info("Enhancing blueprint($basePath)")

+        val blueprintRuntimeService = BluePrintMetadataUtils

+                .getBaseEnhancementBluePrintRuntime(UUID.randomUUID().toString(), basePath)

+

+        try {

+

+            bluePrintTypeEnhancerService.enhanceServiceTemplate(blueprintRuntimeService, "service_template",

+                    blueprintRuntimeService.bluePrintContext().serviceTemplate)

+

+            log.info("##### Enhancing blueprint Resource Definitions")

+            val resourceDefinitions = resourceDefinitionEnhancerService.enhance(bluePrintTypeEnhancerService,

+                    blueprintRuntimeService)

+

+            // Write the Enhanced Blueprint Definitions

+            BluePrintFileUtils.writeEnhancedBluePrint(blueprintRuntimeService.bluePrintContext())

+

+            // Write the Enhanced Blueprint Resource Definitions

+            ResourceDictionaryUtils.writeResourceDefinitionTypes(basePath, resourceDefinitions)

+

+            if (blueprintRuntimeService.getBluePrintError().errors.isNotEmpty()) {

+                throw BluePrintException(blueprintRuntimeService.getBluePrintError().errors.toString())

+            }

+

+        } catch (e: Exception) {

+            throw e

+        }

+        return blueprintRuntimeService.bluePrintContext()

+    }

+

+}

+

diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTemplateEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTemplateEnhancerImpl.kt
new file mode 100644
index 000000000..0765f9035
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTemplateEnhancerImpl.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeTemplate
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintNodeTemplateEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintNodeTemplateEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                             private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+    : BluePrintNodeTemplateEnhancer {
+
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintNodeTemplateEnhancerImpl::class.toString())
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
+        log.info("***** Enhancing NodeTemplate($name)")
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+
+        val nodeTypeName = nodeTemplate.type
+        // Get NodeType from Repo and Update Service Template
+        val nodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, nodeTypeName)
+
+        // Enrich NodeType
+        bluePrintTypeEnhancerService.enhanceNodeType(bluePrintRuntimeService, nodeTypeName, nodeType)
+
+        //Enrich Node Template Artifacts
+        enhanceNodeTemplateArtifactDefinition(name, nodeTemplate)
+    }
+
+    open fun enhanceNodeTemplateArtifactDefinition(nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+
+        nodeTemplate.artifacts?.forEach { artifactDefinitionName, artifactDefinition ->
+            // Enhance Artifacct Definitions
+            bluePrintTypeEnhancerService.enhanceArtifactDefinition(bluePrintRuntimeService, artifactDefinitionName, artifactDefinition)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTypeEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTypeEnhancerImpl.kt
new file mode 100644
index 000000000..6ff0b39be
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintNodeTypeEnhancerImpl.kt
@@ -0,0 +1,154 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.data.InterfaceDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
+import org.onap.ccsdk.apps.controllerblueprints.core.data.OperationDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintNodeTypeEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintNodeTypeEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                         private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService) : BluePrintNodeTypeEnhancer {
+
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintNodeTypeEnhancerImpl::class.toString())
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeType: NodeType) {
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+
+        val derivedFrom = nodeType.derivedFrom
+
+        if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
+            val derivedFromNodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, name)
+            // Enrich NodeType
+            enhance(bluePrintRuntimeService, derivedFrom, derivedFromNodeType)
+        }
+
+        // NodeType Attribute Definitions
+        enrichNodeTypeAttributes(name, nodeType)
+
+        // NodeType Property Definitions
+        enrichNodeTypeProperties(name, nodeType)
+
+        //NodeType Requirement
+        enrichNodeTypeRequirements(name, nodeType)
+
+        //NodeType Capability
+        enrichNodeTypeCapabilityProperties(name, nodeType)
+
+        //NodeType Interface
+        enrichNodeTypeInterfaces(name, nodeType)
+
+    }
+
+    open fun enrichNodeTypeAttributes(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.attributes?.let {
+            bluePrintTypeEnhancerService.enhanceAttributeDefinitions(bluePrintRuntimeService, nodeType.attributes!!)
+        }
+    }
+
+    open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.properties?.let {
+            bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, nodeType.properties!!)
+        }
+    }
+
+    open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {
+
+        nodeType.requirements?.forEach { requirementName, requirementDefinition ->
+            // Populate Requirement Node
+            requirementDefinition.node?.let { requirementNodeTypeName ->
+                // Get Requirement NodeType from Repo and Update Service Template
+                val requirementNodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext,
+                        bluePrintRepoService, requirementNodeTypeName)
+                // Enhance Node Type
+                enhance(bluePrintRuntimeService, requirementNodeTypeName, requirementNodeType)
+
+                // Enhance Relationship Type
+                val relationShipTypeName = requirementDefinition.relationship
+                        ?: throw BluePrintException("couldn't get relationship name for the NodeType($nodeTypeName) " +
+                                "Requirement($requirementName)")
+                enrichRelationShipType(relationShipTypeName)
+            }
+        }
+    }
+
+    open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.capabilities?.forEach { _, capabilityDefinition ->
+            capabilityDefinition.properties?.let { properties ->
+                bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, properties)
+            }
+        }
+    }
+
+    open fun enrichNodeTypeInterfaces(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.interfaces?.forEach { interfaceName, interfaceObj ->
+            // Populate Node type Interface Operation
+            log.debug("Enriching NodeType({}) Interface({})", nodeTypeName, interfaceName)
+            populateNodeTypeInterfaceOperation(nodeTypeName, interfaceName, interfaceObj)
+
+        }
+    }
+
+    open fun populateNodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, interfaceObj: InterfaceDefinition) {
+
+        interfaceObj.operations?.forEach { operationName, operation ->
+            enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)
+            enrichNodeTypeInterfaceOperationOutputs(nodeTypeName, operationName, operation)
+        }
+    }
+
+    open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {
+        operation.inputs?.let { inputs ->
+            bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, inputs)
+        }
+    }
+
+    open fun enrichNodeTypeInterfaceOperationOutputs(nodeTypeName: String, operationName: String,
+                                                     operation: OperationDefinition) {
+        operation.outputs?.let { inputs ->
+            bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, inputs)
+        }
+    }
+
+    /**
+     * Get the Relationship Type from database and add to Blueprint Context
+     */
+    open fun enrichRelationShipType(relationshipName: String) {
+        BluePrintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, relationshipName)
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPolicyTypeEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPolicyTypeEnhancerImpl.kt
new file mode 100644
index 000000000..80a84fcde
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPolicyTypeEnhancerImpl.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import org.onap.ccsdk.apps.controllerblueprints.core.data.PolicyType
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintPolicyTypeEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+class BluePrintPolicyTypeEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                      private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+    : BluePrintPolicyTypeEnhancer {
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: PolicyType) {
+
+       this.bluePrintRuntimeService = bluePrintRuntimeService
+
+        // TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPropertyDefinitionEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPropertyDefinitionEnhancerImpl.kt
new file mode 100644
index 000000000..1675e8cd2
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintPropertyDefinitionEnhancerImpl.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.data.PropertyDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintPropertyDefinitionEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                                   private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+    : BluePrintPropertyDefinitionEnhancer {
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        val propertyType = propertyDefinition.type
+        if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)
+                || BluePrintTypes.validComplexTypes().contains(propertyType)) {
+            // Do Nothing,
+        } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+            val entrySchema = propertyDefinition.entrySchema
+                    ?: throw BluePrintException("Entry Schema is missing for collection property($name)")
+
+            if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
+                BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
+            }
+        } else {
+            BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintServiceTemplateEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintServiceTemplateEnhancerImpl.kt
new file mode 100644
index 000000000..8c269e546
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintServiceTemplateEnhancerImpl.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.data.ServiceTemplate
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintServiceTemplateEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintServiceTemplateEnhancerImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+    : BluePrintServiceTemplateEnhancer {
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateEnhancerImpl::class.toString())
+
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: ServiceTemplate) {
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        initialCleanUp()
+        enhanceTopologyTemplate()
+    }
+
+    open fun initialCleanUp() {
+        bluePrintContext.serviceTemplate.artifactTypes?.clear()
+        bluePrintContext.serviceTemplate.nodeTypes?.clear()
+        bluePrintContext.serviceTemplate.dataTypes?.clear()
+        bluePrintContext.serviceTemplate.policyTypes?.clear()
+        bluePrintContext.serviceTemplate.relationshipTypes?.clear()
+
+        bluePrintContext.serviceTemplate.artifactTypes = mutableMapOf()
+        bluePrintContext.serviceTemplate.nodeTypes = mutableMapOf()
+        bluePrintContext.serviceTemplate.dataTypes = mutableMapOf()
+        bluePrintContext.serviceTemplate.policyTypes = mutableMapOf()
+        bluePrintContext.serviceTemplate.relationshipTypes = mutableMapOf()
+        log.info("reinitialized all type definitions")
+
+    }
+
+    open fun enhanceTopologyTemplate() {
+        bluePrintContext.serviceTemplate.topologyTemplate?.let { topologyTemplate ->
+            bluePrintTypeEnhancerService.enhanceTopologyTemplate(bluePrintRuntimeService, "topology_template", topologyTemplate)
+        }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTopologyTemplateEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTopologyTemplateEnhancerImpl.kt
new file mode 100644
index 000000000..428d490b5
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTopologyTemplateEnhancerImpl.kt
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import org.onap.ccsdk.apps.controllerblueprints.core.data.TopologyTemplate
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTopologyTemplateEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintTopologyTemplateEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                                 private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService) : BluePrintTopologyTemplateEnhancer {
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: TopologyTemplate) {
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+
+        enhanceTopologyTemplateInputs(type)
+        enhanceTopologyTemplateNodeTemplates(type)
+        enhanceTopologyTemplateWorkflows(type)
+    }
+
+    open fun enhanceTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {
+        topologyTemplate.inputs?.let { inputs ->
+            bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, inputs)
+        }
+    }
+
+    open fun enhanceTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {
+        topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->
+            bluePrintTypeEnhancerService.enhanceNodeTemplate(bluePrintRuntimeService, nodeTemplateName, nodeTemplate)
+        }
+    }
+
+    open fun enhanceTopologyTemplateWorkflows(topologyTemplate: TopologyTemplate) {
+        topologyTemplate.workflows?.forEach { workflowName, workflow ->
+            bluePrintTypeEnhancerService.enhanceWorkflow(bluePrintRuntimeService, workflowName, workflow)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTypeEnhancerServiceImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTypeEnhancerServiceImpl.kt
new file mode 100644
index 000000000..02a19c3fc
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintTypeEnhancerServiceImpl.kt
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.*
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.ApplicationContext
+import org.springframework.stereotype.Service
+
+@Service
+open class BluePrintTypeEnhancerServiceImpl : BluePrintTypeEnhancerService {
+
+    @Autowired
+    private lateinit var context: ApplicationContext
+
+    override fun getServiceTemplateEnhancers(): List<BluePrintServiceTemplateEnhancer> {
+        return context.getBeansOfType(BluePrintServiceTemplateEnhancer::class.java).map { it.value }
+    }
+
+    override fun getTopologyTemplateEnhancers(): List<BluePrintTopologyTemplateEnhancer> {
+        return context.getBeansOfType(BluePrintTopologyTemplateEnhancer::class.java).map { it.value }
+    }
+
+    override fun getWorkflowEnhancers(): List<BluePrintWorkflowEnhancer> {
+        return context.getBeansOfType(BluePrintWorkflowEnhancer::class.java).map { it.value }
+    }
+
+    override fun getNodeTemplateEnhancers(): List<BluePrintNodeTemplateEnhancer> {
+        return context.getBeansOfType(BluePrintNodeTemplateEnhancer::class.java).map { it.value }
+    }
+
+    override fun getNodeTypeEnhancers(): List<BluePrintNodeTypeEnhancer> {
+        return context.getBeansOfType(BluePrintNodeTypeEnhancer::class.java).map { it.value }
+    }
+
+    override fun getArtifactDefinitionEnhancers(): List<BluePrintArtifactDefinitionEnhancer> {
+        return context.getBeansOfType(BluePrintArtifactDefinitionEnhancer::class.java).map { it.value }
+    }
+
+    override fun getPolicyTypeEnhancers(): List<BluePrintPolicyTypeEnhancer> {
+        return context.getBeansOfType(BluePrintPolicyTypeEnhancer::class.java).map { it.value }
+    }
+
+    override fun getPropertyDefinitionEnhancers(): List<BluePrintPropertyDefinitionEnhancer> {
+        return context.getBeansOfType(BluePrintPropertyDefinitionEnhancer::class.java).map { it.value }
+    }
+
+    override fun getAttributeDefinitionEnhancers(): List<BluePrintAttributeDefinitionEnhancer> {
+        return context.getBeansOfType(BluePrintAttributeDefinitionEnhancer::class.java).map { it.value }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintWorkflowEnhancerImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintWorkflowEnhancerImpl.kt
new file mode 100644
index 000000000..fc9ee5045
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintWorkflowEnhancerImpl.kt
@@ -0,0 +1,214 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.apps.controllerblueprints.core.asJsonPrimitive
+import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType
+import org.onap.ccsdk.apps.controllerblueprints.core.data.PropertyDefinition
+import org.onap.ccsdk.apps.controllerblueprints.core.data.Workflow
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintWorkflowEnhancer
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintWorkflowEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
+                                         private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+                                         private val resourceAssignmentEnhancerService: ResourceAssignmentEnhancerService)
+    : BluePrintWorkflowEnhancer {
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintWorkflowEnhancerImpl::class.toString())
+
+    companion object {
+        const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
+        const val PROPERTY_DEPENDENCY_NODE_TEMPLATES = "dependency-node-templates"
+    }
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+
+    private val workflowDataTypes: MutableMap<String, DataType> = hashMapOf()
+
+    override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, workflow: Workflow) {
+        log.info("##### Enhancing Workflow($name)")
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        val dynamicPropertyName = "$name-properties"
+        if (workflow.inputs == null) {
+            workflow.inputs = hashMapOf()
+        }
+        // Clean Dynamic Property Field, If present
+        workflow.inputs?.remove(dynamicPropertyName)
+
+        // Enrich Only for Resource Assignment and Dynamic Input Properties if any
+        enhanceStepTargets(name, workflow)
+
+        // Enrich Workflow Inputs
+        enhanceWorkflowInputs(name, workflow)
+    }
+
+    open fun enhanceWorkflowInputs(name: String, workflow: Workflow) {
+
+        workflow.inputs?.let { inputs ->
+            bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, inputs)
+        }
+    }
+
+    private fun enhanceStepTargets(name: String, workflow: Workflow) {
+
+        // Get the first Step Target NodeTemplate name( It may be Component or DG Node Template)
+        val firstNodeTemplateName = bluePrintContext.workflowFirstStepNodeTemplate(name)
+
+        val derivedFrom = bluePrintContext.nodeTemplateNodeType(firstNodeTemplateName).derivedFrom
+
+        when {
+            derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_COMPONENT, true) -> {
+                // DO Nothing
+            }
+            derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_DG, true) -> {
+                enhanceDGStepTargets(name, workflow, firstNodeTemplateName)
+            }
+            else -> {
+                throw BluePrintProcessorException("couldn't execute workflow($name) step mapped " +
+                        "to node template($firstNodeTemplateName) derived from($derivedFrom)")
+            }
+        }
+
+    }
+
+    private fun enhanceDGStepTargets(name: String, workflow: Workflow, dgNodeTemplateName: String) {
+
+        val dgNodeTemplate = bluePrintContext.nodeTemplateByName(dgNodeTemplateName)
+
+        // Get the Dependent Component Node Template Names
+        val dependencyNodeTemplateNodes = dgNodeTemplate.properties?.get(PROPERTY_DEPENDENCY_NODE_TEMPLATES)
+                ?: throw BluePrintException("couldn't get property($PROPERTY_DEPENDENCY_NODE_TEMPLATES) ")
+
+        val dependencyNodeTemplates = JacksonUtils.getListFromJsonNode(dependencyNodeTemplateNodes, String::class.java)
+
+        log.info("workflow($name) dependent component NodeTemplates($dependencyNodeTemplates)")
+
+        // Check and Get Resource Assignment File
+        val resourceAssignmentArtifacts = dependencyNodeTemplates?.mapNotNull { componentNodeTemplateName ->
+            log.info("identified workflow($name) targets($componentNodeTemplateName)")
+
+            val resourceAssignmentArtifacts = bluePrintContext.nodeTemplateByName(componentNodeTemplateName)
+                    .artifacts?.filter {
+                it.value.type == ARTIFACT_TYPE_MAPPING_SOURCE
+            }?.map {
+                log.info("resource assignment artifacts(${it.key}) for NodeType(${componentNodeTemplateName})")
+                it.value.file
+            }
+            resourceAssignmentArtifacts
+        }?.flatten()
+
+        log.info("workflow($name) resource assignment files($resourceAssignmentArtifacts")
+
+        if (resourceAssignmentArtifacts != null && resourceAssignmentArtifacts.isNotEmpty()) {
+
+            // Add Workflow Dynamic Property
+            addWorkFlowDynamicPropertyDefinitions(name, workflow)
+
+            resourceAssignmentArtifacts.forEach { fileName ->
+                // Enhance Resource Assignment File
+                val resourceAssignmentProperties = enhanceResourceAssignmentFile(fileName!!)
+                // Add Workflow Dynamic DataType
+                addWorkFlowDynamicDataType(name, resourceAssignmentProperties)
+            }
+        }
+    }
+
+    // Enhancement for Dynamic Properties, Resource Assignment Properties, Resource Sources
+    private fun enhanceResourceAssignmentFile(fileName: String): MutableMap<String, PropertyDefinition> {
+
+        val filePath = "${bluePrintContext.rootPath}/$fileName"
+
+        log.info("enriching artifacts file(${filePath}")
+
+        val resourceAssignmentProperties: MutableMap<String, PropertyDefinition> = hashMapOf()
+
+        val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromFile(filePath, ResourceAssignment::class.java)
+                as? MutableList<ResourceAssignment>
+                ?: throw BluePrintProcessorException("couldn't get ResourceAssignment definitions for the file($filePath)")
+
+        val alreadyEnhancedKey = "enhanced-$fileName"
+        val alreadyEnhanced = bluePrintRuntimeService.check(alreadyEnhancedKey)
+
+        log.info("enhancing workflow resource mapping file($fileName) already enhanced($alreadyEnhanced)")
+
+        if (!alreadyEnhanced) {
+            // Call Resource Assignment Enhancer
+            resourceAssignmentEnhancerService.enhanceBluePrint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
+            bluePrintRuntimeService.put(alreadyEnhancedKey, true.asJsonPrimitive())
+        }
+
+        resourceAssignments.forEach { resourceAssignment ->
+            resourceAssignmentProperties[resourceAssignment.name] = resourceAssignment.property!!
+        }
+        return resourceAssignmentProperties
+    }
+
+    private fun addWorkFlowDynamicPropertyDefinitions(name: String, workflow: Workflow) {
+        val dynamicPropertyName = "$name-properties"
+        val propertyDefinition = PropertyDefinition()
+        propertyDefinition.description = "Dynamic PropertyDefinition for workflow($name)."
+        propertyDefinition.type = "dt-$dynamicPropertyName"
+        propertyDefinition.required = true
+        // Add to Workflow Inputs
+        workflow.inputs?.put(dynamicPropertyName, propertyDefinition)
+    }
+
+    private fun addWorkFlowDynamicDataType(workflowName: String, mappingProperties: MutableMap<String, PropertyDefinition>) {
+
+        val dataTypeName = "dt-$workflowName-properties"
+
+        var dynamicDataType: DataType? = bluePrintContext.serviceTemplate.dataTypes?.get(dataTypeName)
+
+        if (dynamicDataType == null) {
+            log.info("dataType not present for the recipe({})", dataTypeName)
+            dynamicDataType = DataType()
+            dynamicDataType.version = "1.0.0"
+            dynamicDataType.description = "Dynamic DataType definition for workflow($workflowName)."
+            dynamicDataType.derivedFrom = BluePrintConstants.MODEL_TYPE_DATA_TYPE_DYNAMIC
+
+            val dataTypeProperties: MutableMap<String, PropertyDefinition> = hashMapOf()
+            dynamicDataType.properties = dataTypeProperties
+
+            // Overwrite WorkFlow DataType
+            bluePrintContext.serviceTemplate.dataTypes?.put(dataTypeName, dynamicDataType)
+
+        } else {
+            log.info("dynamic dataType($dataTypeName) already present for workflow($workflowName).")
+        }
+        // Merge all the Recipe Properties
+        mappingProperties.forEach { propertyName, propertyDefinition ->
+            dynamicDataType.properties?.put(propertyName, propertyDefinition)
+        }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt
new file mode 100644
index 000000000..4d1f44a6a
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt
@@ -0,0 +1,111 @@
+/*

+ *  Copyright © 2017-2018 AT&T Intellectual Property.

+ *

+ *  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.onap.ccsdk.apps.controllerblueprints.service.enhancer

+

+import com.att.eelf.configuration.EELFLogger

+import com.att.eelf.configuration.EELFManager

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes

+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService

+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDictionaryConstants

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.factory.ResourceSourceMappingFactory

+import org.onap.ccsdk.apps.controllerblueprints.service.ResourceDefinitionRepoService

+import org.springframework.beans.factory.config.ConfigurableBeanFactory

+import org.springframework.context.annotation.Scope

+import org.springframework.stereotype.Service

+

+/**

+ * ResourceAssignmentEnhancerService.

+ *

+ * @author Brinda Santh

+ */

+interface ResourceAssignmentEnhancerService {

+

+    @Throws(BluePrintException::class)

+    fun enhanceBluePrint(bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,

+                         bluePrintRuntimeService: BluePrintRuntimeService<*>,

+                         resourceAssignments: List<ResourceAssignment>)

+}

+

+/**

+ * ResourceAssignmentEnhancerDefaultService.

+ *

+ * @author Brinda Santh

+ */

+@Service

+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)

+open class ResourceAssignmentEnhancerServiceImpl(private val resourceDefinitionRepoService: ResourceDefinitionRepoService)

+    : ResourceAssignmentEnhancerService {

+    private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentEnhancerServiceImpl::class.java)

+

+    /**

+     * Get the defined source instance from the ResourceAssignment,

+     * then get the NodeType of the Sources assigned

+     */

+    override fun enhanceBluePrint(bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,

+                                  bluePrintRuntimeService: BluePrintRuntimeService<*>,

+                                  resourceAssignments: List<ResourceAssignment>) {

+

+        val uniqueSourceNodeTypeNames = hashSetOf<String>()

+

+        // Iterate the Resource Assignment and

+        resourceAssignments.map { resourceAssignment ->

+            val dictionaryName = resourceAssignment.dictionaryName!!

+            val dictionarySource = resourceAssignment.dictionarySource!!

+            log.debug("Enriching assignment name(${resourceAssignment.name}), dictionary name($dictionaryName), source($dictionarySource)")

+            val sourceNodeTypeName = ResourceSourceMappingFactory.getRegisterSourceMapping(dictionarySource)

+

+            // Add Unique Node Types

+            uniqueSourceNodeTypeNames.add(sourceNodeTypeName)

+

+            // TODO("Candidate for Optimisation")

+            if (checkResourceDefinitionNeeded(resourceAssignment)) {

+

+                bluePrintTypeEnhancerService.enhancePropertyDefinition(bluePrintRuntimeService, resourceAssignment.name,

+                        resourceAssignment.property!!);

+

+                // Get the Resource Definition from Repo

+                val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)

+

+                val sourceNodeTemplate = resourceDefinition.sources.get(dictionarySource)

+                        ?: throw BluePrintException("failed to get assigned dictionarySource($dictionarySource) from resourceDefinition($dictionaryName)")

+

+                // Enrich as NodeTemplate

+                bluePrintTypeEnhancerService.enhanceNodeTemplate(bluePrintRuntimeService, dictionarySource, sourceNodeTemplate)

+            }

+        }

+        // Enrich the ResourceSource NodeTypes

+        uniqueSourceNodeTypeNames.map { nodeTypeName ->

+            val nodeType = resourceDefinitionRepoService.getNodeType(nodeTypeName)

+            bluePrintTypeEnhancerService.enhanceNodeType(bluePrintRuntimeService, nodeTypeName, nodeType)

+        }

+

+    }

+

+    private fun checkResourceDefinitionNeeded(resourceAssignment: ResourceAssignment): Boolean {

+        return !((resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_INPUT)

+                || resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_DEFAULT))

+                && BluePrintTypes.validPrimitiveOrCollectionPrimitive(resourceAssignment.property!!))

+    }

+

+    private fun getResourceDefinition(name: String): ResourceDefinition {

+        return resourceDefinitionRepoService.getResourceDefinition(name)

+    }

+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceDefinitionEnhancerService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceDefinitionEnhancerService.kt
new file mode 100644
index 000000000..816b35664
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceDefinitionEnhancerService.kt
@@ -0,0 +1,145 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2018 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.ResourceDictionaryUtils
+import org.onap.ccsdk.apps.controllerblueprints.service.ResourceDefinitionRepoService
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.stereotype.Service
+
+interface ResourceDefinitionEnhancerService {
+
+    @Throws(BluePrintException::class)
+    fun enhance(bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+                bluePrintRuntimeService: BluePrintRuntimeService<*>): List<ResourceDefinition>
+}
+
+@Service
+class ResourceDefinitionEnhancerServiceImpl(private val resourceDefinitionRepoService: ResourceDefinitionRepoService) :
+        ResourceDefinitionEnhancerService {
+
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceDefinitionEnhancerService::class.toString())
+
+    companion object {
+        const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
+    }
+
+    // Enhance the Resource Definition
+    // 1. Get the Resource Mapping files from all NodeTemplates.
+    // 2. Get all the Unique Resource assignments from all mapping files
+    // 3. Collect the Resource Definition for Resource Assignment names from database.
+    // 4. Create the Resource Definition under blueprint base path.
+    override fun enhance(bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+                         bluePrintRuntimeService: BluePrintRuntimeService<*>): List<ResourceDefinition> {
+
+        var resourceDefinitions: List<ResourceDefinition> = mutableListOf()
+
+        val blueprintContext = bluePrintRuntimeService.bluePrintContext()
+
+        val mappingFiles = getAllResourceMappingFiles(blueprintContext)
+        log.info("resources assignment files ($mappingFiles)")
+        if (mappingFiles != null) {
+            resourceDefinitions = getResourceDefinition(blueprintContext, mappingFiles)
+            // Enriching Resource Definition Sources
+            enrichResourceDefinitionSources(bluePrintRuntimeService.bluePrintContext(), resourceDefinitions)
+        }
+        return resourceDefinitions
+    }
+
+    // Get all the Mapping files from all node templates.
+    private fun getAllResourceMappingFiles(blueprintContext: BluePrintContext): List<String>? {
+
+        return blueprintContext.nodeTemplates()?.mapNotNull { nodeTemplateMap ->
+
+            // Return only Mapping Artifact File Names
+            nodeTemplateMap.value.artifacts?.filter { artifactDefinitionMap ->
+                artifactDefinitionMap.value.type == ARTIFACT_TYPE_MAPPING_SOURCE
+            }?.mapNotNull { artifactDefinitionMap ->
+                artifactDefinitionMap.value.file
+            }
+
+        }?.flatten()?.distinct()
+    }
+
+    // Convert file content to ResourceAssignments asynchronously
+    private fun getResourceDefinition(blueprintContext: BluePrintContext, files: List<String>) = runBlocking {
+        val blueprintBasePath = blueprintContext.rootPath
+        val deferredResourceAssignments = mutableListOf<Deferred<List<ResourceAssignment>>>()
+        for (file in files) {
+            log.info("processing file ($file)")
+            deferredResourceAssignments += async {
+                ResourceDictionaryUtils.getResourceAssignmentFromFile("$blueprintBasePath/$file")
+            }
+        }
+
+        val resourceAssignments = mutableListOf<ResourceAssignment>()
+        for (deferredResourceAssignment in deferredResourceAssignments) {
+            resourceAssignments.addAll(deferredResourceAssignment.await())
+        }
+
+        val distinctResourceAssignments = resourceAssignments.distinctBy { it.name }
+        generateResourceDictionary(blueprintBasePath, distinctResourceAssignments)
+        //log.info("distinct Resource assignment ($distinctResourceAssignments)")
+    }
+
+
+    // Read the Resource Definitions from the Database and write to type file.
+    private fun generateResourceDictionary(blueprintBasePath: String, resourceAssignments: List<ResourceAssignment>)
+            : List<ResourceDefinition> {
+        val resourceKeys = resourceAssignments.mapNotNull { it.dictionaryName }.distinct().sorted()
+        log.info("distinct resource keys ($resourceKeys)")
+
+        //TODO("Optimise DB single Query to multiple Query")
+        return resourceKeys.map { resourceKey ->
+            getResourceDefinition(resourceKey)
+        }
+    }
+
+    private fun enrichResourceDefinitionSources(bluePrintContext: BluePrintContext,
+                                                resourceDefinitions: List<ResourceDefinition>) {
+        val sources = resourceDefinitions
+                .map { it.sources }
+                .map {
+                    it.values
+                            .map { nodeTemplate ->
+                                nodeTemplate.type
+                            }
+                }
+                .flatten().distinct()
+        log.info("Enriching Resource Definition sources Node Template: $sources")
+        sources.forEach {
+            BluePrintEnhancerUtils.populateNodeType(bluePrintContext, resourceDefinitionRepoService, it)
+        }
+    }
+
+    // Get the Resource Definition from Database
+    private fun getResourceDefinition(name: String): ResourceDefinition {
+        return resourceDefinitionRepoService.getResourceDefinition(name)
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/BluePrintModelHandler.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/BluePrintModelHandler.kt
new file mode 100644
index 000000000..11087bc52
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/BluePrintModelHandler.kt
@@ -0,0 +1,330 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 Bell Canada.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.handler
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.apps.controllerblueprints.core.data.ErrorCode
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.normalizedPathName
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintFileUtils
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModel
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModelSearch
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ControllerBlueprintModelContentRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ControllerBlueprintModelRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ControllerBlueprintModelSearchRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.utils.BluePrintEnhancerUtils
+import org.springframework.core.io.ByteArrayResource
+import org.springframework.core.io.Resource
+import org.springframework.http.HttpHeaders
+import org.springframework.http.MediaType
+import org.springframework.http.ResponseEntity
+import org.springframework.http.codec.multipart.FilePart
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import reactor.core.publisher.Mono
+import java.io.File
+import java.io.IOException
+import java.util.*
+
+/**
+ * BlueprintModelHandler Purpose: Handler service to handle the request from BlurPrintModelRest
+ *
+ * @author Brinda Santh
+ * @version 1.0
+ */
+
+@Service
+open class BluePrintModelHandler(private val bluePrintCatalogService: BluePrintCatalogService,
+                                 private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+                                 private val blueprintModelSearchRepository: ControllerBlueprintModelSearchRepository,
+                                 private val blueprintModelRepository: ControllerBlueprintModelRepository,
+                                 private val blueprintModelContentRepository: ControllerBlueprintModelContentRepository,
+                                 private val bluePrintEnhancerService: BluePrintEnhancerService) {
+
+    /**
+     * This is a getAllBlueprintModel method to retrieve all the BlueprintModel in Database
+     *
+     * @return List<BlueprintModelSearch> list of the controller blueprint archives
+    </BlueprintModelSearch> */
+    open fun allBlueprintModel(): List<BlueprintModelSearch> {
+        return blueprintModelSearchRepository.findAll()
+    }
+
+    /**
+     * This is a saveBlueprintModel method
+     *
+     * @param filePart filePart
+     * @return Mono<BlueprintModelSearch>
+     * @throws BluePrintException BluePrintException
+    </BlueprintModelSearch> */
+    @Throws(BluePrintException::class)
+    open fun saveBlueprintModel(filePart: FilePart): Mono<BlueprintModelSearch> {
+        try {
+            val cbaLocation = BluePrintFileUtils.getCbaStorageDirectory(bluePrintLoadConfiguration.blueprintArchivePath)
+            return BluePrintEnhancerUtils.saveCBAFile(filePart, cbaLocation).map { fileName ->
+                var blueprintId: String? = null
+                try {
+                    blueprintId = bluePrintCatalogService.saveToDatabase(cbaLocation.resolve(fileName).toFile(), false)
+                } catch (e: BluePrintException) {
+                    // FIXME handle expection
+                }
+                blueprintModelSearchRepository.findById(blueprintId!!).get()
+            }
+        } catch (e: IOException) {
+            throw BluePrintException(ErrorCode.IO_FILE_INTERRUPT.value,
+                    String.format("I/O Error while uploading the CBA file: %s", e.message), e)
+        }
+
+    }
+
+
+    /**
+     * This is a searchBlueprintModels method
+     *
+     * @param tags tags
+     * @return List<BlueprintModelSearch>
+    </BlueprintModelSearch> */
+    open fun searchBlueprintModels(tags: String): List<BlueprintModelSearch> {
+        return blueprintModelSearchRepository.findByTagsContainingIgnoreCase(tags)
+    }
+
+    /**
+     * This is a getBlueprintModelSearchByNameAndVersion method
+     *
+     * @param name name
+     * @param version version
+     * @return BlueprintModelSearch
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open fun getBlueprintModelSearchByNameAndVersion(name: String, version: String): BlueprintModelSearch {
+        val blueprintModelSearch: BlueprintModelSearch
+        val dbBlueprintModel = blueprintModelSearchRepository
+                .findByArtifactNameAndArtifactVersion(name, version)
+        if (dbBlueprintModel.isPresent) {
+            blueprintModelSearch = dbBlueprintModel.get()
+        } else {
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value,
+                    String.format(BLUEPRINT_MODEL_NAME_VERSION_FAILURE_MSG, name, version))
+        }
+        return blueprintModelSearch
+    }
+
+    /**
+     * This is a downloadBlueprintModelFileByNameAndVersion method to download a Blueprint by Name and Version
+     *
+     * @param name name
+     * @param version version
+     * @return ResponseEntity<Resource>
+     * @throws BluePrintException BluePrintException
+    </Resource> */
+    @Throws(BluePrintException::class)
+    open fun downloadBlueprintModelFileByNameAndVersion(name: String,
+                                                        version: String): ResponseEntity<Resource> {
+        val blueprintModel: BlueprintModel
+        try {
+            blueprintModel = getBlueprintModelByNameAndVersion(name, version)
+        } catch (e: BluePrintException) {
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, String.format("Error while " + "downloading the CBA file: %s", e.message), e)
+        }
+
+        val fileName = blueprintModel.id + ".zip"
+        val file = blueprintModel.blueprintModelContent.content
+        return prepareResourceEntity(fileName, file)
+    }
+
+    /**
+     * This is a downloadBlueprintModelFile method to find the target file to download and return a file resource
+     *
+     * @return ResponseEntity<Resource>
+     * @throws BluePrintException BluePrintException
+    </Resource> */
+    @Throws(BluePrintException::class)
+    open fun downloadBlueprintModelFile(id: String): ResponseEntity<Resource> {
+        val blueprintModel: BlueprintModel
+        try {
+            blueprintModel = getBlueprintModel(id)
+        } catch (e: BluePrintException) {
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, String.format("Error while " + "downloading the CBA file: %s", e.message), e)
+        }
+
+        val fileName = blueprintModel.id + ".zip"
+        val file = blueprintModel.blueprintModelContent.content
+        return prepareResourceEntity(fileName, file)
+    }
+
+    /**
+     * @return ResponseEntity<Resource>
+    </Resource> */
+    private fun prepareResourceEntity(fileName: String, file: ByteArray): ResponseEntity<Resource> {
+        return ResponseEntity.ok()
+                .contentType(MediaType.parseMediaType("text/plain"))
+                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"$fileName\"")
+                .body(ByteArrayResource(file))
+    }
+
+    /**
+     * This is a getBlueprintModel method
+     *
+     * @param id id
+     * @return BlueprintModel
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open fun getBlueprintModel(id: String): BlueprintModel {
+        val blueprintModel: BlueprintModel
+        val dbBlueprintModel = blueprintModelRepository.findById(id)
+        if (dbBlueprintModel.isPresent) {
+            blueprintModel = dbBlueprintModel.get()
+        } else {
+            val msg = String.format(BLUEPRINT_MODEL_ID_FAILURE_MSG, id)
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, msg)
+        }
+        return blueprintModel
+    }
+
+    /**
+     * This is a getBlueprintModelByNameAndVersion method
+     *
+     * @param name name
+     * @param version version
+     * @return BlueprintModel
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open fun getBlueprintModelByNameAndVersion(name: String, version: String): BlueprintModel {
+        val blueprintModel = blueprintModelRepository
+                .findByArtifactNameAndArtifactVersion(name, version)
+        if (blueprintModel != null) {
+            return blueprintModel
+        } else {
+            val msg = String.format(BLUEPRINT_MODEL_NAME_VERSION_FAILURE_MSG, name, version)
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, msg)
+        }
+    }
+
+    /**
+     * This is a getBlueprintModelSearch method
+     *
+     * @param id id
+     * @return BlueprintModelSearch
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open fun getBlueprintModelSearch(id: String): BlueprintModelSearch {
+        val blueprintModelSearch: BlueprintModelSearch
+        val dbBlueprintModel = blueprintModelSearchRepository.findById(id)
+        if (dbBlueprintModel.isPresent) {
+            blueprintModelSearch = dbBlueprintModel.get()
+        } else {
+            val msg = String.format(BLUEPRINT_MODEL_ID_FAILURE_MSG, id)
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, msg)
+        }
+
+        return blueprintModelSearch
+    }
+
+    /**
+     * This is a deleteBlueprintModel method
+     *
+     * @param id id
+     * @throws BluePrintException BluePrintException
+     */
+    @Transactional
+    @Throws(BluePrintException::class)
+    open fun deleteBlueprintModel(id: String) {
+        val dbBlueprintModel = blueprintModelRepository.findById(id)
+        if (dbBlueprintModel.isPresent) {
+            blueprintModelContentRepository.deleteByBlueprintModel(dbBlueprintModel.get())
+            blueprintModelRepository.delete(dbBlueprintModel.get())
+        } else {
+            val msg = String.format(BLUEPRINT_MODEL_ID_FAILURE_MSG, id)
+            throw BluePrintException(ErrorCode.RESOURCE_NOT_FOUND.value, msg)
+        }
+    }
+
+    /**
+     * This is a CBA enrichBlueprint method
+     * Save the Zip File in archive location and extract the cba content.
+     * Populate the Enhancement Location
+     * Enhance the CBA content
+     * Compress the Enhanced Content
+     * Return back the the compressed content back to the caller.
+     *
+     * @param filePart filePart
+     * @return ResponseEntity<Resource>
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open suspend fun enrichBlueprint(filePart: FilePart): ResponseEntity<Resource> {
+        val enhanceId = UUID.randomUUID().toString()
+        val blueprintArchive = normalizedPathName(bluePrintLoadConfiguration.blueprintArchivePath, enhanceId)
+        val blueprintEnrichmentDir = normalizedPathName(bluePrintLoadConfiguration.blueprintEnrichmentPath, enhanceId)
+        try {
+            BluePrintEnhancerUtils.decompressFilePart(filePart, blueprintArchive, blueprintEnrichmentDir)
+
+            // Enhance the Blue Prints
+            bluePrintEnhancerService.enhance(blueprintEnrichmentDir)
+
+            return BluePrintEnhancerUtils.compressToFilePart(blueprintEnrichmentDir, blueprintArchive)
+
+        } catch (e: IOException) {
+            throw BluePrintException(ErrorCode.IO_FILE_INTERRUPT.value,
+                    "Error in Enriching CBA: ${e.message}", e)
+        } finally {
+            BluePrintEnhancerUtils.cleanEnhancer(blueprintArchive, blueprintEnrichmentDir)
+        }
+    }
+
+    /**
+     * This is a publishBlueprintModel method to change the status published to YES
+     *
+     * @param filePart filePart
+     * @return BlueprintModelSearch
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open suspend fun publishBlueprint(filePart: FilePart): BlueprintModelSearch {
+        val publishId = UUID.randomUUID().toString()
+        val blueprintArchive = bluePrintLoadConfiguration.blueprintArchivePath.plus(File.separator).plus(publishId)
+        val blueprintEnrichmentDir = bluePrintLoadConfiguration.blueprintEnrichmentPath.plus(File.separator).plus(publishId)
+        try {
+            val compressedFilePart = BluePrintEnhancerUtils
+                    .extractCompressFilePart(filePart, blueprintArchive, blueprintEnrichmentDir)
+
+            val blueprintId = bluePrintCatalogService.saveToDatabase(compressedFilePart, true)
+
+            return blueprintModelSearchRepository.findById(blueprintId).get()
+
+        } catch (e: Exception) {
+            throw BluePrintException(ErrorCode.IO_FILE_INTERRUPT.value,
+                    "Error in Publishing CBA: ${e.message}", e)
+        } finally {
+            BluePrintEnhancerUtils.cleanEnhancer(blueprintArchive, blueprintEnrichmentDir)
+        }
+    }
+
+    companion object {
+
+        private const val BLUEPRINT_MODEL_ID_FAILURE_MSG = "failed to get blueprint model id(%s) from repo"
+        private const val BLUEPRINT_MODEL_NAME_VERSION_FAILURE_MSG = "failed to get blueprint model by name(%s)" + " and version(%s) from repo"
+    }
+}
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ModelTypeHandler.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ModelTypeHandler.kt
new file mode 100644
index 000000000..8099d07ff
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ModelTypeHandler.kt
@@ -0,0 +1,116 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.handler
+
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ModelTypeRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.validator.ModelTypeValidator
+import org.springframework.stereotype.Service
+
+@Service
+open class ModelTypeHandler(private val modelTypeRepository: ModelTypeRepository) {
+
+    private val log = EELFManager.getInstance().getLogger(ModelTypeHandler::class.java)!!
+
+    /**
+     * This is a getModelTypeByName service
+     *
+     * @param modelTypeName modelTypeName
+     * @return ModelType
+     */
+    fun getModelTypeByName(modelTypeName: String): ModelType? {
+        log.info("Searching : $modelTypeName")
+        check(modelTypeName.isNotBlank()) { "Model Name Information is missing." }
+        return modelTypeRepository.findByModelName(modelTypeName)
+    }
+
+
+    /**
+     * This is a searchModelTypes service
+     *
+     * @param tags tags
+     * @return List<ModelType>
+    </ModelType> */
+    fun searchModelTypes(tags: String): List<ModelType> {
+        check(tags.isNotBlank()) { "No Search Information provide" }
+        return modelTypeRepository.findByTagsContainingIgnoreCase(tags)
+    }
+
+    /**
+     * This is a saveModel service
+     *
+     * @param modelType modelType
+     * @return ModelType
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    open fun saveModel(modelType: ModelType): ModelType {
+        lateinit var dbModel: ModelType
+        ModelTypeValidator.validateModelType(modelType)
+        val dbModelType: ModelType? = modelTypeRepository.findByModelName(modelType.modelName)
+        if (dbModelType != null) {
+            dbModel = dbModelType
+            dbModel.description = modelType.description
+            dbModel.definition = modelType.definition
+            dbModel.definitionType = modelType.definitionType
+            dbModel.derivedFrom = modelType.derivedFrom
+            dbModel.tags = modelType.tags
+            dbModel.version = modelType.version
+            dbModel.updatedBy = modelType.updatedBy
+            dbModel = modelTypeRepository.save(dbModel)
+        } else {
+            dbModel = modelTypeRepository.save(modelType)
+        }
+        return dbModel
+    }
+
+
+    /**
+     * This is a deleteByModelName service
+     *
+     * @param modelName modelName
+     */
+    open fun deleteByModelName(modelName: String) {
+        check(modelName.isNotBlank()) { "Model Name Information is missing." }
+        modelTypeRepository.deleteByModelName(modelName)
+
+    }
+
+    /**
+     * This is a getModelTypeByDefinitionType service
+     *
+     * @param definitionType definitionType
+     * @return List<ModelType>
+    */
+    fun getModelTypeByDefinitionType(definitionType: String): List<ModelType> {
+        check(definitionType.isNotBlank()) { "Model definitionType Information is missing." }
+        return modelTypeRepository.findByDefinitionType(definitionType)
+    }
+
+    /**
+     * This is a getModelTypeByDerivedFrom service
+     *
+     * @param derivedFrom derivedFrom
+     * @return List<ModelType>
+    */
+    fun getModelTypeByDerivedFrom(derivedFrom: String): List<ModelType> {
+        check(derivedFrom.isNotBlank()) { "Model derivedFrom Information is missing." }
+        return modelTypeRepository.findByDerivedFrom(derivedFrom)
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ResourceDictionaryHandler.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ResourceDictionaryHandler.kt
new file mode 100644
index 000000000..ec7d8aebc
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/handler/ResourceDictionaryHandler.kt
@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.handler
+
+import com.google.common.base.Preconditions
+import org.apache.commons.collections.CollectionUtils
+import org.apache.commons.lang3.StringUtils
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceSourceMapping
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.factory.ResourceSourceMappingFactory
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ResourceDictionaryRepository
+import org.springframework.stereotype.Service
+
+@Service
+class ResourceDictionaryHandler(private val resourceDictionaryRepository: ResourceDictionaryRepository) {
+
+
+    /**
+     * This is a getDataDictionaryByName service
+     *
+     * @param name name
+     * @return DataDictionary
+     * @throws BluePrintException BluePrintException
+     */
+    @Throws(BluePrintException::class)
+    fun getResourceDictionaryByName(name: String): ResourceDictionary {
+        Preconditions.checkArgument(StringUtils.isNotBlank(name), "Resource dictionary Name Information is missing.")
+        val resourceDictionaryDb = resourceDictionaryRepository.findByName(name)
+        return if (resourceDictionaryDb.isPresent) {
+            resourceDictionaryDb.get()
+        } else {
+            throw BluePrintException(String.format("couldn't get resource dictionary for name (%s)", name))
+        }
+    }
+
+    /**
+     * This is a searchResourceDictionaryByNames service
+     *
+     * @param names names
+     * @return List<ResourceDictionary>
+    </ResourceDictionary> */
+    fun searchResourceDictionaryByNames(names: List<String>): List<ResourceDictionary> {
+        Preconditions.checkArgument(CollectionUtils.isNotEmpty(names), "No Search Information provide")
+        return resourceDictionaryRepository.findByNameIn(names)
+    }
+
+    /**
+     * This is a searchResourceDictionaryByTags service
+     *
+     * @param tags tags
+     * @return List<ResourceDictionary>
+    </ResourceDictionary> */
+    fun searchResourceDictionaryByTags(tags: String): List<ResourceDictionary> {
+        Preconditions.checkArgument(StringUtils.isNotBlank(tags), "No search tag information provide")
+        return resourceDictionaryRepository.findByTagsContainingIgnoreCase(tags)
+    }
+
+    /**
+     * This is a saveDataDictionary service
+     *
+     * @param resourceDictionary resourceDictionary
+     * @return DataDictionary
+     */
+    @Throws(BluePrintException::class)
+    fun saveResourceDictionary(resourceDictionary: ResourceDictionary): ResourceDictionary {
+        var resourceDictionary = resourceDictionary
+
+        val resourceDefinition = resourceDictionary.definition
+        Preconditions.checkNotNull(resourceDefinition, "failed to get resource definition from content")
+        // Validate the Resource Definitions
+        //TODO( Save Validator)
+        //validate(resourceDefinition)
+
+        resourceDictionary.tags = resourceDefinition.tags
+        resourceDefinition.updatedBy = resourceDictionary.updatedBy
+        // Set the Property Definitions
+        val propertyDefinition = resourceDefinition.property
+        resourceDictionary.description = propertyDefinition.description
+        resourceDictionary.dataType = propertyDefinition.type
+        if (propertyDefinition.entrySchema != null) {
+            resourceDictionary.entrySchema = propertyDefinition.entrySchema!!.type
+        }
+
+        validateResourceDictionary(resourceDictionary)
+
+        val dbResourceDictionaryData = resourceDictionaryRepository.findByName(resourceDictionary.name)
+        if (dbResourceDictionaryData.isPresent) {
+            val dbResourceDictionary = dbResourceDictionaryData.get()
+
+            dbResourceDictionary.name = resourceDictionary.name
+            dbResourceDictionary.definition = resourceDictionary.definition
+            dbResourceDictionary.description = resourceDictionary.description
+            dbResourceDictionary.tags = resourceDictionary.tags
+            dbResourceDictionary.updatedBy = resourceDictionary.updatedBy
+            dbResourceDictionary.dataType = resourceDictionary.dataType
+            dbResourceDictionary.entrySchema = resourceDictionary.entrySchema
+            resourceDictionary = resourceDictionaryRepository.save(dbResourceDictionary)
+        } else {
+            resourceDictionary = resourceDictionaryRepository.save(resourceDictionary)
+        }
+
+        return resourceDictionary
+    }
+
+    /**
+     * This is a deleteResourceDictionary service
+     *
+     * @param name name
+     */
+    fun deleteResourceDictionary(name: String) {
+        check(name.isNotBlank()) { "Resource dictionary name is missing." }
+        resourceDictionaryRepository.deleteByName(name)
+    }
+
+    /**
+     * This is a getResourceSourceMapping service
+     */
+    fun getResourceSourceMapping(): ResourceSourceMapping {
+        return ResourceSourceMappingFactory.getRegisterSourceMapping()
+    }
+
+    private fun validateResourceDictionary(resourceDictionary: ResourceDictionary): Boolean {
+        checkNotEmptyOrThrow(resourceDictionary.name, "DataDictionary Definition name is missing.")
+        checkNotNull(resourceDictionary.definition) { "DataDictionary Definition Information is missing." }
+        checkNotEmptyOrThrow(resourceDictionary.description, "DataDictionary Definition Information is missing.")
+        checkNotEmptyOrThrow(resourceDictionary.tags, "DataDictionary Definition tags is missing.")
+        checkNotEmptyOrThrow(resourceDictionary.updatedBy, "DataDictionary Definition updatedBy is missing.")
+        return true
+
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintCatalogLoadService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintCatalogLoadService.kt
new file mode 100644
index 000000000..948601cf4
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintCatalogLoadService.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.load
+
+import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.apache.commons.lang3.text.StrBuilder
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.springframework.stereotype.Service
+import java.io.File
+
+@Service
+open class BluePrintCatalogLoadService(private val bluePrintCatalogService: BluePrintCatalogService) {
+
+    private val log = EELFManager.getInstance().getLogger(BluePrintCatalogLoadService::class.java)
+
+    open fun loadPathsBluePrintModelCatalog(paths: List<String>) {
+        paths.forEach { loadPathBluePrintModelCatalog(it) }
+    }
+
+    open fun loadPathBluePrintModelCatalog(path: String) {
+
+        val files = File(path).listFiles()
+        runBlocking {
+            val errorBuilder = StrBuilder()
+            val deferredResults = mutableListOf<Deferred<Unit>>()
+
+            for (file in files) {
+                deferredResults += async {
+                    loadBluePrintModelCatalog(errorBuilder, file)
+                }
+            }
+
+            for (deferredResult in deferredResults) {
+                deferredResult.await()
+            }
+
+            if (!errorBuilder.isEmpty) {
+                log.error(errorBuilder.toString())
+            }
+        }
+    }
+
+    open fun loadBluePrintModelCatalog(errorBuilder: StrBuilder, file: File) {
+        try {
+            bluePrintCatalogService.saveToDatabase(file)
+        } catch (e: Exception) {
+            errorBuilder.appendln("Couldn't load BlueprintModel(${file.name}: ${e.message}")
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintDatabaseLoadService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintDatabaseLoadService.kt
new file mode 100644
index 000000000..8144a1e79
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/BluePrintDatabaseLoadService.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.load
+
+import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.runBlocking
+import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.springframework.boot.context.event.ApplicationReadyEvent
+import org.springframework.context.event.EventListener
+import org.springframework.stereotype.Service
+
+@Service
+open class BluePrintDatabaseLoadService(private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+                                        private val modelTypeLoadService: ModelTypeLoadService,
+                                        private val resourceDictionaryLoadService: ResourceDictionaryLoadService,
+                                        private val bluePrintCatalogLoadService: BluePrintCatalogLoadService) {
+
+    private val log = EELFManager.getInstance().getLogger(BluePrintDatabaseLoadService::class.java)
+
+
+    @EventListener(ApplicationReadyEvent::class)
+    open fun init() {
+        if (bluePrintLoadConfiguration.loadInitialData) {
+            initModelTypes()
+            initResourceDictionary()
+            initBluePrintCatalog()
+        } else {
+            log.info("Initial data load is disabled")
+        }
+    }
+
+    open fun initModelTypes() {
+        log.info("model types load configuration(${bluePrintLoadConfiguration.loadModelType}) " +
+                "under paths(${bluePrintLoadConfiguration.loadModeTypePaths})")
+
+        if (bluePrintLoadConfiguration.loadModelType) {
+            val paths = bluePrintLoadConfiguration.loadModeTypePaths?.split(",")
+            paths?.let {
+                runBlocking {
+                    modelTypeLoadService.loadPathsModelType(paths)
+                }
+            }
+        }
+    }
+
+    open fun initResourceDictionary() {
+        log.info("resource dictionary load configuration(${bluePrintLoadConfiguration.loadResourceDictionary}) " +
+                "under paths(${bluePrintLoadConfiguration.loadResourceDictionaryPaths})")
+
+        if (bluePrintLoadConfiguration.loadResourceDictionary) {
+            val paths = bluePrintLoadConfiguration.loadResourceDictionaryPaths?.split(",")
+            paths?.let {
+                resourceDictionaryLoadService.loadPathsResourceDictionary(paths)
+            }
+        }
+    }
+
+    open fun initBluePrintCatalog() {
+        log.info("blueprint load configuration(${bluePrintLoadConfiguration.loadBluePrint}) " +
+                "under paths(${bluePrintLoadConfiguration.loadBluePrintPaths})")
+
+        if (bluePrintLoadConfiguration.loadBluePrint) {
+            val paths = bluePrintLoadConfiguration.loadBluePrintPaths?.split(",")
+            paths?.let {
+                bluePrintCatalogLoadService.loadPathsBluePrintModelCatalog(paths)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ControllerBlueprintCatalogServiceImpl.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ControllerBlueprintCatalogServiceImpl.kt
new file mode 100755
index 000000000..17149e466
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ControllerBlueprintCatalogServiceImpl.kt
@@ -0,0 +1,112 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 Bell Canada.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.load
+
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.common.ApplicationConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.apps.controllerblueprints.core.data.ErrorCode
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintValidatorService
+import org.onap.ccsdk.apps.controllerblueprints.db.resources.BlueprintCatalogServiceImpl
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModel
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModelContent
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ControllerBlueprintModelRepository
+import org.slf4j.LoggerFactory
+import org.springframework.dao.DataIntegrityViolationException
+import org.springframework.stereotype.Service
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+/**
+ * Similar implementation in [org.onap.ccsdk.apps.blueprintsprocessor.db.BlueprintProcessorCatalogServiceImpl]
+ */
+@Service
+class ControllerBlueprintCatalogServiceImpl(bluePrintValidatorService: BluePrintValidatorService,
+                                            private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+                                            private val blueprintModelRepository: ControllerBlueprintModelRepository)
+    : BlueprintCatalogServiceImpl(bluePrintValidatorService) {
+
+
+    private val log = LoggerFactory.getLogger(ControllerBlueprintCatalogServiceImpl::class.toString())
+
+    init {
+        log.info("BlueprintProcessorCatalogServiceImpl initialized")
+    }
+
+    override fun delete(name: String, version: String) = blueprintModelRepository.deleteByArtifactNameAndArtifactVersion(name, version)
+
+    override fun get(name: String, version: String, extract: Boolean): Path? {
+        val path = if (extract) {
+            Paths.get("${bluePrintLoadConfiguration.blueprintDeployPath}/$name/$version")
+        } else {
+            Paths.get("${bluePrintLoadConfiguration.blueprintArchivePath}/$name/$version.zip")
+        }
+        blueprintModelRepository.findByArtifactNameAndArtifactVersion(name, version)?.also {
+            it.blueprintModelContent.run {
+                path.toFile().writeBytes(this!!.content!!).let {
+                    return path
+                }
+            }
+        }
+        return null
+    }
+
+    override fun save(metadata: MutableMap<String, String>, archiveFile: File) {
+
+        val artifactName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]
+        val artifactVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]
+
+
+        blueprintModelRepository.findByArtifactNameAndArtifactVersion(artifactName!!, artifactVersion!!)?.let {
+            log.info("Overwriting blueprint model :$artifactName::$artifactVersion")
+            blueprintModelRepository.deleteByArtifactNameAndArtifactVersion(artifactName, artifactVersion)
+        }
+
+        val blueprintModel = BlueprintModel()
+        blueprintModel.id = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
+        blueprintModel.artifactType = ApplicationConstants.ASDC_ARTIFACT_TYPE_SDNC_MODEL
+        blueprintModel.published = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_VALID]
+                ?: BluePrintConstants.FLAG_N
+        blueprintModel.artifactName = artifactName
+        blueprintModel.artifactVersion = artifactVersion
+        blueprintModel.updatedBy = metadata[BluePrintConstants.METADATA_TEMPLATE_AUTHOR]
+        blueprintModel.tags = metadata[BluePrintConstants.METADATA_TEMPLATE_TAGS]
+        blueprintModel.artifactDescription = "Controller Blueprint for $artifactName:$artifactVersion"
+
+        val blueprintModelContent = BlueprintModelContent()
+        blueprintModelContent.id = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
+        blueprintModelContent.contentType = "CBA_ZIP"
+        blueprintModelContent.name = "$artifactName:$artifactVersion"
+        blueprintModelContent.description = "$artifactName:$artifactVersion CBA Zip Content"
+        blueprintModelContent.content = Files.readAllBytes(archiveFile.toPath())
+        blueprintModelContent.blueprintModel = blueprintModel
+        // Set the Blueprint Model Content into blueprintModel
+        blueprintModel.blueprintModelContent = blueprintModelContent
+
+        try {
+            blueprintModelRepository.saveAndFlush(blueprintModel)
+        } catch (ex: DataIntegrityViolationException) {
+            throw BluePrintException(ErrorCode.CONFLICT_ADDING_RESOURCE.value, "The blueprint entry " +
+                    "is already exist in database: ${ex.message}", ex)
+        }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ModelTypeLoadService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ModelTypeLoadService.kt
new file mode 100644
index 000000000..061ef88ef
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ModelTypeLoadService.kt
@@ -0,0 +1,150 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.load
+
+import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.*
+import org.apache.commons.io.FilenameUtils
+import org.apache.commons.lang3.text.StrBuilder
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+import org.onap.ccsdk.apps.controllerblueprints.service.handler.ModelTypeHandler
+import org.springframework.stereotype.Service
+import java.io.File
+import java.nio.charset.Charset
+
+@Service
+open class ModelTypeLoadService(private val modelTypeHandler: ModelTypeHandler) {
+
+    private val log = EELFManager.getInstance().getLogger(ModelTypeLoadService::class.java)
+    private val updateBySystem = "System"
+
+    open suspend fun loadPathsModelType(modelTypePaths: List<String>) {
+        modelTypePaths.forEach { runBlocking { loadPathModelType(it) } }
+    }
+
+    /**
+     * Load the Model Type file content from the defined path, Load of sequencing should be maintained.
+     */
+    open suspend fun loadPathModelType(modelTypePath: String) = runBlocking {
+        log.info(" *************************** loadModelType **********************")
+        try {
+            val errorBuilder = StrBuilder()
+
+            coroutineScope {
+                val dataTypeFiles = File("$modelTypePath/data_type").listFiles()
+
+                val deferredResults = mutableListOf<Deferred<Unit>>()
+
+                for (file in dataTypeFiles) deferredResults += async {
+                    loadModelType(file, DataType::class.java, errorBuilder)
+                }
+
+                deferredResults.awaitAll()
+            }
+
+            coroutineScope {
+                val artifactTypeFiles = File("$modelTypePath/artifact_type").listFiles()
+
+                val deferredResults = mutableListOf<Deferred<Unit>>()
+
+                for (file in artifactTypeFiles) deferredResults += async {
+                    loadModelType(file,
+                            ArtifactType::class.java, errorBuilder)
+                }
+
+                deferredResults.awaitAll()
+            }
+
+            coroutineScope {
+                val relationshipTypeFiles = File("$modelTypePath/relationship_type").listFiles()
+
+                val deferredResults = mutableListOf<Deferred<Unit>>()
+
+                for (file in relationshipTypeFiles) deferredResults += async {
+                    loadModelType(file,
+                            RelationshipType::class.java, errorBuilder)
+                }
+
+                deferredResults.awaitAll()
+            }
+
+            coroutineScope {
+                val nodeTypeFiles = File("$modelTypePath/node_type").listFiles()
+
+                val deferredResults = mutableListOf<Deferred<Unit>>()
+
+                for (file in nodeTypeFiles) deferredResults += async {
+                    loadModelType(file,
+                            NodeType::class.java, errorBuilder)
+                }
+                deferredResults.awaitAll()
+            }
+
+            if (!errorBuilder.isEmpty) {
+                log.error(errorBuilder.toString())
+            }
+        } catch (e: Exception) {
+            log.error("Failed to loade ModelTypes under($modelTypePath)", e)
+        }
+    }
+
+    private inline fun <reified T> loadModelType(file: File, classType: Class<T>, errorBuilder: StrBuilder) {
+        try {
+            log.trace("Loading ${classType.name} (${file.name})")
+            val dataKey = FilenameUtils.getBaseName(file.name)
+            val definitionContent = file.readText(Charset.defaultCharset())
+            val definition = JacksonUtils.readValue(definitionContent, classType) as EntityType
+            //checkNotNull(definition) { "failed to get data type from file : ${file.name}" }
+
+            val modelType = ModelType()
+            val definitionType: String?
+            when (T::class) {
+                DataType::class -> {
+                    definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+                }
+                RelationshipType::class -> {
+                    definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE
+                }
+                ArtifactType::class -> {
+                    definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
+                }
+                NodeType::class -> {
+                    definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
+                }
+                else -> {
+                    throw BluePrintException("couldn't process model type($classType) definition")
+                }
+            }
+            modelType.definitionType = definitionType
+            modelType.derivedFrom = definition.derivedFrom
+            modelType.description = definition.description
+            modelType.definition = JacksonUtils.jsonNode(definitionContent)
+            modelType.modelName = dataKey
+            modelType.version = definition.version
+            modelType.updatedBy = updateBySystem
+            modelType.tags = (dataKey + "," + definition.derivedFrom + "," + definitionType)
+            modelTypeHandler.saveModel(modelType)
+            log.trace("${classType.name}(${file.name}) loaded successfully ")
+        } catch (e: Exception) {
+            errorBuilder.appendln("Couldn't load ${classType.name}(${file.name}: ${e.message}")
+        }
+    }
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ResourceDictionaryLoadService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ResourceDictionaryLoadService.kt
new file mode 100644
index 000000000..8100cac39
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/load/ResourceDictionaryLoadService.kt
@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.load
+
+import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.apache.commons.lang3.StringUtils
+import org.apache.commons.lang3.text.StrBuilder
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary
+import org.onap.ccsdk.apps.controllerblueprints.service.handler.ResourceDictionaryHandler
+import org.springframework.stereotype.Service
+import java.io.File
+import java.nio.charset.Charset
+
+@Service
+open class ResourceDictionaryLoadService(private val resourceDictionaryHandler: ResourceDictionaryHandler) {
+
+    private val log = EELFManager.getInstance().getLogger(ResourceDictionaryLoadService::class.java)
+
+    open fun loadPathsResourceDictionary(paths: List<String>) {
+        paths.forEach { loadPathResourceDictionary(it) }
+    }
+
+    open fun loadPathResourceDictionary(path: String) {
+        log.info(" *************************** loadResourceDictionary **********************")
+        val files = File(path).listFiles()
+
+        runBlocking {
+            val errorBuilder = StrBuilder()
+            val deferredResults = mutableListOf<Deferred<Unit>>()
+
+            for (file in files) {
+                deferredResults += async {
+                    loadResourceDictionary(errorBuilder, file)
+                }
+            }
+
+            for (deferredResult in deferredResults) {
+                deferredResult.await()
+            }
+
+            if (!errorBuilder.isEmpty) {
+                log.error(errorBuilder.toString())
+            }
+        }
+    }
+
+    private fun loadResourceDictionary(errorBuilder: StrBuilder, file: File) {
+        try {
+            log.trace("Loading NodeType(${file.name}")
+            val definitionContent = file.readText(Charset.defaultCharset())
+            val resourceDefinition = JacksonUtils.readValue(definitionContent, ResourceDefinition::class.java)
+            if (resourceDefinition != null) {
+
+                checkNotNull(resourceDefinition.property) { "Failed to get Property Definition" }
+                val resourceDictionary = ResourceDictionary()
+                resourceDictionary.name = resourceDefinition.name
+                resourceDictionary.definition = resourceDefinition
+
+                checkNotNull(resourceDefinition.property) { "Property field is missing" }
+                resourceDictionary.description = resourceDefinition.property.description
+                resourceDictionary.dataType = resourceDefinition.property.type
+
+                if (resourceDefinition.property.entrySchema != null) {
+                    resourceDictionary.entrySchema = resourceDefinition.property.entrySchema!!.type
+                }
+                resourceDictionary.updatedBy = resourceDefinition.updatedBy
+
+                if (StringUtils.isBlank(resourceDefinition.tags)) {
+                    resourceDictionary.tags = (resourceDefinition.name + ", " + resourceDefinition.updatedBy
+                            + ", " + resourceDefinition.updatedBy)
+
+                } else {
+                    resourceDictionary.tags = resourceDefinition.tags
+                }
+                resourceDictionaryHandler.saveResourceDictionary(resourceDictionary)
+
+                log.trace("Resource dictionary(${file.name}) loaded successfully ")
+            } else {
+                throw BluePrintException("couldn't get dictionary from content information")
+            }
+        } catch (e: Exception) {
+            errorBuilder.appendln("Couldn't load Resource dictionary (${file.name}: ${e.message}")
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/BluePrintsReactRepository.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/BluePrintsReactRepository.kt
new file mode 100644
index 000000000..141ba92c6
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/BluePrintsReactRepository.kt
@@ -0,0 +1,76 @@
+/*
+ *  Copyright © 2018 IBM.
+ *
+ *  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.onap.ccsdk.apps.controllerblueprints.service.repository
+
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+import org.springframework.stereotype.Service
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import reactor.core.scheduler.Schedulers
+
+/**
+ * ModelTypeReactRepository.
+ *
+ * @author Brinda Santh
+ */
+@Service
+open class ModelTypeReactRepository(private val modelTypeRepository: ModelTypeRepository) {
+
+    fun save(modelType: ModelType): Mono<ModelType> {
+        return Mono.justOrEmpty(modelTypeRepository.save(modelType))
+    }
+
+    fun findByModelName(modelName: String): Mono<ModelType> {
+        return Mono.justOrEmpty(modelTypeRepository.findByModelName(modelName))
+    }
+
+    fun findByModelNameIn(modelNames: List<String>): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByModelNameIn(modelNames))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByDerivedFrom(derivedFrom: String): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByDerivedFrom(derivedFrom))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByDerivedFromIn(derivedFroms: List<String>): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByDerivedFromIn(derivedFroms))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByDefinitionType(definitionType: String): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByDefinitionType(definitionType))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByDefinitionTypeIn(definitionTypes: List<String>): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByDefinitionTypeIn(definitionTypes))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByTagsContainingIgnoreCase(tags: String): Flux<ModelType> {
+        return Flux.fromIterable(modelTypeRepository.findByTagsContainingIgnoreCase(tags))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun deleteByModelName(modelName: String): Mono<Void> {
+        modelTypeRepository.deleteByModelName(modelName)
+        return Mono.empty()
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelContentRepository.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelContentRepository.kt
new file mode 100644
index 000000000..7cda72763
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelContentRepository.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 Bell Canada.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.repository
+
+import org.onap.ccsdk.apps.controllerblueprints.db.resources.repository.ModelContentRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModel
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModelContent
+
+interface ControllerBlueprintModelContentRepository : ModelContentRepository<BlueprintModel, BlueprintModelContent>
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelRepository.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelRepository.kt
new file mode 100644
index 000000000..ec1175072
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ControllerBlueprintModelRepository.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2019 Bell Canada.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.repository
+
+import org.onap.ccsdk.apps.controllerblueprints.db.resources.repository.ModelRepository
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.BlueprintModel
+
+interface ControllerBlueprintModelRepository : ModelRepository<BlueprintModel>
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ModelTypeRepository.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ModelTypeRepository.kt
new file mode 100644
index 000000000..990cc6518
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ModelTypeRepository.kt
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.repository
+
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+import javax.transaction.Transactional
+
+@Repository
+interface ModelTypeRepository : JpaRepository<ModelType, String> {
+    /**
+     * This is a findByModelName method
+     *
+     * @param modelName Model Name
+     * @return Optional<ModelType>
+     */
+    fun findByModelName(modelName: String): ModelType?
+    /**
+     * This is a findByModelNameIn method
+     *
+     * @param modelNames Model Names
+     * @return List<ModelType>
+     */
+    fun findByModelNameIn(modelNames: List<String>): List<ModelType>
+    /**
+     * This is a findByDerivedFrom method
+     *
+     * @param derivedFrom Derived From
+     * @return List<ModelType>
+    */
+    fun findByDerivedFrom(derivedFrom: String): List<ModelType>
+    /**
+     * This is a findByDerivedFromIn method
+     *
+     * @param derivedFroms Derived Froms
+     * @return List<ModelType>
+    */
+    fun findByDerivedFromIn(derivedFroms: List<String>): List<ModelType>
+
+    /**
+     * This is a findByDefinitionType method
+     *
+     * @param definitionType Definition Type
+     * @return List<ModelType>
+     */
+    fun findByDefinitionType(definitionType: String): List<ModelType>
+    /**
+     * This is a findByDefinitionTypeIn method
+     *
+     * @param definitionTypes Definition Types
+     * @return List<ModelType>
+    */
+    fun findByDefinitionTypeIn(definitionTypes: List<String>): List<ModelType>
+
+    /**
+     * This is a findByTagsContainingIgnoreCase method
+     *
+     * @param tags Tags
+     * @return Optional<ModelType>
+     */
+    fun findByTagsContainingIgnoreCase(tags: String): List<ModelType>
+
+    /**
+     * This is a deleteByModelName method
+     *
+     * @param modelName ModelName
+     */
+    @Transactional
+    fun deleteByModelName(modelName: String)
+}
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ResourceDictionaryReactRepository.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ResourceDictionaryReactRepository.kt
new file mode 100644
index 000000000..0865b69da
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/repository/ResourceDictionaryReactRepository.kt
@@ -0,0 +1,56 @@
+/*
+ *  Copyright © 2018 IBM.
+ *
+ *  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.onap.ccsdk.apps.controllerblueprints.service.repository
+
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary
+import org.springframework.stereotype.Service
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import reactor.core.scheduler.Schedulers
+
+/**
+ * ResourceDictionaryReactRepository.
+ *
+ * @author Brinda Santh
+ */
+@Service
+open class ResourceDictionaryReactRepository(private val resourceDictionaryRepository: ResourceDictionaryRepository) {
+
+    fun save(resourceDictionary: ResourceDictionary): Mono<ResourceDictionary> {
+        return Mono.justOrEmpty(resourceDictionaryRepository.save(resourceDictionary))
+    }
+
+    fun findByName(name: String): Mono<ResourceDictionary> {
+        return Mono.justOrEmpty(resourceDictionaryRepository.findByName(name))
+    }
+
+    fun findByNameIn(names: List<String>): Flux<ResourceDictionary> {
+        return Flux.fromIterable(resourceDictionaryRepository.findByNameIn(names))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun findByTagsContainingIgnoreCase(tags: String): Flux<ResourceDictionary> {
+        return Flux.fromIterable(resourceDictionaryRepository.findByTagsContainingIgnoreCase(tags))
+                .subscribeOn(Schedulers.elastic())
+    }
+
+    fun deleteByName(name: String): Mono<Void> {
+        resourceDictionaryRepository.deleteByName(name)
+        return Mono.empty()
+    }
+
+}
\ No newline at end of file
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/utils/BluePrintEnhancerUtils.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/utils/BluePrintEnhancerUtils.kt
new file mode 100644
index 000000000..41a7bf8a5
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/utils/BluePrintEnhancerUtils.kt
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 Bell Canada.
+ * Modifications Copyright © 2019 IBM.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.utils
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.reactive.awaitSingle
+import kotlinx.coroutines.withContext
+import org.onap.ccsdk.apps.controllerblueprints.core.*
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.springframework.core.io.ByteArrayResource
+import org.springframework.core.io.Resource
+import org.springframework.http.HttpHeaders
+import org.springframework.http.MediaType
+import org.springframework.http.ResponseEntity
+import org.springframework.http.codec.multipart.FilePart
+import org.springframework.util.StringUtils
+import reactor.core.publisher.Mono
+import java.io.File
+import java.io.IOException
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.util.*
+
+
+class BluePrintEnhancerUtils {
+    companion object {
+
+        fun populateDataTypes(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
+                              dataTypeName: String): DataType {
+            val dataType = bluePrintContext.serviceTemplate.dataTypes?.get(dataTypeName)
+                    ?: bluePrintRepoService.getDataType(dataTypeName)
+                    ?: throw BluePrintException("couldn't get DataType($dataTypeName) from repo.")
+            bluePrintContext.serviceTemplate.dataTypes?.put(dataTypeName, dataType)
+            return dataType
+        }
+
+        fun populateRelationshipType(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
+                                     relationshipName: String): RelationshipType {
+
+            val relationshipType = bluePrintContext.serviceTemplate.relationshipTypes?.get(relationshipName)
+                    ?: bluePrintRepoService.getRelationshipType(relationshipName)
+                    ?: throw BluePrintException("couldn't get RelationshipType($relationshipName) from repo.")
+            bluePrintContext.serviceTemplate.relationshipTypes?.put(relationshipName, relationshipType)
+            return relationshipType
+        }
+
+
+        fun populateNodeType(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
+                             nodeTypeName: String): NodeType {
+
+            val nodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(nodeTypeName)
+                    ?: bluePrintRepoService.getNodeType(nodeTypeName)
+                    ?: throw BluePrintException("couldn't get NodeType($nodeTypeName) from repo.")
+            bluePrintContext.serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)
+            return nodeType
+        }
+
+        fun populateArtifactType(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
+                                 artifactTypeName: String): ArtifactType {
+
+            val artifactType = bluePrintContext.serviceTemplate.artifactTypes?.get(artifactTypeName)
+                    ?: bluePrintRepoService.getArtifactType(artifactTypeName)
+                    ?: throw BluePrintException("couldn't get ArtifactType($artifactTypeName) from repo.")
+            bluePrintContext.serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)
+            return artifactType
+        }
+
+        private suspend fun copyFromFilePart(filePart: FilePart, targetFile: File): File {
+            // Delete the Directory
+            targetFile.deleteRecursively()
+            return filePart.transferTo(targetFile)
+                    .thenReturn(targetFile)
+                    .awaitSingle()
+        }
+
+        suspend fun extractCompressFilePart(filePart: FilePart, archiveDir: String, enhanceDir: String): File {
+            //Recreate the Base Directories
+            normalizedFile(archiveDir).reCreateDirs()
+            normalizedFile(enhanceDir).reCreateDirs()
+            val filePartFile = normalizedFile(archiveDir, "cba.zip")
+            // Copy the File Part to ZIP
+            return copyFromFilePart(filePart, filePartFile)
+        }
+
+        suspend fun decompressFilePart(filePart: FilePart, archiveDir: String, enhanceDir: String): File {
+            val filePartFile = extractCompressFilePart(filePart, archiveDir, enhanceDir)
+            val deCompressFileName = normalizedPathName(enhanceDir)
+            return filePartFile.deCompress(deCompressFileName)
+        }
+
+        suspend fun compressToFilePart(enhanceDir: String, archiveDir: String): ResponseEntity<Resource> {
+            val compressedFile = normalizedFile(archiveDir, "enhanced-cba.zip")
+            BluePrintArchiveUtils.compress(Paths.get(enhanceDir).toFile(), compressedFile, true)
+            return prepareResourceEntity(compressedFile.name, compressedFile.readBytes())
+        }
+
+        suspend fun prepareResourceEntity(fileName: String, file: ByteArray): ResponseEntity<Resource> {
+            return ResponseEntity.ok()
+                    .contentType(MediaType.parseMediaType("text/plain"))
+                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"$fileName\"")
+                    .body(ByteArrayResource(file))
+        }
+
+        suspend fun cleanEnhancer(archiveLocation: String, enhancementLocation: String) = withContext(Dispatchers.Default) {
+            deleteDir(archiveLocation)
+            deleteDir(enhancementLocation)
+        }
+
+        /**
+         * This is a saveCBAFile method
+         * take a [FilePart], transfer it to disk using a Flux of FilePart and return a [Mono] representing the CBA file name
+         *
+         * @param (filePart, targetDirectory) - the request part containing the file to be saved and the default directory where to save
+         * @return a [Mono] String representing the result of the operation
+         * @throws (BluePrintException, IOException) BluePrintException, IOException
+         */
+        @Throws(BluePrintException::class, IOException::class)
+        fun saveCBAFile(filePart: FilePart, targetDirectory: Path): Mono<String> {
+
+            // Normalize file name
+            val fileName = StringUtils.cleanPath(filePart.filename())
+
+            // Check if the file's extension is "CBA"
+            if (StringUtils.getFilenameExtension(fileName) != "zip") {
+                throw BluePrintException(ErrorCode.INVALID_FILE_EXTENSION.value, "Invalid file extension required ZIP")
+            }
+
+            // Change file name to match a pattern
+            val changedFileName = UUID.randomUUID().toString() + ".zip"
+            //String changedFileName = BluePrintFileUtils.Companion.getCBAGeneratedFileName(fileName, this.CBA_FILE_NAME_PATTERN);
+
+            // Copy file to the target location (Replacing existing file with the same name)
+            val targetLocation = targetDirectory.resolve(changedFileName)
+
+            // if a file with the same name already exists in a repository, delete and recreate it
+            val file = File(targetLocation.toString())
+            if (file.exists())
+                file.delete()
+            file.createNewFile()
+
+            return filePart.transferTo(file).thenReturn(changedFileName)
+        }
+    }
+}
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/validator/ModelTypeValidator.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/validator/ModelTypeValidator.kt
new file mode 100644
index 000000000..1428c81d6
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/validator/ModelTypeValidator.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.onap.ccsdk.apps.controllerblueprints.service.validator
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+
+class ModelTypeValidator {
+    companion object {
+        /**
+         * This is a validateModelTypeDefinition
+         *
+         * @param definitionType definitionType
+         * @param definitionContent definitionContent
+         * @return boolean
+         */
+        fun validateModelTypeDefinition(definitionType: String, definitionContent: JsonNode): Boolean {
+
+            when (definitionType) {
+                BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE -> {
+                    JacksonUtils.readValue(definitionContent, DataType::class.java)
+                            ?: throw BluePrintException("Model type definition is not DataType valid content $definitionContent")
+                }
+                BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE -> {
+                    JacksonUtils.readValue(definitionContent, NodeType::class.java)
+                            ?: throw BluePrintException("Model type definition is not NodeType valid content $definitionContent")
+                }
+                BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE -> {
+                    JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
+                            ?: throw BluePrintException("Model type definition is not ArtifactType valid content $definitionContent")
+                }
+                BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE -> {
+                    JacksonUtils.readValue(definitionContent, CapabilityDefinition::class.java)
+                            ?: throw BluePrintException("Model type definition is not CapabilityDefinition valid content $definitionContent")
+                }
+                BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE -> {
+                    JacksonUtils.readValue(definitionContent, RelationshipType::class.java)
+                            ?: throw BluePrintException("Model type definition is not RelationshipType valid content $definitionContent")
+                }
+            }
+            return true
+        }
+
+        /**
+         * This is a validateModelType method
+         *
+         * @param modelType modelType
+         * @return boolean
+         */
+        fun validateModelType(modelType: ModelType?): Boolean {
+            checkNotNull(modelType) { "Model Type Information is missing." }
+
+            val validRootTypes = BluePrintTypes.validModelTypes()
+
+            check(validRootTypes.contains(modelType.definitionType)) {
+                "Not Valid Model Root Type(${modelType.definitionType}), It should be $validRootTypes"
+            }
+
+            validateModelTypeDefinition(modelType.definitionType, modelType.definition)
+            return true
+        }
+    }
+
+}