catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceLifecycleTypeImportManager.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Collections;
  27 import java.util.HashMap;
  28 import java.util.Iterator;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Map.Entry;
  32 import java.util.Optional;
  33 import java.util.stream.Collectors;
  34 import java.util.stream.Stream;
  35 import javax.annotation.Resource;
  36 import org.apache.commons.collections.MapUtils;
  37 import org.apache.commons.lang3.StringUtils;
  38 import org.openecomp.sdc.be.dao.api.ActionStatus;
  39 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  40 import org.openecomp.sdc.be.impl.ComponentsUtils;
  41 import org.openecomp.sdc.be.model.InterfaceDefinition;
  42 import org.openecomp.sdc.be.model.Model;
  43 import org.openecomp.sdc.be.model.Operation;
  44 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  45 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  46 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  47 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
  48 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
  49 import org.openecomp.sdc.common.log.wrappers.Logger;
  50 import org.openecomp.sdc.exception.ResponseFormat;
  51 import org.springframework.stereotype.Component;
  52
  53 @Component("interfaceLifecycleTypeImportManager")
  54 public class InterfaceLifecycleTypeImportManager {
  55
  56     private static final Logger log = Logger.getLogger(InterfaceLifecycleTypeImportManager.class);
  57     @Resource
  58     private IInterfaceLifecycleOperation interfaceLifecycleOperation;
  59     @Resource
  60     private ComponentsUtils componentsUtils;
  61     @Resource
  62     private CommonImportManager commonImportManager;
  63     @Resource
  64     private ModelOperation modelOperation;
  65
  66     public Either<List<InterfaceDefinition>, ResponseFormat> createLifecycleTypes(String interfaceLifecycleTypesYml, final String modelName,
  67                                                                                   final boolean includeToModelDefaultImports) {
  68         Either<List<InterfaceDefinition>, ActionStatus> interfaces =
  69             createInterfaceTypeFromYml(interfaceLifecycleTypesYml, modelName, !includeToModelDefaultImports);
  70         if (interfaces.isRight()) {
  71             ActionStatus status = interfaces.right().value();
  72             ResponseFormat responseFormat = componentsUtils.getResponseFormatByGroupType(status, null);
  73             return Either.right(responseFormat);
  74         }
  75         final Either<List<InterfaceDefinition>, ResponseFormat> elementTypes = createInterfacesByDao(interfaces.left().value());
  76         if (includeToModelDefaultImports && StringUtils.isNotEmpty(modelName)) {
  77             commonImportManager.addTypesToDefaultImports(ElementTypeEnum.INTERFACE_LIFECYCLE_TYPE, interfaceLifecycleTypesYml, modelName);
  78         }
  79         return elementTypes;
  80     }
  81
  82     private Either<List<InterfaceDefinition>, ActionStatus> createInterfaceTypeFromYml(final String interfaceTypesYml, final String modelName,
  83                                                                                        final boolean normative) {
  84         final Either<List<InterfaceDefinition>, ActionStatus> interfaceTypesEither =
  85             commonImportManager.createElementTypesFromYml(interfaceTypesYml, this::createInterfaceDefinition);
  86         if (interfaceTypesEither.isRight()) {
  87             return interfaceTypesEither;
  88         }
  89         final List<InterfaceDefinition> interfaceTypes = interfaceTypesEither.left().value();
  90         if (StringUtils.isNotEmpty(modelName)) {
  91             final Optional<Model> modelOptional = modelOperation.findModelByName(modelName);
  92             if (modelOptional.isPresent()) {
  93                 interfaceTypes.forEach(interfaceType -> {
  94                     interfaceType.setModel(modelName);
  95                     interfaceType.setUserCreated(!normative);
  96                 });
  97                 return Either.left(interfaceTypes);
  98             }
  99             return Either.right(ActionStatus.INVALID_MODEL);
 100         } else {
 101             interfaceTypes.forEach(interfaceType -> interfaceType.setUserCreated(!normative));
 102         }
 103         return Either.left(interfaceTypes);
 104     }
 105
 106     private Either<List<InterfaceDefinition>, ResponseFormat> createInterfacesByDao(List<InterfaceDefinition> interfacesToCreate) {
 107         List<InterfaceDefinition> createdInterfaces = new ArrayList<>();
 108         Either<List<InterfaceDefinition>, ResponseFormat> eitherResult = Either.left(createdInterfaces);
 109         Iterator<InterfaceDefinition> interfaceItr = interfacesToCreate.iterator();
 110         boolean stopDao = false;
 111         while (interfaceItr.hasNext() && !stopDao) {
 112             InterfaceDefinition interfaceDef = interfaceItr.next();
 113             log.info("send interfaceDefinition {} to dao for create", interfaceDef.getType());
 114             Either<InterfaceDefinition, StorageOperationStatus> dataModelResponse = interfaceLifecycleOperation.createInterfaceType(interfaceDef);
 115             if (dataModelResponse.isRight()) {
 116                 log.info("failed to create interface : {}  error: {}", interfaceDef.getType(), dataModelResponse.right().value().name());
 117                 if (dataModelResponse.right().value() != StorageOperationStatus.SCHEMA_VIOLATION) {
 118                     ResponseFormat responseFormat = componentsUtils
 119                         .getResponseFormat(componentsUtils.convertFromStorageResponseForLifecycleType(dataModelResponse.right().value()),
 120                             interfaceDef.getType());
 121                     eitherResult = Either.right(responseFormat);
 122                     stopDao = true;
 123                 }
 124             } else {
 125                 createdInterfaces.add(dataModelResponse.left().value());
 126             }
 127             if (!interfaceItr.hasNext()) {
 128                 log.info("lifecycle types were created successfully!!!");
 129             }
 130         }
 131         return eitherResult;
 132     }
 133
 134     private InterfaceDefinition createInterfaceDefinition(final String interfaceDefinition, final Map<String, Object> toscaJson) {
 135         final InterfaceDefinition interfaceDef = new InterfaceDefinition();
 136         interfaceDef.setType(interfaceDefinition);
 137         final Object descriptionObj = toscaJson.get(ToscaTagNamesEnum.DESCRIPTION.getElementName());
 138         if (descriptionObj instanceof String) {
 139             interfaceDef.setDescription((String) descriptionObj);
 140         }
 141         final Object derivedFromObj = toscaJson.get(ToscaTagNamesEnum.DERIVED_FROM.getElementName());
 142         if (derivedFromObj instanceof String) {
 143             interfaceDef.setDerivedFrom((String) derivedFromObj);
 144         }
 145         final Object versionObj = toscaJson.get(ToscaTagNamesEnum.VERSION.getElementName());
 146         if (versionObj instanceof String) {
 147             interfaceDef.setVersion((String) versionObj);
 148         }
 149         final Object metadataObj = toscaJson.get(ToscaTagNamesEnum.METADATA.getElementName());
 150         if (metadataObj instanceof Map) {
 151             interfaceDef.setToscaPresentationValue(JsonPresentationFields.METADATA, metadataObj);
 152         }
 153         final Map<String, Object> operationsMap;
 154         if (toscaJson.containsKey(ToscaTagNamesEnum.OPERATIONS.getElementName())) {
 155             operationsMap = (Map<String, Object>) toscaJson.get(ToscaTagNamesEnum.OPERATIONS.getElementName());
 156         } else {
 157             final List<String> entitySchemaEntryList = Arrays
 158                 .asList(ToscaTagNamesEnum.DERIVED_FROM.getElementName(), ToscaTagNamesEnum.DESCRIPTION.getElementName(),
 159                     ToscaTagNamesEnum.VERSION.getElementName(), ToscaTagNamesEnum.METADATA.getElementName(),
 160                     ToscaTagNamesEnum.INPUTS.getElementName(), ToscaTagNamesEnum.NOTIFICATIONS.getElementName());
 161
 162             Stream<Entry<String, Object>> oldFormatOperations =
 163                 toscaJson.entrySet().stream().filter(interfaceEntry -> !entitySchemaEntryList.contains(interfaceEntry.getKey()));
 164             operationsMap = new HashMap<>();
 165             oldFormatOperations.forEach(entry -> operationsMap.put(entry.getKey(), entry.getValue()));
 166         }
 167         interfaceDef.setOperationsMap(handleOperations(operationsMap));
 168         return interfaceDef;
 169     }
 170
 171     private Map<String, Operation> handleOperations(final Map<String, Object> operationsToscaEntry) {
 172         if (MapUtils.isEmpty(operationsToscaEntry)) {
 173             return Collections.emptyMap();
 174         }
 175         return operationsToscaEntry.entrySet().stream()
 176             .collect(Collectors.toMap(Entry::getKey, operationEntry -> createOperation((Map<String, Object>) operationEntry.getValue())));
 177     }
 178
 179     private Operation createOperation(final Map<String, Object> toscaOperationMap) {
 180         if (toscaOperationMap == null) {
 181             return new Operation();
 182         }
 183         final Operation operation = new Operation();
 184         operation.setDescription((String) toscaOperationMap.get(ToscaTagNamesEnum.DESCRIPTION.getElementName()));
 185         return operation;
 186     }
 187 }