Adding Orchard.DynamicForms.

src/Orchard.Web/Modules/Orchard.DynamicForms/Activities/FormSubmittedActivity.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Orchard.DynamicForms.Elements;
+using Orchard.Localization;
+using Orchard.Workflows.Models;
+using Orchard.Workflows.Services;
+
+namespace Orchard.DynamicForms.Activities {
+    public class FormSubmittedActivity : Event {
+
+        public const string EventName = "DynamicFormSubmitted";
+
+        public Localizer T { get; set; }
+
+        public override bool CanStartWorkflow {
+            get { return true; }
+        }
+
+        public override bool CanExecute(WorkflowContext workflowContext, ActivityContext activityContext) {
+            var state = activityContext.GetState<string>("DynamicForms");
+
+            // "" means 'any'.
+            if (String.IsNullOrEmpty(state)) {
+                return true;
+            }
+
+            var form = workflowContext.Tokens["DynamicForm"] as Form;
+
+            if (form == null) {
+                return false;
+            }
+
+            var formNames = state.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            return formNames.Any(x => x == form.Name);
+        }
+
+        public override IEnumerable<LocalizedString> GetPossibleOutcomes(WorkflowContext workflowContext, ActivityContext activityContext) {
+            return new[] { T("Done") };
+        }
+
+        public override IEnumerable<LocalizedString> Execute(WorkflowContext workflowContext, ActivityContext activityContext) {
+            yield return T("Done");
+        }
+
+        public override string Form {
+            get {
+                return "SelectDynamicForms";
+            }
+        }
+
+        public override string Name {
+            get { return EventName; }
+        }
+
+        public override LocalizedString Category {
+            get { return T("Forms"); }
+        }
+
+        public override LocalizedString Description {
+            get { return T("A dynamic form is submitted."); }
+        }
+    }
+
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Activities/SelectDynamicForms.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.ContentManagement;
+using Orchard.DisplayManagement;
+using Orchard.Forms.Services;
+using Orchard.Localization;
+
+namespace Orchard.DynamicForms.Activities {
+    public class SelectDynamicForms : IFormProvider {
+        protected dynamic Shape { get; set; }
+        public Localizer T { get; set; }
+
+        public SelectDynamicForms(IShapeFactory shapeFactory) {
+            Shape = shapeFactory;
+            T = NullLocalizer.Instance;
+        }
+
+        public void Describe(DescribeContext context) {
+            context.Form("SelectDynamicForms", factory => {
+                var shape = (dynamic)factory;
+                 var form = shape.Form(
+                    Id: "AnyOfDynamicForms",
+                    _Parts: Shape.Textbox(
+                        Id: "dynamicforms",
+                        Name: "DynamicForms",
+                        Title: T("Dynamic Forms"),
+                        Description: T("Enter a comma separated list of dynamic form names. Leave empty to handle all forms."),
+                        Classes: new[] { "text", "large" })
+                    );
+
+                return form;
+            });
+
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/AdminMenu.cs

@@ -0,0 +1,18 @@
+using Orchard.UI.Navigation;
+
+namespace Orchard.DynamicForms {
+    public class AdminMenu : Component, INavigationProvider {
+        public string MenuName { get { return "admin"; } }
+
+        public void GetNavigation(NavigationBuilder builder) {
+            builder
+                .AddImageSet("dynamicforms")
+                .Add(T("Dynamic Forms"), "4", menu => menu
+                    .Add(T("Manage Forms"), "1.0",
+                        item => item
+                            .Action("Index", "Admin", new { area = "Orchard.DynamicForms" })
+                            .Permission(Permissions.ManageForms))
+            );
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Bindings/BodyPartBindings.cs

@@ -0,0 +1,12 @@
+using Orchard.Core.Common.Models;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Bindings {
+    public class BodyPartBindings : Component, IBindingProvider {
+        public void Describe(BindingDescribeContext context) {
+            context.For<BodyPart>()
+                .Binding("Text", (part, s) => part.Text = s);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Bindings/TextFieldBindings.cs

@@ -0,0 +1,12 @@
+using Orchard.Core.Common.Fields;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Bindings {
+    public class TextFieldBindings : Component, IBindingProvider {
+        public void Describe(BindingDescribeContext context) {
+            context.For<TextField>()
+                .Binding("Text", (field, s) => field.Value = s);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Bindings/TitlePartBindings.cs

@@ -0,0 +1,12 @@
+using Orchard.Core.Title.Models;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Bindings {
+    public class TitlePartBindings : Component, IBindingProvider {
+        public void Describe(BindingDescribeContext context) {
+            context.For<TitlePart>()
+                .Binding("Title", (part, s) => part.Title = s);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Bindings/UserPartBindings.cs

@@ -0,0 +1,14 @@
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Users.Models;
+
+namespace Orchard.DynamicForms.Bindings {
+    public class UserPartBindings : Component, IBindingProvider {
+        public void Describe(BindingDescribeContext context) {
+            context.For<UserPart>()
+                .Binding("UserName", (part, s) => part.UserName = s)
+                .Binding("Email", (part, s) => part.Email = s)
+                .Binding("Password", (part, s) => part.Password = s);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Controllers/AdminController.cs

@@ -0,0 +1,21 @@
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.ViewModels;
+
+namespace Orchard.DynamicForms.Controllers {
+    public class AdminController : Controller {
+        private readonly IFormService _formService;
+        public AdminController(IFormService formService) {
+            _formService = formService;
+        }
+
+        public ActionResult Index() {
+            var forms = _formService.GetSubmissions().ToArray().GroupBy(x => x.FormName).ToArray();
+            var viewModel = new FormsIndexViewModel {
+                Forms = forms
+            };
+            return View(viewModel);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Controllers/FormController.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Helpers;
+using Orchard.DynamicForms.Services;
+using Orchard.Layouts.Services;
+using Orchard.Localization;
+using Orchard.Logging;
+using Orchard.UI.Notify;
+using IController = Orchard.DynamicForms.Services.IController;
+
+namespace Orchard.DynamicForms.Controllers {
+    public class FormController : Controller, IController {
+        private readonly INotifier _notifier;
+        private readonly ILayoutManager _layoutManager;
+        private readonly IFormService _formService;
+
+        public FormController(
+            INotifier notifier, 
+            ILayoutManager layoutManager, 
+            IFormService formService) {
+
+            _notifier = notifier;
+            _layoutManager = layoutManager;
+            _formService = formService;
+            T = NullLocalizer.Instance;
+            Logger = NullLogger.Instance;
+        }
+
+        public Localizer T { get; set; }
+        public ILogger Logger { get; set; }
+
+        public ActionResult Submit(int contentId, string formName) {
+            var layoutPart = _layoutManager.GetLayout(contentId);
+            var form = _formService.FindForm(layoutPart, formName);
+            var urlReferrer = HttpContext.Request.UrlReferrer != null ? HttpContext.Request.UrlReferrer.ToString() : "~/";
+
+            if (form == null) {
+                Logger.Warning("The specified form \"{0}\" could not be found.", formName);
+                _notifier.Warning(T("The specified form \"{0}\" could not be found."));
+                return Redirect(urlReferrer);
+            }
+
+            var values = _formService.SubmitForm(form, ValueProvider, ModelState);
+            this.TransferFormSubmission(form, values);
+
+            if(Response.IsRequestBeingRedirected)
+                return new EmptyResult();
+
+            var redirectUrl = !String.IsNullOrWhiteSpace(form.RedirectUrl) ? form.RedirectUrl : urlReferrer;
+            return Redirect(redirectUrl);
+        }
+
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Controllers/SubmissionAdminController.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Helpers;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.ViewModels;
+using Orchard.Localization;
+using Orchard.Mvc;
+using Orchard.UI.Admin;
+using Orchard.UI.Navigation;
+using Orchard.UI.Notify;
+
+namespace Orchard.DynamicForms.Controllers {
+    [Admin]
+    public class SubmissionAdminController : Controller {
+        private readonly IFormService _formService;
+        private readonly IOrchardServices _services;
+
+        public SubmissionAdminController(IFormService formService, IOrchardServices services) {
+            _formService = formService;
+            _services = services;
+            T = NullLocalizer.Instance;
+        }
+
+        public Localizer T { get; set; }
+
+        public ActionResult Index(string id, PagerParameters pagerParameters) {
+            var pager = new Pager(_services.WorkContext.CurrentSite, pagerParameters);
+            var submissions = _formService.GetSubmissions(id, pager.GetStartIndex(), pager.PageSize);
+            var pagerShape = _services.New.Pager(pager).TotalItemCount(submissions.TotalItemCount);
+            var viewModel = new SubmissionsIndexViewModel {
+                FormName = id,
+                Submissions = _formService.GenerateDataTable(submissions),
+                Pager = pagerShape
+            };
+            return View(viewModel);
+        }
+
+        public ActionResult Details(int id) {
+            var submission = _formService.GetSubmission(id);
+
+            if (submission == null)
+                return HttpNotFound();
+
+            var viewModel = new SubmissionViewModel {
+                Submission = submission,
+                NameValues = submission.ToNameValues()
+            };
+            return View(viewModel);
+        }
+
+        public ActionResult Delete(int id) {
+            var submission = _formService.GetSubmission(id);
+
+            if (submission == null)
+                return HttpNotFound();
+
+            _formService.DeleteSubmission(submission);
+            _services.Notifier.Information(T("That submission has been deleted."));
+            return Redirect(Request.UrlReferrer.ToString());
+        }
+
+        [FormValueRequired("submit.BulkEdit")]
+        [ActionName("Index")]
+        public ActionResult BulkDelete(IEnumerable<int> submissionIds) {
+            if (submissionIds == null || !submissionIds.Any()) {
+                _services.Notifier.Error(T("Please select the submissions to delete."));
+
+            }
+            else {
+                var numDeletedSubmissions = _formService.DeleteSubmissions(submissionIds);
+                _services.Notifier.Information(T("{0} submissions have been deleted.", numDeletedSubmissions));
+            }
+
+            return Redirect(Request.UrlReferrer.ToString());
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/BindingsElementDriver.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Linq;
+using Orchard.ContentManagement.MetaData;
+using Orchard.ContentManagement.MetaData.Models;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.ViewModels;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class BindingsElementDriver : ElementDriver<FormElement> {
+        private readonly IBindingManager _bindingManager;
+        private readonly IContentDefinitionManager _contentDefinitionManager;
+
+        public BindingsElementDriver(
+            IBindingManager bindingManager, 
+            IContentDefinitionManager contentDefinitionManager) {
+
+            _bindingManager = bindingManager;
+            _contentDefinitionManager = contentDefinitionManager;
+        }
+
+        protected override EditorResult OnBuildEditor(FormElement element, ElementEditorContext context) {
+            var contentType = element.FormBindingContentType;
+            var contentTypeDefinition = !String.IsNullOrWhiteSpace(contentType) ? _contentDefinitionManager.GetTypeDefinition(contentType) : default(ContentTypeDefinition);
+
+            if (contentTypeDefinition == null)
+                return null;
+
+            var viewModel = new FormBindingSettings {
+                AvailableBindings = _bindingManager.DescribeBindingsFor(contentTypeDefinition).ToArray()
+            };
+
+            if (context.Updater != null) {
+                context.Updater.TryUpdateModel(viewModel, null, null, new[] {"AvailableBindings"});
+            }
+
+            var bindingsEditor = context.ShapeFactory.EditorTemplate(TemplateName: "FormBindings", Model: viewModel);
+
+            bindingsEditor.Metadata.Position = "Bindings:10";
+            
+            return Editor(context, bindingsEditor);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/ButtonDriver.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class ButtonDriver : FormsElementDriver<Button> {
+        public ButtonDriver(IFormManager formManager) : base(formManager) { }
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "Button"; }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("Button", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "Form",
+                    _ButtonText: shape.Textbox(
+                        Id: "ButtonText",
+                        Name: "ButtonText",
+                        Title: "Text",
+                        Value: "Submit",
+                        Classes: new[] { "text", "medium" },
+                        Description: T("The button text.")));
+
+                return form;
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/CheckboxDriver.cs

@@ -0,0 +1,71 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class CheckboxDriver : FormsElementDriver<CheckBox> {
+        private readonly ITokenizer _tokenizer;
+
+        public CheckboxDriver(IFormManager formManager, ITokenizer tokenizer)
+            : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override EditorResult OnBuildEditor(CheckBox element, ElementEditorContext context) {
+            var autoLabelEditor = BuildForm(context, "AutoLabel");
+            var checkBoxEditor = BuildForm(context, "CheckBox");
+            var checkBoxValidation = BuildForm(context, "CheckBoxValidation", "Validation:10");
+
+            return Editor(context, autoLabelEditor, checkBoxEditor, checkBoxValidation);
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("CheckBox", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "CheckBox",
+                    _Value: shape.Textbox(
+                        Id: "Value",
+                        Name: "Value",
+                        Title: "Value",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The value of this checkbox.")));
+
+                return form;
+            });
+
+            context.Form("CheckBoxValidation", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "CheckBoxValidation",
+                    _IsRequired: shape.Checkbox(
+                        Id: "IsMandatory",
+                        Name: "IsMandatory",
+                        Title: "Mandatory",
+                        Value: "true",
+                        Description: T("Tick this checkbox to make this check box element mandatory.")),
+                    _CustomValidationMessage: shape.Textbox(
+                        Id: "CustomValidationMessage",
+                        Name: "CustomValidationMessage",
+                        Title: "Custom Validation Message",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("Optionally provide a custom validation message.")),
+                    _ShowValidationMessage: shape.Checkbox(
+                        Id: "ShowValidationMessage",
+                        Name: "ShowValidationMessage",
+                        Title: "Show Validation Message",
+                        Value: "true",
+                        Description: T("Autogenerate a validation message when a validation error occurs for the current field. Alternatively, to control the placement of the validation message you can use the ValidationMessage element instead.")));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(CheckBox element, ElementDisplayContext context) {
+            context.ElementShape.TokenizedValue = _tokenizer.Replace(element.Value, null);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/CommonFormElementDriver.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using Orchard.DisplayManagement;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class CommonFormElementDriver : FormsElementDriver<FormElement> {
+
+        public CommonFormElementDriver(IFormManager formManager, IShapeFactory shapeFactory) : base(formManager) {
+            New = shapeFactory;
+        }
+
+        public override int Priority {
+            get { return 500; }
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "CommonFormElement"; }
+        }
+
+        public dynamic New { get; set; }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("CommonFormElement", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "CommonFormElement",
+                    _Span: shape.Textbox(
+                        Id: "InputName",
+                        Name: "InputName",
+                        Title: "Name",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The name of this form field.")),
+                    _FormBindingContentType: shape.Hidden(
+                        Id: "FormBindingContentType",
+                        Name: "FormBindingContentType"));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(FormElement element, ElementDisplayContext context) {
+            context.ElementShape.Metadata.Wrappers.Add("FormElement_Wrapper");
+            context.ElementShape.Child.Add(New.PlaceChildContent(Source: context.ElementShape));
+
+        }
+
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/EnumerationDriver.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Helpers;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using Orchard.Utility.Extensions;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class EnumerationDriver : FormsElementDriver<Enumeration> {
+        private readonly ITokenizer _tokenizer;
+        public EnumerationDriver(IFormManager formManager, ITokenizer tokenizer)
+            : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get {
+                yield return "AutoLabel";
+                yield return "Enumeration";
+            }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("Enumeration", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "Enumeration",
+                    _Options: shape.Textarea(
+                        Id: "Options",
+                        Name: "Options",
+                        Title: "Options",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("Enter one option per line. To differentiate between an option's text and value, separate the two by a colon. For example: &quot;Option 1:1&quot;")),
+                    _InputType: shape.SelectList(
+                        Id: "InputType",
+                        Name: "InputType",
+                        Title: "Input Type",
+                        Description: T("The control to render when presenting the list of options.")));
+
+                form._InputType.Items.Add(new SelectListItem { Text = T("Select List").Text, Value = "SelectList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Multi Select List").Text, Value = "MultiSelectList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Radio List").Text, Value = "RadioList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Check List").Text, Value = "CheckList" });
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(Enumeration element, ElementDisplayContext context) {
+            var tokenizedOptions = _tokenizer.Replace(element.Options).ToArray();
+            var typeName = element.GetType().Name;
+            var category = element.Category.ToSafeName();
+            var displayType = context.DisplayType;
+
+            context.ElementShape.TokenizedOptions = tokenizedOptions;
+            context.ElementShape.Metadata.Alternates.Add(String.Format("Element__{0}__{1}__{2}", category, typeName, element.InputType));
+            context.ElementShape.Metadata.Alternates.Add(String.Format("Element_{0}__{1}__{2}__{3}", displayType, category, typeName, element.InputType));
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/FormDriver.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.ContentManagement.MetaData;
+using Orchard.ContentManagement.MetaData.Models;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Helpers;
+using Orchard.DynamicForms.Services;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Layouts.Helpers;
+using Orchard.Layouts.Services;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class FormDriver : FormsElementDriver<Form> {
+        private readonly IContentDefinitionManager _contentDefinitionManager;
+        private readonly IFormService _formService;
+        private readonly ICurrentControllerAccessor _currentControllerAccessor;
+        private readonly ICultureAccessor _cultureAccessor;
+
+        public FormDriver(
+            IFormManager formManager, 
+            IContentDefinitionManager contentDefinitionManager, 
+            IFormService formService, 
+            ICurrentControllerAccessor currentControllerAccessor, 
+            ICultureAccessor cultureAccessor)
+
+            : base(formManager) {
+            _contentDefinitionManager = contentDefinitionManager;
+            _formService = formService;
+            _currentControllerAccessor = currentControllerAccessor;
+            _cultureAccessor = cultureAccessor;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "Form"; }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("Form", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "Form",
+                    _FormName: shape.Textbox(
+                        Id: "FormName",
+                        Name: "FormName",
+                        Title: "Name",
+                        Classes: new[] { "text", "medium" },
+                        Description: T("The name of the form.")),
+                    _FormAction: shape.Textbox(
+                        Id: "FormAction",
+                        Name: "FormAction",
+                        Title: "Custom Target URL",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The action of the form. Leave blank to have the form submitted to the default form controller.")),
+                    _FormMethod: shape.SelectList(
+                        Id: "FormMethod",
+                        Name: "FormMethod",
+                        Title: "Method",
+                        Description: T("The method of the form.")),
+                    _EnableClientValidation: shape.Checkbox(
+                        Id: "EnableClientValidation",
+                        Name: "EnableClientValidation",
+                        Title: "Enable Client Validation",
+                        Value: "true",
+                        Description: T("Enables client validation.")),
+                    _StoreSubmission: shape.Checkbox(
+                        Id: "StoreSubmission",
+                        Name: "StoreSubmission",
+                        Title: "Store Submission",
+                        Value: "true",
+                        Description: T("Stores the submitted form into the database.")),
+                    _CreateContent: shape.Checkbox(
+                        Id: "CreateContent",
+                        Name: "CreateContent",
+                        Title: "Create Content",
+                        Value: "true",
+                        Description: T("Check this to create a content item based using the submitted values. You will have to select a Content Type here and bind the form fields to the various parts and fields of the selected Content Type.")),
+                    _ContentType: shape.SelectList(
+                        Id: "CreateContentType",
+                        Name: "CreateContentType",
+                        Title: "Content Type",
+                        Description: T("The Content Type to use when storing the submitted form values as a content item. Note that if you change the content type, you will have to update the form field bindings."),
+                        EnabledBy: "CreateContent"),
+                    _PublicationDraft: shape.Radio(
+                        Id: "Publication-Draft",
+                        Name: "Publication",
+                        Title: "Save As Draft",
+                        Value: "Draft",
+                        Checked: true,
+                        Description: T("Save the created content item as a draft."),
+                        EnabledBy: "CreateContent"),
+                    _PublicationPublish: shape.Radio(
+                        Id: "Publication-Publish",
+                        Name: "Publication",
+                        Title: "Publish",
+                        Value: "Publish",
+                        Description: T("Publish the created content item."),
+                        EnabledBy: "CreateContent"),
+                    _Notification: shape.Textbox(
+                        Id: "Notification",
+                        Name: "Notification",
+                        Title: "Show Notification",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The message to show after the form has been submitted. Leave blank if you don't want to show a message.")),
+                    _RedirectUrl: shape.Textbox(
+                        Id: "RedirectUrl",
+                        Name: "RedirectUrl",
+                        Title: "Redirect URL",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The URL to redirect to after the form has been submitted. Leave blank to stay on the same page. tip: you can use a Workflow to control what happens when this form is submitted.")));
+
+                // FormMethod
+                form._FormMethod.Items.Add(new SelectListItem { Text = "POST", Value = "POST" });
+                form._FormMethod.Items.Add(new SelectListItem { Text = "GET", Value = "GET" });
+
+                // ContentType
+                var contentTypes = _contentDefinitionManager.ListTypeDefinitions().Where(IsCreatableContentType).ToArray();
+                foreach (var contentType in contentTypes.OrderBy(x => x.DisplayName)) {
+                    form._ContentType.Items.Add(new SelectListItem { Text = contentType.DisplayName, Value = contentType.Name });
+                }
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(Form element, ElementDisplayContext context) {
+            var controller = _currentControllerAccessor.CurrentController;
+            var values = controller.FetchPostedValues(element);
+            var modelState = controller.FetchModelState(element);
+
+            if (modelState != null && !modelState.IsValid) {
+                // Read any posted values from the previous request.
+                _formService.ReadElementValues(element, new NameValueCollectionValueProvider(values, _cultureAccessor.CurrentCulture));
+
+                // Add any model validation errors from the previous request.
+                controller.ApplyAnyModelErrors(element, modelState);   
+            }
+
+            // Assign the binding content type to each element within the form element.
+            foreach (var child in element.Elements.Flatten().Where(x => x is FormElement).Cast<FormElement>()) {
+                child.FormBindingContentType = element.CreateContent == true ? element.ContentType : default(string);
+            }
+        }
+
+        private static bool IsCreatableContentType(ContentTypeDefinition contentTypeDefinition) {
+            var blacklist = new[] {"Site", "Layer"};
+
+            return !blacklist.Any(x => contentTypeDefinition.Name == x) && String.IsNullOrEmpty(contentTypeDefinition.Stereotype());
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/HiddenFieldDriver.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class HiddenFieldDriver : FormsElementDriver<HiddenField> {
+        private readonly ITokenizer _tokenizer;
+        public HiddenFieldDriver(IFormManager formManager, ITokenizer tokenizer) : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "HiddenField"; }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("HiddenField", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "HiddenField",
+                    _Span: shape.Textbox(
+                        Id: "Value",
+                        Name: "Value",
+                        Title: "Value",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The value of this hidden field.")));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(HiddenField element, ElementDisplayContext context) {
+            context.ElementShape.TokenizedValue = _tokenizer.Replace(element.Value, null);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/IpAddressFieldDriver.cs

@@ -0,0 +1,6 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class IpAddressFieldDriver : ElementDriver<IpAddressField> { }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/LabelDriver.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class LabelDriver : FormsElementDriver<Label> {
+        public LabelDriver(IFormManager formManager) : base(formManager) {}
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "Label"; }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("Label", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "Label",
+                    _LabelText: shape.Textbox(
+                        Id: "LabelText",
+                        Name: "LabelText",
+                        Title: "Text",
+                        Classes: new[] { "text", "large" },
+                        Description: T("The label text.")),
+                    _LabelFor: shape.Textbox(
+                        Id: "LabelFor",
+                        Name: "LabelFor",
+                        Title: "For",
+                        Classes: new[] { "text", "large" },
+                        Description: T("The name of the field this label is for.")));
+
+                return form;
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/RadioButtonDriver.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class RadioButtonDriver : FormsElementDriver<RadioButton> {
+        private readonly ITokenizer _tokenizer;
+
+        public RadioButtonDriver(IFormManager formManager, ITokenizer tokenizer)
+            : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get {
+                yield return "AutoLabel";
+                yield return "RadioButton";
+            }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("RadioButton", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "RadioButton",
+                    Description: T("The label for this radio button."),
+                        _Value: shape.Textbox(
+                        Id: "Value",
+                        Name: "Value",
+                        Title: "Value",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The value of this radio button.")));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(RadioButton element, ElementDisplayContext context) {
+            context.ElementShape.TokenizedValue = _tokenizer.Replace(element.Value, null);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/TaxonomyDriver.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Elements;
+using Orchard.Environment.Extensions;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Taxonomies.Models;
+using Orchard.Taxonomies.Services;
+using Orchard.Utility.Extensions;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    [OrchardFeature("Orchard.DynamicForms.Taxonomies")]
+    public class TaxonomyDriver : FormsElementDriver<Taxonomy> {
+        private readonly ITaxonomyService _taxonomyService;
+
+        public TaxonomyDriver(IFormManager formManager, ITaxonomyService taxonomyService)
+            : base(formManager) {
+            _taxonomyService = taxonomyService;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get {
+                yield return "AutoLabel";
+                yield return "TaxonomyForm";
+            }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("TaxonomyForm", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "TaxonomyForm",
+                    _OptionLabel: shape.Textbox(
+                        Id: "OptionLabel",
+                        Name: "OptionLabel",
+                        Title: "Option Label",
+                        Description: T("Optionally specify a label for the first option. If no label is specified, no empty option will be rendered.")),
+                    _Taxonomy: shape.SelectList(
+                        Id: "TaxonomyId",
+                        Name: "TaxonomyId",
+                        Title: "Taxonomy",
+                        Description: T("Select the taxonomy to use as a source for the list.")),
+                    _SortOrder: shape.SelectList(
+                        Id: "SortOrder",
+                        Name: "SortOrder",
+                        Title: "Sort Order",
+                        Description: T("The sort order to use when presenting the term values.")),
+                    _ValueType_TermText: shape.Radio(
+                        Id: "ValueType_TermText",
+                        Name: "ValueType",
+                        Title: "Use Term Name",
+                        Checked: true,
+                        Value: "TermText",
+                        Description: T("Select this option to use the term name as the option value.")),
+                    _ValueType_TermId: shape.Radio(
+                        Id: "ValueType_TermId",
+                        Name: "ValueType",
+                        Title: "Use Term ID",
+                        Checked: false,
+                        Value: "TermId",
+                        Description: T("Select this option to use the term ID as the option value.")),
+                    _InputType: shape.SelectList(
+                        Id: "InputType",
+                        Name: "InputType",
+                        Title: "Input Type",
+                        Description: T("The control to render when presenting the list of options.")));
+
+                // Taxonomy
+                var taxonomies = _taxonomyService.GetTaxonomies();
+                foreach (var taxonomy in taxonomies) {
+                    form._Taxonomy.Items.Add(new SelectListItem { Text = taxonomy.Name, Value = taxonomy.Id.ToString(CultureInfo.InvariantCulture) });
+                }
+
+                // Sort Order
+                form._SortOrder.Items.Add(new SelectListItem { Text = T("None").Text, Value = "" });
+                form._SortOrder.Items.Add(new SelectListItem { Text = T("Ascending").Text, Value = "Asc" });
+                form._SortOrder.Items.Add(new SelectListItem { Text = T("Descending").Text, Value = "Desc" });
+
+                // Input Type
+                form._InputType.Items.Add(new SelectListItem { Text = T("Select List").Text, Value = "SelectList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Multi Select List").Text, Value = "MultiSelectList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Radio List").Text, Value = "RadioList" });
+                form._InputType.Items.Add(new SelectListItem { Text = T("Check List").Text, Value = "CheckList" });
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(Taxonomy element, ElementDisplayContext context) {
+            var taxonomyId = element.TaxonomyId;
+            var typeName = element.GetType().Name;
+            var category = element.Category.ToSafeName();
+            var displayType = context.DisplayType;
+
+            context.ElementShape.TermOptions = GetTermOptions(element, taxonomyId).ToArray();
+            context.ElementShape.Metadata.Alternates.Add(String.Format("Element__{0}__{1}__{2}", category, typeName, element.InputType));
+            context.ElementShape.Metadata.Alternates.Add(String.Format("Element_{0}__{1}__{2}__{3}", displayType, category, typeName, element.InputType));
+        }
+
+        private IEnumerable<SelectListItem> GetTermOptions(Taxonomy element, int? taxonomyId) {
+            var optionLabel = element.OptionLabel;
+
+            if (!String.IsNullOrWhiteSpace(optionLabel)) {
+                yield return new SelectListItem { Text = optionLabel };
+            }
+
+            if (taxonomyId == null)
+                yield break;
+
+            var terms = _taxonomyService.GetTerms(taxonomyId.Value);
+            var valueAccessor = element.UseTermId ? (Func<TermPart, string>)(x => x.Id.ToString()) : (x => x.Name);
+            var projection = terms.Select(x => new SelectListItem {Text = x.Name, Value = valueAccessor(x)});
+
+            switch (element.SortOrder) {
+                case "Asc":
+                    projection = projection.OrderBy(x => x.Text);
+                    break;
+                case "Desc":
+                    projection = projection.OrderByDescending(x => x.Text);
+                    break;
+            }
+
+            foreach (var item in projection) {
+                yield return item;
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/TextAreaDriver.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class TextAreaDriver : FormsElementDriver<TextArea> {
+        private readonly ITokenizer _tokenizer;
+        public TextAreaDriver(IFormManager formManager, ITokenizer tokenizer) : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override IEnumerable<string> FormNames {
+            get {
+                yield return "AutoLabel";
+                yield return "TextArea";
+            }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("TextArea", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "TextArea",
+                    _Value: shape.Textarea(
+                        Id: "Value",
+                        Name: "Value",
+                        Title: "Value",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The value of this text area.")),
+                    _Rows: shape.Textbox(
+                        Id: "Rows",
+                        Name: "Rows",
+                        Title: "Rows",
+                        Classes: new[] { "text", "small" },
+                        Description: T("The number of rows for this text area.")),
+                    _Columns: shape.Textbox(
+                        Id: "Columns",
+                        Name: "Columns",
+                        Title: "Columns",
+                        Classes: new[] { "text", "small" },
+                        Description: T("The number of columns for this text area.")));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(TextArea element, ElementDisplayContext context) {
+            context.ElementShape.TokenizedValue = _tokenizer.Replace(element.RuntimeValue, null);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/TextFieldDriver.cs

@@ -0,0 +1,81 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Tokens;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class TextFieldDriver : FormsElementDriver<TextField>{
+        private readonly ITokenizer _tokenizer;
+        public TextFieldDriver(IFormManager formManager, ITokenizer tokenizer) : base(formManager) {
+            _tokenizer = tokenizer;
+        }
+
+        protected override EditorResult OnBuildEditor(TextField element, ElementEditorContext context) {
+            var autoLabelEditor = BuildForm(context, "AutoLabel");
+            var textFieldEditor = BuildForm(context, "TextField");
+            var textFieldValidation = BuildForm(context, "TextFieldValidation", "Validation:10");
+
+            return Editor(context, autoLabelEditor, textFieldEditor, textFieldValidation);
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("TextField", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "TextField",
+                    _Value: shape.Textbox(
+                        Id: "Value",
+                        Name: "Value",
+                        Title: "Value",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The value of this text field.")));
+
+                return form;
+            });
+
+            context.Form("TextFieldValidation", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "TextFieldValidation",
+                    _IsRequired: shape.Checkbox(
+                        Id: "IsRequired",
+                        Name: "IsRequired",
+                        Title: "Required",
+                        Value: "true",
+                        Description: T("Tick this checkbox to make this text field a required field.")),
+                    _MinimumLength: shape.Textbox(
+                        Id: "MinimumLength",
+                        Name: "MinimumLength",
+                        Title: "Minimum Length",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The minimum length required.")),
+                    _MaximumLength: shape.Textbox(
+                        Id: "MaximumLength",
+                        Name: "MaximumLength",
+                        Title: "Maximum Length",
+                        Classes: new[] { "text", "medium", "tokenized" },
+                        Description: T("The maximum length allowed.")),
+                    _CustomValidationMessage: shape.Textbox(
+                        Id: "CustomValidationMessage",
+                        Name: "CustomValidationMessage",
+                        Title: "Custom Validation Message",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("Optionally provide a custom validation message.")),
+                    _ShowValidationMessage: shape.Checkbox(
+                        Id: "ShowValidationMessage",
+                        Name: "ShowValidationMessage",
+                        Title: "Show Validation Message",
+                        Value: "true",
+                        Description: T("Autogenerate a validation message when a validation error occurs for the current field. Alternatively, to control the placement of the validation message you can use the ValidationMessage element instead.")));
+
+                return form;
+            });
+        }
+
+        protected override void OnDisplaying(TextField element, ElementDisplayContext context) {
+            context.ElementShape.TokenizedValue = _tokenizer.Replace(element.RuntimeValue, null);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/UserNameFieldDriver.cs

@@ -0,0 +1,6 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class UserNameFieldDriver : ElementDriver<UserNameField> { }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/ValidationElementDriver.cs

@@ -0,0 +1,94 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using Orchard.DynamicForms.Elements;
+//using Orchard.DynamicForms.Helpers;
+//using Orchard.DynamicForms.Services;
+//using Orchard.DynamicForms.Services.Models;
+//using Orchard.DynamicForms.ViewModels;
+//using Orchard.Forms.Services;
+//using Orchard.Layouts.Framework.Display;
+//using Orchard.Layouts.Framework.Drivers;
+//using Orchard.Layouts.Helpers;
+
+//namespace Orchard.DynamicForms.Drivers {
+//    public class ValidationElementDriver : ElementDriver<FormElement> {
+//        private readonly IValidationManager _validationManager;
+//        private readonly IFormManager _formManager;
+
+//        public ValidationElementDriver(IValidationManager validationManager, IFormManager formManager) {
+//            _validationManager = validationManager;
+//            _formManager = formManager;
+//        }
+
+//        protected override EditorResult OnBuildEditor(FormElement element, ElementEditorContext context) {
+//            var validatorNames = element.ValidatorNames.ToArray();
+
+//            var validators = new FieldValidationSettingsViewModel {
+//                Validators = _validationManager.GetValidatorsByNames(validatorNames).Select(x => new FieldValidationSettingViewModel() {
+//                    Name = x.Name,
+//                    SettingsEditor = BuildSettingsEditor(context, x)
+//                }).ToList()
+//            };
+
+//            if (context.Updater != null) {
+//                var viewModel = new FieldValidationSettingsViewModel();
+//                if (context.Updater.TryUpdateModel(viewModel, null, null, null)) {
+//                    if (viewModel.Validators != null) {
+//                        foreach (var validatorModel in viewModel.Validators) {
+//                            var validator = validators.Validators.SingleOrDefault(x => x.Name == validatorModel.Name);
+
+//                            if (validator == null)
+//                                continue;
+
+//                            validator.Enabled = validatorModel.Enabled;
+//                            validator.CustomValidationMessage = validatorModel.CustomValidationMessage;
+//                        }
+//                    }
+//                    validators.ShowValidationMessage = viewModel.ShowValidationMessage;
+//                }
+//            }
+
+//            // Fetch validation descriptors.
+//            foreach (var validator in validators.Validators) {
+//                validator.Descriptor = _validationManager.GetValidatorByName(validator.Name);
+//            }
+
+//            var validatorsEditor = context.ShapeFactory.EditorTemplate(TemplateName: "Validators", Model: validators);
+//            validatorsEditor.Metadata.Position = "Validation:10";
+
+//            return Editor(context, validatorsEditor);
+//        }
+
+//        protected override void OnDisplaying(FormElement element, ElementDisplayContext context) {
+//            if (context.DisplayType == "Design" || element.Form == null)
+//                return;
+
+//            if (element.Form.EnableClientValidation != true) {
+//                context.ElementShape.ClientValidationAttributes = new Dictionary<string, string>();
+//                return;
+//            }
+
+//            var clientAttributes = new Dictionary<string, string> {
+//                {"data-val", "true"}
+//            };
+
+//            foreach (var validatorSetting in element.ValidationSettings.Validators.Enabled()) {
+//                var validatorDescriptor = _validationManager.GetValidatorByName(validatorSetting.Name);
+//                var clientValidationRegistrationContext = new ClientValidationRegistrationContext(element, validatorSetting, validatorDescriptor);
+                
+//                validatorDescriptor.ClientAttributes(clientValidationRegistrationContext);
+//                clientAttributes.Combine(clientValidationRegistrationContext.ClientAttributes);
+//            }
+
+//            context.ElementShape.ClientValidationAttributes = clientAttributes;
+//        }
+
+//        private dynamic BuildSettingsEditor(ElementEditorContext context, ValidatorDescriptor validatorDescriptor) {
+//            if (String.IsNullOrWhiteSpace(validatorDescriptor.SettingsFormName))
+//                return null;
+
+//            return _formManager.Bind(_formManager.Build(validatorDescriptor.SettingsFormName), context.ValueProvider);
+//        }
+//    }
+//}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/ValidationMessageDriver.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Forms.Services;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class ValidationMessageDriver : FormsElementDriver<ValidationMessage> {
+        public ValidationMessageDriver(IFormManager formManager) : base(formManager) {}
+
+        protected override IEnumerable<string> FormNames {
+            get { yield return "ValidationMessage"; }
+        }
+
+        protected override void DescribeForm(DescribeContext context) {
+            context.Form("ValidationMessage", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "ValidationMessage",
+                    _ValidationMessageFor: shape.Textbox(
+                        Id: "ValidationMessageFor",
+                        Name: "ValidationMessageFor",
+                        Title: "For",
+                        Classes: new[] { "text", "large" },
+                        Description: T("The name of the field this validation message is for.")));
+
+                return form;
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Drivers/ValidationSummaryDriver.cs

@@ -0,0 +1,7 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.Layouts.Framework.Drivers;
+
+namespace Orchard.DynamicForms.Drivers {
+    public class ValidationSummaryDriver : ElementDriver<ValidationSummary> {
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Button.cs

@@ -0,0 +1,14 @@
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class Button : FormElement {
+        public override bool HasEditor {
+            get { return true; }
+        }
+
+        public string Text {
+            get { return State.Get("ButtonText", "Submit"); }
+            set { State["ButtonText"] = value; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Checkbox.cs

@@ -0,0 +1,9 @@
+using Orchard.DynamicForms.Validators.Settings;
+
+namespace Orchard.DynamicForms.Elements {
+    public class CheckBox : LabeledFormElement {
+        public CheckBoxValidationSettings ValidationSettings {
+            get { return State.GetModel<CheckBoxValidationSettings>(""); }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Enumeration.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Web.Mvc;
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class Enumeration : LabeledFormElement {
+        private readonly Lazy<IEnumerable<SelectListItem>> _options;
+
+        public Enumeration() {
+            _options = new Lazy<IEnumerable<SelectListItem>>(GetOptions);
+        }
+
+        public IEnumerable<SelectListItem> Options {
+            get { return _options.Value; }
+        }
+
+        public string InputType {
+            get { return State.Get("InputType", "SelectList"); }
+            set { State["InputType"] = value; }
+        }
+
+        private IEnumerable<SelectListItem> GetOptions() {
+            return ParseOptionsText();
+        }
+
+        private IEnumerable<SelectListItem> ParseOptionsText() {
+            var data = State.Get("Options");
+            var lines = Regex.Split(data, @"(?:\r\n|[\r\n])", RegexOptions.Multiline);
+            return lines.Select(ParseLine).Where(x => x != null);
+        }
+
+        private static SelectListItem ParseLine(string line) {
+            if (String.IsNullOrWhiteSpace(line))
+                return null;
+
+            var parts = line.Split(':');
+
+            if (parts.Length == 1) {
+                var value = parts[0].Trim();
+                return new SelectListItem {
+                    Text = value,
+                    Value = value
+                };
+            }
+            else {
+                var text = parts[0].Trim();
+                var value = String.Join(":", parts.Skip(1)).Trim();
+                return new SelectListItem {
+                    Text = text,
+                    Value = value
+                };
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Form.cs

@@ -0,0 +1,60 @@
+using Orchard.Layouts.Elements;
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class Form : Container {
+        public override string Category {
+            get { return "Form"; }
+        }
+
+        public string Name {
+            get { return State.Get("FormName"); }
+            set { State["FormName"] = value; }
+        }
+
+        public bool? EnableClientValidation {
+            get { return State.Get("EnableClientValidation").ToBoolean(); }
+            set { State["EnableClientValidation"] = value.ToString(); }
+        }
+
+        public string Action {
+            get { return State.Get("FormAction"); }
+            set { State["FormAction"] = value; }
+        }
+
+        public string Method {
+            get { return State.Get("FormMethod"); }
+            set { State["FormMethod"] = value; }
+        }
+
+        public bool? StoreSubmission {
+            get { return State.Get("StoreSubmission").ToBoolean(); }
+            set { State["StoreSubmission"] = value != null ? value.Value.ToString() : null; }
+        }
+
+        public bool? CreateContent {
+            get { return State.Get("CreateContent").ToBoolean(); }
+            set { State["CreateContent"] = value != null ? value.Value.ToString() : null; }
+        }
+
+        public string ContentType {
+            get { return State.Get("CreateContentType"); }
+            set { State["CreateContentType"] = value; }
+        }
+
+        public string Publication {
+            get { return State.Get("Publication"); }
+            set { State["Publication"] = value; }
+        }
+
+        public string Notification {
+            get { return State.Get("Notification"); }
+            set { State["Notification"] = value; }
+        }
+
+        public string RedirectUrl {
+            get { return State.Get("RedirectUrl"); }
+            set { State["RedirectUrl"] = value; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/FormCategoryProvider.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using Orchard.Layouts.Framework.Elements;
+using Orchard.Layouts.Framework.Harvesters;
+
+namespace Orchard.DynamicForms.Elements {
+    public class FormCategoryProvider : Component, ICategoryProvider {
+        public IEnumerable<Category> GetCategories() {
+            yield return new Category("Form", T("Form"), T("Contains elements that help building forms."), 10);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/FormElement.cs

@@ -0,0 +1,56 @@
+using System;
+using Orchard.Layouts.Framework.Elements;
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public abstract class FormElement : Element {
+        private Lazy<string> _runtimeValue;
+
+        protected FormElement() {
+            _runtimeValue = new Lazy<string>(() => Value);
+        }
+
+        public override string Category {
+            get { return "Form"; }
+        }
+
+        public override bool HasEditor {
+            get { return true; }
+        }
+
+        public virtual string Name {
+            get { return State.Get("InputName"); }
+        }
+
+        public string Value {
+            get { return State.Get("Value"); }
+        }
+
+        public string RuntimeValue {
+            get { return _runtimeValue.Value; }
+            set { _runtimeValue = new Lazy<string>(() => value); }
+        }
+
+        public string FormBindingContentType {
+            get { return State.Get("FormBindingContentType"); }
+            set { State["FormBindingContentType"] = value; }
+        }
+
+        public Form Form {
+            get {
+                var parent = Container;
+
+                while (parent != null) {
+                    var form = parent as Form;
+
+                    if (form != null)
+                        return form;
+
+                    parent = parent.Container;
+                }
+
+                return null;
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/HiddenField.cs

@@ -0,0 +1,4 @@
+namespace Orchard.DynamicForms.Elements {
+    public class HiddenField : FormElement {
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/IpAddressField.cs

@@ -0,0 +1,11 @@
+namespace Orchard.DynamicForms.Elements {
+    public class IpAddressField : FormElement {
+        public override bool HasEditor {
+            get { return false; }
+        }
+
+        public override string Name {
+            get { return "IPAddress"; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Label.cs

@@ -0,0 +1,24 @@
+using Orchard.Layouts.Framework.Elements;
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class Label : Element {
+        public override string Category {
+            get { return "Form"; }
+        }
+
+        public override bool HasEditor {
+            get { return true; }
+        }
+
+        public string Text {
+            get { return State.Get("LabelText"); }
+            set { State["LabelText"] = value; }
+        }
+
+        public string For {
+            get { return State.Get("LabelFor"); }
+            set { State["LabelFor"] = value; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/LabeledFormElement.cs

@@ -0,0 +1,15 @@
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public abstract class LabeledFormElement : FormElement {
+        public string Label {
+            get { return State.Get("Label"); }
+            set { State["Label"] = value; }
+        }
+
+        public bool ShowLabel {
+            get { return State.Get("ShowLabel").ToBoolean().GetValueOrDefault(); }
+            set { State["ShowLabel"] = value.ToString(); }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/RadioButton.cs

@@ -0,0 +1,4 @@
+namespace Orchard.DynamicForms.Elements {
+    public class RadioButton : LabeledFormElement {
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/Taxonomy.cs

@@ -0,0 +1,30 @@
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class Taxonomy : LabeledFormElement {
+        
+        public string InputType {
+            get { return State.Get("InputType", "SelectList"); }
+            set { State["InputType"] = value; }
+        }
+
+        public int? TaxonomyId {
+            get { return State.Get("TaxonomyId").ToInt32(); }
+            set { State["TaxonomyId"] = value.ToString(); }
+        }
+
+        public string SortOrder {
+            get { return State.Get("SortOrder"); }
+            set { State["SortOrder"] = value; }
+        }
+
+        public string OptionLabel {
+            get { return State.Get("OptionLabel"); }
+            set { State["OptionLabel"] = value; }
+        }
+
+        public bool UseTermId {
+            get { return State.Get("ValueType") == "TermId"; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/TextArea.cs

@@ -0,0 +1,15 @@
+using Orchard.Layouts.Helpers;
+
+namespace Orchard.DynamicForms.Elements {
+    public class TextArea : LabeledFormElement {
+        public int? Rows {
+            get { return State.Get("Rows").ToInt32(); }
+            set { State["Rows"] = value.ToString(); }
+        }
+
+        public int? Columns {
+            get { return State.Get("Columns").ToInt32(); }
+            set { State["Columns"] = value.ToString(); }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/TextField.cs

@@ -0,0 +1,9 @@
+using Orchard.DynamicForms.Validators.Settings;
+
+namespace Orchard.DynamicForms.Elements {
+    public class TextField : LabeledFormElement {
+        public TextFieldValidationSettings ValidationSettings {
+            get { return State.GetModel<TextFieldValidationSettings>(""); }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/UserNameField.cs

@@ -0,0 +1,11 @@
+namespace Orchard.DynamicForms.Elements {
+    public class UserNameField : FormElement {
+        public override bool HasEditor {
+            get { return false; }
+        }
+
+        public override string Name {
+            get { return "UserName"; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/ValidationMessage.cs

@@ -0,0 +1,13 @@
+using Orchard.Layouts.Framework.Elements;
+
+namespace Orchard.DynamicForms.Elements {
+    public class ValidationMessage : Element {
+        public override string Category {
+            get { return "Form"; }
+        }
+
+        public override bool HasEditor {
+            get { return true; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Elements/ValidationSummary.cs

@@ -0,0 +1,13 @@
+using Orchard.Layouts.Framework.Elements;
+
+namespace Orchard.DynamicForms.Elements {
+    public class ValidationSummary : Element {
+        public override string Category {
+            get { return "Form"; }
+        }
+
+        public override bool HasEditor {
+            get { return false; }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Forms/AutoLabelForm.cs

@@ -0,0 +1,30 @@
+using Orchard.Forms.Services;
+using DescribeContext = Orchard.Forms.Services.DescribeContext;
+
+namespace Orchard.DynamicForms.Forms {
+    public class AutoLabelForm : Component, IFormProvider {
+    
+        public void Describe(DescribeContext context) {
+            context.Form("AutoLabel", factory => {
+                var shape = (dynamic)factory;
+                var form = shape.Fieldset(
+                    Id: "AutoLabel",
+                     _ShowLabel: shape.Checkbox(
+                        Id: "ShowLabel",
+                        Name: "ShowLabel",
+                        Title: "Show Label",
+                        Value: "true",
+                        Description: T("Check this to show a label for this text field.")),
+                    _Label: shape.Textbox(
+                        Id: "Label",
+                        Name: "Label",
+                        Title: "Label",
+                        Classes: new[] { "text", "large", "tokenized" },
+                        Description: T("The label text to render."),
+                        EnabledBy: "ShowLabel"));
+
+                return form;
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ClientValidationRegistrationCoordinator.cs

@@ -0,0 +1,45 @@
+using System.Linq;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Layouts.Framework.Display;
+using Orchard.Layouts.Framework.Drivers;
+using Orchard.Layouts.Services;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class ClientValidationRegistrationCoordinator : IFormElementEventHandler, IElementEventHandler {
+        private readonly IFormService _formService;
+        public ClientValidationRegistrationCoordinator(IFormService formService) {
+            _formService = formService;
+        }
+
+        void IFormElementEventHandler.RegisterClientValidation(RegisterClientValidationAttributesEventContext context) {
+            var validators = _formService.GetValidators(context.Element).ToArray();
+
+            foreach (var validator in validators) {
+                validator.RegisterClientValidation(context);
+            }
+        }
+
+        void IElementEventHandler.Displaying(ElementDisplayContext context) {
+            var element = context.Element as FormElement;
+
+            if (element == null)
+                return;
+
+            var registrationContext = new RegisterClientValidationAttributesEventContext { Element = element };
+
+            if (element.Form.EnableClientValidation == true) {    
+                _formService.RegisterClientValidationAttributes(registrationContext);
+            }
+
+            context.ElementShape.ClientValidationAttributes = registrationContext.ClientAttributes;
+        }
+
+        void IFormElementEventHandler.GetElementValue(FormElement element, ReadElementValuesContext context) { }
+        void IElementEventHandler.Creating(ElementCreatingContext context) {}
+        void IElementEventHandler.Created(ElementCreatedContext context) {}
+        void IElementEventHandler.BuildEditor(ElementEditorContext context) {}
+        void IElementEventHandler.UpdateEditor(ElementEditorContext context) {}
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/FormSubmissionCoordinator.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using Orchard.ContentManagement;
+using Orchard.DynamicForms.Activities;
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Layouts.Helpers;
+using Orchard.UI.Notify;
+using Orchard.Workflows.Services;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class FormSubmissionCoordinator : FormEventHandlerBase {
+        private readonly INotifier _notifier;
+        private readonly IWorkflowManager _workflowManager;
+
+        public FormSubmissionCoordinator(INotifier notifier, IWorkflowManager workflowManager) {
+            _notifier = notifier;
+            _workflowManager = workflowManager;
+        }
+
+        public override void Validated(FormValidatedEventContext context) {
+            if (!context.ModelState.IsValid)
+                return;
+
+            var form = context.Form;
+            var formName = form.Name;
+            var values = context.Values;
+            var formService = context.FormService;
+
+            // Store the submission.
+            if (form.StoreSubmission == true) {
+                formService.CreateSubmission(formName, values);
+            }
+
+            // Create content item.
+            var contentItem = default(ContentItem);
+            if (form.CreateContent == true && !String.IsNullOrWhiteSpace(form.ContentType)) {
+                contentItem = formService.CreateContentItem(form, context.ValueProvider);
+            }
+
+            // Notifiy.
+            if (!String.IsNullOrWhiteSpace(form.Notification))
+                _notifier.Information(T(form.Notification));
+
+            // Trigger workflow event.
+            var formValuesDictionary = values.ToTokenDictionary();
+            _workflowManager.TriggerEvent(FormSubmittedActivity.EventName, contentItem, () => new Dictionary<string, object>(formValuesDictionary) {
+                {"DynamicForm", form}
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/IpAddressFieldHandler.cs

@@ -0,0 +1,23 @@
+using Orchard.AuditTrail.Services;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class IpAddressFieldHandler : FormElementEventHandlerBase {
+        private readonly IClientIpAddressProvider _clientIpAddressProvider;
+
+        public IpAddressFieldHandler(IClientIpAddressProvider clientIpAddressProvider) {
+            _clientIpAddressProvider = clientIpAddressProvider;
+        }
+
+        public override void GetElementValue(FormElement element, ReadElementValuesContext context) {
+            var ipAddressField = element as IpAddressField;
+
+            if (ipAddressField == null)
+                return;
+
+            var key = ipAddressField.Name;
+            context.Output[key] = _clientIpAddressProvider.GetClientIpAddress();
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ReadFormValuesHandler.cs

@@ -0,0 +1,29 @@
+using System;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class ReadFormValuesHandler : FormElementEventHandlerBase {
+        public override void GetElementValue(FormElement element, ReadElementValuesContext context) {
+
+            if (String.IsNullOrWhiteSpace(element.Name))
+                return;
+
+            var key = element.Name;
+            var valueProviderResult = context.ValueProvider.GetValue(key);
+
+            if (String.IsNullOrWhiteSpace(key) || valueProviderResult == null)
+                return;
+
+            var items = valueProviderResult.RawValue as string[];
+            if (items == null)
+                return;
+
+            foreach (var item in items) {
+                context.Output[key] = item;
+            }
+
+            element.RuntimeValue = String.Join(",", items);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/UserNameFieldHandler.cs

@@ -0,0 +1,22 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class UserNameFieldHandler : FormElementEventHandlerBase {
+        private readonly IWorkContextAccessor _wca;
+        public UserNameFieldHandler(IWorkContextAccessor wca) {
+            _wca = wca;
+        }
+
+        public override void GetElementValue(FormElement element, ReadElementValuesContext context) {
+            var userNameField = element as UserNameField;
+
+            if (userNameField == null)
+                return;
+
+            var key = userNameField.Name;
+            var currentUser = _wca.GetContext().CurrentUser;
+            context.Output[key] = currentUser != null ? currentUser.UserName : null;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ValidatorsCoordinator.cs

@@ -0,0 +1,30 @@
+using Orchard.DynamicForms.Services;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Handlers {
+    public class ValidatorsCoordinator : FormEventHandlerBase {
+        public override void Validating(FormValidatingEventContext context) {
+            var form = context.Form;
+            var values = context.Values;
+            var formService = context.FormService;
+            var formElements = formService.GetFormElements(form);
+            var modelState = context.ModelState;
+
+            // Get the validators for each element and validate its submitted values.
+            foreach (var element in formElements) {
+                var validators = formService.GetValidators(element);
+                var attemptedValue = values[element.Name];
+
+                foreach (var validator in validators) {
+                    var validateContext = new ValidateInputContext {
+                        Element = element,
+                        ModelState = modelState,
+                        AttemptedValue = attemptedValue,
+                        FieldName = element.Name
+                    };
+                    validator.Validate(validateContext);
+                }
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/ContentTypeDefinitionExtensions.cs

@@ -0,0 +1,9 @@
+using Orchard.ContentManagement.MetaData.Models;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class ContentTypeDefinitionExtensions {
+        public static string Stereotype(this ContentTypeDefinition contentTypeDefinition) {
+            return contentTypeDefinition.Settings.ContainsKey("Stereotype") ? contentTypeDefinition.Settings["Stereotype"] : null;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/DataTableExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Data;
+using System.IO;
+using System.Linq;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class DataTableExtensions {
+        public static string ToCsv(this DataTable table, string delimiter = ",", bool includeHeader = true) {
+            using (var writer = new StringWriter()) {
+                ToCsv(table, writer, delimiter, includeHeader);
+                return writer.GetStringBuilder().ToString();
+            }
+        }
+
+        public static Stream ToCsv(this DataTable table, Stream output, string delimiter = ",", bool includeHeader = true) {
+            var writer = new StreamWriter(output);
+            ToCsv(table, writer, delimiter, includeHeader);
+            return output;
+        }
+
+        public static TextWriter ToCsv(this DataTable table, TextWriter writer, string delimiter = ",", bool includeHeader = true) {
+            if (includeHeader) {
+                var columnNames = table.Columns.Cast<DataColumn>().Select(column => column.ColumnName);
+                writer.WriteLine(String.Join(",", columnNames));
+            }
+
+            var projection =
+                from DataRow row in table.Rows
+                select row.ItemArray.Select(field => String.Concat("\"", field.ToString().Replace("\"", "\"\""), "\""));
+
+            foreach (var fields in projection) {
+                writer.WriteLine(String.Join(",", fields));
+            }
+
+            writer.Flush();
+            return writer;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/FieldValidatorsExtensions.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Linq;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class FieldValidatorsExtensions {
+        public static IEnumerable<FieldValidatorSetting> Enabled(this IEnumerable<FieldValidatorSetting> list) {
+            return list.Where(x => x.Enabled);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/FormControllerExtensions.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Elements;
+
+namespace Orchard.DynamicForms.Helpers {
+    internal static class FormControllerExtensions {
+        internal static void TransferFormSubmission(this Controller controller, Form form, NameValueCollection values) {
+            controller.TempData[String.Format("Form_ModelState_{0}", form.Name)] = controller.ModelState;
+            controller.TempData[String.Format("Form_Values_{0}", form.Name)] = values;
+        }
+
+        internal static ModelStateDictionary FetchModelState(this Controller controller, Form form) {
+            return (ModelStateDictionary)controller.TempData[String.Format("Form_ModelState_{0}", form.Name)];
+        }
+
+        internal static NameValueCollection FetchPostedValues(this Controller controller, Form form) {
+            return (NameValueCollection)controller.TempData[String.Format("Form_Values_{0}", form.Name)] ?? new NameValueCollection();
+        }
+
+        internal static void ApplyAnyModelErrors(this Controller controller, Form form, ModelStateDictionary modelState) {
+            var hasErrors = modelState != null && !modelState.IsValid;
+
+            if (hasErrors) {
+                foreach (var state in modelState) {
+                    if (state.Value.Errors.Any()) {
+                        foreach (var error in state.Value.Errors) {
+                            controller.ModelState.AddModelError(state.Key, error.ErrorMessage);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/NameValueCollectionExtensions.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Web;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class NameValueCollectionExtensions {
+        public static string ToQueryString(this NameValueCollection nameValues) {
+            return String.Join("&", (from string name in nameValues select String.Concat(name, "=", HttpUtility.UrlEncode(nameValues[name]))).ToArray());
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/StreamExtensions.cs

@@ -0,0 +1,10 @@
+using System.IO;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class StreamExtensions {
+        public static T Reset<T>(this T stream) where T:Stream {
+            stream.Position = 0;
+            return stream;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/SubmissionExtensions.cs

@@ -0,0 +1,11 @@
+using System.Collections.Specialized;
+using System.Web;
+using Orchard.DynamicForms.Models;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class SubmissionExtensions {
+        public static NameValueCollection ToNameValues(this Submission submission) {
+            return HttpUtility.ParseQueryString(submission.FormData);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Helpers/TokenizerExtensions.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.Tokens;
+
+namespace Orchard.DynamicForms.Helpers {
+    public static class TokenizerExtensions {
+        public static IEnumerable<SelectListItem> Replace(this ITokenizer tokenizer, IEnumerable<SelectListItem> items) {
+            return items.Select(item => new SelectListItem {
+                Text = tokenizer.Replace(item.Text, null),
+                Value = item.Value,
+                Disabled = item.Disabled,
+                Group = item.Group,
+                Selected = item.Selected
+            });
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/ImportExport/FormsExportHandler.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Orchard.DynamicForms.Services;
+using Orchard.Environment.Extensions;
+using Orchard.Events;
+
+namespace Orchard.DynamicForms.ImportExport {
+    public interface IExportEventHandler : IEventHandler {
+        void Exporting(dynamic context);
+        void Exported(dynamic context);
+    }
+
+    [OrchardFeature("Orchard.DynamicForms.ImportExport")]
+    public class FormsExportHandler : IExportEventHandler {
+        private readonly IFormService _formService;
+        public FormsExportHandler(IFormService formService) {
+            _formService = formService;
+        }
+
+        public void Exporting(dynamic context) {
+        }
+
+        public void Exported(dynamic context) {
+
+            if (!((IEnumerable<string>)context.ExportOptions.CustomSteps).Contains("Forms")) {
+                return;
+            }
+
+            var submissions = _formService.GetSubmissions().ToArray();
+
+            if (!submissions.Any()) {
+                return;
+            }
+
+            var forms = submissions.GroupBy(x => x.FormName);
+            var root = new XElement("Forms");
+            context.Document.Element("Orchard").Add(root);
+
+            foreach (var form in forms) {
+                root.Add(new XElement("Form",
+                    new XAttribute("Name", form.Key),
+                    new XElement("Submissions", form.Select(submission =>
+                        new XElement("Submission",
+                            new XAttribute("CreatedUtc", submission.CreatedUtc),
+                            new XCData(submission.FormData))))));
+            }
+        }
+    }
+}
+

src/Orchard.Web/Modules/Orchard.DynamicForms/ImportExport/FormsExportStep.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using Orchard.Environment.Extensions;
+using Orchard.Events;
+
+namespace Orchard.DynamicForms.ImportExport {
+    public interface ICustomExportStep : IEventHandler {
+        void Register(IList<string> steps);
+    }
+
+    [OrchardFeature("Orchard.DynamicForms.ImportExport")]
+    public class FormsExportStep : ICustomExportStep {
+        public void Register(IList<string> steps) {
+            steps.Add("Forms");
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/ImportExport/FormsImportHandler.cs

@@ -0,0 +1,39 @@
+using System;
+using Orchard.ContentManagement;
+using Orchard.DynamicForms.Models;
+using Orchard.DynamicForms.Services;
+using Orchard.Environment.Extensions;
+using Orchard.Recipes.Models;
+using Orchard.Recipes.Services;
+
+namespace Orchard.DynamicForms.ImportExport {
+    [OrchardFeature("Orchard.DynamicForms.ImportExport")]
+    public class FormsImportHandler : Component, IRecipeHandler {
+        private readonly IFormService _formService;
+        public FormsImportHandler(IFormService formService) {
+            _formService = formService;
+        }
+
+        public void ExecuteRecipeStep(RecipeContext recipeContext) {
+            if (!String.Equals(recipeContext.RecipeStep.Name, "Forms", StringComparison.OrdinalIgnoreCase)) {
+                return;
+            }
+
+            var formsElement = recipeContext.RecipeStep.Step.Elements();
+            foreach (var formElement in formsElement) {
+                var formName = formElement.Attr<string>("Name");
+                var submissionElements = formElement.Element("Submissions").Elements();
+
+                foreach (var submissionElement in submissionElements) {
+                    _formService.CreateSubmission(new Submission {
+                        FormName = formName,
+                        CreatedUtc = submissionElement.Attr<DateTime>("CreatedUtc"),
+                        FormData = submissionElement.Value
+                    });
+                }
+            }
+
+            recipeContext.Executed = true;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Migrations.cs

@@ -0,0 +1,62 @@
+using System;
+using Orchard.ContentManagement.MetaData;
+using Orchard.Core.Contents.Extensions;
+using Orchard.Data.Migration;
+
+namespace Orchard.DynamicForms {
+    public class Migrations : DataMigrationImpl {
+        public int Create() {
+            SchemaBuilder.CreateTable("Submission", table => table
+                .Column<int>("Id", c => c.PrimaryKey().Identity())
+                .Column<string>("FormName", c => c.WithLength(128))
+                .Column<string>("FormData", c => c.Unlimited())
+                .Column<DateTime>("CreatedUtc"));
+
+            ContentDefinitionManager.AlterTypeDefinition("Form", type => type
+                .WithPart("CommonPart", p => p
+                    .WithSetting("OwnerEditorSettings.ShowOwnerEditor", "false")
+                    .WithSetting("DateEditorSettings.ShowDateEditor", "false"))
+                .WithPart("TitlePart")
+                 .WithPart("AutoroutePart", builder => builder
+                    .WithSetting("AutorouteSettings.AllowCustomPattern", "True")
+                    .WithSetting("AutorouteSettings.AutomaticAdjustmentOnEdit", "False")
+                    .WithSetting("AutorouteSettings.PatternDefinitions", "[{\"Name\":\"Title\",\"Pattern\":\"{Content.Slug}\",\"Description\":\"my-form\"}]")
+                    .WithSetting("AutorouteSettings.DefaultPatternIndex", "0"))
+                .WithPart("LayoutPart", p => p
+                    .WithSetting("LayoutTypePartSettings.DefaultLayoutState", 
+                    "{" +
+                        "\"elements\": [{" +
+                            "\"typeName\": \"Orchard.DynamicForms.Elements.Form\"," +
+                            "\"elements\": [{" +
+                                "\"typeName\": \"Orchard.DynamicForms.Elements.Button\"," +
+                                "\"state\": \"ButtonText=Submit\"" +
+                            "}]" +
+                        "}]" +
+                    "}"))
+                .DisplayedAs("Form")
+                .Listable()
+                .Creatable()
+                .Draftable());
+
+            ContentDefinitionManager.AlterTypeDefinition("FormWidget", type => type
+                .WithPart("CommonPart", p => p
+                    .WithSetting("OwnerEditorSettings.ShowOwnerEditor", "false")
+                    .WithSetting("DateEditorSettings.ShowDateEditor", "false"))
+                .WithPart("WidgetPart")
+                .WithPart("LayoutPart", p => p
+                    .WithSetting("LayoutTypePartSettings.DefaultLayoutState",
+                    "{" +
+                        "\"elements\": [{" +
+                            "\"typeName\": \"Orchard.DynamicForms.Elements.Form\"," +
+                            "\"elements\": [{" +
+                                "\"typeName\": \"Orchard.DynamicForms.Elements.Button\"," +
+                                "\"state\": \"ButtonText=Submit\"" +
+                            "}]" +
+                        "}]" +
+                    "}"))
+                .WithSetting("Stereotype", "Widget")
+                .DisplayedAs("Form Widget"));
+            return 1;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Models/Submission.cs

@@ -0,0 +1,13 @@
+using System;
+using Orchard.Data.Conventions;
+
+namespace Orchard.DynamicForms.Models {
+    public class Submission {
+        public virtual int Id { get; set; }
+        public virtual string FormName { get; set; }
+
+        [StringLengthMax]
+        public virtual string FormData { get; set; }
+        public virtual DateTime CreatedUtc { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Module.txt

@@ -0,0 +1,23 @@
+Name: Custom Forms
+AntiForgery: enabled
+Author: The Orchard Team
+Website: http://orchardcustomforms.codeplex.com
+Version: 1.8.1
+OrchardVersion: 1.8
+Description: Create custom forms like contact forms using layouts.
+Features:
+    Orchard.DynamicForms:
+        Name: Dynamic Forms
+        Description: Create custom forms like contact forms using layouts.
+        Category: Forms
+        Dependencies: Orchard.Layouts, Orchard.Tokens, Orchard.Workflows, Orchard.Users, Orchard.AuditTrail, Common
+    Orchard.DynamicForms.Taxonomies:
+        Name: Taxonomy Element
+        Description: Adds a Taxonomy foem element to the sytem.
+        Category: Forms
+        Dependencies: Orchard.DynamicForms, Orchard.Taxonomies
+    Orchard.DynamicForms.ImportExport:
+        Name: Dynamic Forms Import Export
+        Description: Enables the import and export of form submissions.
+        Category: Forms
+        Dependencies: Orchard.DynamicForms, Orchard.ImportExport

src/Orchard.Web/Modules/Orchard.DynamicForms/Orchard.DynamicForms.csproj

@@ -0,0 +1,392 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{82190F52-2901-46D6-8A4C-34649959483F}</ProjectGuid>
+    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Orchard.DynamicForms</RootNamespace>
+    <AssemblyName>Orchard.DynamicForms</AssemblyName>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <MvcBuildViews>false</MvcBuildViews>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>4.0</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <TargetFrameworkProfile />
+    <UseIISExpress>false</UseIISExpress>
+    <IISExpressSSLPort />
+    <IISExpressAnonymousAuthentication />
+    <IISExpressWindowsAuthentication />
+    <IISExpressUseClassicPipelineMode />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.ComponentModel.DataAnnotations">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Web.ApplicationServices" />
+    <Reference Include="System.Web.DynamicData" />
+    <Reference Include="System.Web.Entity" />
+    <Reference Include="System.Web.Extensions" />
+    <Reference Include="System.Web.Mvc, Version=5.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\lib\aspnetmvc\System.Web.Mvc.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Abstractions" />
+    <Reference Include="System.Web.Routing" />
+    <Reference Include="System.Web.WebPages, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\lib\aspnetmvc\System.Web.WebPages.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Xml.Linq" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Scripts\jquery.validate.js" />
+    <Content Include="Scripts\jquery.validate.min.js" />
+    <Content Include="Scripts\jquery.validate.unobtrusive.additional.js" />
+    <Content Include="Scripts\jquery.validate.unobtrusive.js" />
+    <Content Include="Scripts\jquery.validate.unobtrusive.min.js" />
+    <Content Include="Styles\form-elements.css" />
+    <Content Include="Styles\forms-admin.css" />
+    <Content Include="Styles\form.designer.css" />
+    <Content Include="Styles\menu.dynamicforms-admin.css" />
+    <Content Include="Styles\menu.dynamicforms.png" />
+    <Content Include="Web.config" />
+    <Content Include="Scripts\Web.config" />
+    <Content Include="Styles\Web.config" />
+    <Content Include="Properties\AssemblyInfo.cs" />
+    <Content Include="Module.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Orchard\Orchard.Framework.csproj">
+      <Project>{2D1D92BB-4555-4CBE-8D0E-63563D6CE4C6}</Project>
+      <Name>Orchard.Framework</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Core\Orchard.Core.csproj">
+      <Project>{9916839C-39FC-4CEB-A5AF-89CA7E87119F}</Project>
+      <Name>Orchard.Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.AuditTrail\Orchard.AuditTrail.csproj">
+      <Project>{3dd574cd-9c5d-4a45-85e1-ebba64c22b5f}</Project>
+      <Name>Orchard.AuditTrail</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Forms\Orchard.Forms.csproj">
+      <Project>{642a49d7-8752-4177-80d6-bfbbcfad3de0}</Project>
+      <Name>Orchard.Forms</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Layouts\Orchard.Layouts.csproj">
+      <Project>{6bd8b2fa-f2e3-4ac8-a4c3-2925a653889a}</Project>
+      <Name>Orchard.Layouts</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Taxonomies\Orchard.Taxonomies.csproj">
+      <Project>{e649ea64-d213-461b-87f7-d67035801443}</Project>
+      <Name>Orchard.Taxonomies</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Tokens\Orchard.Tokens.csproj">
+      <Project>{6f759635-13d7-4e94-bcc9-80445d63f117}</Project>
+      <Name>Orchard.Tokens</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Users\Orchard.Users.csproj">
+      <Project>{79aed36e-abd0-4747-93d3-8722b042454b}</Project>
+      <Name>Orchard.Users</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Workflows\Orchard.Workflows.csproj">
+      <Project>{7059493c-8251-4764-9c1e-2368b8b485bc}</Project>
+      <Name>Orchard.Workflows</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Activities\FormSubmittedActivity.cs" />
+    <Compile Include="Activities\SelectDynamicForms.cs" />
+    <Compile Include="Bindings\TextFieldBindings.cs" />
+    <Compile Include="Bindings\BodyPartBindings.cs" />
+    <Compile Include="Bindings\UserPartBindings.cs" />
+    <Compile Include="Controllers\SubmissionAdminController.cs" />
+    <Compile Include="Controllers\AdminController.cs" />
+    <Compile Include="Controllers\FormController.cs" />
+    <Compile Include="Drivers\ValidationMessageDriver.cs" />
+    <Compile Include="Drivers\ValidationSummaryDriver.cs" />
+    <Compile Include="Elements\ValidationMessage.cs" />
+    <Compile Include="Elements\ValidationSummary.cs" />
+    <Compile Include="Handlers\ClientValidationRegistrationCoordinator.cs" />
+    <Compile Include="Handlers\ValidatorsCoordinator.cs" />
+    <Compile Include="Handlers\FormSubmissionCoordinator.cs" />
+    <Compile Include="Helpers\FormControllerExtensions.cs" />
+    <Compile Include="Helpers\FieldValidatorsExtensions.cs" />
+    <Compile Include="Services\ElementValidator.cs" />
+    <Compile Include="Services\FormEventHandlerBase.cs" />
+    <Compile Include="Services\ITempDataAccessor.cs" />
+    <Compile Include="Services\IElementValidator.cs" />
+    <Compile Include="Services\Models\RegisterClientValidationAttributesEventContext.cs" />
+    <Compile Include="Validators\CheckBoxValidator.cs" />
+    <Compile Include="Validators\Settings\CheckBoxValidationSettings.cs" />
+    <Compile Include="Validators\Settings\TextFieldValidationSettings.cs" />
+    <Compile Include="Validators\Settings\ValidationSettingsBase.cs" />
+    <Compile Include="Services\Models\FormEventContext.cs" />
+    <Compile Include="Drivers\ValidationElementDriver.cs" />
+    <Compile Include="Drivers\BindingsElementDriver.cs" />
+    <Compile Include="Drivers\TaxonomyDriver.cs" />
+    <Compile Include="Drivers\HiddenFieldDriver.cs" />
+    <Compile Include="Drivers\CheckboxDriver.cs" />
+    <Compile Include="Drivers\TextAreaDriver.cs" />
+    <Compile Include="Drivers\RadioButtonDriver.cs" />
+    <Compile Include="Drivers\EnumerationDriver.cs" />
+    <Compile Include="Drivers\UserNameFieldDriver.cs" />
+    <Compile Include="Elements\LabeledFormElement.cs" />
+    <Compile Include="Elements\Taxonomy.cs" />
+    <Compile Include="Elements\HiddenField.cs" />
+    <Compile Include="Elements\Checkbox.cs" />
+    <Compile Include="Elements\RadioButton.cs" />
+    <Compile Include="Elements\TextArea.cs" />
+    <Compile Include="Elements\Enumeration.cs" />
+    <Compile Include="Elements\UserNameField.cs" />
+    <Compile Include="Forms\AutoLabelForm.cs" />
+    <Compile Include="Handlers\UserNameFieldHandler.cs" />
+    <Compile Include="Helpers\StreamExtensions.cs" />
+    <Compile Include="Helpers\DataTableExtensions.cs" />
+    <Compile Include="Helpers\TokenizerExtensions.cs" />
+    <Compile Include="ImportExport\FormsExportStep.cs" />
+    <Compile Include="ImportExport\FormsExportHandler.cs" />
+    <Compile Include="ImportExport\FormsImportHandler.cs" />
+    <Compile Include="Services\IFormEventHandler.cs" />
+    <Compile Include="Services\Models\FieldValidatorDescriptor.cs" />
+    <Compile Include="Services\Models\FormSubmittedEventContext.cs" />
+    <Compile Include="Services\Models\FormValidatedEventContext.cs" />
+    <Compile Include="Services\Models\FormValidatingEventContext.cs" />
+    <Compile Include="Services\Models\BindingDescriptor.cs" />
+    <Compile Include="Services\Models\ContentFieldBindingDescriptor.cs" />
+    <Compile Include="Services\Models\ContentPartBindingDescriptor.cs" />
+    <Compile Include="Services\Models\ValidateInputContext.cs" />
+    <Compile Include="Validators\TextFieldValidator.cs" />
+    <Compile Include="ViewModels\FieldValidationSettings.cs" />
+    <Compile Include="ViewModels\FormBindingSettings.cs" />
+    <Compile Include="Helpers\ContentTypeDefinitionExtensions.cs" />
+    <Compile Include="Services\BindingManager.cs" />
+    <Compile Include="Services\IBindingManager.cs" />
+    <Compile Include="Services\IBindingProvider.cs" />
+    <Compile Include="Services\Models\BindingDescribeContext.cs" />
+    <Compile Include="Services\Models\BindingContext.cs" />
+    <Compile Include="Bindings\TitlePartBindings.cs" />
+    <Compile Include="ViewModels\BindingSettings.cs" />
+    <Compile Include="ViewModels\FieldBindingSettings.cs" />
+    <Compile Include="ViewModels\PartBindingSettings.cs" />
+    <Compile Include="ViewModels\BlueprintsIndexViewModel.cs" />
+    <Compile Include="ViewModels\SubmissionViewModel.cs" />
+    <Compile Include="ViewModels\SubmissionsIndexViewModel.cs" />
+    <Compile Include="Helpers\SubmissionExtensions.cs" />
+    <Compile Include="ViewModels\FormsIndexViewModel.cs" />
+    <Compile Include="Drivers\CommonFormElementDriver.cs" />
+    <Compile Include="Drivers\FormDriver.cs" />
+    <Compile Include="Drivers\ButtonDriver.cs" />
+    <Compile Include="Drivers\IpAddressFieldDriver.cs" />
+    <Compile Include="Elements\IpAddressField.cs" />
+    <Compile Include="Handlers\IpAddressFieldHandler.cs" />
+    <Compile Include="AdminMenu.cs" />
+    <Compile Include="Migrations.cs" />
+    <Compile Include="Handlers\ReadFormValuesHandler.cs" />
+    <Compile Include="Services\FormElementEventHandlerBase.cs" />
+    <Compile Include="Helpers\NameValueCollectionExtensions.cs" />
+    <Compile Include="Models\Submission.cs" />
+    <Compile Include="Permissions.cs" />
+    <Compile Include="Services\FormService.cs" />
+    <Compile Include="Services\IFormElementEventHandler.cs" />
+    <Compile Include="Services\IFormService.cs" />
+    <Compile Include="Drivers\LabelDriver.cs" />
+    <Compile Include="Drivers\TextFieldDriver.cs" />
+    <Compile Include="Elements\FormCategoryProvider.cs" />
+    <Compile Include="Elements\FormElement.cs" />
+    <Compile Include="Elements\Form.cs" />
+    <Compile Include="Elements\Button.cs" />
+    <Compile Include="Elements\Label.cs" />
+    <Compile Include="Elements\TextField.cs" />
+    <Compile Include="Services\ReadElementValuesContext.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\SubmissionAdmin\Index.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-TextField.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Button.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Label.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-TextField.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-IpAddressField.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-IpAddressField.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Admin\Index.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\SubmissionAdmin\Details.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\EditorTemplates\FormBindings.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-UserNameField.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-UserNameField.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-HiddenField.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-HiddenField.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-TextArea.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-TextArea.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-RadioButton.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-RadioButton.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Checkbox.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Checkbox.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Enumeration-SelectList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Enumeration-MultiSelectList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Enumeration-RadioList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Enumeration-CheckList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Taxonomy-SelectList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Taxonomy-RadioList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Taxonomy-MultiSelectList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-Taxonomy-CheckList.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Activity-DynamicFormSubmitted.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\BlueprintAdmin\Index.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-ValidationSummary.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-ValidationSummary.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-ValidationMessage.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Element-Form-ValidationMessage.Design.cshtml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\FormElement.Wrapper.cshtml" />
+  </ItemGroup>
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets" Condition="'$(VSToolsPath)' != ''" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" Condition="false" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target> -->
+  <Target Name="AfterBuild" DependsOnTargets="AfterBuildCompiler">
+    <PropertyGroup>
+      <AreasManifestDir>$(ProjectDir)\..\Manifests</AreasManifestDir>
+    </PropertyGroup>
+    <!-- If this is an area child project, uncomment the following line:
+    <CreateAreaManifest AreaName="$(AssemblyName)" AreaType="Child" AreaPath="$(ProjectDir)" ManifestPath="$(AreasManifestDir)" ContentFiles="@(Content)" />
+    -->
+    <!-- If this is an area parent project, uncomment the following lines:
+    <CreateAreaManifest AreaName="$(AssemblyName)" AreaType="Parent" AreaPath="$(ProjectDir)" ManifestPath="$(AreasManifestDir)" ContentFiles="@(Content)" />
+    <CopyAreaManifests ManifestPath="$(AreasManifestDir)" CrossCopy="false" RenameViews="true" />
+    -->
+  </Target>
+  <Target Name="AfterBuildCompiler" Condition="'$(MvcBuildViews)'=='true'">
+    <AspNetCompiler VirtualPath="temp" PhysicalPath="$(ProjectDir)\..\$(ProjectName)" />
+  </Target>
+  <ProjectExtensions>
+    <VisualStudio>
+      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
+        <WebProjectProperties>
+          <UseIIS>False</UseIIS>
+          <AutoAssignPort>True</AutoAssignPort>
+          <DevelopmentServerPort>45979</DevelopmentServerPort>
+          <DevelopmentServerVPath>/</DevelopmentServerVPath>
+          <IISUrl>
+          </IISUrl>
+          <NTLMAuthentication>False</NTLMAuthentication>
+          <UseCustomServer>True</UseCustomServer>
+          <CustomServerUrl>http://orchard.codeplex.com</CustomServerUrl>
+          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
+        </WebProjectProperties>
+      </FlavorProperties>
+    </VisualStudio>
+  </ProjectExtensions>
+</Project>

src/Orchard.Web/Modules/Orchard.DynamicForms/Permissions.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+using Orchard.Environment.Extensions.Models;
+using Orchard.Security.Permissions;
+
+namespace Orchard.DynamicForms {
+    public class Permissions : IPermissionProvider {
+        private static readonly Permission SubmitAnyForm = new Permission { Description = "Submit any forms", Name = "Submit" };
+        private static readonly Permission SubmitForm = new Permission { Description = "Submit {0} forms", Name = "Submit_{0}", ImpliedBy = new[] { SubmitAnyForm } };
+        public static readonly Permission ManageForms = new Permission { Description = "Manage custom forms", Name = "ManageForms" };
+
+        public virtual Feature Feature { get; set; }
+
+        public IEnumerable<Permission> GetPermissions() {
+            yield return SubmitAnyForm;
+            yield return ManageForms;
+        }
+
+        public IEnumerable<PermissionStereotype> GetDefaultStereotypes() {
+            return new[] {
+                new PermissionStereotype {
+                    Name = "Administrator",
+                    Permissions = new[] { SubmitAnyForm, ManageForms }
+                },
+                new PermissionStereotype {
+                    Name = "Editor",
+                    Permissions = new[] { SubmitAnyForm }
+                },
+                new PermissionStereotype {
+                    Name = "Moderator",
+                    Permissions = new[] { SubmitAnyForm }
+                },
+                new PermissionStereotype {
+                    Name = "Author",
+                    Permissions = new[] { SubmitAnyForm }
+                },
+                new PermissionStereotype {
+                    Name = "Contributor",
+                    Permissions = new[] { SubmitAnyForm }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Generates a permission dynamically for a content type
+        /// </summary>
+        public static Permission CreateSubmitPermission(Form form) {
+            return new Permission {
+                Name = String.Format(SubmitForm.Name, form.Name),
+                Description = String.Format(SubmitForm.Description, form.Name),
+                Category = "Dynamic Forms",
+                ImpliedBy = new [] { SubmitForm }
+            };
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Properties/AssemblyInfo.cs

@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Orchard.DynamicForms")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyProduct("Orchard")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("13b1e976-66ef-432f-8e2d-11328c28ca52")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+

src/Orchard.Web/Modules/Orchard.DynamicForms/Scripts/Web.config

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+  <system.webServer>
+    <staticContent>
+      <clientCache cacheControlMode="UseMaxAge" cacheControlMaxAge="7.00:00:00" />
+    </staticContent>
+
+    <handlers accessPolicy="Script,Read">
+      <!--
+      iis7 - for any request to a file exists on disk, return it via native http module.
+      accessPolicy 'Script' is to allow for a managed 404 page.
+      -->
+      <add name="StaticFile" path="*" verb="*" modules="StaticFileModule" preCondition="integratedMode" resourceType="File" requireAccess="Read" />
+    </handlers>
+  </system.webServer>
+</configuration>

src/Orchard.Web/Modules/Orchard.DynamicForms/Scripts/jquery.validate.unobtrusive.additional.js

@@ -0,0 +1,3 @@
+(function ($) {
+    $.validator.unobtrusive.adapters.addBool("mandatory", "required");
+}(jQuery));

src/Orchard.Web/Modules/Orchard.DynamicForms/Scripts/jquery.validate.unobtrusive.js

@@ -0,0 +1,410 @@
+/* NUGET: BEGIN LICENSE TEXT
+ *
+ * Microsoft grants you the right to use these script files for the sole
+ * purpose of either: (i) interacting through your browser with the Microsoft
+ * website or online service, subject to the applicable licensing or use
+ * terms; or (ii) using the files as included with a Microsoft product subject
+ * to that product's license terms. Microsoft reserves all other rights to the
+ * files not expressly granted by Microsoft, whether by implication, estoppel
+ * or otherwise. Insofar as a script file is dual licensed under GPL,
+ * Microsoft neither took the code under GPL nor distributes it thereunder but
+ * under the terms set out in this paragraph. All notices and licenses
+ * below are for informational purposes only.
+ *
+ * NUGET: END LICENSE TEXT */
+/*!
+** Unobtrusive validation support library for jQuery and jQuery Validate
+** Copyright (C) Microsoft Corporation. All rights reserved.
+*/
+
+/*jslint white: true, browser: true, onevar: true, undef: true, nomen: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true, strict: false */
+/*global document: false, jQuery: false */
+
+(function ($) {
+    var $jQval = $.validator,
+        adapters,
+        data_validation = "unobtrusiveValidation";
+
+    function setValidationValues(options, ruleName, value) {
+        options.rules[ruleName] = value;
+        if (options.message) {
+            options.messages[ruleName] = options.message;
+        }
+    }
+
+    function splitAndTrim(value) {
+        return value.replace(/^\s+|\s+$/g, "").split(/\s*,\s*/g);
+    }
+
+    function escapeAttributeValue(value) {
+        // As mentioned on http://api.jquery.com/category/selectors/
+        return value.replace(/([!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~])/g, "\\$1");
+    }
+
+    function getModelPrefix(fieldName) {
+        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
+    }
+
+    function appendModelPrefix(value, prefix) {
+        if (value.indexOf("*.") === 0) {
+            value = value.replace("*.", prefix);
+        }
+        return value;
+    }
+
+    function onError(error, inputElement) {  // 'this' is the form element
+        var container = $(this).find("[data-valmsg-for='" + escapeAttributeValue(inputElement[0].name) + "']"),
+            replaceAttrValue = container.attr("data-valmsg-replace"),
+            replace = replaceAttrValue ? $.parseJSON(replaceAttrValue) !== false : null;
+
+        container.removeClass("field-validation-valid").addClass("field-validation-error");
+        error.data("unobtrusiveContainer", container);
+
+        if (replace) {
+            container.empty();
+            error.removeClass("input-validation-error").appendTo(container);
+        }
+        else {
+            error.hide();
+        }
+    }
+
+    function onErrors(event, validator) {  // 'this' is the form element
+        var container = $(this).find("[data-valmsg-summary=true]"),
+            list = container.find("ul");
+
+        if (list && list.length && validator.errorList.length) {
+            list.empty();
+            container.addClass("validation-summary-errors").removeClass("validation-summary-valid");
+
+            $.each(validator.errorList, function () {
+                $("<li />").html(this.message).appendTo(list);
+            });
+        }
+    }
+
+    function onSuccess(error) {  // 'this' is the form element
+        var container = error.data("unobtrusiveContainer"),
+            replaceAttrValue = container.attr("data-valmsg-replace"),
+            replace = replaceAttrValue ? $.parseJSON(replaceAttrValue) : null;
+
+        if (container) {
+            container.addClass("field-validation-valid").removeClass("field-validation-error");
+            error.removeData("unobtrusiveContainer");
+
+            if (replace) {
+                container.empty();
+            }
+        }
+    }
+
+    function onReset(event) {  // 'this' is the form element
+        var $form = $(this);
+        $form.data("validator").resetForm();
+        $form.find(".validation-summary-errors")
+            .addClass("validation-summary-valid")
+            .removeClass("validation-summary-errors");
+        $form.find(".field-validation-error")
+            .addClass("field-validation-valid")
+            .removeClass("field-validation-error")
+            .removeData("unobtrusiveContainer")
+            .find(">*")  // If we were using valmsg-replace, get the underlying error
+                .removeData("unobtrusiveContainer");
+    }
+
+    function validationInfo(form) {
+        var $form = $(form),
+            result = $form.data(data_validation),
+            onResetProxy = $.proxy(onReset, form),
+            defaultOptions = $jQval.unobtrusive.options || {},
+            execInContext = function (name, args) {
+                var func = defaultOptions[name];
+                func && $.isFunction(func) && func.apply(form, args);
+            }
+
+        if (!result) {
+            result = {
+                options: {  // options structure passed to jQuery Validate's validate() method
+                    errorClass: defaultOptions.errorClass || "input-validation-error",
+                    errorElement: defaultOptions.errorElement || "span",
+                    errorPlacement: function () {
+                        onError.apply(form, arguments);
+                        execInContext("errorPlacement", arguments);
+                    },
+                    invalidHandler: function () {
+                        onErrors.apply(form, arguments);
+                        execInContext("invalidHandler", arguments);
+                    },
+                    messages: {},
+                    rules: {},
+                    success: function () {
+                        onSuccess.apply(form, arguments);
+                        execInContext("success", arguments);
+                    }
+                },
+                attachValidation: function () {
+                    $form
+                        .off("reset." + data_validation, onResetProxy)
+                        .on("reset." + data_validation, onResetProxy)
+                        .validate(this.options);
+                },
+                validate: function () {  // a validation function that is called by unobtrusive Ajax
+                    $form.validate();
+                    return $form.valid();
+                }
+            };
+            $form.data(data_validation, result);
+        }
+
+        return result;
+    }
+
+    $jQval.unobtrusive = {
+        adapters: [],
+
+        parseElement: function (element, skipAttach) {
+            /// <summary>
+            /// Parses a single HTML element for unobtrusive validation attributes.
+            /// </summary>
+            /// <param name="element" domElement="true">The HTML element to be parsed.</param>
+            /// <param name="skipAttach" type="Boolean">[Optional] true to skip attaching the
+            /// validation to the form. If parsing just this single element, you should specify true.
+            /// If parsing several elements, you should specify false, and manually attach the validation
+            /// to the form when you are finished. The default is false.</param>
+            var $element = $(element),
+                form = $element.parents("form")[0],
+                valInfo, rules, messages;
+
+            if (!form) {  // Cannot do client-side validation without a form
+                return;
+            }
+
+            valInfo = validationInfo(form);
+            valInfo.options.rules[element.name] = rules = {};
+            valInfo.options.messages[element.name] = messages = {};
+
+            $.each(this.adapters, function () {
+                var prefix = "data-val-" + this.name,
+                    message = $element.attr(prefix),
+                    paramValues = {};
+
+                if (message !== undefined) {  // Compare against undefined, because an empty message is legal (and falsy)
+                    prefix += "-";
+
+                    $.each(this.params, function () {
+                        paramValues[this] = $element.attr(prefix + this);
+                    });
+
+                    this.adapt({
+                        element: element,
+                        form: form,
+                        message: message,
+                        params: paramValues,
+                        rules: rules,
+                        messages: messages
+                    });
+                }
+            });
+
+            $.extend(rules, { "__dummy__": true });
+
+            if (!skipAttach) {
+                valInfo.attachValidation();
+            }
+        },
+
+        parse: function (selector) {
+            /// <summary>
+            /// Parses all the HTML elements in the specified selector. It looks for input elements decorated
+            /// with the [data-val=true] attribute value and enables validation according to the data-val-*
+            /// attribute values.
+            /// </summary>
+            /// <param name="selector" type="String">Any valid jQuery selector.</param>
+
+            // $forms includes all forms in selector's DOM hierarchy (parent, children and self) that have at least one
+            // element with data-val=true
+            var $selector = $(selector),
+                $forms = $selector.parents()
+                                  .addBack()
+                                  .filter("form")
+                                  .add($selector.find("form"))
+                                  .has("[data-val=true]");
+
+            $selector.find("[data-val=true]").each(function () {
+                $jQval.unobtrusive.parseElement(this, true);
+            });
+
+            $forms.each(function () {
+                var info = validationInfo(this);
+                if (info) {
+                    info.attachValidation();
+                }
+            });
+        }
+    };
+
+    adapters = $jQval.unobtrusive.adapters;
+
+    adapters.add = function (adapterName, params, fn) {
+        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation.</summary>
+        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
+        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
+        /// <param name="params" type="Array" optional="true">[Optional] An array of parameter names (strings) that will
+        /// be extracted from the data-val-nnnn-mmmm HTML attributes (where nnnn is the adapter name, and
+        /// mmmm is the parameter name).</param>
+        /// <param name="fn" type="Function">The function to call, which adapts the values from the HTML
+        /// attributes into jQuery Validate rules and/or messages.</param>
+        /// <returns type="jQuery.validator.unobtrusive.adapters" />
+        if (!fn) {  // Called with no params, just a function
+            fn = params;
+            params = [];
+        }
+        this.push({ name: adapterName, params: params, adapt: fn });
+        return this;
+    };
+
+    adapters.addBool = function (adapterName, ruleName) {
+        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
+        /// the jQuery Validate validation rule has no parameter values.</summary>
+        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
+        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
+        /// <param name="ruleName" type="String" optional="true">[Optional] The name of the jQuery Validate rule. If not provided, the value
+        /// of adapterName will be used instead.</param>
+        /// <returns type="jQuery.validator.unobtrusive.adapters" />
+        return this.add(adapterName, function (options) {
+            setValidationValues(options, ruleName || adapterName, true);
+        });
+    };
+
+    adapters.addMinMax = function (adapterName, minRuleName, maxRuleName, minMaxRuleName, minAttribute, maxAttribute) {
+        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
+        /// the jQuery Validate validation has three potential rules (one for min-only, one for max-only, and
+        /// one for min-and-max). The HTML parameters are expected to be named -min and -max.</summary>
+        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
+        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
+        /// <param name="minRuleName" type="String">The name of the jQuery Validate rule to be used when you only
+        /// have a minimum value.</param>
+        /// <param name="maxRuleName" type="String">The name of the jQuery Validate rule to be used when you only
+        /// have a maximum value.</param>
+        /// <param name="minMaxRuleName" type="String">The name of the jQuery Validate rule to be used when you
+        /// have both a minimum and maximum value.</param>
+        /// <param name="minAttribute" type="String" optional="true">[Optional] The name of the HTML attribute that
+        /// contains the minimum value. The default is "min".</param>
+        /// <param name="maxAttribute" type="String" optional="true">[Optional] The name of the HTML attribute that
+        /// contains the maximum value. The default is "max".</param>
+        /// <returns type="jQuery.validator.unobtrusive.adapters" />
+        return this.add(adapterName, [minAttribute || "min", maxAttribute || "max"], function (options) {
+            var min = options.params.min,
+                max = options.params.max;
+
+            if (min && max) {
+                setValidationValues(options, minMaxRuleName, [min, max]);
+            }
+            else if (min) {
+                setValidationValues(options, minRuleName, min);
+            }
+            else if (max) {
+                setValidationValues(options, maxRuleName, max);
+            }
+        });
+    };
+
+    adapters.addSingleVal = function (adapterName, attribute, ruleName) {
+        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
+        /// the jQuery Validate validation rule has a single value.</summary>
+        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
+        /// in the data-val-nnnn HTML attribute(where nnnn is the adapter name).</param>
+        /// <param name="attribute" type="String">[Optional] The name of the HTML attribute that contains the value.
+        /// The default is "val".</param>
+        /// <param name="ruleName" type="String" optional="true">[Optional] The name of the jQuery Validate rule. If not provided, the value
+        /// of adapterName will be used instead.</param>
+        /// <returns type="jQuery.validator.unobtrusive.adapters" />
+        return this.add(adapterName, [attribute || "val"], function (options) {
+            setValidationValues(options, ruleName || adapterName, options.params[attribute]);
+        });
+    };
+
+    $jQval.addMethod("__dummy__", function (value, element, params) {
+        return true;
+    });
+
+    $jQval.addMethod("regex", function (value, element, params) {
+        var match;
+        if (this.optional(element)) {
+            return true;
+        }
+
+        match = new RegExp(params).exec(value);
+        return (match && (match.index === 0) && (match[0].length === value.length));
+    });
+
+    $jQval.addMethod("nonalphamin", function (value, element, nonalphamin) {
+        var match;
+        if (nonalphamin) {
+            match = value.match(/\W/g);
+            match = match && match.length >= nonalphamin;
+        }
+        return match;
+    });
+
+    if ($jQval.methods.extension) {
+        adapters.addSingleVal("accept", "mimtype");
+        adapters.addSingleVal("extension", "extension");
+    } else {
+        // for backward compatibility, when the 'extension' validation method does not exist, such as with versions
+        // of JQuery Validation plugin prior to 1.10, we should use the 'accept' method for
+        // validating the extension, and ignore mime-type validations as they are not supported.
+        adapters.addSingleVal("extension", "extension", "accept");
+    }
+
+    adapters.addSingleVal("regex", "pattern");
+    adapters.addBool("creditcard").addBool("date").addBool("digits").addBool("email").addBool("number").addBool("url");
+    adapters.addMinMax("length", "minlength", "maxlength", "rangelength").addMinMax("range", "min", "max", "range");
+    adapters.addMinMax("minlength", "minlength").addMinMax("maxlength", "minlength", "maxlength");
+    adapters.add("equalto", ["other"], function (options) {
+        var prefix = getModelPrefix(options.element.name),
+            other = options.params.other,
+            fullOtherName = appendModelPrefix(other, prefix),
+            element = $(options.form).find(":input").filter("[name='" + escapeAttributeValue(fullOtherName) + "']")[0];
+
+        setValidationValues(options, "equalTo", element);
+    });
+    adapters.add("required", function (options) {
+        // jQuery Validate equates "required" with "mandatory" for checkbox elements
+        if (options.element.tagName.toUpperCase() !== "INPUT" || options.element.type.toUpperCase() !== "CHECKBOX") {
+            setValidationValues(options, "required", true);
+        }
+    });
+    adapters.add("remote", ["url", "type", "additionalfields"], function (options) {
+        var value = {
+            url: options.params.url,
+            type: options.params.type || "GET",
+            data: {}
+        },
+            prefix = getModelPrefix(options.element.name);
+
+        $.each(splitAndTrim(options.params.additionalfields || options.element.name), function (i, fieldName) {
+            var paramName = appendModelPrefix(fieldName, prefix);
+            value.data[paramName] = function () {
+                return $(options.form).find(":input").filter("[name='" + escapeAttributeValue(paramName) + "']").val();
+            };
+        });
+
+        setValidationValues(options, "remote", value);
+    });
+    adapters.add("password", ["min", "nonalphamin", "regex"], function (options) {
+        if (options.params.min) {
+            setValidationValues(options, "minlength", options.params.min);
+        }
+        if (options.params.nonalphamin) {
+            setValidationValues(options, "nonalphamin", options.params.nonalphamin);
+        }
+        if (options.params.regex) {
+            setValidationValues(options, "regex", options.params.regex);
+        }
+    });
+
+    $(function () {
+        $jQval.unobtrusive.parse(document);
+    });
+}(jQuery));

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/BindingManager.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Linq;
+using Orchard.ContentManagement.MetaData.Models;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public class BindingManager : IBindingManager {
+        private readonly IEnumerable<IBindingProvider> _providers;
+        public BindingManager(IEnumerable<IBindingProvider> providers) {
+            _providers = providers;
+        }
+
+        public IEnumerable<BindingContext> DescribeBindingContexts() {
+            foreach (var provider in _providers) {
+                var context = new BindingDescribeContext();
+                provider.Describe(context);
+
+                foreach (var description in context.Describe()) {
+                    yield return description;
+                }
+            }
+        }
+
+        public IEnumerable<ContentPartBindingDescriptor> DescribeBindingsFor(ContentTypeDefinition contentTypeDefinition) {
+            var contexts = DescribeBindingContexts().ToLookup(x => x.ContextName);
+
+            foreach (var part in contentTypeDefinition.Parts) {
+                var partName = part.PartDefinition.Name;
+                var partBinding = new ContentPartBindingDescriptor() {
+                    Part = part,
+                    BindingContexts = contexts[partName].ToList()
+                };
+
+                foreach (var field in part.PartDefinition.Fields) {
+                    var fieldName = field.FieldDefinition.Name;
+                    var fieldBinding = new ContentFieldBindingDescriptor {
+                        Field = field,
+                        BindingContexts = contexts[fieldName].ToList()
+                    };
+
+                    partBinding.FieldBindings.Add(fieldBinding);
+                }
+
+                yield return partBinding;
+            }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/ElementValidator.cs

@@ -0,0 +1,18 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public abstract class ElementValidator<TElement> : Component, IElementValidator where TElement : FormElement {
+        public void Validate(ValidateInputContext context) {
+            OnValidate((TElement) context.Element, context);
+        }
+
+        public void RegisterClientValidation(RegisterClientValidationAttributesEventContext context) {
+            OnRegisterClientValidation((TElement)context.Element, context);
+        }
+
+        protected virtual void OnValidate(TElement element, ValidateInputContext context) {}
+
+        protected virtual void OnRegisterClientValidation(TElement element, RegisterClientValidationAttributesEventContext context) {}
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/FormElementEventHandlerBase.cs

@@ -0,0 +1,9 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public abstract class FormElementEventHandlerBase : IFormElementEventHandler {
+        public virtual void GetElementValue(FormElement element, ReadElementValuesContext context) {}
+        public virtual void RegisterClientValidation(RegisterClientValidationAttributesEventContext context) {}
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/FormEventHandlerBase.cs

@@ -0,0 +1,9 @@
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public abstract class FormEventHandlerBase : Component, IFormEventHandler {
+        public virtual void Submitted(FormSubmittedEventContext context) {}
+        public virtual void Validating(FormValidatingEventContext context) {}
+        public virtual void Validated(FormValidatedEventContext context) {}
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/FormService.cs

@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Data;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.Collections;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.MetaData;
+using Orchard.Core.Contents.Settings;
+using Orchard.Data;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Handlers;
+using Orchard.DynamicForms.Helpers;
+using Orchard.DynamicForms.Models;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.DynamicForms.ViewModels;
+using Orchard.Layouts.Framework.Serialization;
+using Orchard.Layouts.Helpers;
+using Orchard.Layouts.Models;
+using Orchard.Layouts.Services;
+using Orchard.Mvc;
+using Orchard.Services;
+
+namespace Orchard.DynamicForms.Services {
+    public class FormService : IFormService {
+        private readonly ILayoutSerializer _serializer;
+        private readonly IClock _clock;
+        private readonly IRepository<Submission> _submissionRepository;
+        private readonly IFormElementEventHandler _elementHandlers;
+        private readonly IContentManager _contentManager;
+        private readonly IContentDefinitionManager _contentDefinitionManager;
+        private readonly IBindingManager _bindingManager;
+        private readonly IHttpContextAccessor _httpContextAccessor;
+        private readonly IFormEventHandler _formEventHandler;
+        private readonly Lazy<IEnumerable<IElementValidator>> _validators;
+
+        public FormService(
+            ILayoutSerializer serializer, 
+            IClock clock, 
+            IRepository<Submission> submissionRepository, 
+            IFormElementEventHandler elementHandlers, 
+            IContentManager contentManager, 
+            IContentDefinitionManager contentDefinitionManager, 
+            IBindingManager bindingManager, 
+            IHttpContextAccessor httpContextAccessor,
+            IFormEventHandler formEventHandler, 
+            Lazy<IEnumerable<IElementValidator>> validators) {
+
+            _serializer = serializer;
+            _clock = clock;
+            _submissionRepository = submissionRepository;
+            _elementHandlers = elementHandlers;
+            _contentManager = contentManager;
+            _contentDefinitionManager = contentDefinitionManager;
+            _bindingManager = bindingManager;
+            _httpContextAccessor = httpContextAccessor;
+            _formEventHandler = formEventHandler;
+            _validators = validators;
+        }
+
+        public Form FindForm(LayoutPart layoutPart, string formName = null) {
+            var elements = _serializer.Deserialize(layoutPart.LayoutState, new DescribeElementsContext { Content = layoutPart });
+            var forms = elements.Flatten().Where(x => x is Form).Cast<Form>();
+            return String.IsNullOrWhiteSpace(formName) ? forms.FirstOrDefault() : forms.FirstOrDefault(x => x.Name == formName);
+        }
+
+        public IEnumerable<FormElement> GetFormElements(Form form) {
+            return form.Elements.Flatten().Where(x => x is FormElement).Cast<FormElement>();
+        }
+
+        public IEnumerable<string> GetFormElementNames(Form form) {
+            return GetFormElements(form).Select(x => x.Name).Where(x => !String.IsNullOrWhiteSpace(x)).Distinct();
+        }
+
+        public NameValueCollection SubmitForm(Form form, IValueProvider valueProvider, ModelStateDictionary modelState) {
+            var values = ReadElementValues(form, valueProvider);
+
+            _formEventHandler.Submitted(new FormSubmittedEventContext {
+                Form = form,
+                FormService = this,
+                ValueProvider = valueProvider,
+                Values = values
+            });
+
+            _formEventHandler.Validating(new FormValidatingEventContext {
+                Form = form,
+                FormService = this,
+                Values = values,
+                ModelState = modelState,
+                ValueProvider = valueProvider
+            });
+
+            _formEventHandler.Validated(new FormValidatedEventContext {
+                Form = form,
+                FormService = this,
+                Values = values,
+                ModelState = modelState,
+                ValueProvider = valueProvider
+            });
+
+            return values;
+        }
+
+        public Submission CreateSubmission(string formName, NameValueCollection values) {
+            var submission = new Submission {
+                FormName = formName,
+                CreatedUtc = _clock.UtcNow,
+                FormData = values.ToQueryString()
+            };
+
+            CreateSubmission(submission);
+            return submission;
+        }
+
+        public Submission CreateSubmission(Submission submission) {
+            _submissionRepository.Create(submission);
+            return submission;
+        }
+
+        public Submission GetSubmission(int id) {
+            return _submissionRepository.Get(id);
+        }
+
+        public IPageOfItems<Submission> GetSubmissions(string formName = null, int? skip = null, int? take = null) {
+            var query = _submissionRepository.Table;
+
+            if (!String.IsNullOrWhiteSpace(formName))
+                query = query.Where(x => x.FormName == formName);
+
+            query = new Orderable<Submission>(query).Desc(x => x.CreatedUtc).Queryable;
+
+            var totalItemCount = query.Count();
+            if (skip != null && take.GetValueOrDefault() > 0)
+                query = query.Skip(skip.Value).Take(take.GetValueOrDefault());
+
+            return new PageOfItems<Submission>(query) {
+                PageNumber = skip.GetValueOrDefault() * take.GetValueOrDefault(),
+                PageSize = take ?? Int32.MaxValue,
+                TotalItemCount = totalItemCount
+            };
+        }
+
+        public void DeleteSubmission(Submission submission) {
+            _submissionRepository.Delete(submission);
+        }
+
+        public int DeleteSubmissions(IEnumerable<int> submissionIds) {
+            var submissions = _submissionRepository.Table.Where(x => submissionIds.Contains(x.Id)).ToArray();
+
+            foreach (var submission in submissions) {
+                DeleteSubmission(submission);
+            }
+
+            return submissions.Length;
+        }
+
+        public void ReadElementValues(FormElement element, ReadElementValuesContext context) {
+            _elementHandlers.GetElementValue(element, context);
+        }
+
+        public NameValueCollection ReadElementValues(Form form, IValueProvider valueProvider) {
+            var formElements = GetFormElements(form);
+            var values = new NameValueCollection();
+
+            // Let each element provide its values.
+            foreach (var element in formElements) {
+                var context = new ReadElementValuesContext { ValueProvider = valueProvider };
+                ReadElementValues(element, context);
+
+                foreach (var key in from string key in context.Output where !String.IsNullOrWhiteSpace(key) && values[key] == null select key) {
+                    values.Add(key, context.Output[key]);
+                }
+            }
+
+            // Collect any remaining form values not handled by any specific element.
+            var requestForm = _httpContextAccessor.Current().Request.Form;
+            var blackList = new[] {"__RequestVerificationToken", "formName", "contentId"};
+            foreach (var key in 
+                from string key in requestForm 
+                where !String.IsNullOrWhiteSpace(key) && !blackList.Contains(key) && values[key] == null 
+                select key) {
+
+                values.Add(key, requestForm[key]);
+            }
+
+            return values;
+        }
+
+        public DataTable GenerateDataTable(IEnumerable<Submission> submissions) {
+            var records = submissions.Select(x => Tuple.Create(x, x.ToNameValues())).ToArray();
+            var columnNames = new HashSet<string>();
+            var dataTable = new DataTable();
+
+            foreach (var key in 
+                from record in records 
+                from string key in record.Item2 where !columnNames.Contains(key) 
+                where !String.IsNullOrWhiteSpace(key)
+                select key) {
+                columnNames.Add(key);
+            }
+
+            dataTable.Columns.Add("Id");
+            dataTable.Columns.Add("CreatedUtc", typeof (DateTime));
+            foreach (var columnName in columnNames) {
+                dataTable.Columns.Add(columnName);
+            }
+
+            foreach (var record in records) {
+                var dataRow = dataTable.NewRow();
+
+                dataRow["Id"] = record.Item1.Id;
+                dataRow["CreatedUtc"] = record.Item1.CreatedUtc;
+                foreach (var columnName in columnNames) {
+                    var value = record.Item2[columnName];
+                    dataRow[columnName] = value;
+                }
+
+                dataTable.Rows.Add(dataRow);
+            }
+
+            return dataTable;
+        }
+
+        public ContentItem CreateContentItem(Form form, IValueProvider valueProvider) {
+            var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(form.ContentType);
+
+            if (contentTypeDefinition == null)
+                return null;
+
+            var contentItem = _contentManager.Create(contentTypeDefinition.Name, VersionOptions.Draft);
+            var lookup = _bindingManager.DescribeBindingsFor(contentTypeDefinition);
+            var formElements = GetFormElements(form);
+
+            foreach (var element in formElements) {
+                var context = new ReadElementValuesContext { ValueProvider = valueProvider };
+                ReadElementValues(element, context);
+
+                var value = context.Output[element.Name];
+                var bindingSettings = element.State.GetModel<FormBindingSettings>(null);
+
+                if (bindingSettings != null) {
+                    foreach (var partBindingSettings in bindingSettings.Parts) {
+                        InvokePartBindings(contentItem, lookup, partBindingSettings, value);
+
+                        foreach (var fieldBindingSettings in partBindingSettings.Fields) {
+                            InvokeFieldBindings(contentItem, lookup, partBindingSettings, fieldBindingSettings, value);
+                        }
+                    }
+                }
+            }
+
+            var contentTypeSettings = contentTypeDefinition.Settings.GetModel<ContentTypeSettings>();
+            if (form.Publication == "Publish" || !contentTypeSettings.Draftable)
+                _contentManager.Publish(contentItem);
+            return contentItem;
+        }
+
+        public IEnumerable<IElementValidator> GetValidators<TElement>() where TElement : FormElement {
+            return GetValidators(typeof(TElement));
+        }
+
+        public IEnumerable<IElementValidator> GetValidators(FormElement element) {
+            return GetValidators(element.GetType());
+        }
+
+        public IEnumerable<IElementValidator> GetValidators(Type elementType) {
+            return _validators.Value.Where(x => IsFormElementType(x, elementType)).ToArray();
+        }
+
+        public IEnumerable<IElementValidator> GetValidators() {
+            return _validators.Value.ToArray();
+        }
+
+        public void RegisterClientValidationAttributes(RegisterClientValidationAttributesEventContext context) {
+            _elementHandlers.RegisterClientValidation(context);
+        }
+
+        private static void InvokePartBindings(
+            ContentItem contentItem, 
+            IEnumerable<ContentPartBindingDescriptor> lookup, 
+            PartBindingSettings partBindingSettings,
+            string value) {
+
+            var part = contentItem.Parts.FirstOrDefault(x => x.PartDefinition.Name == partBindingSettings.Name);
+            if (part == null)
+                return;
+
+            var partBindingDescriptors = lookup.Where(x => x.Part.PartDefinition.Name == partBindingSettings.Name);
+            var partBindingsQuery =
+                from descriptor in partBindingDescriptors
+                from bindingContext in descriptor.BindingContexts
+                where bindingContext.ContextName == part.PartDefinition.Name
+                from binding in bindingContext.Bindings
+                select binding;
+            var partBindings = partBindingsQuery.ToArray();
+
+            foreach (var binding in partBindingSettings.Bindings.Where(x => x.Enabled)) {
+                var localBinding = binding;
+                foreach (var partBinding in partBindings.Where(x => x.Name == localBinding.Name)) {
+                    partBinding.Setter.DynamicInvoke(part, value);
+                }
+            }
+        }
+
+        private static void InvokeFieldBindings(
+            ContentItem contentItem,
+            IEnumerable<ContentPartBindingDescriptor> lookup,
+            PartBindingSettings partBindingSettings,
+            FieldBindingSettings fieldBindingSettings,
+            string value) {
+
+            var part = contentItem.Parts.FirstOrDefault(x => x.PartDefinition.Name == partBindingSettings.Name);
+            if (part == null)
+                return;
+
+            var field = part.Fields.FirstOrDefault(x => x.Name == fieldBindingSettings.Name);
+            if (field == null)
+                return;
+
+            var fieldBindingDescriptorsQuery = 
+                from partBindingDescriptor in lookup
+                where partBindingDescriptor.Part.PartDefinition.Name == partBindingSettings.Name
+                from fieldBindingDescriptor in partBindingDescriptor.FieldBindings
+                where fieldBindingDescriptor.Field.Name == fieldBindingSettings.Name
+                select fieldBindingDescriptor;
+            var fieldBindingDescriptors = fieldBindingDescriptorsQuery.ToArray();
+            var fieldBindingsQuery =
+                from descriptor in fieldBindingDescriptors
+                from bindingContext in descriptor.BindingContexts
+                where bindingContext.ContextName == field.FieldDefinition.Name
+                from binding in bindingContext.Bindings
+                select binding;
+            var fieldBindings = fieldBindingsQuery.ToArray();
+
+            foreach (var binding in fieldBindingSettings.Bindings.Where(x => x.Enabled)) {
+                var localBinding = binding;
+                foreach (var fieldBinding in fieldBindings.Where(x => x.Name == localBinding.Name)) {
+                    fieldBinding.Setter.DynamicInvoke(field, value);
+                }
+            }
+        }
+
+        private static bool IsFormElementType(IElementValidator validator, Type elementType) {
+            var validatorType = validator.GetType();
+            var validatorElementType = validatorType.BaseType.GenericTypeArguments[0];
+            return validatorElementType == elementType || validatorElementType.IsAssignableFrom(elementType);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IBindingManager.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using Orchard.ContentManagement.MetaData.Models;
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IBindingManager : IDependency {
+        IEnumerable<BindingContext> DescribeBindingContexts();
+        IEnumerable<ContentPartBindingDescriptor> DescribeBindingsFor(ContentTypeDefinition contentTypeDefinition);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IBindingProvider.cs

@@ -0,0 +1,8 @@
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Events;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IBindingProvider : IEventHandler {
+        void Describe(BindingDescribeContext context);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IElementValidator.cs

@@ -0,0 +1,8 @@
+using Orchard.DynamicForms.Services.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IElementValidator : IDependency {
+        void Validate(ValidateInputContext context);
+        void RegisterClientValidation(RegisterClientValidationAttributesEventContext context);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IFormElementEventHandler.cs

@@ -0,0 +1,10 @@
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Events;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IFormElementEventHandler : IEventHandler{
+        void GetElementValue(FormElement element, ReadElementValuesContext context);
+        void RegisterClientValidation(RegisterClientValidationAttributesEventContext context);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IFormEventHandler.cs

@@ -0,0 +1,10 @@
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Events;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IFormEventHandler : IEventHandler {
+        void Submitted(FormSubmittedEventContext context);
+        void Validating(FormValidatingEventContext context);
+        void Validated(FormValidatedEventContext context);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/IFormService.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Data;
+using System.Web.Mvc;
+using Orchard.Collections;
+using Orchard.ContentManagement;
+using Orchard.DynamicForms.Elements;
+using Orchard.DynamicForms.Models;
+using Orchard.DynamicForms.Services.Models;
+using Orchard.Layouts.Models;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IFormService : IDependency {
+        Form FindForm(LayoutPart layoutPart, string formName = null);
+        IEnumerable<FormElement> GetFormElements(Form form);
+        IEnumerable<string> GetFormElementNames(Form form);
+        NameValueCollection SubmitForm(Form form, IValueProvider valueProvider, ModelStateDictionary modelState);
+        Submission CreateSubmission(string formName, NameValueCollection values);
+        Submission CreateSubmission(Submission submission);
+        Submission GetSubmission(int id);
+        IPageOfItems<Submission> GetSubmissions(string formName = null, int? skip = null, int? take = null);
+        void DeleteSubmission(Submission submission);
+        int DeleteSubmissions(IEnumerable<int> submissionIds);
+        void ReadElementValues(FormElement element, ReadElementValuesContext context);
+        NameValueCollection ReadElementValues(Form form, IValueProvider valueProvider);
+        DataTable GenerateDataTable(IEnumerable<Submission> submissions);
+        ContentItem CreateContentItem(Form form, IValueProvider valueProvider);
+        IEnumerable<IElementValidator> GetValidators<TElement>() where TElement : FormElement;
+        IEnumerable<IElementValidator> GetValidators(FormElement element);
+        IEnumerable<IElementValidator> GetValidators(Type elementType);
+        IEnumerable<IElementValidator> GetValidators();
+        void RegisterClientValidationAttributes(RegisterClientValidationAttributesEventContext context);
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/ITempDataAccessor.cs

@@ -0,0 +1,8 @@
+using System.Web.Mvc;
+
+namespace Orchard.DynamicForms.Services {
+    public interface IController {
+        TempDataDictionary TempData { get; }
+        ModelStateDictionary ModelState { get; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/BindingContext.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public abstract class BindingContext {
+        protected readonly IList<BindingDescriptor> _bindings = new List<BindingDescriptor>();
+
+        protected BindingContext(string contextName) {
+            ContextName = contextName;
+        }
+
+        public string ContextName { get; set; }
+        public IEnumerable<BindingDescriptor> Bindings {
+            get { return _bindings; }
+        }
+    }
+
+    public class BindingContext<T> : BindingContext {
+
+        public BindingContext() : base(typeof(T).Name) {
+        }
+
+        public BindingContext<T> Binding(string name, Action<T, string> setter) {
+
+            _bindings.Add(new BindingDescriptor<T> {
+                Name = name,
+                Setter = setter
+            });
+
+            return this;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/BindingDescribeContext.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class BindingDescribeContext {
+        private readonly IDictionary<string, BindingContext> _describes = new Dictionary<string, BindingContext>();
+
+        public IEnumerable<BindingContext> Describe() {
+            return _describes.Values;
+        }
+
+        public BindingContext<T> For<T>() {
+            BindingContext bindingContext;
+            var key = typeof (T).Name;
+            if (!_describes.TryGetValue(key, out bindingContext)) {
+                bindingContext = new BindingContext<T>();
+                _describes[key] = bindingContext;
+            }
+            return (BindingContext<T>)bindingContext;
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/BindingDescriptor.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public abstract class BindingDescriptor {
+        public string Name { get; set; }
+        public Delegate Setter { get; set; }
+    }
+
+    public class BindingDescriptor<T> : BindingDescriptor {
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/ContentFieldBindingDescriptor.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using Orchard.ContentManagement.MetaData.Models;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class ContentFieldBindingDescriptor {
+        public ContentFieldBindingDescriptor() {
+            BindingContexts = new List<BindingContext>();
+        }
+        public ContentPartFieldDefinition Field { get; set; }
+        public IList<BindingContext> BindingContexts { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/ContentPartBindingDescriptor.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Orchard.ContentManagement.MetaData.Models;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class ContentPartBindingDescriptor {
+        public ContentPartBindingDescriptor() {
+            BindingContexts = new List<BindingContext>();
+            FieldBindings = new List<ContentFieldBindingDescriptor>();
+        }
+        public ContentTypePartDefinition Part { get; set; }
+        public IList<BindingContext> BindingContexts { get; set; }
+        public IList<ContentFieldBindingDescriptor> FieldBindings { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/FieldValidatorDescriptor.cs

@@ -0,0 +1,7 @@
+namespace Orchard.DynamicForms.Services.Models {
+    public class FieldValidatorSetting {
+        public string Name { get; set; }
+        public bool Enabled { get; set; }
+        public string CustomValidationMessage { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/FormEventContext.cs

@@ -0,0 +1,12 @@
+using System.Collections.Specialized;
+using System.Web.Mvc;
+using Orchard.DynamicForms.Elements;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class FormEventContext {
+        public Form Form { get; set; }
+        public NameValueCollection Values { get; set; }
+        public IFormService FormService { get; set; }
+        public IValueProvider ValueProvider { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/FormSubmittedEventContext.cs

@@ -0,0 +1,4 @@
+namespace Orchard.DynamicForms.Services.Models {
+    public class FormSubmittedEventContext : FormEventContext {
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/FormValidatedEventContext.cs

@@ -0,0 +1,7 @@
+using System.Web.Mvc;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class FormValidatedEventContext : FormEventContext {
+        public ModelStateDictionary ModelState { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/FormValidatingEventContext.cs

@@ -0,0 +1,7 @@
+using System.Web.Mvc;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class FormValidatingEventContext : FormEventContext {
+        public ModelStateDictionary ModelState { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/RegisterClientValidationAttributesEventContext.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using Orchard.DynamicForms.Elements;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class RegisterClientValidationAttributesEventContext {
+        public RegisterClientValidationAttributesEventContext() {
+            ClientAttributes = new Dictionary<string, string>();
+        }
+        public IDictionary<string, string> ClientAttributes { get; set; }
+        public FormElement Element { get; set; }
+
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/Models/ValidateInputContext.cs

@@ -0,0 +1,11 @@
+using System.Web.Mvc;
+using Orchard.DynamicForms.Elements;
+
+namespace Orchard.DynamicForms.Services.Models {
+    public class ValidateInputContext {
+        public FormElement Element { get; set; }
+        public ModelStateDictionary ModelState { get; set; }
+        public string FieldName { get; set; }
+        public string AttemptedValue { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Services/ReadElementValuesContext.cs

@@ -0,0 +1,12 @@
+using System.Collections.Specialized;
+using System.Web.Mvc;
+
+namespace Orchard.DynamicForms.Services {
+    public class ReadElementValuesContext {
+        public ReadElementValuesContext() {
+            Output = new NameValueCollection();
+        }
+        public IValueProvider ValueProvider { get; set; }
+        public NameValueCollection Output { get; set; }
+    }
+}

src/Orchard.Web/Modules/Orchard.DynamicForms/Styles/Web.config

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+  <system.webServer>
+    <staticContent>
+      <clientCache cacheControlMode="UseMaxAge" cacheControlMaxAge="7.00:00:00" />
+    </staticContent>
+
+    <handlers accessPolicy="Script,Read">
+      <!--
+      iis7 - for any request to a file exists on disk, return it via native http module.
+      accessPolicy 'Script' is to allow for a managed 404 page.
+      -->
+      <add name="StaticFile" path="*" verb="*" modules="StaticFileModule" preCondition="integratedMode" resourceType="File" requireAccess="Read" />
+    </handlers>
+  </system.webServer>
+</configuration>