From 2c78e55c6918b090d0ca47f931ac7f24a7c64abc Mon Sep 17 00:00:00 2001 From: talig Date: Mon, 5 Aug 2019 16:53:44 +0300 Subject: Add versioning, session and zusammen libs Issue-ID: SDC-2486 Signed-off-by: talig Change-Id: I848edbcb84f424f949b646df04f04fa66d0f3bd2 --- .../sdc/common/versioning/persistence/ItemDao.java | 17 ++ .../common/versioning/persistence/VersionDao.java | 31 ++++ .../versioning/persistence/types/InternalItem.java | 77 ++++++++ .../persistence/types/InternalVersion.java | 42 +++++ .../persistence/zusammen/ItemZusammenDao.java | 126 +++++++++++++ .../persistence/zusammen/VersionZusammenDao.java | 202 +++++++++++++++++++++ .../zusammen/ZusammenSessionContextCreator.java | 28 +++ .../common/versioning/services/ItemManager.java | 37 ++++ .../versioning/services/VersioningManager.java | 48 +++++ .../services/convertors/ItemConvertor.java | 17 ++ .../services/convertors/VersionConvertor.java | 16 ++ .../services/exceptions/VersioningException.java | 8 + .../versioning/services/impl/ItemManagerImpl.java | 91 ++++++++++ .../services/impl/MajorVersionCalculatorImpl.java | 46 +++++ .../services/impl/VersionCalculator.java | 12 ++ .../services/impl/VersioningManagerImpl.java | 202 +++++++++++++++++++++ .../sdc/common/versioning/services/types/Item.java | 55 ++++++ .../versioning/services/types/ItemStatus.java | 5 + .../common/versioning/services/types/Revision.java | 15 ++ .../services/types/SynchronizationState.java | 17 ++ .../common/versioning/services/types/Version.java | 56 ++++++ .../services/types/VersionCreationMethod.java | 5 + .../versioning/services/types/VersionState.java | 11 ++ .../versioning/services/types/VersionStatus.java | 21 +++ .../versioning/services/types/VersionType.java | 25 +++ 25 files changed, 1210 insertions(+) create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java create mode 100644 versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java (limited to 'versioning-lib/src/main/java/org') diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java new file mode 100644 index 0000000..a47ce00 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.persistence; + +import java.util.Collection; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; + +public interface ItemDao { + + Collection list(); + + InternalItem get(String itemId); + + InternalItem create(InternalItem item); + + void update(InternalItem item); + + void delete(String itemId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java new file mode 100644 index 0000000..17354e8 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java @@ -0,0 +1,31 @@ +package org.onap.sdc.common.versioning.persistence; + +import java.util.List; +import java.util.Optional; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.types.Revision; + +public interface VersionDao { + + List list(String itemId); + + InternalVersion create(String itemId, InternalVersion version); + + void update(String itemId, InternalVersion version); + + Optional get(String itemId, String versionId); + + void delete(String itemId, String versionId); + + void publish(String itemId, String versionId, String message); + + void sync(String itemId, String versionId); + + void forceSync(String itemId, String versionId); + + void clean(String itemId, String versionId); + + void revert(String itemId, String versionId, String revisionId); + + List listRevisions(String itemId, String versionId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java new file mode 100644 index 0000000..3d6610b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java @@ -0,0 +1,77 @@ +/* + * + * Copyright © 2017-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.onap.sdc.common.versioning.persistence.types; + +import java.util.Date; +import java.util.EnumMap; +import java.util.Map; +import lombok.Getter; +import lombok.Setter; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + + +@Setter +@Getter +public class InternalItem extends Item { + + private Map versionStatusCounters = new EnumMap<>(VersionStatus.class); + + public void setId(String id) { + this.id = id; + } + + public void setCreationTime(Date creationTime) { + this.creationTime = creationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + public void setStatus(ItemStatus status) { + this.status = status; + } + + public void addVersionStatus(VersionStatus versionStatus) { + Integer counter = versionStatusCounters.get(versionStatus); + versionStatusCounters.put(versionStatus, counter == null ? 1 : counter + 1); + } + + public void removeVersionStatus(VersionStatus versionStatus) { + Integer counter = versionStatusCounters.get(versionStatus); + if (counter == null) { + return; + } + if (counter == 1) { + versionStatusCounters.remove(versionStatus); + } else { + versionStatusCounters.put(versionStatus, counter - 1); + } + } + + public void populateExternalFields(Item item) { + setType(item.getType()); + setName(item.getName()); + setOwner(item.getOwner()); + setDescription(item.getDescription()); + item.getProperties().forEach(this::addProperty); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java new file mode 100644 index 0000000..d48400b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java @@ -0,0 +1,42 @@ +package org.onap.sdc.common.versioning.persistence.types; + +import java.util.Date; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionState; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + +public class InternalVersion extends Version { + + public void setId(String id) { + this.id = id; + } + + public void setBaseId(String baseId) { + this.baseId = baseId; + } + + public void setName(String name) { + this.name = name; + } + + public void setStatus(VersionStatus status) { + this.status = status; + } + + public void setState(VersionState state) { + this.state = state; + } + + public void setCreationTime(Date creationTime) { + this.creationTime = creationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + public void populateExternalFields(Version version) { + setDescription(version.getDescription()); + version.getProperties().forEach(this::addProperty); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java new file mode 100644 index 0000000..8530697 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java @@ -0,0 +1,126 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.item.Info; +import com.amdocs.zusammen.datatypes.item.Item; +import java.util.Collection; +import java.util.Map; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; +import org.onap.sdc.common.versioning.services.types.ItemStatus; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.onap.sdc.common.zusammen.services.ZusammenAdaptor; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; + +@Repository +public class ItemZusammenDao implements ItemDao { + + private final ZusammenSessionContextCreator contextCreator; + private final ZusammenAdaptor zusammenAdaptor; + + @Autowired + public ItemZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) { + this.contextCreator = contextCreator; + this.zusammenAdaptor = zusammenAdaptor; + } + + @Override + public Collection list() { + return zusammenAdaptor.listItems(contextCreator.create()).stream().map(this::mapFromZusammenItem) + .collect(Collectors.toList()); + } + + @Override + public InternalItem get(String itemId) { + return mapFromZusammenItem(zusammenAdaptor.getItem(contextCreator.create(), new Id(itemId))); + } + + @Override + public InternalItem create(InternalItem item) { + Id itemId = zusammenAdaptor.createItem(contextCreator.create(), mapToZusammenItemInfo(item)); + item.setId(itemId.getValue()); + return item; + } + + @Override + public void delete(String itemId) { + zusammenAdaptor.deleteItem(contextCreator.create(), new Id(itemId)); + } + + @Override + public void update(InternalItem item) { + zusammenAdaptor.updateItem(contextCreator.create(), new Id(item.getId()), mapToZusammenItemInfo(item)); + } + + private InternalItem mapFromZusammenItem(Item zusammenItem) { + if (zusammenItem == null) { + return null; + } + InternalItem item = new InternalItem(); + item.setId(zusammenItem.getId().getValue()); + item.setName(zusammenItem.getInfo().getName()); + item.setDescription(zusammenItem.getInfo().getDescription()); + + zusammenItem.getInfo().getProperties().forEach((key, value) -> addPropertyToItem(key, value, item)); + + item.setCreationTime(zusammenItem.getCreationTime()); + item.setModificationTime(zusammenItem.getModificationTime()); + + if (item.getStatus() == null) { + item.setStatus(ItemStatus.ACTIVE); + update(item); + } + + return item; + } + + private void addPropertyToItem(String propertyKey, Object propertyValue, InternalItem item) { + switch (propertyKey) { + case InfoPropertyName.ITEM_TYPE: + item.setType((String) propertyValue); + break; + case InfoPropertyName.ITEM_OWNER: + item.setOwner((String) propertyValue); + break; + case InfoPropertyName.ITEM_STATUS: + item.setStatus(ItemStatus.valueOf((String) propertyValue)); + break; + case InfoPropertyName.ITEM_VERSIONS_STATUSES: + for (Map.Entry statusCounter : ((Map) propertyValue).entrySet()) { + item.getVersionStatusCounters() + .put(VersionStatus.valueOf(statusCounter.getKey()), statusCounter.getValue().intValue()); + } + break; + default: + item.addProperty(propertyKey, propertyValue); + } + } + + private Info mapToZusammenItemInfo(InternalItem item) { + Info info = new Info(); + info.setName(item.getName()); + info.setDescription(item.getDescription()); + info.addProperty(InfoPropertyName.ITEM_TYPE, item.getType()); + info.addProperty(InfoPropertyName.ITEM_OWNER, item.getOwner()); + if (item.getStatus() != null) { + info.addProperty(InfoPropertyName.ITEM_STATUS, item.getStatus()); + } + info.addProperty(InfoPropertyName.ITEM_VERSIONS_STATUSES, item.getVersionStatusCounters()); + item.getProperties().forEach(info::addProperty); + return info; + } + + private static final class InfoPropertyName { + + private static final String ITEM_TYPE = "item_type"; + private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses"; + private static final String ITEM_OWNER = "Owner"; + private static final String ITEM_STATUS = "status"; + + private InfoPropertyName() { + throw new IllegalStateException("Constants class"); + } + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java new file mode 100644 index 0000000..cb062c7 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java @@ -0,0 +1,202 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + + +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.Info; +import com.amdocs.zusammen.datatypes.item.ItemVersion; +import com.amdocs.zusammen.datatypes.item.ItemVersionData; +import com.amdocs.zusammen.datatypes.item.ItemVersionStatus; +import com.amdocs.zusammen.datatypes.item.SynchronizationStatus; +import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.VersionDao; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.SynchronizationState; +import org.onap.sdc.common.versioning.services.types.VersionState; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.onap.sdc.common.zusammen.services.ZusammenAdaptor; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; + +@Repository +public class VersionZusammenDao implements VersionDao { + + private static final String STATUS_PROPERTY = "status"; + + private final ZusammenSessionContextCreator contextCreator; + private final ZusammenAdaptor zusammenAdaptor; + + @Autowired + public VersionZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) { + this.contextCreator = contextCreator; + this.zusammenAdaptor = zusammenAdaptor; + } + + @Override + public List list(String itemId) { + return zusammenAdaptor.listPublicVersions(contextCreator.create(), new Id(itemId)).stream() + .map(VersionZusammenDao::convertFromZusammen).collect(Collectors.toList()); + } + + @Override + public InternalVersion create(String itemId, InternalVersion version) { + Id versionId = zusammenAdaptor.createVersion(contextCreator.create(), new Id(itemId), + version.getBaseId() == null ? null : new Id(version.getBaseId()), mapToZusammenVersion(version)); + + version.setId(versionId.getValue()); + return version; + } + + @Override + public void update(String itemId, InternalVersion version) { + zusammenAdaptor.updateVersion(contextCreator.create(), new Id(itemId), new Id(version.getId()), + mapToZusammenVersion(version)); + } + + @Override + public Optional get(String itemId, String versionId) { + SessionContext context = contextCreator.create(); + Id itemIdObj = new Id(itemId); + Id versionIdObj = new Id(versionId); + ItemVersion itemVersion = zusammenAdaptor.getVersion(context, itemIdObj, versionIdObj); + + if (itemVersion == null) { + return Optional.empty(); + } + + VersionState versionState = convertState(zusammenAdaptor.getVersionStatus(context, itemIdObj, versionIdObj)); + updateVersionStatus(context, itemIdObj, versionIdObj, versionState, itemVersion); + + InternalVersion result = convertFromZusammen(itemVersion); + result.setState(versionState); + return Optional.of(result); + } + + @Override + public void delete(String itemId, String versionId) { + throw new UnsupportedOperationException("Delete version operation is not yet supported."); + } + + @Override + public void publish(String itemId, String versionId, String message) { + zusammenAdaptor.publishVersion(contextCreator.create(), new Id(itemId), new Id(versionId), message); + } + + @Override + public void sync(String itemId, String versionId) { + zusammenAdaptor.syncVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void forceSync(String itemId, String versionId) { + zusammenAdaptor.forceSyncVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void clean(String itemId, String versionId) { + zusammenAdaptor.cleanVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void revert(String itemId, String versionId, String revisionId) { + zusammenAdaptor.revert(contextCreator.create(), new Id(itemId), new Id(versionId), new Id(revisionId)); + } + + @Override + public List listRevisions(String itemId, String versionId) { + ItemVersionRevisions itemVersionRevisions = + zusammenAdaptor.listRevisions(contextCreator.create(), new Id(itemId), new Id(versionId)); + + return itemVersionRevisions == null || itemVersionRevisions.getItemVersionRevisions() == null + || itemVersionRevisions.getItemVersionRevisions().isEmpty() ? new ArrayList<>() : + itemVersionRevisions.getItemVersionRevisions().stream().map(this::convertRevision) + .sorted(this::compareRevisionsTime).collect(Collectors.toList()); + } + + private void updateVersionStatus(SessionContext context, Id itemId, Id versionId, VersionState versionState, + ItemVersion itemVersion) { + if (versionState.getSynchronizationState() != SynchronizationState.UpToDate) { + String versionStatus = zusammenAdaptor.getPublicVersion(context, itemId, versionId).getData().getInfo() + .getProperty(STATUS_PROPERTY); + itemVersion.getData().getInfo().addProperty(STATUS_PROPERTY, versionStatus); + } + } + + private ItemVersionData mapToZusammenVersion(InternalVersion version) { + Info info = new Info(); + info.addProperty(STATUS_PROPERTY, version.getStatus().name()); + info.setName(version.getName()); + info.setDescription(version.getDescription()); + version.getProperties().forEach(info::addProperty); + ItemVersionData itemVersionData = new ItemVersionData(); + itemVersionData.setInfo(info); + return itemVersionData; + } + + private VersionState convertState(ItemVersionStatus versionStatus) { + VersionState state = new VersionState(); + state.setSynchronizationState(getSyncState(versionStatus.getSynchronizationStatus())); + state.setDirty(versionStatus.isDirty()); + return state; + } + + private SynchronizationState getSyncState(SynchronizationStatus synchronizationStatus) { + switch (synchronizationStatus) { + case UP_TO_DATE: + return SynchronizationState.UpToDate; + case OUT_OF_SYNC: + return SynchronizationState.OutOfSync; + case MERGING: + return SynchronizationState.Merging; + default: + throw new VersioningException("Version state is unknown"); + } + } + + private Revision convertRevision(com.amdocs.zusammen.datatypes.itemversion.Revision zusammenRevision) { + Revision revision = new Revision(); + revision.setId(zusammenRevision.getRevisionId().getValue()); + revision.setTime(zusammenRevision.getTime()); + revision.setUser(zusammenRevision.getUser()); + revision.setMessage(zusammenRevision.getMessage()); + return revision; + } + + private int compareRevisionsTime(Revision revision1, Revision revision2) { + return revision1.getTime().before(revision2.getTime()) ? 1 : -1; + } + + private static InternalVersion convertFromZusammen(ItemVersion itemVersion) { + if (itemVersion == null) { + return null; + } + InternalVersion version = new InternalVersion(); + version.setId(itemVersion.getId().getValue()); + if (itemVersion.getBaseId() != null) { + version.setBaseId(itemVersion.getBaseId().getValue()); + } + version.setName(itemVersion.getData().getInfo().getName()); + version.setDescription(itemVersion.getData().getInfo().getDescription()); + version.setCreationTime(itemVersion.getCreationTime()); + version.setModificationTime(itemVersion.getModificationTime()); + + itemVersion.getData().getInfo().getProperties() + .forEach((key, value) -> addPropertyToVersion(key, value, version)); + + return version; + } + + private static void addPropertyToVersion(String propertyKey, Object propertyValue, InternalVersion version) { + if (STATUS_PROPERTY.equals(propertyKey)) { + version.setStatus(VersionStatus.valueOf((String) propertyValue)); + } else { + version.addProperty(propertyKey, propertyValue); + } + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java new file mode 100644 index 0000000..f8a677a --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java @@ -0,0 +1,28 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.UserInfo; +import org.onap.sdc.common.session.SessionContextProvider; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class ZusammenSessionContextCreator { + + private final SessionContextProvider sessionContextProvider; + + @Autowired + public ZusammenSessionContextCreator(SessionContextProvider sessionContextProvider) { + this.sessionContextProvider = sessionContextProvider; + } + + + public SessionContext create() { + org.onap.sdc.common.session.SessionContext sdcSessionContext = sessionContextProvider.get(); + + SessionContext sessionContext = new SessionContext(); + sessionContext.setUser(new UserInfo(sdcSessionContext.getUserId())); + sessionContext.setTenant(sdcSessionContext.getTenant()); + return sessionContext; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java new file mode 100644 index 0000000..de91f2e --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java @@ -0,0 +1,37 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.sdc.common.versioning.services; + +import java.util.Collection; +import java.util.function.Predicate; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; + +public interface ItemManager { + + Collection list(Predicate predicate); + + Item get(String itemId); + + Item create(Item item); + + Item update(String itemId, Item item); + + void delete(String itemId); + + void updateStatus(String itemId, ItemStatus status); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java new file mode 100644 index 0000000..f522077 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java @@ -0,0 +1,48 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.sdc.common.versioning.services; + +import java.util.List; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + +public interface VersioningManager { + + List list(String itemId); // TODO: 5/24/2017 filter (by status for example) + + Version get(String itemId, String versionId); + + Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod); + + Version update(String itemId, String versionId, Version version); + + void updateStatus(String itemId, String versionId, VersionStatus status, String message); + + void publish(String itemId, String versionId, String message); + + void sync(String itemId, String versionId); + + void forceSync(String itemId, String versionId); + + void revert(String itemId, String versionId, String revisionId); + + List listRevisions(String itemId, String versionId); + + void clean(String itemId, String versionId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java new file mode 100644 index 0000000..88405e5 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.services.convertors; + +import org.onap.sdc.common.versioning.services.types.Item; + +public interface ItemConvertor { + + String getItemType(); + + //Item toItem(T model); + + void toItem(T source, Item target); + + // void fromItem(Item source, T target); + + T fromItem(Item item); + +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java new file mode 100644 index 0000000..beab1d9 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java @@ -0,0 +1,16 @@ +package org.onap.sdc.common.versioning.services.convertors; + +import org.onap.sdc.common.versioning.services.types.Version; + +public interface VersionConvertor { + + String getItemType(); + + //Version toVersion(T model); + + void toVersion(T source, Version target); + + //void fromVersion(Version source, T target); + + T fromVersion(Version version); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java new file mode 100644 index 0000000..6440ccc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java @@ -0,0 +1,8 @@ +package org.onap.sdc.common.versioning.services.exceptions; + +public class VersioningException extends RuntimeException { + + public VersioningException(String message) { + super(message); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java new file mode 100644 index 0000000..47acabc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java @@ -0,0 +1,91 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.sdc.common.versioning.services.impl; + +import java.util.Collection; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; +import org.onap.sdc.common.versioning.services.ItemManager; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class ItemManagerImpl implements ItemManager { + + private final ItemDao itemDao; + + @Autowired + public ItemManagerImpl(ItemDao itemDao) { + this.itemDao = itemDao; + + } + + @Override + public Collection list(Predicate predicate) { + return itemDao.list().stream().filter(predicate).collect(Collectors.toList()); + } + + @Override + public Item get(String itemId) { + return itemDao.get(itemId); + } + + @Override + public Item create(Item item) { + InternalItem internalItem = new InternalItem(); + internalItem.populateExternalFields(item); + return itemDao.create(internalItem); + } + + @Override + public Item update(String itemId, Item item) { + InternalItem internalItem = getItem(itemId); + internalItem.populateExternalFields(item); + itemDao.update(internalItem); + return internalItem; + } + + @Override + public void delete(String itemId) { + itemDao.delete(itemId); + } + + @Override + public void updateStatus(String itemId, ItemStatus status) { + InternalItem item = getItem(itemId); + if (item.getStatus() == status) { + throw new VersioningException( + String.format("Update status of item %s failed, it is already in status %s", item.getId(), status)); + } + + item.setStatus(status); + itemDao.update(item); + } + + private InternalItem getItem(String itemId) { + InternalItem item = itemDao.get(itemId); + if (item == null) { + throw new VersioningException(String.format("Item with Id %s does not exist", itemId)); + } + return item; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java new file mode 100644 index 0000000..a98fa58 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java @@ -0,0 +1,46 @@ +package org.onap.sdc.common.versioning.services.impl; + +import java.util.HashSet; +import java.util.Set; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.springframework.stereotype.Service; + +@Service +public class MajorVersionCalculatorImpl implements VersionCalculator { + + private static final String INITIAL_VERSION = "1.0"; + private static final String VERSION_STRING_VIOLATION_MSG = + "Version string must be in the format of: {integer}.{integer}"; + + @Override + public String calculate(String baseVersion, VersionCreationMethod creationMethod) { + + if (baseVersion == null) { + return INITIAL_VERSION; + } + + String[] versionLevels = baseVersion.split("\\."); + if (versionLevels.length != 2) { + throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG); + } + + int index = Integer.parseInt(versionLevels[0]); + index++; + + return index + ".0"; + } + + @Override + public void injectAdditionalInfo(Version version, Set existingVersions) { + Set optionalCreationMethods = new HashSet<>(); + if (version.getStatus().equals(VersionStatus.Certified)) { + String nextVersion = calculate(version.getName(), VersionCreationMethod.major); + if (!existingVersions.contains(nextVersion)) { + optionalCreationMethods.add(VersionCreationMethod.major); + } + } + version.addProperty("OptionalCreationMethods", optionalCreationMethods); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java new file mode 100644 index 0000000..203dfbb --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java @@ -0,0 +1,12 @@ +package org.onap.sdc.common.versioning.services.impl; + +import java.util.Set; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; + +public interface VersionCalculator { + + String calculate(String baseVersion, VersionCreationMethod creationMethod); + + void injectAdditionalInfo(Version version, Set existingVersions); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java new file mode 100644 index 0000000..601f517 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java @@ -0,0 +1,202 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.sdc.common.versioning.services.impl; + + +import static org.onap.sdc.common.versioning.services.types.VersionStatus.Certified; +import static org.onap.sdc.common.versioning.services.types.VersionStatus.Draft; + +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.onap.sdc.common.versioning.persistence.VersionDao; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.VersioningManager; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.SynchronizationState; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class VersioningManagerImpl implements VersioningManager { + + //private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class); + + private final ItemDao itemDao; + private final VersionDao versionDao; + private final VersionCalculator versionCalculator; + + @Autowired + public VersioningManagerImpl(VersionDao versionDao, VersionCalculator versionCalculator, ItemDao itemDao) { + this.itemDao = itemDao; + this.versionDao = versionDao; + this.versionCalculator = versionCalculator; + } + + + @Override + public List list(String itemId) { + List versions = versionDao.list(itemId); + Set versionsNames = versions.stream().map(Version::getName).collect(Collectors.toSet()); + versions.forEach(version -> versionCalculator.injectAdditionalInfo(version, versionsNames)); + return versions.stream().map(version -> (Version) version).collect(Collectors.toList()); + } + + @Override + public Version get(String itemId, String versionId) { + return getVersion(itemId, versionId); + } + + @Override + public Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod) { + InternalVersion internalVersion = new InternalVersion(); + internalVersion.setBaseId(baseVersionId); + internalVersion.populateExternalFields(version); + + String baseVersionName = null; + if (baseVersionId != null) { + Version baseVersion = getVersion(itemId, baseVersionId); + validateBaseVersion(itemId, baseVersion); + baseVersionName = baseVersion.getName(); + } + String versionName = versionCalculator.calculate(baseVersionName, creationMethod); + validateVersionName(itemId, versionName); + internalVersion.setName(versionName); + + InternalVersion createdVersion = versionDao.create(itemId, internalVersion); + + updateStatusOnItem(itemId, Draft, null); + + publish(itemId, createdVersion.getId(), String.format("Create version: %s", versionName)); + return createdVersion; + } + + @Override + public Version update(String itemId, String versionId, Version version) { + InternalVersion internalVersion = getVersion(itemId, versionId); + internalVersion.populateExternalFields(version); + versionDao.update(itemId, internalVersion); + return internalVersion; + } + + @Override + public void updateStatus(String itemId, String versionId, VersionStatus status, String message) { + InternalVersion version = getVersion(itemId, versionId); + + VersionStatus prevStatus = version.getStatus(); + if (prevStatus == status) { + throw new VersioningException( + String.format("Item %s: update version status failed, version %s is already in status %s", itemId, + version.getId(), status)); + } + + version.setStatus(status); + versionDao.update(itemId, version); + + publish(itemId, versionId, message); + + updateStatusOnItem(itemId, status, prevStatus); + } + + @Override + public void publish(String itemId, String versionId, String message) { + versionDao.publish(itemId, versionId, message); + } + + @Override + public void sync(String itemId, String versionId) { + versionDao.sync(itemId, versionId); + } + + @Override + public void forceSync(String itemId, String versionId) { + versionDao.forceSync(itemId, versionId); + } + + @Override + public void revert(String itemId, String versionId, String revisionId) { + versionDao.revert(itemId, versionId, revisionId); + } + + @Override + public List listRevisions(String itemId, String versionId) { + return versionDao.listRevisions(itemId, versionId); + } + + @Override + public void clean(String itemId, String versionId) { + versionDao.clean(itemId, versionId); + } + + private InternalVersion getVersion(String itemId, String versionId) { + return versionDao.get(itemId, versionId) + .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion)) + .orElseGet(() -> getSyncedVersion(itemId, versionId)); + } + + private InternalVersion getUpdateRetrievedVersion(String itemId, InternalVersion version) { + if (version.getStatus() == Certified + && version.getState().getSynchronizationState() == SynchronizationState.OutOfSync) { + forceSync(itemId, version.getId()); + //LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId()); + version = versionDao.get(itemId, version.getId()).orElseThrow(() -> new IllegalStateException( + "Get version after a successful force sync must return the version")); + } + return version; + } + + private InternalVersion getSyncedVersion(String itemId, String versionId) { + sync(itemId, versionId); + //LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId()); + return versionDao.get(itemId, versionId).orElseThrow( + () -> new IllegalStateException("Get version after a successful sync must return the version")); + } + + private void validateBaseVersion(String itemId, Version baseVersion) { + if (Certified != baseVersion.getStatus()) { + throw new VersioningException( + String.format("Item %s: base version %s must be Certified", itemId, baseVersion.getId())); + } + } + + private void validateVersionName(String itemId, String versionName) { + if (versionDao.list(itemId).stream().anyMatch(version -> versionName.equals(version.getName()))) { + throw new VersioningException( + String.format("Item %s: create version failed, a version with the name %s already exist", itemId, + versionName)); + } + } + + private void updateStatusOnItem(String itemId, VersionStatus addedVersionStatus, + VersionStatus removedVersionStatus) { + InternalItem item = itemDao.get(itemId); + if (item == null) { + throw new VersioningException(String.format("Item with Id %s does not exist", itemId)); + } + item.addVersionStatus(addedVersionStatus); + if (removedVersionStatus != null) { + item.removeVersionStatus(removedVersionStatus); + } + itemDao.update(item); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java new file mode 100644 index 0000000..796fc1a --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java @@ -0,0 +1,55 @@ +/* + * + * Copyright © 2017-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.onap.sdc.common.versioning.services.types; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import lombok.Getter; +import lombok.Setter; + +@Getter +public class Item { + + protected String id; + protected Date creationTime; + protected Date modificationTime; + protected ItemStatus status; + @Setter + private String type; + @Setter + private String name; + @Setter + private String owner; + @Setter + private String description; + private Map properties = new HashMap<>(); + + public boolean isNew() { + return id == null; + } + + public void addProperty(String key, Object value) { + properties.put(key, value); + } + + public T getProperty(String key) { + return (T) properties.get(key); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java new file mode 100644 index 0000000..57b5f23 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java @@ -0,0 +1,5 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum ItemStatus { + ACTIVE, ARCHIVED +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java new file mode 100644 index 0000000..10cadb5 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java @@ -0,0 +1,15 @@ +package org.onap.sdc.common.versioning.services.types; + +import java.util.Date; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class Revision { + + private String id; + private String message; + private Date time; + private String user; +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java new file mode 100644 index 0000000..dd2efcc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum SynchronizationState { + UpToDate("Up to date"), + OutOfSync("Out of sync"), + Merging("Merging"); + + private final String displayName; + + SynchronizationState(String displayName) { + this.displayName = displayName; + } + + public String toString() { + return this.displayName; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java new file mode 100644 index 0000000..5cb0b69 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java @@ -0,0 +1,56 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.sdc.common.versioning.services.types; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@NoArgsConstructor +public class Version { + + protected String id; + protected String baseId; + protected String name; + protected VersionStatus status = VersionStatus.Draft; + protected VersionState state; + protected Date creationTime; + protected Date modificationTime; + @Setter + private String description; + private Map properties = new HashMap<>(); + + public boolean isNew() { + return id == null; + } + + public void addProperty(String key, Object value) { + properties.put(key, value); + } + + public T getProperty(String key) { + return (T) properties.get(key); + } +} \ No newline at end of file diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java new file mode 100644 index 0000000..3e18c28 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java @@ -0,0 +1,5 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum VersionCreationMethod { + major, minor +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java new file mode 100644 index 0000000..755c671 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java @@ -0,0 +1,11 @@ +package org.onap.sdc.common.versioning.services.types; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class VersionState { + private SynchronizationState synchronizationState; + private boolean dirty; +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java new file mode 100644 index 0000000..53c2e8f --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java @@ -0,0 +1,21 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.sdc.common.versioning.services.types; + +public enum VersionStatus { + Draft, Certified, Deprecated, Deleted +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java new file mode 100644 index 0000000..771959b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java @@ -0,0 +1,25 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.sdc.common.versioning.services.types; + +public enum VersionType { + Draft, Finalized +} -- cgit 1.2.3-korg