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   public static final String parent = "LicenseKeyGroup";
  38
  39   @Override
  40   public Response createLimit(LimitRequestDto request,
  41                               String vlmId,
  42                               String versionId,
  43                               String licenseKeyGroupId,
  44                               String user) {
  45
  46     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  47
  48     MdcUtil.initMdc(LoggerServiceName.Create_LIMIT.toString());
  49     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
  50             (versionId), licenseKeyGroupId), user);
  51
  52     LimitEntity limitEntity =
  53             new MapLimitRequestDtoToLimitEntity()
  54                     .applyMapping(request, LimitEntity.class);
  55     limitEntity.setEpLkgId(licenseKeyGroupId);
  56     limitEntity.setVendorLicenseModelId(vlmId);
  57     limitEntity.setParent(parent);
  58
  59     LimitEntity createdLimit = vendorLicenseManager.createLimit(limitEntity, user);
  60     MapLimitEntityToLimitCreationDto mapper = new MapLimitEntityToLimitCreationDto();
  61     LimitCreationDto createdLimitDto = mapper.applyMapping(createdLimit, LimitCreationDto
  62             .class);
  63     /*StringWrapperResponse result =
  64         createdLimit != null ? new StringWrapperResponse(createdLimit.getId())
  65             : null;*/
  66
  67     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  68
  69     //return Response.ok(result).build();
  70     return Response.ok(createdLimitDto != null ? createdLimitDto : null)
  71             .build();
  72   }
  73
  74   @Override
  75   public Response listLimits(String vlmId, String versionId, String licenseKeyGroupId, String
  76           user) {
  77     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  78
  79     MdcUtil.initMdc(LoggerServiceName.List_EP.toString());
  80     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
  81             (versionId), licenseKeyGroupId), user);
  82
  83     Collection<LimitEntity> limits =
  84             vendorLicenseManager.listLimits(vlmId, Version.valueOf(versionId), licenseKeyGroupId, user);
  85
  86     GenericCollectionWrapper<LimitEntityDto> result = new GenericCollectionWrapper<>();
  87     MapLimitEntityToLimitDto outputMapper =
  88             new MapLimitEntityToLimitDto();
  89     for (LimitEntity limit : limits) {
  90       result.add(outputMapper.applyMapping(limit, LimitEntityDto.class));
  91     }
  92
  93     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId);
  94
  95     return Response.ok(result).build();
  96   }
  97
  98   @Override
  99   public Response updateLimit(LimitRequestDto request,
 100                               String vlmId,
 101                               String versionId,
 102                               String licenseKeyGroupId,
 103                               String limitId,
 104                               String user) {
 105     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId, "limit Id",
 106             limitId);
 107
 108     MdcUtil.initMdc(LoggerServiceName.Update_LIMIT.toString());
 109
 110     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 111             (versionId), licenseKeyGroupId), user);
 112
 113     LimitEntity limitEntity =
 114             new MapLimitRequestDtoToLimitEntity()
 115                     .applyMapping(request, LimitEntity.class);
 116     limitEntity.setEpLkgId(licenseKeyGroupId);
 117     limitEntity.setVendorLicenseModelId(vlmId);
 118     limitEntity.setId(limitId);
 119     limitEntity.setParent(parent);
 120
 121     vendorLicenseManager.updateLimit(limitEntity, user);
 122
 123     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "LKG id", licenseKeyGroupId, "limit Id",
 124             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
 143     MdcUtil.initMdc(LoggerServiceName.Delete_LIMIT.toString());
 144     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 145             (versionId), licenseKeyGroupId), user);
 146
 147     LimitEntity limitInput = new LimitEntity();
 148     limitInput.setVendorLicenseModelId(vlmId);
 149     limitInput.setEpLkgId(licenseKeyGroupId);
 150     limitInput.setId(limitId);
 151     limitInput.setParent(parent);
 152
 153     vendorLicenseManager.deleteLimit(limitInput, user);
 154
 155     mdcDataDebugMessage.debugExitMessage("VLM id, Verison Id, LKG id, Limit Id", vlmId, versionId,
 156             licenseKeyGroupId, limitId);
 157
 158     return Response.ok().build();
 159   }
 160
 161   @Override
 162   public Response getLimit( String vlmId, String versionId, String licenseKeyGroupId,
 163                             String limitId, String user) {
 164     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id, Limit Id", vlmId, licenseKeyGroupId,
 165             limitId);
 166
 167     MdcUtil.initMdc(LoggerServiceName.Get_LIMIT.toString());
 168     vendorLicenseManager.getLicenseKeyGroup(new LicenseKeyGroupEntity(vlmId, Version.valueOf
 169             (versionId), licenseKeyGroupId), user);
 170     LimitEntity epInput = new LimitEntity();
 171     epInput.setVendorLicenseModelId(vlmId);
 172     epInput.setVersion(Version.valueOf(versionId));
 173     epInput.setEpLkgId(licenseKeyGroupId);
 174     epInput.setId(limitId);
 175     LimitEntity limit = vendorLicenseManager.getLimit(epInput, user);
 176
 177     LimitEntityDto entitlementPoolEntityDto = limit == null ? null :
 178             new MapLimitEntityToLimitDto()
 179                     .applyMapping(limit, LimitEntityDto.class);
 180
 181     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id, Limit Id", vlmId, licenseKeyGroupId,
 182             limitId);
 183
 184     return Response.ok(entitlementPoolEntityDto).build();
 185   }
 186 }