public FormFieldValidatorInvocation(IFormFieldValidator formFieldValidator, object submittedValue,
IFormFieldValidatorContext validatorContext) : base(null, null)
{
this.FormFieldValidator = formFieldValidator;
this.SubmittedValue = submittedValue;
this.ValidatorContext = validatorContext;
}
public bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
ProcessEngineConfigurationImpl processEngineConfiguration = ESS.FW.Bpm.Engine.context.Impl.Context.ProcessEngineConfiguration;
IIdentityService identityService = processEngineConfiguration.IdentityService;
IRuntimeService runtimeService = processEngineConfiguration.RuntimeService;
logAuthentication(identityService);
logInstancesCount(runtimeService);
return(true);
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
if (submittedValue == null)
{
//ITypedValue value = validatorContext.VariableScope.getVariableTyped(validatorContext.FormFieldHandler.Id);
//return (value != null && value.Value != null);
}
if (submittedValue is string)
{
return((submittedValue != null) && (((string)submittedValue).Length > 0));
}
return(submittedValue != null);
}
protected internal virtual bool DoValidate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
IFormFieldValidator validator;
if (!ReferenceEquals(Clazz, null))
{
// resolve validator using Fully Qualified Classname
var validatorObject = ReflectUtil.Instantiate(Clazz);
if (validatorObject is IFormFieldValidator)
{
validator = (IFormFieldValidator)validatorObject;
}
else
{
throw new ProcessEngineException("Validator class '" + Clazz + "' is not an instance of " +
typeof(IFormFieldValidator).FullName);
}
}
else
{
//resolve validator using expression
var validatorObject = DelegateExpression.GetValue(validatorContext.Execution);
if (validatorObject is IFormFieldValidator)
{
validator = (IFormFieldValidator)validatorObject;
}
else
{
throw new ProcessEngineException("Validator expression '" + DelegateExpression +
"' does not resolve to instance of " +
typeof(IFormFieldValidator).FullName);
}
}
var invocation = new FormFieldValidatorInvocation(validator, submittedValue, validatorContext);
try
{
Context.ProcessEngineConfiguration.DelegateInterceptor.HandleInvocation(invocation);
}
catch (System.Exception e)
{
throw new ProcessEngineException(e);
}
//return invocation.InvocationResult.Value;
return(true);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public boolean validate(final Object submittedValue, final FormFieldValidatorContext validatorContext)
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.delegate.DelegateExecution execution = validatorContext.getExecution();
var execution = validatorContext.Execution;
if (ShouldPerformPaContextSwitch(validatorContext.Execution))
{
var processApplicationReference =
ProcessApplicationContextUtil.GetTargetProcessApplication((ExecutionEntity)execution);
return
(Context.ExecuteWithinProcessApplication(() => DoValidate(submittedValue, validatorContext),
processApplicationReference, new InvocationContext(execution)));
}
return(DoValidate(submittedValue, validatorContext));
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
if (submittedValue == null)
{
return(NullValid);
}
var configuration = validatorContext.Configuration;
if (submittedValue is string)
{
return(Validate((string)submittedValue, configuration));
}
throw new ProcessEngineException("String validator " + GetType().Name +
" cannot be used on non-string value of type " + submittedValue.GetType());
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
if (submittedValue == null)
{
return(true);
}
if (submittedValue.Equals("A") || submittedValue.Equals("B"))
{
return(true);
}
if (submittedValue.Equals("C"))
{
throw new FormFieldValidationException("EXPIRED", "Unable to validate " + submittedValue);
}
// return false in the generic case
return(false);
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
return(submittedValue == null || submittedValue.Equals("validValue"));
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
if (submittedValue == null)
{
return(NullValid);
}
var configurationString = validatorContext.Configuration;
// Double
if (submittedValue is double?)
{
double?configuration = null;
try
{
configuration = double.Parse(configurationString);
}
catch (FormatException)
{
throw new FormFieldConfigurationException(configurationString,
"Cannot validate Double value " + submittedValue + ": configuration " + configurationString +
" cannot be parsed as Double.");
}
return(Validate((double?)submittedValue, configuration));
}
// Float
if (submittedValue is float?)
{
float?configuration = null;
try
{
configuration = float.Parse(configurationString);
}
catch (FormatException)
{
throw new FormFieldConfigurationException(configurationString,
"Cannot validate Float value " + submittedValue + ": configuration " + configurationString +
" cannot be parsed as Float.");
}
return(Validate((float?)submittedValue, configuration));
}
// Long
if (submittedValue is long?)
{
long?configuration = null;
try
{
configuration = long.Parse(configurationString);
}
catch (FormatException)
{
throw new FormFieldConfigurationException(configurationString,
"Cannot validate Long value " + submittedValue + ": configuration " + configurationString +
" cannot be parsed as Long.");
}
return(Validate((long?)submittedValue, configuration));
}
// Integer
if (submittedValue is int?)
{
int?configuration = null;
try
{
configuration = int.Parse(configurationString);
}
catch (FormatException)
{
throw new FormFieldConfigurationException(configurationString,
"Cannot validate Integer value " + submittedValue + ": configuration " + configurationString +
" cannot be parsed as Integer.");
}
return(Validate((int?)submittedValue, configuration));
}
// Short
if (submittedValue is short?)
{
short?configuration = null;
try
{
configuration = short.Parse(configurationString);
}
catch (FormatException)
{
throw new FormFieldConfigurationException(configurationString,
"Cannot validate Short value " + submittedValue + ": configuration " + configurationString +
" cannot be parsed as Short.");
}
return(Validate((short?)submittedValue, configuration));
}
throw new FormFieldValidationException("Numeric validator " + GetType().Name +
" cannot be used on non-numeric value " + submittedValue);
}
public virtual bool Validate(object submittedValue, IFormFieldValidatorContext validatorContext)
{
// no value was submitted
return(submittedValue == null);
}
