Beispiel #1
0
        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);
        }
Beispiel #2
0
        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);
            }
        }
 public virtual void SetType(AbstractFormFieldType type)
 {
     this.Type = type;
 }
Beispiel #4
0
 public virtual void SetType(AbstractFormFieldType formType)
 {
     Type = formType;
 }
Beispiel #5
0
 public virtual void setType(AbstractFormFieldType formType)
 {
     this.type = formType;
 }