package org.openecomp.sdc.be.servlets;
import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
import fj.data.Either;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import io.swagger.v3.oas.annotations.OpenAPIDefinition;
+import io.swagger.v3.oas.annotations.info.Info;
+import io.swagger.v3.oas.annotations.servers.Server;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
-import org.openecomp.sdc.be.components.impl.ComponentBusinessLogic;
+import org.openecomp.sdc.be.components.impl.BaseBusinessLogic;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ElementBusinessLogic;
-import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
-import org.openecomp.sdc.be.components.impl.MonitoringBusinessLogic;
+import org.openecomp.sdc.be.components.impl.GenericArtifactBrowserBusinessLogic;
+import org.openecomp.sdc.be.components.impl.InputsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.OutputsBusinessLogic;
import org.openecomp.sdc.be.components.impl.PolicyBusinessLogic;
-import org.openecomp.sdc.be.components.impl.PolicyTypeBusinessLogic;
-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.components.lifecycle.LifecycleBusinessLogic;
-import org.openecomp.sdc.be.components.scheduledtasks.ComponentsCleanBusinessLogic;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
-import org.openecomp.sdc.be.dao.api.IElementDAO;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-import org.openecomp.sdc.be.ecomp.converters.AssetMetadataConverter;
+import org.openecomp.sdc.be.datatypes.enums.DeclarationTypeEnum;
+import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.WebAppContextWrapper;
+import org.openecomp.sdc.be.model.ComponentInstInputsMap;
import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintJacksonDeserializer;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.common.api.Constants;
-import org.openecomp.sdc.common.datastructure.Wrapper;
+import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.common.servlets.BasicServlet;
import org.openecomp.sdc.exception.ResponseFormat;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
import javax.servlet.ServletContext;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.ResponseBuilder;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
import java.util.function.Supplier;
+@OpenAPIDefinition(info = @Info(title = "SDC API", description = "SDC External, Distribution and Internal APIs"),
+ servers = {@Server(url = "/sdc", description = "SDC External and Distribution APIs"),
+ @Server(url = "/sdc2/rest", description = "SDC Internal APIs")})
public class BeGenericServlet extends BasicServlet {
+ public BeGenericServlet(UserBusinessLogic userAdminManager,
+ ComponentsUtils componentsUtils) {
+ this.userAdminManager = userAdminManager;
+ this.componentsUtils = componentsUtils;
+ }
+
@Context
protected HttpServletRequest servletRequest;
- private static final Logger log = LoggerFactory.getLogger(BeGenericServlet.class);
+ private static final Logger log = Logger.getLogger(BeGenericServlet.class);
+
+ private static final String PROPERTY_NAME_REGEX = "[\\w,\\d,_]+";
+
+ private UserBusinessLogic userAdminManager;
+ protected ComponentsUtils componentsUtils;
/******************** New error response mechanism
* @param requestErrorWrapper **************/
return buildOkResponseStatic(entity);
}
- static public Response buildOkResponseStatic(Object entity) {
+ private static Response buildOkResponseStatic(Object entity) {
return Response.status(Response.Status.OK)
- .entity(entity)
- .build();
+ .entity(entity)
+ .build();
+ }
+
+ public HttpServletRequest getServletRequest() {
+ return servletRequest;
}
+ @VisibleForTesting
+ public void setRequestServlet(HttpServletRequest request) {this.servletRequest = request;}
+
protected Response buildOkResponse(ResponseFormat errorResponseWrapper, Object entity) {
return buildOkResponse(errorResponseWrapper, entity, null);
}
/*******************************************************************************************************/
protected Either<User, ResponseFormat> getUser(final HttpServletRequest request, String userId) {
- Either<User, ActionStatus> eitherCreator = getUserAdminManager(request.getSession().getServletContext()).getUser(userId, false);
- if (eitherCreator.isRight()) {
+ User user;
+ try {
+ user = getUserAdminManager(request.getSession().getServletContext()).getUser(userId, false);
+ return Either.left(user);
+ } catch (ComponentException ce) {
log.info("createResource method - user is not listed. userId= {}", userId);
- ResponseFormat errorResponse = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_INFORMATION);
- User user = new User("", "", userId, "", null, null);
-
+ ResponseFormat errorResponse = getComponentsUtils().getResponseFormat(ce);
+ user = new User("", "", userId, "", null, null);
getComponentsUtils().auditResource(errorResponse, user, "", AuditingActionEnum.CHECKOUT_RESOURCE);
return Either.right(errorResponse);
}
- return Either.left(eitherCreator.left().value());
-
}
- protected PolicyTypeBusinessLogic getPolicyTypeBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> PolicyTypeBusinessLogic.class);
+ UserBusinessLogic getUserAdminManager(ServletContext context) {
+ return getClassFromWebAppContext(context, () -> UserBusinessLogic.class);
}
- protected UserBusinessLogic getUserAdminManager(ServletContext context) {
- return getClassFromWebAppContext(context, () -> UserBusinessLogic.class);
+ protected GenericArtifactBrowserBusinessLogic getGenericArtifactBrowserBL(ServletContext context) {
+ return getClassFromWebAppContext(context, () -> GenericArtifactBrowserBusinessLogic.class);
}
protected ResourceBusinessLogic getResourceBL(ServletContext context) {
return getClassFromWebAppContext(context, () -> ResourceBusinessLogic.class);
}
- protected ComponentsCleanBusinessLogic getComponentCleanerBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> ComponentsCleanBusinessLogic.class);
- }
-
protected ServiceBusinessLogic getServiceBL(ServletContext context) {
return getClassFromWebAppContext(context, () -> ServiceBusinessLogic.class);
}
- protected ProductBusinessLogic getProductBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> ProductBusinessLogic.class);
- }
-
protected ArtifactsBusinessLogic getArtifactBL(ServletContext context) {
return getClassFromWebAppContext(context, () -> ArtifactsBusinessLogic.class);
}
return getClassFromWebAppContext(context, () -> ElementBusinessLogic.class);
}
- protected MonitoringBusinessLogic getMonitoringBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> MonitoringBusinessLogic.class);
- }
-
- protected AssetMetadataConverter getAssetUtils(ServletContext context) {
- return getClassFromWebAppContext(context, () -> AssetMetadataConverter.class);
- }
-
- protected LifecycleBusinessLogic getLifecycleBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> LifecycleBusinessLogic.class);
+ <T> T getClassFromWebAppContext(final ServletContext context, final Supplier<Class<T>> businessLogicClassGen) {
+ return getWebAppContext(context).getBean(businessLogicClassGen.get());
}
- protected PolicyBusinessLogic getPolicyBL(ServletContext context) {
- return getClassFromWebAppContext(context, () -> PolicyBusinessLogic.class);
- }
-
- protected <T> T getClassFromWebAppContext(ServletContext context, Supplier<Class<T>> businessLogicClassGen) {
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
- return webApplicationContext.getBean(businessLogicClassGen.get());
- }
-
- protected GroupBusinessLogic getGroupBL(ServletContext context) {
-
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
- return webApplicationContext.getBean(GroupBusinessLogic.class);
- }
-
- protected ComponentInstanceBusinessLogic getComponentInstanceBL(ServletContext context, ComponentTypeEnum containerComponentType) {
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
- return webApplicationContext.getBean(ComponentInstanceBusinessLogic.class);
- }
-
- protected IElementDAO getElementDao(Class<? extends IElementDAO> clazz, ServletContext context) {
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
-
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
-
- return webApplicationContext.getBean(clazz);
+ protected ComponentInstanceBusinessLogic getComponentInstanceBL(final ServletContext context) {
+ return getClassFromWebAppContext(context, () -> ComponentInstanceBusinessLogic.class);
}
protected ComponentsUtils getComponentsUtils() {
- ServletContext context = this.servletRequest.getSession().getServletContext();
-
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
- return webApplicationContext.getBean(ComponentsUtils.class);
+ final ServletContext context = this.servletRequest.getSession().getServletContext();
+ return getClassFromWebAppContext(context, () -> ComponentsUtils.class);
}
/**
*
* @return
*/
- protected String initHeaderParam(String headerValue, HttpServletRequest request, String headerName) {
+ String initHeaderParam(String headerValue, HttpServletRequest request, String headerName) {
String retValue;
if (headerValue != null) {
retValue = headerValue;
return new StringBuilder().append("attachment; filename=\"").append(artifactFileName).append("\"").toString();
}
- protected ComponentBusinessLogic getComponentBL(ComponentTypeEnum componentTypeEnum, ServletContext context) {
- ComponentBusinessLogic businessLogic;
- switch (componentTypeEnum) {
- case RESOURCE:
- businessLogic = getResourceBL(context);
- break;
- case SERVICE:
- businessLogic = getServiceBL(context);
- break;
- case PRODUCT:
- businessLogic = getProductBL(context);
- break;
- case RESOURCE_INSTANCE:
- businessLogic = getResourceBL(context);
- break;
- default:
- BeEcompErrorManager.getInstance().logBeSystemError("getComponentBL");
- throw new IllegalArgumentException("Illegal component type:" + componentTypeEnum.getValue());
- }
- return businessLogic;
- }
-
- protected <T> void convertJsonToObjectOfClass(String json, Wrapper<T> policyWrapper, Class<T> clazz, Wrapper<Response> errorWrapper) {
+ <T> T convertJsonToObjectOfClass(String json, Class<T> clazz) {
T object = null;
ObjectMapper mapper = new ObjectMapper()
- .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
- .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
+ .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
+ .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
try {
log.trace("Starting to convert json to object. Json=\n{}", json);
object = mapper.readValue(json, clazz);
if (object != null) {
- policyWrapper.setInnerElement(object);
+ return object;
} else {
BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
log.debug("The object of class {} is null after converting from json. ", clazz);
- errorWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT)));
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
}
- } catch (Exception e) {
+ } catch (IOException e) {
BeEcompErrorManager.getInstance().logBeInvalidJsonInput("convertJsonToObject");
- log.debug("The exception {} occured upon json to object convertation. Json=\n{}", e, json);
- errorWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT)));
+ log.debug("The exception {} occurred upon json to object convertation. Json=\n{}", e, json);
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
+ }
+ }
+
+ protected Either<Map<String, PropertyDefinition>, ActionStatus> getPropertyModel(String componentId, String data) {
+ JSONParser parser = new JSONParser();
+ JSONObject root;
+ try {
+ Map<String, PropertyDefinition> properties = new HashMap<>();
+ root = (JSONObject) parser.parse(data);
+
+ Set entrySet = root.entrySet();
+ Iterator iterator = entrySet.iterator();
+ while (iterator.hasNext()) {
+ Entry next = (Entry) iterator.next();
+ String propertyName = (String) next.getKey();
+
+ if(!isPropertyNameValid(propertyName)) {
+ return Either.right(ActionStatus.INVALID_PROPERTY_NAME);
+ }
+
+ JSONObject value = (JSONObject) next.getValue();
+ Either<PropertyDefinition, ActionStatus> propertyDefinitionEither =
+ getPropertyDefinitionFromJson(componentId, propertyName, value);
+
+ if(propertyDefinitionEither.isRight()) {
+ return Either.right(propertyDefinitionEither.right().value());
+ }
+
+ properties.put(propertyName, propertyDefinitionEither.left().value());
+ }
+
+ return Either.left(properties);
+ } catch (ParseException e) {
+ log.info("Property conetnt is invalid - {}", data);
+ return Either.right(ActionStatus.INVALID_CONTENT);
}
}
+
+ protected boolean isPropertyNameValid(String propertyName) {
+ return Objects.nonNull(propertyName)
+ && propertyName.matches(PROPERTY_NAME_REGEX);
+
+ }
+
+ private Either<PropertyDefinition, ActionStatus> getPropertyDefinitionFromJson(String componentId, String propertyName, JSONObject value) {
+ String jsonString = value.toJSONString();
+ Either<PropertyDefinition, ActionStatus> convertJsonToObject = convertJsonToObject(jsonString, PropertyDefinition.class);
+ if (convertJsonToObject.isRight()) {
+ return Either.right(convertJsonToObject.right().value());
+ }
+ PropertyDefinition propertyDefinition = convertJsonToObject.left().value();
+ String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, propertyName);
+ propertyDefinition.setUniqueId(uniqueId);
+
+ return Either.left(propertyDefinition);
+ }
+
+ private Either<InputDefinition, ActionStatus> getInputDefinitionFromJson(String componentId, String inputName, JSONObject value) {
+ String jsonString = value.toJSONString();
+ Either<InputDefinition, ActionStatus> convertJsonToObject = convertJsonToObject(jsonString, InputDefinition.class);
+ if (convertJsonToObject.isRight()) {
+ return Either.right(convertJsonToObject.right().value());
+ }
+ InputDefinition inputDefinition = convertJsonToObject.left().value();
+ String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, inputName);
+ inputDefinition.setUniqueId(uniqueId);
+
+ return Either.left(inputDefinition);
+ }
+
+ protected Either<Map<String, PropertyDefinition>, ActionStatus> getPropertiesListForUpdate(String data) {
+
+ Map<String, PropertyDefinition> properties = new HashMap<>();
+ JSONParser parser = new JSONParser();
+ JSONArray jsonArray;
+
+ try {
+ jsonArray = (JSONArray) parser.parse(data);
+ for (Object jsonElement : jsonArray) {
+ String propertyAsString = jsonElement.toString();
+ Either<PropertyDefinition, ActionStatus> convertJsonToObject = convertJsonToObject(propertyAsString, PropertyDefinition.class);
+
+ if (convertJsonToObject.isRight()) {
+ return Either.right(convertJsonToObject.right().value());
+ }
+
+ PropertyDefinition propertyDefinition = convertJsonToObject.left().value();
+ properties.put(propertyDefinition.getName(), propertyDefinition);
+ }
+
+ return Either.left(properties);
+ } catch (Exception e) {
+ log.info("Property content is invalid - {}", data);
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+
+ }
+
+ protected String propertyToJson(Map.Entry<String, PropertyDefinition> property) {
+ JSONObject root = new JSONObject();
+ String propertyName = property.getKey();
+ PropertyDefinition propertyDefinition = property.getValue();
+ JSONObject propertyDefinitionO = getPropertyDefinitionJSONObject(propertyDefinition);
+ root.put(propertyName, propertyDefinitionO);
+ propertyDefinition.getType();
+ return root.toString();
+ }
+
+ private JSONObject getPropertyDefinitionJSONObject(PropertyDefinition propertyDefinition) {
+
+ Either<String, ActionStatus> either = convertObjectToJson(propertyDefinition);
+ if (either.isRight()) {
+ return new JSONObject();
+ }
+ try {
+ return (JSONObject) new JSONParser().parse(either.left().value());
+ } catch (ParseException e) {
+ log.info("failed to convert input to json");
+ log.error("failed to convert to json", e);
+ return new JSONObject();
+ }
+
+ }
+
+ protected <T> Either<T, ActionStatus> convertJsonToObject(String data, Class<T> clazz) {
+ T t = null;
+ Type constraintType = new TypeToken<PropertyConstraint>() {
+ }.getType();
+ Gson
+ gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyOperation.PropertyConstraintDeserialiser()).create();
+ try {
+ log.trace("convert json to object. json=\n {}", data);
+ t = gson.fromJson(data, clazz);
+ if (t == null) {
+ log.info("object is null after converting from json");
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+ } catch (Exception e) {
+ // INVALID JSON
+ log.info("failed to convert from json");
+ log.error("failed to convert from json", e);
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+ return Either.left(t);
+ }
+
+ private Either<String, ActionStatus> convertObjectToJson(PropertyDefinition propertyDefinition) {
+ Type constraintType = new TypeToken<PropertyConstraint>() {
+ }.getType();
+ Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyOperation.PropertyConstraintSerialiser()).create();
+ try {
+ log.trace("convert object to json. propertyDefinition= {}", propertyDefinition);
+ String json = gson.toJson(propertyDefinition);
+ if (json == null) {
+ log.info("object is null after converting to json");
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+ return Either.left(json);
+ } catch (Exception e) {
+ // INVALID JSON
+ log.info("failed to convert to json");
+ log.debug("failed to convert fto json", e);
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+
+ }
+
+ private OutputsBusinessLogic getOutputBL(final ServletContext context) {
+ return getClassFromWebAppContext(context, () -> OutputsBusinessLogic.class);
+ }
+
+ private InputsBusinessLogic getInputBL(final ServletContext context) {
+ return getClassFromWebAppContext(context, () -> InputsBusinessLogic.class);
+ }
+
+ private PolicyBusinessLogic getPolicyBL(final ServletContext context) {
+ return getClassFromWebAppContext(context, () -> PolicyBusinessLogic.class);
+ }
+
+ private WebApplicationContext getWebAppContext(final ServletContext context) {
+ return ((WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).getWebAppContext(context);
+ }
+
+ protected <T> Either<T, ResponseFormat> parseToComponentInstanceMap(final String componentJson,
+ final User user,
+ final ComponentTypeEnum componentType,
+ final Class<T> clazz) {
+ return getComponentsUtils()
+ .convertJsonToObjectUsingObjectMapper(componentJson, user, clazz, AuditingActionEnum.CREATE_RESOURCE, componentType);
+ }
+
+ protected Response declareProperties(String userId, String componentId, String componentType,
+ String componentInstInputsMapObj, DeclarationTypeEnum typeEnum, HttpServletRequest request) {
+ ServletContext context = request.getSession().getServletContext();
+ String url = request.getMethod() + " " + request.getRequestURI();
+ log.debug("(get) Start handle request of {}", url);
+
+ try {
+ BaseBusinessLogic businessLogic = getBlForDeclaration(typeEnum, context);
+
+ // get modifier id
+ User modifier = new User();
+ modifier.setUserId(userId);
+ log.debug("modifier id is {}", userId);
+ ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.findByParamName(componentType);
+ Either<ComponentInstInputsMap, ResponseFormat> componentInstInputsMapRes = parseToComponentInstanceMap(
+ componentInstInputsMapObj, modifier, componentTypeEnum, ComponentInstInputsMap.class);
+ if (componentInstInputsMapRes.isRight()) {
+ log.debug("failed to parse componentInstInputsMap");
+ return buildErrorResponse(componentInstInputsMapRes.right().value());
+ }
+
+ Either<List<ToscaDataDefinition>, ResponseFormat> propertiesAfterDeclaration = businessLogic
+ .declareProperties(userId, componentId,
+ componentTypeEnum,
+ componentInstInputsMapRes.left().value());
+ if (propertiesAfterDeclaration.isRight()) {
+ log.debug("failed to create inputs for service: {}", componentId);
+ return buildErrorResponse(propertiesAfterDeclaration.right().value());
+ }
+ Object properties = RepresentationUtils.toRepresentation(propertiesAfterDeclaration.left().value());
+ return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), properties);
+
+ } catch (Exception e) {
+ BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create inputs for service with id: " + componentId);
+ log.debug("Properties declaration failed with exception", e);
+ return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+ }
+ }
+
+ public BaseBusinessLogic getBlForDeclaration(final DeclarationTypeEnum typeEnum,
+ final ServletContext context) {
+ switch (typeEnum) {
+ case OUTPUT:
+ return getOutputBL(context);
+ case POLICY:
+ return getPolicyBL(context);
+ case INPUT:
+ return getInputBL(context);
+ default:
+ throw new IllegalArgumentException("Invalid DeclarationTypeEnum");
+ }
+ }
+
+ protected Either<Map<String, InputDefinition>, ActionStatus> getInputModel(String componentId, String data) {
+ JSONParser parser = new JSONParser();
+ JSONObject root;
+ try {
+ Map<String, InputDefinition> inputs = new HashMap<>();
+ root = (JSONObject) parser.parse(data);
+
+ Set entrySet = root.entrySet();
+ Iterator iterator = entrySet.iterator();
+ while (iterator.hasNext()) {
+ Entry next = (Entry) iterator.next();
+ String inputName = (String) next.getKey();
+
+ if(!isInputNameValid(inputName)) {
+ return Either.right(ActionStatus.INVALID_INPUT_NAME);
+ }
+
+ JSONObject value = (JSONObject) next.getValue();
+ Either<InputDefinition, ActionStatus> inputDefinitionEither =
+ getInputDefinitionFromJson(componentId, inputName, value);
+
+ if(inputDefinitionEither.isRight()) {
+ return Either.right(inputDefinitionEither.right().value());
+ }
+
+ inputs.put(inputName, inputDefinitionEither.left().value());
+ }
+
+ return Either.left(inputs);
+ } catch (ParseException e) {
+ log.warn("Input content is invalid - {}", data, e);
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+ }
+
+ protected boolean isInputNameValid(String inputName) {
+ return Objects.nonNull(inputName)
+ && inputName.matches(PROPERTY_NAME_REGEX);
+
+ }
}
Code Review / sdc.git / blobdiff