catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceServlet.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.be.servlets;
  21
  22 import com.fasterxml.jackson.core.JsonProcessingException;
  23 import com.fasterxml.jackson.databind.ObjectMapper;
  24 import com.google.gson.reflect.TypeToken;
  25 import com.jcabi.aspects.Loggable;
  26 import fj.data.Either;
  27 import io.swagger.v3.oas.annotations.Operation;
  28 import io.swagger.v3.oas.annotations.Parameter;
  29 import io.swagger.v3.oas.annotations.media.ArraySchema;
  30 import io.swagger.v3.oas.annotations.media.Content;
  31 import io.swagger.v3.oas.annotations.media.Schema;
  32 import io.swagger.v3.oas.annotations.responses.ApiResponse;
  33 import io.swagger.v3.oas.annotations.servers.Server;
  34 import io.swagger.v3.oas.annotations.servers.Servers;
  35 import io.swagger.v3.oas.annotations.tags.Tag;
  36 import io.swagger.v3.oas.annotations.tags.Tags;
  37 import java.io.File;
  38 import java.io.FileNotFoundException;
  39 import java.io.IOException;
  40 import java.lang.reflect.Type;
  41 import java.util.ArrayList;
  42 import java.util.List;
  43 import java.util.Map;
  44 import javax.inject.Inject;
  45 import javax.servlet.ServletContext;
  46 import javax.servlet.http.HttpServletRequest;
  47 import javax.ws.rs.Consumes;
  48 import javax.ws.rs.DELETE;
  49 import javax.ws.rs.GET;
  50 import javax.ws.rs.HeaderParam;
  51 import javax.ws.rs.POST;
  52 import javax.ws.rs.PUT;
  53 import javax.ws.rs.Path;
  54 import javax.ws.rs.PathParam;
  55 import javax.ws.rs.QueryParam;
  56 import javax.ws.rs.Produces;
  57 import javax.ws.rs.core.Context;
  58 import javax.ws.rs.core.MediaType;
  59 import javax.ws.rs.core.Response;
  60 import org.apache.http.HttpStatus;
  61 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
  62 import org.glassfish.jersey.media.multipart.FormDataParam;
  63 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  64 import org.openecomp.sdc.be.components.impl.ElementBusinessLogic;
  65 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  66 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  67 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  68 import org.openecomp.sdc.be.components.impl.aaf.AafPermission;
  69 import org.openecomp.sdc.be.components.impl.aaf.PermissionAllowed;
  70 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  71 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  72 import org.openecomp.sdc.be.dao.api.ActionStatus;
  73 import org.openecomp.sdc.be.datamodel.ServiceRelations;
  74 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
  75 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  76 import org.openecomp.sdc.be.impl.ComponentsUtils;
  77 import org.openecomp.sdc.be.impl.ServletUtils;
  78 import org.openecomp.sdc.be.model.Component;
  79 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  80 import org.openecomp.sdc.be.model.GroupInstanceProperty;
  81 import org.openecomp.sdc.be.model.Resource;
  82 import org.openecomp.sdc.be.model.Service;
  83 import org.openecomp.sdc.be.model.UploadServiceInfo;
  84 import org.openecomp.sdc.be.model.User;
  85 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  86 import org.openecomp.sdc.be.resources.data.auditing.model.DistributionData;
  87 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  88 import org.openecomp.sdc.be.servlets.ServiceUploadServlet.ServiceAuthorityTypeEnum;
  89 import org.openecomp.sdc.be.user.UserBusinessLogic;
  90 import org.openecomp.sdc.common.api.Constants;
  91 import org.openecomp.sdc.common.datastructure.Wrapper;
  92 import org.openecomp.sdc.common.log.elements.LoggerSupportability;
  93 import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions;
  94 import org.openecomp.sdc.common.log.enums.StatusCode;
  95 import org.openecomp.sdc.common.log.wrappers.Logger;
  96 import org.openecomp.sdc.common.zip.exception.ZipException;
  97 import org.openecomp.sdc.exception.ResponseFormat;
  98 import org.springframework.stereotype.Controller;
  99
 100 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
 101 @Path("/v1/catalog")
 102 @Servers({@Server(url = "/sdc2/rest")})
 103 @Controller
 104 public class ServiceServlet extends AbstractValidationsServlet {
 105
 106     private static final Logger log = Logger.getLogger(ServiceServlet.class);
 107     private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(ServiceServlet.class.getName());
 108     private static final String START_HANDLE_REQUEST_OF = "Start handle request of {}";
 109     private static final String MODIFIER_ID_IS = "modifier id is {}";
 110     private final ElementBusinessLogic elementBusinessLogic;
 111     private final ServiceBusinessLogic serviceBusinessLogic;
 112
 113     public enum Action {DELETE, MARK_AS_DELETE}
 114
 115     @Inject
 116     public ServiceServlet(UserBusinessLogic userBusinessLogic, ComponentInstanceBusinessLogic componentInstanceBL, ComponentsUtils componentsUtils,
 117                           ServletUtils servletUtils, ResourceImportManager resourceImportManager, ServiceBusinessLogic serviceBusinessLogic,
 118                           ResourceBusinessLogic resourceBusinessLogic, ElementBusinessLogic elementBusinessLogic) {
 119         super(userBusinessLogic, componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);
 120         this.serviceBusinessLogic = serviceBusinessLogic;
 121         this.elementBusinessLogic = elementBusinessLogic;
 122     }
 123
 124     @POST
 125     @Path("/services")
 126     @Tags({@Tag(name = "SDCE-2 APIs")})
 127     @Consumes(MediaType.APPLICATION_JSON)
 128     @Produces(MediaType.APPLICATION_JSON)
 129     @Operation(description = "Create Service", method = "POST", summary = "Returns created service", responses = {
 130         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 131         @ApiResponse(responseCode = "201", description = "Service created"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 132         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 133         @ApiResponse(responseCode = "409", description = "Service already exist")})
 134     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 135     public Response createService(@Parameter(description = "Service object to be created", required = true) String data,
 136                                   @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 137         String url = request.getMethod() + " " + request.getRequestURI();
 138         log.debug(START_HANDLE_REQUEST_OF, url);
 139         User modifier = new User();
 140         modifier.setUserId(userId);
 141         log.debug(MODIFIER_ID_IS, userId);
 142         loggerSupportability.log(LoggerSupportabilityActions.CREATE_SERVICE, StatusCode.STARTED, "Starting to create a service by user {} ", userId);
 143         validateNotEmptyBody(data);
 144         Either<Service, ResponseFormat> convertResponse = parseToService(data, modifier);
 145         if (convertResponse.isRight()) {
 146             throw new ByResponseFormatComponentException(convertResponse.right().value());
 147         }
 148         Service service = convertResponse.left().value();
 149         Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.createService(service, modifier);
 150         if (actionResponse.isRight()) {
 151             log.debug("Failed to create service");
 152             throw new ByResponseFormatComponentException(actionResponse.right().value());
 153         }
 154         loggerSupportability.log(LoggerSupportabilityActions.CREATE_SERVICE, service.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,
 155             "Service {} has been created by user {} ", service.getName(), userId);
 156         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), actionResponse.left().value());
 157     }
 158
 159     public Either<Service, ResponseFormat> parseToService(String serviceJson, User user) {
 160         return getComponentsUtils()
 161             .convertJsonToObjectUsingObjectMapper(serviceJson, user, Service.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
 162     }
 163
 164     @GET
 165     @Path("/services/validate-name/{serviceName}")
 166     @Tags({@Tag(name = "SDCE-2 APIs")})
 167     @Consumes(MediaType.APPLICATION_JSON)
 168     @Produces(MediaType.APPLICATION_JSON)
 169     @Operation(description = "validate service name", method = "GET", summary = "checks if the chosen service name is available ", responses = {
 170         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 171         @ApiResponse(responseCode = "200", description = "Service found"), @ApiResponse(responseCode = "403", description = "Restricted operation")})
 172     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 173     public Response validateServiceName(@PathParam("serviceName") final String serviceName, @Context final HttpServletRequest request,
 174                                         @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 175         String url = request.getMethod() + " " + request.getRequestURI();
 176         log.debug(START_HANDLE_REQUEST_OF, url);
 177         // get modifier id
 178         User modifier = new User();
 179         modifier.setUserId(userId);
 180         log.debug(MODIFIER_ID_IS, userId);
 181         try {
 182             Either<Map<String, Boolean>, ResponseFormat> actionResponse = serviceBusinessLogic.validateServiceNameExists(serviceName, userId);
 183             if (actionResponse.isRight()) {
 184                 log.debug("failed to get validate service name");
 185                 return buildErrorResponse(actionResponse.right().value());
 186             }
 187             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), actionResponse.left().value());
 188         } catch (Exception e) {
 189             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Validate Service Name");
 190             log.debug("validate service name failed with exception", e);
 191             throw e;
 192         }
 193     }
 194
 195     @GET
 196     @Path("/audit-records/{componentType}/{componentUniqueId}")
 197     @Tags({@Tag(name = "SDCE-2 APIs")})
 198     @Consumes(MediaType.APPLICATION_JSON)
 199     @Produces(MediaType.APPLICATION_JSON)
 200     @Operation(description = "get component audit records", method = "GET", summary = "get audit records for a service or a resource", responses = {
 201         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 202         @ApiResponse(responseCode = "200", description = "Service found"), @ApiResponse(responseCode = "403", description = "Restricted operation")})
 203     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 204     public Response getComponentAuditRecords(@PathParam("componentType") final String componentType,
 205                                              @PathParam("componentUniqueId") final String componentUniqueId,
 206                                              @Context final HttpServletRequest request,
 207                                              @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 208         init();
 209         ServletContext context = request.getSession().getServletContext();
 210         String url = request.getMethod() + " " + request.getRequestURI();
 211         log.debug(START_HANDLE_REQUEST_OF, url);
 212         User modifier = new User();
 213         modifier.setUserId(userId);
 214         log.debug(MODIFIER_ID_IS, userId);
 215         Wrapper<Response> responseWrapper = new Wrapper<>();
 216         Wrapper<String> uuidWrapper = new Wrapper<>();
 217         Wrapper<String> versionWrapper = new Wrapper<>();
 218         Wrapper<User> userWrapper = new Wrapper<>();
 219         try {
 220             validateUserExist(responseWrapper, userWrapper, userId);
 221             if (responseWrapper.isEmpty()) {
 222                 fillUUIDAndVersion(responseWrapper, uuidWrapper, versionWrapper, userWrapper.getInnerElement(), validateComponentType(componentType),
 223                     componentUniqueId, context);
 224             }
 225             if (responseWrapper.isEmpty()) {
 226                 Either<List<Map<String, Object>>, ResponseFormat> eitherServiceAudit = serviceBusinessLogic
 227                     .getComponentAuditRecords(versionWrapper.getInnerElement(), uuidWrapper.getInnerElement(), userId);
 228                 if (eitherServiceAudit.isRight()) {
 229                     Response errorResponse = buildErrorResponse(eitherServiceAudit.right().value());
 230                     responseWrapper.setInnerElement(errorResponse);
 231                 } else {
 232                     List<Map<String, Object>> auditRecords = eitherServiceAudit.left().value();
 233                     Response okResponse = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), auditRecords);
 234                     responseWrapper.setInnerElement(okResponse);
 235                 }
 236             }
 237         } catch (Exception e) {
 238             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Validate Service Name");
 239             log.debug("get Service Audit Records failed with exception", e);
 240             throw e;
 241         }
 242         return responseWrapper.getInnerElement();
 243     }
 244
 245     private void fillUUIDAndVersion(Wrapper<Response> responseWrapper, Wrapper<String> uuidWrapper, Wrapper<String> versionWrapper, User user,
 246                                     final ComponentTypeEnum componentTypeEnum, final String componentUniqueId, ServletContext context) {
 247         if (componentTypeEnum == ComponentTypeEnum.RESOURCE) {
 248             Either<Resource, ResponseFormat> eitherResource = getResourceBL(context).getResource(componentUniqueId, user);
 249             if (eitherResource.isLeft()) {
 250                 uuidWrapper.setInnerElement(eitherResource.left().value().getUUID());
 251                 versionWrapper.setInnerElement(eitherResource.left().value().getVersion());
 252             } else {
 253                 responseWrapper.setInnerElement(buildErrorResponse(eitherResource.right().value()));
 254             }
 255         } else {
 256             Either<Service, ResponseFormat> eitherService = getServiceBL(context).getService(componentUniqueId, user);
 257             if (eitherService.isLeft()) {
 258                 uuidWrapper.setInnerElement(eitherService.left().value().getUUID());
 259                 versionWrapper.setInnerElement(eitherService.left().value().getVersion());
 260             } else {
 261                 responseWrapper.setInnerElement(buildErrorResponse(eitherService.right().value()));
 262             }
 263         }
 264     }
 265
 266     @DELETE
 267     @Path("/services/{serviceId}")
 268     @Tags({@Tag(name = "SDCE-2 APIs")})
 269     @Operation(description = "Delete Service", method = "DELETE", summary = "Return no content", responses = {
 270         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 271         @ApiResponse(responseCode = "204", description = "Service deleted"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 272         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 273         @ApiResponse(responseCode = "404", description = "Service not found")})
 274     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 275     public Response deleteService(@PathParam("serviceId") final String serviceId,
 276                                   @Parameter(description = "Optional parameter to determine the delete action: " +
 277                                           "DELETE, which will permanently delete theService from the system or " +
 278                                           "MARK_AS_DELETE, which will logically mark the service as deleted. Default action is to MARK_AS_DELETE")
 279                                   @QueryParam("deleteAction") final Action deleteAction,
 280                                   @Context final HttpServletRequest request) {
 281         ServletContext context = request.getSession().getServletContext();
 282         String url = request.getMethod() + " " + request.getRequestURI();
 283         log.debug(START_HANDLE_REQUEST_OF, url);
 284         // get modifier id
 285         String userId = request.getHeader(Constants.USER_ID_HEADER);
 286         User modifier = new User();
 287         modifier.setUserId(userId);
 288         log.debug(MODIFIER_ID_IS, userId);
 289         try {
 290             String serviceIdLower = serviceId.toLowerCase();
 291             loggerSupportability
 292                 .log(LoggerSupportabilityActions.DELETE_SERVICE, StatusCode.STARTED, "Starting to delete service {} by user {} ", serviceIdLower,
 293                     userId);
 294             ServiceBusinessLogic businessLogic = getServiceBL(context);
 295             ResponseFormat actionResponse;
 296             if (Action.DELETE.equals(deleteAction)) {
 297                 businessLogic.deleteServiceAllVersions(serviceIdLower, modifier);
 298                 actionResponse = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
 299             } else {
 300                 actionResponse = businessLogic.markServiceForDeletion(serviceIdLower, modifier);
 301             }
 302             if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 303                 log.debug("failed to delete service");
 304                 return buildErrorResponse(actionResponse);
 305             }
 306             loggerSupportability
 307                 .log(LoggerSupportabilityActions.DELETE_SERVICE, StatusCode.COMPLETE, "Ended deleting service {} by user {}", serviceIdLower, userId);
 308             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 309         } catch (Exception e) {
 310             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Service");
 311             log.debug("delete service failed with exception", e);
 312             throw e;
 313         }
 314     }
 315
 316     @DELETE
 317     @Path("/services/{serviceName}/{version}")
 318     @Tags({@Tag(name = "SDCE-2 APIs")})
 319     @Operation(description = "Delete Service By Name And Version", method = "DELETE", summary = "Returns no content", responses = {
 320         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Resource.class)))),
 321         @ApiResponse(responseCode = "204", description = "Service deleted"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 322         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 323         @ApiResponse(responseCode = "404", description = "Service not found")})
 324     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 325     public Response deleteServiceByNameAndVersion(@PathParam("serviceName") final String serviceName, @PathParam("version") final String version,
 326                                                   @Context final HttpServletRequest request) {
 327         User modifier = getUser(request);
 328         try {
 329             ResponseFormat actionResponse = serviceBusinessLogic.deleteServiceByNameAndVersion(serviceName, version, modifier);
 330             if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 331                 log.debug("failed to delete service");
 332                 return buildErrorResponse(actionResponse);
 333             }
 334             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 335         } catch (Exception e) {
 336             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Service");
 337             log.debug("delete service failed with exception", e);
 338             throw e;
 339         }
 340     }
 341
 342     private User getUser(HttpServletRequest request) {
 343         String url = request.getMethod() + " " + request.getRequestURI();
 344         log.debug(START_HANDLE_REQUEST_OF, url);
 345         // get modifier id
 346         String userId = request.getHeader(Constants.USER_ID_HEADER);
 347         User modifier = new User();
 348         modifier.setUserId(userId);
 349         log.debug(MODIFIER_ID_IS, userId);
 350         return modifier;
 351     }
 352
 353     @PUT
 354     @Path("/services/{serviceId}/metadata")
 355     @Tags({@Tag(name = "SDCE-2 APIs")})
 356     @Consumes(MediaType.APPLICATION_JSON)
 357     @Produces(MediaType.APPLICATION_JSON)
 358     @Operation(description = "Update Service Metadata", method = "PUT", summary = "Returns updated service", responses = {
 359         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 360         @ApiResponse(responseCode = "200", description = "Service Updated"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 361         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content")})
 362     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 363     public Response updateServiceMetadata(@PathParam("serviceId") final String serviceId,
 364                                           @Parameter(description = "Service object to be Updated", required = true) String data,
 365                                           @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId)
 366         throws IOException {
 367         String url = request.getMethod() + " " + request.getRequestURI();
 368         log.debug(START_HANDLE_REQUEST_OF, url);
 369         User modifier = new User();
 370         modifier.setUserId(userId);
 371         log.debug(MODIFIER_ID_IS, userId);
 372         try {
 373             String serviceIdLower = serviceId.toLowerCase();
 374             Either<Service, ResponseFormat> convertResponse = parseToService(data, modifier);
 375             if (convertResponse.isRight()) {
 376                 log.debug("failed to parse service");
 377                 return buildErrorResponse(convertResponse.right().value());
 378             }
 379             Service updatedService = convertResponse.left().value();
 380             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.updateServiceMetadata(serviceIdLower, updatedService, modifier);
 381             if (actionResponse.isRight()) {
 382                 log.debug("failed to update service");
 383                 return buildErrorResponse(actionResponse.right().value());
 384             }
 385             Service service = actionResponse.left().value();
 386             Object result = RepresentationUtils.toRepresentation(service);
 387             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 388         } catch (Exception e) {
 389             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Service Metadata");
 390             log.debug("update service metadata failed with exception", e);
 391             throw e;
 392         }
 393     }
 394
 395     /**
 396      * updates group instance property values Note, than in case of group instance updated successfully, related resourceInstance and containing
 397      * component modification time will be updated
 398      *
 399      * @param serviceId
 400      * @param componentInstanceId
 401      * @param groupInstanceId
 402      * @param data
 403      * @param request
 404      * @param userId
 405      * @return
 406      */
 407     @PUT
 408     @Path("/{containerComponentType}/{serviceId}/resourceInstance/{componentInstanceId}/groupInstance/{groupInstanceId}")
 409     @Tags({@Tag(name = "SDCE-2 APIs")})
 410     @Consumes(MediaType.APPLICATION_JSON)
 411     @Produces(MediaType.APPLICATION_JSON)
 412     @Operation(description = "Update Group Instance Property Values", method = "PUT", summary = "Returns updated group instance", responses = {
 413         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 414         @ApiResponse(responseCode = "200", description = "Group Instance Property Values Updated"),
 415         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 416         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content")})
 417     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 418     public Response updateGroupInstancePropertyValues(@PathParam("serviceId") final String serviceId,
 419                                                       @PathParam("componentInstanceId") final String componentInstanceId,
 420                                                       @PathParam("groupInstanceId") final String groupInstanceId,
 421                                                       @Parameter(description = "Group instance object to be Updated", required = true) String data,
 422                                                       @Context final HttpServletRequest request,
 423                                                       @HeaderParam(value = Constants.USER_ID_HEADER) String userId) throws JsonProcessingException {
 424         String url = request.getMethod() + " " + request.getRequestURI();
 425         log.debug(START_HANDLE_REQUEST_OF, url);
 426         User modifier = new User();
 427         modifier.setUserId(userId);
 428         log.debug(MODIFIER_ID_IS, userId);
 429         Either<List<GroupInstanceProperty>, ResponseFormat> actionResponse = null;
 430         try {
 431             List<GroupInstanceProperty> updatedProperties;
 432             Type listType = new TypeToken<ArrayList<GroupInstanceProperty>>() {
 433             }.getType();
 434             ArrayList<GroupInstanceProperty> newProperties = gson.fromJson(data, listType);
 435             if (newProperties == null) {
 436                 actionResponse = Either.right(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT));
 437             }
 438             if (actionResponse == null) {
 439                 log.debug("Start handle update group instance property values request. Received group instance is {}", groupInstanceId);
 440                 actionResponse = serviceBusinessLogic
 441                     .updateGroupInstancePropertyValues(modifier, serviceId, componentInstanceId, groupInstanceId, newProperties);
 442                 if (actionResponse.isRight()) {
 443                     actionResponse = Either.right(actionResponse.right().value());
 444                 }
 445             }
 446             if (actionResponse.isLeft()) {
 447                 updatedProperties = actionResponse.left().value();
 448                 ObjectMapper mapper = new ObjectMapper();
 449                 String result = mapper.writeValueAsString(updatedProperties);
 450                 return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 451             } else {
 452                 return buildErrorResponse(actionResponse.right().value());
 453             }
 454         } catch (Exception e) {
 455             log.error("Exception occured during update Group Instance property values: {}", e.getMessage(), e);
 456             throw e;
 457         }
 458     }
 459
 460     @GET
 461     @Path("/services/{serviceId}")
 462     @Tags({@Tag(name = "SDCE-2 APIs")})
 463     @Consumes(MediaType.APPLICATION_JSON)
 464     @Produces(MediaType.APPLICATION_JSON)
 465     @Operation(description = "Retrieve Service", method = "GET", summary = "Returns service according to serviceId", responses = {
 466         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 467         @ApiResponse(responseCode = "200", description = "Service found"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 468         @ApiResponse(responseCode = "404", description = "Service not found")})
 469     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 470     public Response getServiceById(@PathParam("serviceId") final String serviceId, @Context final HttpServletRequest request,
 471                                    @HeaderParam(value = Constants.USER_ID_HEADER) String userId) throws IOException {
 472         String url = request.getMethod() + " " + request.getRequestURI();
 473         log.debug(START_HANDLE_REQUEST_OF, url);
 474         // get modifier id
 475         User modifier = new User();
 476         modifier.setUserId(userId);
 477         log.debug(MODIFIER_ID_IS, userId);
 478         try {
 479             String serviceIdLower = serviceId.toLowerCase();
 480             log.debug("get service with id {}", serviceId);
 481             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.getService(serviceIdLower, modifier);
 482             if (actionResponse.isRight()) {
 483                 log.debug("failed to get service");
 484                 return buildErrorResponse(actionResponse.right().value());
 485             }
 486             Service service = actionResponse.left().value();
 487             Object result = RepresentationUtils.toRepresentation(service);
 488             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 489         } catch (Exception e) {
 490             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service");
 491             log.debug("get service failed with exception", e);
 492             throw e;
 493         }
 494     }
 495
 496     @GET
 497     @Path("/services/serviceName/{serviceName}/serviceVersion/{serviceVersion}")
 498     @Tags({@Tag(name = "SDCE-2 APIs")})
 499     @Consumes(MediaType.APPLICATION_JSON)
 500     @Produces(MediaType.APPLICATION_JSON)
 501     @Operation(description = "Retrieve Service", method = "GET", summary = "Returns service according to name and version", responses = {
 502         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
 503         @ApiResponse(responseCode = "200", description = "Service found"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 504         @ApiResponse(responseCode = "404", description = "Service not found")})
 505     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 506     public Response getServiceByNameAndVersion(@PathParam("serviceName") final String serviceName,
 507                                                @PathParam("serviceVersion") final String serviceVersion, @Context final HttpServletRequest request,
 508                                                @HeaderParam(value = Constants.USER_ID_HEADER) String userId) throws IOException {
 509         // get modifier id
 510         User modifier = new User();
 511         modifier.setUserId(userId);
 512         log.debug(MODIFIER_ID_IS, userId);
 513         try {
 514             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.getServiceByNameAndVersion(serviceName, serviceVersion, userId);
 515             if (actionResponse.isRight()) {
 516                 return buildErrorResponse(actionResponse.right().value());
 517             }
 518             Service service = actionResponse.left().value();
 519             Object result = RepresentationUtils.toRepresentation(service);
 520             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 521         } catch (Exception e) {
 522             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service by name and version");
 523             log.debug("get service failed with exception", e);
 524             throw e;
 525         }
 526     }
 527
 528     @POST
 529     @Path("/services/{serviceId}/distribution/{env}/activate")
 530     @Tags({@Tag(name = "SDCE-5 APIs")})
 531     @Consumes(MediaType.APPLICATION_JSON)
 532     @Produces(MediaType.APPLICATION_JSON)
 533     @Operation(description = "Activate distribution", method = "POST", summary = "activate distribution", responses = {
 534         @ApiResponse(responseCode = "200", description = "OK"),
 535         @ApiResponse(responseCode = "409", description = "Service cannot be distributed due to missing deployment artifacts"),
 536         @ApiResponse(responseCode = "404", description = "Requested service was not found"),
 537         @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})
 538     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 539     public Response activateDistribution(@PathParam("serviceId") final String serviceId, @PathParam("env") final String env,
 540                                          @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId)
 541         throws IOException {
 542         String url = request.getMethod() + " " + request.getRequestURI();
 543         log.debug(START_HANDLE_REQUEST_OF, url);
 544         User modifier = new User();
 545         modifier.setUserId(userId);
 546         log.debug(MODIFIER_ID_IS, userId);
 547         Either<Service, ResponseFormat> distResponse = serviceBusinessLogic.activateDistribution(serviceId, env, modifier, request);
 548         if (distResponse.isRight()) {
 549             log.debug("failed to activate service distribution");
 550             return buildErrorResponse(distResponse.right().value());
 551         }
 552         Service service = distResponse.left().value();
 553         Object result = null;
 554         try {
 555             result = RepresentationUtils.toRepresentation(service);
 556         } catch (IOException e) {
 557             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Activate Distribution");
 558             log.debug("activate distribution failed with exception", e);
 559             throw e;
 560         }
 561         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 562     }
 563
 564     @POST
 565     @Path("/services/{serviceId}/distribution/{did}/markDeployed")
 566     @Tags({@Tag(name = "SDCE-5 APIs")})
 567     @Consumes(MediaType.APPLICATION_JSON)
 568     @Produces(MediaType.APPLICATION_JSON)
 569     @Operation(description = "Mark distribution as deployed", method = "POST", summary = "relevant audit record will be created", responses = {
 570         @ApiResponse(responseCode = "200", description = "Service was marked as deployed"),
 571         @ApiResponse(responseCode = "409", description = "Restricted operation"),
 572         @ApiResponse(responseCode = "403", description = "Service is not available"),
 573         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 574         @ApiResponse(responseCode = "404", description = "Requested service was not found"),
 575         @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})
 576     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 577     public Response markDistributionAsDeployed(@PathParam("serviceId") final String serviceId, @PathParam("did") final String did,
 578                                                @Context final HttpServletRequest request,
 579                                                @HeaderParam(value = Constants.USER_ID_HEADER) String userId) throws IOException {
 580         String url = request.getMethod() + " " + request.getRequestURI();
 581         log.debug(START_HANDLE_REQUEST_OF, url);
 582         User modifier = new User();
 583         modifier.setUserId(userId);
 584         log.debug(MODIFIER_ID_IS, userId);
 585         try {
 586             Either<Service, ResponseFormat> distResponse = serviceBusinessLogic.markDistributionAsDeployed(serviceId, did, modifier);
 587             if (distResponse.isRight()) {
 588                 log.debug("failed to mark distribution as deployed");
 589                 return buildErrorResponse(distResponse.right().value());
 590             }
 591             Service service = distResponse.left().value();
 592             Object result = RepresentationUtils.toRepresentation(service);
 593             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 594         } catch (Exception e) {
 595             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Mark Distribution As Deployed");
 596             log.debug("mark distribution as deployed failed with exception", e);
 597             throw e;
 598         }
 599     }
 600
 601     @POST
 602     @Path("/services/{serviceId}/tempUrlToBeDeleted")
 603     @Tags({@Tag(name = "SDCE-2 APIs")})
 604     @Consumes(MediaType.APPLICATION_JSON)
 605     @Produces(MediaType.APPLICATION_JSON)
 606     @Operation(responses = {@ApiResponse(responseCode = "200", description = "OK"),
 607         @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})
 608     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 609     public Response tempUrlToBeDeleted(@PathParam("serviceId") final String serviceId, @Context final HttpServletRequest request,
 610                                        @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 611         ServletContext context = request.getSession().getServletContext();
 612         String url = request.getMethod() + " " + request.getRequestURI();
 613         log.debug(START_HANDLE_REQUEST_OF, url);
 614         User modifier = new User();
 615         modifier.setUserId(userId);
 616         log.debug(MODIFIER_ID_IS, userId);
 617         try {
 618             Service service = (serviceBusinessLogic.getService(serviceId, modifier)).left().value();
 619             Either<Service, ResponseFormat> res = serviceBusinessLogic
 620                 .updateDistributionStatusForActivation(service, modifier, DistributionStatusEnum.DISTRIBUTED);
 621             if (res.isRight()) {
 622                 buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 623             }
 624             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), null);
 625         } catch (Exception e) {
 626             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("tempUrlToBeDeleted");
 627             log.debug("failed with exception", e);
 628             throw e;
 629         }
 630     }
 631
 632     @GET
 633     @Path("/services/{serviceId}/linksMap")
 634     @Tags({@Tag(name = "SDCE-2 APIs")})
 635     @Consumes(MediaType.APPLICATION_JSON)
 636     @Produces(MediaType.APPLICATION_JSON)
 637     @Operation(description = "Retrieve Service component relations map", method = "GET", summary = "Returns service components relations", responses = {
 638         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = ServiceRelations.class)))),
 639         @ApiResponse(responseCode = "200", description = "Service found"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 640         @ApiResponse(responseCode = "404", description = "Service not found")})
 641     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 642     public Response getServiceComponentRelationMap(@PathParam("serviceId") final String serviceId, @Context final HttpServletRequest request,
 643                                                    @HeaderParam(value = Constants.USER_ID_HEADER) String userId) throws IOException {
 644         String url = request.getMethod() + " " + request.getRequestURI();
 645         log.debug(START_HANDLE_REQUEST_OF, url);
 646         // get modifier id
 647         User modifier = new User();
 648         modifier.setUserId(userId);
 649         log.debug(MODIFIER_ID_IS, userId);
 650         try {
 651             String serviceIdLower = serviceId.toLowerCase();
 652             log.debug("get service components relations with id {}", serviceId);
 653             Either<ServiceRelations, ResponseFormat> actionResponse = serviceBusinessLogic.getServiceComponentsRelations(serviceIdLower, modifier);
 654             if (actionResponse.isRight()) {
 655                 log.debug("failed to get service relations data");
 656                 return buildErrorResponse(actionResponse.right().value());
 657             }
 658             ServiceRelations serviceRelations = actionResponse.left().value();
 659             Object result = RepresentationUtils.toRepresentation(serviceRelations);
 660             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 661         } catch (Exception e) {
 662             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service");
 663             log.debug("get service relations data failed with exception", e);
 664             throw e;
 665         }
 666     }
 667
 668     @POST
 669     @Path("/services/importService")
 670     @Tags({@Tag(name = "SDCE-2 APIs")})
 671     @Consumes(MediaType.APPLICATION_JSON)
 672     @Produces(MediaType.APPLICATION_JSON)
 673     @Operation(description = "Import Service", method = "POST", summary = "Returns imported service", responses = {
 674         @ApiResponse(responseCode = "201", description = "Service created"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 675         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 676         @ApiResponse(responseCode = "409", description = "Service already exist")})
 677     public Response importNsService(@Parameter(description = "Service object to be imported", required = true) String data,
 678                                     @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 679         userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
 680         initSpringFromContext();
 681         String url = request.getMethod() + " " + request.getRequestURI();
 682         log.debug("Start handle request of {}", url);
 683         // get modifier id
 684         User modifier = new User();
 685         modifier.setUserId(userId);
 686         log.debug("modifier id is {}", userId);
 687         Response response;
 688         try {
 689             Wrapper<Response> responseWrapper = new Wrapper<>();
 690             performUIImport(responseWrapper, data, request, userId, null);
 691             return responseWrapper.getInnerElement();
 692         } catch (IOException | ZipException e) {
 693             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Import Service");
 694             log.debug("import service failed with exception", e);
 695             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 696             return response;
 697         }
 698     }
 699
 700     private void performUIImport(Wrapper<Response> responseWrapper, String data, final HttpServletRequest request, String userId,
 701                                  String ServiceUniqueId) throws FileNotFoundException, ZipException {
 702         Wrapper<User> userWrapper = new Wrapper<>();
 703         Wrapper<UploadServiceInfo> uploadServiceInfoWrapper = new Wrapper<>();
 704         Wrapper<String> yamlStringWrapper = new Wrapper<>();
 705         ServiceAuthorityTypeEnum ServiceAuthorityEnum = ServiceAuthorityTypeEnum.USER_TYPE_UI;
 706         commonServiceGeneralValidations(responseWrapper, userWrapper, uploadServiceInfoWrapper, ServiceAuthorityEnum, userId, data);
 707         specificServiceAuthorityValidations(responseWrapper, uploadServiceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), request,
 708             data, ServiceAuthorityEnum);
 709         if (responseWrapper.isEmpty()) {
 710             handleImportService(responseWrapper, userWrapper.getInnerElement(), uploadServiceInfoWrapper.getInnerElement(),
 711                 yamlStringWrapper.getInnerElement(), ServiceAuthorityEnum, true, ServiceUniqueId);
 712         }
 713     }
 714
 715     /**
 716      * import ReplaceService
 717      *
 718      * @param userId
 719      * @param requestId
 720      * @param instanceIdHeader
 721      * @param accept
 722      * @param authorization
 723      * @param request
 724      * @param file
 725      * @param contentDispositionHeader
 726      * @param serviceInfoJsonString
 727      * @param uuid
 728      * @return
 729      */
 730     @POST
 731     @Path("/services/serviceUUID/{uuid}/importReplaceService")
 732     @Tags({@Tag(name = "SDCE-2 APIs")})
 733     @Produces(MediaType.APPLICATION_JSON)
 734     @Operation(description = "Import Service", method = "POST", summary = "Returns imported service", responses = {
 735         @ApiResponse(responseCode = "201", description = "Service created"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
 736         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 737         @ApiResponse(responseCode = "409", description = "Service already exist")})
 738     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 739     public Response importReplaceService(
 740         @Parameter(description = "The user id", required = true) @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
 741         @Parameter(description = "X-ECOMP-RequestID header", required = false) @HeaderParam(value = Constants.X_ECOMP_REQUEST_ID_HEADER) String requestId,
 742         @Parameter(description = "X-ECOMP-InstanceID header", required = true) @HeaderParam(value = Constants.X_ECOMP_INSTANCE_ID_HEADER) final String instanceIdHeader,
 743         @Parameter(description = "Determines the format of the body of the response", required = false) @HeaderParam(value = Constants.ACCEPT_HEADER) String accept,
 744         @Parameter(description = "The username and password", required = true) @HeaderParam(value = Constants.AUTHORIZATION_HEADER) String authorization,
 745         @Context final HttpServletRequest request, @Parameter(description = "FileInputStream") @FormDataParam("serviceZip") File file,
 746         @Parameter(description = "ContentDisposition") @FormDataParam("serviceZip") FormDataContentDisposition contentDispositionHeader,
 747         @Parameter(description = "serviceMetadata") @FormDataParam("serviceZipMetadata") String serviceInfoJsonString,
 748         @Parameter(description = "The requested asset uuid", required = true) @PathParam("uuid") final String uuid) {
 749         initSpringFromContext();
 750         String requestURI = request.getRequestURI();
 751         String url = request.getMethod() + " " + requestURI;
 752         log.debug("importReplaceService,Start handle request of {}", url);
 753         // get modifier id
 754         User modifier = new User();
 755         modifier.setUserId(userId);
 756         log.debug("importReplaceService,modifier id is {}", userId);
 757         log.debug("importReplaceService,get file:{},fileName:{}", file, file.getName());
 758         Response response;
 759         ResponseFormat responseFormat = null;
 760         AuditingActionEnum auditingActionEnum = AuditingActionEnum.Import_Replace_Service;
 761         String assetType = "services";
 762         Either<List<? extends Component>, ResponseFormat> assetTypeData = elementBusinessLogic
 763             .getCatalogComponentsByUuidAndAssetType(assetType, uuid);
 764         if (assetTypeData.isRight() || assetTypeData.left().value().size() != 1) {
 765             log.debug("getServiceAbstractStatus: Service Fetching Failed");
 766             throw new ByResponseFormatComponentException(assetTypeData.right().value());
 767         }
 768         log.debug("getServiceAbstractStatus: Service Fetching Success");
 769         Service oldService = (Service) assetTypeData.left().value().get(0);
 770         ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 771         ResourceCommonInfo resourceCommonInfo = new ResourceCommonInfo(componentType.getValue());
 772         DistributionData distributionData = new DistributionData(instanceIdHeader, requestURI);
 773         // Mandatory
 774         if (instanceIdHeader == null || instanceIdHeader.isEmpty()) {
 775             log.debug("importReplaceService: Missing X-ECOMP-InstanceID header");
 776             responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 777             getComponentsUtils().auditExternalGetAsset(responseFormat, auditingActionEnum, distributionData, resourceCommonInfo, requestId, null);
 778             return buildErrorResponse(responseFormat);
 779         }
 780         try {
 781             Wrapper<Response> responseWrapper = new Wrapper<>();
 782             // file import
 783             Wrapper<User> userWrapper = new Wrapper<>();
 784             Wrapper<UploadServiceInfo> uploadServiceInfoWrapper = new Wrapper<>();
 785             Wrapper<String> yamlStringWrapper = new Wrapper<>();
 786             ServiceUploadServlet.ServiceAuthorityTypeEnum serviceAuthorityEnum = ServiceUploadServlet.ServiceAuthorityTypeEnum.CSAR_TYPE_BE;
 787             // PayLoad Validations
 788             commonServiceGeneralValidations(responseWrapper, userWrapper, uploadServiceInfoWrapper, serviceAuthorityEnum, userId,
 789                 serviceInfoJsonString);
 790             fillServicePayload(responseWrapper, uploadServiceInfoWrapper, yamlStringWrapper, modifier, serviceInfoJsonString, serviceAuthorityEnum,
 791                 file);
 792             specificServiceAuthorityValidations(responseWrapper, uploadServiceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), request,
 793                 serviceInfoJsonString, serviceAuthorityEnum);
 794             log.debug("importReplaceService:get payload:{}", uploadServiceInfoWrapper.getInnerElement().getPayloadData());
 795             ServiceMetadataDataDefinition serviceMetadataDataDefinition = (ServiceMetadataDataDefinition) oldService.getComponentMetadataDefinition()
 796                 .getMetadataDataDefinition();
 797             uploadServiceInfoWrapper.getInnerElement().setServiceVendorModelNumber(serviceMetadataDataDefinition.getServiceVendorModelNumber());
 798             uploadServiceInfoWrapper.getInnerElement().setDescription(oldService.getDescription());
 799             uploadServiceInfoWrapper.getInnerElement().setCategories(oldService.getCategories());
 800             uploadServiceInfoWrapper.getInnerElement().setIcon(oldService.getIcon());
 801             uploadServiceInfoWrapper.getInnerElement().setProjectCode(oldService.getProjectCode());
 802             if (responseWrapper.isEmpty()) {
 803                 log.debug("importReplaceService:start handleImportService");
 804                 handleImportService(responseWrapper, userWrapper.getInnerElement(), uploadServiceInfoWrapper.getInnerElement(),
 805                     yamlStringWrapper.getInnerElement(), serviceAuthorityEnum, true, null);
 806             }
 807             return responseWrapper.getInnerElement();
 808         } catch (IOException | ZipException e) {
 809             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Import Service");
 810             log.debug("import service failed with exception", e);
 811             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 812             return response;
 813         }
 814     }
 815 }