gerrit.onap Code Review - sdc.git/blob

   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.sdcrests.vendorlicense.rest.services;
  22
  23 import java.util.Comparator;
  24 import java.util.HashSet;
  25 import java.util.stream.Collectors;
  26 import javax.inject.Named;
  27 import javax.ws.rs.core.Response;
  28 import org.apache.commons.collections4.CollectionUtils;
  29 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
  30 import org.openecomp.sdc.vendorlicense.VendorLicenseManagerFactory;
  31 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  32 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
  33 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
  34 import org.openecomp.sdc.versioning.dao.types.Version;
  35 import org.openecomp.sdcrests.vendorlicense.rest.LicenseAgreements;
  36 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapFeatureGroupEntityToFeatureGroupDescriptorDto;
  37 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapLicenseAgreementDescriptorDtoToLicenseAgreementEntity;
  38 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapLicenseAgreementEntityToLicenseAgreementDescriptorDto;
  39 import org.openecomp.sdcrests.vendorlicense.types.FeatureGroupEntityDto;
  40 import org.openecomp.sdcrests.vendorlicense.types.LicenseAgreementEntityDto;
  41 import org.openecomp.sdcrests.vendorlicense.types.LicenseAgreementModelDto;
  42 import org.openecomp.sdcrests.vendorlicense.types.LicenseAgreementRequestDto;
  43 import org.openecomp.sdcrests.vendorlicense.types.LicenseAgreementUpdateRequestDto;
  44 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
  45 import org.openecomp.sdcrests.wrappers.StringWrapperResponse;
  46 import org.springframework.context.annotation.Scope;
  47 import org.springframework.stereotype.Service;
  48
  49 @Named
  50 @Service("licenseAgreements")
  51 @Scope(value = "prototype")
  52 public class LicenseAgreementsImpl implements LicenseAgreements {
  53
  54     private VendorLicenseManager vendorLicenseManager =
  55             VendorLicenseManagerFactory.getInstance().createInterface();
  56
  57     /**
  58      * List license agreements response.
  59      *
  60      * @param vlmId     the vlm id
  61      * @param versionId the version
  62      * @param user      the user
  63      * @return the response
  64      */
  65     public Response listLicenseAgreements(String vlmId, String versionId, String user) {
  66
  67         MapLicenseAgreementEntityToLicenseAgreementDescriptorDto outputMapper =
  68                 new MapLicenseAgreementEntityToLicenseAgreementDescriptorDto();
  69
  70         GenericCollectionWrapper<LicenseAgreementEntityDto> results = new GenericCollectionWrapper<>(
  71                 vendorLicenseManager.listLicenseAgreements(vlmId, new Version(versionId)).stream()
  72                                     .sorted(Comparator.comparing(LicenseAgreementEntity::getName))
  73                                     .map(lae -> getLicenseAgreementEntityDto(outputMapper, lae))
  74                                     .collect(Collectors.toList()));
  75
  76         return Response.ok(results).build();
  77     }
  78
  79
  80     /**
  81      * Create license agreement response.
  82      *
  83      * @param request the request
  84      * @param vlmId   the vlm id
  85      * @param user    the user
  86      * @return the response
  87      */
  88     public Response createLicenseAgreement(LicenseAgreementRequestDto request, String vlmId,
  89                                            String versionId, String user) {
  90         LicenseAgreementEntity licenseAgreementEntity =
  91                 new MapLicenseAgreementDescriptorDtoToLicenseAgreementEntity()
  92                         .applyMapping(request, LicenseAgreementEntity.class);
  93         licenseAgreementEntity.setVendorLicenseModelId(vlmId);
  94         licenseAgreementEntity.setVersion(new Version(versionId));
  95         licenseAgreementEntity.setFeatureGroupIds(request.getAddedFeatureGroupsIds());
  96
  97         LicenseAgreementEntity createdLicenseAgreement =
  98                 vendorLicenseManager.createLicenseAgreement(licenseAgreementEntity);
  99         StringWrapperResponse result =
 100                 createdLicenseAgreement != null ? new StringWrapperResponse(createdLicenseAgreement.getId())
 101                         : null;
 102         return Response.ok(result).build();
 103     }
 104
 105     /**
 106      * Update license agreement response.
 107      *
 108      * @param request            the request
 109      * @param vlmId              the vlm id
 110      * @param licenseAgreementId the license agreement id
 111      * @param user               the user
 112      * @return the response
 113      */
 114     public Response updateLicenseAgreement(LicenseAgreementUpdateRequestDto request, String vlmId,
 115                                            String versionId, String licenseAgreementId, String user) {
 116         LicenseAgreementEntity licenseAgreementEntity =
 117                 new MapLicenseAgreementDescriptorDtoToLicenseAgreementEntity()
 118                         .applyMapping(request, LicenseAgreementEntity.class);
 119         licenseAgreementEntity.setVendorLicenseModelId(vlmId);
 120         licenseAgreementEntity.setVersion(new Version(versionId));
 121         licenseAgreementEntity.setId(licenseAgreementId);
 122
 123         vendorLicenseManager
 124                 .updateLicenseAgreement(licenseAgreementEntity, request.getAddedFeatureGroupsIds(),
 125                         request.getRemovedFeatureGroupsIds());
 126         return Response.ok().build();
 127     }
 128
 129     /**
 130      * Gets license agreement.
 131      *
 132      * @param vlmId              the vlm id
 133      * @param versionId          the version
 134      * @param licenseAgreementId the license agreement id
 135      * @param user               the user
 136      * @return the license agreement
 137      */
 138     public Response getLicenseAgreement(String vlmId, String versionId, String licenseAgreementId,
 139                                         String user) {
 140         LicenseAgreementModel licenseAgreementModel = vendorLicenseManager
 141                 .getLicenseAgreementModel(vlmId, new Version(versionId), licenseAgreementId);
 142
 143         if (licenseAgreementModel == null) {
 144             return Response.ok().build();
 145         }
 146
 147         LicenseAgreementModelDto lamDto = new LicenseAgreementModelDto();
 148         lamDto.setId(licenseAgreementModel.getLicenseAgreement().getId());
 149         new MapLicenseAgreementEntityToLicenseAgreementDescriptorDto()
 150                 .doMapping(licenseAgreementModel.getLicenseAgreement(), lamDto);
 151
 152         if (!CollectionUtils.isEmpty(licenseAgreementModel.getFeatureGroups())) {
 153             lamDto.setFeatureGroups(new HashSet<>());
 154
 155             MapFeatureGroupEntityToFeatureGroupDescriptorDto fgMapper =
 156                     new MapFeatureGroupEntityToFeatureGroupDescriptorDto();
 157             for (FeatureGroupEntity fg : licenseAgreementModel.getFeatureGroups()) {
 158                 FeatureGroupEntityDto fgeDto = new FeatureGroupEntityDto();
 159                 fgeDto.setId(fg.getId());
 160                 fgeDto.setEntitlementPoolsIds(fg.getEntitlementPoolIds());
 161                 fgeDto.setLicenseKeyGroupsIds(fg.getLicenseKeyGroupIds());
 162                 fgMapper.doMapping(fg, fgeDto);
 163
 164                 lamDto.getFeatureGroups().add(fgeDto);
 165             }
 166         }
 167         return Response.ok(lamDto).build();
 168     }
 169
 170     /**
 171      * Delete license agreement response.
 172      *
 173      * @param vlmId              the vlm id
 174      * @param versionId          the version id
 175      * @param licenseAgreementId the license agreement id
 176      * @param user               the user
 177      * @return the response
 178      */
 179     public Response deleteLicenseAgreement(String vlmId, String versionId, String licenseAgreementId,
 180                                            String user) {
 181         vendorLicenseManager.deleteLicenseAgreement(vlmId, new Version(versionId), licenseAgreementId);
 182         return Response.ok().build();
 183     }
 184
 185     private LicenseAgreementEntityDto getLicenseAgreementEntityDto(
 186             MapLicenseAgreementEntityToLicenseAgreementDescriptorDto mapper, LicenseAgreementEntity lae) {
 187         LicenseAgreementEntityDto laeDto = new LicenseAgreementEntityDto();
 188         laeDto.setId(lae.getId());
 189         laeDto.setFeatureGroupsIds(lae.getFeatureGroupIds());
 190         mapper.doMapping(lae, laeDto);
 191         return laeDto;
 192     }
 193 }