public string ToJson()
        {
            ControllerConfiguration config = this.Virtualize(this.ControllerName);

            Complete();
            XPathNodeIterator ruleIterator = config.Select("/c:dataController/c:businessRules/c:rule");
            bool newOnServer       = false;
            bool calculateOnServer = false;

            while (ruleIterator.MoveNext())
            {
                string type        = ruleIterator.Current.GetAttribute("type", String.Empty);
                string commandName = ruleIterator.Current.GetAttribute("commandName", String.Empty);
                if (type != "JavaScript")
                {
                    if ((commandName == "New") && !(newOnServer))
                    {
                        newOnServer = true;
                        config.SelectSingleNode("/c:dataController").CreateAttribute(String.Empty, "newOnServer", null, "true");
                    }
                    else
                    if ((commandName == "Calculate") && !(calculateOnServer))
                    {
                        calculateOnServer = true;
                        config.SelectSingleNode("/c:dataController").CreateAttribute(String.Empty, "calculateOnServer", null, "true");
                    }
                }
            }
            string expressions = JArray.FromObject(this.Expressions).ToString();

            string[] exceptions = new string[] {
                "//comment()",
                "c:dataController/c:commands",
                "c:dataController/@handler",
                "//c:field/c:formula",
                "//c:businessRules/c:rule[@type=\"Code\" or @type=\"Sql\" or @type=\"Email\"]",
                "//c:businessRules/c:rule/text()",
                "//c:validate",
                "//c:styles",
                "//c:visibility",
                "//c:readOnly",
                "//c:expression"
            };
            foreach (string ex in exceptions)
            {
                List <XPathNavigator> toDelete = new List <XPathNavigator>();
                XPathNodeIterator     iterator = config.Select(ex);
                while (iterator.MoveNext())
                {
                    toDelete.Add(iterator.Current.Clone());
                }
                foreach (XPathNavigator node in toDelete)
                {
                    node.DeleteSelf();
                }
            }
            // special case of items/item serialization
            XPathNodeIterator itemsIterator = config.Select("//c:items[c:item]");

            while (itemsIterator.MoveNext())
            {
                StringBuilder     lovBuilder   = new StringBuilder("<list>");
                XPathNodeIterator itemIterator = itemsIterator.Current.SelectChildren(XPathNodeType.Element);
                while (itemIterator.MoveNext())
                {
                    lovBuilder.Append(itemIterator.Current.OuterXml);
                }
                lovBuilder.Append("</list>");
                itemsIterator.Current.InnerXml = lovBuilder.ToString();
            }
            // load custom view layouts
            XPathNodeIterator viewIterator = config.Select("//c:views/c:view");

            while (viewIterator.MoveNext())
            {
                string layout = LoadLayout(viewIterator.Current.GetAttribute("id", String.Empty));
                if (!(String.IsNullOrEmpty(layout)))
                {
                    viewIterator.Current.AppendChild(String.Format("<layout><![CDATA[{0}]]></layout>", layout));
                }
            }
            // extend JSON with "expressions"
            string json = XmlConverter.ToJson(config.Navigator, "dataController", true, "commands", "output", "fields", "views", "categories", "dataFields", "actions", "actionGroup", "businessRules", "list");
            Match  eof  = Regex.Match(json, "\\}\\s*\\}\\s*$");

            json = (json.Substring(0, eof.Index)
                    + (",\"expressions\":"
                       + (expressions + eof.Value)));
            return(json);
        }
        protected virtual void ProcessArguments(ControllerConfiguration config, ActionArgs args)
        {
            if (args.Values == null)
            {
                return;
            }
            FieldValueDictionary values = new FieldValueDictionary(args);

            _pk = null;
            // detect negative primary keys
            XPathNavigator pkNav = config.SelectSingleNode("/c:dataController/c:fields/c:field[@isPrimaryKey=\'true\']");

            if (pkNav != null)
            {
                FieldValue fv = null;
                if (values.TryGetValue(pkNav.GetAttribute("name", String.Empty), out fv))
                {
                    int value = 0;
                    if ((fv.NewValue != null) && int.TryParse(Convert.ToString(fv.NewValue), out value))
                    {
                        if (value < 0)
                        {
                            if (args.CommandName == "Insert")
                            {
                                // request a new row from business rules
                                PageRequest newRowRequest = new PageRequest();
                                newRowRequest.Controller       = args.Controller;
                                newRowRequest.View             = args.View;
                                newRowRequest.Inserting        = true;
                                newRowRequest.RequiresMetaData = true;
                                newRowRequest.MetadataFilter   = new string[] {
                                    "fields"
                                };
                                ViewPage page = ControllerFactory.CreateDataController().GetPage(newRowRequest.Controller, newRowRequest.View, newRowRequest);
                                if (page.NewRow != null)
                                {
                                    for (int i = 0; (i < page.NewRow.Length); i++)
                                    {
                                        object newValue = page.NewRow[i];
                                        if (newValue != null)
                                        {
                                            DataField field = page.Fields[i];
                                            if (field.IsPrimaryKey)
                                            {
                                                // resolve the value of the primary key
                                                ResolvePrimaryKey(args.Controller, fv.Name, value, newValue);
                                                value       = 0;
                                                fv.NewValue = newValue;
                                            }
                                            else
                                            {
                                                // inject a missing default value in the arguments
                                                FieldValue newFieldValue = null;
                                                if (values.TryGetValue(field.Name, out newFieldValue))
                                                {
                                                    if (!(newFieldValue.Modified))
                                                    {
                                                        newFieldValue.NewValue = newValue;
                                                        newFieldValue.Modified = true;
                                                    }
                                                }
                                                else
                                                {
                                                    List <FieldValue> newValues = new List <FieldValue>(args.Values);
                                                    newFieldValue = new FieldValue(field.Name, newValue);
                                                    newValues.Add(newFieldValue);
                                                    args.Values        = newValues.ToArray();
                                                    values[field.Name] = newFieldValue;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            // resolve the primary key after the command execution
                            if (value < 0)
                            {
                                _pk         = new FieldValue(fv.Name, value);
                                fv.NewValue = null;
                                fv.Modified = false;
                            }
                        }
                    }
                }
            }
            // resolve negative foreign keys
            if (_resolvedKeys.Count > 0)
            {
                XPathNodeIterator fkIterator = config.Select("/c:dataController/c:fields/c:field[c:items/@dataController]");
                while (fkIterator.MoveNext())
                {
                    FieldValue fv = null;
                    if (values.TryGetValue(fkIterator.Current.GetAttribute("name", String.Empty), out fv))
                    {
                        XPathNavigator itemsDataControllerNav = fkIterator.Current.SelectSingleNode("c:items/@dataController", config.Resolver);
                        object         resolvedKey            = null;
                        if (_resolvedKeys.TryGetValue(String.Format("{0}${1}", itemsDataControllerNav.Value, fv.NewValue), out resolvedKey))
                        {
                            fv.NewValue = resolvedKey;
                        }
                    }
                }
            }
        }
        public virtual ControllerConfiguration EnsureVitalElements()
        {
            // verify that the data controller has views and actions
            XPathNavigator root = SelectSingleNode("/c:dataController[c:views/c:view and c:actions/c:actionGroup]");

            if (root != null)
            {
                return(this);
            }
            // add missing configuration elements
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(_navigator.OuterXml);
            ControllerConfiguration config     = new ControllerConfiguration(doc.CreateNavigator());
            XPathNavigator          fieldsNode = config.SelectSingleNode("/c:dataController/c:fields[not(c:field[@isPrimaryKey=\'true\'])]");

            if (fieldsNode != null)
            {
                fieldsNode.AppendChild("<field name=\"PrimaryKey\" type=\"Int32\" isPrimaryKey=\"true\" readOnly=\"true\"/>");
            }
            root = config.SelectSingleNode("/c:dataController");
            EnsureChildNode(root, "views");
            XPathNavigator viewsNode = config.SelectSingleNode("/c:dataController/c:views[not(c:view)]");

            if (viewsNode != null)
            {
                StringBuilder sb = new StringBuilder("<view id=\"view1\" type=\"Form\" label=\"Form\"><categories><category id=\"c1\" flow=\"New" +
                                                     "Column\"><dataFields>");
                XPathNodeIterator fieldIterator = config.Select("/c:dataController/c:fields/c:field");
                while (fieldIterator.MoveNext())
                {
                    string fieldName = fieldIterator.Current.GetAttribute("name", String.Empty);
                    bool   hidden    = (fieldName == "PrimaryKey");
                    string length    = fieldIterator.Current.GetAttribute("length", String.Empty);
                    if (String.IsNullOrEmpty(length) && (((bool)(fieldIterator.Current.Evaluate("not(c:items/@style!=\'\')", _resolver))) == true))
                    {
                        if (fieldIterator.Current.GetAttribute("type", String.Empty) == "String")
                        {
                            length = "50";
                        }
                        else
                        {
                            length = "20";
                        }
                    }
                    sb.AppendFormat("<dataField fieldName=\"{0}\" hidden=\"{1}\"", fieldName, hidden.ToString().ToLower());
                    if (!(String.IsNullOrEmpty(length)))
                    {
                        sb.AppendFormat(" columns=\"{0}\"", length);
                    }
                    sb.Append(" />");
                }
                sb.Append("</dataFields></category></categories></view>");
                viewsNode.AppendChild(sb.ToString());
            }
            EnsureChildNode(root, "actions");
            XPathNavigator actionsNode = config.SelectSingleNode("/c:dataController/c:actions[not(c:actionGroup)]");

            if (actionsNode != null)
            {
                actionsNode.AppendChild(@"<actionGroup id=""ag1"" scope=""Form"">
<action id=""a1"" commandName=""Confirm"" causesValidation=""true"" whenLastCommandName=""New"" />
<action id=""a2"" commandName=""Cancel"" whenLastCommandName=""New"" />
<action id=""a3"" commandName=""Confirm"" causesValidation=""true"" whenLastCommandName=""Edit"" />
<action id=""a4"" commandName=""Cancel"" whenLastCommandName=""Edit"" />
<action id=""a5"" commandName=""Edit"" causesValidation=""true"" />
</actionGroup>");
            }
            XPathNavigator plugIn = config.SelectSingleNode("/c:dataController/@plugIn");

            if (plugIn != null)
            {
                plugIn.DeleteSelf();
                config._plugIn = null;
            }
            return(config);
        }