gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 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.onap.sdc.activityspec.be.impl;
  18
  19 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  20 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deleted;
  21 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Deprecated;
  22 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  23
  24 import java.util.Collection;
  25 import java.util.Collections;
  26 import java.util.EnumMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Objects;
  30 import java.util.function.Predicate;
  31
  32 import org.onap.sdc.activityspec.api.rest.types.ActivitySpecAction;
  33 import org.onap.sdc.activityspec.be.dao.ActivitySpecDao;
  34 import org.onap.sdc.activityspec.utils.ActivitySpecConstant;
  35 import org.onap.sdc.activityspec.be.ActivitySpecManager;
  36 import org.onap.sdc.activityspec.be.dao.types.ActivitySpecEntity;
  37 import org.onap.sdc.activityspec.be.datatypes.ItemType;
  38 import org.onap.sdc.activityspec.errors.ActivitySpecNotFoundException;
  39 import org.openecomp.core.dao.UniqueValueDao;
  40 import org.openecomp.core.util.UniqueValueUtil;
  41 import org.openecomp.sdc.common.errors.CoreException;
  42 import org.openecomp.sdc.common.errors.ErrorCategory;
  43 import org.openecomp.sdc.common.errors.ErrorCode;
  44 import org.openecomp.sdc.common.errors.SdcRuntimeException;
  45 import org.openecomp.sdc.logging.api.Logger;
  46 import org.openecomp.sdc.logging.api.LoggerFactory;
  47 import org.openecomp.sdc.versioning.ItemManager;
  48 import org.openecomp.sdc.versioning.VersioningManager;
  49 import org.openecomp.sdc.versioning.dao.types.Version;
  50 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  51 import org.openecomp.sdc.versioning.types.Item;
  52 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  53
  54 public class ActivitySpecManagerImpl implements ActivitySpecManager {
  55
  56     private static final Map<VersionStatus, VersionStatus> EXPECTED_PREV_STATUS;
  57
  58     static {
  59         EXPECTED_PREV_STATUS = new EnumMap<>(VersionStatus.class);
  60         EXPECTED_PREV_STATUS.put(Certified, Draft);
  61         EXPECTED_PREV_STATUS.put(Deprecated, Certified);
  62         EXPECTED_PREV_STATUS.put(Deleted, Deprecated);
  63     }
  64
  65     private final ItemManager itemManager;
  66     private final VersioningManager versioningManager;
  67     private final ActivitySpecDao activitySpecDao;
  68     private final UniqueValueUtil uniqueValueUtil;
  69     private static final String ACTIVITY_SPEC_NAME = "ActivitySpec.Name";
  70     private static final Logger LOGGER = LoggerFactory.getLogger(ActivitySpecManagerImpl.class);
  71
  72     public ActivitySpecManagerImpl(ItemManager itemManager, VersioningManager versioningManager,
  73                                           ActivitySpecDao activitySpecDao, UniqueValueDao uniqueValueDao) {
  74         this.itemManager = itemManager;
  75         this.versioningManager = versioningManager;
  76         this.activitySpecDao = activitySpecDao;
  77         this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
  78     }
  79
  80     @Override
  81     public ActivitySpecEntity createActivitySpec(ActivitySpecEntity activitySpecEntity) {
  82
  83         validateUniqueValue(activitySpecEntity);
  84
  85         Item item = getActivitySpecItem(activitySpecEntity);
  86         item = itemManager.create(item);
  87
  88         Version version = getActivitySpecVersion(activitySpecEntity);
  89         versioningManager.create(item.getId(), version, VersionCreationMethod.major);
  90
  91         enrichActivitySpec(item, version, activitySpecEntity);
  92         activitySpecDao.create(activitySpecEntity);
  93
  94         uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
  95         return activitySpecEntity;
  96     }
  97
  98     private void validateUniqueValue(ActivitySpecEntity activitySpecEntity) {
  99         try {
 100             uniqueValueUtil.validateUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 101         } catch (CoreException exception) {
 102             LOGGER.debug("Unique value error for activity spec name :" + activitySpecEntity.getName(), exception);
 103             throw new CoreException(new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 104                                                                     .withId(exception.code().id())
 105                                                                     .withMessage("name already in use").build());
 106         }
 107     }
 108
 109     private Version getActivitySpecVersion(ActivitySpecEntity activitySpecEntity) {
 110         return activitySpecEntity.getVersion() == null ? new Version() : activitySpecEntity.getVersion();
 111
 112     }
 113
 114     @Override
 115     public ActivitySpecEntity get(ActivitySpecEntity activitySpec) {
 116         activitySpec.setVersion(calculateLatestVersion(activitySpec.getId(), activitySpec.getVersion()));
 117         ActivitySpecEntity retrieved;
 118         try {
 119             retrieved = activitySpecDao.get(activitySpec);
 120         } catch (SdcRuntimeException runtimeException) {
 121             LOGGER.debug(
 122                     "Failed to retrieve activity spec for activitySpecId: " + activitySpec.getId() + " and version: "
 123                             + activitySpec.getVersion().getId(), runtimeException);
 124             throw new ActivitySpecNotFoundException(ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND, runtimeException);
 125         }
 126         if (retrieved != null) {
 127             final Version retrievedVersion = versioningManager.get(activitySpec.getId(), activitySpec.getVersion());
 128             retrieved.setStatus(Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus().name() : null);
 129         }
 130         return retrieved;
 131     }
 132
 133     @Override
 134     public void update(ActivitySpecEntity activitySpec) {
 135
 136         ActivitySpecEntity previousActivitySpec = get(activitySpec);
 137
 138         if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 139             validateUniqueValue(activitySpec);
 140         }
 141
 142         activitySpecDao.update(activitySpec);
 143
 144         if (!activitySpec.getName().equals(previousActivitySpec.getName())) {
 145             uniqueValueUtil.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
 146             itemManager.updateName(activitySpec.getId(), activitySpec.getName());
 147             uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, previousActivitySpec.getName());
 148         }
 149     }
 150
 151     @Override
 152     public void actOnAction(String activitySpecId, String versionId, ActivitySpecAction action) {
 153         Version version = new Version(versionId);
 154         version = calculateLatestVersion(activitySpecId, version);
 155         if (action == ActivitySpecAction.CERTIFY) {
 156             version.setStatus(Certified);
 157         }
 158         if (action == ActivitySpecAction.DEPRECATE) {
 159             version.setStatus(Deprecated);
 160         }
 161         if (action == ActivitySpecAction.DELETE) {
 162             version.setStatus(Deleted);
 163         }
 164
 165         updateVersionStatus(activitySpecId, action, version);
 166         if (action == ActivitySpecAction.DELETE) {
 167             ActivitySpecEntity entity = new ActivitySpecEntity();
 168             entity.setId(activitySpecId);
 169             entity.setVersion(version);
 170             final ActivitySpecEntity activitySpecEntity = get(entity);
 171             uniqueValueUtil.deleteUniqueValue(ACTIVITY_SPEC_NAME, activitySpecEntity.getName());
 172         }
 173     }
 174
 175     private void updateVersionStatus(String activitySpecId, ActivitySpecAction action, Version version) {
 176         VersionStatus prevVersionStatus = null;
 177         Version retrievedVersion;
 178         try {
 179             retrievedVersion = versioningManager.get(activitySpecId, version);
 180         } catch (SdcRuntimeException exception) {
 181             LOGGER.debug(
 182                     "Failed to get version for activitySpecId: " + activitySpecId + " and version: " + version.getId(),
 183                     exception);
 184             throw new ActivitySpecNotFoundException(ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND, exception);
 185
 186         }
 187
 188         VersionStatus status = version.getStatus();
 189         VersionStatus expectedPrevStatus = EXPECTED_PREV_STATUS.get(status);
 190         if (expectedPrevStatus != null) {
 191
 192             VersionStatus retrievedStatus = Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus() : null;
 193             if (retrievedStatus != expectedPrevStatus) {
 194                 LOGGER.debug("Failed to " + version.getStatus() + " since activity spec is in " + retrievedStatus);
 195                 throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage(ActivitySpecConstant.INVALID_STATE)
 196                                                                         .build());
 197             }
 198             prevVersionStatus = expectedPrevStatus;
 199         }
 200
 201         if (Objects.nonNull(retrievedVersion)) {
 202             retrievedVersion.setStatus(status);
 203             versioningManager.updateVersion(activitySpecId, retrievedVersion);
 204             itemManager.updateVersionStatus(activitySpecId, status, prevVersionStatus);
 205             versioningManager.publish(activitySpecId, retrievedVersion, "actionOnActivitySpec :" + action.name());
 206         }
 207     }
 208
 209     private Version calculateLatestVersion(String activitySpecId, Version version) {
 210         if (ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE.equalsIgnoreCase(version.getId())) {
 211             List<Version> list;
 212             try {
 213                 list = versioningManager.list(activitySpecId);
 214             } catch (SdcRuntimeException runtimeException) {
 215                 LOGGER.debug("Failed to list versions for activitySpecId " + activitySpecId, runtimeException);
 216                 throw new ActivitySpecNotFoundException(ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND, runtimeException);
 217             }
 218             if (Objects.nonNull(list) && !list.isEmpty()) {
 219                 return list.get(0);
 220             }
 221         }
 222         return version;
 223     }
 224
 225     @Override
 226     public Collection<Item> list(String versionStatus) {
 227         Predicate<Item> itemPredicate;
 228         if (Objects.nonNull(versionStatus)) {
 229
 230             VersionStatus statusEnumValue;
 231
 232             try {
 233                 statusEnumValue = VersionStatus.valueOf(versionStatus);
 234             } catch (IllegalArgumentException e) {
 235                 LOGGER.debug("Unexpected value of VersionStatus {}", versionStatus);
 236                 return Collections.emptyList();
 237             }
 238
 239             itemPredicate =
 240                     item -> ItemType.ACTIVITYSPEC.name().equals(item.getType()) && item.getVersionStatusCounters()
 241                                                                                        .containsKey(statusEnumValue);
 242
 243         } else {
 244             itemPredicate = item -> ItemType.ACTIVITYSPEC.name().equals(item.getType());
 245         }
 246
 247         return itemManager.list(itemPredicate);
 248     }
 249
 250     private void enrichActivitySpec(Item item, Version version, ActivitySpecEntity activitySpecEntity) {
 251         activitySpecEntity.setId(item.getId());
 252         activitySpecEntity.setVersion(version);
 253     }
 254
 255     private Item getActivitySpecItem(ActivitySpecEntity activitySpecEntity) {
 256         Item item = new Item();
 257         item.setType(ItemType.ACTIVITYSPEC.name());
 258         item.setName(activitySpecEntity.getName());
 259         if (activitySpecEntity.getId() != null) {
 260             item.setId(activitySpecEntity.getId());
 261         }
 262         item.addProperty(ActivitySpecConstant.CATEGORY_ATTRIBUTE_NAME, activitySpecEntity.getCategoryList());
 263         return item;
 264     }
 265 }