private void reportPropertyTypes(DataObject data) throws Exception { ObjectType type = data.getObjectType(); Iterator keys = type.getProperties(); s_log.info("Properties for type: " + type.getName()); while (keys.hasNext()) { Property p = (Property) keys.next(); if (p.isAttribute()) { String msg = "Property " + p.getName() + " is attribute. Class is: " + p.getJavaClass(); if (type.isKeyProperty(p)) { msg += " is key property."; } msg += " value is: " + data.get(p.getName()); s_log.info(msg); } else { s_log.info( "Property " + p.getName() + " is component: " + p.isComponent() + " is collection: " + p.isCollection() + " is role: " + p.isRole()); s_log.info("ObjectType is is: " + p.getType().getName()); } } s_log.info("END Properties for type: " + type.getName()); }
public void manipulate(Property p, DataObject dataInner) throws Exception { s_log.debug("checking property: " + p.getName()); Object currentVal = dataInner.get(p.getName()); DataObjectManipulator.SimpleTypeManipulator manip = m_manipulator.getManipulator(p); Object defaultVal = manip.getDefaultValue(); manip.checkEquals(p.getName(), defaultVal, currentVal); }
private void setDefaultProperties(DataObject data, DataObject associatedObject) throws Exception { final ObjectType type = data.getObjectType(); s_log.info(""); s_log.info("Making new object for: " + type.getQualifiedName()); KeyGenerator.setKeyValues(data); ObjectType associated = (associatedObject == null) ? null : associatedObject.getObjectType(); for (Iterator it = type.getKeyProperties(); it.hasNext(); ) { Property prop = (Property) it.next(); if (prop.isAttribute()) { continue; } DataType propType = prop.getType(); if (propType.equals(associated)) { data.set(prop.getName(), associatedObject); } else { makeChild(prop, data); } } PropertyManipulator.NonKeyManipulator manip = new PropertyManipulator.NonKeyManipulator(type) { public void manipulate(Property p, DataObject dataInner) throws Exception { m_manipulator.setDefaultProperty(p, dataInner); } }; PropertyManipulator.manipulateProperties(data, manip); s_log.info("END new object."); s_log.info(""); s_log.info(""); }
public SimpleTypeManipulator getManipulator(Property p) { SimpleTypeManipulator manip = (SimpleTypeManipulator) m_manipulators.get(p.getJavaClass()); if (null == manip) { throw new IllegalArgumentException( "Unsupported java type: " + p.getJavaClass() + " for Property " + p.getName()); } else { return manip; } }
public void assertPropertyClass(Property p) { final boolean classesDiffer = !m_propertyClass.equals(p.getJavaClass()); if (classesDiffer) { String msg = "Property: " + p.getName(); msg += " has a different JavaClass! Expecting " + m_propertyClass; msg += " but property is " + p.getJavaClass(); throw new IllegalArgumentException(msg); } }
private static final Column getColumn(Property p) { Root root = SessionManager.getSession().getMetadataRoot().getRoot(); ObjectMap om = root.getObjectMap(root.getObjectType(p.getContainer().getQualifiedName())); Mapping m = om.getMapping(Path.get(p.getName())); if (m instanceof Value) { return ((Value) m).getColumn(); } else { return null; } }
/** * Creates an OID with a single attribute for the key. To create a multi-valued OID, use a single * arg OID constructor, and add individual properties with the set method. This constructor should * be used when the object type being instantiated has a single primary key. For instance, if the * object type is <code>com.arsdigita.kernel.ACSObject</code> then the value should be the <code> * object_id</code>. So, if developers wanted to create the OID for ID zero, they would call * <code>new OID(acsObjectType, new BigDecimal(0))</code>. A <code>BigDecimal</code> is passed in * because the "id" attribute for the ACSObject type is declared as <code>BigDecimal</code> in the * PDL file. * * @param type The ObjectType of the ID * @param value The value of the ID * @exception PersistenceException will be thrown if the given object type does not have exactly a * single key (if <code>type.getObjectMap().getObjectKey().getCount() * != 1</code>). * @pre type != null * @pre type.getObjectMap().getObjectKey().getCount() == 1 */ public OID(ObjectType type, Object value) { this(type); Iterator it = type.getKeyProperties(); if (!it.hasNext()) { throw new PersistenceException("Empty object key: " + type); } Property prop = (Property) it.next(); if (it.hasNext()) { throw new PersistenceException("This object type has a compound key."); } String attr = prop.getName(); set(attr, value); }
/** * Iterates over all of the variantValues for the given Property and attempts to update the * property to that value. If an invalid failure to update occurs, an exception is thrown. * * @param p The property to update. * @param data The DataObject to save. * @pre p.equals(data.getObjectType.getProperty(p.getName())) */ public void updateAllPropertyCombinations(Property p, DataObject data) throws Exception { OID id = data.getOID(); s_log.info("Property " + p.getName() + " class is: " + p.getJavaClass()); // Verify that nulls are handled correctly for all columns setProperty(p, data, null); data = SessionManager.getSession().retrieve(id); Iterator iter = getVariantValues().iterator(); while (iter.hasNext()) { Object value = iter.next(); setProperty(p, data, value); // It is neccessary to re-fetch the DataObject, since some 'failed' updates // will not cause the test to fail, but will leave the DataObject in an inconsistent state. // These are proper update failures, such as an oversized default String value being sent // to a constrained column. data = SessionManager.getSession().retrieve(id); } }
private void makeChild(Property p, final DataObject parent) throws Exception { final String fullTypeName = p.getType().getQualifiedName(); s_log.info( "Making child object: " + fullTypeName + " for ObjectType: " + parent.getObjectType().getQualifiedName()); DataObject child = SessionManager.getSession().create(fullTypeName); reportPropertyTypes(child); initializeObject(child, parent); PropertyManipulator.AssociationManipulator manip = new PropertyManipulator.AssociationManipulator() { public boolean obeys(Property pInner) { final boolean isParentRef = super.obeys(pInner) && !pInner.isCollection() && pInner.getType().equals(parent.getObjectType()); return isParentRef; } public void manipulate(Property pInner, DataObject data) throws Exception { s_log.info( "Setting parent role reference for: " + fullTypeName + " Property: " + pInner.getName()); data.set(pInner.getName(), parent); } }; PropertyManipulator.manipulateProperties(child, manip); if (p.isCollection()) { DataAssociation children = (DataAssociation) parent.get(p.getName()); children.add(child); } else { parent.set(p.getName(), child); } }
/** * Logs the fact that a Property failed to update. If the column is specified, this is also * logged. The attemted update value is also logged. * * @param p The property that failed to update. * @param value The value that was used to update the property. */ void logSetError(Property p, Object value) { s_log.debug("Failed to set property " + p.getName()); final boolean columnIsSpecified = getColumn(p) != null; if (columnIsSpecified) { s_log.debug("Bound to column " + getColumn(p).getQualifiedName()); } else { s_log.debug("Column is not specified for property"); } s_log.debug("New Value is: " + value); }
private void makeAssociation(Property p, DataObject data) throws Exception { String fullTypeName = p.getType().getQualifiedName(); s_log.info( "Making associated object: " + fullTypeName + " for ObjectType: " + data.getObjectType().getQualifiedName()); DataObject associatedObject = SessionManager.getSession().create(fullTypeName); reportPropertyTypes(associatedObject); initializeObject(associatedObject, data); associatedObject.save(); reportPropertyTypes(associatedObject); s_log.info("Getting association: " + p.getName()); if (p.isCollection()) { DataAssociation assoc = (DataAssociation) data.get(p.getName()); assoc.add(associatedObject); } else { data.set(p.getName(), associatedObject); } }
/** * Adds a property to the OID. Is used as part of the key for the Object ID. * * @param propertyName Name of the property * @param value The property */ public void set(String propertyName, Object value) { Property prop = m_type.getProperty(propertyName); // We do some type-checking here, to ensure that OIDs are being // created with legit types of values. if (prop == null) { throw new PersistenceException( "no such property: " + propertyName + " for type " + m_type.getName()); } // null has no type // if prop isn't an attribute, not sure what to do with it. if (prop.isAttribute() && value != null) { // we can be sure this is a simpletype because // isAttribute was true. SimpleType expectedType = (SimpleType) prop.getType(); if (!expectedType.getJavaClass().isAssignableFrom(value.getClass())) { throw new PersistenceException( "expected " + expectedType.getJavaClass() + "actual type " + value.getClass()); } } else if (value != null) { if (value instanceof DataObject) { ObjectType ot = (ObjectType) prop.getType(); DataObject dobj = (DataObject) value; ObjectType.verifySubtype(ot, dobj.getObjectType()); } else { throw new PersistenceException( "expected DataObject for property " + propertyName + " but got " + value.getClass()); } } if (hasProperty(propertyName)) { throw new PersistenceException(propertyName + " is already set to " + get(propertyName)); } m_values.put(propertyName, value); }
public static final com.redhat.persistence.metadata.Property prop(Root root, Property prop) { return type(root, prop.getContainer().getQualifiedName()).getProperty(prop.getName()); }
/** * Attempts to update the Property to a given value. If an invalid failure to update occurs, an * exception is thrown. If the update appears successful, the DataObject is re-fetched from the * database, and the property value compared to what it should be. If they differ, an exception * is thrown. * * @param p The property to update. * @param data The DataObject to save. * @param value The value to update the property with. * @pre p.equals(data.getObjectType.getProperty(p.getName())) */ void setProperty(Property p, DataObject data, Object value) throws Exception { final String propName = p.getName(); OID id = data.getOID(); s_log.debug( "setting property : " + data.getObjectType().getQualifiedName() + "." + data.getObjectType().getName() + "." + p.getName()); // + " to value: " + value); s_log.debug("Old value was: " + data.get(p.getName())); final boolean valueIsNull = (value == null || value instanceof String && ((String) value).length() == 0); boolean savedNullInRequiredField = false; try { data.set(p.getName(), value); data.save(); // This is neccessary since fail cannot be called here. // Its exception would be caught. Need to check this // value after the catch block savedNullInRequiredField = (p.isRequired() && valueIsNull); } catch (Exception t) { if (p.isRequired() && valueIsNull) { return; } if (p.isNullable() && valueIsNull) { String msg = "Failed to save DataObject: " + data.getObjectType().getName(); msg += "\nTried to update nullable property " + p.getName(); msg += " with null value and failed!"; msg += "\nException is: " + t.getMessage(); s_log.debug(msg); throw new CheckedWrapperException(msg, t); } else { s_log.debug("Failed to set property " + p.getName()); s_log.debug("Checking error"); checkSetError(t, p, data, value); // if (DbHelper.getDatabase(getSession().getConnection()) == // DbHelper.DB_POSTGRES) { throw new AbortMetaTestException(); // } else { // return; // } } } if (savedNullInRequiredField) { String msg = "DataObject saved null value in a required Property: " + p.getName(); s_log.debug(msg); throw new Exception(msg); } DataObject fromDatabase = SessionManager.getSession().retrieve(id); Object newValue = fromDatabase.get(p.getName()); checkEquals(p.getName(), value, newValue); }
void setDefaultProperty(Property p, DataObject data) { assertPropertyClass(p); data.set(p.getName(), getDefaultValue()); }
private static boolean isNonKeyAttribute(Property p, ObjectType type) { return p.isAttribute() && !type.isKeyProperty(p); }