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