openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.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.openecomp.sdc.versioning.impl;
  18
  19 import org.openecomp.sdc.common.errors.CoreException;
  20 import org.openecomp.sdc.common.errors.ErrorCategory;
  21 import org.openecomp.sdc.common.errors.ErrorCode;
  22 import org.openecomp.sdc.logging.api.Logger;
  23 import org.openecomp.sdc.logging.api.LoggerFactory;
  24 import org.openecomp.sdc.versioning.ItemManager;
  25 import org.openecomp.sdc.versioning.VersionCalculator;
  26 import org.openecomp.sdc.versioning.VersioningManager;
  27 import org.openecomp.sdc.versioning.dao.VersionDao;
  28 import org.openecomp.sdc.versioning.dao.types.Revision;
  29 import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
  30 import org.openecomp.sdc.versioning.dao.types.Version;
  31 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  32
  33 import java.util.HashMap;
  34 import java.util.List;
  35 import java.util.Set;
  36 import java.util.stream.Collectors;
  37
  38 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  39 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  40
  41 public class VersioningManagerImpl implements VersioningManager {
  42   private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class);
  43
  44   private VersionDao versionDao;
  45   private VersionCalculator versionCalculator;
  46   private ItemManager itemManager;
  47
  48   public VersioningManagerImpl(VersionDao versionDao,
  49                                VersionCalculator versionCalculator,
  50       ItemManager itemManager) {
  51     this.versionDao = versionDao;
  52     this.versionCalculator = versionCalculator;
  53     this.itemManager = itemManager;
  54   }
  55
  56
  57   @Override
  58   public List<Version> list(String itemId) {
  59
  60     List<Version> versions = versionDao.list(itemId);
  61     Set<String> versionsNames = versions.stream().map(Version::getName).collect(Collectors.toSet());
  62     versions.forEach(version -> {
  63       version.setAdditionalInfo(new HashMap<>());
  64       versionCalculator.injectAdditionalInfo(version, versionsNames);
  65     });
  66     return versions;
  67   }
  68
  69   @Override
  70   public Version get(String itemId, Version version) {
  71     return versionDao.get(itemId, version)
  72         .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion))
  73         .orElseGet(() -> getSyncedVersion(itemId, version));
  74   }
  75
  76   private Version getUpdateRetrievedVersion(String itemId, Version version) {
  77     if (version.getStatus() == Certified &&
  78         (version.getState().getSynchronizationState() == SynchronizationState.OutOfSync ||
  79             version.getState().isDirty())) {
  80       forceSync(itemId, version);
  81       LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId());
  82       version = versionDao.get(itemId, version)
  83           .orElseThrow(() -> new IllegalStateException(
  84               "Get version after a successful force sync must return the version"));
  85     }
  86     return version;
  87   }
  88
  89   private Version getSyncedVersion(String itemId, Version version) {
  90     sync(itemId, version);
  91     LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId());
  92     return versionDao.get(itemId, version)
  93         .orElseThrow(() -> new IllegalStateException(
  94             "Get version after a successful sync must return the version"));
  95   }
  96
  97   @Override
  98   public Version create(String itemId, Version version, VersionCreationMethod creationMethod) {
  99     String baseVersionName = null;
 100     if (version.getBaseId() == null) {
 101       version.setDescription("Initial version");
 102     } else {
 103       baseVersionName = get(itemId, new Version(version.getBaseId())).getName();
 104     }
 105     String versionName = versionCalculator.calculate(baseVersionName, creationMethod);
 106     validateVersionName(itemId, versionName);
 107     version.setName(versionName);
 108
 109     versionDao.create(itemId, version);
 110     itemManager.updateVersionStatus(itemId, Draft, null);
 111
 112     publish(itemId, version, String.format("Create version: %s", version.getName()));
 113     return version;
 114   }
 115
 116   private void validateVersionName(String itemId, String versionName) {
 117     if (versionDao.list(itemId).stream()
 118         .anyMatch(version -> versionName.equals(version.getName()))) {
 119       String errorDescription = String
 120           .format("Item %s: create version failed, a version with the name %s already exist",
 121               itemId, versionName);
 122
 123       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 124           .withMessage(errorDescription)
 125           .build());
 126     }
 127   }
 128
 129   @Override
 130   public void submit(String itemId, Version version, String submitDescription) {
 131     version = get(itemId, version);
 132
 133     validateSubmit(itemId, version);
 134
 135     version.setStatus(Certified);
 136     versionDao.update(itemId, version);
 137
 138     publish(itemId, version, submitDescription);
 139
 140     itemManager.updateVersionStatus(itemId, Certified, Draft);
 141   }
 142
 143   private void validateSubmit(String itemId, Version version) {
 144     if (version.getStatus() == Certified) {
 145       String errorDescription = String
 146           .format("Item %s: submit version failed, version %s is already Certified", itemId,
 147               version.getId());
 148       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 149           .withCategory(ErrorCategory.APPLICATION)
 150           .withId("VERSION_ALREADY_CERTIFIED")
 151           .withMessage(errorDescription)
 152           .build());
 153     }
 154   }
 155
 156   @Override
 157   public void publish(String itemId, Version version, String message) {
 158     versionDao.publish(itemId, version, message);
 159   }
 160
 161
 162   @Override
 163   public void sync(String itemId, Version version) {
 164     versionDao.sync(itemId, version);
 165   }
 166
 167   @Override
 168   public void forceSync(String itemId, Version version) {
 169     versionDao.forceSync(itemId, version);
 170   }
 171
 172   @Override
 173   public void revert(String itemId, Version version, String revisionId) {
 174     versionDao.revert(itemId, version, revisionId);
 175   }
 176
 177   @Override
 178   public List<Revision> listRevisions(String itemId, Version version) {
 179     return versionDao.listRevisions(itemId, version);
 180   }
 181
 182   @Override
 183   public void updateVersion(String itemId, Version version) {
 184     versionDao.update(itemId, version);
 185   }
 186
 187   @Override
 188   public void clean(String itemId, Version version) {
 189     versionDao.clean(itemId, version);
 190   }
 191
 192 }