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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.servlets;
  22
  23 import com.jcabi.aspects.Loggable;
  24 import fj.data.Either;
  25 import io.swagger.annotations.*;
  26 import javax.inject.Inject;
  27 import org.apache.http.HttpStatus;
  28 import org.json.JSONException;
  29 import org.json.JSONObject;
  30 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  31 import org.openecomp.sdc.be.components.impl.CsarValidationUtils;
  32 import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
  33 import org.openecomp.sdc.be.components.impl.ImportUtils;
  34 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  35 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  36 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  37 import org.openecomp.sdc.be.dao.api.ActionStatus;
  38 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  41 import org.openecomp.sdc.be.impl.ComponentsUtils;
  42 import org.openecomp.sdc.be.impl.ServletUtils;
  43 import org.openecomp.sdc.be.model.Resource;
  44 import org.openecomp.sdc.be.model.UploadResourceInfo;
  45 import org.openecomp.sdc.be.model.User;
  46 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  47 import org.openecomp.sdc.be.servlets.ResourceUploadServlet.ResourceAuthorityTypeEnum;
  48 import org.openecomp.sdc.be.user.UserBusinessLogic;
  49 import org.openecomp.sdc.common.api.Constants;
  50 import org.openecomp.sdc.common.datastructure.Wrapper;
  51 import org.openecomp.sdc.common.log.wrappers.Logger;
  52 import org.openecomp.sdc.exception.ResponseFormat;
  53
  54 import javax.inject.Singleton;
  55 import javax.servlet.ServletContext;
  56 import javax.servlet.http.HttpServletRequest;
  57 import javax.ws.rs.*;
  58 import javax.ws.rs.core.Context;
  59 import javax.ws.rs.core.MediaType;
  60 import javax.ws.rs.core.Response;
  61 import java.io.FileNotFoundException;
  62 import java.io.IOException;
  63 import java.util.List;
  64 import java.util.Map;
  65
  66 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  67 @Path("/v1/catalog")
  68 @Api(value = "Resources Catalog", description = "Resources Servlet")
  69 @Singleton
  70 public class ResourcesServlet extends AbstractValidationsServlet {
  71
  72     private static final Logger log = Logger.getLogger(ResourcesServlet.class);
  73     private final ResourceBusinessLogic resourceBusinessLogic;
  74
  75     @Inject
  76     public ResourcesServlet(UserBusinessLogic userBusinessLogic,
  77         ComponentInstanceBusinessLogic componentInstanceBL,
  78         ResourceBusinessLogic resourceBusinessLogic,
  79         ComponentsUtils componentsUtils, ServletUtils servletUtils,
  80         ResourceImportManager resourceImportManager) {
  81         super(userBusinessLogic, componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);
  82         this.resourceBusinessLogic = resourceBusinessLogic;
  83     }
  84
  85     @POST
  86     @Path("/resources")
  87     @Consumes(MediaType.APPLICATION_JSON)
  88     @Produces(MediaType.APPLICATION_JSON)
  89     @ApiOperation(value = "Create Resource", httpMethod = "POST", notes = "Returns created resource", response = Resource.class)
  90     @ApiResponses(value = { @ApiResponse(code = 201, message = "Resource created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  91             @ApiResponse(code = 409, message = "Resource already exist") })
  92     public Response createResource(@ApiParam(value = "Resource object to be created", required = true) String data, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
  93
  94         userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
  95         init();
  96
  97         String url = request.getMethod() + " " + request.getRequestURI();
  98         log.debug("Start handle request of {}" , url);
  99
 100         // get modifier id
 101         User modifier = new User();
 102         modifier.setUserId(userId);
 103         log.debug("modifier id is {}", userId);
 104
 105         Response response;
 106         try {
 107
 108             Wrapper<Response> responseWrapper = new Wrapper<>();
 109             // UI Import
 110             if (isUIImport(data)) {
 111                 performUIImport(responseWrapper, data, request, userId, null);
 112             }
 113             // UI Create
 114             else {
 115
 116                 Either<Resource, ResponseFormat> convertResponse = parseToResource(data, modifier);
 117                 if (convertResponse.isRight()) {
 118                     log.debug("failed to parse resource");
 119                     response = buildErrorResponse(convertResponse.right().value());
 120                     return response;
 121                 }
 122
 123                 Resource resource = convertResponse.left().value();
 124                 Resource createdResource = resourceBusinessLogic.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, modifier, null, null);
 125                 Object representation = RepresentationUtils.toRepresentation(createdResource);
 126                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), representation);
 127                 responseWrapper.setInnerElement(response);
 128             }
 129             return responseWrapper.getInnerElement();
 130         } catch (IOException e) {
 131             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create Resource");
 132             log.debug("create resource failed with exception", e);
 133             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 134             return response;
 135         }
 136     }
 137
 138     private boolean isUIImport(String data) {
 139         boolean isUIImport;
 140         try {
 141             JSONObject json = new JSONObject(data);
 142             String payloadName = json.getString(ImportUtils.Constants.UI_JSON_PAYLOAD_NAME);
 143             isUIImport = payloadName != null && !payloadName.isEmpty();
 144         } catch (JSONException e) {
 145             log.debug("failed to parse json sent from client, json:{}", data, e);
 146             isUIImport = false;
 147         }
 148         return isUIImport;
 149     }
 150
 151     private void performUIImport(Wrapper<Response> responseWrapper, String data, final HttpServletRequest request, String userId, String resourceUniqueId) throws FileNotFoundException {
 152
 153         Wrapper<User> userWrapper = new Wrapper<>();
 154         Wrapper<UploadResourceInfo> uploadResourceInfoWrapper = new Wrapper<>();
 155         Wrapper<String> yamlStringWrapper = new Wrapper<>();
 156
 157         ResourceAuthorityTypeEnum resourceAuthorityEnum = ResourceAuthorityTypeEnum.USER_TYPE_UI;
 158
 159         commonGeneralValidations(responseWrapper, userWrapper, uploadResourceInfoWrapper, resourceAuthorityEnum, userId, data);
 160
 161         if (!CsarValidationUtils.isCsarPayloadName(uploadResourceInfoWrapper.getInnerElement().getPayloadName())) {
 162             fillPayload(responseWrapper, uploadResourceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), data, resourceAuthorityEnum, null);
 163
 164             // PayLoad Validations
 165             commonPayloadValidations(responseWrapper, yamlStringWrapper, userWrapper.getInnerElement(), uploadResourceInfoWrapper.getInnerElement());
 166         }
 167         specificResourceAuthorityValidations(responseWrapper, uploadResourceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), request, data, resourceAuthorityEnum);
 168
 169         if (responseWrapper.isEmpty()) {
 170             handleImport(responseWrapper, userWrapper.getInnerElement(), uploadResourceInfoWrapper.getInnerElement(), yamlStringWrapper.getInnerElement(), resourceAuthorityEnum, true, resourceUniqueId);
 171         }
 172     }
 173
 174     private Either<Resource, ResponseFormat> parseToResource(String resourceJson, User user) {
 175         return getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, Resource.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.RESOURCE);
 176     }
 177
 178     private Either<Resource, ResponseFormat> parseToLightResource(String resourceJson, User user) {
 179         Either<Resource, ResponseFormat> ret = getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, Resource.class, AuditingActionEnum.UPDATE_RESOURCE_METADATA, ComponentTypeEnum.RESOURCE);
 180         if (ret.isLeft()) {// drop unwanted data (sent from UI in update flow)
 181             ret.left().value().setRequirements(null);
 182             ret.left().value().setCapabilities(null);
 183         }
 184         return ret;
 185     }
 186
 187     @DELETE
 188     @Path("/resources/{resourceId}")
 189     public Response deleteResource(@PathParam("resourceId") final String resourceId, @Context final HttpServletRequest request) {
 190
 191         ServletContext context = request.getSession().getServletContext();
 192
 193         String url = request.getMethod() + " " + request.getRequestURI();
 194         log.debug("Start handle request of {}" , url);
 195
 196         // get modifier id
 197         String userId = request.getHeader(Constants.USER_ID_HEADER);
 198         User modifier = new User();
 199         modifier.setUserId(userId);
 200         log.debug("modifier id is {}" , userId);
 201
 202         Response response;
 203
 204         try {
 205             String resourceIdLower = resourceId.toLowerCase();
 206             ResponseFormat actionResponse = resourceBusinessLogic.deleteResource(resourceIdLower, modifier);
 207
 208             if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 209                 log.debug("failed to delete resource");
 210                 response = buildErrorResponse(actionResponse);
 211                 return response;
 212             }
 213             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 214             return response;
 215
 216         } catch (JSONException e) {
 217             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Resource");
 218             log.debug("delete resource failed with exception", e);
 219             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 220             return response;
 221
 222         }
 223     }
 224
 225     @DELETE
 226     @Path("/resources/{resourceName}/{version}")
 227     public Response deleteResourceByNameAndVersion(@PathParam("resourceName") final String resourceName, @PathParam("version") final String version, @Context final HttpServletRequest request) {
 228
 229         ServletContext context = request.getSession().getServletContext();
 230
 231         String url = request.getMethod() + " " + request.getRequestURI();
 232         log.debug("Start handle request of {}" , url);
 233
 234         // get modifier id
 235         String userId = request.getHeader(Constants.USER_ID_HEADER);
 236         User modifier = new User();
 237         modifier.setUserId(userId);
 238         log.debug("modifier id is {}" , userId);
 239
 240         Response response;
 241         ResponseFormat actionResponse = resourceBusinessLogic.deleteResourceByNameAndVersion(resourceName, version, modifier);
 242
 243         if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 244             log.debug("failed to delete resource");
 245             response = buildErrorResponse(actionResponse);
 246             return response;
 247         }
 248         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 249         return response;
 250     }
 251
 252     @GET
 253     @Path("/resources/{resourceId}")
 254     @Consumes(MediaType.APPLICATION_JSON)
 255     @Produces(MediaType.APPLICATION_JSON)
 256     @ApiOperation(value = "Retrieve Resource", httpMethod = "GET", notes = "Returns resource according to resourceId", response = Resource.class)
 257     @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 404, message = "Resource not found") })
 258     public Response getResourceById(@PathParam("resourceId") final String resourceId, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 259
 260         ServletContext context = request.getSession().getServletContext();
 261
 262         String url = request.getMethod() + " " + request.getRequestURI();
 263         log.debug("Start handle request of {}" , url);
 264
 265         // get modifier id
 266         User modifier = new User();
 267         modifier.setUserId(userId);
 268         log.debug("modifier id is {}" , userId);
 269
 270         Response response;
 271
 272         try {
 273             String resourceIdLower = resourceId.toLowerCase();
 274             log.trace("get resource with id {}", resourceId);
 275             Either<Resource, ResponseFormat> actionResponse = resourceBusinessLogic.getResource(resourceIdLower, modifier);
 276
 277             if (actionResponse.isRight()) {
 278                 log.debug("failed to get resource");
 279                 response = buildErrorResponse(actionResponse.right().value());
 280                 return response;
 281             }
 282             Object resource = RepresentationUtils.toRepresentation(actionResponse.left().value());
 283             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 284
 285         } catch (IOException e) {
 286             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Resource");
 287             log.debug("get resource failed with exception", e);
 288             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 289
 290         }
 291     }
 292
 293     @GET
 294     @Path("/resources/resourceName/{resourceName}/resourceVersion/{resourceVersion}")
 295     @Consumes(MediaType.APPLICATION_JSON)
 296     @Produces(MediaType.APPLICATION_JSON)
 297     @ApiOperation(value = "Retrieve Resource by name and version", httpMethod = "GET", notes = "Returns resource according to resourceId", response = Resource.class)
 298     @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 404, message = "Resource not found") })
 299     public Response getResourceByNameAndVersion(@PathParam("resourceName") final String resourceName, @PathParam("resourceVersion") final String resourceVersion, @Context final HttpServletRequest request,
 300             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 301
 302         ServletContext context = request.getSession().getServletContext();
 303         // get modifier id
 304         User modifier = new User();
 305         modifier.setUserId(userId);
 306         log.debug("modifier id is {}" , userId);
 307         Response response;
 308         try {
 309             Either<Resource, ResponseFormat> actionResponse = resourceBusinessLogic.getResourceByNameAndVersion(resourceName, resourceVersion, userId);
 310             if (actionResponse.isRight()) {
 311                 response = buildErrorResponse(actionResponse.right().value());
 312                 return response;
 313             }
 314             Object resource = RepresentationUtils.toRepresentation(actionResponse.left().value());
 315             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 316
 317         } catch (IOException e) {
 318             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Resource by name and version");
 319             log.debug("get resource failed with exception", e);
 320             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 321
 322         }
 323     }
 324
 325     @GET
 326     @Path("/resources/validate-name/{resourceName}")
 327     @Consumes(MediaType.APPLICATION_JSON)
 328     @Produces(MediaType.APPLICATION_JSON)
 329     @ApiOperation(value = "validate resource name", httpMethod = "GET", notes = "checks if the chosen resource name is available ", response = Response.class)
 330     @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation") })
 331     public Response validateResourceName(@PathParam("resourceName") final String resourceName, @QueryParam("subtype") String resourceType, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 332         ServletContext context = request.getSession().getServletContext();
 333         String url = request.getMethod() + " " + request.getRequestURI();
 334         log.debug("Start handle request of {}" , url);
 335
 336         // get modifier id
 337         User modifier = new User();
 338         modifier.setUserId(userId);
 339         log.debug("modifier id is {}" , userId);
 340         Response response;
 341
 342         if (resourceType != null && !ResourceTypeEnum.containsName(resourceType)) {
 343             log.debug("invalid resource type received");
 344             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT));
 345             return response;
 346
 347         }
 348         ResourceTypeEnum typeEnum = null;
 349         if (resourceType != null) {
 350             typeEnum = ResourceTypeEnum.valueOf(resourceType);
 351         }
 352         Either<Map<String, Boolean>, ResponseFormat> actionResponse = resourceBusinessLogic.validateResourceNameExists(resourceName, typeEnum, userId);
 353
 354         if (actionResponse.isRight()) {
 355             log.debug("failed to validate resource name");
 356             response = buildErrorResponse(actionResponse.right().value());
 357             return response;
 358         }
 359         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), actionResponse.left().value());
 360     }
 361
 362     @GET
 363     @Path("/resources/certified/abstract")
 364     @Consumes(MediaType.APPLICATION_JSON)
 365     @Produces(MediaType.APPLICATION_JSON)
 366     public Response getCertifiedAbstractResources(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 367         String url = request.getMethod() + " " + request.getRequestURI();
 368         log.debug("(get) Start handle request of {}" , url);
 369         try {
 370             List<Resource> resources = resourceBusinessLogic
 371                     .getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, userId);
 372             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), RepresentationUtils.toRepresentation(resources));
 373
 374         } catch (IOException e) {
 375             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Certified Abstract Resources");
 376             log.debug("getCertifiedAbstractResources failed with exception", e);
 377             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 378         }
 379     }
 380
 381     @GET
 382     @Path("/resources/certified/notabstract")
 383     @Consumes(MediaType.APPLICATION_JSON)
 384     @Produces(MediaType.APPLICATION_JSON)
 385     public Response getCertifiedNotAbstractResources(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 386         String url = request.getMethod() + " " + request.getRequestURI();
 387         log.debug("(get) Start handle request of {}" , url);
 388         try {
 389             List<Resource> resouces = resourceBusinessLogic.getAllCertifiedResources(false, HighestFilterEnum.ALL, userId);
 390             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), RepresentationUtils.toRepresentation(resouces));
 391
 392         } catch (IOException e) {
 393             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Certified Non Abstract Resources");
 394             log.debug("getCertifiedNotAbstractResources failed with exception", e);
 395             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 396         }
 397
 398     }
 399
 400     @PUT
 401     @Path("/resources/{resourceId}/metadata")
 402     @Consumes(MediaType.APPLICATION_JSON)
 403     @Produces(MediaType.APPLICATION_JSON)
 404     @ApiOperation(value = "Update Resource Metadata", httpMethod = "PUT", notes = "Returns updated resource metadata", response = Resource.class)
 405     @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource metadata updated"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content") })
 406     public Response updateResourceMetadata(@PathParam("resourceId") final String resourceId, @ApiParam(value = "Resource metadata to be updated", required = true) String data, @Context final HttpServletRequest request,
 407             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 408
 409         String url = request.getMethod() + " " + request.getRequestURI();
 410         log.debug("Start handle request of {}" , url);
 411
 412         // get modifier id
 413         User modifier = new User();
 414         modifier.setUserId(userId);
 415         log.debug("modifier id is {}", userId);
 416         Response response;
 417         try {
 418             String resourceIdLower = resourceId.toLowerCase();
 419             Either<Resource, ResponseFormat> updateInfoResource = getComponentsUtils().convertJsonToObjectUsingObjectMapper(data, modifier, Resource.class, AuditingActionEnum.UPDATE_RESOURCE_METADATA, ComponentTypeEnum.RESOURCE);
 420             if (updateInfoResource.isRight()) {
 421                 log.debug("failed to parse resource metadata");
 422                 response = buildErrorResponse(updateInfoResource.right().value());
 423                 return response;
 424             }
 425             Resource updatedResource = resourceBusinessLogic.updateResourceMetadata(resourceIdLower, updateInfoResource.left().value(), null, modifier, false);
 426             Object resource = RepresentationUtils.toRepresentation(updatedResource);
 427             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 428         } catch (IOException e) {
 429             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Resource Metadata");
 430             log.debug("Update Resource Metadata failed with exception", e);
 431             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 432             return response;
 433
 434         }
 435     }
 436
 437     @PUT
 438     @Path("/resources/{resourceId}")
 439     @Consumes(MediaType.APPLICATION_JSON)
 440     @Produces(MediaType.APPLICATION_JSON)
 441     @ApiOperation(value = "Update Resource", httpMethod = "PUT", notes = "Returns updated resource", response = Resource.class)
 442     @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource updated"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 443             @ApiResponse(code = 409, message = "Resource already exist") })
 444     public Response updateResource(@ApiParam(value = "Resource object to be updated", required = true) String data, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
 445             @PathParam(value = "resourceId") String resourceId) {
 446
 447         userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
 448         init();
 449         String url = request.getMethod() + " " + request.getRequestURI();
 450         log.debug("Start handle request of {}" , url);
 451         // get modifier id
 452         User modifier = new User();
 453         modifier.setUserId(userId);
 454         log.debug("modifier id is {}", userId);
 455         Response response;
 456         try {
 457             Wrapper<Response> responseWrapper = new Wrapper<>();
 458             // UI Import
 459             if (isUIImport(data)) {
 460                 performUIImport(responseWrapper, data, request, userId, resourceId);
 461             } else {
 462                 Either<Resource, ResponseFormat> convertResponse = parseToLightResource(data, modifier);
 463                 if (convertResponse.isRight()) {
 464                     log.debug("failed to parse resource");
 465                     response = buildErrorResponse(convertResponse.right().value());
 466                     return response;
 467                 }
 468                 Resource updatedResource = resourceBusinessLogic.validateAndUpdateResourceFromCsar(convertResponse.left().value(), modifier, null, null, resourceId);
 469                 Object representation = RepresentationUtils.toRepresentation(updatedResource);
 470                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation);
 471                 responseWrapper.setInnerElement(response);
 472             }
 473             return responseWrapper.getInnerElement();
 474         } catch (IOException e) {
 475             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Resource");
 476             log.debug("update resource failed with exception", e);
 477             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 478             return response;
 479
 480         }
 481     }
 482
 483     @GET
 484     @Path("/resources/csar/{csaruuid}")
 485     @Consumes(MediaType.APPLICATION_JSON)
 486     @Produces(MediaType.APPLICATION_JSON)
 487     @ApiOperation(value = "Create Resource", httpMethod = "POST", notes = "Returns resource created from csar uuid", response = Resource.class)
 488     @ApiResponses(value = { @ApiResponse(code = 201, message = "Resource retrieced"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content") })
 489     public Response getResourceFromCsar(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @PathParam(value = "csaruuid") String csarUUID) {
 490
 491         init();
 492
 493         String url = request.getMethod() + " " + request.getRequestURI();
 494         log.debug("Start handle request of {}" , url);
 495
 496         // retrieve user details
 497         userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
 498         User user = new User();
 499         user.setUserId(userId);
 500
 501         log.debug("user id is {}", userId);
 502
 503         Response response;
 504
 505         try {
 506
 507             Either<Resource, ResponseFormat> eitherResource = resourceBusinessLogic.getLatestResourceFromCsarUuid(csarUUID, user);
 508
 509             // validate response
 510             if (eitherResource.isRight()) {
 511                 log.debug("failed to get resource from csarUuid : {}", csarUUID);
 512                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), eitherResource.right().value());
 513             } else {
 514                 Object representation = RepresentationUtils.toRepresentation(eitherResource.left().value());
 515                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation);
 516             }
 517
 518             return response;
 519
 520         } catch (IOException e) {
 521             log.debug("get resource by csar failed with exception", e);
 522             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 523             return response;
 524         }
 525     }
 526 }