internal static FormTreeCompiler Build(string formPath, IFormChannelIdentifier channel, Dictionary <string, object> bindings, bool debugMode) { string folderPath = Path.GetDirectoryName(formPath).ToLowerInvariant(); string fileName = Path.GetFileName(formPath).ToLowerInvariant(); List <IFormDefinitionFile> formFiles = (from file in DataFacade.GetData <IFormDefinitionFile>() where file.FolderPath.ToLowerInvariant() == folderPath && file.FileName.ToLowerInvariant() == fileName select file).ToList(); if (formFiles.Count == 0) { throw new ArgumentException(string.Format("No form definition with path '{0}' was found. Please use a virtual Form Path", formPath), "formPath"); } if (formFiles.Count > 1) { throw new ArgumentException(string.Format("Multiple form definitions with path '{0}' was found", formPath), "formPath"); } FormTreeCompiler compiler = new FormTreeCompiler(); using (XmlTextReader formMarkupReader = new XmlTextReader(formFiles[0].GetReadStream())) { compiler.Compile(formMarkupReader, channel, bindings, debugMode); return(compiler); } }
private void ShowServerValidationErrors(FormTreeCompiler formTreeCompiler, Dictionary <string, Exception> serverValidationErrors) { foreach (var serverValidationError in serverValidationErrors) { string controlId = formTreeCompiler.GetBindingToClientIDMapping()[serverValidationError.Key]; string message = StringResourceSystemFacade.ParseString(serverValidationError.Value.Message); plhErrors.Controls.Add(new FieldMessage(controlId, message)); } }
/// <exclude /> public static FormTreeCompiler BuildWidgetForParameters(IEnumerable <ParameterProfile> parameterProfiles, Dictionary <string, object> bindings, string uniqueName, string panelLabel, IFormChannelIdentifier channelIdentifier) { XNamespace stdControlLibSpace = Namespaces.BindingFormsStdUiControls10; var bindingsDeclaration = new XElement(Namespaces.BindingForms10 + "bindings"); var widgetPlaceholder = new XElement(stdControlLibSpace + "FieldGroup", new XAttribute("Label", panelLabel)); var bindingsValidationRules = new Dictionary <string, List <ClientValidationRule> >(); foreach (ParameterProfile parameterProfile in parameterProfiles.Where(f => f.WidgetFunction != null)) { IWidgetFunction widgetFunction = parameterProfile.WidgetFunction; Type bindingType = widgetFunction != null && parameterProfile.Type.IsLazyGenericType() ? widgetFunction.ReturnType : parameterProfile.Type; bindingsDeclaration.Add( new XElement(Namespaces.BindingForms10 + "binding", new XAttribute("optional", true), new XAttribute("name", parameterProfile.Name), new XAttribute("type", bindingType.AssemblyQualifiedName))); var context = new FunctionContextContainer(); XElement uiMarkup = FunctionFacade.GetWidgetMarkup(widgetFunction, parameterProfile.Type, parameterProfile.WidgetFunctionParameters, parameterProfile.Label, parameterProfile.HelpDefinition, parameterProfile.Name, context); widgetPlaceholder.Add(uiMarkup); if (!bindings.ContainsKey(parameterProfile.Name)) { bindings.Add(parameterProfile.Name, ""); } if (parameterProfile.IsRequired) { bindingsValidationRules.Add(parameterProfile.Name, new List <ClientValidationRule> { new NotNullClientValidationRule() }); } } FormDefinition widgetFormDefinition = BuildFormDefinition(bindingsDeclaration, widgetPlaceholder, bindings); var compiler = new FormTreeCompiler(); using (XmlReader reader = widgetFormDefinition.FormMarkup) { compiler.Compile(reader, channelIdentifier, widgetFormDefinition.Bindings, false, "WidgetParameterSetters" + uniqueName, bindingsValidationRules); } return(compiler); }
/// <exclude /> public static FormTreeCompiler AttachAndCompileParameterWidgets(Control attachmentControl, IEnumerable <ParameterProfile> parameterProfiles, Dictionary <string, object> bindings, string uniqueName, string panelLabel, IFormChannelIdentifier channelIdentifier, bool reset) { FormTreeCompiler compiler = FunctionUiHelper.BuildWidgetForParameters(parameterProfiles, bindings, uniqueName, panelLabel, channelIdentifier); IWebUiControl webUiControl = (IWebUiControl)compiler.UiControl; Control form = webUiControl.BuildWebControl(); attachmentControl.Controls.Add(form); if (reset) { webUiControl.InitializeViewState(); } return(compiler); }
internal static FormTreeCompiler Build(string formPath, IFormChannelIdentifier channel, Dictionary<string, object> bindings, bool debugMode) { string folderPath = Path.GetDirectoryName(formPath).ToLowerInvariant(); string fileName = Path.GetFileName(formPath).ToLowerInvariant(); List<IFormDefinitionFile> formFiles = (from file in DataFacade.GetData<IFormDefinitionFile>() where file.FolderPath.ToLowerInvariant() == folderPath && file.FileName.ToLowerInvariant() == fileName select file).ToList(); if (formFiles.Count == 0) throw new ArgumentException(string.Format("No form definition with path '{0}' was found. Please use a virtual Form Path", formPath), "formPath"); if (formFiles.Count > 1) throw new ArgumentException(string.Format("Multiple form definitions with path '{0}' was found", formPath), "formPath"); FormTreeCompiler compiler = new FormTreeCompiler(); using (XmlTextReader formMarkupReader = new XmlTextReader(formFiles[0].GetReadStream())) { compiler.Compile(formMarkupReader, channel, bindings, debugMode); return compiler; } }
public static void InsertForm(Control control, ParameterList parameters) { Page currentPageHandler = HttpContext.Current.Handler as Page; if (currentPageHandler == null) { throw new InvalidOperationException("The Current HttpContext Handler must be a System.Web.Ui.Page"); } Type dataType = null; DataTypeDescriptor dataTypeDescriptor = null; string dataTypeName = parameters.GetParameter <string>("DataType"); dataType = TypeManager.GetType(dataTypeName); dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(dataType); IFormChannelIdentifier channelIdentifier = FormsRendererChannel.Identifier; formHelper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); newData = DataFacade.BuildNew(dataType); GeneratedTypesHelper.SetNewIdFieldValue(newData); //Hide not editable fields, fox example - PageId GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); formHelper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); //If is Page Datatype if (PageFolderFacade.GetAllFolderTypes().Contains(dataType)) { IPage currentPage = PageRenderer.CurrentPage; if (currentPage.GetDefinedFolderTypes().Contains(dataType) == false) { currentPage.AddFolderDefinition(dataType.GetImmutableTypeId()); } PageFolderFacade.AssignFolderDataSpecificValues(newData, currentPage); } _compiler = new FormTreeCompiler(); //bindings = formHelper.GetBindings(newData); bindings = new Dictionary <string, object>(); formHelper.UpdateWithNewBindings(bindings); formHelper.ObjectToBindings(newData, bindings); using (XmlReader reader = XDocument.Parse(formHelper.GetForm()).CreateReader()) { try { _compiler.Compile(reader, channelIdentifier, bindings, formHelper.GetBindingsValidationRules(newData)); #region ClientValidationRules clientValidationRules = new Dictionary <string, List <ClientValidationRule> >(); foreach (var item in _compiler.GetField <object>("_context").GetProperty <IEnumerable>("Rebindings")) { var SourceProducer = item.GetProperty <object>("SourceProducer"); var uiControl = SourceProducer as IWebUiControl; if (uiControl != null) { clientValidationRules[uiControl.UiControlID] = uiControl.ClientValidationRules; } } #endregion } catch (ConfigurationErrorsException e) { if (e.Message.Contains("Failed to load the configuration for IUiControlFactory")) { throw new ConfigurationErrorsException("Composite.Forms.Renderer does not support widget. " + e.Message); } else { throw new ConfigurationErrorsException(e.Message); } } } webUiControl = (IWebUiControl)_compiler.UiControl; Control form = webUiControl.BuildWebControl(); control.Controls.Add(form); /*if (currentPageHandler.IsPostBack) * try * { * compiler.SaveControlProperties(); * } * catch { }*/ if (!currentPageHandler.IsPostBack) { webUiControl.InitializeViewState(); } return; }
public static IUiControl Render( string consoleId, string elementProviderName, FlowToken flowToken, FormFlowUiDefinition formFlowUiCommand, IFormChannelIdentifier channel, bool debugMode, FlowControllerServicesContainer servicesContainer) { FlowControllerServicesContainer formServicesContainer = new FlowControllerServicesContainer(servicesContainer); formServicesContainer.AddService(new FormFlowRenderingService()); formServicesContainer.AddService(new FormFlowWebRenderingService()); IFormMarkupProvider formMarkupProvider = formFlowUiCommand.MarkupProvider; IFormMarkupProvider customToolbarItemsMarkupProvider = formFlowUiCommand.CustomToolbarItemsMarkupProvider; Dictionary <string, object> innerFormBindings = formFlowUiCommand.BindingsProvider.GetBindings(); Dictionary <IFormEventIdentifier, FormFlowEventHandler> eventHandlers = formFlowUiCommand.EventHandlers; Dictionary <string, List <ClientValidationRule> > bindingsValidationRules = formFlowUiCommand.BindingsValidationRules; FormTreeCompiler formCompiler = new FormTreeCompiler(); IUiContainer renderingContainer = GetRenderingContainer(channel, formFlowUiCommand.UiContainerType); // Setting state related objects so the delegate below can access them "fresh" CurrentFormTreeCompiler = formCompiler; CurrentInnerFormBindings = innerFormBindings; CurrentControlContainer = (IWebUiContainer)renderingContainer; Dictionary <string, object> containerEventHandlerStubs = new Dictionary <string, object>(); foreach (IFormEventIdentifier eventIdentifier in eventHandlers.Keys) { IFormEventIdentifier localScopeEventIdentifier = eventIdentifier; // See: Local variable usage with anonymous methods within loop control structures EventHandler handlerStub = delegate(object sender, EventArgs e) { try { BaseEventHandler(consoleId, elementProviderName, flowToken, formFlowUiCommand, servicesContainer, eventHandlers, localScopeEventIdentifier, formServicesContainer); } catch (Exception ex) { formServicesContainer.GetService <IManagementConsoleMessageService>().ShowLogEntry(typeof(FormFlowUiDefinitionRenderer), ex); throw; } }; containerEventHandlerStubs.Add(eventIdentifier.BindingName, handlerStub); if (innerFormBindings.ContainsKey(eventIdentifier.BindingName)) { innerFormBindings.Remove(eventIdentifier.BindingName); } innerFormBindings.Add(eventIdentifier.BindingName, handlerStub); } XDocument document; using (XmlReader formMarkupReader = formMarkupProvider.GetReader()) { document = XDocument.Load(formMarkupReader); formMarkupReader.Close(); } formCompiler.Compile(document, channel, innerFormBindings, debugMode, "", bindingsValidationRules); IUiControl innerForm = formCompiler.UiControl; IUiControl customToolbarItems = null; if (customToolbarItemsMarkupProvider != null) { var toolbarCompiler = new FormTreeCompiler(); CurrentCustomToolbarFormTreeCompiler = toolbarCompiler; using (XmlReader formMarkupReader = customToolbarItemsMarkupProvider.GetReader()) { toolbarCompiler.Compile(formMarkupReader, channel, innerFormBindings, debugMode, bindingsValidationRules); } customToolbarItems = toolbarCompiler.UiControl; } CurrentControlTreeRoot = (IWebUiControl)innerForm; string label = formCompiler.Label; if (label.IsNullOrEmpty()) { label = formFlowUiCommand.ContainerLabel ?? ""; } string labelField = GetFormLabelField(document); ResourceHandle containerIcon = formCompiler.Icon; return(renderingContainer.Render(formCompiler.UiControl, customToolbarItems, channel, containerEventHandlerStubs, label, labelField, formCompiler.Tooltip, containerIcon)); }
private static void BaseEventHandler(string consoleId, string elementProviderName, FlowToken flowToken, FormFlowUiDefinition formFlowUiCommand, FlowControllerServicesContainer servicesContainer, Dictionary <IFormEventIdentifier, FormFlowEventHandler> eventHandlers, IFormEventIdentifier localScopeEventIdentifier, FlowControllerServicesContainer formServicesContainer) { FormTreeCompiler activeFormTreeCompiler = CurrentFormTreeCompiler; Dictionary <string, object> activeInnerFormBindings = CurrentInnerFormBindings; FormFlowEventHandler handler = eventHandlers[localScopeEventIdentifier]; Dictionary <string, Exception> bindingErrors = activeFormTreeCompiler.SaveAndValidateControlProperties(); FormTreeCompiler activeCustomToolbarFormTreeCompiler = CurrentCustomToolbarFormTreeCompiler; if (activeCustomToolbarFormTreeCompiler != null) { var toolbarBindingErrors = activeCustomToolbarFormTreeCompiler.SaveAndValidateControlProperties(); foreach (var pair in toolbarBindingErrors) { bindingErrors.Add(pair.Key, pair.Value); } } formServicesContainer.AddService(new BindingValidationService(bindingErrors)); handler.Invoke(flowToken, activeInnerFormBindings, formServicesContainer); if (formServicesContainer.GetService <IManagementConsoleMessageService>().CloseCurrentViewRequested) { ViewTransitionHelper.HandleCloseCurrentView(formFlowUiCommand.UiContainerType); return; } var formFlowService = formServicesContainer.GetService <IFormFlowRenderingService>(); bool replacePageOutput = (formServicesContainer.GetService <IFormFlowWebRenderingService>().NewPageOutput != null); bool rerenderView = formFlowService.RerenderViewRequested; if (formFlowService.BindingPathedMessages != null) { ShowFieldMessages(CurrentControlTreeRoot, formFlowService.BindingPathedMessages, CurrentControlContainer, servicesContainer); } List <bool> boolCounterList = new List <bool> { replacePageOutput, rerenderView }; if (boolCounterList.Count(f => f) > 1) { StringBuilder sb = new StringBuilder("Flow returned conflicting directives for post handling:\n"); if (replacePageOutput) { sb.AppendLine(" - Replace page output with new web control."); } if (rerenderView) { sb.AppendLine(" - Rerender view."); } throw new InvalidOperationException(sb.ToString()); } if (rerenderView) { Log.LogVerbose("FormFlowRendering", "Re-render requested"); IFlowUiDefinition newFlowUiDefinition = FlowControllerFacade.GetCurrentUiDefinition(flowToken, servicesContainer); if (!(newFlowUiDefinition is FlowUiDefinitionBase)) { throw new NotImplementedException("Unable to handle transitions to ui definition of type " + newFlowUiDefinition.GetType()); } ViewTransitionHelper.HandleRerender(consoleId, elementProviderName, flowToken, formFlowUiCommand, (FlowUiDefinitionBase)newFlowUiDefinition, servicesContainer); } if (replacePageOutput) { Log.LogVerbose("FormFlowRendering", "Replace pageoutput requested"); IFormFlowWebRenderingService webRenderingService = formServicesContainer.GetService <IFormFlowWebRenderingService>(); Control newPageOutput = webRenderingService.NewPageOutput; foreach (Control control in GetNestedControls(newPageOutput).Where(f => f is ScriptManager).ToList()) { control.Parent.Controls.Remove(control); } Page currentPage = HttpContext.Current.Handler as Page; HtmlHead newHeadControl = GetNestedControls(newPageOutput).FirstOrDefault(f => f is HtmlHead) as HtmlHead; HtmlHead oldHeadControl = currentPage.Header; ControlCollection headContainer = null; bool headersHasToBeSwitched = newHeadControl != null && oldHeadControl != null; if (headersHasToBeSwitched) { headContainer = newHeadControl.Parent.Controls; headContainer.Remove(newHeadControl); } currentPage.Controls.Clear(); if (string.IsNullOrEmpty(webRenderingService.NewPageMimeType)) { currentPage.Response.ContentType = "text/html"; } else { currentPage.Response.ContentType = webRenderingService.NewPageMimeType; } currentPage.Controls.Add(newPageOutput); if (headersHasToBeSwitched) { oldHeadControl.Controls.Clear(); oldHeadControl.InnerHtml = ""; oldHeadControl.InnerText = ""; if (newHeadControl.ID != null) { oldHeadControl.ID = newHeadControl.ID; } oldHeadControl.Title = newHeadControl.Title; headContainer.AddAt(0, oldHeadControl); foreach (Control c in newHeadControl.Controls.Cast <Control>().ToList()) { oldHeadControl.Controls.Add(c); } } } }