public Naked invoke() { return action.execute(target, parameters); }
public static ActionHelper createInstance(final NakedReference target, final NakedObjectAction action) { int numberParameters = action.getParameterTypes().length; Naked[] parameters = new Naked[numberParameters]; Naked[] defaultValues; String [] descriptions; boolean[] optional; names = action.getParameterNames(); descriptions = action.getParameterDescriptions(); defaultValues = action.getDefaultParameterValues(target); options = action.getOptions(target); optional = action.getOptionalParameters(); parameterTypes = action.getParameterTypes(); values = new Naked[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { int[] maxLength = action.getParameterMaxLengths(); int[] typicalLength = action.getParameterTypicalLengths(); int[] noLines = action.getParameterNoLines(); boolean[] canWrap = action.canParametersWrap();
public NakedObjectAction getObjectAction( final NakedObjectAction.Type type, final String name, final NakedObjectSpecification[] parameters) { if (action != null && action.getId().equals(name)) { return action; } return null; }
public static ImmediateObjectOption createOption(final NakedObjectAction action, final NakedReference object) { Assert.assertTrue("Only suitable for 0 param methods", action.getParameterTypes().length == 0); if (!action.isVisible() || !action.isVisible(object)) { return null; } ImmediateObjectOption option = new ImmediateObjectOption(action, object); return option; }
public static DialoggedObjectOption createOption(final NakedObjectAction action, final NakedReference object) { int paramCount = action.getParameterCount(); Assert.assertTrue("Only for actions taking one or more params", paramCount > 0); if (!action.isVisible() || !action.isVisible(object)) { return null; } DialoggedObjectOption option = new DialoggedObjectOption(action, object); return option; }
Naked result = action.execute(object, parameters); if (action.getParameterTypes()[i].getType() == NakedObjectSpecification.OBJECT && parameterData[i] instanceof ObjectData) { persistedParameters[i] = encoder.createMadePersistentGraph((ObjectData) parameterData[i],
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; }
protected void setUp() throws Exception { BasicConfigurator.configure(); LogManager.getRootLogger().setLevel(Level.OFF); encoder = createMock(ObjectEncoder.class); server = new ServerDistribution(null); server.setEncoder(encoder); server.init(); reset(encoder); // server calls encoder, so we need to ignore this system = new TestProxySystem(); system.init(); adapter = system.createPersistentTestObject(); oid = adapter.getOid(); targetData = new DummyIdentityData(oid, TestProxyNakedObject.class.getName(), new TestProxyVersion(1)); parameterData = new ReferenceData[] {}; TestProxySpecification proxySpecification = (TestProxySpecification) adapter.getSpecification(); action = createMock(NakedObjectAction.class); proxySpecification.setupAction(action); action.getId(); expectLastCall().andStubReturn("action()"); action.execute(eq(adapter), aryEq(new Naked[0])); expectLastCall().andReturn(adapter); }
private static void menuOptions( final NakedObjectAction[] actions, final NakedReference target, final UserActionSet menuOptionSet) { for (int i = 0; i < actions.length; i++) { UserAction option = null; if (actions[i].getActions().length > 0) { option = new UserActionSet(actions[i].getName(), menuOptionSet); menuOptions(actions[i].getActions(), target, (UserActionSet) option); } else { int noOfParameters = actions[i].getParameterTypes().length; if (noOfParameters == 0) { option = ImmediateObjectOption.createOption(actions[i], target); } else if (actions[i].isContributedMethodWithSuitableParameter() && noOfParameters == 1 && target != null && target.getSpecification().isOfType(actions[i].getParameterTypes()[0])) { option = ImmediateObjectOption.createServiceOption(actions[i], target); } else { option = DialoggedObjectOption.createOption(actions[i], target); } } if (option != null) { menuOptionSet.add(option); } } } }
public void refresh() { Naked[] defaults = getNakedObjectAction().getDefaultParameterValues(getNakedObject()); Naked[][] optionsSet = getNakedObjectAction().getOptions(getNakedObject()); parameterInstances = getParameterInstances(); for(int i=0; i<parameterInstances.length; i++) { Object defaultValue = defaults[i]; Naked[] options = optionsSet[i]; parameterInstances[i].refresh(defaultValue, options); } }
public Consent disabled() { // REVIEW this is no good as it lumps all the parameters together; I need to know which parameter is disabled! return action.isParameterSetValid(target, parameters); }
private Consent canDropOntoObject(final NakedObject target, final NakedObject source) { NakedObjectAction action = dropAction(source, target); if (action != null) { Consent parameterSetValid = action.isParameterSetValid(target, new NakedObject[] { source }); if (parameterSetValid.isAllowed()) { parameterSetValid = new Allow("Execute '" + action.getName() + "' with " + source.titleString()); } return parameterSetValid; } else { return setFieldOfMatchingType(target, source); } }
public Type getType() { return action.getType(); }
public String check( Naked[] values) { final Consent usable = getNakedObjectActionInstance().getNakedObjectAction().isUsable(); return usable.isAllowed()?null:usable.getReason(); }
public Consent disabled(final View view) { NakedObject adapter = (NakedObject) view.getContent().getNaked(); if (adapter.getResolveState().isDestroyed()) { return new Veto("Can't do anything with a destroyed object"); } Consent usableForUser = action.isUsable(); if (usableForUser.isVetoed()) { return usableForUser; } Consent usableInState = action.isUsable(target); if (usableInState.isVetoed()) { return usableInState; } Consent validParameters = checkValid(); if (validParameters != null && validParameters.isVetoed()) { return validParameters; } String desc = action.getDescription(); String description = getName(view) + (desc.length() == 0 ? "" : ": " + desc); return new Allow(description); }
public String check( Naked[] values) { return getNakedObjectActionInstance().getNakedObjectAction().isVisible()?null:"Hidden"; }
private NakedObjectAction[] findServiceMethodsWithParameter(final NakedObjectAction.Type type) { Object[] services = NakedObjectsContext.getObjectLoader().getServices(); List serviceActionSets = new ArrayList(); for (int i = 0; i < services.length; i++) { NakedObject serviceAdapter = NakedObjectsContext.getObjectLoader().getAdapterFor(services[i]); NakedObjectSpecification specification = serviceAdapter.getSpecification(); if (specification == this) { continue; } NakedObjectAction[] serviceActions = specification.getObjectActions(type); List matchingServiceActions = new ArrayList(); for (int j = 0; j < serviceActions.length; j++) { NakedObjectSpecification[] params = serviceActions[j].getParameterTypes(); for (int k = 0; k < params.length; k++) { if (isOfType(params[k])) { matchingServiceActions.add(serviceActions[j]); break; } } } if (matchingServiceActions.size() > 0) { NakedObjectAction[] asArray = (NakedObjectAction[]) matchingServiceActions .toArray(new NakedObjectAction[matchingServiceActions.size()]); ActionSet actionSet = new ActionSet("id", serviceAdapter.titleString(), asArray); serviceActionSets.add(actionSet); } } return (NakedObjectAction[]) serviceActionSets.toArray(new NakedObjectAction[serviceActionSets.size()]); }
public static ImmediateObjectOption createServiceOption(final NakedObjectAction action, final NakedReference object) { Assert.assertTrue("Only suitable for 1 param methods", action.getParameterTypes().length == 1); if (!action.isVisible() || !action.isVisible(object)) { return null; } ImmediateObjectOption option = new ImmediateObjectOption(action, object); return option; }
protected Consent checkValid() { return action.isParameterSetValid(target, null); }
public NakedObjectActionInstance getActionInstance( NakedObjectAction action) { NakedObjectActionInstance[] actionInstances = getActionInstances(action.getType()); for(int i=0; i<actionInstances.length; i++) { if (actionInstances[i].getNakedObjectAction() == action) { return actionInstances[i]; } } return null; }