private void saveState(final NakedObject targetAdapter, final NakedObject[] entryAdapters) { for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation fld = fields[i]; final NakedObject entryAdapter = entryAdapters[i]; final boolean isReadOnly = readOnly[i]; if (isReadOnly) { continue; } if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = ((OneToOneAssociation) fld); final Object entryPojo = NakedObjectUtils.unwrap(entryAdapter); if (entryPojo == null) { if (oneToOneAssociation.get(targetAdapter) != null) { oneToOneAssociation.clearAssociation(targetAdapter); } } else { final NakedObject currentAdapter = oneToOneAssociation.get(targetAdapter); final Object currentPojo = NakedObjectUtils.unwrap(currentAdapter); if (currentAdapter == null || currentPojo == null || !currentPojo.equals(entryPojo)) { oneToOneAssociation.setAssociation(targetAdapter, entryAdapter); } } } } }
@Override public void checkForValidity(final Context context) { final NakedObject target = getTarget(context); final NakedObject[] entries = getEntries(context); final int len = fields.length; for (int i = 0; i < len; i++) { if (readOnly[i] || errors[i] != null) { continue; } final NakedObjectAssociation fld = fields[i]; if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = (OneToOneAssociation) fld; final NakedObject entryReference = entries[i]; final NakedObject currentReference = oneToOneAssociation.get(target); if (currentReference != entryReference) { final Consent valueValid = ((OneToOneAssociation) fld).isAssociationValid(target, entryReference); errors[i] = valueValid.getReason(); } } } }
private void setUpEncodedField( final NakedObject adapter, final OneToOneAssociation field, final Data data) { String value; if (data instanceof NullData) { field.initAssociation(adapter, null); } else { value = ((EncodableObjectData) data).getEncodedObjectData(); final EncodableFacet encoder = field.getSpecification().getFacet(EncodableFacet.class); final NakedObject valueAdapter = encoder.fromEncodedString(value); if (LOG.isDebugEnabled()) { LOG.debug("setting value for field " + field.getId() + ": " + valueAdapter); } field.initAssociation(adapter, valueAdapter); } }
private void setUpReferenceField( final NakedObject adapter, final OneToOneAssociation field, final Data data, final KnownObjectsRequest knownObjects) { NakedObject associate; associate = deserializeObject(data, knownObjects); if (LOG.isDebugEnabled()) { LOG.debug("setting association for field " + field.getId() + ": " + associate); } field.initAssociation(adapter, associate); }
private void updateOneToOneAssociation(final NakedObject object, final OneToOneAssociation field, final Data fieldData) { if (fieldData == null) { field.initAssociation(object, null); } else { final NakedObject ref = recreateReference(fieldData); if (field.get(object) != ref) { LOG.debug(" association " + field + " changed to " + ref.getOid()); field.initAssociation(object, ref); } } }
private Object handleSetterMethodOnProperty( final Object[] args, final AuthenticationSession session, final NakedObject targetAdapter, final OneToOneAssociation otoa, final String methodName) { if (args.length != 1) { throw new IllegalArgumentException("Invoking a setter should only have a single argument"); } resolveIfRequired(targetAdapter); final Object argumentObj = underlying(args[0]); final NakedObject argumentNO = argumentObj != null? getRuntimeContext().adapterFor(argumentObj): null; final InteractionResult interactionResult = otoa.isAssociationValid(targetAdapter, argumentNO).getInteractionResult(); notifyListenersAndVetoIfRequired(interactionResult); if (getExecutionMode() == ExecutionMode.EXECUTE) { if (argumentNO != null) { otoa.setAssociation(targetAdapter, argumentNO); // need to wrap arg } else { otoa.clearAssociation(targetAdapter); } } objectChangedIfRequired(targetAdapter); return null; }
private Object handleGetterMethodOnProperty( final Object[] args, final NakedObject targetAdapter, final OneToOneAssociation otoa, final String methodName) { if (args.length != 0) { throw new IllegalArgumentException("Invoking a 'get' should have no arguments"); } resolveIfRequired(targetAdapter); final NakedObject currentReferencedAdapter = otoa.get(targetAdapter); final Object currentReferencedObj = NakedObjectUtils.unwrap(currentReferencedAdapter); final PropertyAccessEvent ev = new PropertyAccessEvent(getDelegate(), otoa.getIdentifier(), currentReferencedObj); notifyListeners(ev); return currentReferencedObj; }
final NakedObject referencedObject = oneToOneAssociation.get(fieldPlace.getObject());
public void execute() { field.setAssociation(object, associatedObject); } }
public void undo() { field.clearAssociation(object); }
/** * Applies only for {@link OneToOneAssociation}s. */ public SetValueResponse setValue( SetValueRequest request) { AuthenticationSession session = request.getSession(); String fieldIdentifier = request.getFieldIdentifier(); IdentityData targetIdentityData = request.getTarget(); EncodableObjectData encodeableObjectData = request.getValue(); Assert.assertNotNull(encodeableObjectData); if (LOG.isDebugEnabled()) { LOG.debug("request setValue " + fieldIdentifier + " on " + targetIdentityData + " with " + encodeableObjectData + " for " + session); } final NakedObject targetAdapter = getPersistentNakedObject(session, targetIdentityData); final OneToOneAssociation association = (OneToOneAssociation) targetAdapter.getSpecification().getAssociation(fieldIdentifier); ensureAssociationModifiableElseThrowException(session, targetAdapter, association); final String encodedObject = encodeableObjectData.getEncodedObjectData(); final NakedObjectSpecification specification = association.getSpecification(); final NakedObject adapter = restoreLeafObject(encodedObject, specification); association.setAssociation(targetAdapter, adapter); return new SetValueResponse(getUpdates()); }
OneToOneAssociation otoa = (OneToOneAssociation) association; if (association.get(target) == null && otoa.isAssociationValid(target, source).isAllowed()) { otoa.setAssociation(target, source); break;
value = valueAssociation.get(object); referencedNakedObject = (NakedObject) oneToOneAssociation.get(object); .getSpecification().getFullName(), FacetUtil.getFacetsByType(oneToOneAssociation));
private NakedObject validateAndParse(final String entryText) { final NakedObject newValue = parse(entryText); final OneToOneAssociation nakedObjectAssociation = (OneToOneAssociation) field.getNakedObjectAssociation(); final Consent valid = nakedObjectAssociation.isAssociationValid(parent, newValue); if (valid.isVetoed()) { throw new InvalidEntryException(valid.getReason()); } return newValue; }
@Override public Consent canSet(final NakedObject adapter) { final NakedObjectSpecification targetType = getOneToOneAssociation().getSpecification(); final NakedObjectSpecification spec = adapter.getSpecification(); if (isEditable().isVetoed()) { return isEditable(); } if (!spec.isOfType(targetType)) { // TODO: move logic into Facet return new Veto(String.format("Can only drop objects of type %s", targetType.getSingularName())); } if (getParent().isPersistent() && adapter.isTransient()) { // TODO: move logic into Facet return new Veto("Can't drop a non-persistent into this persistent object"); } final Consent perm = getOneToOneAssociation().isAssociationValid(getParent(), adapter); return perm; }
public void undo() { final EncodeableFacet facet = value.getFacet(EncodeableFacet.class); final Object obj = facet.fromEncodedString(oldValue); final NakedObject adapter = getAdapterManager().adapterFor(obj); value.setAssociation(object, adapter); // have commented this out because it isn't needed; the transaction manager will do this // for us on endTransaction. Still, if I'm wrong and it is needed, hopefully this // comment will help... // NakedObjectsContext.getObjectPersistor().objectChangedAllDirty(); }
@Override public void parseTextEntry(final String entryText) { object = validateAndParse(entryText); final Consent valid = ((OneToOneAssociation) getField()).isAssociationValid(getParent(), object); if (valid.isVetoed()) { throw new InvalidEntryException(valid.getReason()); } if (getValueAssociation().isMandatory() && object == null) { throw new InvalidEntryException("Mandatory field cannot be empty"); } }
adapter.changeState(ResolveState.DESTROYED); ((OneToOneAssociation) field).initAssociation(object, adapter); } else { final NakedObject reference = NakedObjectsContext.getPersistenceSession().recreateAdapter(referenceOid, specFor(fieldData)); ((OneToOneAssociation) field).initAssociation(object, reference);
public NakedObjectSpecification getSpecification() { return getOneToOneAssociation().getSpecification(); }
public boolean canDisplay(final Content content, ViewRequirement requirement) { boolean openCollection = content instanceof CollectionContent && requirement.is(ViewRequirement.OPEN); if (openCollection) { List<OneToOneAssociation> propertyList = ((CollectionContent) content).getElementSpecification().getPropertyList(); for (OneToOneAssociation association : propertyList) { if (!association.containsFacet(HiddenFacet.class) && association.getSpecification().containsFacet(DateValueFacet.class)) { return true; } } } return false; }