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 java.io.FileNotFoundException;
  24 import java.util.ArrayList;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Map.Entry;
  28
  29 import javax.inject.Singleton;
  30 import javax.servlet.ServletContext;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.ws.rs.Consumes;
  33 import javax.ws.rs.DELETE;
  34 import javax.ws.rs.GET;
  35 import javax.ws.rs.HeaderParam;
  36 import javax.ws.rs.POST;
  37 import javax.ws.rs.PUT;
  38 import javax.ws.rs.Path;
  39 import javax.ws.rs.PathParam;
  40 import javax.ws.rs.Produces;
  41 import javax.ws.rs.QueryParam;
  42 import javax.ws.rs.core.Context;
  43 import javax.ws.rs.core.MediaType;
  44 import javax.ws.rs.core.Response;
  45
  46 import org.apache.http.HttpStatus;
  47 import org.json.JSONObject;
  48 import org.openecomp.sdc.be.components.impl.CsarValidationUtils;
  49 import org.openecomp.sdc.be.components.impl.ImportUtils;
  50 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  51 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  52 import org.openecomp.sdc.be.dao.api.ActionStatus;
  53 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  54 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  57 import org.openecomp.sdc.be.model.PropertyDefinition;
  58 import org.openecomp.sdc.be.model.Resource;
  59 import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
  60 import org.openecomp.sdc.be.model.UploadResourceInfo;
  61 import org.openecomp.sdc.be.model.User;
  62 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  63 import org.openecomp.sdc.be.servlets.ResourceUploadServlet.ResourceAuthorityTypeEnum;
  64 import org.openecomp.sdc.common.api.Constants;
  65 import org.openecomp.sdc.common.config.EcompErrorName;
  66 import org.openecomp.sdc.common.datastructure.Wrapper;
  67 import org.openecomp.sdc.exception.ResponseFormat;
  68 import org.slf4j.Logger;
  69 import org.slf4j.LoggerFactory;
  70
  71 import com.jcabi.aspects.Loggable;
  72 import com.wordnik.swagger.annotations.Api;
  73 import com.wordnik.swagger.annotations.ApiOperation;
  74 import com.wordnik.swagger.annotations.ApiParam;
  75 import com.wordnik.swagger.annotations.ApiResponse;
  76 import com.wordnik.swagger.annotations.ApiResponses;
  77
  78 import fj.data.Either;
  79
  80 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  81 @Path("/v1/catalog")
  82 @Api(value = "Resources Catalog", description = "Resources Servlet")
  83 @Singleton
  84 public class ResourcesServlet extends AbstractValidationsServlet {
  85
  86         private static Logger log = LoggerFactory.getLogger(ResourcesServlet.class.getName());
  87
  88         @POST
  89         @Path("/resources")
  90         @Consumes(MediaType.APPLICATION_JSON)
  91         @Produces(MediaType.APPLICATION_JSON)
  92         @ApiOperation(value = "Create Resource", httpMethod = "POST", notes = "Returns created resource", response = Resource.class)
  93         @ApiResponses(value = { @ApiResponse(code = 201, message = "Resource created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  94                         @ApiResponse(code = 409, message = "Resource already exist") })
  95         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) {
  96
  97                 userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
  98                 init(log);
  99
 100                 ServletContext context = request.getSession().getServletContext();
 101
 102                 String url = request.getMethod() + " " + request.getRequestURI();
 103                 log.debug("Start handle request of {}", url);
 104
 105                 // get modifier id
 106                 User modifier = new User();
 107                 modifier.setUserId(userId);
 108                 log.debug("modifier id is {}", userId);
 109
 110                 Response response = null;
 111                 try {
 112
 113                         Wrapper<Response> responseWrapper = new Wrapper<>();
 114                         // UI Import
 115                         if (isUIImport(data)) {
 116                                 performUIImport(responseWrapper, data, request, userId, null);
 117                         }
 118                         // UI Create
 119                         else {
 120
 121                                 ResourceBusinessLogic businessLogic = getResourceBL(context);
 122
 123                                 Either<Resource, ResponseFormat> convertResponse = parseToResource(data, modifier);
 124                                 if (convertResponse.isRight()) {
 125                                         log.debug("failed to parse resource");
 126                                         response = buildErrorResponse(convertResponse.right().value());
 127                                         return response;
 128                                 }
 129
 130                                 Resource resource = convertResponse.left().value();
 131                                 Either<Resource, ResponseFormat> actionResponse = businessLogic.createResource(resource, modifier, null, null);
 132
 133                                 if (actionResponse.isRight()) {
 134                                         log.debug("failed to create resource");
 135                                         response = buildErrorResponse(actionResponse.right().value());
 136                                 } else {
 137                                         Object representation = RepresentationUtils.toRepresentation(actionResponse.left().value());
 138                                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), representation);
 139                                 }
 140                                 responseWrapper.setInnerElement(response);
 141                         }
 142
 143                         return responseWrapper.getInnerElement();
 144
 145                         // return response;
 146                 } catch (Exception e) {
 147                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Create Resource");
 148                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create Resource");
 149                         log.debug("create resource failed with exception", e);
 150                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 151                         return response;
 152
 153                 }
 154         }
 155
 156         private boolean isUIImport(String data) {
 157                 boolean isUIImport;
 158                 try {
 159                         JSONObject json = new JSONObject(data);
 160                         String payloadName = json.getString(ImportUtils.Constants.UI_JSON_PAYLOAD_NAME);
 161                         isUIImport = payloadName != null && !payloadName.isEmpty();
 162                 } catch (Exception e) {
 163                         log.debug("failed to parse json sent from client, json:{}", data);
 164                         isUIImport = false;
 165                 }
 166                 return isUIImport;
 167         }
 168
 169         private void performUIImport(Wrapper<Response> responseWrapper, String data, final HttpServletRequest request, String userId, String resourceUniqueId) throws FileNotFoundException {
 170
 171                 Wrapper<User> userWrapper = new Wrapper<>();
 172                 Wrapper<UploadResourceInfo> uploadResourceInfoWrapper = new Wrapper<>();
 173                 Wrapper<String> yamlStringWrapper = new Wrapper<>();
 174                 String resourceInfoJsonString = data;
 175
 176                 ResourceAuthorityTypeEnum resourceAuthorityEnum = ResourceAuthorityTypeEnum.USER_TYPE_UI;
 177
 178                 commonGeneralValidations(responseWrapper, userWrapper, uploadResourceInfoWrapper, resourceAuthorityEnum, userId, resourceInfoJsonString);
 179
 180                 // TODO suspect next line is unnecessary
 181                 userWrapper.getInnerElement();
 182                 if (!CsarValidationUtils.isCsarPayloadName(uploadResourceInfoWrapper.getInnerElement().getPayloadName())) {
 183                         fillPayload(responseWrapper, uploadResourceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), resourceInfoJsonString, resourceAuthorityEnum, null);
 184
 185                         // PayLoad Validations
 186                         commonPayloadValidations(responseWrapper, yamlStringWrapper, userWrapper.getInnerElement(), uploadResourceInfoWrapper.getInnerElement());
 187                 }
 188                 specificResourceAuthorityValidations(responseWrapper, uploadResourceInfoWrapper, yamlStringWrapper, userWrapper.getInnerElement(), request, resourceInfoJsonString, resourceAuthorityEnum);
 189
 190                 if (responseWrapper.isEmpty()) {
 191                         handleImport(responseWrapper, userWrapper.getInnerElement(), uploadResourceInfoWrapper.getInnerElement(), yamlStringWrapper.getInnerElement(), resourceAuthorityEnum, true, resourceUniqueId);
 192                 }
 193         }
 194
 195         public Either<Resource, ResponseFormat> parseToResource(String resourceJson, User user) {
 196                 return getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, Resource.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.RESOURCE);
 197         }
 198
 199         public Either<Resource, ResponseFormat> parseToLightResource(String resourceJson, User user) {
 200                 Either<Resource, ResponseFormat> ret = getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, Resource.class, AuditingActionEnum.UPDATE_RESOURCE_METADATA, ComponentTypeEnum.RESOURCE);
 201                 if (ret.isLeft()) {// drop unwanted data (sent from UI in update flow)
 202                         ret.left().value().setRequirements(null);
 203                         ret.left().value().setCapabilities(null);
 204                 }
 205                 return ret;
 206         }
 207
 208         @DELETE
 209         @Path("/resources/{resourceId}")
 210         public Response deleteResource(@PathParam("resourceId") final String resourceId, @Context final HttpServletRequest request) {
 211
 212                 ServletContext context = request.getSession().getServletContext();
 213
 214                 String url = request.getMethod() + " " + request.getRequestURI();
 215                 log.debug("Start handle request of {}", url);
 216
 217                 // get modifier id
 218                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 219                 User modifier = new User();
 220                 modifier.setUserId(userId);
 221                 log.debug("modifier id is {}", userId);
 222
 223                 Response response = null;
 224
 225                 try {
 226                         String resourceIdLower = resourceId.toLowerCase();
 227                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 228                         ResponseFormat actionResponse = businessLogic.deleteResource(resourceIdLower, modifier);
 229
 230                         if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 231                                 log.debug("failed to delete resource");
 232                                 response = buildErrorResponse(actionResponse);
 233                                 return response;
 234                         }
 235                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 236                         return response;
 237
 238                 } catch (Exception e) {
 239                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Delete Resource");
 240                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Resource");
 241                         log.debug("delete resource failed with exception", e);
 242                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 243                         return response;
 244
 245                 }
 246         }
 247
 248         @DELETE
 249         @Path("/resources/{resourceName}/{version}")
 250         public Response deleteResourceByNameAndVersion(@PathParam("resourceName") final String resourceName, @PathParam("version") final String version, @Context final HttpServletRequest request) {
 251
 252                 ServletContext context = request.getSession().getServletContext();
 253
 254                 String url = request.getMethod() + " " + request.getRequestURI();
 255                 log.debug("Start handle request of {}", url);
 256
 257                 // get modifier id
 258                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 259                 User modifier = new User();
 260                 modifier.setUserId(userId);
 261                 log.debug("modifier id is {}", userId);
 262
 263                 Response response = null;
 264
 265                 try {
 266                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 267                         ResponseFormat actionResponse = businessLogic.deleteResourceByNameAndVersion(resourceName, version, modifier);
 268
 269                         if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {
 270                                 log.debug("failed to delete resource");
 271                                 response = buildErrorResponse(actionResponse);
 272                                 return response;
 273                         }
 274                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);
 275                         return response;
 276
 277                 } catch (Exception e) {
 278                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Delete Resource");
 279                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Resource");
 280                         log.debug("delete resource failed with exception", e);
 281                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 282                         return response;
 283
 284                 }
 285         }
 286
 287         @GET
 288         @Path("/resources/{resourceId}")
 289         @Consumes(MediaType.APPLICATION_JSON)
 290         @Produces(MediaType.APPLICATION_JSON)
 291         @ApiOperation(value = "Retrieve Resource", httpMethod = "GET", notes = "Returns resource according to resourceId", response = Resource.class)
 292         @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 404, message = "Resource not found") })
 293         public Response getResourceById(@PathParam("resourceId") final String resourceId, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 294
 295                 ServletContext context = request.getSession().getServletContext();
 296
 297                 String url = request.getMethod() + " " + request.getRequestURI();
 298                 log.debug("Start handle request of {}", url);
 299
 300                 // get modifier id
 301                 User modifier = new User();
 302                 modifier.setUserId(userId);
 303                 log.debug("modifier id is {}", userId);
 304
 305                 Response response = null;
 306
 307                 try {
 308                         String resourceIdLower = resourceId.toLowerCase();
 309                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 310                         log.trace("get resource with id {}", resourceId);
 311                         Either<Resource, ResponseFormat> actionResponse = businessLogic.getResource(resourceIdLower, modifier);
 312
 313                         if (actionResponse.isRight()) {
 314                                 log.debug("failed to get resource");
 315                                 response = buildErrorResponse(actionResponse.right().value());
 316                                 return response;
 317                         }
 318                         Object resource = RepresentationUtils.toRepresentation(actionResponse.left().value());
 319                         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 320
 321                 } catch (Exception e) {
 322                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Get Resource");
 323                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Resource");
 324                         log.debug("get resource failed with exception", e);
 325                         return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 326
 327                 }
 328         }
 329
 330         @GET
 331         @Path("/resources/resourceName/{resourceName}/resourceVersion/{resourceVersion}")
 332         @Consumes(MediaType.APPLICATION_JSON)
 333         @Produces(MediaType.APPLICATION_JSON)
 334         @ApiOperation(value = "Retrieve Resource by name and version", httpMethod = "GET", notes = "Returns resource according to resourceId", response = Resource.class)
 335         @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 404, message = "Resource not found") })
 336         public Response getResourceByNameAndVersion(@PathParam("resourceName") final String resourceName, @PathParam("resourceVersion") final String resourceVersion, @Context final HttpServletRequest request,
 337                         @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 338
 339                 ServletContext context = request.getSession().getServletContext();
 340                 // get modifier id
 341                 User modifier = new User();
 342                 modifier.setUserId(userId);
 343                 log.debug("modifier id is {}", userId);
 344                 Response response = null;
 345                 try {
 346                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 347                         Either<List<Resource>, ResponseFormat> actionResponse = businessLogic.getResourceByNameAndVersion(resourceName, resourceVersion, userId);
 348                         if (actionResponse.isRight()) {
 349                                 response = buildErrorResponse(actionResponse.right().value());
 350                                 return response;
 351                         }
 352                         Object resource = RepresentationUtils.toRepresentation(actionResponse.left().value());
 353                         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 354
 355                 } catch (Exception e) {
 356                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Get Resource by name and version");
 357                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Resource by name and version");
 358                         log.debug("get resource failed with exception", e);
 359                         return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 360
 361                 }
 362         }
 363
 364         @GET
 365         @Path("/resources/validate-name/{resourceName}")
 366         @Consumes(MediaType.APPLICATION_JSON)
 367         @Produces(MediaType.APPLICATION_JSON)
 368         @ApiOperation(value = "validate resource name", httpMethod = "GET", notes = "checks if the chosen resource name is available ", response = Response.class)
 369         @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource found"), @ApiResponse(code = 403, message = "Restricted operation") })
 370         public Response validateResourceName(@PathParam("resourceName") final String resourceName, @QueryParam("subtype") String resourceType, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 371                 ServletContext context = request.getSession().getServletContext();
 372                 String url = request.getMethod() + " " + request.getRequestURI();
 373                 log.debug("Start handle request of {}", url);
 374
 375                 // get modifier id
 376                 User modifier = new User();
 377                 modifier.setUserId(userId);
 378                 log.debug("modifier id is {}", userId);
 379                 Response response = null;
 380                 try {
 381                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 382
 383                         if (resourceType != null && !ResourceTypeEnum.contains(resourceType)) {
 384                                 log.debug("invalid resource type received");
 385                                 response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT));
 386                                 return response;
 387
 388                         }
 389                         ResourceTypeEnum typeEnum = null;
 390                         if (resourceType != null) {
 391                                 typeEnum = ResourceTypeEnum.valueOf(resourceType);
 392                         }
 393                         Either<Map<String, Boolean>, ResponseFormat> actionResponse = businessLogic.validateResourceNameExists(resourceName, typeEnum, userId);
 394
 395                         if (actionResponse.isRight()) {
 396                                 log.debug("failed to validate resource name");
 397                                 response = buildErrorResponse(actionResponse.right().value());
 398                                 return response;
 399                         }
 400                         return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), actionResponse.left().value());
 401                 } catch (Exception e) {
 402                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Validate Resource Name");
 403                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Validate Resource Name");
 404                         log.debug("validate resource name failed with exception", e);
 405                         return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 406                 }
 407         }
 408
 409         @GET
 410         @Path("/resources/certified/abstract")
 411         @Consumes(MediaType.APPLICATION_JSON)
 412         @Produces(MediaType.APPLICATION_JSON)
 413         public Response getCertifiedAbstractResources(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 414
 415                 // TODO: any validations???
 416                 ServletContext context = request.getSession().getServletContext();
 417
 418                 String url = request.getMethod() + " " + request.getRequestURI();
 419                 log.debug("(get) Start handle request of {}", url);
 420                 Response response = null;
 421                 try {
 422
 423                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 424
 425                         Either<List<Resource>, ResponseFormat> actionResponse = businessLogic.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, userId);
 426
 427                         if (actionResponse.isRight()) {
 428                                 log.debug("failed to get all abstract resources");
 429                                 response = buildErrorResponse(actionResponse.right().value());
 430                                 return response;
 431                         }
 432                         Object resources = RepresentationUtils.toRepresentation(actionResponse.left().value());
 433                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resources);
 434                         return response;
 435
 436                 } catch (Exception e) {
 437                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Get Certified Abstract Resources");
 438                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Certified Abstract Resources");
 439                         log.debug("getCertifiedAbstractResources failed with exception", e);
 440                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 441                         return response;
 442
 443                 }
 444         }
 445
 446         @GET
 447         @Path("/resources/certified/notabstract")
 448         @Consumes(MediaType.APPLICATION_JSON)
 449         @Produces(MediaType.APPLICATION_JSON)
 450         public Response getCertifiedNotAbstractResources(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 451                 // TODO: any vlidations???
 452                 ServletContext context = request.getSession().getServletContext();
 453
 454                 String url = request.getMethod() + " " + request.getRequestURI();
 455                 log.debug("(get) Start handle request of {}", url);
 456                 Response response = null;
 457
 458                 try {
 459
 460                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 461
 462                         Either<List<Resource>, ResponseFormat> actionResponse = businessLogic.getAllCertifiedResources(false, HighestFilterEnum.ALL, userId);
 463
 464                         if (actionResponse.isRight()) {
 465                                 log.debug("failed to get all non abstract resources");
 466                                 return buildErrorResponse(actionResponse.right().value());
 467                         }
 468                         Object resources = RepresentationUtils.toRepresentation(actionResponse.left().value());
 469                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resources);
 470                         return response;
 471
 472                 } catch (Exception e) {
 473                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Get Certified Non Abstract Resources");
 474                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Certified Non Abstract Resources");
 475                         log.debug("getCertifiedNotAbstractResources failed with exception", e);
 476                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 477                         return response;
 478
 479                 }
 480
 481         }
 482
 483         @PUT
 484         @Path("/resources/{resourceId}/metadata")
 485         @Consumes(MediaType.APPLICATION_JSON)
 486         @Produces(MediaType.APPLICATION_JSON)
 487         @ApiOperation(value = "Update Resource Metadata", httpMethod = "PUT", notes = "Returns updated resource metadata", response = Resource.class)
 488         @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource metadata updated"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content") })
 489         public Response updateResourceMetadata(@PathParam("resourceId") final String resourceId, @ApiParam(value = "Resource metadata to be updated", required = true) String data, @Context final HttpServletRequest request,
 490                         @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 491
 492                 ServletContext context = request.getSession().getServletContext();
 493
 494                 String url = request.getMethod() + " " + request.getRequestURI();
 495                 log.debug("Start handle request of {}", url);
 496
 497                 // get modifier id
 498                 User modifier = new User();
 499                 modifier.setUserId(userId);
 500                 log.debug("modifier id is {}", userId);
 501
 502                 Response response = null;
 503
 504                 try {
 505                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 506                         String resourceIdLower = resourceId.toLowerCase();
 507                         Either<Resource, ResponseFormat> updateInfoResource = getComponentsUtils().convertJsonToObjectUsingObjectMapper(data, modifier, Resource.class, AuditingActionEnum.UPDATE_RESOURCE_METADATA, ComponentTypeEnum.RESOURCE);
 508                         if (updateInfoResource.isRight()) {
 509                                 log.debug("failed to parse resource metadata");
 510                                 response = buildErrorResponse(updateInfoResource.right().value());
 511                                 return response;
 512                         }
 513                         Either<Resource, ResponseFormat> actionResponse = businessLogic.updateResourceMetadata(resourceIdLower,
 514                                         updateInfoResource.left().value(), null, modifier, false);
 515
 516                         if (actionResponse.isRight()) {
 517                                 log.debug("failed to update resource metadata");
 518                                 response = buildErrorResponse(actionResponse.right().value());
 519                                 return response;
 520                         }
 521                         Object resource = RepresentationUtils.toRepresentation(actionResponse.left().value());
 522                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), resource);
 523                         return response;
 524
 525                 } catch (Exception e) {
 526                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Update Resource Metadata");
 527                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Resource Metadata");
 528                         log.debug("Update Resource Metadata failed with exception", e);
 529                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 530                         return response;
 531
 532                 }
 533         }
 534
 535         @PUT
 536         @Path("/resources/{resourceId}")
 537         @Consumes(MediaType.APPLICATION_JSON)
 538         @Produces(MediaType.APPLICATION_JSON)
 539         @ApiOperation(value = "Update Resource", httpMethod = "PUT", notes = "Returns updated resource", response = Resource.class)
 540         @ApiResponses(value = { @ApiResponse(code = 200, message = "Resource updated"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 541                         @ApiResponse(code = 409, message = "Resource already exist") })
 542         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,
 543                         @PathParam(value = "resourceId") String resourceId) {
 544
 545                 userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
 546                 init(log);
 547
 548                 ServletContext context = request.getSession().getServletContext();
 549
 550                 String url = request.getMethod() + " " + request.getRequestURI();
 551                 log.debug("Start handle request of {}", url);
 552
 553                 // get modifier id
 554                 User modifier = new User();
 555                 modifier.setUserId(userId);
 556                 log.debug("modifier id is {}", userId);
 557
 558                 Response response = null;
 559                 try {
 560
 561                         Wrapper<Response> responseWrapper = new Wrapper<>();
 562                         // UI Import
 563                         if (isUIImport(data)) {
 564                                 performUIImport(responseWrapper, data, request, userId, resourceId);
 565                         } else {
 566
 567                                 ResourceBusinessLogic businessLogic = getResourceBL(context);
 568
 569                                 Either<Resource, ResponseFormat> convertResponse = parseToLightResource(data, modifier);
 570                                 if (convertResponse.isRight()) {
 571                                         log.debug("failed to parse resource");
 572                                         response = buildErrorResponse(convertResponse.right().value());
 573                                         return response;
 574                                 }
 575
 576                                 Resource resource = convertResponse.left().value();
 577                                 Either<Resource, ResponseFormat> actionResponse = businessLogic.validateAndUpdateResourceFromCsar(resource, modifier, null, null, resourceId);
 578
 579                                 if (actionResponse.isRight()) {
 580                                         log.debug("failed to update resource");
 581                                         response = buildErrorResponse(actionResponse.right().value());
 582                                 } else {
 583                                         Object representation = RepresentationUtils.toRepresentation(actionResponse.left().value());
 584                                         response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation);
 585                                 }
 586                                 responseWrapper.setInnerElement(response);
 587                         }
 588
 589                         return responseWrapper.getInnerElement();
 590
 591                 } catch (Exception e) {
 592                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeRestApiGeneralError, "Update Resource");
 593                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Resource");
 594                         log.debug("update resource failed with exception", e);
 595                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 596                         return response;
 597
 598                 }
 599         }
 600
 601         /*
 602          * @GET
 603          *
 604          * @Path("/resources/latestversion/notabstract")
 605          *
 606          * @Consumes(MediaType.APPLICATION_JSON)
 607          *
 608          * @Produces(MediaType.APPLICATION_JSON) public Response getLatestVersionNotAbstractResources(@Context final HttpServletRequest request) { //TODO: any vlidations??? ServletContext context = request.getSession().getServletContext();
 609          *
 610          * String url = request.getMethod() + " " + request.getRequestURI(); log.debug("(get) Start handle request of {}", url); Response response=null;
 611          *
 612          * try {
 613          *
 614          * ResourceBusinessLogic businessLogic = getResourceBL(context);
 615          *
 616          * Either<List<Resource>, ResponseFormat> actionResponse = businessLogic.getLatestVersionResources(false, HighestFilterEnum.HIGHEST_ONLY);
 617          *
 618          *
 619          * if (actionResponse.isRight()){ log.debug( "failed to get all non abstract resources"); return buildErrorResponse(actionResponse.right().value()); } return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
 620          * actionResponse.left().value());
 621          *
 622          * } catch (Exception e){ BeEcompErrorManager.getInstance().processEcompError(EcompErrorName. BeRestApiGeneralError, "Get Certified Non Abstract Resources"); log.debug("getCertifiedNotAbstractResources failed with exception", e); response =
 623          * buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus. GENERAL_ERROR)); return response;
 624          *
 625          * } }
 626          */
 627         public static List<PropertyDefinition> convertMapToList(Map<String, PropertyDefinition> properties) {
 628                 if (properties == null) {
 629                         return null;
 630                 }
 631
 632                 List<PropertyDefinition> definitions = new ArrayList<>();
 633                 for (Entry<String, PropertyDefinition> entry : properties.entrySet()) {
 634                         String name = entry.getKey();
 635                         PropertyDefinition propertyDefinition = entry.getValue();
 636                         propertyDefinition.setName(name);
 637                         definitions.add(propertyDefinition);
 638                 }
 639
 640                 return definitions;
 641         }
 642
 643         @GET
 644         @Path("/resources/csar/{csaruuid}")
 645         @Consumes(MediaType.APPLICATION_JSON)
 646         @Produces(MediaType.APPLICATION_JSON)
 647         @ApiOperation(value = "Create Resource", httpMethod = "POST", notes = "Returns resource created from csar uuid", response = Resource.class)
 648         @ApiResponses(value = { @ApiResponse(code = 201, message = "Resource retrieced"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content") })
 649         public Response getResourceFromCsar(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @PathParam(value = "csaruuid") String csarUUID) {
 650
 651                 init(log);
 652
 653                 ServletContext context = request.getSession().getServletContext();
 654
 655                 String url = request.getMethod() + " " + request.getRequestURI();
 656                 log.debug("Start handle request of {}", url);
 657
 658                 // retrieve user details
 659                 userId = (userId != null) ? userId : request.getHeader(Constants.USER_ID_HEADER);
 660                 User user = new User();
 661                 user.setUserId(userId);
 662
 663                 log.debug("user id is {}", userId);
 664
 665                 Response response = null;
 666
 667                 try {
 668
 669                         ResourceBusinessLogic businessLogic = getResourceBL(context);
 670
 671                         Either<Resource, ResponseFormat> eitherResource = businessLogic.getLatestResourceFromCsarUuid(csarUUID, user);
 672
 673                         // validate response
 674                         if (eitherResource.isRight()) {
 675                                 log.debug("failed to get resource from csarUuid : {}", csarUUID);
 676                                 // response =
 677                                 // buildErrorResponse(eitherResource.right().value());
 678                                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), eitherResource.right().value());
 679                         } else {
 680                                 Object representation = RepresentationUtils.toRepresentation(eitherResource.left().value());
 681                                 response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation);
 682                         }
 683
 684                         return response;
 685
 686                 } catch (Exception e) {
 687                         log.debug("get resource by csar failed with exception", e);
 688                         response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 689                         return response;
 690                 }
 691         }
 692 }