vid-app-common/src/main/java/org/onap/vid/mso/MsoBusinessLogicImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2018 - 2019 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21 package org.onap.vid.mso;
  22
  23 import com.fasterxml.jackson.annotation.JsonCreator;
  24 import com.fasterxml.jackson.annotation.JsonValue;
  25 import com.fasterxml.jackson.databind.DeserializationFeature;
  26 import com.fasterxml.jackson.databind.ObjectMapper;
  27 import com.google.common.collect.ImmutableList;
  28 import com.google.common.collect.ImmutableMap;
  29 import io.joshworks.restclient.http.HttpResponse;
  30 import org.apache.commons.collections4.ListUtils;
  31 import org.jetbrains.annotations.NotNull;
  32 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  33 import org.onap.portalsdk.core.util.SystemProperties;
  34 import org.onap.vid.changeManagement.ChangeManagementRequest;
  35 import org.onap.vid.changeManagement.RequestDetailsWrapper;
  36 import org.onap.vid.changeManagement.WorkflowRequestDetail;
  37 import org.onap.vid.controller.OperationalEnvironmentController;
  38 import org.onap.vid.exceptions.GenericUncheckedException;
  39 import org.onap.vid.model.RequestReferencesContainer;
  40 import org.onap.vid.model.SOWorkflowList;
  41 import org.onap.vid.model.SoftDeleteRequest;
  42 import org.onap.vid.model.probes.ExternalComponentStatus;
  43 import org.onap.vid.model.probes.HttpRequestMetadata;
  44 import org.onap.vid.model.probes.StatusMetadata;
  45 import org.onap.vid.mso.model.CloudConfiguration;
  46 import org.onap.vid.mso.model.ModelInfo;
  47 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
  48 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
  49 import org.onap.vid.mso.model.RequestInfo;
  50 import org.onap.vid.mso.model.RequestParameters;
  51 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
  52 import org.onap.vid.mso.rest.RelatedInstance;
  53 import org.onap.vid.mso.rest.Request;
  54 import org.onap.vid.mso.rest.RequestDetails;
  55 import org.onap.vid.mso.rest.RequestList;
  56 import org.onap.vid.mso.rest.RequestWrapper;
  57 import org.onap.vid.mso.rest.Task;
  58 import org.onap.vid.mso.rest.TaskList;
  59 import org.springframework.beans.factory.annotation.Autowired;
  60 import org.springframework.http.HttpMethod;
  61 import org.springframework.http.HttpStatus;
  62 import org.togglz.core.manager.FeatureManager;
  63
  64 import javax.ws.rs.BadRequestException;
  65 import java.io.IOException;
  66 import java.util.ArrayList;
  67 import java.util.Collections;
  68 import java.util.HashMap;
  69 import java.util.List;
  70 import java.util.Map;
  71 import java.util.Objects;
  72 import java.util.UUID;
  73 import java.util.regex.Pattern;
  74 import java.util.stream.Collectors;
  75 import java.util.stream.Stream;
  76
  77 import static java.util.stream.Collectors.collectingAndThen;
  78 import static java.util.stream.Collectors.toList;
  79 import static org.apache.commons.lang.StringUtils.upperCase;
  80 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
  81 import static org.onap.vid.controller.MsoController.CONFIGURATION_ID;
  82 import static org.onap.vid.controller.MsoController.REQUEST_TYPE;
  83 import static org.onap.vid.controller.MsoController.SVC_INSTANCE_ID;
  84 import static org.onap.vid.controller.MsoController.VNF_INSTANCE_ID;
  85 import static org.onap.vid.controller.MsoController.WORKFLOW_ID;
  86 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS;
  87 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE;
  88 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE;
  89 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE;
  90 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_WORKFLOW_SPECIFICATIONS;
  91 import static org.onap.vid.properties.Features.FLAG_UNASSIGN_SERVICE;
  92 import static org.onap.vid.utils.Logging.debugRequestDetails;
  93
  94 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
  95
  96     static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
  97             RequestType.UPDATE_INSTANCE,
  98             RequestType.APPLY_UPDATED_CONFIG,
  99             RequestType.IN_PLACE_SOFTWARE_UPDATE,
 100             RequestType.SCALE_OUT)
 101             .map(requestType -> requestType.toString().toUpperCase())
 102             .collect(collectingAndThen(toList(), Collections::unmodifiableList));
 103     private static final String RESOURCE_TYPE = "resourceType";
 104     private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
 105     private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
 106     private static final String ACTIVATE = "/activate";
 107     private static final String DEACTIVATE = "/deactivate";
 108     private static final String ENABLE_PORT = "/enablePort";
 109     private static final String DISABLE_PORT = "/disablePort";
 110     private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
 111     private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
 112     private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
 113     private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
 114     private static final ObjectMapper objectMapper = new ObjectMapper();
 115     /**
 116      * The logger.
 117      */
 118     private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
 119     /**
 120      * The Mso REST client
 121      * This should be replaced with mso client factory.
 122      */
 123     private final MsoInterface msoClientInterface;
 124     FeatureManager featureManager;
 125
 126     @Autowired
 127     public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
 128         this.msoClientInterface = msoClientInterface;
 129         this.featureManager = featureManager;
 130     }
 131
 132     public static String validateEndpointPath(String endpointEnvVariable) {
 133         String endpoint = SystemProperties.getProperty(endpointEnvVariable);
 134         if (endpoint == null || endpoint.isEmpty()) {
 135             throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
 136         }
 137         return endpoint;
 138     }
 139
 140     // this function should get params from tosca and send them to instance at mso, then return success response.
 141     @Override
 142     public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
 143         logInvocationInDebug("createSvcInstance");
 144
 145         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 146
 147         return msoClientInterface.createSvcInstance(msoRequest, endpoint);
 148     }
 149
 150     @Override
 151     public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
 152         logInvocationInDebug("createE2eSvcInstance");
 153         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
 154
 155         return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
 156     }
 157
 158     @Override
 159     public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
 160         logInvocationInDebug("createVnf");
 161
 162         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 163
 164         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 165         return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
 166     }
 167
 168     @Override
 169     public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
 170         logInvocationInDebug("createNwInstance");
 171
 172         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 173
 174         String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 175         return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
 176     }
 177
 178     @Override
 179     public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 180         logInvocationInDebug("createVolumeGroupInstance");
 181
 182         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 183
 184         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 185         vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 186
 187         return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
 188     }
 189
 190     @Override
 191     public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 192         logInvocationInDebug("createVfModuleInstance");
 193
 194         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 195
 196         String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 197         String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 198
 199         return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
 200     }
 201
 202     @Override
 203     public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 204         logInvocationInDebug("scaleOutVfModuleInstance");
 205
 206         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
 207
 208         String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 209         String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 210         RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
 211         requestDetails.setVnfName(null);
 212         requestDetails.setVnfInstanceId(null);
 213         wrapper.requestDetails = requestDetails;
 214
 215         return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
 216     }
 217
 218     @Override
 219     public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
 220         logInvocationInDebug("invokeVnfWorkflow");
 221
 222         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
 223
 224         String final_endpoint = endpoint
 225                 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
 226                 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
 227                 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
 228
 229         Map<String,String> extraHeaders = new HashMap<>();
 230
 231         UUID requestId = UUID.randomUUID();
 232         extraHeaders.put("X-ONAP-RequestID",requestId.toString());
 233         extraHeaders.put("X-ONAP-PartnerName","VID");
 234         extraHeaders.put("X-RequestorID",userId);
 235
 236         return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
 237     }
 238
 239     @Override
 240     public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
 241         logInvocationInDebug("createConfigurationInstance");
 242
 243         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
 244         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 245
 246         return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
 247     }
 248
 249     @Override
 250     public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
 251         logInvocationInDebug("deleteE2eSvcInstance");
 252
 253         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
 254
 255         return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
 256     }
 257
 258     @Override
 259     public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
 260         logInvocationInDebug("deleteSvcInstance");
 261         String endpoint;
 262
 263         if (featureManager.isActive(FLAG_UNASSIGN_SERVICE)) {
 264             endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
 265             if (shouldUnassignService(serviceStatus)) {
 266                 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
 267                 String svc_endpoint = endpoint + "/" + serviceInstanceId + "/unassign";
 268                 return msoClientInterface.unassignSvcInstance(requestDetails, svc_endpoint);
 269             }
 270         } else {
 271             endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 272         }
 273
 274         String svc_endpoint = endpoint + "/" + serviceInstanceId;
 275         return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
 276     }
 277
 278     private boolean shouldUnassignService(String serviceStatus) {
 279         return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
 280     }
 281
 282     @Override
 283     public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 284         logInvocationInDebug("deleteVnf");
 285
 286         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 287         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 288         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 289
 290         return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
 291     }
 292
 293     @Override
 294     public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
 295         logInvocationInDebug("deleteVfModule");
 296
 297         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 298         String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 299         String delete_vf_endpoint = vf__modules_endpoint + '/' + vfModuleId;
 300
 301         return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
 302     }
 303
 304     @Override
 305     public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
 306         logInvocationInDebug("deleteVolumeGroupInstance");
 307
 308         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 309         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 310         String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 311         String delete_volume_group_endpoint = vnfEndpoint + "/" + volumeGroupId;
 312
 313         return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
 314     }
 315
 316     @Override
 317     public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
 318         logInvocationInDebug("deleteNwInstance");
 319
 320         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 321         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 322         String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
 323
 324         return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
 325     }
 326
 327     @Override
 328     public MsoResponseWrapper getOrchestrationRequest(String requestId) {
 329         String methodName = "getOrchestrationRequest";
 330         logInvocationInDebug(methodName);
 331         try {
 332             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
 333             String path = p + "/" + requestId;
 334
 335             return msoClientInterface.getOrchestrationRequest(path);
 336
 337         } catch (Exception e) {
 338             logException(methodName, e);
 339             throw e;
 340         }
 341     }
 342
 343     @Override
 344     public MsoResponseWrapper getOrchestrationRequests(String filterString) {
 345         String methodName = "getOrchestrationRequest";
 346         logInvocationInDebug(methodName);
 347         try {
 348             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 349             String path = p + filterString;
 350
 351             return msoClientInterface.getOrchestrationRequest(path);
 352
 353         } catch (Exception e) {
 354             logException(methodName, e);
 355             throw e;
 356         }
 357     }
 358
 359     @Override
 360     public List<Request> getOrchestrationRequestsForDashboard() {
 361         String methodName = "getOrchestrationRequestsForDashboard";
 362         logInvocationInDebug(methodName);
 363
 364         List<Request> dashboardOrchestrationReqs = new ArrayList<>();
 365         try {
 366             List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
 367             dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
 368                     .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
 369                             && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
 370                     .map(RequestWrapper::getRequest)
 371                     .collect(Collectors.toList());
 372
 373             List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
 374             List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
 375                     .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
 376                     .map(RequestWrapper::getRequest)
 377                     .collect(Collectors.toList());
 378
 379             dashboardOrchestrationReqs.addAll(scaleoutRequests);
 380         } catch (Exception e) {
 381             logException(methodName, e);
 382             throw e;
 383         }
 384         return dashboardOrchestrationReqs;
 385     }
 386
 387     private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
 388         return String.format("%sfilter=%s:EQUALS:%s",
 389                 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
 390     }
 391
 392     private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
 393         String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
 394         RestObject<String> restObjStr = new RestObject<>();
 395         String str = new String();
 396         restObjStr.set(str);
 397         MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
 398         return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
 399     }
 400
 401     private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
 402         logInvocationInDebug("deserializeOrchestrationRequestsJson");
 403
 404         ObjectMapper mapper = new ObjectMapper();
 405         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 406         mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
 407         RequestList requestList;
 408         try {
 409             requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
 410         } catch (IOException e) {
 411             throw new GenericUncheckedException(e);
 412         }
 413         return ListUtils.emptyIfNull(requestList.getRequestList());
 414     }
 415
 416
 417     @Override
 418     public List<Task> getManualTasksByRequestId(String originalRequestId) {
 419         String methodName = "getManualTasksByRequestId";
 420         logInvocationInDebug(methodName);
 421
 422         try {
 423             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 424             String path = p + "?originalRequestId=" + originalRequestId;
 425
 426             RestObject<String> restObjStr = new RestObject<>();
 427             String str = new String();
 428             restObjStr.set(str);
 429
 430             MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
 431             return deserializeManualTasksJson(msoResponseWrapper.getEntity());
 432
 433         } catch (Exception e) {
 434             logException(methodName, e);
 435             throw e;
 436         }
 437     }
 438
 439     private List<Task> deserializeManualTasksJson(String manualTasksJson) {
 440         logInvocationInDebug("deserializeManualTasksJson");
 441
 442         ObjectMapper mapper = new ObjectMapper();
 443         try {
 444             TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
 445             return taskList.getTaskList();
 446         } catch (IOException e) {
 447             throw new GenericUncheckedException(e);
 448         }
 449     }
 450
 451
 452     @Override
 453     public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
 454         String methodName = "completeManualTask";
 455         logInvocationInDebug(methodName);
 456         try {
 457             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 458             String path = p + "/" + taskId + "/complete";
 459
 460             RestObject<String> restObjStr = new RestObject<>();
 461             String str = new String();
 462             restObjStr.set(str);
 463
 464             return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
 465
 466         } catch (Exception e) {
 467             logException(methodName, e);
 468             throw e;
 469         }
 470     }
 471
 472     @Override
 473     public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 474         String methodName = "activateServiceInstance";
 475         logInvocationInDebug(methodName);
 476         try {
 477             String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 478             String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
 479
 480             RestObject<String> restObjStr = new RestObject<>();
 481             String str = "";
 482             restObjStr.set(str);
 483
 484             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", activateServicePath, restObjStr);
 485
 486             return MsoUtil.wrapResponse(restObjStr);
 487
 488         } catch (Exception e) {
 489             logException(methodName, e);
 490             throw e;
 491         }
 492     }
 493
 494
 495     @Override
 496     public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 497         logInvocationInDebug("updateVnf");
 498
 499         String endpoint;
 500         endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 501         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 502         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 503         return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
 504     }
 505
 506     @Override
 507     public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 508         logInvocationInDebug("replaceVnf");
 509
 510         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
 511         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 512         vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
 513         vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
 514         return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
 515     }
 516
 517     public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
 518         validateUpdateVnfSoftwarePayload(requestDetails);
 519         RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
 520         inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
 521         inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 522         inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 523         RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
 524         requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
 525         return requestDetailsWrapper;
 526     }
 527
 528     @Override
 529     public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
 530         validateUpdateVnfConfig(requestDetails);
 531         RequestDetails configUpdateRequest = new RequestDetails();
 532         configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 533         configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 534         RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
 535         requestDetailsWrapper.requestDetails = configUpdateRequest;
 536         return requestDetailsWrapper;
 537     }
 538
 539     @Override
 540     public String getActivateFabricConfigurationPath(String serviceInstanceId) {
 541         String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
 542         path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
 543
 544         return path;
 545     }
 546
 547     @Override
 548     public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
 549         String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 550         path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 551         path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 552         path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
 553
 554         return path;
 555     }
 556
 557     @Override
 558     public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
 559         RequestDetails requestDetails = new RequestDetails();
 560         RequestInfo requestInfo = new RequestInfo();
 561         requestInfo.setSource("VID");
 562         requestInfo.setRequestorId(softDeleteRequest.getUserId());
 563         requestDetails.setRequestInfo(requestInfo);
 564
 565         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 566         cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
 567         cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
 568         requestDetails.setCloudConfiguration(cloudConfiguration);
 569
 570         ModelInfo modelInfo = new ModelInfo();
 571         modelInfo.setModelType("vfModule");
 572         requestDetails.setModelInfo(modelInfo);
 573
 574         RequestParameters requestParameters = new RequestParameters();
 575         requestParameters.setTestApi("GR_API");
 576         requestDetails.setRequestParameters(requestParameters);
 577
 578         return requestDetails;
 579     }
 580
 581     @Override
 582     public MsoResponseWrapper2 deactivateAndCloudDelete(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId, RequestDetails requestDetails) {
 583         String path = getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
 584         return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
 585     }
 586
 587     @Override
 588     public MsoResponseWrapper2 activateFabricConfiguration(String serviceInstanceId, RequestDetails requestDetails) {
 589         String path = getActivateFabricConfigurationPath(serviceInstanceId);
 590         return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
 591     }
 592
 593     @Override
 594     public SOWorkflowList getWorkflowListByModelId(String modelVersionId) {
 595         logInvocationInDebug("getWorkflowListByModelId");
 596         String pathTemplate = validateEndpointPath(MSO_REST_API_WORKFLOW_SPECIFICATIONS);
 597         String path = pathTemplate.replaceFirst("<model_version_id>", modelVersionId);
 598
 599         HttpResponse<SOWorkflowList> workflowListByModelId = msoClientInterface.getWorkflowListByModelId(path);
 600         if (!isSuccessful(workflowListByModelId)) {
 601             logger.error(EELFLoggerDelegate.errorLogger, workflowListByModelId.getStatusText());
 602             throw new WorkflowListException(String.format("Get worklflow list for id: %s failed due to %s", modelVersionId, workflowListByModelId.getStatusText()));
 603         }
 604         return workflowListByModelId.getBody();
 605     }
 606
 607
 608     @Override
 609     public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 610         logInvocationInDebug("updateVnfSoftware");
 611         String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
 612         RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
 613         return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
 614     }
 615
 616     @Override
 617     public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 618         logInvocationInDebug("updateVnfConfig");
 619         RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
 620         String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
 621         return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
 622     }
 623
 624     private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
 625         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
 626         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 627         vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
 628         vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
 629         return vnfEndpoint;
 630     }
 631
 632     private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
 633         if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
 634             throw new BadRequestException(message);
 635         }
 636         Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
 637         try {
 638             return objectMapper.readValue((String) payloadRaw, Map.class);
 639         } catch (Exception exception) {
 640             throw new BadRequestException(message);
 641         }
 642     }
 643
 644     private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
 645         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
 646
 647         Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
 648         validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
 649         validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
 650
 651         //if "operations_timeout" is not integer, trying to read it as String that represent a number
 652         if (!(payload.get("operations_timeout") instanceof Integer)) {
 653             validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
 654         }
 655     }
 656
 657     private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
 658         Object forValidation = payload.get(propertyName);
 659         final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
 660         if (!(forValidation instanceof String)) {
 661             throw new BadRequestException(noValidPayloadPropertyMsg);
 662         }
 663         if (!pattern.matcher((String) forValidation).matches()) {
 664             throw new BadRequestException(noValidPayloadPropertyMsg);
 665         }
 666     }
 667
 668     @Override
 669     public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
 670                                                   String serviceInstanceId,
 671                                                   String configurationId) {
 672
 673         logInvocationInDebug("deleteConfiguration");
 674         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
 675         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 676         endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
 677
 678         return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
 679     }
 680
 681     @Override
 682     public MsoResponseWrapper setConfigurationActiveStatus(
 683             RequestDetails requestDetails,
 684             String serviceInstanceId,
 685             String configurationId,
 686             boolean isActivate) {
 687
 688         logInvocationInDebug("setConfigurationActiveStatus");
 689
 690         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
 691         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 692         endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
 693
 694         String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 695         endpoint = endpoint + isActivateState;
 696
 697         return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
 698     }
 699
 700     @Override
 701     public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
 702         logInvocationInDebug("setServiceInstanceStatus");
 703         String methodName = "setServiceInstanceStatus";
 704         try {
 705             String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 706             String endpoint = serviceEndpoint + "/" + serviceInstanceId;
 707
 708             String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 709             endpoint = endpoint + isActivateState;
 710
 711
 712             RestObject<String> restObjStr = new RestObject<>();
 713             String str = "";
 714             restObjStr.set(str);
 715
 716             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", endpoint, restObjStr);
 717
 718             return MsoUtil.wrapResponse(restObjStr);
 719
 720         } catch (Exception e) {
 721             logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 722             logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 723             throw e;
 724         }
 725     }
 726
 727     @Override
 728     public MsoResponseWrapper setPortOnConfigurationStatus(
 729             RequestDetails requestDetails,
 730             String serviceInstanceId,
 731             String configurationId,
 732             boolean isEnable) {
 733         logInvocationInDebug("setPortOnConfigurationStatus");
 734
 735         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
 736         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 737         endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
 738
 739         String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
 740         endpoint = endpoint + isEnablePortStatus;
 741
 742         return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
 743     }
 744
 745
 746     @Override
 747     public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
 748         RequestDetails requestDetails = new RequestDetails();
 749         RequestInfo requestInfo = new RequestInfo();
 750         requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
 751         requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
 752         requestInfo.setRequestorId(details.getUserId());
 753         requestDetails.setRequestInfo(requestInfo);
 754
 755         RelatedInstance relatedInstance = new RelatedInstance();
 756         relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
 757         relatedInstance.setInstanceId(details.getRelatedInstanceId());
 758         relatedInstance.setInstanceName(details.getRelatedInstanceName());
 759         requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
 760
 761         RequestParameters requestParameters = new RequestParameters();
 762         requestParameters.setUserParams(null);
 763         requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
 764         requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
 765         requestParameters.setAdditionalProperty("manifest", details.getManifest());
 766         requestDetails.setRequestParameters(requestParameters);
 767
 768         RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 769
 770         debugRequestDetails(requestDetailsWrapper, logger);
 771
 772         return requestDetailsWrapper;
 773     }
 774
 775     @Override
 776     public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
 777         String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
 778         path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
 779         return path;
 780     }
 781
 782     @Override
 783     public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
 784         RequestDetails requestDetails = new RequestDetails();
 785
 786         RequestInfo requestInfo = new RequestInfo();
 787         requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
 788         requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
 789         requestInfo.setRequestorId(details.getUserId());
 790         requestDetails.setRequestInfo(requestInfo);
 791
 792         RequestParameters requestParameters = new RequestParameters();
 793         requestParameters.setUserParams(null);
 794         requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
 795         requestDetails.setRequestParameters(requestParameters);
 796         RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 797         debugRequestDetails(requestDetailsWrapper, logger);
 798         return requestDetailsWrapper;
 799     }
 800
 801     @Override
 802     public String getCloudResourcesRequestsStatusPath(String requestId) {
 803         String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
 804         path = path.replace("<request_id>", requestId);
 805         return path;
 806     }
 807
 808     @Override
 809     public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
 810         String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
 811         path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
 812         return path;
 813     }
 814
 815     @Override
 816     public String getOperationalEnvironmentCreationPath() {
 817         return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
 818     }
 819
 820
 821     @Override
 822     public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
 823         OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
 824                 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
 825                 input.getInstanceName(),
 826                 SOURCE_OPERATIONAL_ENVIRONMENT,
 827                 userId);
 828
 829         OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
 830                 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
 831                 input.getEcompInstanceId(),
 832                 input.getEcompInstanceName());
 833
 834         List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
 835
 836         OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
 837                 input.getOperationalEnvironmentType(),
 838                 input.getTenantContext(),
 839                 input.getWorkloadContext());
 840
 841         OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
 842         RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 843         debugRequestDetails(requestDetailsWrapper, logger);
 844         return requestDetailsWrapper;
 845     }
 846
 847     @Override
 848     public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 849         logInvocationInDebug("removeRelationshipFromServiceInstance");
 850
 851         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 852         String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
 853
 854         return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
 855     }
 856
 857     @Override
 858     public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 859         logInvocationInDebug("addRelationshipToServiceInstance");
 860
 861         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 862         String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
 863
 864         return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
 865     }
 866
 867
 868     @Override
 869     public ExternalComponentStatus probeGetOrchestrationRequests() {
 870         String url = SystemProperties.getProperty(
 871                 MsoProperties.MSO_SERVER_URL) + "/" + SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 872         long startTime = System.currentTimeMillis();
 873         ExternalComponentStatus externalComponentStatus;
 874
 875         try {
 876             RestObject<List<Request>> restObject = createRequestsList(getOrchestrationRequestsForDashboard());
 877
 878             StatusMetadata statusMetadata = new HttpRequestMetadata(new RestObjectWithRequestInfo(HttpMethod.GET, url, restObject),
 879                     "VID-SO communication works", System.currentTimeMillis() - startTime);
 880
 881             externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, true, statusMetadata);
 882         } catch (Exception e) {
 883             StatusMetadata statusMetadata = new HttpRequestMetadata(HttpMethod.GET, HttpStatus.INTERNAL_SERVER_ERROR.value(), url, "", e.getMessage(), System.currentTimeMillis() - startTime);
 884             externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false, statusMetadata);
 885         }
 886
 887         return externalComponentStatus;
 888     }
 889
 890     @NotNull
 891     private RestObject<List<Request>> createRequestsList(List<Request> orchestrationRequestsForDashboard) {
 892         RestObject<List<Request>> restObject = new RestObject<>();
 893         restObject.set(orchestrationRequestsForDashboard);
 894         restObject.setStatusCode(200);
 895         return restObject;
 896     }
 897
 898
 899     private void validateUpdateVnfConfig(RequestDetails requestDetails) {
 900         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
 901
 902         Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
 903         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
 904         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
 905     }
 906
 907     private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
 908         final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
 909         if (!payload.containsKey(propertyName)) {
 910             throw new BadRequestException(noValidPayloadPropertyMsg);
 911         }
 912     }
 913
 914     private void logInvocationInDebug(String methodName) {
 915         logger.debug(EELFLoggerDelegate.debugLogger, methodName + "  start");
 916     }
 917
 918     private void logException(String methodName, Exception e) {
 919         logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 920         logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 921     }
 922
 923     private boolean isSuccessful(HttpResponse<SOWorkflowList> workflowListByModelId) {
 924         int status = workflowListByModelId.getStatus();
 925         return HttpStatus.OK.value() == status || HttpStatus.ACCEPTED.value() == status;
 926     }
 927
 928     static class WorkflowListException extends RuntimeException{
 929
 930         WorkflowListException(String message) {
 931             super(message);
 932         }
 933     }
 934
 935     enum RequestType {
 936
 937         CREATE_INSTANCE("createInstance"),
 938         DELETE_INSTANCE("deleteInstance"),
 939         REPLACE_INSTANCE("replaceInstance"),
 940         UPDATE_INSTANCE("updateInstance"),
 941         ACTIVATE_INSTANCE("activateInstance"),
 942         DEACTIVATE_INSTANCE("deactivateInstance"),
 943         APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
 944         IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
 945         SCALE_OUT("scaleOut"),
 946         UNKNOWN("unknown"),
 947         NOT_PROVIDED("not provided");
 948         private final String value;
 949         private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
 950
 951         static {
 952             for (RequestType c : values()) {
 953                 CONSTANTS.put(c.value, c);
 954             }
 955         }
 956
 957         RequestType(String value) {
 958             this.value = value;
 959         }
 960
 961         @JsonCreator
 962         public static RequestType fromValue(String value) {
 963             RequestType constant = CONSTANTS.get(value);
 964             if (constant == null) {
 965                 throw new IllegalArgumentException(value);
 966             } else {
 967                 return constant;
 968             }
 969         }
 970
 971         @JsonValue
 972         @Override
 973         public String toString() {
 974             return this.value;
 975         }
 976     }
 977 }