catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/UiComponentDataConverter.java

   1 package org.openecomp.sdc.be.datamodel.utils;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6
   7 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
   8 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
   9 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
  10 import org.openecomp.sdc.be.model.Component;
  11 import org.openecomp.sdc.be.model.Resource;
  12 import org.openecomp.sdc.be.model.Service;
  13 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  14 import org.openecomp.sdc.be.ui.model.UiComponentMetadata;
  15 import org.openecomp.sdc.be.ui.model.UiResourceDataTransfer;
  16 import org.openecomp.sdc.be.ui.model.UiResourceMetadata;
  17 import org.openecomp.sdc.be.ui.model.UiServiceDataTransfer;
  18 import org.openecomp.sdc.be.ui.model.UiServiceMetadata;
  19
  20 public class UiComponentDataConverter {
  21
  22         public static void setUiTranferDataByFieldName(UiComponentDataTransfer dataTransfer, Component component, String fieldName) {
  23
  24                         switch (ComponentFieldsEnum.findByValue(fieldName)) {
  25
  26                                 case INPUTS:
  27                                         if(component.getInputs() == null){
  28                                                 dataTransfer.setInputs(new ArrayList<>());
  29                                         } else {
  30                                                 dataTransfer.setInputs(component.getInputs());
  31                                         }
  32                                         break;
  33
  34                                 case COMPONENT_INSTANCE_RELATION:
  35                                         if(component.getComponentInstancesRelations() == null){
  36                                                 dataTransfer.setComponentInstancesRelations(new ArrayList<>());
  37                                         } else {
  38                                                 dataTransfer.setComponentInstancesRelations(component.getComponentInstancesRelations());
  39                                         }
  40
  41                                         break;
  42
  43                                 case GROUPS:
  44                                         if(component.getGroups() == null){
  45                                                 dataTransfer.setGroups(new ArrayList<>());
  46                                         } else {
  47                                                 dataTransfer.setGroups(component.getGroups());
  48                                         }
  49                                         break;
  50
  51                                 case COMPONENT_INSTANCES:
  52                                         if(component.getComponentInstances() == null) {
  53                                                 dataTransfer.setComponentInstances(new ArrayList<>());
  54                                         } else {
  55                                                 dataTransfer.setComponentInstances(component.getComponentInstances());
  56                                         }
  57                                         break;
  58
  59                                 case COMPONENT_INSTANCES_PROPERTIES:
  60                                         if(component.getComponentInstancesProperties() == null) {
  61                                                 dataTransfer.setComponentInstancesProperties(new HashMap<>());
  62                                         } else {
  63                                                 dataTransfer.setComponentInstancesProperties(component.getComponentInstancesProperties());
  64                                         }
  65                                         break;
  66
  67                                 case CAPABILITIES:
  68                                         if(component.getCapabilities() == null) {
  69                                                 dataTransfer.setCapabilities(new HashMap<>());
  70                                         } else {
  71                                                 dataTransfer.setCapabilities(component.getCapabilities());
  72                                         }
  73                                         break;
  74
  75                                 case REQUIREMENTS:
  76                                         if(component.getRequirements() == null) {
  77                                                 dataTransfer.setRequirements(new HashMap<>());
  78                                         } else {
  79                                                 dataTransfer.setRequirements(component.getRequirements());
  80                                         }
  81                                         break;
  82
  83                                 case DEPLOYMENT_ARTIFACTS:
  84                                         if(component.getDeploymentArtifacts() == null) {
  85                                                 dataTransfer.setDeploymentArtifacts(new HashMap<>());
  86                                         } else {
  87                                                 dataTransfer.setDeploymentArtifacts(component.getDeploymentArtifacts());
  88                                         }
  89                                         break;
  90
  91                                 case TOSCA_ARTIFACTS:
  92                                         if(component.getToscaArtifacts() == null) {
  93                                                 dataTransfer.setToscaArtifacts(new HashMap<>());
  94                                         } else {
  95                                                 dataTransfer.setToscaArtifacts(component.getToscaArtifacts());
  96                                         }
  97                                         break;
  98
  99                                 case ARTIFACTS:
 100                                         if(component.getArtifacts() == null) {
 101                                                 dataTransfer.setArtifacts(new HashMap<>());
 102                                         } else {
 103                                                 dataTransfer.setArtifacts(component.getArtifacts());
 104                                         }
 105                                         break;
 106
 107                                 case COMPONENT_INSTANCES_ATTRIBUTES:
 108                                         if(component.getComponentInstancesAttributes() == null) {
 109                                                 dataTransfer.setComponentInstancesAttributes(new HashMap<>());
 110                                         } else {
 111                                                 dataTransfer.setComponentInstancesAttributes(component.getComponentInstancesAttributes());
 112                                         }
 113                                         break;
 114
 115                                 case COMPONENT_INSTANCE_INPUTS:
 116                                         if(component.getComponentInstancesInputs() == null) {
 117                                                 dataTransfer.setComponentInstancesInputs(new HashMap<>());
 118                                         } else {
 119                                                 dataTransfer.setComponentInstancesInputs(component.getComponentInstancesInputs());
 120                                         }
 121
 122                                         break;
 123
 124
 125                                 default:
 126                                         break;
 127                         }
 128
 129         }
 130
 131
 132         public static UiComponentDataTransfer getUiDataTransferFromResourceByParams(Resource resource, List<String> paramsToReturn) {
 133                 UiResourceDataTransfer dataTransfer = new UiResourceDataTransfer();
 134
 135                 for(String fieldName: paramsToReturn){
 136
 137                         switch (ComponentFieldsEnum.findByValue(fieldName)) {
 138
 139                                 case PROPERTIES:
 140                                         if(resource.getProperties() == null) {
 141                                                 dataTransfer.setProperties(new ArrayList<>());
 142                                         } else {
 143                                                 dataTransfer.setProperties(resource.getProperties());
 144                                         }
 145                                         break;
 146
 147                                 case INTERFACES:
 148                                         if(resource.getInterfaces() == null) {
 149                                                 dataTransfer.setInterfaces(new HashMap<>());
 150                                         } else {
 151                                                 dataTransfer.setInterfaces(resource.getInterfaces());
 152                                         }
 153                                         break;
 154
 155                                 case DERIVED_FROM:
 156                                         if(resource.getDerivedFrom() == null) {
 157                                                 dataTransfer.setDerivedFrom(new ArrayList<>());
 158                                         } else {
 159                                                 dataTransfer.setDerivedFrom(resource.getDerivedFrom());
 160                                         }
 161                                         break;
 162
 163                                 case ATTRIBUTES:
 164                                         if(resource.getAttributes() == null) {
 165                                                 dataTransfer.setAttributes(new ArrayList<>());
 166                                         } else {
 167                                                 dataTransfer.setAttributes(resource.getAttributes());
 168                                         }
 169                                         break;
 170
 171                                 case ADDITIONAL_INFORMATION:
 172                                         if(resource.getAdditionalInformation() == null) {
 173                                                 dataTransfer.setAdditionalInformation(new ArrayList<>());
 174                                         } else {
 175                                                 dataTransfer.setAdditionalInformation(resource.getAdditionalInformation());
 176                                         }
 177                                         break;
 178                                 case METADATA:
 179                                         UiResourceMetadata metadata = new UiResourceMetadata(resource.getCategories(),  resource.getDerivedFrom(), (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
 180                                         dataTransfer.setMetadata(metadata);
 181                                         break;
 182
 183                                 default:
 184                                         setUiTranferDataByFieldName(dataTransfer, resource, fieldName);
 185                         }
 186                 }
 187
 188                 return dataTransfer;
 189         }
 190
 191         public static UiComponentDataTransfer getUiDataTransferFromServiceByParams(Service service, List<String> paramsToReturn) {
 192                 UiServiceDataTransfer dataTransfer = new UiServiceDataTransfer();
 193
 194                 for(String fieldName: paramsToReturn){
 195
 196                         switch (ComponentFieldsEnum.findByValue(fieldName)) {
 197
 198                                 case SERVICE_API_ARTIFACTS:
 199                                         if(service.getServiceApiArtifacts() == null) {
 200                                                 dataTransfer.setServiceApiArtifacts(new HashMap<>());
 201                                         } else {
 202                                                 dataTransfer.setServiceApiArtifacts(service.getServiceApiArtifacts());
 203                                         }
 204
 205                                         break;
 206
 207                                 case METADATA:
 208                                         UiServiceMetadata metadata = new UiServiceMetadata(service.getCategories(),  (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition().getMetadataDataDefinition());
 209                                         dataTransfer.setMetadata(metadata);
 210                                         break;
 211                                 default:
 212                                         setUiTranferDataByFieldName(dataTransfer, service, fieldName);
 213                                 }
 214                 }
 215
 216                 return dataTransfer;
 217         }
 218
 219
 220         public static UiComponentMetadata convertToUiComponentMetadata(Component component) {
 221
 222                 UiComponentMetadata uiComponentMetadata = null;
 223                 switch (component.getComponentType()) {
 224                         case RESOURCE:
 225                                 Resource resource = (Resource)component;
 226                                 uiComponentMetadata = new UiResourceMetadata(component.getCategories(),  resource.getDerivedFrom(), (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
 227                                 break;
 228                         case SERVICE:
 229                                 uiComponentMetadata = new UiServiceMetadata(component.getCategories(),  (ServiceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition());
 230                         default:
 231
 232                 }
 233                 return uiComponentMetadata;
 234         }
 235 }