private void LoadExtraSettings(FormFieldModel field, XElement bindingsXElement, XElement lastTabElement)
        {
            var config          = FormBuilderConfiguration.GetSection();
            var plugin          = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];
            var inputElement    = plugin.InputElementHandlers.Single(el => el.ElementType.GetType() == field.InputElementType.GetType());
            var settingsHandler = inputElement.SettingsHandler;

            if (settingsHandler != null)
            {
                var formFile = "\\InstalledPackages\\CompositeC1Contrib.FormBuilder.Dynamic\\InputElementSettings\\" + inputElement.Name + ".xml";
                var settingsMarkupProvider = new FormDefinitionFileMarkupProvider(formFile);
                var formDefinitionElement  = XElement.Load(settingsMarkupProvider.GetReader());

                var settingsTab = new XElement(Namespaces.BindingFormsStdUiControls10 + "PlaceHolder");
                var layout      = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Layout);
                var bindings    = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Bindings);

                settingsTab.Add(new XAttribute("Label", StringResourceSystemFacade.ParseString(inputElement.Name)));
                settingsTab.Add(layout.Elements());
                bindingsXElement.Add(bindings.Elements());

                lastTabElement.AddAfterSelf(settingsTab);

                settingsHandler.Load(field);

                foreach (var prop in settingsHandler.GetType().GetProperties())
                {
                    var value = prop.GetValue(settingsHandler, null);

                    Bindings.Add(prop.Name, value);
                }
            }
        }
        static AddFormFieldWorkflow()
        {
            var config = FormBuilderConfiguration.GetSection();
            var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];

            InputElementTypes = plugin.InputElementHandlers.ToDictionary(e => e.ElementType.GetType().AssemblyQualifiedName, e => e.Name);
        }
        static AddSubmitHandlerWorkflow()
        {
            var config = FormBuilderConfiguration.GetSection();
            var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];

            Handlers = plugin.SubmitHandlers;
        }
        private void LoadExtraSettings(IDynamicDefinition definition, XElement bindingsXElement, XElement lastTabElement)
        {
            var config = FormBuilderConfiguration.GetSection();
            var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];

            var settingsType = plugin.SettingsHandler;

            if (settingsType == null)
            {
                return;
            }

            var formFile = "\\InstalledPackages\\" + settingsType.Namespace + "\\" + settingsType.Name + ".xml";
            var settingsMarkupProvider = new FormDefinitionFileMarkupProvider(formFile);
            var formDefinitionElement  = XElement.Load(settingsMarkupProvider.GetReader());
            var settingsTab            = new XElement(Namespaces.BindingFormsStdUiControls10 + "PlaceHolder");

            var layout = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Layout);

            if (layout == null)
            {
                return;
            }

            var bindings = formDefinitionElement.Element(Namespaces.BindingForms10 + FormKeyTagNames.Bindings);

            if (bindings == null)
            {
                return;
            }

            settingsTab.Add(new XAttribute("Label", "Extra Settings"));
            settingsTab.Add(layout.Elements());

            bindingsXElement.Add(bindings.Elements());
            lastTabElement.AddAfterSelf(settingsTab);

            var settings = definition.Settings ?? (IFormSettings)Activator.CreateInstance(settingsType);

            foreach (var prop in settingsType.GetProperties())
            {
                var value = prop.GetValue(settings, null);

                Bindings.Add(prop.Name, value);
            }
        }
        private void LoadParameterProfiles()
        {
            string elementName = (string)_fieldXml.Attribute("name");

            Verify.ArgumentNotNullOrEmpty(elementName, "Missing element name");

            var allElements = FormBuilderConfiguration.GetFieldMap();

            Verify.That(allElements.ContainsKey(elementName), "Undeclared form element 'elementName'");

            var element = allElements[elementName];

            string functionName = (string)element.FunctionNode.Attribute("name");

            IFunction function = FunctionFacade.GetFunction(functionName);

            Verify.IsNotNull(function, "Failed to get C1 function '{0}'", functionName);

            List <string> predefinedParameterNames = element.FunctionNode.Elements().Select(el => (string)el.Attribute("name")).ToList();

            _fieldConfiguration = element;
            _parameterProfiles  = function.ParameterProfiles.Where(p => !predefinedParameterNames.Contains(p.Name)).ToArray();

            _standardParameters = new ParameterGroup {
                ParameterProfiles = _parameterProfiles.Where(p =>
                                                             !_fieldConfiguration.DescriptionParameters.Contains(p.Name) &&
                                                             !_fieldConfiguration.ValidationParameters.Contains(p.Name) &&
                                                             !_fieldConfiguration.AdvancedParameters.Contains(p.Name)).ToArray()
            };

            _descriptionParameters = new ParameterGroup
            {
                ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.DescriptionParameters.Contains(p.Name)).ToArray()
            };

            _validationParameters = new ParameterGroup
            {
                ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.ValidationParameters.Contains(p.Name)).ToArray()
            };

            _advancedParameters = new ParameterGroup {
                ParameterProfiles = _parameterProfiles.Where(p => _fieldConfiguration.AdvancedParameters.Contains(p.Name)).ToArray()
            };
        }
Ejemplo n.º 6
0
        static List <ActionInformation> LoadActions(XElement actionsElement, XElement disabledActionsElement)
        {
            var result = new List <ActionInformation>();

            var definedActions = actionsElement.Elements().ToDictionary(
                handlerElement => (string)handlerElement.Attribute("name"),
                handlerElement => handlerElement);

            var disabledActions = disabledActionsElement.Elements().ToDictionary(
                handlerElement => (string)handlerElement.Attribute("name"),
                handlerElement => handlerElement);

            foreach (var action in FormBuilderConfiguration.GetActions())
            {
                var info = new ActionInformation {
                    ConfigurationElement = action
                };

                if (definedActions.ContainsKey(action.Name))
                {
                    info.Enabled = true;
                    info.Element = definedActions[action.Name];

                    definedActions.Remove(action.Name);
                }
                else if (disabledActions.ContainsKey(action.Name))
                {
                    info.Element = disabledActions[action.Name];

                    disabledActions.Remove(action.Name);
                }

                result.Add(info);
            }

            if (definedActions.Count > 0)
            {
                throw new InvalidOperationException("Action '{0}' is not defined in the FormBuilder configuration file".FormatWith(definedActions.Keys.First()));
            }

            return(result);
        }
Ejemplo n.º 7
0
        public DynamicWizardDefinition(WizardModel model)
        {
            Model = model;

            Name = model.Name;

            SubmitHandlers = new List <FormSubmitHandler>();

            IntroText       = new XhtmlDocument();
            SuccessResponse = new XhtmlDocument();

            var config = FormBuilderConfiguration.GetSection();
            var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];

            var settingsType = plugin.SettingsHandler;

            if (settingsType != null)
            {
                Settings = (IFormSettings)Activator.CreateInstance(settingsType);
            }
        }
        private void SaveExtraSettings(FormFieldModel field)
        {
            var config          = FormBuilderConfiguration.GetSection();
            var plugin          = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];
            var inputElement    = plugin.InputElementHandlers.Single(el => el.ElementType.GetType() == field.InputElementType.GetType());
            var settingsHandler = inputElement.SettingsHandler;

            if (settingsHandler != null)
            {
                foreach (var prop in settingsHandler.GetType().GetProperties())
                {
                    if (BindingExist(prop.Name))
                    {
                        var value = GetBinding <object>(prop.Name);

                        prop.SetValue(settingsHandler, value, null);
                    }
                }

                settingsHandler.Save(field);
            }
        }
        private void SaveExtraSettings(IDynamicDefinition definition)
        {
            var config = FormBuilderConfiguration.GetSection();
            var plugin = (DynamicFormBuilderConfiguration)config.Plugins["dynamic"];

            var settingsType = plugin.SettingsHandler;

            if (settingsType == null)
            {
                definition.Settings = null;

                return;
            }

            definition.Settings = (IFormSettings)Activator.CreateInstance(settingsType);

            foreach (var prop in settingsType.GetProperties().Where(p => BindingExist(p.Name)))
            {
                var value = GetBinding <object>(prop.Name);

                prop.SetValue(definition.Settings, value, null);
            }
        }
Ejemplo n.º 10
0
        static RequiresCaptchaAttribute()
        {
            var captchaConfig = FormBuilderConfiguration.GetSection().Captcha;

            Provider = (CaptchaProvider)captchaConfig.Providers[captchaConfig.DefaultProvider];
        }
Ejemplo n.º 11
0
 protected void Page_PreRender(object sender, EventArgs e)
 {
     rptCssFiles.DataSource = FormBuilderConfiguration.GetFieldEditorConfiguration().CssFiles.Select(UrlUtils.ResolvePublicUrl);
     rptCssFiles.DataBind();
 }
Ejemplo n.º 12
0
    protected void OnClick(object sender, EventArgs e)
    {
        XElement fieldsElement  = XElement.Parse(Request["FormMarkup"]);
        XElement actionsElement = XElement.Parse(Server.UrlDecode(Request["Actions"]));
        XElement receiptElement = XElement.Parse(Server.UrlDecode(Request["confirmation"]));

        if (FormBuilderConfiguration.GetActions().Any() && !actionsElement.Elements().Any())
        {
            Alert(Localization.Editor_SaveError_AlertTitle, Localization.Editor_SaveError_NoActionSelected);
            ctlFeedback.SetStatus(false);
            return;
        }

        string name = Request["txtName"];
        string submitButtonLabel = Request["txtSubmitButtonLabel"];
        string securityHandler   = Request["txtSecurityHandler"];
        bool   useCaptcha        = Request["chkUseCaptcha"] == "1";

        var functionElement = XElement.Parse(string.Format(@"<f:{0} xmlns:f=""{1}"" />", FunctionTreeConfigurationNames.FunctionTagName, FunctionTreeConfigurationNames.NamespaceName));

        functionElement.Add(new XAttribute("name", "Composite.Forms.FormBuilder.Form"));

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "Name"),
                                         new XAttribute("value", name)));

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "SubmitButtonLabel"),
                                         new XAttribute("value", submitButtonLabel)));

        if (securityHandler != null)
        {
            functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                             new XAttribute("name", "SecurityHandler"),
                                             new XAttribute("value", securityHandler)));
        }

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "Fields"),
                                         FixFieldNames(fieldsElement)));

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "Actions"),
                                         actionsElement));

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "Receipt"),
                                         receiptElement));

        functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                         new XAttribute("name", "UseCaptcha"),
                                         new XAttribute("value", useCaptcha.ToString())));

        string failureMessage = ViewState[FailureMessage_ViewStateKey] as string;

        if (failureMessage != null)
        {
            functionElement.Add(new XElement(Namespaces.Function10 + "param",
                                             new XAttribute("name", "FailureMessage"), XElement.Parse(failureMessage)));
        }

        __FunctionMarkup.InnerText = functionElement.ToString();

        ctlFeedback.SetStatus(true);
    }