catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperation.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.model.operations.impl;
  22
  23 import java.util.HashMap;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27 import javax.annotation.Resource;
  28
  29 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  30 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  31 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  32 import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  35 import org.openecomp.sdc.be.model.PropertyDefinition;
  36 import org.openecomp.sdc.be.model.operations.api.IPolicyTypeOperation;
  37 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  38 import org.openecomp.sdc.be.resources.data.PolicyTypeData;
  39 import org.openecomp.sdc.be.resources.data.PropertyData;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.springframework.stereotype.Component;
  43
  44 import fj.data.Either;
  45
  46 @Component("policy-type-operation")
  47 public class PolicyTypeOperation extends AbstractOperation implements IPolicyTypeOperation {
  48
  49         private static final String CREATE_FLOW_CONTEXT = "CreatePolicyType";
  50         private static final String GET_FLOW_CONTEXT = "GetPolicyType";
  51
  52         @Resource
  53         private PropertyOperation propertyOperation;
  54
  55         public PolicyTypeOperation() {
  56                 super();
  57         }
  58
  59         private static Logger log = LoggerFactory.getLogger(PolicyTypeOperation.class.getName());
  60
  61         @Override
  62         public Either<PolicyTypeDefinition, StorageOperationStatus> getLatestPolicyTypeByType(String policyTypeName) {
  63                 return getLatestPolicyTypeByType(policyTypeName, false);
  64         }
  65
  66         private Either<PolicyTypeDefinition, StorageOperationStatus> getLatestPolicyTypeByType(String type, boolean inTransaction) {
  67                 Map<String, Object> mapCriteria = new HashMap<>();
  68                 mapCriteria.put(GraphPropertiesDictionary.TYPE.getProperty(), type);
  69                 mapCriteria.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
  70
  71                 return getPolicyTypeByCriteria(type, mapCriteria, inTransaction);
  72         }
  73
  74         @Override
  75         public Either<PolicyTypeDefinition, StorageOperationStatus> addPolicyType(PolicyTypeDefinition policyType) {
  76                 return addPolicyType(policyType, false);
  77         }
  78
  79         @Override
  80         public Either<PolicyTypeDefinition, StorageOperationStatus> addPolicyType(PolicyTypeDefinition policyTypeDef, boolean inTransaction) {
  81
  82                 Either<PolicyTypeDefinition, StorageOperationStatus> result = null;
  83
  84                 try {
  85
  86                         Either<PolicyTypeData, TitanOperationStatus> eitherStatus = addPolicyTypeToGraph(policyTypeDef);
  87
  88                         if (eitherStatus.isRight()) {
  89                                 BeEcompErrorManager.getInstance().logBeFailedCreateNodeError(CREATE_FLOW_CONTEXT, policyTypeDef.getType(), eitherStatus.right().value().name());
  90                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value()));
  91
  92                         } else {
  93                                 PolicyTypeData policyTypeData = eitherStatus.left().value();
  94
  95                                 String uniqueId = policyTypeData.getUniqueId();
  96                                 Either<PolicyTypeDefinition, StorageOperationStatus> policyTypeRes = this.getPolicyType(uniqueId, true);
  97
  98                                 if (policyTypeRes.isRight()) {
  99                                         BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError(GET_FLOW_CONTEXT, policyTypeDef.getType(), eitherStatus.right().value().name());
 100                                 }
 101
 102                                 result = policyTypeRes;
 103
 104                         }
 105
 106                         return result;
 107
 108                 } finally {
 109                         handleTransactionCommitRollback(inTransaction, result);
 110                 }
 111
 112         }
 113
 114         private Either<PolicyTypeData, TitanOperationStatus> addPolicyTypeToGraph(PolicyTypeDefinition policyTypeDef) {
 115                 log.debug("Got policy type {}", policyTypeDef);
 116
 117                 String ptUniqueId = UniqueIdBuilder.buildPolicyTypeUid(policyTypeDef.getType(), policyTypeDef.getVersion());
 118
 119                 PolicyTypeData policyTypeData = buildPolicyTypeData(policyTypeDef, ptUniqueId);
 120
 121                 log.debug("Before adding policy type to graph. policyTypeData = {}", policyTypeData);
 122
 123                 Either<PolicyTypeData, TitanOperationStatus> eitherPolicyTypeData = titanGenericDao.createNode(policyTypeData, PolicyTypeData.class);
 124                 log.debug("After adding policy type to graph. status is = {}", eitherPolicyTypeData);
 125
 126                 if (eitherPolicyTypeData.isRight()) {
 127                         TitanOperationStatus operationStatus = eitherPolicyTypeData.right().value();
 128                         log.error("Failed to add policy type {} to graph. status is {}", policyTypeDef.getType(), operationStatus);
 129                         return Either.right(operationStatus);
 130                 }
 131
 132                 PolicyTypeData resultCTD = eitherPolicyTypeData.left().value();
 133                 List<PropertyDefinition> properties = policyTypeDef.getProperties();
 134                 Either<Map<String, PropertyData>, TitanOperationStatus> addPropertiesToPolicyType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.PolicyType, properties);
 135                 if (addPropertiesToPolicyType.isRight()) {
 136                         log.error("Failed add properties {} to policy {}", properties, policyTypeDef.getType());
 137                         return Either.right(addPropertiesToPolicyType.right().value());
 138                 }
 139
 140                 return Either.left(eitherPolicyTypeData.left().value());
 141         }
 142
 143         public Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyTypeByCriteria(String type, Map<String, Object> properties, boolean inTransaction) {
 144                 Either<PolicyTypeDefinition, StorageOperationStatus> result = null;
 145                 try {
 146                         if (type == null || type.isEmpty()) {
 147                                 log.error("type is empty");
 148                                 result = Either.right(StorageOperationStatus.INVALID_ID);
 149                                 return result;
 150                         }
 151
 152                         Either<List<PolicyTypeData>, TitanOperationStatus> eitherPolicyData = titanGenericDao.getByCriteria(NodeTypeEnum.PolicyType, properties, PolicyTypeData.class);
 153                         if (eitherPolicyData.isRight()) {
 154                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherPolicyData.right().value()));
 155                         } else {
 156                                 PolicyTypeDataDefinition dataDefinition = eitherPolicyData.left().value().stream().map(e -> e.getPolicyTypeDataDefinition()).findFirst().get();
 157                                 result = getPolicyType(dataDefinition.getUniqueId(), inTransaction);
 158                         }
 159
 160                         return result;
 161
 162                 } finally {
 163                         handleTransactionCommitRollback(inTransaction, result);
 164                 }
 165         }
 166
 167         @Override
 168         public Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyType(String uniqueId, boolean inTransaction) {
 169                 return getElementType(this::getPolicyTypeByUid, uniqueId, inTransaction);
 170         }
 171
 172         private Either<PolicyTypeDefinition, TitanOperationStatus> getPolicyTypeByUid(String uniqueId) {
 173                 Either<PolicyTypeDefinition, TitanOperationStatus> result = null;
 174
 175                 Either<PolicyTypeData, TitanOperationStatus> eitherPolicyTypeData = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), uniqueId, PolicyTypeData.class);
 176
 177                 if (eitherPolicyTypeData.isRight()) {
 178                         TitanOperationStatus status = eitherPolicyTypeData.right().value();
 179                         log.debug("Policy type {} cannot be found in graph. status is {}", uniqueId, status);
 180                         return Either.right(status);
 181                 }
 182
 183                 PolicyTypeData policyTypeData = eitherPolicyTypeData.left().value();
 184                 PolicyTypeDefinition policyTypeDefinition = new PolicyTypeDefinition(policyTypeData.getPolicyTypeDataDefinition());
 185
 186                 TitanOperationStatus propertiesStatus = propertyOperation.fillProperties(uniqueId, propList -> policyTypeDefinition.setProperties(propList));
 187                 if (propertiesStatus != TitanOperationStatus.OK) {
 188                         log.error("Failed to fetch properties of policy type {}", uniqueId);
 189                         return Either.right(propertiesStatus);
 190                 }
 191
 192                 result = Either.left(policyTypeDefinition);
 193
 194                 return result;
 195         }
 196
 197         private PolicyTypeData buildPolicyTypeData(PolicyTypeDefinition policyTypeDefinition, String ptUniqueId) {
 198
 199                 PolicyTypeData policyTypeData = new PolicyTypeData(policyTypeDefinition);
 200
 201                 policyTypeData.getPolicyTypeDataDefinition().setUniqueId(ptUniqueId);
 202                 Long creationDate = policyTypeData.getPolicyTypeDataDefinition().getCreationTime();
 203                 if (creationDate == null) {
 204                         creationDate = System.currentTimeMillis();
 205                 }
 206
 207                 policyTypeData.getPolicyTypeDataDefinition().setCreationTime(creationDate);
 208                 policyTypeData.getPolicyTypeDataDefinition().setModificationTime(creationDate);
 209                 return policyTypeData;
 210         }
 211
 212 }