gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.activityspec.be.impl;
  18
  19 import static org.openecomp.activityspec.api.rest.types.ActivitySpecAction.CERTIFY;
  20 import static org.openecomp.activityspec.api.rest.types.ActivitySpecAction.DELETE;
  21 import static org.openecomp.activityspec.api.rest.types.ActivitySpecAction.DEPRECATE;
  22 import static org.openecomp.activityspec.utils.ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND;
  23 import static org.openecomp.activityspec.utils.ActivitySpecConstant.INVALID_STATE;
  24 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  25 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deleted;
  26 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deprecated;
  27 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  28
  29 import java.util.Collection;
  30 import java.util.Collections;
  31 import java.util.EnumMap;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Objects;
  35 import java.util.function.Predicate;
  36 import org.openecomp.activityspec.api.rest.types.ActivitySpecAction;
  37 import org.openecomp.activityspec.be.ActivitySpecManager;
  38 import org.openecomp.activityspec.be.dao.ActivitySpecDao;
  39 import org.openecomp.activityspec.be.dao.types.ActivitySpecEntity;
  40 import org.openecomp.activityspec.be.datatypes.ItemType;
  41 import org.openecomp.activityspec.errors.ActivitySpecNotFoundException;
  42 import org.openecomp.activityspec.utils.ActivitySpecConstant;
  43 import org.openecomp.core.dao.UniqueValueDao;
  44 import org.openecomp.core.util.UniqueValueUtil;
  45 import org.openecomp.sdc.common.errors.CoreException;
  46 import org.openecomp.sdc.common.errors.ErrorCategory;
  47 import org.openecomp.sdc.common.errors.ErrorCode;
  48 import org.openecomp.sdc.common.errors.SdcRuntimeException;
  49 import org.openecomp.sdc.logging.api.Logger;
  50 import org.openecomp.sdc.logging.api.LoggerFactory;
  51 import org.openecomp.sdc.versioning.ItemManager;
  52 import org.openecomp.sdc.versioning.VersioningManager;
  53 import org.openecomp.sdc.versioning.dao.types.Version;
  54 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  55 import org.openecomp.sdc.versioning.types.Item;
  56 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  57
  58 public class ActivitySpecManagerImpl implements ActivitySpecManager {
  59
  60   private static final Map<VersionStatus, Transition> TRANSITIONS;
  61
  62   static {
  63     TRANSITIONS = new EnumMap<>(VersionStatus.class);
  64     TRANSITIONS.put(Certified, new Transition("Certify", Draft));
  65     TRANSITIONS.put(Deprecated, new Transition("Deprecate", Certified));
  66     TRANSITIONS.put(Deleted, new Transition("Delete", Deprecated));
  67   }
  68
  69   private final ItemManager itemManager;
  70   private final VersioningManager versioningManager;
  71   private final ActivitySpecDao activitySpecDao;
  72   private final UniqueValueUtil uniqueValueUtil;
  73   private static final String ACTIVITY_SPEC_NAME = "ActivitySpec.Name";
  74   private static final Logger LOGGER =
  75       LoggerFactory.getLogger(ActivitySpecManagerImpl.class);
  76
  77   public ActivitySpecManagerImpl(ItemManager itemManager,
  78                                  VersioningManager versioningManager,
  79                                  ActivitySpecDao activitySpecDao,
  80                                  UniqueValueDao uniqueValueDao) {
  81     this.itemManager = itemManager;
  82     this.versioningManager = versioningManager;
  83     this.activitySpecDao = activitySpecDao;
  84     this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
  85   }
  86
  87   @Override
  88   public ActivitySpecEntity createActivitySpec(ActivitySpecEntity activitySpecEntity) {
  89
  90     validateUniqueValue(activitySpecEntity);
  91
  92     Item item = getActivitySpecItem(activitySpecEntity);
  93     item = itemManager.create(item);
  94
  95     Version version = getActivitySpecVersion(activitySpecEntity);
  96     versioningManager.create(item.getId(), version, VersionCreationMethod.major);
  97
  98     enrichActivitySpec(item, version, activitySpecEntity);
  99     activitySpecDao.create(activitySpecEntity);
 100
 101     uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 102     return activitySpecEntity;
 103   }
 104
 105   private void validateUniqueValue(ActivitySpecEntity activitySpecEntity) {
 106     try {
 107       uniqueValueUtil.validateUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 108     } catch (CoreException exception) {
 109       LOGGER.debug("Unique value error for activity spec name :" + activitySpecEntity.getName(), exception);
 110       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 111           .withCategory(ErrorCategory.APPLICATION)
 112           .withId(exception.code().id())
 113           .withMessage("name already in use").build());
 114     }
 115   }
 116
 117   private Version getActivitySpecVersion(ActivitySpecEntity activitySpecEntity) {
 118     return activitySpecEntity.getVersion() == null ? new Version()
 119         : activitySpecEntity.getVersion();
 120
 121   }
 122
 123   @Override
 124   public ActivitySpecEntity get(ActivitySpecEntity activitySpec) {
 125     activitySpec.setVersion(calculateLatestVersion(activitySpec.getId(),activitySpec.getVersion()));
 126     ActivitySpecEntity retrieved;
 127     try {
 128       retrieved = activitySpecDao.get(activitySpec);
 129     } catch (SdcRuntimeException runtimeException) {
 130       LOGGER.debug("Failed to retrieve activity spec for activitySpecId: " + activitySpec.getId()
 131           + " and version: " + activitySpec.getVersion().getId(), runtimeException);
 132       throw new ActivitySpecNotFoundException(ACTIVITY_SPEC_NOT_FOUND, runtimeException);
 133     }
 134     if (retrieved != null) {
 135       final Version retrievedVersion = versioningManager.get(activitySpec.getId(),
 136           activitySpec.getVersion());
 137       retrieved.setStatus(Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus().name()
 138           : null);
 139     }
 140     return retrieved;
 141   }
 142
 143   @Override
 144   public void update(ActivitySpecEntity activitySpec) {
 145
 146     ActivitySpecEntity previousActivitySpec = get(activitySpec);
 147
 148     if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 149       validateUniqueValue(activitySpec);
 150     }
 151
 152     activitySpecDao.update(activitySpec);
 153
 154     if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 155       uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
 156       itemManager.updateName(activitySpec.getId(), activitySpec.getName());
 157       uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, previousActivitySpec.getName());
 158     }
 159   }
 160
 161   @Override
 162   public void actOnAction(String activitySpecId, String versionId, ActivitySpecAction action) {
 163     Version version = new Version(versionId);
 164     version = calculateLatestVersion(activitySpecId, version);
 165     if (action == CERTIFY) {
 166       version.setStatus(Certified);
 167     }
 168     if (action == DEPRECATE) {
 169       version.setStatus(Deprecated);
 170     }
 171     if (action == DELETE) {
 172       version.setStatus(Deleted);
 173     }
 174
 175     updateVersionStatus(activitySpecId, action, version);
 176     if (action == DELETE) {
 177       ActivitySpecEntity entity = new ActivitySpecEntity();
 178       entity.setId(activitySpecId);
 179       entity.setVersion(version);
 180       final ActivitySpecEntity activitySpecEntity = get(entity);
 181       uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 182     }
 183   }
 184
 185   private void updateVersionStatus(String activitySpecId, ActivitySpecAction action,
 186       Version version) {
 187     VersionStatus prevVersionStatus = null;
 188     Version retrievedVersion;
 189     try {
 190       retrievedVersion = versioningManager.get(activitySpecId, version);
 191     } catch (SdcRuntimeException exception) {
 192       LOGGER.debug("Failed to get version for activitySpecId: " + activitySpecId
 193               + " and version: " + version.getId(), exception);
 194       throw new ActivitySpecNotFoundException(ACTIVITY_SPEC_NOT_FOUND, exception);
 195
 196     }
 197
 198     VersionStatus status = version.getStatus();
 199     Transition transition = TRANSITIONS.get(status);
 200     if (transition != null) {
 201
 202       VersionStatus retrievedStatus = Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus() : null;
 203       if (retrievedStatus != transition.prevStatus) {
 204         LOGGER.debug("Failed to " + version.getStatus() + " since activity spec is in "
 205             + retrievedStatus);
 206         throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 207             .withMessage(INVALID_STATE).build());
 208       }
 209       prevVersionStatus = transition.prevStatus;
 210     }
 211
 212     if (Objects.nonNull(retrievedVersion)) {
 213       retrievedVersion.setStatus(status);
 214       versioningManager.updateVersion(activitySpecId, retrievedVersion);
 215       itemManager.updateVersionStatus(activitySpecId, status, prevVersionStatus);
 216       versioningManager.publish(activitySpecId, retrievedVersion, "actionOnActivitySpec :"
 217           + action.name());
 218     }
 219   }
 220
 221   private Version calculateLatestVersion(String activitySpecId, Version version) {
 222     if (ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE.equalsIgnoreCase(version.getId())) {
 223       List<Version> list;
 224       try {
 225         list = versioningManager.list(activitySpecId);
 226       } catch (SdcRuntimeException runtimeException) {
 227         LOGGER.debug("Failed to list versions for activitySpecId "
 228             + activitySpecId, runtimeException);
 229         throw new ActivitySpecNotFoundException(ACTIVITY_SPEC_NOT_FOUND, runtimeException);
 230       }
 231       if (Objects.nonNull(list) && !list.isEmpty()) {
 232         return list.get(0);
 233       }
 234     }
 235     return version;
 236   }
 237
 238   @Override
 239   public Collection<Item> list(String versionStatus) {
 240     Predicate<Item> itemPredicate;
 241     if (Objects.nonNull(versionStatus)) {
 242
 243       VersionStatus statusEnumValue;
 244
 245       try {
 246         statusEnumValue = VersionStatus.valueOf(versionStatus);
 247       } catch (IllegalArgumentException e) {
 248         LOGGER.debug("Unexpected value of VersionStatus {}", versionStatus);
 249         return Collections.emptyList();
 250       }
 251
 252       itemPredicate = item -> ItemType.ACTIVITYSPEC.name().equals(item.getType())
 253           && item.getVersionStatusCounters().containsKey(statusEnumValue);
 254
 255     } else {
 256       itemPredicate = item -> ItemType.ACTIVITYSPEC.name().equals(item.getType());
 257     }
 258
 259     return itemManager.list(itemPredicate);
 260   }
 261
 262   private void enrichActivitySpec(Item item, Version version,
 263                                   ActivitySpecEntity activitySpecEntity) {
 264     activitySpecEntity.setId(item.getId());
 265     activitySpecEntity.setVersion(version);
 266   }
 267
 268   private Item getActivitySpecItem(ActivitySpecEntity activitySpecEntity) {
 269     Item item = new Item();
 270     item.setType(ItemType.ACTIVITYSPEC.name());
 271     item.setName(activitySpecEntity.getName());
 272     if (activitySpecEntity.getId() != null) {
 273       item.setId(activitySpecEntity.getId());
 274     }
 275     item.addProperty(ActivitySpecConstant.CATEGORY_ATTRIBUTE_NAME,
 276         activitySpecEntity.getCategoryList());
 277     return item;
 278   }
 279
 280   private static class Transition {
 281
 282     private final String action;
 283     private final VersionStatus prevStatus;
 284
 285     private Transition(String action, VersionStatus prevStatus) {
 286       this.action = action;
 287       this.prevStatus = prevStatus;
 288     }
 289   }
 290
 291 }