Search in sources :

Example 21 with Sequence

use of commonj.sdo.Sequence in project eclipselink by eclipse-ee4j.

the class SDOHelperTestCases method testUnwrapSequence.

/**
 * Also tests getSequence method.
 */
public void testUnwrapSequence() {
    Sequence teamSeq = teamDO.getSequence();
    assertTrue(SDOHelper.unwrap(teamSeq, SDOSequence.class) instanceof SDOSequence);
}
Also used : Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence)

Example 22 with Sequence

use of commonj.sdo.Sequence in project eclipselink by eclipse-ee4j.

the class SDOUnmarshalListener method afterUnmarshal.

/**
 * @param target assumed to be non-null
 * @param parent may be null, indicating target is root object
 */
@Override
public void afterUnmarshal(Object target, Object parent) {
    SDODataObject targetDataObject;
    // assume target is DataObject or ChangeSummary
    try {
        targetDataObject = (SDODataObject) target;
    } catch (ClassCastException ccex) {
        // each time we hit a ChangeSummary store it to process later and set its root
        // object - this is because we can't fully process the cs's because they have
        // references that can't be resolved until the full tree is built
        SDOChangeSummary sdoChangeSummary = (SDOChangeSummary) target;
        sdoChangeSummary.setRootDataObject((DataObject) parent);
        getChangeSummaries().add(sdoChangeSummary);
        return;
    }
    // if getType is sequenced, then update values to settings map
    if (targetDataObject.getType().isSequenced()) {
        targetDataObject.getSequence().afterUnmarshal();
    }
    // the last object that will hit the afterUnmarshal method
    if (parent == null && null != changeSummaries) {
        XMLUnmarshaller unmarshaller = null;
        for (int i = 0, changeSummariesSize = changeSummaries.size(); i < changeSummariesSize; i++) {
            SDOChangeSummary nextCS = changeSummaries.get(i);
            // Set logging to true until finished building modified list.
            boolean loggingValue = nextCS.isLoggingMapping();
            nextCS.setLogging(true);
            // CREATES
            // For each xpath in the create attribute convert it to an sdo path and execute it against the root
            // dataobject to get the dataobject being pointed to and set that dataobject to be created
            List xpaths = nextCS.getCreatedXPaths();
            for (int j = 0, xpathsSize = xpaths.size(); j < xpathsSize; j++) {
                String nextXPath = (String) xpaths.get(j);
                String sdoPath = convertXPathToSDOPath(nextXPath);
                SDODataObject nextCreatedDO = targetDataObject.getDataObject(sdoPath);
                if (nextCreatedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "/";
                    }
                    nextCreatedDO = targetDataObject.getDataObject(sdoPath);
                }
                if (nextCreatedDO != null) {
                    nextCreatedDO._setCreated(true);
                    nextCS.getOldContainers().remove(nextCreatedDO);
                } else {
                    throw SDOException.errorProcessingXPath(nextXPath);
                }
            }
            // clear the createxpaths list that was read in from XML
            nextCS.setCreatedXPaths(null);
            // MODIFIED
            List modifiedDoms = nextCS.getModifiedDoms();
            for (int j = 0, modifiedDomsSize = modifiedDoms.size(); j < modifiedDomsSize; j++) {
                Element nextNode = (Element) modifiedDoms.get(j);
                String refValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_REF);
                if ((refValue == null) || (refValue.length() == 0)) {
                    throw SDOException.missingRefAttribute();
                }
                // nextModifiedDO is the real modified current data object
                String sdoPath = convertXPathToSDOPath(refValue);
                SDODataObject nextModifiedDO = targetDataObject.getDataObject(sdoPath);
                // if it failed, try peeling off the first fragment (may be the root
                if (nextModifiedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "/";
                    }
                    nextModifiedDO = targetDataObject.getDataObject(sdoPath);
                }
                String unsetValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_UNSET);
                List unsetValueList = new ArrayList();
                if ((unsetValue != null) && (unsetValue.length() > 0)) {
                    XMLConversionManager xmlConversionManager = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlConversionManager();
                    unsetValueList = xmlConversionManager.convertObject(unsetValue, List.class);
                }
                if (nextModifiedDO != null) {
                    nextModifiedDO._setModified(true);
                    SDOCSUnmarshalListener listener = new SDOCSUnmarshalListener(nextModifiedDO.getType().getHelperContext(), true);
                    if (null == unmarshaller) {
                        unmarshaller = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlContext().createUnmarshaller();
                    }
                    unmarshaller.setUnmarshalListener(listener);
                    unmarshaller.getProperties().put("sdoHelperContext", aHelperContext);
                    unmarshaller.setUnmappedContentHandlerClass(SDOUnmappedContentHandler.class);
                    Object unmarshalledNode = unmarshaller.unmarshal(nextNode, nextModifiedDO.getType().getXmlDescriptor().getJavaClass());
                    // unmarshalledDO is the modified dataobject from the changesummary xml
                    SDODataObject unmarshalledDO = null;
                    // Assumption: unmarshalledNode should always be either an instance of XMLRoot or DataObject
                    if (unmarshalledNode instanceof XMLRoot) {
                        unmarshalledDO = (SDODataObject) ((XMLRoot) unmarshalledNode).getObject();
                    } else if (unmarshalledNode instanceof DataObject) {
                        unmarshalledDO = (SDODataObject) unmarshalledNode;
                    }
                    List modifiedProps = new ArrayList();
                    Node n = nextNode.getFirstChild();
                    TypeHelper typeHelper = aHelperContext.getTypeHelper();
                    while (n != null) {
                        if (n.getNodeType() == Node.ELEMENT_NODE) {
                            String propName = n.getLocalName();
                            Property nextProp = unmarshalledDO.getInstanceProperty(propName);
                            if (nextProp == null) {
                                nextProp = typeHelper.getOpenContentProperty(n.getNamespaceURI(), propName);
                            }
                            if (!modifiedProps.contains(nextProp)) {
                                modifiedProps.add(nextProp);
                            }
                        }
                        n = n.getNextSibling();
                    }
                    // instead of iterating over all props can we just check elements in cs and get appropriate properties from DO
                    for (int k = 0, modifiedPropsSize = modifiedProps.size(); k < modifiedPropsSize; k++) {
                        SDOProperty nextProp = (SDOProperty) modifiedProps.get(k);
                        if (!nextProp.getType().isDataType()) {
                            if (nextProp.isMany()) {
                                // original value is the list from the changesummary xml
                                List originalValue = unmarshalledDO.getList(nextProp);
                                List newList = new ArrayList();
                                List toDelete = new ArrayList();
                                List indexsToDelete = new ArrayList();
                                for (int l = 0, originalValueSize = originalValue.size(); l < originalValueSize; l++) {
                                    SDODataObject nextInList = (SDODataObject) originalValue.get(l);
                                    String sdoRef = nextInList._getSdoRef();
                                    if (sdoRef != null) {
                                        // if sdoRef is not null then object is modified
                                        String sdoRefPath = convertXPathToSDOPath(sdoRef);
                                        int nextSlash = sdoRefPath.indexOf('/');
                                        if (nextSlash != -1) {
                                            sdoRefPath = sdoRefPath.substring(nextSlash + 1);
                                        } else {
                                            sdoRefPath = "/";
                                        }
                                        newList.add(targetDataObject.getDataObject(sdoRefPath));
                                    } else {
                                        // if sdo ref is null there is a deleted object
                                        toDelete.add(nextInList);
                                        indexsToDelete.add(l);
                                        newList.add(nextInList);
                                    }
                                }
                                // lw is the list from the real current data object
                                ListWrapper lw = ((ListWrapper) nextModifiedDO.getList(nextProp));
                                int indexsToDeleteSize = indexsToDelete.size();
                                if (indexsToDeleteSize > 0) {
                                    // after this loop, lw will have the entire list when logging was turned on
                                    nextCS.pauseLogging();
                                    for (int m = 0; m < indexsToDeleteSize; m++) {
                                        int toDeleteIndex = (Integer) indexsToDelete.get(m);
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        lw.add(toDeleteIndex, nextToDelete);
                                    }
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, lw);
                                    SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                    nextCS.resumeLogging();
                                    nextModifiedDO._setModified(true);
                                    for (int m = indexsToDeleteSize - 1; m >= 0; m--) {
                                        int toDeleteIndex = (Integer) indexsToDelete.get(m);
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, nextToDelete);
                                        }
                                        nextToDelete.resetChanges();
                                        lw.remove(toDeleteIndex);
                                    }
                                }
                                nextCS.getOriginalElements().put(lw, newList);
                            } else {
                                SDODataObject value = unmarshalledDO.getDataObject(nextProp);
                                if (value != null) {
                                    String sdoRef = value._getSdoRef();
                                    if (sdoRef != null) {
                                        // modified
                                        nextModifiedDO._setModified(true);
                                    } else {
                                        // deleted
                                        value._setChangeSummary(nextCS);
                                        nextModifiedDO._setModified(true);
                                        nextCS.pauseLogging();
                                        boolean wasSet = nextModifiedDO.isSet(nextProp);
                                        Object existingValue = nextModifiedDO.get(nextProp);
                                        // grab index of nextProp's Setting for use during setting below
                                        Sequence nextModifiedDOSequence = nextModifiedDO.getSequence();
                                        int settingIdx = -1;
                                        if (nextModifiedDOSequence != null) {
                                            settingIdx = ((SDOSequence) nextModifiedDOSequence).getIndexForProperty(nextProp);
                                        }
                                        value._setContainmentPropertyName(null);
                                        value._setContainer(null);
                                        nextModifiedDO.set(nextProp, value);
                                        nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                                        SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, value);
                                        }
                                        nextCS.resumeLogging();
                                        nextModifiedDO._setModified(true);
                                        value.resetChanges();
                                        value.delete();
                                        if (wasSet) {
                                            // need to add at the right pos in the list, not at the end
                                            nextModifiedDO.set(nextProp, existingValue, false);
                                            if (settingIdx != -1) {
                                                nextModifiedDO.getSequence().addSettingWithoutModifyingDataObject(settingIdx, nextProp, existingValue);
                                            }
                                        } else {
                                            nextModifiedDO.unset(nextProp);
                                        }
                                    }
                                } else {
                                    nextModifiedDO._setModified(true);
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                                }
                            }
                        } else {
                            nextModifiedDO._setModified(true);
                            Object value = unmarshalledDO.get(nextProp);
                            if (nextProp.isMany()) {
                                Property theProp = nextModifiedDO.getInstanceProperty(nextProp.getName());
                                if (theProp == null) {
                                    Property newProp = nextModifiedDO.defineOpenContentProperty(nextProp.getName(), new ArrayList(), nextProp.getType());
                                    nextModifiedDO.set(newProp, new ArrayList());
                                    theProp = newProp;
                                }
                                List lw = nextModifiedDO.getList(theProp.getName());
                                nextCS.setPropertyInternal(nextModifiedDO, theProp, lw);
                                nextCS.getOriginalElements().put(lw, ((ListWrapper) value).getCurrentElements());
                            } else {
                                nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                            }
                        }
                    }
                    for (int k = 0, unsetValueListSize = unsetValueList.size(); k < unsetValueListSize; k++) {
                        SDOProperty nextProp = unmarshalledDO.getInstanceProperty((String) unsetValueList.get(k));
                        if (nextProp != null) {
                            Object oldValue = null;
                            if (nextProp.getType().isDataType() || nextProp.isMany()) {
                                // to get default
                                oldValue = unmarshalledDO.get(nextProp);
                            }
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, oldValue);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        } else {
                            nextProp = nextModifiedDO.getInstanceProperty((String) unsetValueList.get(k));
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        }
                    }
                } else {
                    throw SDOException.errorProcessingXPath(refValue);
                }
            }
            // clear modified doms list
            nextCS.setModifiedDoms(null);
            // clear deleted xpaths list
            nextCS.setDeletedXPaths(null);
            List created = nextCS.getCreated();
            for (int j = 0, createdSize = created.size(); j < createdSize; j++) {
                SDODataObject next = (SDODataObject) created.get(j);
                Property containmentProperty = next.getContainmentProperty();
                if (containmentProperty != null && containmentProperty.isMany()) {
                    SDODataObject container = next.getContainer();
                    ListWrapper list = (ListWrapper) container.get(containmentProperty);
                    if (!(nextCS.getOriginalElements().containsKey(list))) {
                        // if there was an object created as part of a list, and that list is not
                        // already in the original elements map. Add an empty list to the map.
                        nextCS.getOriginalElements().put(list, new ArrayList());
                    }
                }
            }
            nextCS.setLogging(loggingValue);
        }
        // reset changeSummary list - we are done with it
        changeSummaries = null;
    }
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) XMLRoot(org.eclipse.persistence.oxm.XMLRoot) Element(org.w3c.dom.Element) Node(org.w3c.dom.Node) ArrayList(java.util.ArrayList) Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) SDOChangeSummary(org.eclipse.persistence.sdo.SDOChangeSummary) ArrayList(java.util.ArrayList) List(java.util.List) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) XMLUnmarshaller(org.eclipse.persistence.oxm.XMLUnmarshaller) SDOProperty(org.eclipse.persistence.sdo.SDOProperty) Property(commonj.sdo.Property) SDOProperty(org.eclipse.persistence.sdo.SDOProperty) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) XMLConversionManager(org.eclipse.persistence.internal.oxm.XMLConversionManager)

Example 23 with Sequence

use of commonj.sdo.Sequence in project eclipselink by eclipse-ee4j.

the class ChangeSummaryXSDwSeqTestCases method testDetachYardDOViaSequenceRemoveAndUndo.

public void testDetachYardDOViaSequenceRemoveAndUndo() {
    DataObject shipToDO = rootObject.getDataObject("shipTo");
    // Property containmentProp = shipToDO.getInstanceProperty("yard");
    DataObject yardDO = shipToDO.getDataObject("yard");
    Object length = yardDO.get("length");
    cs.beginLogging();
    Sequence aSequence = shipToDO.getSequence();
    // remove/detach yardDO by index in its sequence instead of via property on shipToDO
    // aSequence.addText("Unstructured1");
    int yardIndex = getNthSequenceIndexFor((SDOSequence) aSequence, "yard");
    aSequence.remove(yardIndex);
    // yardDO.detach();
    List yardDOSettings = cs.getOldValues(yardDO);
    assertEquals(3, yardDOSettings.size());
    assertDetached(yardDO, cs);
    // assertModified(shipToDO, cs);
    assertFalse(cs.isModified(yardDO));
    assertEquals(2, cs.getChangedDataObjects().size());
    // return yardDOSettings;
    // check oldSequence before undo
    Sequence shipToSeqBefore = cs.getOldSequence(shipToDO);
    assertNotNull(shipToSeqBefore);
    cs.undoChanges();
    // check oldSequence after undo
    Sequence shipToSeqAfter = cs.getOldSequence(shipToDO);
    assertNotNull(shipToSeqAfter);
    // verify that object references in settings are the same ones on the valueStore
    assertFalse(cs.isDeleted(yardDO));
    // if we add new logic
    assertFalse(cs.isModified(shipToDO));
    // assertTrue(cs.isModified(shipToDO)); // see bug# 5882923 - we should clear the setting here
    assertFalse(cs.isModified(yardDO));
    // if we add new logic
    assertEquals(0, cs.getChangedDataObjects().size());
    // assertEquals(1, cs.getChangedDataObjects().size());//just shipTo
    assertEquals(14, ((SDOChangeSummary) cs).getOldContainer().size());
    assertEquals(14, ((SDOChangeSummary) cs).getOldContainmentProperty().size());
    List shipToSettings = cs.getOldValues(shipToDO);
    // 20070214: modified from 1
    assertEquals(0, shipToSettings.size());
    yardDOSettings = cs.getOldValues(yardDO);
    // see cs.getOldValues() does not return and empty List when yardDO is !modified and !deleted (but !created as well) - (re)set
    // was 3 before we implemented undoChanges()
    assertEquals(0, yardDOSettings.size());
    // see cs.getOldValue() does not return null when yardDO is !modified and !deleted (but !created as well) - (re)set
    ChangeSummary.Setting lengthSetting = cs.getOldValue(yardDO, yardDO.getInstanceProperty("length"));
    // assertNotNull(lengthSetting);
    assertNull(lengthSetting);
// assertEquals(length, lengthSetting.getValue());
// writeXML(rootObject);
}
Also used : SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) SDOChangeSummary(org.eclipse.persistence.sdo.SDOChangeSummary) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) ArrayList(java.util.ArrayList) List(java.util.List) Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) ChangeSummary(commonj.sdo.ChangeSummary) SDOChangeSummary(org.eclipse.persistence.sdo.SDOChangeSummary)

Example 24 with Sequence

use of commonj.sdo.Sequence in project eclipselink by eclipse-ee4j.

the class ChangeSummaryXSDwSeqTestCases method testUnmarshalSequenceOrderCorrect.

// verify order of sequence matches what is in the XML (not the XSD) document - to verify unmarshal
// Note: order should be the same except for special cases such as nulls or non-containment references
// see xmlhelper tests for full suite tests
public void testUnmarshalSequenceOrderCorrect() {
    // this test should fail until unmarshall is fully implemented
    DataObject shipToDO = rootObject.getDataObject("shipTo");
    // Property containmentProp = shipToDO.getInstanceProperty("yard");
    DataObject yardDO = shipToDO.getDataObject("yard");
    Object length = yardDO.get("length");
    cs.beginLogging();
    Sequence aSequence = shipToDO.getSequence();
    // <ns0:purchaseOrder orderDate="1999-10-20" xmlns:sdo="commonj.sdo" xmlns:ns0="http://www.example.org" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    // <ns0:myChangeSummary logging="true">
    // <ns0:shipTo country="US">
    // <ns0:name>Alice Smith</ns0:name>
    // <ns0:street>123 Maple Street</ns0:street>
    // <ns0:city>Mill Valley</ns0:city>
    // <ns0:state>CA</ns0:state>
    // <ns0:zip>90952</ns0:zip>
    // <ns0:yard>
    // <ns0:phone>
    // <ns0:phone>
    // <ns0:billTo country="US">
    // <ns0:comment>Hurry, my lawn is going wild!</ns0:comment>
    // <ns0:items>
    // <ns0:item partNum="872-AA">
    // <ns0:product>
    // <ns0:price>
    // <ns0:price>
    // <ns0:comment>Confirm this is electric2</ns0:comment>
    // <ns0:item partNum="926-AA">
    // <ns0:product>
    // <ns0:price>
    // <ns0:price>
    assertEquals(8, aSequence.size());
    assertEquals(aSequence.getValue(0), shipToDO.get("name"));
    assertEquals(aSequence.getValue(1), shipToDO.get("street"));
    assertEquals(aSequence.getValue(2), shipToDO.get("city"));
    assertEquals(aSequence.getValue(3), shipToDO.get("state"));
    assertEquals(aSequence.getValue(4), shipToDO.get("zip"));
    assertEquals(aSequence.getValue(5), shipToDO.get("yard"));
    assertEquals(aSequence.getValue(6), shipToDO.get("phone[1]"));
    assertEquals(aSequence.getValue(7), shipToDO.get("phone[2]"));
}
Also used : SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence)

Example 25 with Sequence

use of commonj.sdo.Sequence in project eclipselink by eclipse-ee4j.

the class ChangeSummaryGetOldSequenceTestCases method testGetOldSequenceNotSequenced.

public void testGetOldSequenceNotSequenced() {
    cs.beginLogging();
    DataObject lineItem1 = (DataObject) itemsObject.getList("item").get(0);
    assertNotNull(lineItem1);
    lineItem1.unset(0);
    Sequence oldLineItemSeq = cs.getOldSequence(lineItem1);
    // old seq should be null because line item is not sequenced
    assertNull(oldLineItemSeq);
}
Also used : DataObject(commonj.sdo.DataObject) Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence)

Aggregations

Sequence (commonj.sdo.Sequence)32 SDOSequence (org.eclipse.persistence.sdo.SDOSequence)29 DataObject (commonj.sdo.DataObject)18 SDODataObject (org.eclipse.persistence.sdo.SDODataObject)12 List (java.util.List)10 ArrayList (java.util.ArrayList)8 ChangeSummary (commonj.sdo.ChangeSummary)7 SDOChangeSummary (org.eclipse.persistence.sdo.SDOChangeSummary)6 SDOType (org.eclipse.persistence.sdo.SDOType)4 Property (commonj.sdo.Property)3 DataHelper (commonj.sdo.helper.DataHelper)1 TypeHelper (commonj.sdo.helper.TypeHelper)1 Iterator (java.util.Iterator)1 SDOException (org.eclipse.persistence.exceptions.SDOException)1 XMLConversionManager (org.eclipse.persistence.internal.oxm.XMLConversionManager)1 XMLRoot (org.eclipse.persistence.oxm.XMLRoot)1 XMLUnmarshaller (org.eclipse.persistence.oxm.XMLUnmarshaller)1 SequencedObject (org.eclipse.persistence.oxm.sequenced.SequencedObject)1 SDOProperty (org.eclipse.persistence.sdo.SDOProperty)1 ListWrapper (org.eclipse.persistence.sdo.helper.ListWrapper)1