gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorlicense.dao.impl.zusammen;
   2
   3 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
   4 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
   5 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
   6 import com.amdocs.zusammen.datatypes.Id;
   7 import com.amdocs.zusammen.datatypes.SessionContext;
   8 import com.amdocs.zusammen.datatypes.item.Action;
   9 import com.amdocs.zusammen.datatypes.item.ElementContext;
  10 import com.amdocs.zusammen.datatypes.item.Info;
  11 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  12 import org.openecomp.core.zusammen.api.ZusammenUtil;
  13 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
  14 import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
  15 import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
  16 import org.openecomp.sdc.vendorlicense.dao.types.LimitType;
  17 import org.openecomp.sdc.versioning.dao.types.Version;
  18
  19 import java.util.Collection;
  20 import java.util.Collections;
  21 import java.util.Optional;
  22 import java.util.stream.Collectors;
  23
  24 public class LimitZusammenDaoImpl implements LimitDao {
  25
  26   public static final String LIMT_TYPE = "type";
  27   public static final String METRIC = "metric";
  28   public static final String AGGREGATIONFUNCTION = "aggregationfunction";
  29   public static final String TIME = "time";
  30   public static final String UNIT = "unit";
  31   public static final String VALUE = "value";
  32   private ZusammenAdaptor zusammenAdaptor;
  33
  34   public LimitZusammenDaoImpl(ZusammenAdaptor zusammenAdaptor) {
  35     this.zusammenAdaptor = zusammenAdaptor;
  36   }
  37
  38   @Override
  39   public void create(LimitEntity limitEntity) {
  40     ZusammenElement limitElement = limitToZusammen(limitEntity, Action.CREATE);
  41
  42     ZusammenElement limitsElement =
  43         VlmZusammenUtil.buildStructuralElement(StructureElement.Limits, null);
  44     limitsElement.setSubElements(Collections.singletonList(limitElement));
  45
  46     ZusammenElement epLkgElement =
  47         buildZusammenElement(new Id(limitEntity.getEpLkgId()), Action.IGNORE);
  48     epLkgElement.setSubElements(Collections.singletonList(limitsElement));
  49
  50     SessionContext context = ZusammenUtil.createSessionContext();
  51     Id itemId = new Id(limitEntity.getVendorLicenseModelId());
  52     ElementContext elementContext = new ElementContext(itemId,
  53         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
  54
  55     Optional<Element> savedElement =
  56         zusammenAdaptor.saveElement(context, elementContext, epLkgElement, "Create limit");
  57     savedElement.ifPresent(element ->
  58         limitEntity.setId(element.getSubElements().iterator().next()
  59             .getSubElements().iterator().next().getElementId().getValue()));
  60   }
  61
  62   @Override
  63   public boolean isLimitPresent(LimitEntity limitEntity) {
  64     SessionContext context = ZusammenUtil.createSessionContext();
  65     Id itemId = new Id(limitEntity.getVendorLicenseModelId());
  66     ElementContext elementContext = new ElementContext(itemId,
  67         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
  68         VlmZusammenUtil.getVersionTag(limitEntity.getVersion()));
  69
  70     Collection<ElementInfo> elementInfos = zusammenAdaptor.listElementsByName(context,
  71         elementContext, new Id(limitEntity.getEpLkgId()),StructureElement.Limits.name());
  72
  73     for (ElementInfo elementInfo : elementInfos) {
  74       if (elementInfo.getId().getValue().equals(limitEntity.getId())) {
  75         return true;
  76       }
  77     }
  78
  79     return false;
  80   }
  81
  82   @Override
  83   public Collection<LimitEntity> list(LimitEntity limitEntity) {
  84     SessionContext context = ZusammenUtil.createSessionContext();
  85     Id itemId = new Id(limitEntity.getVendorLicenseModelId());
  86     ElementContext elementContext = new ElementContext(itemId,
  87         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
  88         VlmZusammenUtil.getVersionTag(limitEntity.getVersion()));
  89
  90     return listLimits(context, elementContext, limitEntity);
  91   }
  92
  93   private Collection<LimitEntity> listLimits(SessionContext context, ElementContext elementContext,
  94                                            LimitEntity limitEntity) {
  95     return zusammenAdaptor
  96         .listElementsByName(context, elementContext, new Id(limitEntity.getEpLkgId()),
  97             StructureElement.Limits.name())
  98         .stream().map(elementInfo -> mapElementInfoToLimit(
  99             limitEntity.getVendorLicenseModelId(), limitEntity.getVersion(),
 100             limitEntity.getEpLkgId(), elementInfo))
 101         .collect(Collectors.toList());
 102   }
 103
 104   private LimitEntity mapElementInfoToLimit(String vlmId, Version version,
 105                                         String epLkgId, ElementInfo elementInfo) {
 106     LimitEntity limitEntity =
 107         new LimitEntity(vlmId, version, epLkgId, elementInfo.getId().getValue());
 108
 109     limitEntity.setName(elementInfo.getInfo().getName());
 110     limitEntity.setDescription(elementInfo.getInfo().getDescription());
 111     limitEntity.setType( elementInfo.getInfo().getProperties().get(LIMT_TYPE) != null ?
 112         LimitType.valueOf((String) elementInfo.getInfo().getProperties().get(LIMT_TYPE)) :
 113         null);
 114     limitEntity.setTime((String) elementInfo.getInfo().getProperties().get(TIME) );
 115     limitEntity.setMetric( (String) elementInfo.getInfo().getProperties().get(METRIC));
 116     limitEntity.setAggregationFunction( elementInfo.getInfo().getProperties().get
 117         (AGGREGATIONFUNCTION) != null ?
 118         AggregationFunction.valueOf((String) elementInfo.getInfo().getProperties()
 119             .get(AGGREGATIONFUNCTION)) : null);
 120     Object unit = elementInfo.getInfo().getProperties().get(UNIT);
 121     limitEntity.setUnit((String) unit);
 122     Object value = elementInfo.getInfo().getProperties().get(VALUE);
 123     limitEntity.setValue((String) value);
 124
 125     return limitEntity;
 126   }
 127
 128   @Override
 129   public void update(LimitEntity entity) {
 130     ZusammenElement limitElement = limitToZusammen(entity, Action.UPDATE);
 131
 132     SessionContext context = ZusammenUtil.createSessionContext();
 133     Id itemId = new Id(entity.getVendorLicenseModelId());
 134     ElementContext elementContext =  new ElementContext(itemId,
 135         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 136
 137     zusammenAdaptor.saveElement(context,elementContext, limitElement,
 138         String.format("Update limit with id %s", entity.getId()));
 139   }
 140
 141   @Override
 142   public LimitEntity get(LimitEntity limitEntity) {
 143     SessionContext context = ZusammenUtil.createSessionContext();
 144     Id itemId = new Id(limitEntity.getVendorLicenseModelId());
 145     ElementContext elementContext = new ElementContext(itemId,
 146         VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor),
 147         VlmZusammenUtil.getVersionTag(limitEntity.getVersion()));
 148
 149     return zusammenAdaptor.getElementInfo(context, elementContext, new Id(limitEntity.getId()))
 150         .map(elementInfo -> mapElementInfoToLimit(
 151             limitEntity.getVendorLicenseModelId(), limitEntity.getVersion(), limitEntity
 152                 .getEpLkgId(), elementInfo))
 153         .orElse(null);
 154   }
 155
 156   @Override
 157   public void delete(LimitEntity entity) {
 158     SessionContext context = ZusammenUtil.createSessionContext();
 159     ZusammenElement zusammenElement = new ZusammenElement();
 160     zusammenElement.setAction(Action.DELETE);
 161     zusammenElement.setElementId(new Id(entity.getId()));
 162
 163     Id itemId = new Id(entity.getVendorLicenseModelId());
 164     ElementContext elementContext =
 165             new ElementContext(itemId,
 166                     VlmZusammenUtil.getFirstVersionId(context, itemId, zusammenAdaptor));
 167     zusammenAdaptor.saveElement(context, elementContext, zusammenElement,
 168             "delete limit Id:" + entity.getId() + ".");
 169   }
 170
 171   @Override
 172   public void registerVersioning(String versionableEntityType) {
 173
 174   }
 175
 176   private ZusammenElement limitToZusammen(LimitEntity limit,
 177                                                      Action action) {
 178     ZusammenElement limitElement = buildLimitElement(limit, action);
 179     return limitElement;
 180   }
 181
 182   private ZusammenElement buildLimitElement(LimitEntity limit,
 183                                                        Action action) {
 184     ZusammenElement limitElement = new ZusammenElement();
 185     limitElement.setAction(action);
 186     if (limit.getId() != null) {
 187       limitElement.setElementId(new Id(limit.getId()));
 188     }
 189
 190     Info info = new Info();
 191     info.setName(limit.getName());
 192     info.setDescription(limit.getDescription());
 193     info.addProperty(LIMT_TYPE, limit.getType());
 194     info.addProperty(METRIC, limit.getMetric());
 195     info.addProperty(AGGREGATIONFUNCTION, limit.getAggregationFunction());
 196     info.addProperty(TIME, limit.getTime());
 197     info.addProperty(VALUE, limit.getValue());
 198     info.addProperty(UNIT, limit.getUnit());
 199     limitElement.setInfo(info);
 200     return limitElement;
 201   }
 202
 203   private ZusammenElement buildZusammenElement(Id elementId, Action action) {
 204     ZusammenElement element = new ZusammenElement();
 205     element.setElementId(elementId);
 206     element.setAction(action);
 207     return element;
 208   }
 209 }