gerrit.onap Code Review - sdc.git/blob

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