protected void SetupFormData(IDynamicDefinition definition, IModel model)
{
Bindings.Add("Name", definition.Name);
Bindings.Add("RequiresCaptcha", model.RequiresCaptcha);
Bindings.Add("ForceHttpsConnection", model.ForceHttps);
Bindings.Add("IntroText", GetValue("IntroText"));
Bindings.Add("SuccessResponse", GetValue("SuccessResponse"));
var markupProvider = new FormDefinitionFileMarkupProvider(_formFile);
var formDocument = XDocument.Load(markupProvider.GetReader());
var root = formDocument.Root;
var tabPanelElements = root?.Element(Namespaces.BindingForms10 + FormKeyTagNames.Layout)?.Element(Namespaces.BindingFormsStdUiControls10 + "TabPanels");
if (tabPanelElements == null)
{
return;
}
var bindingsXElement = root.Element(Namespaces.BindingForms10 + FormKeyTagNames.Bindings);
var lastTabElement = tabPanelElements.Elements().Last();
LoadExtraSettings(definition, bindingsXElement, lastTabElement);
DeliverFormData("EditForm", StandardUiContainerTypes.Document, formDocument.ToString(), Bindings, BindingsValidationRules);
}
protected static void ParseSubmitHandlers(XElement root, IDynamicDefinition definition)
{
var submitHandlersElement = root.Element("SubmitHandlers");
if (submitHandlersElement == null)
{
return;
}
foreach (var handler in submitHandlersElement.Elements("Add"))
{
var typeString = handler.Attribute("Type").Value;
var type = Type.GetType(typeString);
if (type == null)
{
if (typeString.StartsWith("CompositeC1Contrib.FormBuilder.Dynamic.Wizard.SubmitHandlers.EmailSubmitHandler"))
{
type = typeof(EmailSubmitHandler);
}
}
if (type == null)
{
continue;
}
var instance = (FormSubmitHandler)XElementHelper.DeserializeInstanceWithArgument(type, handler);
instance.Load(definition, handler);
definition.SubmitHandlers.Add(instance);
}
}
public static void Copy(IDynamicDefinition definition, string newName)
{
var def = GetDefinition(definition.Name);
def.Name = newName;
var serializer = XmlDefinitionSerializer.GetSerializer(definition.Name);
serializer.Save(def);
}
public static void Delete(IDynamicDefinition definition)
{
var dir = Path.Combine(ModelsFacade.RootPath, definition.Name);
C1Directory.Delete(dir, true);
foreach (var submitHandler in definition.SubmitHandlers)
{
submitHandler.Delete(definition);
}
ModelsFacade.NotifyFormChanges();
}
public override void Delete(IDynamicDefinition definition)
{
using (var data = new DataConnection())
{
var templates = data.Get <IMailTemplate>().Where(t => t.Key == definition.Name + "." + Name);
var templateContents = data.Get <IMailTemplateContent>().Where(t => t.TemplateKey == definition.Name + "." + Name);
data.Delete(templates);
data.Delete(templateContents);
}
base.Delete(definition);
}
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);
}
}
protected void Save(IDynamicDefinition definition)
{
SaveExtraSettings(definition);
var token = GetBinding <DataEntityToken>("BoundToken");
var modelReference = (IModelReference)token.Data;
var name = GetBinding <string>("Name");
var introText = GetBinding <string>("IntroText");
var successResponse = GetBinding <string>("SuccessResponse");
using (var writer = ResourceFacade.GetResourceWriter())
{
writer.AddResource(GetKey("IntroText"), introText);
writer.AddResource(GetKey("SuccessResponse"), successResponse);
}
var isNewName = name != modelReference.Name;
if (isNewName)
{
LocalizationsFacade.RenameNamespace(Localization.KeyPrefix + "." + modelReference.Name, Localization.KeyPrefix + "." + name, Localization.ResourceSet);
DefinitionsFacade.Copy(definition, name);
DefinitionsFacade.Delete(definition);
modelReference = ModelReferenceFacade.GetModelReference(name);
token = modelReference.GetDataEntityToken();
UpdateBinding("BoundToken", token);
SetSaveStatus(true, token);
}
else
{
DefinitionsFacade.Save(definition);
SetSaveStatus(true);
}
CreateParentTreeRefresher().PostRefreshMessages(EntityToken);
}
protected void SaveMetaData(IDynamicDefinition definition, XElement root)
{
if (definition.SubmitHandlers.Any())
{
var submitHandlers = new XElement("SubmitHandlers");
foreach (var handler in definition.SubmitHandlers)
{
var qualifiedName = handler.GetType().AssemblyQualifiedName;
if (qualifiedName == null)
{
continue;
}
var handlerElement = new XElement("Add",
new XAttribute("Name", handler.Name),
new XAttribute("Type", qualifiedName));
handler.Save(definition, handlerElement);
submitHandlers.Add(handlerElement);
}
root.Add(submitHandlers);
}
if (definition.Settings != null)
{
var qualifiedName = definition.Settings.GetType().AssemblyQualifiedName;
if (qualifiedName != null)
{
var settingsElement = new XElement("FormSettings",
new XAttribute("Type", qualifiedName));
SerializeInstanceWithArgument(definition.Settings, settingsElement);
root.Add(settingsElement);
}
}
}
protected static void ParseFormSettings(XElement metaData, IDynamicDefinition definition)
{
var formSettingsElement = metaData.Element("FormSettings");
if (formSettingsElement == null)
{
return;
}
var typeString = formSettingsElement.Attribute("Type").Value;
var type = Type.GetType(typeString);
if (type == null)
{
return;
}
var instance = (IFormSettings)XElementHelper.DeserializeInstanceWithArgument(type, formSettingsElement);
definition.Settings = instance;
}
public override void Save(IDynamicDefinition form)
{
var wizard = (DynamicWizardDefinition)form;
var root = new XElement("FormBuilder.Wizard",
new XAttribute("name", wizard.Name),
new XAttribute("requiresCaptcha", wizard.Model.RequiresCaptcha),
new XAttribute("forceHttpsConnection", wizard.Model.ForceHttps));
var steps = new XElement("Steps");
foreach (var step in wizard.Model.Steps)
{
var stepElement = new XElement("Step",
new XAttribute("Name", step.Name),
new XAttribute("FormName", step.FormName),
new XAttribute("Label", step.Label),
new XAttribute("LocalOrdering", step.LocalOrdering));
if (!String.IsNullOrEmpty(step.NextButtonLabel))
{
stepElement.Add(new XAttribute("nextButtonLabel", step.NextButtonLabel));
}
if (!String.IsNullOrEmpty(step.PreviousButtonLabel))
{
stepElement.Add(new XAttribute("previousButtonLabel", step.PreviousButtonLabel));
}
steps.Add(stepElement);
}
root.Add(steps);
SaveMetaData(form, root);
SaveDefinitionFile(form.Name, root);
base.Save(form);
}
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);
}
}
public virtual void Load(IDynamicDefinition model, XElement handler)
{
Name = handler.Attribute("Name").Value;
}
public virtual void Save(IDynamicDefinition form)
{
ModelsFacade.NotifyFormChanges();
}
public virtual void Save(IDynamicDefinition definition, XElement handler)
{
}
public virtual void Delete(IDynamicDefinition definition)
{
}
public override void Save(IDynamicDefinition form)
{
var definition = (DynamicFormDefinition)form;
var model = definition.Model;
var root = new XElement("FormBuilder.DynamicForm",
new XAttribute("name", definition.Name));
var metaData = new XElement("MetaData");
if (model.Attributes.OfType <ForceHttpsConnectionAttribute>().Any())
{
metaData.Add(new XElement("forceHttpsConnection"));
}
if (model.Attributes.OfType <RequiresCaptchaAttribute>().Any())
{
metaData.Add(new XElement("requiresCaptcha"));
}
if (definition.DefaultValues.Any())
{
var defaultValues = new XElement("DefaultValues");
foreach (var kvp in definition.DefaultValues)
{
var defaultValueElement = new XElement("Add",
new XAttribute("field", kvp.Key),
new XAttribute("functionMarkup", kvp.Value.ToString()));
defaultValues.Add(defaultValueElement);
}
metaData.Add(defaultValues);
}
SaveMetaData(definition, metaData);
if (metaData.HasElements)
{
root.Add(metaData);
}
var fields = new XElement("Fields");
foreach (var field in model.Fields)
{
var add = new XElement("Add",
new XAttribute("name", field.Name),
new XAttribute("valueType", field.ValueType.AssemblyQualifiedName));
if (field.IsReadOnly)
{
add.Add(new XAttribute("isReadOnly", true));
}
var formatAttribute = field.Attributes.OfType <DisplayFormatAttribute>().SingleOrDefault();
if (formatAttribute != null)
{
add.Add(new XAttribute("format", formatAttribute.FormatString));
}
if (field.InputElementType != null)
{
var inputElement = new XElement("InputElement");
var inputElementType = field.InputElementType.GetType();
inputElement.Add(new XAttribute("type", inputElementType.AssemblyQualifiedName));
SerializeInstanceWithArgument(field.InputElementType, inputElement);
add.Add(inputElement);
}
if (field.ValidationAttributes.Any())
{
var validationRules = new XElement("ValidationRules");
foreach (var rule in field.ValidationAttributes)
{
var ruleType = rule.GetType();
var ruleElement = new XElement("Add",
new XAttribute("type", ruleType.AssemblyQualifiedName));
SerializeInstanceWithArgument(rule, ruleElement);
validationRules.Add(ruleElement);
}
add.Add(validationRules);
}
if (field.DependencyAttributes.Any())
{
var dependencies = new XElement("Dependencies");
foreach (var dep in field.DependencyAttributes)
{
var dependency = new XElement("Add",
new XAttribute("type", dep.GetType().AssemblyQualifiedName),
new XAttribute("field", dep.ReadFromFieldName));
var values = new XElement("values");
foreach (var value in dep.ResolveRequiredFieldValues())
{
values.Add(new XElement("item",
new XAttribute("type", value.GetType().AssemblyQualifiedName),
new XAttribute("value", value)));
}
dependency.Add(values);
dependencies.Add(dependency);
}
add.Add(dependencies);
}
var dataSourceAttribute = field.Attributes.OfType <DataSourceAttribute>().FirstOrDefault();
if (dataSourceAttribute != null)
{
var datasource = new XElement("DataSource",
new XAttribute("type", dataSourceAttribute.GetType().AssemblyQualifiedName));
var stringBasedDataSourceAttribute = dataSourceAttribute as StringBasedDataSourceAttribute;
if (stringBasedDataSourceAttribute != null)
{
var values = new XElement("values");
foreach (var value in stringBasedDataSourceAttribute.Values)
{
values.Add(new XElement("item",
new XAttribute("value", value)));
}
datasource.Add(values);
}
add.Add(datasource);
}
fields.Add(add);
}
root.Add(fields);
SaveDefinitionFile(definition.Name, root);
base.Save(definition);
}
public static void SaveForm(IDynamicDefinition definition)
{
var serializer = new FormXmlSerializer();
serializer.Save(definition);
}
public override void Save(IDynamicDefinition definition, XElement handler)
{
handler.Add(new XAttribute("IncludeAttachments", IncludeAttachments));
}
public static void Save(IDynamicDefinition definition)
{
var serializer = XmlDefinitionSerializer.GetSerializer(definition.Name);
serializer.Save(definition);
}
