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.sdc.versioning.dao.types.VersionStatus.Certified;
  23 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deleted;
  24 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deprecated;
  25 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  26
  27 import java.util.Collection;
  28 import java.util.Collections;
  29 import java.util.EnumMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Objects;
  33 import java.util.function.Predicate;
  34 import org.openecomp.activityspec.api.rest.types.ActivitySpecAction;
  35 import org.openecomp.activityspec.be.ActivitySpecManager;
  36 import org.openecomp.activityspec.be.dao.ActivitySpecDao;
  37 import org.openecomp.activityspec.be.dao.types.ActivitySpecEntity;
  38 import org.openecomp.activityspec.be.datatypes.ItemType;
  39 import org.openecomp.activityspec.utils.ActivitySpecConstant;
  40 import org.openecomp.core.dao.UniqueValueDao;
  41 import org.openecomp.core.util.UniqueValueUtil;
  42 import org.openecomp.sdc.common.errors.CoreException;
  43 import org.openecomp.sdc.common.errors.ErrorCategory;
  44 import org.openecomp.sdc.common.errors.ErrorCode;
  45 import org.openecomp.sdc.common.errors.SdcRuntimeException;
  46 import org.openecomp.sdc.logging.api.Logger;
  47 import org.openecomp.sdc.logging.api.LoggerFactory;
  48 import org.openecomp.sdc.versioning.ItemManager;
  49 import org.openecomp.sdc.versioning.VersioningManager;
  50 import org.openecomp.sdc.versioning.dao.types.Version;
  51 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  52 import org.openecomp.sdc.versioning.types.Item;
  53 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  54
  55 public class ActivitySpecManagerImpl implements ActivitySpecManager {
  56
  57   private static final Map<VersionStatus, Transition> TRANSITIONS;
  58
  59   static {
  60     TRANSITIONS = new EnumMap<>(VersionStatus.class);
  61     TRANSITIONS.put(Certified, new Transition("Certify", Draft));
  62     TRANSITIONS.put(Deprecated, new Transition("Deprecate", Certified));
  63     TRANSITIONS.put(Deleted, new Transition("Delete", Deprecated));
  64   }
  65
  66   private final ItemManager itemManager;
  67   private final VersioningManager versioningManager;
  68   private final ActivitySpecDao activitySpecDao;
  69   private final UniqueValueUtil uniqueValueUtil;
  70   private static final String ACTIVITY_SPEC_NAME = "ActivitySpec.Name";
  71   private static final Logger LOGGER =
  72       LoggerFactory.getLogger(ActivitySpecManagerImpl.class);
  73
  74   public ActivitySpecManagerImpl(ItemManager itemManager,
  75                                  VersioningManager versioningManager,
  76                                  ActivitySpecDao activitySpecDao,
  77                                  UniqueValueDao uniqueValueDao) {
  78     this.itemManager = itemManager;
  79     this.versioningManager = versioningManager;
  80     this.activitySpecDao = activitySpecDao;
  81     this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
  82   }
  83
  84   @Override
  85   public ActivitySpecEntity createActivitySpec(ActivitySpecEntity activitySpecEntity) {
  86
  87     uniqueValueUtil.validateUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
  88
  89     Item item = getActivitySpecItem(activitySpecEntity);
  90     item = itemManager.create(item);
  91
  92     Version version = getActivitySpecVersion(activitySpecEntity);
  93     versioningManager.create(item.getId(), version, VersionCreationMethod.major);
  94
  95     enrichActivitySpec(item, version, activitySpecEntity);
  96     activitySpecDao.create(activitySpecEntity);
  97
  98     uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
  99     return activitySpecEntity;
 100   }
 101
 102   private Version getActivitySpecVersion(ActivitySpecEntity activitySpecEntity) {
 103     return activitySpecEntity.getVersion() == null ? new Version()
 104         : activitySpecEntity.getVersion();
 105
 106   }
 107
 108   @Override
 109   public ActivitySpecEntity get(ActivitySpecEntity activitySpec) {
 110     activitySpec.setVersion(calculateLatestVersion(activitySpec.getId(),activitySpec.getVersion()
 111         ));
 112     ActivitySpecEntity retrieved = null;
 113     try {
 114       retrieved = activitySpecDao.get(activitySpec);
 115     } catch (SdcRuntimeException runtimeException) {
 116       LOGGER.error("Failed to retrieve activity spec for activitySpecId: " + activitySpec.getId() + " and version: "
 117           + activitySpec.getVersion().getId(), runtimeException);
 118       validateActivitySpecExistence(activitySpec.getId(), activitySpec.getVersion());
 119     }
 120     if (retrieved != null) {
 121       final Version retrievedVersion = versioningManager.get(activitySpec.getId(),
 122           activitySpec.getVersion());
 123       retrieved.setStatus(Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus().name()
 124           : null);
 125     }
 126     return retrieved;
 127   }
 128
 129   @Override
 130   public void update(ActivitySpecEntity activitySpec) {
 131
 132     ActivitySpecEntity previousActivitySpec = get(activitySpec);
 133
 134     if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 135       uniqueValueUtil.validateUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
 136     }
 137
 138     activitySpecDao.update(activitySpec);
 139
 140     if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 141       uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
 142       itemManager.updateName(activitySpec.getId(), activitySpec.getName());
 143       uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, previousActivitySpec.getName());
 144     }
 145   }
 146
 147   @Override
 148   public void actOnAction(String activitySpecId, String versionId, ActivitySpecAction action) {
 149     Version version = new Version(versionId);
 150     version = calculateLatestVersion(activitySpecId, version);
 151     if (action == CERTIFY) {
 152       version.setStatus(Certified);
 153     }
 154     if (action == DEPRECATE) {
 155       version.setStatus(Deprecated);
 156     }
 157     if (action == DELETE) {
 158       version.setStatus(Deleted);
 159     }
 160
 161     updateVersionStatus(activitySpecId, action, version);
 162     if (action == DELETE) {
 163       ActivitySpecEntity entity = new ActivitySpecEntity();
 164       entity.setId(activitySpecId);
 165       entity.setVersion(version);
 166       final ActivitySpecEntity activitySpecEntity = get(entity);
 167       uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 168     }
 169   }
 170
 171   private void updateVersionStatus(String activitySpecId, ActivitySpecAction action,
 172       Version version) {
 173     VersionStatus prevVersionStatus = null;
 174     Version retrievedVersion = null;
 175     try {
 176       retrievedVersion = versioningManager.get(activitySpecId, version);
 177     } catch (SdcRuntimeException exception) {
 178       LOGGER.error("Failed to get version for activitySpecId: " + activitySpecId + " and version: " + version.getId(),
 179           exception);
 180       validateActivitySpecExistence(activitySpecId, version);
 181
 182     }
 183
 184     VersionStatus status = version.getStatus();
 185     Transition transition = TRANSITIONS.get(status);
 186     if (transition != null) {
 187       String errMsg = String.format("%s ActivitySpec With Id %s failed since it is not in %s status",
 188           transition.action, activitySpecId, transition.prevStatus);
 189       validateStatus(Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus() : null,
 190           transition.prevStatus, errMsg);
 191       prevVersionStatus = transition.prevStatus;
 192     }
 193
 194     if (Objects.nonNull(retrievedVersion)) {
 195       retrievedVersion.setStatus(status);
 196       versioningManager.updateVersion(activitySpecId, retrievedVersion);
 197       itemManager.updateVersionStatus(activitySpecId, status, prevVersionStatus);
 198       versioningManager.publish(activitySpecId, retrievedVersion, "actionOnActivitySpec :"
 199           + action.name());
 200     }
 201   }
 202
 203   private void validateActivitySpecExistence(String activitySpecId, Version version) {
 204     throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 205         .withCategory(ErrorCategory.APPLICATION)
 206         .withId("ACTIVITYSPEC_NOT_FOUND")
 207         .withMessage(String.format("Activity Spec With Id %s and version %s not found",
 208             activitySpecId, version.getId()))
 209         .build());
 210   }
 211
 212   private void validateStatus(VersionStatus retrievedVersionStatus,
 213       VersionStatus expectedVersionStatus, String errorMessage) {
 214     if (retrievedVersionStatus != expectedVersionStatus) {
 215       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 216           .withCategory(ErrorCategory.APPLICATION)
 217           .withId("STATUS_NOT_" + expectedVersionStatus.name().toUpperCase())
 218           .withMessage(errorMessage).build());
 219     }
 220   }
 221
 222   private Version calculateLatestVersion(String activitySpecId, Version version) {
 223     if (ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE.equalsIgnoreCase(version.getId())) {
 224       List<Version> list = null;
 225       try {
 226         list = versioningManager.list(activitySpecId);
 227       } catch (SdcRuntimeException runtimeException) {
 228         LOGGER.error("Failed to list versions for activitySpecId " + activitySpecId, runtimeException);
 229         validateActivitySpecExistence(activitySpecId, version);
 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 }