private void updateField(final NakedObject object, final ObjectData od, final NakedObjectAssociation field) { final Object fieldData = od.getEntry(field.getId()); if (field.isOneToManyAssociation()) { updateOneToManyAssociation(object, (OneToManyAssociation) field, (CollectionData) fieldData); } else if (field.getSpecification().containsFacet(EncodableFacet.class)) { final EncodableFacet facet = field.getSpecification().getFacet(EncodableFacet.class); final NakedObject value = facet.fromEncodedString((String) fieldData); ((OneToOneAssociation) field).initAssociation(object, value); } else if (field.isOneToOneAssociation()) { updateOneToOneAssociation(object, (OneToOneAssociation) field, (Data) fieldData); } }
private void ensureAssociationModifiableElseThrowException( final AuthenticationSession session, final NakedObject targetAdapter, final NakedObjectAssociation association) { if (!association.isVisible(session, targetAdapter).isAllowed() || association.isUsable(session, targetAdapter).isVetoed()) { throw new NakedObjectException("can't modify field as not visible or editable"); } }
public void resolveField(final NakedObject adapter, final NakedObjectAssociation field) { if (field.getSpecification().isCollectionOrIsAggregated()) { return; } final NakedObject referenceAdapter = field.get(adapter); if (referenceAdapter != null && referenceAdapter.getResolveState().isResolved()) { return; } if (referenceAdapter == null || !referenceAdapter.isPersistent()) { return; } if (LOG.isInfoEnabled()) { LOG.info("resolveField on server: " + adapter + "/" + field.getId()); } resolveFieldFromPersistenceLayer(adapter, field); }
public CollectionLink( final NakedObjectAssociation field, final NakedObject collection, final String description, final String objectId) { this.description = description; this.objectId = objectId; fieldId = field.getId(); title = collection.titleString(); specification = field.getSpecification(); }
public boolean accept(NakedObjectAssociation t) { return t.isOneToManyAssociation() || (t.isOneToOneAssociation() && !((OneToOneAssociation)t).getSpecification().isParseable()); } });
private static boolean skipField(final NakedObject object, final NakedObjectAssociation fld) { return fld.isOneToManyAssociation() || fld.isUsable(NakedObjectsContext.getAuthenticationSession(), object).isVetoed(); }
private Consent setFieldOfMatchingType(final NakedObject targetAdapter, final NakedObject sourceAdapter) { if (targetAdapter.isTransient() && sourceAdapter.isPersistent()) { // TODO: use Facet for this test instead. return new Veto("Can't set field in persistent object with reference to non-persistent object"); } final NakedObjectAssociation[] fields = targetAdapter.getSpecification().getAssociations( NakedObjectAssociationFilters.dynamicallyVisible(NakedObjectsContext.getAuthenticationSession(), targetAdapter)); for (final NakedObjectAssociation fld : fields) { if (!fld.isOneToOneAssociation()) { continue; } if (!sourceAdapter.getSpecification().isOfType(fld.getSpecification())) { continue; } if (fld.get(targetAdapter) != null) { continue; } final Consent associationValid = ((OneToOneAssociation) fld).isAssociationValid(targetAdapter, sourceAdapter); if (associationValid.isAllowed()) { return associationValid.setDescription("Set field " + fld.getName()); } } // TODO: use Facet for this test instead return new Veto(String.format("No empty field accepting object of type %s in %s", sourceAdapter.getSpecification() .getSingularName(), title())); }
debug.indent(); for (int i = 0; i < fields.length; i++) { debug.appendln((i + 1) + "." + fields[i].getId()); debug.indent(); for (int i = 0; i < fields2.length; i++) { debug.appendln((i + 1) + "." + fields2[i].getId()); debug.appendln((i + 1) + "." + field.getId() + " (" + field.getClass().getName() + ")"); final String description = field.getDescription(); if (description != null && !description.equals("")) { debug.appendln("Description", description); final String help = field.getHelp(); if (help != null && !help.equals("")) { debug debug.appendln("ID", field.getIdentifier()); debug.appendln("Short ID", field.getId()); debug.appendln("Name", field.getName()); final String type = field.isOneToManyAssociation() ? "Collection" : field.isOneToOneAssociation() ? "Object" : "Unknown"; debug.appendln("Type", type); debug.appendln("Has identity", !field.getSpecification().isCollectionOrIsAggregated()); debug.appendln("Spec", field.getSpecification().getFullName()); + (field.isMandatory() ? "Mandatory " : "")); final Class<? extends Facet>[] facets = field.getFacetTypes();
private ObjectData createObjectData(final NakedObject object, final boolean ensurePersistent) { LOG.debug("compiling object data for " + object); ObjectData data; data = new ObjectData(object.getSpecification(), (SerialOid) object.getOid(), (FileVersion) object.getVersion()); final NakedObjectAssociation[] fields = object.getSpecification().getAssociations(); for (int i = 0; i < fields.length; i++) { if (!fields[i].isPersisted()) { continue; } final NakedObject field = fields[i].get(object); final NakedObject fieldContent = field; final String fieldId = fields[i].getId(); if (fields[i].isOneToManyAssociation()) { data.addInternalCollection(fieldContent, fieldId, ensurePersistent); } else if (fields[i].getSpecification().isEncodeable()) { final boolean isEmpty = fields[i].isEmpty(object); if (field == null || isEmpty) { data.saveValue(fieldId, isEmpty, null); } else { final EncodeableFacet facet = fieldContent.getSpecification().getFacet(EncodeableFacet.class); final String encodedValue = facet.toEncodedString(fieldContent); data.saveValue(fieldId, isEmpty, encodedValue); } } else if (fields[i].isOneToOneAssociation()) { data.addAssociation(fieldContent, fieldId, ensurePersistent); } } return data; }
final NakedObjectAssociation fld = allFields[j]; fields[i] = fld; names[i] = fld.getName(); descriptions[i] = fld.getDescription(); final Consent usableByUser = fld.isUsable(NakedObjectsContext.getAuthenticationSession(), object); if (usableByUser.isVetoed()) { descriptions[i] = usableByUser.getReason(); fieldSpecifications[i] = fld.getSpecification(); initialState[i] = fld.get(object); if (skipField(object, fld)) { readOnly[i] = true; } else { readOnly[i] = false; optional[i] = !fld.isMandatory(); if (fieldSpecifications[i].isParseable()) { final MultiLineFacet multilineFacet = fld.getFacet(MultiLineFacet.class); noLines[i] = multilineFacet.numberOfLines(); wraps[i] = !multilineFacet.preventWrapping(); final MaxLengthFacet maxLengthFacet = fld.getFacet(MaxLengthFacet.class); maxLength[i] = maxLengthFacet.value(); final TypicalLengthFacet typicalLengthFacet = fld.getFacet(TypicalLengthFacet.class); typicalLength[i] = typicalLengthFacet.value();
int len = 0; for (int i = 0; i < visibleFields.length; i++) { if (!visibleFields[i].isOneToManyAssociation()) { fields[len++] = visibleFields[i]; table.addColumnHeader(fields[i].getName()); table.addRowHeader(context.getComponentFactory().createObjectIcon(element, elementId, "icon")); for (int i = 0; i < len; i++) { final NakedObject fld = fields[i].get(element); if (!fields[i].isVisible(NakedObjectsContext.getAuthenticationSession(), element).isAllowed()) { table.addEmptyCell(); } else if (fld.getSpecification().isParseable()) { final boolean shouldTruncate = multiline != null && multiline.numberOfLines() > 1; table.addCell(titleString, shouldTruncate); } else if (fields[i].isOneToOneAssociation() && fld == null) { table.addEmptyCell(); } else if (fields[i].isOneToOneAssociation()) { NakedObjectsContext.getPersistenceSession().resolveImmediately(fld); final String objectId = context.mapObject(fld);
final NakedObjectAssociation field = fieldFromActualSpec(spec, viewAxis.getFieldForColumn(i)); final View subview = subviews[i]; final NakedObject value = field.get(object); if (field.getSpecification().isParseable()) { final boolean visiblityChange = !field.isVisible(NakedObjectsContext.getAuthenticationSession(), object).isAllowed() ^ (subview instanceof BlankView); final NakedObject nakedObject = subview.getContent().getNaked(); } else if (field.isOneToOneAssociation()) { final NakedObject existing = ((ObjectContent) subviews[i].getContent()).getObject(); final boolean changedValue = value != existing;
private void setUpFields( final NakedObject adapter, final ObjectData adapterData, final KnownObjectsRequest knownObjects) { final Data[] fieldContent = adapterData.getFieldContent(); if (fieldContent != null && fieldContent.length > 0) { final NakedObjectAssociation[] fields = fieldOrderCache.getFields(adapter.getSpecification()); if (fields.length != fieldContent.length) { throw new NakedObjectsRemoteException("Data received for different number of fields; expected " + fields.length + ", but was " + fieldContent.length); } for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation field = fields[i]; final Data fieldData = fieldContent[i]; if (fieldData == null || field.isDerived()) { LOG.debug("no data for field " + field.getId()); continue; } if (field.isOneToManyAssociation()) { setUpCollectionField(adapter, adapterData, field, (CollectionData) fieldData, knownObjects); } else if (field.getSpecification().isEncodeable()) { setUpEncodedField(adapter, (OneToOneAssociation) field, fieldData); } else { setUpReferenceField(adapter, (OneToOneAssociation) field, fieldData, knownObjects); } } } }
if (field.isDerived()) { continue; if (field.isOneToManyAssociation()) { final NakedObject collection = field.get(object); if (collection == null) { throw new ObjectPersistenceException( "Collection " + field.getName() + " does not exist in " + object.getSpecification().getFullName()); final NakedObject fieldValue = field.get(object); if (fieldValue == null) { continue;
private String debugObjectGraph(final NakedObject object, final int level, final Vector recursiveElements) { final StringBuffer s = new StringBuffer(); recursiveElements.addElement(object); // work through all its fields NakedObjectAssociation[] fields; fields = object.getSpecification().getAssociations(); for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation field = fields[i]; final Object obj = field.get(object); final String id = field.getId(); indent(s, level); if (field.isOneToManyAssociation()) { s.append(id + ": \n" + debugCollectionGraph((NakedObject) obj, level + 1, recursiveElements)); } else { if (obj instanceof NakedObject) { if (recursiveElements.contains(obj)) { s.append(id + ": " + obj + "*\n"); } else { s.append(id + ": " + obj); s.append(debugGraph((NakedObject) obj, level + 1, recursiveElements)); } } else { s.append(id + ": " + obj); s.append("\n"); } } } return s.toString(); }
private void setUpFields( final NakedObject adapter, final ObjectData adapterData, final KnownObjectsRequest knownObjects) { final Data[] fieldContent = adapterData.getFieldContent(); if (fieldContent != null && fieldContent.length > 0) { final NakedObjectAssociation[] fields = fieldOrderCache.getFields(adapter.getSpecification()); if (fields.length != fieldContent.length) { throw new NakedObjectsRemoteException("Data received for different number of fields; expected " + fields.length + ", but was " + fieldContent.length); } for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation field = fields[i]; final Data fieldData = fieldContent[i]; if (fieldData == null || !field.isNotDerived()) { LOG.debug("no data for field " + field.getId()); continue; } if (field.isOneToManyAssociation()) { setUpCollectionField(adapter, adapterData, field, (CollectionData) fieldData, knownObjects); } else if (field.getSpecification().isEncodeable()) { setUpEncodedField(adapter, (OneToOneAssociation) field, fieldData); } else { setUpReferenceField(adapter, (OneToOneAssociation) field, fieldData, knownObjects); } } } }
table.addColumnHeader(columnAssociation.getName()); final NakedObject columnAdapter = columnAssociation.get(rowAdapter); NakedObjectSpecification columnSpec = columnAssociation.getSpecification(); if (!columnAssociation.isVisible(getAuthenticationSession(), rowAdapter).isAllowed()) { table.addEmptyCell(); } else if (columnSpec.isParseable()) {
private void setUpCollectionFieldForNoContents( final ObjectData parentData, final NakedObject adapter, final NakedObjectAssociation field) { final NakedObject collection = field.get(adapter); if (collection.getResolveState() == ResolveState.GHOST) { return; } if (LOG.isDebugEnabled()) { LOG.debug("No data for collection: " + field.getId()); } Version adapterVersion = adapter.getVersion(); Version parentVersion = parentData.getVersion(); if (adapterVersion.different(parentVersion)) { if (LOG.isDebugEnabled()) { LOG.debug("clearing collection as versions differ: " + adapter.getVersion() + " " + parentData.getVersion()); } final CollectionFacet facet = CollectionFacetUtils.getCollectionFacetFromSpec(collection); facet.init(collection, new NakedObject[0]); collection.changeState(ResolveState.GHOST); } }
for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation field = fields[i]; final NakedObject obj = field.get(object); final String name = field.getId(); graphIndent(s, level); if (field.isVisible(authenticationSession, object).isVetoed()) { s.append(name + ": (not visible)"); s.append("\n");
public String invalidReason(final ObjectValidityContext context) { final StringBuilder buf = new StringBuilder(); final NakedObject nakedObject = context.getTarget(); for (final NakedObjectAssociation property : nakedObject.getSpecification().getAssociations( NakedObjectAssociationFilters.PROPERTIES)) { // ignore hidden properties if (property.isVisible(context.getSession(), nakedObject).isVetoed()) { continue; } // ignore disabled properties if (property.isUsable(context.getSession(), nakedObject).isVetoed()) { continue; } final OneToOneAssociation otoa = (OneToOneAssociation) property; final NakedObject value = otoa.get(nakedObject); if (otoa.isAssociationValid(nakedObject, value).isVetoed()) { if (buf.length() > 0) { buf.append(", "); } buf.append(property.getName()); } } if (buf.length() > 0) { return "Invalid properties: " + buf.toString(); } return null; }