public ObjectData[] setValue( final Session session, final String fieldIdentifier, final IdentityData target, final ValueData value) { Assert.assertNotNull(value); LOG.debug("request setValue " + fieldIdentifier + " on " + target + " with " + value + " for " + session); NakedObject inObject = getPersistentNakedObject(session, target); ValueAssociation association = (ValueAssociation) inObject.getSpecification().getField(fieldIdentifier); if (!association.isVisible() || association.isUsable(inObject).isVetoed()) { throw new IllegalRequestException("can't modify field as not visible or editable"); } NakedValue fieldValue = (NakedValue) association.get(inObject); if (fieldValue != null) { // /byte[] encodedString = // NakedObjectsContext.getObjectLoader().createAdapterForValue(value).asEncodedString(); fieldValue.restoreFromEncodedString(value.getEncodedValue()); } NakedValue valueAdapter = NakedObjectsContext.getObjectLoader().createValueInstance(association.getSpecification()); valueAdapter.restoreFromEncodedString(value.getEncodedValue()); association.setValue(inObject, valueAdapter); return getUpdates(); }
public ObjectData[] clearValue(final Session session, final String fieldIdentifier, final IdentityData target) { LOG.debug("request clearValue " + fieldIdentifier + " on " + target + " for " + session); NakedObject inObject = getPersistentNakedObject(session, target); ValueAssociation association = (ValueAssociation) inObject.getSpecification().getField(fieldIdentifier); if (!association.isVisible() || association.isUsable(inObject).isVetoed()) { throw new IllegalRequestException("can't modify field as not visible or editable"); } association.clearValue(inObject); return getUpdates(); }
public void entryComplete() { if (valueAdapter.isEmpty()) { getValueAssociation().clearValue( getParent()); } else { getValueAssociation().setValue( getParent(), valueAdapter); } }
public void testSetAssociationFailsWhenUnavailable() { associationControl.expectAndReturn(association.getId(), "name"); // the field is authorised, but not available associationControl.expectAndReturn(association.isVisible(), true); associationControl.expectAndReturn(association.isUsable(movieAdapter), Veto.DEFAULT); replay(); try { server.setValue(session, "name", movieData, new DummyValueData("test data")); fail(); } catch (IllegalRequestException expected) { assertEquals("can't modify field as not visible or editable", expected.getMessage()); } verify(); }
private void initObject(final NakedObject object, final ObjectData data) { if (object.getResolveState().isResolvable(ResolveState.RESOLVING)) { objectLoader().start(object, ResolveState.RESOLVING); NakedObjectField[] fields = object.getSpecification().getFields(); for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; if (!field.isPersisted()) { continue; } if (field.isValue()) { NakedValue value = (NakedValue) ((ValueAssociation) field).get(object); String valueData = data.value(field.getId()); value.restoreFromEncodedString(valueData == null ? "NULL" : valueData); ((ValueAssociation) field).initValue(object, value); } else if (field.isCollection()) { initObjectSetupCollection(object, data, field); } else if (field.isObject()) { initObjectSetupReference(object, data, field); } } object.setOptimisticLock(data.getVersion()); objectLoader().end(object); } }
public NakedObjectSpecification getSpecification() { return getValueAssociation().getSpecification(); }
/** * Sets the underlying value. * * @param value - should be a {@link NakedValue}. */ protected void doSet(final Object value) { NakedValue valueNV = (NakedValue) value; getValueAssociation().setValue(getNakedObject(), valueNV); }
public void testSetAssociationFailsWhenUnauthorised() { associationControl.expectAndReturn(association.getId(), "name"); // the field is not authorised associationControl.expectAndReturn(association.isVisible(), false); replay(); try { server.setValue(session, "name", movieData, new DummyValueData("test data")); fail(); } catch (IllegalRequestException expected) { assertEquals("can't modify field as not visible or editable", expected.getMessage()); } verify(); }
value = valueAssociation.get(object);
public String check( Naked[] values) { return getValueAssociationInstance().getValueAssociation().isVisible()?null:"Hidden"; }
public void testInitValue() { association.initValue(nakedObject, new IntAdapter(new Integer(12))); assertEquals(12, ((TestPojo) nakedObject.getObject()).getValue()); }
public void parseTextEntry(final String entryText) { String existingEntry = valueAdapter.asEncodedString(); valueAdapter.parseTextEntry(entryText); Consent valid = ((ValueAssociation) getField()).isValueValid(getParent(), valueAdapter); if (valid.isVetoed()) { valueAdapter.restoreFromEncodedString(existingEntry); throw new InvalidEntryException(valid.getReason()); } if (getValueAssociation().isMandatory() && valueAdapter.isEmpty()) { valueAdapter.restoreFromEncodedString(existingEntry); throw new InvalidEntryException("Mandatory field cannot be empty"); } }
public String isValid( Object proposedValue) { NakedValue proposedNV = (NakedValue)proposedValue; // TODO: need to do the full checking here against annotations etc. Consent valueValid = getValueAssociation().isValueValid(getNakedObject(), proposedNV); return valueValid.isAllowed()?null:valueValid.getReason(); }
public String check( Naked[] values) { final Consent usable = getValueAssociationInstance().getValueAssociation().isUsable(); return usable.isAllowed()?null:usable.getReason(); }
protected boolean isStringProperty() { return "java.lang.String".equals(getValueAssociationInstance().getValueAssociation().getSpecification().getFullName()); }
public void execute(final Workspace workspace, final View view, final Location at) { NakedObject original = (NakedObject) view.getContent().getNaked(); // NakedObject original = getObject(); NakedObjectSpecification spec = original.getSpecification(); NakedObject clone = NakedObjectsContext.getObjectLoader().createTransientInstance(spec); NakedObjectField[] fields = spec.getFields(); for (int i = 0; i < fields.length; i++) { Naked fld = fields[i].get(original); if (fields[i].isObject()) { ((OneToOneAssociation) fields[i]).setAssociation(clone, (NakedObject) fld); } else if (fields[i].isValue()) { ((ValueAssociation) fields[i]).setValue(clone, (NakedValue) fld); } else if (fields[i].isCollection()) { // clone.setValue((OneToOneAssociation) fields[i], fld.getObject()); } } // AbstractNakedObject clone = (AbstractNakedObject) createInstance(getClass()); // clone.copyObject(this); // clone.objectChanged(); Content content = Toolkit.getContentFactory().createRootContent(clone); View cloneView = Toolkit.getViewFactory().createWindow(content); cloneView.setLocation(at); workspace.addView(cloneView); // newWorkspace.markDamaged(); } }
public String check( Naked[] values) { ValueAssociationInstance vai = getValueAssociationInstance(); return vai.getValueAssociation().isVisible(vai.getNakedObject())?null:"Hidden"; }
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); } }
public String check( Naked[] values) { NakedValue nakedValue = getArgument(values); final Consent valueValid = getValueAssociationInstance().getValueAssociation().isValueValid(getValueAssociationInstance().getNakedObject(), nakedValue); return valueValid.isAllowed()?null:valueValid.getReason(); }