openecomp-be/api/openecomp-sdc-rest-webapp/vendor-license-rest/vendor-license-rest-services/src/main/java/org/openecomp/sdcrests/vendorlicense/rest/services/LicenseKeyGroupLimitsImpl.java

   1 package org.openecomp.sdcrests.vendorlicense.rest.services;
   2
   3 import org.openecomp.sdc.logging.context.MdcUtil;
   4 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
   5 import org.openecomp.sdc.logging.types.LoggerServiceName;
   6 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
   7 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
   8 import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
   9 import org.openecomp.sdc.versioning.dao.types.Version;
  10 import org.openecomp.sdcrests.vendorlicense.rest.LicenseKeyGroupLimits;
  11 import org.openecomp.sdcrests.vendorlicense.rest.mapping.LimitCreationDto;
  12 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapLimitEntityToLimitCreationDto;
  13 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapLimitEntityToLimitDto;
  14 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapLimitRequestDtoToLimitEntity;
  15 import org.openecomp.sdcrests.vendorlicense.types.LimitEntityDto;
  16 import org.openecomp.sdcrests.vendorlicense.types.LimitRequestDto;
  17 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
  18 import org.openecomp.sdcrests.wrappers.StringWrapperResponse;
  19 import org.springframework.beans.factory.annotation.Autowired;
  20 import org.springframework.context.annotation.Scope;
  21 import org.springframework.stereotype.Service;
  22
  23 import java.util.Collection;
  24 import javax.inject.Named;
  25 import javax.ws.rs.core.Response;
  26
  27 @Named
  28 @Service("licenseKeyGroupLimits")
  29 @Scope(value = "prototype")
  30 public class LicenseKeyGroupLimitsImpl implements LicenseKeyGroupLimits {
  31
  32   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  33   @Autowired
  34   private VendorLicenseManager vendorLicenseManager;
  35
  36   @Override
  37   public Response createLimit(LimitRequestDto request,
  38                               String vlmId,
  39                               String versionId,
  40                               String licenseKeyGroupId,
  41                               String user) {
  42
  43     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  44
  45     MdcUtil.initMdc(LoggerServiceName.Create_LIMIT.toString());
  46     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
  47             (versionId), licenseKeyGroupId), user);
  48
  49     LimitEntity limitEntity =
  50         new MapLimitRequestDtoToLimitEntity()
  51             .applyMapping(request, LimitEntity.class);
  52     limitEntity.setEpLkgId(licenseKeyGroupId);
  53     limitEntity.setVendorLicenseModelId(vlmId);
  54
  55     LimitEntity createdLimit = vendorLicenseManager.createLimit(limitEntity, user);
  56     MapLimitEntityToLimitCreationDto mapper = new MapLimitEntityToLimitCreationDto();
  57     LimitCreationDto createdLimitDto = mapper.applyMapping(createdLimit, LimitCreationDto
  58         .class);
  59     /*StringWrapperResponse result =
  60         createdLimit != null ? new StringWrapperResponse(createdLimit.getId())
  61             : null;*/
  62
  63     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  64
  65     //return Response.ok(result).build();
  66     return Response.ok(createdLimitDto != null ? createdLimitDto : null)
  67         .build();
  68   }
  69
  70   @Override
  71   public Response listLimits(String vlmId, String versionId, String licenseKeyGroupId, String
  72       user) {
  73     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  74
  75     MdcUtil.initMdc(LoggerServiceName.List_EP.toString());
  76     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
  77         (versionId), licenseKeyGroupId), user);
  78
  79     Collection<LimitEntity> limits =
  80         vendorLicenseManager.listLimits(vlmId, Version.valueOf(versionId), licenseKeyGroupId, user);
  81
  82     GenericCollectionWrapper<LimitEntityDto> result = new GenericCollectionWrapper<>();
  83     MapLimitEntityToLimitDto outputMapper =
  84         new MapLimitEntityToLimitDto();
  85     for (LimitEntity limit : limits) {
  86       result.add(outputMapper.applyMapping(limit, LimitEntityDto.class));
  87     }
  88
  89     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  90
  91     return Response.ok(result).build();
  92   }
  93
  94   @Override
  95   public Response updateLimit(LimitRequestDto request,
  96                               String vlmId,
  97                               String versionId,
  98                               String licenseKeyGroupId,
  99                               String limitId,
 100                               String user) {
 101     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId, "limit Id",
 102         limitId);
 103
 104     MdcUtil.initMdc(LoggerServiceName.Update_LIMIT.toString());
 105
 106     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 107         (versionId), licenseKeyGroupId), user);
 108
 109     LimitEntity limitEntity =
 110         new MapLimitRequestDtoToLimitEntity()
 111             .applyMapping(request, LimitEntity.class);
 112     limitEntity.setEpLkgId(licenseKeyGroupId);
 113     limitEntity.setVendorLicenseModelId(vlmId);
 114     limitEntity.setId(limitId);
 115
 116     vendorLicenseManager.updateLimit(limitEntity, user);
 117
 118     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId, "limit Id",
 119         limitId);
 120
 121     return Response.ok().build();
 122   }
 123
 124   /**
 125    * Delete License Key Group.
 126    *
 127    * @param vlmId               the vlm id
 128    * @param licenseKeyGroupId   the license Key Group id
 129    * @param limitId             the limitId
 130    * @param user                the user
 131    * @return the response
 132    */
 133   public Response deleteLimit(String vlmId, String versionId, String licenseKeyGroupId,
 134                               String limitId, String user) {
 135     mdcDataDebugMessage.debugEntryMessage("VLM id, Verison Id, LKG id, Limit Id", vlmId, versionId,
 136         licenseKeyGroupId, limitId);
 137
 138     MdcUtil.initMdc(LoggerServiceName.Delete_LIMIT.toString());
 139     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 140               (versionId), licenseKeyGroupId), user);
 141
 142     LimitEntity limitInput = new LimitEntity();
 143     limitInput.setVendorLicenseModelId(vlmId);
 144     limitInput.setEpLkgId(licenseKeyGroupId);
 145     limitInput.setId(limitId);
 146     vendorLicenseManager.deleteLimit(limitInput, user);
 147
 148     mdcDataDebugMessage.debugExitMessage("VLM id, Verison Id, LKG id, Limit Id", vlmId, versionId,
 149         licenseKeyGroupId, limitId);
 150
 151     return Response.ok().build();
 152   }
 153
 154   @Override
 155   public Response getLimit( String vlmId, String versionId, String licenseKeyGroupId,
 156                             String limitId, String user) {
 157     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id, Limit Id", vlmId, licenseKeyGroupId,
 158         limitId);
 159
 160     MdcUtil.initMdc(LoggerServiceName.Get_LIMIT.toString());
 161     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 162         (versionId), licenseKeyGroupId), user);
 163     LimitEntity epInput = new LimitEntity();
 164     epInput.setVendorLicenseModelId(vlmId);
 165     epInput.setVersion(Version.valueOf(versionId));
 166     epInput.setEpLkgId(licenseKeyGroupId);
 167     epInput.setId(limitId);
 168     LimitEntity limit = vendorLicenseManager.getLimit(epInput, user);
 169
 170     LimitEntityDto entitlementPoolEntityDto = limit == null ? null :
 171         new MapLimitEntityToLimitDto()
 172             .applyMapping(limit, LimitEntityDto.class);
 173
 174     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id, Limit Id", vlmId, licenseKeyGroupId,
 175         limitId);
 176
 177     return Response.ok(entitlementPoolEntityDto).build();
 178   }
 179 }