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