4 files changed, 349 insertions, 22 deletions
diff --git a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java
index 8e98f947..ef3b4a48 100644
--- a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java
+++ b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java
@@ -25,12 +25,13 @@ import org.jetbrains.annotations.NotNull;
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException;
 import org.onap.ccsdk.apps.controllerblueprints.core.ConfigModelConstant;
 import org.onap.ccsdk.apps.controllerblueprints.core.data.*;
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerDefaultService;
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService;
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceDefinitionRepoService;
+import org.onap.ccsdk.apps.controllerblueprints.service.enhancer.BluePrintEnhancerDefaultService;
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils;
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment;
 import com.att.eelf.configuration.EELFLogger;
 import com.att.eelf.configuration.EELFManager;
+import org.onap.ccsdk.apps.controllerblueprints.service.enhancer.ResourceAssignmentEnhancerService;
 import org.springframework.stereotype.Service;
 
 import java.util.HashMap;
@@ -48,14 +49,18 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService {
 
     private static EELFLogger log = EELFManager.getInstance().getLogger(BluePrintEnhancerService.class);
 
+    private ResourceAssignmentEnhancerService resourceAssignmentEnhancerService;
+
     private Map<String, DataType> recipeDataTypes = new HashMap<>();
 
-    public BluePrintEnhancerService(BluePrintRepoService bluePrintEnhancerRepoDBService) {
-        super(bluePrintEnhancerRepoDBService);
+    public BluePrintEnhancerService(ResourceDefinitionRepoService resourceDefinitionRepoService,
+                                    ResourceAssignmentEnhancerService resourceAssignmentEnhancerService) {
+        super(resourceDefinitionRepoService);
+        this.resourceAssignmentEnhancerService = resourceAssignmentEnhancerService;
     }
 
     @Override
-    public void enrichTopologyTemplate(@NotNull ServiceTemplate serviceTemplate) throws BluePrintException{
+    public void enrichTopologyTemplate(@NotNull ServiceTemplate serviceTemplate) throws BluePrintException {
         super.enrichTopologyTemplate(serviceTemplate);
 
         // Update the Recipe Inputs and DataTypes
@@ -101,7 +106,7 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService {
             // Modified for ONAP converted Object to JsonNode
             JsonNode recipeNames = nodeTemplate.getProperties().get(ConfigModelConstant.PROPERTY_RECIPE_NAMES);
 
-            log.info("Processing Receipe Names : {} ", recipeNames);
+            log.info("Processing Recipe Names : {} ", recipeNames);
 
             if (recipeNames != null && recipeNames.isArray() && recipeNames.size() > 0) {
 
@@ -159,6 +164,9 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService {
                         JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment.class);
 
                 Preconditions.checkNotNull(resourceAssignments, "Failed to Processing Resource Mapping " + resourceAssignmentContent);
+                // Enhance Resource Assignment
+                resourceAssignmentEnhancerService.enhanceBluePrint(this, resourceAssignments);
+
                 dataTypeProperties = new HashMap<>();
 
                 for (ResourceAssignment resourceAssignment : resourceAssignments) {
@@ -167,9 +175,6 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService {
                             && resourceAssignment.getProperty() != null
                             && StringUtils.isNotBlank(resourceAssignment.getName())) {
 
-                        // Enrich the Property Definition
-                        super.enrichPropertyDefinition(resourceAssignment.getName(), resourceAssignment.getProperty());
-
                         dataTypeProperties.put(resourceAssignment.getName(), resourceAssignment.getProperty());
 
                     }
diff --git a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java
index 5510e480..16cc8415 100644
--- a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java
+++ b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java
@@ -23,28 +23,35 @@ import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException;
 import org.onap.ccsdk.apps.controllerblueprints.core.data.*;
-import org.onap.ccsdk.apps.controllerblueprints.core.service.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.resource.dict.service.ResourceDefinitionRepoService;
 import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType;
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary;
 import org.onap.ccsdk.apps.controllerblueprints.service.repository.ModelTypeRepository;
+import org.onap.ccsdk.apps.controllerblueprints.service.repository.ResourceDictionaryRepository;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
 
 import java.util.Optional;
 
 /**
- * BluePrintRepoDBService
+ * ResourceDefinitionRepoDBService
  *
  * @author Brinda Santh
  */
 @Service
 @SuppressWarnings("unused")
-public class BluePrintRepoDBService implements BluePrintRepoService {
+public class ResourceDefinitionRepoDBService implements ResourceDefinitionRepoService {
 
     private ModelTypeRepository modelTypeRepository;
+    private ResourceDictionaryRepository resourceDictionaryRepository;
+
     @SuppressWarnings("unused")
-    public BluePrintRepoDBService(ModelTypeRepository modelTypeRepository) {
+    public ResourceDefinitionRepoDBService(ModelTypeRepository modelTypeRepository,
+                                           ResourceDictionaryRepository resourceDictionaryRepository) {
         this.modelTypeRepository = modelTypeRepository;
+        this.resourceDictionaryRepository = resourceDictionaryRepository;
     }
 
     @Override
@@ -72,6 +79,17 @@ public class BluePrintRepoDBService implements BluePrintRepoService {
         return getModelType(capabilityDefinitionName, CapabilityDefinition.class);
     }
 
+    @NotNull
+    @Override
+    public Mono<ResourceDefinition> getResourceDefinition(@NotNull String resourceDefinitionName) throws BluePrintException{
+        Optional<ResourceDictionary> dbResourceDictionary = resourceDictionaryRepository.findByName(resourceDefinitionName);
+        if(dbResourceDictionary.isPresent()){
+            return Mono.just(dbResourceDictionary.get().getDefinition());
+        }else{
+            throw new BluePrintException(String.format("failed to get resource dictionary (%s) from repo", resourceDefinitionName));
+        }
+    }
+
     private <T> Mono<T> getModelType(String modelName, Class<T> valueClass) throws BluePrintException {
         Preconditions.checkArgument(StringUtils.isNotBlank(modelName),
                 "Failed to get model from repo, model name is missing");
diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt
new file mode 100644
index 00000000..cf9e96e7
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt
@@ -0,0 +1,272 @@
+/*
+ * 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 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.format
+import com.att.eelf.configuration.EELFLogger
+import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonReactorUtils
+import java.io.Serializable
+
+/**
+ * BluePrintEnhancerService
+ * @author Brinda Santh
+ *
+ */
+interface BluePrintEnhancerService : Serializable {
+
+    @Throws(BluePrintException::class)
+    fun enhance(content: String): ServiceTemplate
+
+    /**
+     * Read Blueprint from CSAR structure Directory
+     */
+    @Throws(BluePrintException::class)
+    fun enhance(fileName: String, basePath: String): ServiceTemplate
+
+    @Throws(BluePrintException::class)
+    fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate
+
+    @Throws(BluePrintException::class)
+    fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate)
+
+    @Throws(BluePrintException::class)
+    fun enrichNodeType(nodeTypeName: String, nodeType: NodeType)
+
+    @Throws(BluePrintException::class)
+    fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition)
+}
+
+open class BluePrintEnhancerDefaultService(val bluePrintRepoService: BluePrintRepoService) : BluePrintEnhancerService {
+
+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerDefaultService::class.toString())
+
+    lateinit var serviceTemplate: ServiceTemplate
+
+    @Throws(BluePrintException::class)
+    override fun enhance(content: String): ServiceTemplate {
+        return JacksonReactorUtils.readValueFromFile(content, ServiceTemplate::class.java).map { serviceTemplate ->
+            enhance(serviceTemplate!!)
+        }.block()!!
+    }
+
+    @Throws(BluePrintException::class)
+    override fun enhance(fileName: String, basePath: String): ServiceTemplate {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    @Throws(BluePrintException::class)
+    override fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate {
+        this.serviceTemplate = serviceTemplate
+        initialCleanUp()
+        enrichTopologyTemplate(serviceTemplate)
+
+        // log.info("Enriched Blueprint :\n {}", JacksonUtils.getJson(serviceTemplate, true))
+        return this.serviceTemplate
+    }
+
+    open fun initialCleanUp() {
+        serviceTemplate.artifactTypes?.clear()
+        serviceTemplate.nodeTypes?.clear()
+        serviceTemplate.dataTypes?.clear()
+
+        serviceTemplate.artifactTypes = HashMap()
+        serviceTemplate.nodeTypes = HashMap()
+        serviceTemplate.dataTypes = HashMap()
+
+    }
+
+    @Throws(BluePrintException::class)
+    open fun enrichTopologyTemplate(serviceTemplate: ServiceTemplate) {
+        serviceTemplate.topologyTemplate?.let { topologyTemplate ->
+            enrichTopologyTemplateInputs(topologyTemplate)
+            enrichTopologyTemplateNodeTemplates(topologyTemplate)
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    open fun enrichTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {
+        topologyTemplate.inputs?.let { inputs ->
+            enrichPropertyDefinitions(inputs)
+        }
+    }
+
+    open fun enrichTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {
+        topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->
+            enrichNodeTemplate(nodeTemplateName, nodeTemplate)
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    override fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+        val nodeTypeName = nodeTemplate.type
+        // Get NodeType from Repo and Update Service Template
+        val nodeType = populateNodeType(nodeTypeName)
+
+        // Enrich NodeType
+        enrichNodeType(nodeTypeName, nodeType)
+
+        //Enrich Node Template Artifacts
+        enrichNodeTemplateArtifactDefinition(nodeTemplateName, nodeTemplate)
+    }
+
+    @Throws(BluePrintException::class)
+    override fun enrichNodeType(nodeTypeName: String, nodeType: NodeType) {
+        log.debug("Enriching NodeType({})", nodeTypeName)
+        val derivedFrom = nodeType.derivedFrom
+
+        if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
+            val derivedFromNodeType = populateNodeType(nodeTypeName)
+            // Enrich NodeType
+            enrichNodeType(derivedFrom, derivedFromNodeType)
+        }
+
+        // NodeType Property Definitions
+        enrichNodeTypeProperties(nodeTypeName, nodeType)
+
+        //NodeType Requirement
+        enrichNodeTypeRequirements(nodeTypeName, nodeType)
+
+        //NodeType Capability
+        enrichNodeTypeCapabilityProperties(nodeTypeName, nodeType)
+
+        //NodeType Interface
+        enrichNodeTypeInterfaces(nodeTypeName, nodeType)
+    }
+
+    open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.properties?.let { enrichPropertyDefinitions(nodeType.properties!!) }
+    }
+
+    open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {
+
+        nodeType.requirements?.forEach { _, requirementDefinition ->
+            // Populate Requirement Node
+            requirementDefinition.node?.let { requirementNodeTypeName ->
+                // Get Requirement NodeType from Repo and Update Service Template
+                val requirementNodeType = populateNodeType(requirementNodeTypeName)
+
+                enrichNodeType(requirementNodeTypeName, requirementNodeType)
+            }
+        }
+    }
+
+    open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {
+        nodeType.capabilities?.forEach { capabilityDefinitionName, capabilityDefinition ->
+            capabilityDefinition.properties?.let { properties ->
+                enrichPropertyDefinitions(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)
+            enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)
+        }
+    }
+
+    open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {
+        operation.inputs?.let { inputs ->
+            enrichPropertyDefinitions(inputs)
+        }
+    }
+
+    open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {
+        operation.outputs?.let { inputs ->
+            enrichPropertyDefinitions(inputs)
+        }
+    }
+
+    open fun enrichPropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {
+
+        properties.forEach { propertyName, propertyDefinition ->
+            enrichPropertyDefinition(propertyName, propertyDefinition)
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    override fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition) {
+        val propertyType = propertyDefinition.type
+        if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {
+
+        } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+            val entrySchema = propertyDefinition.entrySchema
+                    ?: throw BluePrintException(format("Entry Schema is missing for collection property : {}", propertyName))
+
+            if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
+                populateDataTypes(entrySchema.type)
+            }
+        } else {
+            populateDataTypes(propertyType)
+        }
+
+    }
+
+    open fun enrichNodeTemplateArtifactDefinition(nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+
+        nodeTemplate.artifacts?.forEach { artifactDefinitionName, artifactDefinition ->
+            val artifactTypeName = artifactDefinition.type
+                    ?: throw BluePrintException(format("Artifact type is missing for NodeTemplate({}) artifact({})", nodeTemplateName, artifactDefinitionName))
+
+            // Populate Artifact Type
+            populateArtifactType(artifactTypeName)
+        }
+    }
+
+    open fun populateNodeType(nodeTypeName: String): NodeType {
+
+        val nodeType = serviceTemplate.nodeTypes?.get(nodeTypeName)
+                ?: bluePrintRepoService.getNodeType(nodeTypeName)?.block()
+                ?: throw BluePrintException(format("Couldn't get NodeType({}) from repo.", nodeTypeName))
+        serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)
+        return nodeType
+    }
+
+    open fun populateArtifactType(artifactTypeName: String): ArtifactType {
+        val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)
+                ?: bluePrintRepoService.getArtifactType(artifactTypeName)?.block()
+                ?: throw BluePrintException(format("Couldn't get ArtifactType({}) from repo.", artifactTypeName))
+        serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)
+        return artifactType
+    }
+
+    open fun populateDataTypes(dataTypeName: String): DataType {
+        val dataType = serviceTemplate.dataTypes?.get(dataTypeName)
+                ?: bluePrintRepoService.getDataType(dataTypeName)?.block()
+                ?: throw BluePrintException(format("Couldn't get DataType({}) from repo.", dataTypeName))
+        serviceTemplate.dataTypes?.put(dataTypeName, dataType)
+        return dataType
+    }
+
+}
+
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
index 0d08985a..de6f82ff 100644
--- 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
@@ -19,13 +19,16 @@ package org.onap.ccsdk.apps.controllerblueprints.service.enhancer
 import com.att.eelf.configuration.EELFLogger
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
 import org.onap.ccsdk.apps.controllerblueprints.core.data.ServiceTemplate
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerDefaultService
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerService
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
 import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.format
+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.resource.dict.service.ResourceAssignmentValidationDefaultService
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceDefinitionRepoService
+import org.springframework.stereotype.Service
 
 /**
  * ResourceAssignmentEnhancerService.
@@ -47,6 +50,7 @@ interface ResourceAssignmentEnhancerService {
  *
  * @author Brinda Santh
  */
+@Service
 open class ResourceAssignmentEnhancerDefaultService(private val resourceDefinitionRepoService: ResourceDefinitionRepoService)
     : ResourceAssignmentEnhancerService {
     private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentValidationDefaultService::class.java)
@@ -58,20 +62,41 @@ open class ResourceAssignmentEnhancerDefaultService(private val resourceDefiniti
     override fun enhanceBluePrint(bluePrintEnhancerService: BluePrintEnhancerService,
                                   resourceAssignments: List<ResourceAssignment>) {
 
+        val uniqueSourceNodeTypeNames = hashSetOf<String>()
+
         // Iterate the Resource Assignment and
         resourceAssignments.map { resourceAssignment ->
             val dictionaryName = resourceAssignment.dictionaryName!!
             val dictionarySource = resourceAssignment.dictionarySource!!
-            log.info("Enriching Assignment name({}), dictionary name({}), source({})", resourceAssignment.name,
+            log.debug("Enriching Assignment name({}), dictionary name({}), source({})", resourceAssignment.name,
                     dictionaryName, dictionarySource)
-            // Get the Resource Definition from Repo
-            val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)
+            val sourceNodeTypeName = ResourceSourceMappingFactory.getRegisterSourceMapping(dictionarySource)
+
+            // Add Unique Node Types
+            uniqueSourceNodeTypeNames.add(sourceNodeTypeName)
+
+            // TODO("Candidate for Optimisation")
+            if (checkResourceDefinitionNeeded(resourceAssignment)) {
+
+                bluePrintEnhancerService.enrichPropertyDefinition(resourceAssignment.name, resourceAssignment.property!!);
+
+                // Get the Resource Definition from Repo
+                val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)
 
-            val sourceNodeTemplate = resourceDefinition.sources.get(dictionarySource)
+                val sourceNodeTemplate = resourceDefinition.sources.get(dictionarySource)
+                        ?: throw BluePrintException(format("failed to get assigned dictionarySource({}) from resourceDefinition({})", dictionarySource, dictionaryName))
 
-            // Enrich as NodeTemplate
-            bluePrintEnhancerService.enrichNodeTemplate(dictionarySource, sourceNodeTemplate!!)
+                // Enrich as NodeTemplate
+                bluePrintEnhancerService.enrichNodeTemplate(dictionarySource, sourceNodeTemplate)
+            }
         }
+        // Enrich the ResourceSource NodeTypes
+        uniqueSourceNodeTypeNames.map { nodeTypeName ->
+            resourceDefinitionRepoService.getNodeType(nodeTypeName).subscribe { nodeType ->
+                bluePrintEnhancerService.enrichNodeType(nodeTypeName, nodeType)
+            }
+        }
+
     }
 
     override fun enhanceBluePrint(resourceAssignments: List<ResourceAssignment>): ServiceTemplate {
@@ -82,7 +107,14 @@ open class ResourceAssignmentEnhancerDefaultService(private val resourceDefiniti
         return bluePrintEnhancerService.serviceTemplate
     }
 
+    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).block()!!
+        return resourceDefinitionRepoService.getResourceDefinition(name).block()
+                ?: throw BluePrintException(format("failed to get dictionary definition({})", name))
     }
 }
 \ No newline at end of file