catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.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.externalapi.servlet;
  22
  23 import java.io.ByteArrayInputStream;
  24 import java.io.InputStream;
  25 import java.util.EnumMap;
  26 import java.util.HashMap;
  27 import java.util.Map;
  28
  29 import javax.inject.Singleton;
  30 import javax.servlet.ServletContext;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.ws.rs.DELETE;
  33 import javax.ws.rs.GET;
  34 import javax.ws.rs.POST;
  35 import javax.ws.rs.Path;
  36 import javax.ws.rs.PathParam;
  37 import javax.ws.rs.Produces;
  38 import javax.ws.rs.core.Context;
  39 import javax.ws.rs.core.MediaType;
  40 import javax.ws.rs.core.Response;
  41
  42 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  43 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  44 import org.openecomp.sdc.be.dao.api.ActionStatus;
  45 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  46 import org.openecomp.sdc.be.model.ArtifactDefinition;
  47 import org.openecomp.sdc.be.servlets.BeGenericServlet;
  48 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  49 import org.openecomp.sdc.common.api.Constants;
  50 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  51 import org.openecomp.sdc.common.datastructure.Wrapper;
  52 import org.openecomp.sdc.common.util.GeneralUtility;
  53 import org.openecomp.sdc.exception.ResponseFormat;
  54 import org.slf4j.Logger;
  55 import org.slf4j.LoggerFactory;
  56
  57 import com.jcabi.aspects.Loggable;
  58 import com.wordnik.swagger.annotations.ApiOperation;
  59 import com.wordnik.swagger.annotations.ApiParam;
  60 import com.wordnik.swagger.annotations.ApiResponse;
  61 import com.wordnik.swagger.annotations.ApiResponses;
  62
  63 import fj.data.Either;
  64
  65 /**
  66  * This Servlet serves external users operations on artifacts.
  67  *
  68  * @author mshitrit
  69  *
  70  */
  71 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  72 @Path("/v1/catalog")
  73 @Singleton
  74 public class ArtifactExternalServlet extends BeGenericServlet {
  75
  76         @Context
  77         private HttpServletRequest request;
  78
  79         private static Logger log = LoggerFactory.getLogger(ArtifactExternalServlet.class.getName());
  80
  81         /**
  82          * Uploads an artifact to resource or service
  83          *
  84          * @param assetType
  85          * @param uuid
  86          * @return
  87          */
  88         @POST
  89         @Path("/{assetType}/{uuid}/artifacts")
  90         @Produces(MediaType.APPLICATION_JSON)
  91         @ApiOperation(value = "uploads of artifact to a resource or service", httpMethod = "POST", notes = "uploads of artifact to a resource or service", response = Response.class)
  92         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact uploaded"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
  93                         @ApiResponse(code = 404, message = "Asset not found") })
  94         public Response uploadArtifact(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @ApiParam(value = "json describe the artifact", required = true) String data) {
  95
  96                 Wrapper<Response> responseWrapper = new Wrapper<>();
  97                 ResponseFormat responseFormat = null;
  98                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
  99                 String requestURI = request.getRequestURI();
 100                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 101                 String url = request.getMethod() + " " + requestURI;
 102                 log.debug("Start handle request of {}", url);
 103                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 104                 if (componentType == null) {
 105                         log.debug("uploadArtifact: assetType parameter {} is not valid", assetType);
 106                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 107                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 108                 }
 109                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 110
 111                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 112                         log.debug("uploadArtifact: Missing X-ECOMP-InstanceID header");
 113                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 114                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 115                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 116                 }
 117                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 118                         log.debug("uploadArtifact: Missing USER_ID header");
 119                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 120                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 121                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 122                 }
 123                 if (responseWrapper.isEmpty()) {
 124                         try {
 125                                 ServletContext context = request.getSession().getServletContext();
 126                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 127                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.uploadArtifactToComponentByUUID(data, request, componentType, uuid, additionalParams);
 128                                 if (uploadArtifactEither.isRight()) {
 129                                         log.debug("failed to upload artifact");
 130                                         responseFormat = uploadArtifactEither.right().value();
 131                                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 132                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 133                                 } else {
 134                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 135                                         Map<String, String> headers = new HashMap<>();
 136                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 137                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 138                                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 139                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 140                                 }
 141                         } catch (Exception e) {
 142                                 final String message = "failed to upload artifact to a resource or service";
 143                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 144                                 log.debug(message, e);
 145                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 146                         }
 147                 }
 148                 return responseWrapper.getInnerElement();
 149         }
 150
 151         /**
 152          * Uploads an artifact to resource instance
 153          *
 154          * @param assetType
 155          * @param uuid
 156          * @param resourceInstanceName
 157          * @return
 158          */
 159         @POST
 160         @Path("/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts")
 161         @Produces(MediaType.APPLICATION_JSON)
 162         @ApiOperation(value = "uploads an artifact to a resource instance", httpMethod = "POST", notes = "uploads an artifact to a resource instance", response = Response.class)
 163         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact uploaded"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 164                         @ApiResponse(code = 404, message = "Asset not found") })
 165         public Response uploadArtifactToInstance(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @PathParam("resourceInstanceName") final String resourceInstanceName,
 166                         @ApiParam(value = "json describe the artifact", required = true) String data) {
 167
 168                 Wrapper<Response> responseWrapper = new Wrapper<>();
 169                 ResponseFormat responseFormat = null;
 170                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 171                 String requestURI = request.getRequestURI();
 172                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 173                 String url = request.getMethod() + " " + requestURI;
 174                 log.debug("Start handle request of {}", url);
 175                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 176                 if (componentType == null) {
 177                         log.debug("uploadArtifact: assetType parameter {} is not valid", assetType);
 178                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 179                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 180                 }
 181                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 182
 183                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 184                         log.debug("uploadArtifact: Missing X-ECOMP-InstanceID header");
 185                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 186                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 187                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 188                 }
 189                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 190                         log.debug("uploadArtifact: Missing USER_ID header");
 191                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 192                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 193                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 194                 }
 195                 if (responseWrapper.isEmpty()) {
 196                         try {
 197                                 ServletContext context = request.getSession().getServletContext();
 198                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 199                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.uploadArtifactToRiByUUID(data, request, componentType, uuid, resourceInstanceName, additionalParams);
 200                                 if (uploadArtifactEither.isRight()) {
 201                                         log.debug("failed to upload artifact");
 202                                         responseFormat = uploadArtifactEither.right().value();
 203                                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 204                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 205                                 } else {
 206                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 207                                         Map<String, String> headers = new HashMap<>();
 208                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 209                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 210                                         getComponentsUtils().auditExternalUploadArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 211                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 212                                 }
 213                         } catch (Exception e) {
 214                                 final String message = "failed to upload artifact to a resource instance";
 215                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 216                                 log.debug(message, e);
 217                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 218                         }
 219                 }
 220                 return responseWrapper.getInnerElement();
 221         }
 222
 223         /**
 224          * updates an artifact on a resource or service
 225          *
 226          * @param assetType
 227          * @param uuid
 228          * @param artifactUUID
 229          * @return
 230          */
 231         @POST
 232         @Path("/{assetType}/{uuid}/artifacts/{artifactUUID}")
 233         @Produces(MediaType.APPLICATION_JSON)
 234         @ApiOperation(value = "updates an artifact on a resource or service", httpMethod = "POST", notes = "uploads of artifact to a resource or service", response = Response.class)
 235         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact Updated"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 236                         @ApiResponse(code = 404, message = "Asset not found") })
 237         public Response updateArtifact(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @PathParam("artifactUUID") final String artifactUUID,
 238                         @ApiParam(value = "json describe the artifact", required = true) String data) {
 239
 240                 Wrapper<Response> responseWrapper = new Wrapper<>();
 241                 ResponseFormat responseFormat = null;
 242                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 243                 String requestURI = request.getRequestURI();
 244                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 245                 String url = request.getMethod() + " " + requestURI;
 246                 log.debug("Start handle request of {}", url);
 247                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 248                 if (componentType == null) {
 249                         log.debug("updateArtifact: assetType parameter {} is not valid", assetType);
 250                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 251                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 252                 }
 253                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 254
 255                 // Mandatory
 256                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 257                         log.debug("updateArtifact: Missing X-ECOMP-InstanceID header");
 258                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 259                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 260                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 261                 }
 262                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 263                         log.debug("updateArtifact: Missing USER_ID header");
 264                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 265                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 266                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 267                 }
 268                 if (responseWrapper.isEmpty()) {
 269                         try {
 270                                 ServletContext context = request.getSession().getServletContext();
 271                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 272                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.updateArtifactOnComponentByUUID(data, request, componentType, uuid, artifactUUID, additionalParams);
 273                                 if (uploadArtifactEither.isRight()) {
 274                                         log.debug("failed to update artifact");
 275                                         responseFormat = uploadArtifactEither.right().value();
 276                                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 277                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 278                                 } else {
 279                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 280                                         Map<String, String> headers = new HashMap<>();
 281                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 282                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 283                                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 284                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 285                                 }
 286                         } catch (Exception e) {
 287                                 final String message = "failed to update artifact on a resource or service";
 288                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 289                                 log.debug(message, e);
 290                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 291                         }
 292                 }
 293                 return responseWrapper.getInnerElement();
 294         }
 295
 296         /**
 297          * updates an artifact on a resource instance
 298          *
 299          * @param assetType
 300          * @param uuid
 301          * @param resourceInstanceName
 302          * @param artifactUUID
 303          * @return
 304          */
 305         @POST
 306         @Path("/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}")
 307         @Produces(MediaType.APPLICATION_JSON)
 308         @ApiOperation(value = "updates an artifact on a resource instance", httpMethod = "POST", notes = "uploads of artifact to a resource or service", response = Response.class)
 309         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact Updated"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 310                         @ApiResponse(code = 404, message = "Asset not found") })
 311         public Response updateArtifactOnResourceInstance(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @PathParam("resourceInstanceName") final String resourceInstanceName,
 312                         @PathParam("artifactUUID") final String artifactUUID, @ApiParam(value = "json describe the artifact", required = true) String data) {
 313
 314                 Wrapper<Response> responseWrapper = new Wrapper<>();
 315                 ResponseFormat responseFormat = null;
 316                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 317                 String requestURI = request.getRequestURI();
 318                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 319                 String url = request.getMethod() + " " + requestURI;
 320                 log.debug("Start handle request of {}", url);
 321                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 322                 if (componentType == null) {
 323                         log.debug("updateArtifactOnResourceInstance: assetType parameter {} is not valid", assetType);
 324                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 325                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 326                 }
 327                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 328
 329                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 330                         log.debug("updateArtifactOnResourceInstance: Missing X-ECOMP-InstanceID header");
 331                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 332                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 333                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 334                 }
 335                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 336                         log.debug("updateArtifactOnResourceInstance: Missing USER_ID header");
 337                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 338                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 339                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 340                 }
 341                 if (responseWrapper.isEmpty()) {
 342                         try {
 343                                 ServletContext context = request.getSession().getServletContext();
 344                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 345                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.updateArtifactOnRiByUUID(data, request, componentType, uuid, resourceInstanceName, artifactUUID, additionalParams);
 346                                 if (uploadArtifactEither.isRight()) {
 347                                         log.debug("failed to update artifact");
 348                                         responseFormat = uploadArtifactEither.right().value();
 349                                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 350                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 351                                 } else {
 352                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 353                                         Map<String, String> headers = new HashMap<>();
 354                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 355                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 356                                         getComponentsUtils().auditExternalUpdateArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 357                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 358                                 }
 359                         } catch (Exception e) {
 360                                 final String message = "failed to update artifact on resource instance";
 361                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 362                                 log.debug(message, e);
 363                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 364                         }
 365                 }
 366                 return responseWrapper.getInnerElement();
 367         }
 368
 369         /**
 370          * deletes an artifact of a resource or service
 371          *
 372          * @param assetType
 373          * @param uuid
 374          * @param artifactUUID
 375          * @return
 376          */
 377         @DELETE
 378         @Path("/{assetType}/{uuid}/artifacts/{artifactUUID}")
 379         @Produces(MediaType.APPLICATION_JSON)
 380         @ApiOperation(value = "deletes an artifact of a resource or service", httpMethod = "DELETE", notes = "deletes an artifact of a resource or service", response = Response.class)
 381         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact Deleted"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 382                         @ApiResponse(code = 404, message = "Asset not found") })
 383         public Response deleteArtifact(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @PathParam("artifactUUID") final String artifactUUID) {
 384
 385                 Wrapper<Response> responseWrapper = new Wrapper<>();
 386                 ResponseFormat responseFormat;
 387                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 388                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 389                 String requestURI = request.getRequestURI();
 390                 String url = request.getMethod() + " " + requestURI;
 391                 log.debug("Start handle request of {}", url);
 392
 393                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 394                 if (componentType == null) {
 395                         log.debug("deleteArtifact: assetType parameter {} is not valid", assetType);
 396                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 397                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 398                 }
 399                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 400
 401                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 402                         log.debug("deleteArtifact: Missing X-ECOMP-InstanceID header");
 403                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 404                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 405                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 406                 }
 407                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 408                         log.debug("deleteArtifact: Missing USER_ID header");
 409                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 410                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 411                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 412                 }
 413                 if (responseWrapper.isEmpty()) {
 414                         try {
 415                                 ServletContext context = request.getSession().getServletContext();
 416                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 417                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.deleteArtifactOnComponentByUUID(request, componentType, uuid, artifactUUID, additionalParams);
 418                                 if (uploadArtifactEither.isRight()) {
 419                                         log.debug("failed to delete artifact");
 420                                         responseFormat = uploadArtifactEither.right().value();
 421                                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 422                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 423                                 } else {
 424                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 425                                         Map<String, String> headers = new HashMap<>();
 426                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 427                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 428                                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 429                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 430                                 }
 431                         } catch (Exception e) {
 432                                 final String message = "failed to delete an artifact of a resource or service";
 433                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 434                                 log.debug(message, e);
 435                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 436                         }
 437                 }
 438                 return responseWrapper.getInnerElement();
 439         }
 440
 441         /**
 442          * deletes an artifact of a resource instance
 443          *
 444          * @param assetType
 445          * @param uuid
 446          * @param resourceInstanceName
 447          * @return
 448          */
 449         @DELETE
 450         @Path("{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}")
 451         @Produces(MediaType.APPLICATION_JSON)
 452         @ApiOperation(value = "deletes an artifact of a resource insatnce", httpMethod = "DELETE", notes = "deletes an artifact of a resource insatnce", response = Response.class)
 453         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact Deleted"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 454                         @ApiResponse(code = 404, message = "Asset not found") })
 455         public Response deleteArtifactOnResourceInstance(@PathParam("assetType") final String assetType, @PathParam("uuid") final String uuid, @PathParam("resourceInstanceName") final String resourceInstanceName,
 456                         @PathParam("artifactUUID") final String artifactUUID) {
 457
 458                 Wrapper<Response> responseWrapper = new Wrapper<>();
 459                 ResponseFormat responseFormat;
 460                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 461                 String userId = request.getHeader(Constants.USER_ID_HEADER);
 462                 String requestURI = request.getRequestURI();
 463                 String url = request.getMethod() + " " + requestURI;
 464                 log.debug("Start handle request of {}", url);
 465
 466                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 467                 if (componentType == null) {
 468                         log.debug("deleteArtifactOnResourceInsatnce: assetType parameter {} is not valid", assetType);
 469                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 470                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 471                 }
 472                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParams = new EnumMap<>(AuditingFieldsKeysEnum.class);
 473
 474                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 475                         log.debug("deleteArtifactOnResourceInsatnce: Missing X-ECOMP-InstanceID header");
 476                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 477                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 478                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 479                 }
 480                 if (responseWrapper.isEmpty() && (userId == null || userId.isEmpty())) {
 481                         log.debug("deleteArtifactOnResourceInsatnce: Missing USER_ID header");
 482                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.COMPONENT_MISSING_CONTACT);
 483                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 484                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 485                 }
 486                 if (responseWrapper.isEmpty()) {
 487                         try {
 488                                 ServletContext context = request.getSession().getServletContext();
 489                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 490                                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic.deleteArtifactOnRiByUUID(request, componentType, uuid, resourceInstanceName, artifactUUID, additionalParams);
 491                                 if (uploadArtifactEither.isRight()) {
 492                                         log.debug("failed to delete artifact");
 493                                         responseFormat = uploadArtifactEither.right().value();
 494                                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 495                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 496                                 } else {
 497                                         Object representation = RepresentationUtils.toRepresentation(uploadArtifactEither.left().value());
 498                                         Map<String, String> headers = new HashMap<>();
 499                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByString((String) representation));
 500                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 501                                         getComponentsUtils().auditExternalDeleteArtifact(responseFormat, componentType.getValue(), request, additionalParams);
 502                                         responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), representation, headers));
 503                                 }
 504                         } catch (Exception e) {
 505                                 final String message = "failed to delete an artifact of a resource instance";
 506                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 507                                 log.debug(message, e);
 508                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 509                         }
 510                 }
 511                 return responseWrapper.getInnerElement();
 512         }
 513
 514         /**
 515          * downloads an artifact of a component (either a service or a resource) by artifactUUID
 516          *
 517          * @param assetType
 518          * @param uuid
 519          * @param artifactUUID
 520          * @return
 521          */
 522         @GET
 523         @Path("/{assetType}/{uuid}/artifacts/{artifactUUID}")
 524         @Produces(MediaType.APPLICATION_OCTET_STREAM)
 525         @ApiOperation(value = "Download component artifact", httpMethod = "GET", notes = "Returns downloaded artifact", response = Response.class)
 526         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact downloaded"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 527                         @ApiResponse(code = 404, message = "Artifact not found") })
 528         public Response downloadComponentArtifact(
 529                         @ApiParam(value = "valid values: resources / services", allowableValues = ComponentTypeEnum.RESOURCE_PARAM_NAME + "," + ComponentTypeEnum.SERVICE_PARAM_NAME) @PathParam("assetType") final String assetType,
 530                         @PathParam("uuid") final String uuid, @PathParam("artifactUUID") final String artifactUUID) {
 531
 532                 Wrapper<Response> responseWrapper = new Wrapper<>();
 533                 ResponseFormat responseFormat;
 534                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 535                 String requestURI = request.getRequestURI();
 536                 String url = request.getMethod() + " " + requestURI;
 537                 log.debug("Start handle request of {}", url);
 538                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 539                 if (componentType == null) {
 540                         log.debug("downloadComponentArtifact: assetType parameter {} is not valid", assetType);
 541                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 542                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 543                 }
 544                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParam = new EnumMap<>(AuditingFieldsKeysEnum.class);
 545
 546                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 547                         log.debug("downloadComponentArtifact: Missing X-ECOMP-InstanceID header");
 548                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 549                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 550                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 551                 }
 552                 if (responseWrapper.isEmpty()) {
 553                         try {
 554                                 ServletContext context = request.getSession().getServletContext();
 555                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 556                                 Either<byte[], ResponseFormat> downloadComponentArtifactEither = artifactsLogic.downloadComponentArtifactByUUIDs(componentType, uuid, artifactUUID, additionalParam);
 557                                 if (downloadComponentArtifactEither.isRight()) {
 558                                         responseFormat = downloadComponentArtifactEither.right().value();
 559                                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 560                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 561                                 } else {
 562                                         byte[] value = downloadComponentArtifactEither.left().value();
 563                                         InputStream is = new ByteArrayInputStream(value);
 564                                         Map<String, String> headers = new HashMap<>();
 565                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByByteArray(value));
 566                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 567                                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 568                                         responseWrapper.setInnerElement(buildOkResponse(responseFormat, is, headers));
 569                                 }
 570                         } catch (Exception e) {
 571                                 final String message = "failed to download an artifact of a resource or service";
 572                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 573                                 log.debug(message, e);
 574                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 575                         }
 576                 }
 577                 return responseWrapper.getInnerElement();
 578         }
 579
 580         /**
 581          * downloads an artifact of a resource instance of a component (either a service or a resource) by artifactUUID
 582          *
 583          * @param assetType
 584          * @param uuid
 585          * @param resourceInstanceName
 586          * @param artifactUUID
 587          * @return
 588          */
 589         @GET
 590         @Path("/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}")
 591         @Produces(MediaType.APPLICATION_OCTET_STREAM)
 592         @ApiOperation(value = "Download resource instance artifact", httpMethod = "GET", notes = "Returns downloaded artifact", response = Response.class)
 593         @ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact downloaded"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
 594                         @ApiResponse(code = 404, message = "Artifact not found") })
 595         public Response downloadResourceInstanceArtifact(
 596                         @ApiParam(value = "valid values: resources / services", allowableValues = ComponentTypeEnum.RESOURCE_PARAM_NAME + "," + ComponentTypeEnum.SERVICE_PARAM_NAME) @PathParam("assetType") final String assetType,
 597                         @PathParam("uuid") final String uuid, @PathParam("resourceInstanceName") final String resourceInstanceName, @PathParam("artifactUUID") final String artifactUUID) {
 598
 599                 Wrapper<Response> responseWrapper = new Wrapper<>();
 600                 ResponseFormat responseFormat;
 601                 String instanceIdHeader = request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER);
 602                 String requestURI = request.getRequestURI();
 603                 String url = request.getMethod() + " " + requestURI;
 604                 log.debug("Start handle request of {}", url);
 605                 ComponentTypeEnum componentType = ComponentTypeEnum.findByParamName(assetType);
 606                 if (componentType == null) {
 607                         log.debug("downloadResourceInstanceArtifact: assetType parameter {} is not valid", assetType);
 608                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
 609                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 610                 }
 611                 EnumMap<AuditingFieldsKeysEnum, Object> additionalParam = new EnumMap<>(AuditingFieldsKeysEnum.class);
 612
 613                 if (responseWrapper.isEmpty() && (instanceIdHeader == null || instanceIdHeader.isEmpty())) {
 614                         log.debug("downloadResourceInstanceArtifact: Missing X-ECOMP-InstanceID header");
 615                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID);
 616                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 617                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 618                 }
 619                 if (responseWrapper.isEmpty()) {
 620                         try {
 621                                 ServletContext context = request.getSession().getServletContext();
 622                                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
 623                                 Either<byte[], ResponseFormat> downloadResourceArtifactEither = artifactsLogic.downloadResourceInstanceArtifactByUUIDs(componentType, uuid, resourceInstanceName, artifactUUID, additionalParam);
 624                                 if (downloadResourceArtifactEither.isRight()) {
 625                                         responseFormat = downloadResourceArtifactEither.right().value();
 626                                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 627                                         responseWrapper.setInnerElement(buildErrorResponse(responseFormat));
 628                                 } else {
 629                                         byte[] value = downloadResourceArtifactEither.left().value();
 630                                         InputStream is = new ByteArrayInputStream(value);
 631                                         Map<String, String> headers = new HashMap<>();
 632                                         headers.put(Constants.MD5_HEADER, GeneralUtility.calculateMD5ByByteArray(value));
 633                                         responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.OK);
 634                                         getComponentsUtils().auditExternalDownloadArtifact(responseFormat, componentType.getValue(), request, additionalParam);
 635                                         responseWrapper.setInnerElement(buildOkResponse(responseFormat, is, headers));
 636                                 }
 637                         } catch (Exception e) {
 638                                 final String message = "failed to download an artifact of a resource instance";
 639                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(message);
 640                                 log.debug(message, e);
 641                                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 642                         }
 643                 }
 644                 return responseWrapper.getInnerElement();
 645         }
 646 }