if ( controlActionUri == NullValue.NULL ) controlActionUri = actionUri;
controlParameters.put(Control.ACTION, controlActionUri);
try {
ProcessorManager.prepareValues(control.getParameterDescriptors(), controlParameters, context);
} catch ( ValidationException exception ) {
throw new ValidationException(new ErrorMessage("controlComposer/controlParameterInvalid", new Object[] { controlUri }), exception);
}
Value controlContainerUri = (Value)controlParameters.get(CONTROL_CONTAINER);
ParameterDescriptor parameterDescriptor = Control.getParameterDescriptor(controlParameters, context);
String parameterName = parameterDescriptor.getName();
involvedParameters.add(new StringValue(parameterName));
ParameterMessage description = (ParameterMessage)parameterDescriptor.getDescription();
boolean required = parameterDescriptor.isRequired();
String controlState = Control.OPTIONAL_CONTROL;
if ( required ) {
controlState = Control.REQUIRED_CONTROL;
}
Object controlValue = null;
boolean validate = false;
if ( mapResource != null ) {
controlValue = mapResource.getMap().get(parameterName);
validate = false;
BooleanValue validateResource = ((BooleanValue)mapResource.getMap().get(VALIDATE));
if ( validateResource != null ) validate = validateResource.booleanValue();
}
if ( validate ) {
try {
controlValue = ProcessorManager.prepareValue(parameterDescriptor, controlValue, context);
} catch ( ValidationException exception ) {
controlValue = StringValueDescriptor.ANY.valueOf(controlValue, context).toString();
context.addInformation(new Information(Information.ERROR, exception.getErrorMessage(), new String[] { parameterName }));
}
controlParameters.put(Control.VALUE, controlValue);
if ( hasErrors(informations, parameterName) ) {
if ( required ) {
controlState = Control.REQUIRED_INVALID_CONTROL;
} else {
controlState = Control.OPTIONAL_INVALID_CONTROL;
}
explodeInformations(controlParameters, informations, parameterName, locale);
} else {
if ( required ) {
controlState = Control.REQUIRED_VALID_CONTROL;
} else {
controlState = Control.OPTIONAL_VALID_CONTROL;
}
}
}
controlParameters.put(Control.STATE, controlState);
controlParameters.put(Control.VALUE, controlValue);
Result controlResult = control.process(controlParameters, context);
if ( controlContainerUri != NullValue.NULL ) {
Processor controlContainer = ProcessorManager.getInstance().getProcessor((URI)controlContainerUri);
Map controlContainerParameters = new HashMap();
controlContainerParameters.putAll(parameter);
if ( hasErrors(informations, parameterName) ) {
explodeInformations(controlContainerParameters, informations, parameterName, locale);
}
controlContainerParameters.put(Control.STATE, controlState);
controlContainerParameters.put(CONTROL, controlResult.getResultEntries().get(OUTPUT));
controlContainerParameters.put(TITLE, description.getTitle(locale, parameterName ));
try {
controlContainerParameters.put(TEXT, description.getText(locale));
controlContainerParameters.put(PROMPT, description.getPrompt(locale));
} catch ( MessageNotFoundException exception ) {
controlContainerParameters.put(TEXT, NO_PARAMETER_MESSAGE_AVAILABLE.getText(locale, " "));
controlContainerParameters.put(PROMPT, NO_PARAMETER_MESSAGE_AVAILABLE.getPrompt(locale, " "));
}
try {
ProcessorManager.prepareValues(controlContainer.getParameterDescriptors(), controlContainerParameters, context);
} catch ( ValidationException exception ) {
throw new ValidationException(new ErrorMessage("controlComposer/controlContainerParameterInvalid", new Object[] { controlContainerUri }), exception);
}
Result controlContainerResult = controlContainer.process(controlContainerParameters, context);
generatedControls.add(new MapValue(controlName, (Value)controlContainerResult.getResultEntries().get(OUTPUT)));
} else {
generatedControls.add(new MapValue(controlName, (Value)controlResult.getResultEntries().get(OUTPUT)));
}
if ( controlState == Control.OPTIONAL_INVALID_CONTROL || controlState == Control.REQUIRED_INVALID_CONTROL ) {
state = INVALID_STATE;
} else if ( state == DEFAULT_STATE && ( controlState == Control.OPTIONAL_VALID_CONTROL || controlState == Control.REQUIRED_VALID_CONTROL ) ) {
state = VALID_STATE;
}
}
Result composerResult = new Result(state, GENERATED_CONTROLS, new ArrayValue((Value [])generatedControls.toArray(new Value[generatedControls.size()])));
List generatedTriggers = new ArrayList();
for (int i = 0; i < triggerDescriptions.length; i++ ) {
Map triggerParameters = ((MapValue)triggerDescriptions[i]).getMap();
String triggerName = triggerParameters.get(TRIGGER_NAME).toString();
Value involvedTriggerParameters = (Value)triggerParameters.get(Trigger.INVOLVED_PARAMETERS);
if ( involvedTriggerParameters == NullValue.NULL ) {
involvedTriggerParameters = new ArrayValue((StringValue[])involvedParameters.toArray(new StringValue[involvedParameters.size()]));
}
triggerParameters.put(Trigger.INVOLVED_PARAMETERS, involvedTriggerParameters);
URI triggerUri = (URI)triggerParameters.get(TRIGGER);
Trigger trigger = (Trigger)ProcessorManager.getInstance().getProcessor(triggerUri);
Value triggerActionUri = (Value)triggerParameters.get(Trigger.ACTION);
if ( triggerActionUri == NullValue.NULL ) triggerActionUri = actionUri;
triggerParameters.put(Trigger.ACTION, triggerActionUri);
try {
ProcessorManager.prepareValues(trigger.getParameterDescriptors(), triggerParameters, context);
} catch ( ValidationException exception ) {
throw new ValidationException(new ErrorMessage("controlComposer/triggerParameterInvalid", new Object[] { triggerUri }), exception);
}
Value triggerContainerUri = (Value)triggerParameters.get(TRIGGER_CONTAINER);
Result triggerResult = trigger.process(triggerParameters, context);
if ( triggerContainerUri != NullValue.NULL ) {
Processor triggerContainer = ProcessorManager.getInstance().getProcessor((URI)triggerContainerUri);
Map triggerContainerParameters = new HashMap();
triggerContainerParameters.putAll(parameter);
triggerContainerParameters.put(TRIGGER, triggerResult.getResultEntries().get(OUTPUT));
try {
ProcessorManager.prepareValues(triggerContainer.getParameterDescriptors(), triggerContainerParameters, context);
} catch ( ValidationException exception ) {
throw new ValidationException(new ErrorMessage("controlComposer/triggerContainerParameterInvalid", new Object[] { triggerContainerUri }), exception);
}
Result triggerContainerResult = triggerContainer.process(triggerContainerParameters, context);
generatedTriggers.add(new MapValue(triggerName, (Value)triggerContainerResult.getResultEntries().get(OUTPUT)));
} else {
generatedTriggers.add(new MapValue(triggerName, (Value)triggerResult.getResultEntries().get(OUTPUT)));