private void LoadExtraSettings(FormFieldModel field, XElement bindingsXElement, XElement lastTabElement)
{
var config = FormBuilderConfiguration.GetSection();
var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];
var inputElement = plugin.InputElementHandlers.Single(el => el.ElementType.GetType() == field.InputElementType.GetType());
var settingsHandler = inputElement.SettingsHandler;
if (settingsHandler != null)
{
var formFile = "\\InstalledPackages\\CompositeC1Contrib.FormBuilder.Dynamic\\InputElementSettings\\" + inputElement.Name + ".xml";
var settingsMarkupProvider = new FormDefinitionFileMarkupProvider(formFile);
var formDefinitionElement = XElement.Load(settingsMarkupProvider.GetReader());
var settingsTab = new XElement(Namespaces.BindingFormsStdUiControls10 + "PlaceHolder");
var layout = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Layout);
var bindings = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Bindings);
settingsTab.Add(new XAttribute("Label", StringResourceSystemFacade.ParseString(inputElement.Name)));
settingsTab.Add(layout.Elements());
bindingsXElement.Add(bindings.Elements());
lastTabElement.AddAfterSelf(settingsTab);
settingsHandler.Load(field);
foreach (var prop in settingsHandler.GetType().GetProperties())
{
var value = prop.GetValue(settingsHandler, null);
Bindings.Add(prop.Name, value);
}
}
}
public override void OnFinish(object sender, EventArgs e)
{
var folderToken = (FormFolderEntityToken)EntityToken;
var fieldName = GetBinding <string>("FieldName");
var addFieldToRenderingLayout = GetBinding <bool>("AddFieldToRenderingLayout");
var definition = DynamicFormsFacade.GetFormByName(folderToken.FormName);
var field = new FormFieldModel(definition.Model, fieldName, typeof(string), new List <Attribute>());
var elementType = Type.GetType(GetBinding <string>("InputElementType"));
var inputTypeAttribute = (InputElementTypeAttribute)Activator.CreateInstance(elementType);
field.Attributes.Add(inputTypeAttribute);
definition.Model.Fields.Add(field);
DynamicFormsFacade.SaveForm(definition);
if (RenderingLayoutFacade.HasCustomRenderingLayout(folderToken.FormName) && addFieldToRenderingLayout)
{
var layut = RenderingLayoutFacade.GetRenderingLayout(folderToken.FormName);
layut.Body.Add(new XElement(Namespaces.Xhtml + "p", String.Format("%{0}%", fieldName)));
RenderingLayoutFacade.SaveRenderingLayout(folderToken.FormName, layut);
}
var fieldToken = new FormFieldEntityToken(folderToken.FormName, fieldName);
var workflowToken = new WorkflowActionToken(typeof(EditFormFieldWorkflow));
CreateAddNewTreeRefresher(EntityToken).PostRefreshMessages(fieldToken);
ExecuteAction(fieldToken, workflowToken);
}
public override bool Validate()
{
var stepToken = GetBinding <FormWizardStepEntityToken>("BoundToken");
var stepName = GetBinding <string>("StepName");
if (stepName == stepToken.StepName)
{
return(true);
}
if (!FormFieldModel.IsValidName(stepName))
{
ShowFieldMessage("StepName", "Step name is invalid, only a-z and 0-9 is allowed");
return(false);
}
var wizard = DynamicWizardsFacade.GetWizard(stepToken.WizardName);
var step = wizard.Model.Steps.SingleOrDefault(s => s.Name == stepName);
if (step == null)
{
return(true);
}
ShowFieldMessage("StepName", "Step name already exists");
return(false);
}
/// <summary>
/// 生成控件
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public string CreateControl(FormFieldModel entity)
{
StringBuilder sbControl = new StringBuilder();
string ControlName = entity.ControlName; //属性名称
string ControlId = entity.ControlId; //控件Id
string ControlType = entity.ControlType; //控件类型
string validator_html = "";
if (!string.IsNullOrEmpty(entity.ControlValidator.Trim()))
{
validator_html = "isvalid=\"yes\" checkexpession=\"" + entity.ControlValidator.Trim() + "\"";
}
switch (ControlType)
{
case "input": //文本框
sbControl.Append("<input id=\"" + ControlId + "\" type=\"text\" class=\"form-control\" " + validator_html + " />");
break;
case "select": //下拉框
sbControl.Append("<div id=\"" + ControlId + "\" type=\"select\" class=\"ui-select\" " + validator_html + "></div>");
break;
case "datetime": //日期框
sbControl.Append("<input id=\"" + ControlId + "\" type=\"text\" class=\"form-control input-datepicker\" " + validator_html + "/>");
break;
case "textarea": //多行文本框
sbControl.Append("<textarea id=\"" + ControlId + "\" class=\"form-control\" " + validator_html + "></textarea>");
break;
default:
return("内部错误，配置有错误");
}
return(sbControl.ToString());
}
public override bool Validate()
{
var fieldToken = (FormFieldEntityToken)EntityToken;
var fieldName = GetBinding <string>("FieldName");
if (fieldName != fieldToken.FieldName)
{
if (!FormFieldModel.IsValidName(fieldName))
{
ShowFieldMessage("FieldName", "Field name is invalid, only a-z and 0-9 is allowed");
return(false);
}
var definition = DynamicFormsFacade.GetFormByName(fieldToken.FormName);
var field = definition.Model.Fields.Get(fieldName);
if (field != null)
{
ShowFieldMessage("FieldName", "Field name already exists");
return(false);
}
}
return(true);
}
public HttpResponseMessage SaveFormFieldItem(FormFieldModel formField)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
FormsAdminBLL.SaveFormFieldItem(FormFieldModel.MapFormFieldDbModel(formField));
return(response);
}
public void Save(FormFieldModel field)
{
var existingValidator = field.ValidationAttributes.OfType <MaxFieldLengthAttribute>().FirstOrDefault();
if (existingValidator != null)
{
field.Attributes.Remove(existingValidator);
}
if (MaxLength > 0)
{
var maxLengthValidator = new MaxFieldLengthAttribute("Max length is " + MaxLength, MaxLength);
field.Attributes.Add(maxLengthValidator);
}
var inputTypeAttribute = field.Attributes.OfType <InputElementTypeAttribute>().FirstOrDefault();
if (inputTypeAttribute != null)
{
field.Attributes.Remove(inputTypeAttribute);
}
inputTypeAttribute = new TextAreaInputElementAttribute(Cols, Rows);
field.Attributes.Add(inputTypeAttribute);
}
public override Type ResolveValueType(FormFieldModel field)
{
if (field.DataSource != null)
{
return(typeof(IEnumerable <string>));
}
return(typeof(bool));
}
private static void RemoveValidatorAttribute <T>(FormFieldModel field) where T : Attribute
{
var existingValidator = field.ValidationAttributes.OfType <T>().FirstOrDefault();
if (existingValidator != null)
{
field.Attributes.Remove(existingValidator);
}
}
private static void RemoveAttribute <T>(FormFieldModel field) where T : Attribute
{
var existingAttribute = field.Attributes.OfType <T>().FirstOrDefault();
if (existingAttribute != null)
{
field.Attributes.Remove(existingAttribute);
}
}
public static HtmlString FormControl(this HtmlHelper helper, FormFieldModel formfield, int ID = 0, string defaultValue = "")
{
return(HtmlControllHelper.InitMetadataHtml(new FormControllerModel()
{
FieldID = formfield.FieldID,
ID = ID,
DefaultValue = defaultValue,
FormField = formfield,
}));
}
public ActionResult Fields(int formId = 0, int userid = 0)
{
var fields = db.FormFields.ToList();
ViewBag.FormField = db.FormFields.Select(x => new FormFieldModel
{
FieldName = x.FieldName,
FieldType = x.FieldType,
Id = x.Id,
IsRequired = x.IsRequired,
SortIndex = x.SortIndex,
Icons = x.Icons,
Class = x.Class
}).ToList();
var form = db.Forms.ToList();
var model = new FormModel();
var usertable = db.Users.Where(x => x.UserId == userid).FirstOrDefault();
if (usertable != null)
{
model.UserId = usertable.UserId;
}
if (formId > 0)
{
var formTable = db.Forms.Where(x => x.FormId == formId).FirstOrDefault();
if (formTable != null)
{
foreach (var item in formTable.FormDetails)
{
FormFieldModel ffModel = new FormFieldModel
{
FormDetailId = item.FormDetailId,
FieldType = item.FieldType,
Id = (int)item.Id,
FieldName = item.FieldName,
IsRequired = item.Isrequired,
Icons = item.Icons,
SortIndex = item.Sortindex,
Class = item.Class
};
model.FormName = formTable.FormName;
model.FormDescription = formTable.FormDescription;
model.UserId = formTable.UserId;
model.formField.Add(ffModel);
}
}
}
return(View(model));
}
private void SetupFormData(FormFieldModel field)
{
var markupProvider = new FormDefinitionFileMarkupProvider("\\InstalledPackages\\CompositeC1Contrib.FormBuilder.Dynamic\\EditFormFieldWorkflow.xml");
var formDocument = XDocument.Load(markupProvider.GetReader());
var layoutXElement = formDocument.Root.Element(Namespaces.BindingForms10 + FormKeyTagNames.Layout);
var bindingsXElement = formDocument.Root.Element(Namespaces.BindingForms10 + FormKeyTagNames.Bindings);
var tabPanelElements = layoutXElement.Element(Namespaces.BindingFormsStdUiControls10 + "TabPanels");
var lastTabElement = tabPanelElements.Elements().Last();
LoadExtraSettings(field, bindingsXElement, lastTabElement);
DeliverFormData("EditFormField", StandardUiContainerTypes.Document, formDocument.ToString(), Bindings, BindingsValidationRules);
}
private static string GetInputType(FormFieldModel field)
{
if (field.ValueType == typeof(DateTime))
{
return("Date");
}
var existingValidator = field.ValidationAttributes.OfType <EmailFieldValidatorAttribute>().FirstOrDefault();
if (existingValidator != null)
{
return("Email");
}
return(String.Empty);
}
public void Load(FormFieldModel field)
{
var existingValidator = field.ValidationAttributes.OfType <MaxFieldLengthAttribute>().FirstOrDefault();
if (existingValidator != null)
{
MaxLength = existingValidator.Length;
}
var inputElement = field.InputElementType as TextAreaInputElementAttribute;
if (inputElement != null)
{
Cols = inputElement.Cols;
Rows = inputElement.Rows;
}
}
private void SaveExtraSettings(FormFieldModel field)
{
var config = FormBuilderConfiguration.GetSection();
var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];
var inputElement = plugin.InputElementHandlers.Single(el => el.ElementType.GetType() == field.InputElementType.GetType());
var settingsHandler = inputElement.SettingsHandler;
if (settingsHandler != null)
{
foreach (var prop in settingsHandler.GetType().GetProperties())
{
if (BindingExist(prop.Name))
{
var value = GetBinding <object>(prop.Name);
prop.SetValue(settingsHandler, value, null);
}
}
settingsHandler.Save(field);
}
}
public void Save(FormFieldModel field)
{
switch (InputType)
{
case "Date":
RemoveValidatorAttribute <EmailFieldValidatorAttribute>(field);
field.ValueType = typeof(DateTime);
break;
case "Email":
field.ValueType = typeof(string);
if (!field.ValidationAttributes.OfType <EmailFieldValidatorAttribute>().Any())
{
field.Attributes.Add(new EmailFieldValidatorAttribute("Email is invalid"));
}
break;
default:
RemoveValidatorAttribute <EmailFieldValidatorAttribute>(field);
field.ValueType = typeof(string);
break;
}
RemoveAttribute <DisplayFormatAttribute>(field);
if (!String.IsNullOrEmpty(FormatString))
{
var formatAttribute = new DisplayFormatAttribute(FormatString);
field.Attributes.Add(formatAttribute);
}
}
public ActionResult Index(string id)
{
var model = new FormModel();
if (!string.IsNullOrEmpty(id) && !id.Trim().ToUpper().Equals("HOME"))
{
ViewBag.IsForm = true;
var formTable = db.Forms.Where(x => x.HashUrl == id).FirstOrDefault();
if (formTable != null)
{
foreach (var item in formTable.FormDetails)
{
FormFieldModel ffModel = new FormFieldModel
{
FormDetailId = item.FormDetailId,
FieldType = item.FieldType,
Id = (int)item.Id,
FieldName = item.FieldName,
IsRequired = item.Isrequired,
Icons = item.Icons,
SortIndex = item.Sortindex,
Class = item.Class,
IsRunMode = true,
};
model.FormId = formTable.FormId;
model.FormName = formTable.FormName;
model.FormDescription = formTable.FormDescription;
model.formField.Add(ffModel);
}
}
}
else
{
model = null;
}
return(View(model));
}
public virtual Type ResolveValueType(FormFieldModel field)
{
return(null);
}
public void Init()
{
var model = new FormModel("test.test");
_field = new FormFieldModel(model, "test", typeof(T), new List <Attribute>());
}
public void Load(FormFieldModel field)
{
InputType = GetInputType(field);
FormatString = GetFormatString(field);
}
public override IDynamicDefinition Load(string name, XElement xml)
{
var model = new FormModel(name)
{
SetDefaultValuesHandler = DynamicFormsFacade.SetDefaultValues
};
var fields = xml.Element("Fields").Elements("Add");
foreach (var f in fields)
{
var attrs = new List <Attribute>();
var fieldName = f.Attribute("name").Value;
foreach (var el in f.Elements())
{
switch (el.Name.LocalName)
{
case "InputElement": ParseInputElement(el, attrs); break;
case "ValidationRules": ParseValidationRules(el, attrs); break;
case "DataSource": ParseDataSource(el, attrs); break;
case "Dependencies": ParseDependencies(el, attrs); break;
}
}
var valueTypeAttr = f.Attribute("valueType");
var valueType = valueTypeAttr != null?Type.GetType(valueTypeAttr.Value) : typeof(string);
var formField = new FormFieldModel(model, fieldName, valueType, attrs);
var label = Localization.EvaluateT(formField, "Label", null);
if (label == null)
{
formField.Attributes.Add(new HiddenFieldAttribute());
}
else
{
formField.Attributes.Add(new FieldLabelAttribute());
}
var placeholderText = Localization.EvaluateT(formField, "PlaceholderText", null);
if (placeholderText != null)
{
formField.Attributes.Add(new PlaceholderTextAttribute());
}
var help = Localization.EvaluateT(formField, "Help", null);
if (help != null)
{
formField.Attributes.Add(new FieldHelpAttribute());
}
var isReadOnlyAttr = f.Attribute("isReadOnly");
if (isReadOnlyAttr != null)
{
formField.IsReadOnly = bool.Parse(isReadOnlyAttr.Value);
}
var formatAttribute = f.Attribute("format");
if (formatAttribute != null)
{
formField.Attributes.Add(new DisplayFormatAttribute(formatAttribute.Value));
}
if (valueTypeAttr == null)
{
formField.EnsureValueType();
}
model.Fields.Add(formField);
}
var definition = new DynamicFormDefinition(model);
ParseMetaData(xml, definition);
return(definition);
}
public string GetValidationMessage(FormFieldModel field)
{
return(Localization.EvaluateT(field, "Validation." + GetType().Name, _validationMessage));
}
private static string GetFormatString(FormFieldModel field)
{
var formatAttr = field.Attributes.OfType <DisplayFormatAttribute>().SingleOrDefault();
return(formatAttr == null ? String.Empty : formatAttr.FormatString);
}
protected bool MapRequestFormData(List <FormModel> model)
{
if (Request.HttpMethod != "POST")
{
return(false);
}
// CSRF protection: If the anti CSRF cookie is present, a matching token must be in the form data too.
const string antiCsrfToken = "__RequestVerificationToken";
if (Request.Cookies[antiCsrfToken] != null)
{
AntiForgery.Validate();
}
foreach (var form in model)
{
if (form.FormFields != null)
{
foreach (string formField in Request.Form)
{
if (formField == antiCsrfToken)
{
// This is not a form field, but the anti CSRF token (already validated above).
continue;
}
FormFieldModel fieldModel = form.FormFields.FirstOrDefault(f => f.Name == formField);
if (fieldModel == null)
{
Log.Debug("Form [{0}] has no defined field for form field '{1}'", form.Id, formField);
continue;
}
List <string> formFieldValues = Request.Form.GetValues(formField).Where(f => f != "false").ToList();
try
{
fieldModel.Values = formFieldValues;
}
catch (Exception ex)
{
Log.Debug("Failed to set Model [{0}] property '{1}' to value obtained from form data: '{2}'. {3}", form.Id, fieldModel.Name, formFieldValues, ex.Message);
ModelState.AddModelError(fieldModel.Name, ex.Message);
}
FormFieldValidator validator = new FormFieldValidator(fieldModel);
string validationMessage = "Field Validation Failed";
if (!validator.Validate(formFieldValues, ref validationMessage))
{
if (validationMessage != null)
{
Log.Debug("Validation of property '{0}' failed: {1}", fieldModel.Name, validationMessage);
ModelState.AddModelError(fieldModel.Name, validationMessage);
continue;
}
}
}
}
}
return(true);
}
public FormFieldValidator(FormFieldModel fieldDefinition)
{
field = fieldDefinition;
}
public ActionResult Submit()
{
FormFieldModel model = new FormFieldModel();
return(View("Thanks"));
}
public override Type ResolveValueType(FormFieldModel field)
{
return(typeof(FormFile));
}
private static Type GetUsableFieldType(FormFieldModel field)
{
return(!UsableFieldTypes.Contains(field.ValueType) ? typeof(string) : field.ValueType);
}
private string GetSelectTextField(FormFieldModel field)
{
return(field.GetSelectControlSettings()?.OptionTextField() ?? "description");
}
