gerrit.onap Code Review - sdc.git/blob

   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 package org.openecomp.sdc.be.components.impl;
  21
  22 import java.util.ArrayList;
  23 import java.util.Arrays;
  24 import java.util.Collections;
  25 import java.util.Iterator;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Map.Entry;
  29 import java.util.stream.Collectors;
  30
  31 import javax.annotation.Resource;
  32
  33 import org.apache.commons.collections.MapUtils;
  34 import org.apache.commons.lang3.StringUtils;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  37 import org.openecomp.sdc.be.impl.ComponentsUtils;
  38 import org.openecomp.sdc.be.model.InterfaceDefinition;
  39 import org.openecomp.sdc.be.model.Operation;
  40 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  41 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  42 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  43 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
  44 import org.openecomp.sdc.common.log.wrappers.Logger;
  45 import org.openecomp.sdc.exception.ResponseFormat;
  46 import org.springframework.stereotype.Component;
  47
  48 import fj.data.Either;
  49
  50 @Component("interfaceLifecycleTypeImportManager")
  51 public class InterfaceLifecycleTypeImportManager {
  52
  53     private static final Logger log = Logger.getLogger(InterfaceLifecycleTypeImportManager.class);
  54     @Resource
  55     private IInterfaceLifecycleOperation interfaceLifecycleOperation;
  56     @Resource
  57     private ComponentsUtils componentsUtils;
  58     @Resource
  59     private CommonImportManager commonImportManager;
  60
  61     public Either<List<InterfaceDefinition>, ResponseFormat> createLifecycleTypes(String interfaceLifecycleTypesYml, final String modelName) {
  62         Either<List<InterfaceDefinition>, ActionStatus> interfaces = createInterfaceTypeFromYml(interfaceLifecycleTypesYml, modelName);
  63         if (interfaces.isRight()) {
  64             ActionStatus status = interfaces.right().value();
  65             ResponseFormat responseFormat = componentsUtils.getResponseFormatByGroupType(status, null);
  66             return Either.right(responseFormat);
  67         }
  68         return createInterfacesByDao(interfaces.left().value());
  69     }
  70
  71     private Either<List<InterfaceDefinition>, ActionStatus> createInterfaceTypeFromYml(final String interfaceTypesYml, final String modelName) {
  72         final Either<List<InterfaceDefinition>, ActionStatus> interfaceTypes = commonImportManager.createElementTypesFromYml(interfaceTypesYml, this::createInterfaceDefinition);
  73         if (interfaceTypes.isLeft() && StringUtils.isNotEmpty(modelName)){
  74             interfaceTypes.left().value().forEach(interfaceType -> interfaceType.setModel(modelName));
  75         }
  76         return interfaceTypes;
  77     }
  78
  79     private Either<List<InterfaceDefinition>, ResponseFormat> createInterfacesByDao(List<InterfaceDefinition> interfacesToCreate) {
  80         List<InterfaceDefinition> createdInterfaces = new ArrayList<>();
  81         Either<List<InterfaceDefinition>, ResponseFormat> eitherResult = Either.left(createdInterfaces);
  82         Iterator<InterfaceDefinition> interfaceItr = interfacesToCreate.iterator();
  83         boolean stopDao = false;
  84         while (interfaceItr.hasNext() && !stopDao) {
  85             InterfaceDefinition interfaceDef = interfaceItr.next();
  86             log.info("send interfaceDefinition {} to dao for create", interfaceDef.getType());
  87             Either<InterfaceDefinition, StorageOperationStatus> dataModelResponse = interfaceLifecycleOperation.createInterfaceType(interfaceDef);
  88             if (dataModelResponse.isRight()) {
  89                 log.info("failed to create interface : {}  error: {}", interfaceDef.getType(), dataModelResponse.right().value().name());
  90                 if (dataModelResponse.right().value() != StorageOperationStatus.SCHEMA_VIOLATION) {
  91                     ResponseFormat responseFormat = componentsUtils
  92                         .getResponseFormat(componentsUtils.convertFromStorageResponseForLifecycleType(dataModelResponse.right().value()),
  93                             interfaceDef.getType());
  94                     eitherResult = Either.right(responseFormat);
  95                     stopDao = true;
  96                 }
  97             } else {
  98                 createdInterfaces.add(dataModelResponse.left().value());
  99             }
 100             if (!interfaceItr.hasNext()) {
 101                 log.info("lifecycle types were created successfully!!!");
 102             }
 103         }
 104         return eitherResult;
 105     }
 106
 107     private InterfaceDefinition createInterfaceDefinition(final String interfaceDefinition, final Map<String, Object> toscaJson) {
 108         final InterfaceDefinition interfaceDef = new InterfaceDefinition();
 109         interfaceDef.setType(interfaceDefinition);
 110         final Object descriptionObj = toscaJson.get(ToscaTagNamesEnum.DESCRIPTION.getElementName());
 111         if (descriptionObj instanceof String) {
 112             interfaceDef.setDescription((String) descriptionObj);
 113         }
 114         final Object derivedFromObj = toscaJson.get(ToscaTagNamesEnum.DERIVED_FROM.getElementName());
 115         if (derivedFromObj instanceof String) {
 116             interfaceDef.setDerivedFrom((String) derivedFromObj);
 117         }
 118         final Object versionObj = toscaJson.get(ToscaTagNamesEnum.VERSION.getElementName());
 119         if (versionObj instanceof String) {
 120             interfaceDef.setVersion((String) versionObj);
 121         }
 122         final Object metadataObj = toscaJson.get(ToscaTagNamesEnum.METADATA.getElementName());
 123         if (metadataObj instanceof Map) {
 124             interfaceDef.setToscaPresentationValue(JsonPresentationFields.METADATA, metadataObj);
 125         }
 126         final Map<String, Object> operationsMap;
 127         if (toscaJson.containsKey(ToscaTagNamesEnum.OPERATIONS.getElementName())) {
 128             operationsMap = (Map<String, Object>) toscaJson.get(ToscaTagNamesEnum.OPERATIONS.getElementName());
 129         } else {
 130             final List<String> entitySchemaEntryList = Arrays
 131                 .asList(ToscaTagNamesEnum.DERIVED_FROM.getElementName(), ToscaTagNamesEnum.DESCRIPTION.getElementName(),
 132                     ToscaTagNamesEnum.VERSION.getElementName(), ToscaTagNamesEnum.METADATA.getElementName(),
 133                     ToscaTagNamesEnum.INPUTS.getElementName(), ToscaTagNamesEnum.NOTIFICATIONS.getElementName());
 134             operationsMap = toscaJson.entrySet().stream().filter(interfaceEntry -> !entitySchemaEntryList.contains(interfaceEntry.getKey()))
 135                 .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
 136         }
 137         interfaceDef.setOperationsMap(handleOperations(operationsMap));
 138         return interfaceDef;
 139     }
 140
 141     private Map<String, Operation> handleOperations(final Map<String, Object> operationsToscaEntry) {
 142         if (MapUtils.isEmpty(operationsToscaEntry)) {
 143             return Collections.emptyMap();
 144         }
 145         return operationsToscaEntry.entrySet().stream()
 146             .collect(Collectors.toMap(Entry::getKey, operationEntry -> createOperation((Map<String, Object>) operationEntry.getValue())));
 147     }
 148
 149     private Operation createOperation(final Map<String, Object> toscaOperationMap) {
 150         final Operation operation = new Operation();
 151         operation.setDescription((String) toscaOperationMap.get(ToscaTagNamesEnum.DESCRIPTION.getElementName()));
 152         return operation;
 153     }
 154 }