public NakedObjectSpecification getSpecification() { return field.getSpecification(); } }
public int getPreferredWidth(final int i, final NakedObjectField specification) { NakedObjectSpecification type = specification.getSpecification(); if (type == null) { return 200; } Integer t = (Integer) types.get(type); if (t != null) { return t.intValue(); } else if (type.isOfType(NAKEDOBJECT)) { return 120; } else { return 100; } } }
public PropertyConverter getConverter(final NakedObjectField field) { return getConverter(field.getSpecification().getFullName()); }
private NakedObjectField[] tableFields(final NakedObjectField[] viewFields) { for (int i = 0; i < viewFields.length; i++) { if (viewFields[i].getSpecification().isOfType( NakedObjectsContext.getReflector().loadSpecification(ImageValue.class))) { continue; } if (!viewFields[i].isVisible()) { continue; } LOG.debug("column " + viewFields[i].getSpecification()); // if(viewFields[i].getSpecification().isOfType(NakedObjects.getSpecificationLoader().lo)); } NakedObjectField[] tableFields = new NakedObjectField[viewFields.length]; int c = 0; for (int i = 0; i < viewFields.length; i++) { if (!(viewFields[i] instanceof OneToManyAssociation)) { tableFields[c++] = viewFields[i]; } } NakedObjectField[] results = new NakedObjectField[c]; System.arraycopy(tableFields, 0, results, 0, c); return results; } }
/** * Check which classes/interfaces are used in associations, and mark them */ private void checkAssociations() { // make an array as we may modify the classes map, which would cause an exception in an iterator final PersistentNakedClass[] persistentClasses = classes.values().toArray(new PersistentNakedClass[0]); for (int i = 0; i < persistentClasses.length; i++) { final NakedObjectField[] fields = persistentClasses[i].getSpecification().getFields(); for (int j = 0; j < fields.length; j++) { final NakedObjectField field = fields[j]; if (field.isValue() || !field.isPersisted() || Features.isService(field.getSpecification()) || field.getSpecification().getFullName().startsWith("java.")) { continue; } // object or collection - for both getSpecification returns the spec of the associated object final String associatedClassName = field.getSpecification().getFullName(); if (!classes.containsKey(associatedClassName) && !interfaces.containsKey(associatedClassName)) { // enforce class must be in classes or interface maps throw new NakedObjectRuntimeException("Missing class/interface: " + field.getSpecification().getFullName()); } // if it's a class add a reference PersistentNakedClass associatedClass = classes.get(associatedClassName); if (associatedClass != null) { associatedClass.addReference(); } } } }
public String getDescription() { String name = getFieldName(); String type = getField().getSpecification().getSingularName(); type = name.indexOf(type) == -1 ? " (" + type + ")" : ""; String description = getOneToManyAssociation().getDescription(); return name + type + " " + description; }
public String getDescription() { String name = getFieldName(); String type = getField().getSpecification().getSingularName(); type = name.indexOf(type) == -1 ? " (" + type + ")" : ""; String description = getOneToOneAssociation().getDescription(); return name + type + " " + description; }
/** * Return the one, and only one association from this persistent class to the associated class. */ public NakedObjectField getUniqueAssociation(final String associatedClassName) { ensureUniqueFieldsResolved(); NakedObjectField association = null; for (int i = 0; i < uniqueFields.length; i++) { if (uniqueFields[i].isObject() || uniqueFields[i].isCollection()) { if (associatedClassName.equals(uniqueFields[i].getSpecification().getFullName())) { if (association != null) { return null; } association = uniqueFields[i]; } } } return association; }
public void resolveField(final NakedObject object, final NakedObjectField field) { ensureMapped(object); if (field.isObject() || field.isCollection()) { ensureMapped(field.getSpecification()); } wrapped.resolveField(object, field); }
final boolean nakedPropertyAccessor, final boolean valueFieldAccess) { if (Features.isService(field.getSpecification())) { property.addAttribute("type", DomainModelResourceType.class.getName()); if (valueFieldAccess) { final String fullName = field.getSpecification().getFullName();
private void checkInverseAssociations() { for (Iterator<PersistentNakedClass> iter = classes.values().iterator(); iter.hasNext();) { PersistentNakedClass persistentClass = iter.next(); NakedObjectField[] fields = persistentClass.getUniqueFields(); for (int i = 0; i < fields.length; i++) { if (fields[i].isValue() || !fields[i].isPersisted()) { continue; } PersistentNakedClass associatedClass = getPersistentClass(fields[i].getSpecification().getFullName()); if (associatedClass == null) { continue; } String inverse = getInverse(persistentClass, fields[i].getId()); if (inverse != null) { NakedObjectField associatedField = associatedClass.getSpecification().getField(inverse); Association association = new Association(associatedClass, associatedField, false); persistentClass.addAssociation(fields[i].getId(), association); Association reverseAssociation = new Association(persistentClass, fields[i], true); associatedClass.addAssociation(inverse, reverseAssociation); } } } }
LOG.debug("Binding persistent association [" + field.getId() + "]"); Element assnElement; if (persistentClasses.isPersistentClass(field.getSpecification().getFullName())) { assnElement = bindAssociation(classElement, persistentNakedClass, field, associationFieldAccess); } else if (persistentClasses.isPersistentInterface(field.getSpecification().getFullName()) || field.getSpecification().getFullName().equals("java.lang.Object")) { warnAnyAssociation(persistentNakedClass, field); assnElement = classElement.addElement("any").addAttribute("name", bindAnyAssociation(assnElement, field); } else { throw new NakedObjectRuntimeException("Un-mapped class/interface: " + field.getSpecification().getFullName());
/** * Create an assocation using an any mapping. */ private void bindAnyAssociation(final Element anyElement, final NakedObjectField field) { addIdType(field.getSpecification(), anyElement, "id-type", false, false); anyElement.addElement("column").addAttribute("name", deconflictColumnName(field.getId() + "type")); anyElement.addElement("column").addAttribute("name", deconflictColumnName(field.getId() + PRIMARY_KEY_SUFFIX)); return; }
if (Features.isService(field.getSpecification())) { addColumnAttribute(keyElement, FOREIGN_KEY_PREFIX + tableName.toLowerCase()); associationType = "element"; } else if (persistentClasses.isPersistentClass(field.getSpecification().getFullName())) { associationType = collections + "-to-many"; if ("many".equals(collections)) { } else if (!associationType.equals("many-to-any")) { final Element assnElement = collElement.addElement(associationType).addAttribute("class", field.getSpecification().getFullName()); PersistentNakedClass associatedClass = persistentClasses.getPersistentClass(field.getSpecification() .getFullName()); final String associatedTableName = deconflictTableName(associatedClass.getTableName());
private void updateField(final NakedObject object, ObjectData od, NakedObjectField field) { Object fieldData = od.getEntry(field.getId()); if (field.isCollection()) { updateOneToManyAssociation(object, (OneToManyAssociation) field, (CollectionData) fieldData); } else if (field.isObject()) { updateOneToOneAssociation(object, (OneToOneAssociation) field, (Data) fieldData); } else if (field.isValue()) { NakedValue value = NakedObjectsContext.getObjectLoader().createValueInstance(field.getSpecification()); value.restoreFromEncodedString((String) fieldData); ((ValueAssociation) field).initValue(object, value); } }
continue; final String associatedClassName = field.getSpecification().getFullName(); if (!thisPersistentClass.isUniqueAssociation(associatedClassName)) { continue;
NakedObject adapter = NakedObjectsContext.getObjectLoader().recreateAdapterForPersistent(referenceOid, field.getSpecification()); if (!adapter.getResolveState().isDestroyed()) { adapter.changeState(ResolveState.DESTROYED);
/** * Create a simple assocation (to a class/interface) * * @param persistentNakedClass * @param associationFieldAccess */ private Element bindAssociation( final Element classElement, final PersistentNakedClass persistentNakedClass, final NakedObjectField field, final boolean associationFieldAccess) { final Association assn = persistentNakedClass.getAssociation(field.getId()); if (assn != null && assn.getField().isObject()) { if (assn.isInverse()) { final String FKColumn = deconflictColumnName(FOREIGN_KEY_PREFIX + field.getId()); return classElement.addElement("many-to-one") .addAttribute("name", getPropertyName(field, associationFieldAccess)).addAttribute("column", FKColumn) .addAttribute("class", field.getSpecification().getFullName()).addAttribute("unique", "true"); } else { return classElement.addElement("one-to-one").addAttribute("name", getPropertyName(field, associationFieldAccess)) .addAttribute("class", field.getSpecification().getFullName()).addAttribute("property-ref", getPropertyName(assn.getField(), associationFieldAccess)); } } final String FKColumn = deconflictColumnName(FOREIGN_KEY_PREFIX + field.getId()); return classElement.addElement("many-to-one").addAttribute("name", getPropertyName(field, associationFieldAccess)) .addAttribute("column", FKColumn).addAttribute("class", field.getSpecification().getFullName()); }
private Consent setFieldOfMatchingType(final NakedObject target, final NakedObject source) { if (target.getResolveState().isTransient() && source.getResolveState().isPersistent()) { return new Veto("Can't set field in persistent object with reference to non-persistent object"); } else { NakedObjectField[] fields = target.getSpecification().getDynamicallyVisibleFields(target); for (int i = 0; i < fields.length; i++) { NakedObjectField fld = fields[i]; if (fld.isObject() && source.getSpecification().isOfType(fld.getSpecification())) { if (fld.get(target) == null && ((OneToOneAssociation) fld).isAssociationValid(target, source).isAllowed()) { return new Allow("Set field " + fld.getName()); } } } return new Veto("No empty field accepting object of type " + source.getSpecification().getSingularName() + " in " + title()); } }
public Naked drop(final Content sourceContent) { if (sourceContent instanceof ObjectContent) { NakedObject source = (NakedObject) sourceContent.getNaked(); Assert.assertNotNull(source); NakedObject target = (NakedObject) getObject(); Assert.assertNotNull(target); if (canDrop(sourceContent).isAllowed()) { NakedObjectAction action = dropAction(source, target); if ((action != null) && action.isParameterSetValid(target, new NakedObject[] { source }).isAllowed()) { return action.execute(target, new NakedObject[] { source }); } else { NakedObjectField[] fields = target.getSpecification().getDynamicallyVisibleFields(target); for (int i = 0; i < fields.length; i++) { NakedObjectField fld = fields[i]; if (fld.isObject() && source.getSpecification().isOfType(fld.getSpecification())) { if (fld.get(target) == null && ((OneToOneAssociation) fld).isAssociationValid(target, source).isAllowed()) { ((OneToOneAssociation) fld).setAssociation(target, source); break; } } } } } } return null; }