--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.lifecycle;
+
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+
+import org.openecomp.sdc.be.components.distribution.engine.ServiceDistributionArtifactsBuilder;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ComponentBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ProductBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
+import org.openecomp.sdc.be.config.BeEcompErrorManager;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+import org.openecomp.sdc.be.model.operations.api.ILifecycleOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.ProductOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
+import org.openecomp.sdc.be.tosca.ToscaExportHandler;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.common.config.EcompErrorName;
+import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
+import org.openecomp.sdc.common.util.ValidationUtils;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import fj.data.Either;
+
+@org.springframework.stereotype.Component("lifecycleBusinessLogic")
+public class LifecycleBusinessLogic {
+
+ private static final String COMMENT = "comment";
+
+ @Autowired
+ private IGraphLockOperation graphLockOperation = null;
+
+ @Autowired
+ private ArtifactsBusinessLogic artifactsBusinessLogic;
+
+ @Autowired
+ private ResourceOperation resourceOperation;
+
+ @Autowired
+ private ServiceOperation serviceOperation;
+
+ @Autowired
+ private ProductOperation productOperation;
+
+ @Autowired
+ private CapabilityOperation capabilityOperation;
+
+ private static Logger log = LoggerFactory.getLogger(LifecycleBusinessLogic.class.getName());
+
+ @javax.annotation.Resource
+ private ComponentsUtils componentUtils;
+
+ @javax.annotation.Resource
+ private ILifecycleOperation lifecycleOperation;
+ @javax.annotation.Resource
+ ArtifactsBusinessLogic artifactsManager;
+
+ @javax.annotation.Resource
+ private ServiceDistributionArtifactsBuilder serviceDistributionArtifactsBuilder;
+
+ @javax.annotation.Resource
+ private ServiceBusinessLogic serviceBusinessLogic;
+
+ @javax.annotation.Resource
+ private ResourceBusinessLogic resourceBusinessLogic;
+
+ @javax.annotation.Resource
+ private ProductBusinessLogic productBusinessLogic;
+
+ @Autowired
+ private ToscaExportHandler toscaExportUtils;
+
+ @Autowired
+ ICacheMangerOperation cacheManagerOperation;
+
+ private Map<String, LifeCycleTransition> stateTransitions;
+ private static volatile boolean isInitialized = false;
+
+ @PostConstruct
+ public void init() {
+ // init parameters
+ if (!isInitialized) {
+ synchronized (this) {
+ if (!isInitialized) {
+ initStateOperations();
+ isInitialized = true;
+ }
+ }
+ }
+ }
+
+ private void initStateOperations() {
+ stateTransitions = new HashMap<String, LifeCycleTransition>();
+
+ LifeCycleTransition checkoutOp = new CheckoutTransition(componentUtils, lifecycleOperation);
+ stateTransitions.put(checkoutOp.getName().name(), checkoutOp);
+
+ UndoCheckoutTransition undoCheckoutOp = new UndoCheckoutTransition(componentUtils, lifecycleOperation);
+ undoCheckoutOp.setArtifactsBusinessLogic(artifactsBusinessLogic);
+ stateTransitions.put(undoCheckoutOp.getName().name(), undoCheckoutOp);
+
+ LifeCycleTransition checkinOp = new CheckinTransition(componentUtils, lifecycleOperation);
+ stateTransitions.put(checkinOp.getName().name(), checkinOp);
+
+ LifeCycleTransition certificationRequest = new CertificationRequestTransition(componentUtils, lifecycleOperation, serviceDistributionArtifactsBuilder, serviceBusinessLogic, capabilityOperation, toscaExportUtils);
+ stateTransitions.put(certificationRequest.getName().name(), certificationRequest);
+
+ LifeCycleTransition startCertification = new StartCertificationTransition(componentUtils, lifecycleOperation);
+ stateTransitions.put(startCertification.getName().name(), startCertification);
+
+ LifeCycleTransition failCertification = new CertificationChangeTransition(LifeCycleTransitionEnum.FAIL_CERTIFICATION, componentUtils, lifecycleOperation);
+ stateTransitions.put(failCertification.getName().name(), failCertification);
+
+ LifeCycleTransition cancelCertification = new CertificationChangeTransition(LifeCycleTransitionEnum.CANCEL_CERTIFICATION, componentUtils, lifecycleOperation);
+ stateTransitions.put(cancelCertification.getName().name(), cancelCertification);
+
+ CertificationChangeTransition successCertification = new CertificationChangeTransition(LifeCycleTransitionEnum.CERTIFY, componentUtils, lifecycleOperation);
+ successCertification.setArtifactsManager(artifactsBusinessLogic);
+ stateTransitions.put(successCertification.getName().name(), successCertification);
+ }
+
+ public LifeCycleTransition getLifecycleTransition(LifeCycleTransitionEnum transitionEnum) {
+ return stateTransitions.get(transitionEnum.name());
+ }
+
+ public Either<Service, ResponseFormat> changeServiceState(String serviceId, User modifier, LifeCycleTransitionEnum transitionEnum, LifecycleChangeInfoWithAction changeInfo, boolean inTransaction, boolean needLock) {
+ return (Either<Service, ResponseFormat>) changeComponentState(ComponentTypeEnum.SERVICE, serviceId, modifier, transitionEnum, changeInfo, inTransaction, needLock);
+ }
+
+ // TODO: rhalili - should use changeComponentState when possible
+ public Either<Resource, ResponseFormat> changeState(String resourceId, User modifier, LifeCycleTransitionEnum transitionEnum, LifecycleChangeInfoWithAction changeInfo, boolean inTransaction, boolean needLock) {
+ return (Either<Resource, ResponseFormat>) changeComponentState(ComponentTypeEnum.RESOURCE, resourceId, modifier, transitionEnum, changeInfo, inTransaction, needLock);
+
+ // LifeCycleTransition lifeCycleTransition =
+ // stateTransitions.get(transitionEnum.name());
+ // if (lifeCycleTransition == null) {
+ // log.debug("state operation is not valid. operations allowed are: {}",
+ // LifeCycleTransitionEnum.valuesAsString());
+ // ResponseFormat error =
+ // componentUtils.getInvalidContentErrorAndAudit(modifier,
+ // AuditingActionEnum.CHECKOUT_RESOURCE);
+ // return Either.right(error);
+ // }
+ //
+ // Either<Resource, ResponseFormat> operationResult;
+ // Resource resource = null;
+ // boolean needToUnlockResource = false;
+ //
+ // log.debug("get resource from graph");
+ // ResponseFormat errorResponse;
+ // Either<Resource, ResponseFormat> eitherResourceResponse =
+ // getResourceForChange(resourceId, modifier, lifeCycleTransition);
+ // if (eitherResourceResponse.isRight()) {
+ // return eitherResourceResponse;
+ // }
+ // resource = eitherResourceResponse.left().value();
+ // String resourceCurrVersion = resource.getResourceVersion();
+ // LifecycleStateEnum resourceCurrState = resource.getLifecycleState();
+ //
+ // if (inTransaction == false) {
+ // // lock resource
+ // Either<Boolean, ResponseFormat> eitherLockResource =
+ // lockResource(resource);
+ // if (eitherLockResource.isRight()) {
+ // errorResponse = eitherLockResource.right().value();
+ // componentUtils.auditResource(errorResponse, modifier, resource,
+ // resourceCurrState.name(), resourceCurrVersion,
+ // lifeCycleTransition.getAuditingAction(), null);
+ // return Either.right(errorResponse);
+ // }
+ // needToUnlockResource = true;
+ // }
+ //
+ // try {
+ // Either<Boolean, ResponseFormat> resourceNotDeleted =
+ // validateResourceNotDeleted(modifier, lifeCycleTransition, resource,
+ // resourceCurrVersion);
+ // if (resourceNotDeleted.isRight()) {
+ // return Either.right(resourceNotDeleted.right().value());
+ // }
+ //
+ // Either<Boolean, ResponseFormat> validateHighestVersion =
+ // validateHighestVersion(modifier, lifeCycleTransition, resource,
+ // resourceCurrVersion);
+ // if (validateHighestVersion.isRight()) {
+ // return Either.right(validateHighestVersion.right().value());
+ // }
+ //
+ // Either<User, ResponseFormat> ownerResult =
+ // lifeCycleTransition.getResourceOwner(resource);
+ // if (ownerResult.isRight()) {
+ // return Either.right(ownerResult.right().value());
+ // }
+ // User owner = ownerResult.left().value();
+ // log.debug("owner of resource {} is {}", resource.getUniqueId(),
+ // owner.getUserId());
+ //
+ // LifecycleStateEnum oldState = resource.getLifecycleState();
+ //
+ // Either<String, ResponseFormat> commentValidationResult =
+ // validateComment(changeInfo, transitionEnum);
+ // if (commentValidationResult.isRight()) {
+ // errorResponse = commentValidationResult.right().value();
+ // EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new
+ // EnumMap<AuditingFieldsKeysEnum,
+ // Object>(AuditingFieldsKeysEnum.class);
+ // auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT,
+ // changeInfo.getUserRemarks());
+ // componentUtils.auditResource(errorResponse, modifier, resource,
+ // resourceCurrState.name(), resourceCurrVersion,
+ // lifeCycleTransition.getAuditingAction(), auditingFields);
+ // return Either.right(errorResponse);
+ // }
+ // changeInfo.setUserRemarks(commentValidationResult.left().value());
+ //
+ // Either<Boolean, ResponseFormat> stateValidationResult =
+ // lifeCycleTransition.validateResourceBeforeTransition(resource.getResourceName(),
+ // ComponentTypeEnum.RESOURCE, modifier, owner, oldState);
+ // if (stateValidationResult.isRight()) {
+ // errorResponse = stateValidationResult.right().value();
+ // componentUtils.auditResource(errorResponse, modifier, resource,
+ // resourceCurrState.name(), resourceCurrVersion,
+ // lifeCycleTransition.getAuditingAction(), null);
+ // return Either.right(errorResponse);
+ // }
+ //
+ // operationResult = lifeCycleTransition.changeStateOperation(resource,
+ // modifier, owner, inTransaction);
+ //
+ // if (operationResult.isRight()) {
+ // errorResponse = operationResult.right().value();
+ // log.debug("audit before sending response");
+ // componentUtils.auditResource(errorResponse, modifier, resource,
+ // resourceCurrState.name(), resourceCurrVersion,
+ // lifeCycleTransition.getAuditingAction(), null);
+ //
+ // return Either.right(errorResponse);
+ // }
+ // Resource resourceAfterOperation = operationResult.left().value();
+ // EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new
+ // EnumMap<AuditingFieldsKeysEnum,
+ // Object>(AuditingFieldsKeysEnum.class);
+ // auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT,
+ // changeInfo.getUserRemarks());
+ // componentUtils.auditResource(componentUtils.getResponseFormat(ActionStatus.OK),
+ // modifier, resourceAfterOperation, resourceCurrState.name(),
+ // resourceCurrVersion, lifeCycleTransition.getAuditingAction(),
+ // auditingFields);
+ // return operationResult;
+ //
+ // } finally {
+ // log.debug("unlock resource {}", resourceId);
+ // if (needToUnlockResource && resource != null) {
+ // resource.setUniqueId(resourceId);
+ // graphLockOperation.unlockResource(resource);
+ // }
+ // }
+
+ }
+
+ public Either<? extends Component, ResponseFormat> changeComponentState(ComponentTypeEnum componentType, String componentId, User modifier, LifeCycleTransitionEnum transitionEnum, LifecycleChangeInfoWithAction changeInfo, boolean inTransaction,
+ boolean needLock) {
+
+ LifeCycleTransition lifeCycleTransition = stateTransitions.get(transitionEnum.name());
+ if (lifeCycleTransition == null) {
+ log.debug("state operation is not valid. operations allowed are: {}", LifeCycleTransitionEnum.valuesAsString());
+ ResponseFormat error = componentUtils.getInvalidContentErrorAndAudit(modifier, AuditingActionEnum.CHECKOUT_RESOURCE);
+ return Either.right(error);
+ }
+ ComponentBusinessLogic bl = getComponentBL(componentType);
+
+ Either<? extends Component, ResponseFormat> operationResult = null;
+ Component component = null;
+ // boolean needToUnlockResource = false;
+ log.debug("get resource from graph");
+ ResponseFormat errorResponse;
+
+ Either<? extends Component, ResponseFormat> eitherResourceResponse = getComponentForChange(componentType, componentId, modifier, lifeCycleTransition, changeInfo);
+ if (eitherResourceResponse.isRight()) {
+ return eitherResourceResponse;
+ }
+ component = eitherResourceResponse.left().value();
+ String resourceCurrVersion = component.getVersion();
+ LifecycleStateEnum resourceCurrState = component.getLifecycleState();
+
+ // lock resource
+ if (inTransaction == false && needLock) {
+ Either<Boolean, ResponseFormat> eitherLockResource = lockComponent(componentType, component);
+ if (eitherLockResource.isRight()) {
+ errorResponse = eitherLockResource.right().value();
+ componentUtils.auditComponent(errorResponse, modifier, component, resourceCurrState.name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType, null);
+ return Either.right(errorResponse);
+ }
+ // needToUnlockResource = true;
+ }
+ try {
+ Either<String, ResponseFormat> commentValidationResult = validateComment(changeInfo, transitionEnum);
+ if (commentValidationResult.isRight()) {
+ errorResponse = commentValidationResult.right().value();
+ EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, changeInfo.getUserRemarks());
+ componentUtils.auditComponent(errorResponse, modifier, component, resourceCurrState.name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType, auditingFields);
+ return Either.right(errorResponse);
+ }
+ changeInfo.setUserRemarks(commentValidationResult.left().value());
+
+ Either<Boolean, ResponseFormat> validateHighestVersion = validateHighestVersion(modifier, lifeCycleTransition, component, resourceCurrVersion, componentType);
+ if (validateHighestVersion.isRight()) {
+ return Either.right(validateHighestVersion.right().value());
+ }
+
+ Either<User, ResponseFormat> ownerResult = lifeCycleTransition.getComponentOwner(component, componentType, inTransaction);
+ if (ownerResult.isRight()) {
+ return Either.right(ownerResult.right().value());
+ }
+ User owner = ownerResult.left().value();
+ log.debug("owner of resource {} is {}", component.getUniqueId(), owner.getUserId());
+
+ LifecycleStateEnum oldState = component.getLifecycleState();
+
+ Either<Boolean, ResponseFormat> stateValidationResult = lifeCycleTransition.validateBeforeTransition(component, componentType, modifier, owner, oldState, changeInfo);
+ if (stateValidationResult.isRight()) {
+ errorResponse = stateValidationResult.right().value();
+ EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, changeInfo.getUserRemarks());
+ componentUtils.auditComponent(errorResponse, modifier, component, resourceCurrState.name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType, auditingFields);
+ return Either.right(errorResponse);
+
+ }
+
+ operationResult = lifeCycleTransition.changeState(componentType, component, bl, modifier, owner, false, inTransaction);
+
+ if (operationResult.isRight()) {
+ errorResponse = operationResult.right().value();
+ log.debug("audit before sending response");
+ componentUtils.auditComponentAdmin(errorResponse, modifier, component, resourceCurrState.name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType);
+
+ return Either.right(errorResponse);
+ }
+ Component resourceAfterOperation = operationResult.left().value();
+ EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, changeInfo.getUserRemarks());
+ componentUtils.auditComponent(componentUtils.getResponseFormat(ActionStatus.OK), modifier, resourceAfterOperation, resourceCurrState.name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType, auditingFields);
+ return operationResult;
+
+ } finally {
+ log.debug("unlock component {}", componentId);
+ if (inTransaction == false && needLock && component != null) {
+ component.setUniqueId(componentId);
+ NodeTypeEnum nodeType = componentType.getNodeType();
+
+ // Handle component change in the cache of the side affect of
+ // the operation
+ if (operationResult != null && operationResult.isLeft()) {
+ Component componentAfterOpertion = operationResult.left().value();
+ String uniqueId = componentAfterOpertion.getUniqueId();
+ if (false == componentId.equals(uniqueId)) {
+ log.debug("During change state, another component {} has been created/updated", uniqueId);
+ if (uniqueId != null) {
+ cacheManagerOperation.updateComponentInCache(uniqueId, componentAfterOpertion.getLastUpdateDate(), nodeType);
+ }
+ }
+ }
+
+ graphLockOperation.unlockComponent(componentId, nodeType);
+
+ }
+ }
+
+ }
+
+ private Either<? extends Component, ResponseFormat> getComponentForChange(ComponentTypeEnum componentType, String componentId, User modifier, LifeCycleTransition lifeCycleTransition, LifecycleChangeInfoWithAction changeInfo) {
+
+ Either<? extends Component, StorageOperationStatus> eitherResourceResponse = Either.right(StorageOperationStatus.GENERAL_ERROR);
+ switch (componentType) {
+ case SERVICE:
+ eitherResourceResponse = serviceOperation.getComponent(componentId, true);
+ break;
+ case PRODUCT:
+ eitherResourceResponse = productOperation.getComponent(componentId, true);
+ break;
+ case RESOURCE:
+ eitherResourceResponse = resourceOperation.getComponent(componentId, true);
+ break;
+ default:
+ break;
+ }
+
+ ResponseFormat errorResponse = null;
+ if (eitherResourceResponse.isRight()) {
+ ActionStatus actionStatus = componentUtils.convertFromStorageResponse(eitherResourceResponse.right().value(), componentType);
+ errorResponse = componentUtils.getResponseFormat(actionStatus, Constants.EMPTY_STRING);
+ log.debug("audit before sending response");
+ EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, changeInfo.getUserRemarks());
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentId);
+ componentUtils.auditComponent(errorResponse, modifier, null, Constants.EMPTY_STRING, Constants.EMPTY_STRING, lifeCycleTransition.getAuditingAction(), componentType, auditingFields);
+
+ return Either.right(errorResponse);
+ }
+ return Either.left(eitherResourceResponse.left().value());
+ }
+
+ private Either<Boolean, ResponseFormat> validateHighestVersion(User modifier, LifeCycleTransition lifeCycleTransition, Resource resource, String resourceCurrVersion) {
+ ResponseFormat errorResponse;
+ if (!resource.isHighestVersion()) {
+ log.debug("resource version {} is not the last version of resource {}", resource.getVersion(), resource.getName());
+ errorResponse = componentUtils.getResponseFormat(ActionStatus.COMPONENT_HAS_NEWER_VERSION, resource.getName(), ComponentTypeEnum.RESOURCE.name().toLowerCase());
+ componentUtils.auditResource(errorResponse, modifier, resource, resource.getLifecycleState().name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), null);
+ return Either.right(errorResponse);
+ }
+ return Either.left(true);
+ }
+
+ private Either<Boolean, ResponseFormat> validateResourceNotDeleted(User modifier, LifeCycleTransition lifeCycleTransition, Resource resource, String resourceCurrVersion) {
+
+ ResponseFormat errorResponse;
+ if ((resource.getIsDeleted() != null) && (resource.getIsDeleted() == true)) {
+ ActionStatus actionStatus = ActionStatus.RESOURCE_NOT_FOUND;
+ errorResponse = componentUtils.getResponseFormatByResource(actionStatus, resource.getName());
+ log.debug("resource {} {} is marked for delete", resource.getName(), resource.getVersion());
+ componentUtils.auditResource(errorResponse, modifier, null, "", "", lifeCycleTransition.getAuditingAction(), null);
+
+ return Either.right(errorResponse);
+ }
+ return Either.left(true);
+ }
+
+ private Either<Boolean, ResponseFormat> validateHighestVersion(User modifier, LifeCycleTransition lifeCycleTransition, Component component, String resourceCurrVersion, ComponentTypeEnum componentType) {
+ ResponseFormat errorResponse;
+ if (!component.isHighestVersion()) {
+ log.debug("Component version {} is not the last version of component {}", component.getComponentMetadataDefinition().getMetadataDataDefinition().getVersion(),
+ component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
+ errorResponse = componentUtils.getResponseFormat(ActionStatus.COMPONENT_HAS_NEWER_VERSION, component.getComponentMetadataDefinition().getMetadataDataDefinition().getName(), componentType.getValue().toLowerCase());
+ componentUtils.auditComponentAdmin(errorResponse, modifier, component, component.getLifecycleState().name(), resourceCurrVersion, lifeCycleTransition.getAuditingAction(), componentType);
+ return Either.right(errorResponse);
+ }
+ return Either.left(true);
+ }
+
+ private Either<Boolean, ResponseFormat> lockComponent(ComponentTypeEnum componentType, Component component) {
+ NodeTypeEnum nodeType = componentType.getNodeType();
+ StorageOperationStatus lockResourceStatus = graphLockOperation.lockComponent(component.getUniqueId(), nodeType);
+
+ if (lockResourceStatus.equals(StorageOperationStatus.OK)) {
+ return Either.left(true);
+ } else {
+ ActionStatus actionStatus = componentUtils.convertFromStorageResponse(lockResourceStatus);
+ ResponseFormat responseFormat = componentUtils.getResponseFormat(actionStatus, component.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
+ return Either.right(responseFormat);
+ }
+
+ }
+
+ private Either<Resource, ResponseFormat> getResourceForChange(String resourceId, User modifier, LifeCycleTransition lifeCycleTransition) {
+ Either<Resource, StorageOperationStatus> eitherResourceResponse = resourceOperation.getResource(resourceId, true);
+
+ ResponseFormat errorResponse = null;
+ if (eitherResourceResponse.isRight()) {
+ ActionStatus actionStatus = componentUtils.convertFromStorageResponse(eitherResourceResponse.right().value());
+ errorResponse = componentUtils.getResponseFormatByResource(actionStatus, "");
+ log.debug("audit before sending response");
+ // For audit of not found, resourceName should be uniqueID according
+ // to Ella
+ EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
+ auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceId);
+ componentUtils.auditResource(errorResponse, modifier, null, "", "", lifeCycleTransition.getAuditingAction(), null);
+
+ return Either.right(errorResponse);
+ }
+ Resource resource = eitherResourceResponse.left().value();
+
+ return Either.left(resource);
+
+ }
+
+ private Either<String, ResponseFormat> validateComment(LifecycleChangeInfoWithAction changeInfo, LifeCycleTransitionEnum transitionEnum) {
+ String comment = changeInfo.getUserRemarks();
+ if (LifeCycleTransitionEnum.CANCEL_CERTIFICATION == transitionEnum || LifeCycleTransitionEnum.CERTIFY == transitionEnum || LifeCycleTransitionEnum.FAIL_CERTIFICATION == transitionEnum || LifeCycleTransitionEnum.CHECKIN == transitionEnum
+ || LifeCycleTransitionEnum.CERTIFICATION_REQUEST == transitionEnum
+ // import?
+ ) {
+
+ if (!ValidationUtils.validateStringNotEmpty(comment)) {
+ log.debug("user comment cannot be empty or null.");
+ ResponseFormat errorResponse = componentUtils.getResponseFormat(ActionStatus.MISSING_DATA, COMMENT);
+ return Either.right(errorResponse);
+ }
+
+ comment = ValidationUtils.removeNoneUtf8Chars(comment);
+ comment = ValidationUtils.removeHtmlTags(comment);
+ comment = ValidationUtils.normaliseWhitespace(comment);
+ comment = ValidationUtils.stripOctets(comment);
+
+ if (!ValidationUtils.validateLength(comment, ValidationUtils.COMMENT_MAX_LENGTH)) {
+ log.debug("user comment exceeds limit.");
+ return Either.right(componentUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, COMMENT, String.valueOf(ValidationUtils.COMMENT_MAX_LENGTH)));
+ }
+ if (!ValidationUtils.validateIsEnglish(comment)) {
+ return Either.right(componentUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
+ }
+ }
+ return Either.left(comment);
+ }
+
+ private ComponentBusinessLogic getComponentBL(ComponentTypeEnum componentTypeEnum) {
+ ComponentBusinessLogic businessLogic;
+ switch (componentTypeEnum) {
+ case RESOURCE: {
+ businessLogic = this.resourceBusinessLogic;
+ break;
+ }
+ case SERVICE: {
+ businessLogic = this.serviceBusinessLogic;
+ break;
+ }
+ case PRODUCT: {
+ businessLogic = this.productBusinessLogic;
+ break;
+ }
+
+ default: {
+ BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeSystemError, "getComponentBL");
+ throw new IllegalArgumentException("Illegal component type:" + componentTypeEnum.getValue());
+ }
+ }
+ return businessLogic;
+ }
+
+}
Code Review / sdc.git / blobdiff