path: root/openecomp-be/api/openecomp-sdc-rest-webapp/vendor-software-products-rest/vendor-software-products-rest-services/src/main/java/org/openecomp/sdcrests/vsp/rest/services/VendorSoftwareProductsImpl.java

/*-
 * ============LICENSE_START=======================================================
 * SDC
 * ================================================================================
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */

package org.openecomp.sdcrests.vsp.rest.services;

import org.openecomp.sdc.activityLog.ActivityLogManager;
import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
import org.openecomp.sdc.logging.context.MdcUtil;
import org.openecomp.sdc.logging.messages.AuditMessages;
import org.openecomp.sdc.logging.types.LoggerConstants;
import org.openecomp.sdc.logging.types.LoggerServiceName;
import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo;
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.types.VersionInfo;
import org.openecomp.sdc.versioning.types.VersionableEntityAction;
import org.openecomp.sdcrests.vendorsoftwareproducts.types.*;
import org.openecomp.sdcrests.vsp.rest.VendorSoftwareProducts;
import org.openecomp.sdcrests.vsp.rest.mapping.*;
import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
import org.openecomp.sdcrests.wrappers.StringWrapperResponse;
import org.slf4j.MDC;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import javax.inject.Named;
import javax.ws.rs.core.Response;
import java.io.File;
import java.io.IOException;
import java.util.List;


@Named
@Service("vendorSoftwareProducts")
@Scope(value = "prototype")
public class VendorSoftwareProductsImpl implements VendorSoftwareProducts {

    private VendorSoftwareProductManager vendorSoftwareProductManager =
            VspManagerFactory.getInstance().createInterface();

    private static final Logger logger =
            LoggerFactory.getLogger(VendorSoftwareProductsImpl.class);

    private ActivityLogManager activityLogManager =
            ActivityLogManagerFactory.getInstance().createInterface();

    @Override
    public Response createVsp(VspDescriptionDto vspDescriptionDto, String user) {
        MdcUtil.initMdc(LoggerServiceName.Create_VSP.toString());
        logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.CREATE_VSP + vspDescriptionDto.getName());

        VspDetails vspDetails =
                new MapVspDescriptionDtoToVspDetails().applyMapping(vspDescriptionDto, VspDetails.class);

        vspDetails = vendorSoftwareProductManager.createVsp(vspDetails, user);

        MspVspDetailsToVspCreationDto mapping = new MspVspDetailsToVspCreationDto();
        VspCreationDto vspCreationDto = mapping.applyMapping(vspDetails, VspCreationDto.class);

        return Response.ok(vspCreationDto).build();
    }

    @Override
    public Response listVsps(String versionFilter, String user) {
        MdcUtil.initMdc(LoggerServiceName.List_VSP.toString());
        List<VersionedVendorSoftwareProductInfo> vspList =
                vendorSoftwareProductManager.listVsps(versionFilter, user);

        GenericCollectionWrapper<VspDetailsDto> results = new GenericCollectionWrapper<>();
        if (!vspList.isEmpty()) {
            MapVersionedVendorSoftwareProductInfoToVspDetailsDto mapper =
                    new MapVersionedVendorSoftwareProductInfoToVspDetailsDto();
            for (VersionedVendorSoftwareProductInfo versionedVsp : vspList) {
                results.add(mapper.applyMapping(versionedVsp, VspDetailsDto.class));
            }
        }

        return Response.ok(results).build();
    }

  @Override
  public Response getVsp(String vspId, String versionId, String user) {
    MdcUtil.initMdc(LoggerServiceName.Get_VSP.toString());


    VspDetails vspDetails =
        vendorSoftwareProductManager
            .getVsp(vspId, resolveVspVersion(vspId, versionId, user, VersionableEntityAction.Read),
                user);

    VersionInfo versionInfo = getVersionInfo(vspId, VersionableEntityAction.Read, user);

    //
    if(vspDetails.getOldVersion()!=null && !"".equals(vspDetails.getOldVersion())) {
      if (Version.valueOf(versionId).equals(versionInfo.getActiveVersion())) {
        try {
          Version healedVersion = vendorSoftwareProductManager.callAutoHeal(vspId, versionInfo,
              vspDetails , user);
          vspDetails =
              vendorSoftwareProductManager
                  .getVsp(vspId, resolveVspVersion(vspId, healedVersion.toString(), user,
                      VersionableEntityAction.Read),user);
          versionInfo = getVersionInfo(vspId, VersionableEntityAction.Read, user);
        } catch (Exception e) {
          //to do
        }
      }
    }

    VspDetailsDto vspDetailsDto = vspDetails == null
        ? null
        : new MapVersionedVendorSoftwareProductInfoToVspDetailsDto()
            .applyMapping(new VersionedVendorSoftwareProductInfo(vspDetails, versionInfo),
                VspDetailsDto.class);

        return Response.ok(vspDetailsDto).build();
    }

  @Override
  public Response updateVsp(String vspId, String versionId, VspDescriptionDto vspDescriptionDto,
                            String user) {
    MdcUtil.initMdc(LoggerServiceName.Update_VSP.toString());
    VspDetails vspDetails =
        new MapVspDescriptionDtoToVspDetails().applyMapping(vspDescriptionDto, VspDetails.class);
    vspDetails.setId(vspId);
    vspDetails.setVersion(resolveVspVersion(vspId, null, user, VersionableEntityAction.Write));

        vendorSoftwareProductManager.updateVsp(vspDetails, user);

        return Response.ok().build();
    }

    @Override
    public Response deleteVsp(String vspId, String user) {
        MdcUtil.initMdc(LoggerServiceName.Delete_VSP.toString());
        vendorSoftwareProductManager.deleteVsp(vspId, user);

        return Response.ok().build();
    }

    @Override
    public Response actOnVendorSoftwareProduct(String vspId, String versionId,
                                               VersionSoftwareProductActionRequestDto request,
                                               String user) throws IOException {

    switch (request.getAction()) {
      case Checkout:
        MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Checkout_VSP.toString());
        logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.CHECK_OUT_VSP + vspId);
        vendorSoftwareProductManager.checkout(vspId, user);
        break;
      case Undo_Checkout:
        MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Undo_Checkout_VSP.toString());
        vendorSoftwareProductManager.undoCheckout(vspId, user);
        break;
      case Checkin:
        MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Checkin_VSP.toString());
        logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.CHECK_IN_VSP + vspId);
        vendorSoftwareProductManager.checkin(vspId, user);
        break;
      case Submit:
        MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Submit_VSP.toString());
        logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.SUBMIT_VSP + vspId);
        ValidationResponse validationResponse = vendorSoftwareProductManager.submit(vspId, user);
        if (!validationResponse.isValid()) {
          return Response.status(Response.Status.EXPECTATION_FAILED).entity(
              new MapValidationResponseToDto()
                  .applyMapping(validationResponse, ValidationResponseDto.class)).build();
        }
        break;
      case Create_Package:
        MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Create_Package.toString());

        PackageInfo packageInfo = vendorSoftwareProductManager.createPackage(vspId,
            resolveVspVersion(vspId, null, user, VersionableEntityAction.Read), user);
        return Response.ok(packageInfo == null
            ? null
            : new MapPackageInfoToPackageInfoDto().applyMapping(packageInfo, PackageInfoDto.class))
            .build();
      default:
    }

    return Response.ok().build();
  }

    @Override
    public Response getValidationVsp(String user)
            throws Exception {
        String validationVspId = vendorSoftwareProductManager.fetchValidationVsp(user);
        StringWrapperResponse response = new StringWrapperResponse(validationVspId);
        return Response.ok(response).build();
    }


    @Override
    public Response getOrchestrationTemplate(String vspId, String versionId, String user) {
        MdcUtil.initMdc(LoggerServiceName.Get_Uploaded_File.toString());
        byte[] orchestrationTemplateFile =
                vendorSoftwareProductManager
                        .getOrchestrationTemplateFile(vspId,
                                resolveVspVersion(vspId, versionId, user, VersionableEntityAction.Read), user);

        if (orchestrationTemplateFile == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        Response.ResponseBuilder response = Response.ok(orchestrationTemplateFile);
        response.header("Content-Disposition", "attachment; filename=LatestHeatPackage.zip");
        return response.build();
    }

    @Override
    public Response listPackages(String category, String subCategory, String user) {
        MdcUtil.initMdc(LoggerServiceName.List_Packages.toString());
        List<PackageInfo> packageInfoList =
                vendorSoftwareProductManager.listPackages(category, subCategory);

        GenericCollectionWrapper<PackageInfoDto> results = new GenericCollectionWrapper<>();
        MapPackageInfoToPackageInfoDto mapper = new MapPackageInfoToPackageInfoDto();

        if (packageInfoList != null) {
            for (PackageInfo packageInfo : packageInfoList) {
                results.add(mapper.applyMapping(packageInfo, PackageInfoDto.class));
            }
        }
        return Response.ok(results).build();
    }

  @Override
  public Response getTranslatedFile(String vspId, String version, String user) {
    MdcUtil.initMdc(LoggerServiceName.Get_Translated_File.toString());
    File zipFile =
        vendorSoftwareProductManager.getTranslatedFile(vspId,Version.valueOf(version), user);

    Version versionObj = Version.valueOf(version);
    Version resolvedVersion = versionObj == null
        ? getVersionInfo(vspId, VersionableEntityAction.Read, user).getLatestFinalVersion()
        : versionObj;


        Response.ResponseBuilder response = Response.ok(zipFile);
        if (zipFile == null) {
            logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.IMPORT_FAIL + vspId);
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        response.header("Content-Disposition", "attachment; filename=" + zipFile.getName());

        logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.IMPORT_SUCCESS + vspId);
        return response.build();
    }

    @Override
    public Response getQuestionnaire(String vspId, String versionId, String user) {
        MdcUtil.initMdc(LoggerServiceName.Get_Questionnaire_VSP.toString());
        QuestionnaireResponse questionnaireResponse =
                vendorSoftwareProductManager.getVspQuestionnaire(vspId,
                        resolveVspVersion(vspId, versionId, user, VersionableEntityAction.Read), user);

        if (questionnaireResponse.getErrorMessage() != null) {
            return Response.status(Response.Status.EXPECTATION_FAILED).entity(
                    new MapQuestionnaireResponseToQuestionnaireResponseDto()
                            .applyMapping(questionnaireResponse, QuestionnaireResponseDto.class)).build();
        }

        QuestionnaireResponseDto result = new MapQuestionnaireResponseToQuestionnaireResponseDto()
                .applyMapping(questionnaireResponse, QuestionnaireResponseDto.class);
        return Response.ok(result).build();
    }

  @Override
  public Response updateQuestionnaire(String questionnaireData, String vspId, String
      versionId, String user) {
    MdcUtil.initMdc(LoggerServiceName.Update_Questionnaire_VSP.toString());
    vendorSoftwareProductManager.updateVspQuestionnaire(vspId,
        resolveVspVersion(vspId, null, user, VersionableEntityAction.Write),
        questionnaireData, user);
    return Response.ok().build();
  }

    @Override
    public Response heal(String vspId, String versionId, String user) {
        vendorSoftwareProductManager.heal(vspId, Version.valueOf(versionId), user);

        return Response.ok().build();
    }

    @Override
    public Response getVspInformationArtifact(String vspId, String versionId, String user) {
        MdcUtil.initMdc(LoggerServiceName.Get_Information_Artifact.toString());
        File textInformationArtifact =
                vendorSoftwareProductManager.getInformationArtifact(vspId,
                        resolveVspVersion(vspId, versionId, user, VersionableEntityAction.Read), user);

        Response.ResponseBuilder response = Response.ok(textInformationArtifact);
        if (textInformationArtifact == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        response
                .header("Content-Disposition", "attachment; filename=" + textInformationArtifact.getName());
        return response.build();
    }
}