openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.versioning.impl;
  22
  23 import org.openecomp.sdc.common.errors.CoreException;
  24 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  25 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  26 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  27 import org.openecomp.sdc.logging.types.LoggerConstants;
  28 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  29 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  30 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  31 import org.openecomp.sdc.versioning.VersioningManager;
  32 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
  33 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
  34 import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
  35 import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
  36 import org.openecomp.sdc.versioning.dao.types.Version;
  37 import org.openecomp.sdc.versioning.dao.types.VersionHistoryEntity;
  38 import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
  39 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  40 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  41 import org.openecomp.sdc.versioning.dao.types.VersionType;
  42 import org.openecomp.sdc.versioning.dao.types.VersionableEntityId;
  43 import org.openecomp.sdc.versioning.errors.CheckinOnEntityLockedByOtherErrorBuilder;
  44 import org.openecomp.sdc.versioning.errors.CheckinOnUnlockedEntityErrorBuilder;
  45 import org.openecomp.sdc.versioning.errors.CheckoutOnLockedEntityErrorBuilder;
  46 import org.openecomp.sdc.versioning.errors.DeleteOnLockedEntityErrorBuilder;
  47 import org.openecomp.sdc.versioning.errors.EditOnEntityLockedByOtherErrorBuilder;
  48 import org.openecomp.sdc.versioning.errors.EditOnUnlockedEntityErrorBuilder;
  49 import org.openecomp.sdc.versioning.errors.EntityAlreadyExistErrorBuilder;
  50 import org.openecomp.sdc.versioning.errors.EntityAlreadyFinalizedErrorBuilder;
  51 import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
  52 import org.openecomp.sdc.versioning.errors.SubmitLockedEntityNotAllowedErrorBuilder;
  53 import org.openecomp.sdc.versioning.errors.UndoCheckoutOnEntityLockedByOtherErrorBuilder;
  54 import org.openecomp.sdc.versioning.errors.UndoCheckoutOnUnlockedEntityErrorBuilder;
  55 import org.openecomp.sdc.versioning.types.VersionInfo;
  56 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  57 import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
  58 import org.slf4j.MDC;
  59
  60 import java.util.Collection;
  61 import java.util.HashMap;
  62 import java.util.HashSet;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.Set;
  66 import java.util.stream.Collectors;
  67
  68 public class VersioningManagerImpl implements VersioningManager {
  69
  70   private static final Version INITIAL_ACTIVE_VERSION = new Version(0, 0);
  71   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  72   private static Map<String, Set<VersionableEntityMetadata>> versionableEntities = new HashMap<>();
  73
  74   private VersionInfoDao versionInfoDao;
  75   private VersionInfoDeletedDao versionInfoDeletedDao;
  76
  77   public VersioningManagerImpl(VersionInfoDao versionInfoDao,
  78                                VersionInfoDeletedDao versionInfoDeletedDao) {
  79     this.versionInfoDao = versionInfoDao;
  80     this.versionInfoDeletedDao = versionInfoDeletedDao;
  81   }
  82
  83   private static VersionInfo getVersionInfo(VersionInfoEntity versionInfoEntity, String user,
  84                                             VersionableEntityAction action) {
  85     return getVersionInfo(versionInfoEntity.getEntityId(),
  86         versionInfoEntity.getEntityType(),
  87         versionInfoEntity.getActiveVersion(),
  88         versionInfoEntity.getCandidate(),
  89         versionInfoEntity.getStatus(),
  90         versionInfoEntity.getLatestFinalVersion(),
  91         versionInfoEntity.getViewableVersions(),
  92         action,
  93         user);
  94   }
  95
  96   private static VersionInfo getVersionInfo(VersionInfoDeletedEntity versionInfoEntity, String user,
  97                                             VersionableEntityAction action) {
  98     return getVersionInfo(versionInfoEntity.getEntityId(),
  99         versionInfoEntity.getEntityType(),
 100         versionInfoEntity.getActiveVersion(),
 101         versionInfoEntity.getCandidate(),
 102         versionInfoEntity.getStatus(),
 103         versionInfoEntity.getLatestFinalVersion(),
 104         versionInfoEntity.getViewableVersions(),
 105         action,
 106         user);
 107   }
 108
 109   private static VersionInfo getVersionInfo(String entityId, String entityType, Version activeVer,
 110                                             UserCandidateVersion candidate, VersionStatus status,
 111                                             Version latestFinalVersion,
 112                                             Set<Version> viewableVersions,
 113                                             VersionableEntityAction action, String user) {
 114
 115
 116     mdcDataDebugMessage.debugEntryMessage("entity Id", entityId);
 117
 118     Version activeVersion;
 119
 120     if (action == VersionableEntityAction.Write) {
 121       if (candidate != null) {
 122         if (user.equals(candidate.getUser())) {
 123           activeVersion = candidate.getVersion();
 124         } else {
 125           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 126               LoggerTragetServiceName.GET_VERSION_INFO, ErrorLevel.ERROR.name(),
 127               LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't get entity version info");
 128           throw new CoreException(
 129               new EditOnEntityLockedByOtherErrorBuilder(entityType, entityId, candidate.getUser())
 130                   .build());
 131         }
 132       } else {
 133         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 134             LoggerTragetServiceName.GET_VERSION_INFO, ErrorLevel.ERROR.name(),
 135             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't get entity version info");
 136         throw new CoreException(new EditOnUnlockedEntityErrorBuilder(entityType, entityId).build());
 137       }
 138     } else {
 139       if (candidate != null && user.equals(candidate.getUser())) {
 140         activeVersion = candidate.getVersion();
 141       } else {
 142         activeVersion = activeVer;
 143       }
 144     }
 145
 146     VersionInfo versionInfo = new VersionInfo();
 147     versionInfo.setStatus(status);
 148     activeVersion.setStatus(status);
 149     if(latestFinalVersion!= null) latestFinalVersion.setStatus(status);
 150     if(viewableVersions != null) viewableVersions.forEach(version->version.setStatus(status));
 151     versionInfo.setActiveVersion(activeVersion);
 152     versionInfo.setLatestFinalVersion(latestFinalVersion);
 153     versionInfo.setViewableVersions(toSortedList(viewableVersions));
 154     versionInfo.setFinalVersions(getFinalVersions(viewableVersions));
 155     if (candidate != null) {
 156       candidate.getVersion().setStatus(status);
 157       versionInfo.setLockingUser(candidate.getUser());
 158       if (user.equals(candidate.getUser())) {
 159         versionInfo.getViewableVersions().add(candidate.getVersion());
 160       }
 161     }
 162
 163     mdcDataDebugMessage.debugExitMessage("entity Id", entityId);
 164     return versionInfo;
 165   }
 166
 167   private static List<Version> toSortedList(
 168       Set<Version> versions) { // changing the Set to List in DB will require migration...
 169     return versions.stream().sorted((o1, o2) -> {
 170       return o1.getMajor() > o2.getMajor() ? 1
 171           : o1.getMajor() == o2.getMajor() ? (o1.getMinor() > o2.getMinor() ? 1
 172               : o1.getMinor() == o2.getMinor() ? 0 : -1) : -1;
 173     }).collect(Collectors.toList());
 174   }
 175
 176   private static List<Version> getFinalVersions(Set<Version> versions) {
 177     return versions.stream().filter(Version::isFinal).collect(Collectors.toList());
 178   }
 179
 180   @Override
 181   public void register(String entityType, VersionableEntityMetadata entityMetadata) {
 182     Set<VersionableEntityMetadata> entitiesMetadata =
 183         versionableEntities.computeIfAbsent(entityType, k -> new HashSet<>());
 184     entitiesMetadata.add(entityMetadata);
 185   }
 186
 187   @Override
 188   public Version create(String entityType, String entityId, String user) {
 189     VersionInfoEntity
 190         versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 191     if (versionInfoEntity != null) {
 192       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 193           LoggerTragetServiceName.CREATE_ENTITY, ErrorLevel.ERROR.name(),
 194           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't create versionable entity");
 195       throw new CoreException(new EntityAlreadyExistErrorBuilder(entityType, entityId).build());
 196     }
 197
 198     versionInfoEntity = new VersionInfoEntity(entityType, entityId);
 199     versionInfoEntity.setActiveVersion(INITIAL_ACTIVE_VERSION);
 200     markAsCheckedOut(versionInfoEntity, user);
 201     versionInfoDao.create(versionInfoEntity);
 202
 203     return versionInfoEntity.getCandidate().getVersion();
 204   }
 205
 206   @Override
 207   public void delete(String entityType, String entityId, String user) {
 208     VersionInfoEntity versionInfoEntity =
 209         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 210     if (versionInfoEntity == null) {
 211       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 212           LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
 213           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't delete versionable entity");
 214       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 215     }
 216
 217     switch (versionInfoEntity.getStatus()) {
 218       case Locked:
 219         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 220             LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
 221             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't delete versionable entity");
 222         throw new CoreException(new DeleteOnLockedEntityErrorBuilder(entityType, entityId,
 223             versionInfoEntity.getCandidate().getUser()).build());
 224       default:
 225         //do nothing
 226         break;
 227     }
 228
 229     doDelete(versionInfoEntity);
 230   }
 231
 232   @Override
 233   public void undoDelete(String entityType, String entityId, String user) {
 234     VersionInfoDeletedEntity versionInfoDeletedEntity =
 235         versionInfoDeletedDao.get(new VersionInfoDeletedEntity(entityType, entityId));
 236     if (versionInfoDeletedEntity == null) {
 237       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 238           LoggerTragetServiceName.UNDO_DELETE_ENTITY, ErrorLevel.ERROR.name(),
 239           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't undo delete for versionable entity");
 240       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 241     }
 242
 243     doUndoDelete(versionInfoDeletedEntity);
 244   }
 245
 246   @Override
 247   public Version checkout(String entityType, String entityId, String user) {
 248     VersionInfoEntity versionInfoEntity =
 249         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 250     MDC.put(LoggerConstants.TARGET_SERVICE_NAME, LoggerTragetServiceName.CHECKOUT_ENTITY);
 251     if (versionInfoEntity == null) {
 252       MDC.put(LoggerConstants.ERROR_CATEGORY, ErrorLevel.ERROR.name());
 253       MDC.put(LoggerConstants.TARGET_ENTITY, LoggerConstants.TARGET_ENTITY_DB);
 254       MDC.put(LoggerConstants.ERROR_DESCRIPTION, LoggerErrorDescription.CHECKOUT_ENTITY);
 255       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 256     }
 257
 258     Version checkoutVersion = null;
 259     switch (versionInfoEntity.getStatus()) {
 260       case Locked:
 261         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 262             LoggerTragetServiceName.CHECKOUT_ENTITY, ErrorLevel.ERROR.name(),
 263             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't checkout versionable entity");
 264         throw new CoreException(new CheckoutOnLockedEntityErrorBuilder(entityType, entityId,
 265             versionInfoEntity.getCandidate().getUser()).build());
 266       case Final:
 267       case Available:
 268         checkoutVersion = doCheckout(versionInfoEntity, user);
 269         break;
 270       default:
 271         //do nothing
 272         break;
 273     }
 274
 275     return checkoutVersion;
 276   }
 277
 278   @Override
 279   public Version undoCheckout(String entityType, String entityId, String user) {
 280     VersionInfoEntity versionInfoEntity =
 281         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 282     if (versionInfoEntity == null) {
 283       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 284           LoggerTragetServiceName.UNDO_CHECKOUT_ENTITY, ErrorLevel.ERROR.name(),
 285           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't undo checkout for versionable entity");
 286       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 287     }
 288
 289     Version activeVersion = null;
 290     switch (versionInfoEntity.getStatus()) {
 291       case Locked:
 292         if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
 293           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 294               LoggerTragetServiceName.UNDO_CHECKOUT_ENTITY, ErrorLevel.ERROR.name(),
 295               LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 296               "Can't undo checkout for versionable entity");
 297           throw new CoreException(
 298               new UndoCheckoutOnEntityLockedByOtherErrorBuilder(entityType, entityId,
 299                   versionInfoEntity.getCandidate().getUser()).build());
 300         }
 301         activeVersion = undoCheckout(versionInfoEntity);
 302         break;
 303       case Final:
 304       case Available:
 305         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 306             LoggerTragetServiceName.UNDO_CHECKOUT_ENTITY, ErrorLevel.ERROR.name(),
 307             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 308             "Can't undo checkout for versionable entity");
 309         throw new CoreException(
 310             new UndoCheckoutOnUnlockedEntityErrorBuilder(entityType, entityId).build());
 311       default:
 312         //do nothing
 313         break;
 314     }
 315
 316     return activeVersion;
 317   }
 318
 319   private Version undoCheckout(VersionInfoEntity versionInfoEntity) {
 320     deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
 321         versionInfoEntity.getCandidate().getVersion(), versionInfoEntity.getActiveVersion());
 322
 323     versionInfoEntity.setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Final
 324         : VersionStatus.Available);
 325     versionInfoEntity.setCandidate(null);
 326     versionInfoDao.update(versionInfoEntity);
 327     return versionInfoEntity.getActiveVersion();
 328   }
 329
 330   @Override
 331   public Version checkin(String entityType, String entityId, String user,
 332                          String checkinDescription) {
 333     VersionInfoEntity versionInfoEntity =
 334         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 335     if (versionInfoEntity == null) {
 336       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 337           LoggerTragetServiceName.CHECKIN_ENTITY, ErrorLevel.ERROR.name(),
 338           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't checkin versionable entity");
 339       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 340     }
 341
 342     Version checkedInVersion = null;
 343     switch (versionInfoEntity.getStatus()) {
 344       case Available:
 345       case Final:
 346         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 347             LoggerTragetServiceName.CHECKIN_ENTITY, ErrorLevel.ERROR.name(),
 348             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't checkin versionable entity");
 349         throw new CoreException(
 350             new CheckinOnUnlockedEntityErrorBuilder(entityType, entityId).build());
 351       case Locked:
 352         if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
 353           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 354               LoggerTragetServiceName.CHECKIN_ENTITY, ErrorLevel.ERROR.name(),
 355               LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't checkin versionable entity");
 356           throw new CoreException(new CheckinOnEntityLockedByOtherErrorBuilder(entityType, entityId,
 357               versionInfoEntity.getCandidate().getUser()).build());
 358         }
 359         checkedInVersion = doCheckin(versionInfoEntity, checkinDescription);
 360         break;
 361       default:
 362         //do nothing
 363         break;
 364     }
 365
 366     return checkedInVersion;
 367   }
 368
 369   @Override
 370   public Version submit(String entityType, String entityId, String user, String submitDescription) {
 371     VersionInfoEntity versionInfoEntity =
 372         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 373     if (versionInfoEntity == null) {
 374       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 375           LoggerTragetServiceName.SUBMIT_ENTITY, ErrorLevel.ERROR.name(),
 376           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't submit versionable entity");
 377       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 378     }
 379
 380     Version submitVersion = null;
 381     switch (versionInfoEntity.getStatus()) {
 382       case Final:
 383         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 384             LoggerTragetServiceName.SUBMIT_ENTITY, ErrorLevel.ERROR.name(),
 385             LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't submit versionable entity");
 386         throw new CoreException(
 387             new EntityAlreadyFinalizedErrorBuilder(entityType, entityId).build());
 388       case Locked:
 389         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 390             LoggerTragetServiceName.SUBMIT_ENTITY, ErrorLevel.ERROR.name(),
 391             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't submit versionable entity");
 392         throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
 393             versionInfoEntity.getCandidate().getUser()).build());
 394       case Available:
 395         submitVersion = doSubmit(versionInfoEntity, user, submitDescription);
 396         break;
 397       default:
 398         //do nothing
 399         break;
 400     }
 401
 402     return submitVersion;
 403   }
 404
 405   @Override
 406   public VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
 407                                           VersionableEntityAction action) {
 408     VersionInfoEntity versionInfoEntity =
 409         versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
 410     if (versionInfoEntity == null) {
 411       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 412           LoggerTragetServiceName.GET_VERSION_INFO, ErrorLevel.ERROR.name(),
 413           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't get entity version info");
 414       throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
 415     }
 416     return getVersionInfo(versionInfoEntity, user, action);
 417   }
 418
 419   @Override
 420   public Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
 421                                                           VersionableEntityAction action) {
 422     Collection<VersionInfoEntity> versionInfoEntities =
 423         versionInfoDao.list(new VersionInfoEntity(entityType, null));
 424     Map<String, VersionInfo> activeVersions = new HashMap<>();
 425     for (VersionInfoEntity versionInfoEntity : versionInfoEntities) {
 426       activeVersions
 427           .put(versionInfoEntity.getEntityId(), getVersionInfo(versionInfoEntity, user, action));
 428     }
 429     return activeVersions;
 430   }
 431
 432   @Override
 433   public Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
 434                                                                  VersionableEntityAction action) {
 435     Collection<VersionInfoDeletedEntity> versionInfoDeletedEntities =
 436         versionInfoDeletedDao.list(new VersionInfoDeletedEntity(entityType, null));
 437     Map<String, VersionInfo> activeVersions = new HashMap<>();
 438
 439
 440     for (VersionInfoDeletedEntity versionInfoDeletedEntity : versionInfoDeletedEntities) {
 441       activeVersions.put(versionInfoDeletedEntity.getEntityId(),
 442           getVersionInfo(versionInfoDeletedEntity, user, action));
 443     }
 444     return activeVersions;
 445   }
 446
 447   private void markAsCheckedOut(VersionInfoEntity versionInfoEntity, String checkingOutUser) {
 448     versionInfoEntity.setStatus(VersionStatus.Locked);
 449     versionInfoEntity.setCandidate(new UserCandidateVersion(checkingOutUser,
 450         versionInfoEntity.getActiveVersion().calculateNextCandidate()));
 451   }
 452
 453   private Version doCheckout(VersionInfoEntity versionInfoEntity, String user) {
 454     markAsCheckedOut(versionInfoEntity, user);
 455     versionInfoDao.update(versionInfoEntity);
 456
 457     initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
 458         versionInfoEntity.getActiveVersion(), versionInfoEntity.getCandidate().getVersion());
 459
 460     return versionInfoEntity.getCandidate().getVersion();
 461   }
 462
 463   private void doDelete(VersionInfoEntity versionInfoEntity) {
 464     VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
 465     versionInfoDeletedEntity.setStatus(versionInfoEntity.getStatus());
 466     versionInfoDeletedEntity.setViewableVersions(versionInfoEntity.getViewableVersions());
 467     versionInfoDeletedEntity.setActiveVersion(versionInfoEntity.getActiveVersion());
 468     versionInfoDeletedEntity.setCandidate(versionInfoEntity.getCandidate());
 469     versionInfoDeletedEntity.setEntityId(versionInfoEntity.getEntityId());
 470     versionInfoDeletedEntity.setEntityType(versionInfoEntity.getEntityType());
 471     versionInfoDeletedEntity.setLatestFinalVersion(versionInfoEntity.getLatestFinalVersion());
 472     versionInfoDeletedDao.create(versionInfoDeletedEntity);
 473     versionInfoDao.delete(versionInfoEntity);
 474   }
 475
 476   private void doUndoDelete(VersionInfoDeletedEntity versionInfoDeletedEntity) {
 477     VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
 478     versionInfoEntity.setStatus(versionInfoDeletedEntity.getStatus());
 479     versionInfoEntity.setViewableVersions(versionInfoDeletedEntity.getViewableVersions());
 480     versionInfoEntity.setActiveVersion(versionInfoDeletedEntity.getActiveVersion());
 481     versionInfoEntity.setCandidate(versionInfoDeletedEntity.getCandidate());
 482     versionInfoEntity.setEntityId(versionInfoDeletedEntity.getEntityId());
 483     versionInfoEntity.setEntityType(versionInfoDeletedEntity.getEntityType());
 484     versionInfoEntity.setLatestFinalVersion(versionInfoDeletedEntity.getLatestFinalVersion());
 485     versionInfoDao.create(versionInfoEntity);
 486     versionInfoDeletedDao.delete(versionInfoDeletedEntity);
 487   }
 488
 489   private Version doCheckin(VersionInfoEntity versionInfoEntity, String checkinDescription) {
 490     UserCandidateVersion userCandidateVersion = versionInfoEntity.getCandidate();
 491     versionInfoEntity.setCandidate(null);
 492     versionInfoEntity.setActiveVersion(userCandidateVersion.getVersion());
 493     versionInfoEntity.getViewableVersions().add(versionInfoEntity.getActiveVersion());
 494     versionInfoEntity.setStatus(VersionStatus.Available);
 495     versionInfoDao.update(versionInfoEntity);
 496
 497     closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
 498         versionInfoEntity.getActiveVersion());
 499
 500     return versionInfoEntity.getActiveVersion();
 501   }
 502
 503   private Version doSubmit(VersionInfoEntity versionInfoEntity, String submittingUser,
 504                            String submitDescription) {
 505     Version finalVersion = versionInfoEntity.getActiveVersion().calculateNextFinal();
 506     initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
 507         versionInfoEntity.getActiveVersion(), finalVersion);
 508     closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
 509         finalVersion);
 510
 511     Set<Version> viewableVersions = new HashSet<>();
 512     for (Version version : versionInfoEntity.getViewableVersions()) {
 513       if (version.isFinal()) {
 514         viewableVersions.add(version);
 515       }
 516     }
 517     viewableVersions.add(finalVersion);
 518     versionInfoEntity.setViewableVersions(viewableVersions);
 519     versionInfoEntity.setActiveVersion(finalVersion);
 520     versionInfoEntity.setLatestFinalVersion(finalVersion);
 521     versionInfoEntity.setStatus(VersionStatus.Final);
 522     versionInfoDao.update(versionInfoEntity);
 523
 524     return finalVersion;
 525   }
 526
 527   private void createVersionHistory(VersionableEntityId entityId, Version version, String user,
 528                                     String description, VersionType type) {
 529     VersionHistoryEntity versionHistory = new VersionHistoryEntity(entityId);
 530     versionHistory.setVersion(version);
 531     versionHistory.setUser(user);
 532     versionHistory.setDescription(description);
 533     versionHistory.setType(type);
 534     //versionHistoryDao.create(versionHistory);
 535   }
 536
 537   private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
 538                                    Version newVersion) {
 539     Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
 540     if (entityMetadatas != null) {
 541       for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
 542         VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
 543             .initVersion(entityMetadata, entityId, baseVersion, newVersion);
 544       }
 545     }
 546   }
 547
 548   private void deleteVersionFromEntity(String entityType, String entityId,
 549                                        Version versionToDelete, Version backToVersion) {
 550     Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
 551     if (entityMetadatas != null) {
 552       for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
 553         VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
 554             .deleteVersion(entityMetadata, entityId, versionToDelete, backToVersion);
 555       }
 556     }
 557   }
 558
 559   private void closeVersionOnEntity(String entityType, String entityId, Version versionToClose) {
 560     Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
 561     if (entityMetadatas != null) {
 562       for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
 563         VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
 564             .closeVersion(entityMetadata, entityId, versionToClose);
 565       }
 566     }
 567   }
 568 }