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