private ObjectAction createAction(final FacetedMethod facetedMethod) { return new ObjectActionImpl(facetedMethod, objectMemberContext, getServicesProvider()); }
@Override public ObjectAdapter execute(final ObjectAdapter object, final ObjectAdapter[] parameters) { LOG.debug("execute action " + object + "." + getId()); final ObjectAdapter[] params = realParameters(object, parameters); final ObjectAdapter target = realTarget(object); final ActionInvocationFacet facet = getFacet(ActionInvocationFacet.class); return facet.invoke(target, params); }
private ObjectAdapter findService() { final List<ObjectAdapter> services = getServicesProvider().getServices(); for (final ObjectAdapter serviceAdapter : services) { if (serviceAdapter.getSpecification() == getOnType()) { return serviceAdapter; } } throw new IsisException("failed to find service for action " + this.getName()); }
private boolean determineWhetherContributed() { if (getOnType().isService() && getParameterCount() > 0) { final List<ObjectActionParameter> params = getParameters(); for (int i = 0; i < params.size(); i++) { if (params.get(i).isObject()) { return true; } } } return false; }
/** * Previously (prior to 3.0.x) this method had a check to see if the action * was on an instance. With the reflector redesign this has been removed, * because NOF 3.x only supports instance methods, not class-level methods. */ @Override public ObjectAdapter realTarget(final ObjectAdapter target) { if (target == null) { return findService(); } else if (target.getSpecification().isService()) { return target; } else if (isContributed()) { return findService(); } else { return target; } }
@Override public ObjectAdapter[][] getChoices(final ObjectAdapter target) { final ObjectAdapter realTarget = realTarget(target); final int parameterCount = getParameterCount(); Object[][] parameterChoicesPojos; final ActionChoicesFacet facet = getFacet(ActionChoicesFacet.class); final List<ObjectActionParameter> parameters = getParameters(); ObjectActionParameterAbstract.checkChoicesType(getSpecificationLookup(), parameterChoicesPojos[i], paramSpec); parameterChoicesAdapters[i] = new ObjectAdapter[parameterChoicesPojos[i].length]; for (int j = 0; j < parameterChoicesPojos[i].length; j++) { parameterChoicesAdapters[i][j] = adapterFor(parameterChoicesPojos[i][j]); final List<ObjectAdapter> allInstancesAdapter = getQuerySubmitter().allMatchingQuery(query); parameterChoicesAdapters[i] = new ObjectAdapter[allInstancesAdapter.size()]; int j = 0;
@Override public ObjectAdapter[] getDefaults(final ObjectAdapter target) { final ObjectAdapter realTarget = realTarget(target); final int parameterCount = getParameterCount(); final List<ObjectActionParameter> parameters = getParameters(); final ActionDefaultsFacet facet = getFacet(ActionDefaultsFacet.class); if (!facet.isNoop()) { final ObjectSpecification componentSpec = getSpecificationLookup().loadSpecification(parameterDefaultPojos[i].getClass()); final ObjectSpecification parameterSpec = parameters.get(i).getSpecification(); if (!componentSpec.isOfType(parameterSpec)) { if (parameterDefaultPojos != null) { for (int i = 0; i < parameterCount; i++) { parameterDefaultAdapters[i] = adapterFor(parameterDefaultPojos[i]); if (isContributed() && target != null) { for (int i = 0; i < parameterCount; i++) { if (target.getSpecification().isOfType(parameters.get(i).getSpecification())) {
@Override public String toString() { final StringBuffer sb = new StringBuffer(); sb.append("Action ["); sb.append(super.toString()); sb.append(",type="); sb.append(getType()); sb.append(",returns="); sb.append(getReturnType()); sb.append(",parameters={"); for (int i = 0; i < getParameterCount(); i++) { if (i > 0) { sb.append(","); } sb.append(getParameters().get(i).getSpecification().getShortIdentifier()); } sb.append("}]"); return sb.toString(); }
private InteractionResultSet isProposedArgumentSetValidResultSet(final ObjectAdapter object, final ObjectAdapter[] proposedArguments) { final InteractionInvocationMethod invocationMethod = InteractionInvocationMethod.BY_USER; final InteractionResultSet resultSet = new InteractionResultSet(); final List<ObjectActionParameter> actionParameters = getParameters(); if (proposedArguments != null) { // TODO: doesn't seem to be used... // ObjectAdapter[] params = realParameters(object, // proposedArguments); for (int i = 0; i < proposedArguments.length; i++) { final ValidityContext<?> ic = actionParameters.get(i).createProposedArgumentInteractionContext(getAuthenticationSession(), invocationMethod, object, proposedArguments, i); InteractionUtils.isValidResultSet(getParameter(i), ic, resultSet); } } // only check the action's own validity if all the arguments are OK. if (resultSet.isAllowed()) { final ValidityContext<?> ic = createActionInvocationInteractionContext(getAuthenticationSession(), invocationMethod, object, proposedArguments); InteractionUtils.isValidResultSet(this, ic, resultSet); } return resultSet; }
private ObjectActionParameter getParameter(final int position) { final List<ObjectActionParameter> parameters = getParameters(); if (position >= parameters.size()) { throw new IllegalArgumentException("getParameter(int): only " + parameters.size() + " parameters, position=" + position); } return parameters.get(position); }
@Override public boolean promptForParameters(final ObjectAdapter target) { final List<ObjectActionParameter> parameters = getParameters(); if (isContributed() && !target.getSpecification().isService()) { return getParameterCount() > 1 || !target.getSpecification().isOfType(parameters.get(0).getSpecification()); } else { return getParameterCount() > 0; } }
@Override public ActionType getType() { return getType(this); }
@Test public void testId() { assertEquals("reduceheadcount", action.getId()); }
@Test public void testNameDefaultsToActionsMethodName() { final NamedFacet facet = new NamedFacetAbstract("Reduceheadcount", mockFacetedMethod) { }; mockery.checking(new Expectations() { { one(mockFacetedMethod).getFacet(NamedFacet.class); will(returnValue(facet)); } }); assertEquals("Reduceheadcount", action.getName()); }
@Override public boolean isContributed() { if (!knownWhetherContributed) { contributed = determineWhetherContributed(); knownWhetherContributed = true; } return contributed; }
@Test public void testExecutePassedOnToPeer() { final TestProxyAdapter target = new TestProxyAdapter(); target.setupSpecification(new TestSpecification()); final ObjectAdapter[] parameters = new ObjectAdapter[2]; final TestProxyAdapter result = new TestProxyAdapter(); final ActionInvocationFacet facet = new ActionInvocationFacetAbstract(mockFacetedMethod) { @Override public ObjectAdapter invoke(final ObjectAdapter target, final ObjectAdapter[] parameters) { return result; } @Override public ObjectSpecification getReturnType() { return null; } @Override public ObjectSpecification getOnType() { return new TestSpecification(); } }; mockery.checking(new Expectations() { { exactly(2).of(mockFacetedMethod).getFacet(ActionInvocationFacet.class); will(returnValue(facet)); } }); final ObjectAdapter returnObject = action.execute(target, parameters); assertEquals(returnObject, result); }
@Override public ObjectActionParameter getParameterByName(final String paramName) { final List<ObjectActionParameter> allParameters = getParameters(); for (int i = 0; i < allParameters.size(); i++) { final ObjectActionParameter param = allParameters.get(i); if (Objects.equal(paramName, param.getName())) { return param; } } return null; }
@SuppressWarnings("unused") private ObjectAction getActionMethod(final String actionType, final String actionIdentifier, final Data[] parameterData, final ObjectAdapter adapter) { final List<ObjectSpecification> parameterSpecs = Lists.newArrayList(); for (int i = 0; i < parameterSpecs.size(); i++) { parameterSpecs.add(getSpecification(parameterData[i].getType())); } final ActionType type = ObjectActionImpl.getType(actionType); final int pos = actionIdentifier.indexOf('#'); final String methodName = actionIdentifier.substring(pos + 1); if (adapter == null) { throw new UnexpectedCallException("object not specified"); } return adapter.getSpecification().getObjectAction(type, methodName, parameterSpecs); }
@Override public List<ObjectActionParameter> getParameters(final Filter<ObjectActionParameter> filter) { final List<ObjectActionParameter> allParameters = getParameters(); final List<ObjectActionParameter> selectedParameters = Lists.newArrayList(); for (int i = 0; i < allParameters.size(); i++) { if (filter.accept(allParameters.get(i))) { selectedParameters.add(allParameters.get(i)); } } return selectedParameters; }
@Override @Before public void setUp() throws Exception { super.setUp(); mockFacetedMethod = mockery.mock(FacetedMethod.class); mockAuthenticationSessionProvider = mockery.mock(AuthenticationSessionProvider.class); mockSpecificationLookup = mockery.mock(SpecificationLookup.class); mockAdapterManager = mockery.mock(AdapterMap.class); mockServicesProvider = mockery.mock(ServicesProvider.class); mockQuerySubmitter = mockery.mock(QuerySubmitter.class); mockCollectionTypeRegistry = mockery.mock(CollectionTypeRegistry.class); mockery.checking(new Expectations() { { one(mockFacetedMethod).getIdentifier(); will(returnValue(Identifier.actionIdentifier("Customer", "reduceheadcount"))); } }); action = new ObjectActionImpl(mockFacetedMethod, new ObjectMemberContext(mockAuthenticationSessionProvider, mockSpecificationLookup, mockAdapterManager, mockQuerySubmitter, mockCollectionTypeRegistry), mockServicesProvider); }