/// <summary>
/// factory method for creating validator instances
///
/// </summary>
public virtual FormFieldValidator createValidator(Element constraint, BpmnParse bpmnParse, ExpressionManager expressionManager)
{
string name = constraint.attribute("name");
string config = constraint.attribute("config");
if ("validator".Equals(name))
{
// custom validators
if (string.ReferenceEquals(config, null) || config.Length == 0)
{
bpmnParse.addError("validator configuration needs to provide either a fully " + "qualified classname or an expression resolving to a custom FormFieldValidator implementation.", constraint);
}
else
{
if (StringUtil.isExpression(config))
{
// expression
Expression validatorExpression = expressionManager.createExpression(config);
return(new DelegateFormFieldValidator(validatorExpression));
}
else
{
// classname
return(new DelegateFormFieldValidator(config));
}
}
}
else
{
// built-in validators
Type validator = validators[name];
if (validator != null)
{
FormFieldValidator validatorInstance = createValidatorInstance(validator);
return(validatorInstance);
}
else
{
bpmnParse.addError("Cannot find validator implementation for name '" + name + "'.", constraint);
}
}
return(null);
}
protected internal virtual void parseFormField(Element formField, BpmnParse bpmnParse, ExpressionManager expressionManager)
{
FormFieldHandler formFieldHandler = new FormFieldHandler();
// parse Id
string id = formField.attribute("id");
if (string.ReferenceEquals(id, null) || id.Length == 0)
{
bpmnParse.addError("attribute id must be set for FormFieldGroup and must have a non-empty value", formField);
}
else
{
formFieldHandler.Id = id;
}
if (id.Equals(businessKeyFieldId))
{
formFieldHandler.BusinessKey = true;
}
// parse name
string name = formField.attribute("label");
if (!string.ReferenceEquals(name, null))
{
Expression nameExpression = expressionManager.createExpression(name);
formFieldHandler.Label = nameExpression;
}
// parse properties
parseProperties(formField, formFieldHandler, bpmnParse, expressionManager);
// parse validation
parseValidation(formField, formFieldHandler, bpmnParse, expressionManager);
// parse type
FormTypes formTypes = FormTypes;
AbstractFormFieldType formType = formTypes.parseFormPropertyType(formField, bpmnParse);
formFieldHandler.setType(formType);
// parse default value
string defaultValue = formField.attribute("defaultValue");
if (!string.ReferenceEquals(defaultValue, null))
{
Expression defaultValueExpression = expressionManager.createExpression(defaultValue);
formFieldHandler.DefaultValueExpression = defaultValueExpression;
}
formFieldHandlers.Add(formFieldHandler);
}
public virtual AbstractFormFieldType parseFormPropertyType(Element formFieldElement, BpmnParse bpmnParse)
{
AbstractFormFieldType formType = null;
string typeText = formFieldElement.attribute("type");
string datePatternText = formFieldElement.attribute("datePattern");
if (string.ReferenceEquals(typeText, null) && DefaultFormHandler.FORM_FIELD_ELEMENT.Equals(formFieldElement.TagName))
{
bpmnParse.addError("form field must have a 'type' attribute", formFieldElement);
}
if ("date".Equals(typeText) && !string.ReferenceEquals(datePatternText, null))
{
formType = new DateFormType(datePatternText);
}
else if ("enum".Equals(typeText))
{
// ACT-1023: Using linked hashmap to preserve the order in which the entries are defined
IDictionary <string, string> values = new LinkedHashMap <string, string>();
foreach (Element valueElement in formFieldElement.elementsNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "value"))
{
string valueId = valueElement.attribute("id");
string valueName = valueElement.attribute("name");
values[valueId] = valueName;
}
formType = new EnumFormType(values);
}
else if (!string.ReferenceEquals(typeText, null))
{
formType = formTypes[typeText];
if (formType == null)
{
bpmnParse.addError("unknown type '" + typeText + "'", formFieldElement);
}
}
return(formType);
}
protected internal virtual void parseFormProperties(BpmnParse bpmnParse, ExpressionManager expressionManager, Element extensionElement)
{
FormTypes formTypes = FormTypes;
IList <Element> formPropertyElements = extensionElement.elementsNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, FORM_PROPERTY_ELEMENT);
foreach (Element formPropertyElement in formPropertyElements)
{
FormPropertyHandler formPropertyHandler = new FormPropertyHandler();
string id = formPropertyElement.attribute("id");
if (string.ReferenceEquals(id, null))
{
bpmnParse.addError("attribute 'id' is required", formPropertyElement);
}
formPropertyHandler.Id = id;
string name = formPropertyElement.attribute("name");
formPropertyHandler.Name = name;
AbstractFormFieldType type = formTypes.parseFormPropertyType(formPropertyElement, bpmnParse);
formPropertyHandler.setType(type);
string requiredText = formPropertyElement.attribute("required", "false");
bool? required = bpmnParse.parseBooleanAttribute(requiredText);
if (required != null)
{
formPropertyHandler.Required = required.Value;
}
else
{
bpmnParse.addError("attribute 'required' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string readableText = formPropertyElement.attribute("readable", "true");
bool? readable = bpmnParse.parseBooleanAttribute(readableText);
if (readable != null)
{
formPropertyHandler.Readable = readable.Value;
}
else
{
bpmnParse.addError("attribute 'readable' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string writableText = formPropertyElement.attribute("writable", "true");
bool? writable = bpmnParse.parseBooleanAttribute(writableText);
if (writable != null)
{
formPropertyHandler.Writable = writable.Value;
}
else
{
bpmnParse.addError("attribute 'writable' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string variableName = formPropertyElement.attribute("variable");
formPropertyHandler.VariableName = variableName;
string expressionText = formPropertyElement.attribute("expression");
if (!string.ReferenceEquals(expressionText, null))
{
Expression expression = expressionManager.createExpression(expressionText);
formPropertyHandler.VariableExpression = expression;
}
string defaultExpressionText = formPropertyElement.attribute("default");
if (!string.ReferenceEquals(defaultExpressionText, null))
{
Expression defaultExpression = expressionManager.createExpression(defaultExpressionText);
formPropertyHandler.DefaultExpression = defaultExpression;
}
formPropertyHandlers.Add(formPropertyHandler);
}
}