services/activity-spec/activity-spec-web/activity-spec-service/src/main/java/org/onap/sdc/activityspec/be/impl/ActivitySpecManagerImpl.java

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