workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/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.workflow.services.impl;
  18
  19 import static org.onap.sdc.common.versioning.services.types.VersionStatus.Certified;
  20 import static org.onap.sdc.common.versioning.services.types.VersionStatus.Deleted;
  21 import static org.onap.sdc.common.versioning.services.types.VersionStatus.Deprecated;
  22 import static org.onap.sdc.common.versioning.services.types.VersionStatus.Draft;
  23 import static org.onap.sdc.workflow.services.ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND;
  24 import static org.onap.sdc.workflow.services.ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE;
  25
  26 import java.util.Collection;
  27 import java.util.Collections;
  28 import java.util.Comparator;
  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 java.util.stream.Collectors;
  35 import org.onap.sdc.common.versioning.services.ItemManager;
  36 import org.onap.sdc.common.versioning.services.VersioningManager;
  37 import org.onap.sdc.common.versioning.services.types.Item;
  38 import org.onap.sdc.common.versioning.services.types.Version;
  39 import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
  40 import org.onap.sdc.common.versioning.services.types.VersionStatus;
  41 import org.onap.sdc.workflow.api.types.activityspec.ActivitySpecAction;
  42 import org.onap.sdc.workflow.persistence.ActivitySpecRepository;
  43 import org.onap.sdc.workflow.persistence.types.ActivitySpecEntity;
  44 import org.onap.sdc.workflow.services.ActivitySpecManager;
  45 import org.onap.sdc.workflow.services.UniqueValueService;
  46 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  47 import org.onap.sdc.workflow.services.exceptions.VersionStatusModificationException;
  48 import org.onap.sdc.workflow.services.impl.mappers.ActivitySpecMapper;
  49 import org.openecomp.sdc.logging.api.Logger;
  50 import org.openecomp.sdc.logging.api.LoggerFactory;
  51 import org.springframework.beans.factory.annotation.Autowired;
  52 import org.springframework.beans.factory.annotation.Qualifier;
  53 import org.springframework.stereotype.Service;
  54
  55 @Service("activitySpecManager")
  56 public class ActivitySpecManagerImpl implements ActivitySpecManager {
  57
  58     private static final String ACTIVITY_SPEC_NAME = "ActivitySpec.Name";
  59     private static final Logger LOGGER = LoggerFactory.getLogger(ActivitySpecManagerImpl.class);
  60     private static final Map<VersionStatus, VersionStatus> EXPECTED_PREV_STATUS;
  61
  62     static {
  63         EXPECTED_PREV_STATUS = new EnumMap<>(VersionStatus.class);
  64         EXPECTED_PREV_STATUS.put(Certified, Draft);
  65         EXPECTED_PREV_STATUS.put(Deprecated, Certified);
  66         EXPECTED_PREV_STATUS.put(Deleted, Deprecated);
  67     }
  68
  69     private final ItemManager itemManager;
  70     private final VersioningManager versioningManager;
  71     private final ActivitySpecRepository activitySpecDao;
  72     private final UniqueValueService uniqueValueService;
  73     private final ActivitySpecMapper activitySpecMapper;
  74
  75
  76     @Autowired
  77     public ActivitySpecManagerImpl(ItemManager itemManager, VersioningManager versioningManager,
  78             ActivitySpecRepository activitySpecDao,
  79             @Qualifier("uniqueValueService") UniqueValueService uniqueValueService,
  80             ActivitySpecMapper activitySpecMapper) {
  81         this.itemManager = itemManager;
  82         this.versioningManager = versioningManager;
  83         this.activitySpecDao = activitySpecDao;
  84         this.uniqueValueService = uniqueValueService;
  85         this.activitySpecMapper = activitySpecMapper;
  86     }
  87
  88     @Override
  89     public ActivitySpecEntity createActivitySpec(ActivitySpecEntity activitySpec) {
  90
  91         uniqueValueService.validateUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
  92
  93         Item item = new Item();
  94         activitySpecMapper.toItem(activitySpec, item);
  95         Item createdItem = itemManager.create(item);
  96
  97         Version createdVersion =
  98                 versioningManager.create(createdItem.getId(), null, new Version(), VersionCreationMethod.major);
  99
 100         activitySpec.setId(createdItem.getId());
 101         activitySpec.setVersionId(createdVersion.getId());
 102         activitySpecDao.create(activitySpec);
 103
 104         uniqueValueService.createUniqueValue(ACTIVITY_SPEC_NAME, activitySpec.getName());
 105         return activitySpec;
 106     }
 107
 108     @Override
 109     public ActivitySpecEntity get(ActivitySpecEntity activitySpec) {
 110         activitySpec.setVersionId(calculateLatestVersion(activitySpec));
 111         ActivitySpecEntity retrieved;
 112         try {
 113
 114             retrieved = activitySpecDao.get(activitySpec);
 115         } catch (RuntimeException e) {
 116             LOGGER.error("Failed to retrieve activity spec for activitySpecId: {} and version: {}",
 117                     activitySpec.getId(), activitySpec.getVersionId(), e);
 118             throw new EntityNotFoundException(ACTIVITY_SPEC_NOT_FOUND);
 119         }
 120         if (retrieved != null) {
 121             final Version retrievedVersion = versioningManager.get(activitySpec.getId(), activitySpec.getVersionId());
 122             retrieved.setStatus(Objects.nonNull(retrievedVersion) ? retrievedVersion.getStatus().name() : null);
 123         }
 124         return retrieved;
 125     }
 126
 127     @Override
 128     public void update(ActivitySpecEntity activitySpec) {
 129         Item item = itemManager.get(activitySpec.getId());
 130         if (item == null) {
 131             LOGGER.error("Activity Spec with id {} was not found", activitySpec.getId());
 132             throw new EntityNotFoundException(ACTIVITY_SPEC_NOT_FOUND);
 133         }
 134         uniqueValueService.updateUniqueValue(ACTIVITY_SPEC_NAME, item.getName(), activitySpec.getName());
 135
 136         activitySpecMapper.toItem(activitySpec, item);
 137         itemManager.update(activitySpec.getId(), item);
 138
 139         activitySpec.setVersionId(calculateLatestVersion(activitySpec));
 140         activitySpecDao.update(activitySpec);
 141     }
 142
 143     @Override
 144     public void actOnAction(ActivitySpecEntity activitySpec, ActivitySpecAction action) {
 145         VersionStatus newStatus = getVersionStatusByAction(action);
 146
 147         String versionId = calculateLatestVersion(activitySpec);
 148         Version retrievedVersion;
 149         try {
 150             retrievedVersion = versioningManager.get(activitySpec.getId(), versionId);
 151         } catch (RuntimeException e) {
 152             LOGGER.error("failed to get activity {}, version {}", activitySpec.getId(), versionId, e);
 153             throw new EntityNotFoundException(ACTIVITY_SPEC_NOT_FOUND);
 154         }
 155         if (retrievedVersion == null) {
 156             throw new EntityNotFoundException(ACTIVITY_SPEC_NOT_FOUND);
 157         }
 158
 159         VersionStatus retrievedStatus = retrievedVersion.getStatus();
 160         VersionStatus expectedPrevStatus = EXPECTED_PREV_STATUS.get(newStatus);
 161         if (expectedPrevStatus != null && retrievedStatus != expectedPrevStatus) {
 162             LOGGER.debug("Failed to {} since activity spec is in status {}", action.name(), retrievedStatus);
 163             throw new VersionStatusModificationException(activitySpec.getId(), versionId, retrievedStatus,
 164                     newStatus);
 165         }
 166
 167         versioningManager.updateStatus(activitySpec.getId(), retrievedVersion.getId(), newStatus,
 168                 "actionOnActivitySpec :" + action.name());
 169
 170         if (action == ActivitySpecAction.DELETE) {
 171             final String activitySpecName = get(new ActivitySpecEntity(activitySpec.getId(), versionId)).getName();
 172             uniqueValueService.deleteUniqueValue(ACTIVITY_SPEC_NAME, activitySpecName);
 173         }
 174     }
 175
 176     private VersionStatus getVersionStatusByAction(ActivitySpecAction action) {
 177         switch (action) {
 178             case DELETE:
 179                 return Deleted;
 180             case DEPRECATE:
 181                 return Deprecated;
 182             case CERTIFY:
 183                 return Certified;
 184             default:
 185                 throw new UnsupportedOperationException(
 186                         String.format("Activity Spec action %s is not supported", action.name()));
 187         }
 188
 189     }
 190
 191     @Override
 192     public Collection<ActivitySpecEntity> list(String versionStatus) {
 193         Predicate<Item> itemPredicate;
 194         if (Objects.nonNull(versionStatus)) {
 195             VersionStatus statusEnumValue;
 196
 197             try {
 198                 statusEnumValue = VersionStatus.valueOf(versionStatus);
 199             } catch (IllegalArgumentException e) {
 200                 LOGGER.debug("Unexpected value of VersionStatus {}", versionStatus);
 201                 return Collections.emptyList();
 202             }
 203             itemPredicate =
 204                     item -> ItemType.ACTIVITYSPEC.name().equals(item.getType()) && item.getVersionStatusCounters()
 205                                                                                            .containsKey(
 206                                                                                                    statusEnumValue);
 207         } else {
 208             itemPredicate = item -> ItemType.ACTIVITYSPEC.name().equals(item.getType());
 209         }
 210
 211         return itemManager.list(itemPredicate).stream()
 212                        .sorted(Comparator.comparing(Item::getModificationTime).reversed())
 213                        .map(activitySpecMapper::itemToActivitySpec).collect(Collectors.toList());
 214     }
 215
 216     private String calculateLatestVersion(ActivitySpecEntity activitySpec) {
 217         if (VERSION_ID_DEFAULT_VALUE.equalsIgnoreCase(activitySpec.getVersionId())) {
 218             List<Version> versions;
 219             try {
 220                 versions = versioningManager.list(activitySpec.getId());
 221             } catch (RuntimeException e) {
 222                 LOGGER.error("Failed to list versions for activitySpecId {}", activitySpec.getId(), e);
 223                 throw new EntityNotFoundException(ACTIVITY_SPEC_NOT_FOUND);
 224             }
 225             if (Objects.nonNull(versions) && !versions.isEmpty()) {
 226                 return versions.get(0).getId();
 227             }
 228         }
 229         return activitySpec.getVersionId();
 230     }
 231 }