diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts')
5 files changed, 509 insertions, 0 deletions
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java new file mode 100644 index 0000000000..4c981acee4 --- /dev/null +++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java @@ -0,0 +1,40 @@ +package org.openecomp.conflicts; + +import org.openecomp.conflicts.dao.ConflictsDaoFactory; +import org.openecomp.conflicts.impl.VspMergeHandler; +import org.openecomp.sdc.common.errors.CoreException; +import org.openecomp.sdc.datatypes.model.ItemType; +import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDaoFactory; +import org.openecomp.sdc.versioning.ItemManagerFactory; +import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder; +import org.openecomp.sdc.versioning.types.Item; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class ItemMergeHandlerFactoryImpl extends ItemMergeHandlerFactory { + // TODO: 11/1/2017 read this map from configuration, move Vsp merge handler to vsp lib, rearrange lib deps + private static final Map<ItemType, ItemMergeHandler> MERGE_HANDLER_BY_ITEM_TYPE = + new HashMap<>(); + + static { + MERGE_HANDLER_BY_ITEM_TYPE.put(ItemType.vsp, + new VspMergeHandler(ConflictsDaoFactory.getInstance().createInterface(), + VspMergeDaoFactory.getInstance().createInterface())); + } + + @Override + public Optional<ItemMergeHandler> createInterface(String itemId) { + Item item = ItemManagerFactory.getInstance().createInterface().get(itemId); + if (item == null) { + throw new CoreException(new EntityNotExistErrorBuilder("", itemId).build()); + } + return Optional.ofNullable(MERGE_HANDLER_BY_ITEM_TYPE.get(ItemType.valueOf(item.getType()))); + } + + @Override + public ItemMergeHandler createInterface() { + return null; // call the one with the item id arg + } +} diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java new file mode 100644 index 0000000000..7cb3598b9d --- /dev/null +++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java @@ -0,0 +1,17 @@ +package org.openecomp.conflicts.dao.impl.zusammen; + + +import org.openecomp.conflicts.dao.ConflictsDao; +import org.openecomp.conflicts.dao.ConflictsDaoFactory; +import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory; + +public class ConflictsDaoFactoryImpl extends ConflictsDaoFactory { + + private static final ConflictsDao INSTANCE = new + ConflictsDaoImpl(ZusammenAdaptorFactory.getInstance().createInterface()); + + @Override + public ConflictsDao createInterface() { + return INSTANCE; + } +} diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java new file mode 100644 index 0000000000..eac1be3b8e --- /dev/null +++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java @@ -0,0 +1,175 @@ +package org.openecomp.conflicts.dao.impl.zusammen; + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflict; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo; +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.ElementContext; +import com.amdocs.zusammen.datatypes.item.Item; +import com.amdocs.zusammen.datatypes.item.ItemVersion; +import com.amdocs.zusammen.datatypes.item.Resolution; +import org.openecomp.conflicts.dao.ConflictsDao; +import org.openecomp.conflicts.types.Conflict; +import org.openecomp.conflicts.types.ConflictResolution; +import org.openecomp.conflicts.types.ItemVersionConflict; +import org.openecomp.convertor.ElementConvertor; +import org.openecomp.core.zusammen.api.ZusammenAdaptor; +import org.openecomp.sdc.datatypes.model.ElementType; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToEntitlementPoolConvertor; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToFeatureGroupConvertor; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLicenseAgreementConvertor; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLicenseKeyGroupConvertor; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLimitConvertor; +import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToVLMGeneralConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentDependencyModelConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToCompositionEntityConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComputeConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToImageConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToMonitoringUploadMapConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToNetworkConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToNicConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToOrchestrationTemplateCandidateMapConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToProcessConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToServiceModelMapConvertor; +import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToVSPGeneralConvertor; +import org.openecomp.sdc.versioning.dao.types.Version; + +import static org.openecomp.core.zusammen.api.ZusammenUtil.buildElement; +import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext; + +public class ConflictsDaoImpl implements ConflictsDao { + private final ZusammenAdaptor zusammenAdaptor; + + public ConflictsDaoImpl(ZusammenAdaptor zusammenAdaptor) { + this.zusammenAdaptor = zusammenAdaptor; + } + + @Override + public boolean isConflicted(String itemId, Version version) { + com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict itemVersionConflict = + zusammenAdaptor + .getVersionConflict(createSessionContext(), new Id(itemId), new Id(version.getId())); + return !(itemVersionConflict == null + || (itemVersionConflict.getVersionDataConflict() == null + && itemVersionConflict.getElementConflictInfos().isEmpty())); + } + + @Override + public ItemVersionConflict getConflict(String itemId, Version version) { + return new ItemVersionConflictConvertorFromZusammen().convert(itemId, version, + zusammenAdaptor + .getVersionConflict(createSessionContext(), new Id(itemId), new Id(version.getId()))); + } + + @Override + public Conflict getConflict(String itemId, Version version, String conflictId) { + return zusammenAdaptor.getElementConflict(createSessionContext(), + new ElementContext(new Id(itemId), new Id(version.getId())), new Id(conflictId)) + .map(elementConflict -> convertElementConflict(conflictId, elementConflict)) + .orElse(null); + } + + @Override + public void resolveConflict(String itemId, Version version, String conflictId, + ConflictResolution conflictResolution) { + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(new Id(itemId), new Id(version.getId())); + + // TODO: 7/31/2017 when 'OTHER' resolution will be supported - populate zusammen element with it + zusammenAdaptor.resolveElementConflict(context, elementContext, + buildElement(new Id(conflictId), null), + Resolution.valueOf(conflictResolution.getResolution().name())); + } + + private Conflict convertElementConflict(String conflictId, ElementConflict elementConflict) { + Element element = elementConflict.getLocalElement() == null + ? elementConflict.getRemoteElement() + : elementConflict.getLocalElement(); + ElementType elementType = ElementConvertor.getElementType(element); + + Conflict conflict = + new Conflict(conflictId, elementType, ElementConvertor.getElementName(element)); + ElementConvertor convertor = getConvertor(elementType); + if (elementConflict.getLocalElement() != null) { + conflict.setYours(convertor.convert(elementConflict.getLocalElement())); + } + if (elementConflict.getRemoteElement() != null) { + conflict.setTheirs(convertor.convert(elementConflict.getRemoteElement())); + } + return conflict; + } + + private ElementConvertor getConvertor(ElementType type) { + switch (type) { + case VendorSoftwareProduct: + return new ElementToVSPGeneralConvertor(); + case Process: + return new ElementToProcessConvertor(); + case Nic: + return new ElementToNicConvertor(); + case Network: + return new ElementToNetworkConvertor(); + case SNMP_POLL: + case SNMP_TRAP: + case VES_EVENTS: + return new ElementToMonitoringUploadMapConvertor(); + case Image: + return new ElementToImageConvertor(); + case Compute: + return new ElementToComputeConvertor(); + case Component: + return new ElementToComponentConvertor(); + case ComponentDependencies: + return new ElementToComponentDependencyModelConvertor(); + case VendorLicenseModel: + return new ElementToVLMGeneralConvertor(); + case LicenseAgreement: + return new ElementToLicenseAgreementConvertor(); + case FeatureGroup: + return new ElementToFeatureGroupConvertor(); + case LicenseKeyGroup: + return new ElementToLicenseKeyGroupConvertor(); + case EntitlementPool: + return new ElementToEntitlementPoolConvertor(); + case Limit: + return new ElementToLimitConvertor(); + case OrchestrationTemplateCandidate: + return new ElementToOrchestrationTemplateCandidateMapConvertor(); + case ServiceModel: + return new ElementToServiceModelMapConvertor(); + case VSPQuestionnaire: + case ImageQuestionnaire: + case ComponentQuestionnaire: + case ComputeQuestionnaire: + case NicQuestionnaire: + return new ElementToCompositionEntityConvertor(); + default: + return new EchoConvertor(); + } + } + + public static class EchoConvertor extends ElementConvertor { + + @Override + public Object convert(Element element) { + return element; + } + + @Override + public Object convert(Item item) { + return item; + } + + @Override + public Object convert(ElementInfo elementInfo) { + return elementInfo; + } + + @Override + public Object convert(ItemVersion itemVersion) { + return null; + } + } +} diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java new file mode 100644 index 0000000000..4dffaf8231 --- /dev/null +++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java @@ -0,0 +1,73 @@ +package org.openecomp.conflicts.dao.impl.zusammen; + + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflictInfo; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict; +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.item.ItemVersion; +import com.amdocs.zusammen.datatypes.item.ItemVersionData; +import com.amdocs.zusammen.datatypes.item.ItemVersionDataConflict; +import org.openecomp.conflicts.types.Conflict; +import org.openecomp.conflicts.types.ConflictInfo; +import org.openecomp.sdc.datatypes.model.ElementType; +import org.openecomp.sdc.versioning.dao.impl.zusammen.convertor.ItemVersionToVersionConvertor; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.types.ElementPropertyName; + +import java.util.stream.Collectors; + +public class ItemVersionConflictConvertorFromZusammen { + public org.openecomp.conflicts.types.ItemVersionConflict convert(String itemId, Version version, + ItemVersionConflict source) { + org.openecomp.conflicts.types.ItemVersionConflict target = + new org.openecomp.conflicts.types.ItemVersionConflict(); + + target.setVersionConflict( + convertVersionDataConflict(itemId, version, source.getVersionDataConflict())); + target.setElementConflicts(source.getElementConflictInfos().stream() + .map(this::convertElementConflictInfo) + .collect(Collectors.toList())); + + return target; + } + + + private Conflict<Version> convertVersionDataConflict(String itemId, Version version, + ItemVersionDataConflict versionDataConflict) { + if (versionDataConflict == null) { + return null; + } + + Conflict<Version> conflict = + new Conflict<>(version.getId(), ElementType.itemVersion, null); + + ItemVersionToVersionConvertor convertor = new ItemVersionToVersionConvertor(); + conflict.setYours(convertor.convert( + getItemVersion(version.getId(), versionDataConflict.getLocalData()))); + conflict.setTheirs(convertor.convert( + getItemVersion(version.getId(), versionDataConflict.getRemoteData()))); + return conflict; + } + + private ItemVersion getItemVersion(String versionId, ItemVersionData versionData) { + if (versionData == null) { + return null; + } + ItemVersion itemVersion = new ItemVersion(); + itemVersion.setId(new Id(versionId)); + itemVersion.setData(versionData); + return itemVersion; + } + + private ConflictInfo convertElementConflictInfo(ElementConflictInfo elementConflictInfo) { + ElementInfo elementInfo = elementConflictInfo.getLocalElementInfo() == null + ? elementConflictInfo.getRemoteElementInfo() + : elementConflictInfo.getLocalElementInfo(); + + return new ConflictInfo(elementInfo.getId().getValue(), + ElementType + .valueOf(elementInfo.getInfo().getProperty(ElementPropertyName.elementType.name())), + elementInfo.getInfo().getName()); + } +} diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java new file mode 100644 index 0000000000..f7d0bca392 --- /dev/null +++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java @@ -0,0 +1,204 @@ +package org.openecomp.conflicts.impl; + +import org.openecomp.conflicts.ItemMergeHandler; +import org.openecomp.conflicts.dao.ConflictsDao; +import org.openecomp.conflicts.types.Conflict; +import org.openecomp.conflicts.types.ConflictInfo; +import org.openecomp.conflicts.types.ConflictResolution; +import org.openecomp.conflicts.types.ItemVersionConflict; +import org.openecomp.conflicts.types.Resolution; +import org.openecomp.sdc.common.errors.CoreException; +import org.openecomp.sdc.common.errors.ErrorCategory; +import org.openecomp.sdc.common.errors.ErrorCode; +import org.openecomp.sdc.datatypes.model.ElementType; +import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao; +import org.openecomp.sdc.versioning.dao.types.Version; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.openecomp.sdc.datatypes.model.ElementType.NetworkPackage; +import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplate; +import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateCandidate; +import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateCandidateContent; +import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateValidationData; +import static org.openecomp.sdc.datatypes.model.ElementType.VspModel; + +public class VspMergeHandler implements ItemMergeHandler { + + private static final String VSP_MODEL_CONFLICT_ID = "vspModelConflictId"; + private static final String ELEMENT_CONFLICT_NOT_EXIST_ERR_ID = "ELEMENT_CONFLICT_NOT_EXIST"; + private static final String ELEMENT_CONFLICT_NOT_EXISTS_MSG = + "Item Id %s, version Id %s, element conflict with Id %s does not exists."; + private static final Set<ElementType> FILTERED_OUT_TYPES = Stream + .of(OrchestrationTemplateCandidateContent, OrchestrationTemplateValidationData) + .collect(Collectors.toSet()); + private static final Map<ElementType, Set<ElementType>> ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES = + new HashMap<>(); + + static { + ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplateCandidate, + Collections.singleton(OrchestrationTemplateCandidateContent)); + ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplate, + Collections.singleton(OrchestrationTemplateValidationData)); + } + + private ConflictsDao conflictsDao; + private VspMergeDao vspMergeDao; + + public VspMergeHandler(ConflictsDao conflictsDao, VspMergeDao vspMergeDao) { + this.conflictsDao = conflictsDao; + this.vspMergeDao = vspMergeDao; + } + + @Override + public boolean isConflicted(String itemId, Version version) { + return vspMergeDao.isVspModelConflicted(itemId, version); + } + + @Override + public void finalizeMerge(String itemId, Version version) { + if (!conflictsDao.isConflicted(itemId, version)) { + vspMergeDao.applyVspModelConflictResolution(itemId, version); + } + } + + @Override + public void postListConflicts(String itemId, Version version, ItemVersionConflict conflicts) { + List<ConflictInfo> elementConflicts = new ArrayList<>(); + + boolean vspModelConflicted = false; + for (ConflictInfo elementConflict : conflicts.getElementConflicts()) { + if (elementConflict.getType() == VspModel) { + elementConflicts.add( + new ConflictInfo(elementConflict.getId(), NetworkPackage, NetworkPackage.name())); + vspModelConflicted = true; + continue; + } + if (!FILTERED_OUT_TYPES.contains(elementConflict.getType())) { + elementConflicts.add(elementConflict); + } + } + + if (!vspModelConflicted && vspMergeDao.isVspModelConflicted(itemId, version)) { + elementConflicts + .add(new ConflictInfo(VSP_MODEL_CONFLICT_ID, NetworkPackage, NetworkPackage.name())); + } + + conflicts.setElementConflicts(elementConflicts); + } + + @Override + public Optional<Conflict> getConflict(String itemId, Version version, String conflictId) { + return VSP_MODEL_CONFLICT_ID.equals(conflictId) + ? Optional.of(buildVspModelConflict(conflictId)) + : Optional.empty(); + } + + @Override + public void postGetConflict(String itemId, Version version, Conflict conflict) { + if (conflict.getType() == VspModel) { + Conflict vspModelConflict = buildVspModelConflict(null); + conflict.setType(vspModelConflict.getType()); + conflict.setName(vspModelConflict.getName()); + conflict.setYours(vspModelConflict.getYours()); + conflict.setTheirs(vspModelConflict.getTheirs()); + } + } + + @Override + public void preResolveConflict(String itemId, Version version, String conflictId, + ConflictResolution resolution) { + if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) { + return; + } + resolveDependantConflicts(itemId, version, conflictId, resolution); + } + + @Override + public boolean resolveConflict(String itemId, Version version, String conflictId, + ConflictResolution resolution) { + if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) { + vspMergeDao.updateVspModelConflictResolution(itemId, version, + com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name())); + return true; + } + Conflict conflict = conflictsDao.getConflict(itemId, version, conflictId); + if (conflict == null) { + throw getConflictNotExistException(itemId, version, conflictId); + } + if (conflict.getType() == VspModel) { + vspMergeDao.updateVspModelConflictResolution(itemId, version, + com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name())); + + conflictsDao.resolveConflict(itemId, version, conflictId, new ConflictResolution( + conflict.getTheirs() == null ? Resolution.YOURS : Resolution.THEIRS)); + return true; + } + return false; + } + + private void resolveDependantConflicts(String itemId, Version version, String conflictId, + ConflictResolution resolution) { + ItemVersionConflict conflicts = conflictsDao.getConflict(itemId, version); + + Set<ElementType> conflictDependantTypes = + ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES + .get(findConflictById(conflicts, conflictId).getType()); + + if (conflictDependantTypes == null) { + return; + } + + findConflictsByTypes(conflicts, conflictDependantTypes) + .forEach(dependantConflict -> + conflictsDao.resolveConflict(itemId, version, dependantConflict.getId(), resolution)); + } + + private ConflictInfo findConflictById(ItemVersionConflict versionConflicts, + String conflictId) { + return versionConflicts.getElementConflicts().stream() + .filter(elementConflict -> conflictId.equals(elementConflict.getId())) + .findFirst() + .orElseThrow(() -> new IllegalStateException( + String.format("Conflict Id %s does not exist on conflicts list", conflictId))); + } + + private Collection<ConflictInfo> findConflictsByTypes(ItemVersionConflict versionConflicts, + Set<ElementType> elementTypes) { + return versionConflicts.getElementConflicts().stream() + .filter(elementConflict -> elementTypes.contains(elementConflict.getType())) + .collect(Collectors.toList()); + } + + private Conflict buildVspModelConflict(String conflictId) { + Conflict conflict = new Conflict(conflictId, NetworkPackage, NetworkPackage.name()); + + Map<String, String> yours = new HashMap<>(); + yours.put("File", "Local (Me)"); + conflict.setYours(yours); + + Map<String, String> theirs = new HashMap<>(); + theirs.put("File", "Last Committed"); + conflict.setTheirs(theirs); + return conflict; + } + + private CoreException getConflictNotExistException(String itemId, Version version, + String conflictId) { + return new CoreException(new ErrorCode.ErrorCodeBuilder() + .withCategory(ErrorCategory.APPLICATION) + .withId(ELEMENT_CONFLICT_NOT_EXIST_ERR_ID) + .withMessage( + String.format(ELEMENT_CONFLICT_NOT_EXISTS_MSG, itemId, version.getId(), conflictId)) + .build()); + } +} |