catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperation.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  18
  19 import fj.data.Either;
  20 import org.apache.commons.collections.MapUtils;
  21 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  22 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  23 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  24 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  25 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  26 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  27 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  28 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  29 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  30 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  31 import org.openecomp.sdc.be.model.CapabilityDefinition;
  32 import org.openecomp.sdc.be.model.Component;
  33 import org.openecomp.sdc.be.model.ComponentParametersView;
  34 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  35 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  36 import org.openecomp.sdc.be.model.operations.StorageException;
  37 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 import java.util.ArrayList;
  42 import java.util.Collections;
  43 import java.util.List;
  44 import java.util.Map;
  45
  46 @org.springframework.stereotype.Component("capabilities-operation")
  47 public class CapabilitiesOperation extends BaseOperation {
  48     private static final Logger LOGGER = LoggerFactory.getLogger(CapabilitiesOperation.class);
  49
  50     public Either<List<CapabilityDefinition>, StorageOperationStatus> addCapabilities(String componentId,
  51                                                                                       List<CapabilityDefinition> capabilityDefinitions) {
  52         return addOrUpdateCapabilities(componentId, capabilityDefinitions, false);
  53     }
  54
  55     public Either<List<CapabilityDefinition>, StorageOperationStatus> updateCapabilities(String componentId,
  56                                                                                          List<CapabilityDefinition> capabilityDefinitions) {
  57         return addOrUpdateCapabilities(componentId, capabilityDefinitions, true);
  58     }
  59
  60     private Either<List<CapabilityDefinition>, StorageOperationStatus> addOrUpdateCapabilities(String componentId,
  61                                                                                                List<CapabilityDefinition> capabilityDefinitions,
  62                                                                                                boolean isUpdateAction) {
  63         StorageOperationStatus statusRes = performUpdateToscaAction(isUpdateAction,
  64                 componentId, Collections.singletonList(convertToListCapabilityDataDefinition(capabilityDefinitions)));
  65         if (!statusRes.equals(StorageOperationStatus.OK)) {
  66             LOGGER.error("Failed to find the parent capability of capability type {}." + " status is {}", componentId,
  67                     statusRes);
  68             return Either.right(statusRes);
  69         }
  70         return Either.left(capabilityDefinitions);
  71     }
  72
  73     public StorageOperationStatus deleteCapabilities(Component component, String capabilityIdToDelete) {
  74         return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES,
  75                 Collections.singletonList(capabilityIdToDelete));
  76     }
  77
  78     public StorageOperationStatus deleteCapabilityProperties(Component component, String capabilityPropIdToDelete) {
  79         return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES_PROPERTIES,
  80                 Collections.singletonList(capabilityPropIdToDelete));
  81     }
  82
  83     private static ListCapabilityDataDefinition convertToListCapabilityDataDefinition(List<CapabilityDefinition> capabilities) {
  84         List<CapabilityDataDefinition> capabilityDefinitions = new ArrayList<>(capabilities);
  85         return new ListCapabilityDataDefinition(capabilityDefinitions);
  86     }
  87
  88     private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, String componentId,
  89                                                             List<ListCapabilityDataDefinition> toscaDataList) {
  90         if (isUpdate) {
  91             return updateToscaDataOfToscaElement(componentId, EdgeLabelEnum.CAPABILITIES,
  92                     VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE);
  93         } else {
  94             return addToscaDataToToscaElement(componentId, EdgeLabelEnum.CAPABILITIES,
  95                     VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE);
  96         }
  97     }
  98
  99     private StorageOperationStatus createOrUpdateCapabilityProperties(String componentId, TopologyTemplate toscaElement,
 100                                                                       Map<String, MapPropertiesDataDefinition> propertiesMap) {
 101         GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum
 102             .NoParse)
 103                 .left().on(this::throwStorageException);
 104         Map<String, MapPropertiesDataDefinition> capabilitiesProperties = toscaElement.getCapabilitiesProperties();
 105         if(MapUtils.isNotEmpty(capabilitiesProperties)) {
 106
 107             capabilitiesProperties.forEach((key, val) -> {
 108                 Map<String, PropertyDataDefinition> mapToscaDataDefinition = val.getMapToscaDataDefinition();
 109                 mapToscaDataDefinition.forEach((key1, val1) -> {
 110
 111                     propertiesMap.forEach((propKey, propVal) -> {
 112                         Map<String, PropertyDataDefinition> propValMapToscaDataDefinition = propVal.getMapToscaDataDefinition();
 113                         propValMapToscaDataDefinition.forEach((propKey1, propVal1) -> {
 114                             if(propKey1.equals(key1) && val1.getUniqueId().equals(propVal1.getUniqueId())) {
 115                                 ToscaDataDefinition.mergeDataMaps(mapToscaDataDefinition, propValMapToscaDataDefinition);
 116                             }
 117                         });
 118                     });
 119                 });
 120             });
 121
 122             ToscaDataDefinition.mergeDataMaps(propertiesMap, capabilitiesProperties);
 123         }
 124
 125         return topologyTemplateOperation.updateFullToscaData(toscaElementV,
 126                 EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, propertiesMap);
 127     }
 128
 129     public StorageOperationStatus createOrUpdateCapabilityProperties(String componentId,
 130                                                                      Map<String, MapPropertiesDataDefinition> propertiesMap) {
 131         StorageOperationStatus propertiesStatusRes = null;
 132         if(MapUtils.isNotEmpty(propertiesMap)) {
 133             propertiesStatusRes = createOrUpdateCapabilityProperties(componentId, getTopologyTemplate(componentId),
 134                     propertiesMap);
 135         }
 136
 137         return propertiesStatusRes;
 138     }
 139
 140     private TopologyTemplate getTopologyTemplate(String componentId) {
 141         return (TopologyTemplate)topologyTemplateOperation
 142                 .getToscaElement(componentId, getFilterComponentWithCapProperties())
 143                 .left()
 144                 .on(this::throwStorageException);
 145     }
 146     private ComponentParametersView getFilterComponentWithCapProperties() {
 147         ComponentParametersView filter = new ComponentParametersView();
 148         filter.setIgnoreCapabiltyProperties(false);
 149         return filter;
 150     }
 151
 152     private ToscaElement throwStorageException(StorageOperationStatus status) {
 153         throw new StorageException(status);
 154     }
 155
 156 }