Exemplo n.º 1
0
        protected virtual ControllerConfiguration LoadConfig(string controllerName)
        {
            ControllerConfiguration config = null;

            if (!(_controllers.TryGetValue(controllerName, out config)))
            {
                config = DataControllerBase.CreateConfigurationInstance(GetType(), controllerName);
                _controllers[controllerName] = config;
            }
            return(config);
        }
Exemplo n.º 2
0
        ControllerConfiguration IPlugIn.Create(ControllerConfiguration config)
        {
            if (config.Navigator.CanEdit)
            {
                return(config);
            }
            var document = new XmlDocument();

            document.LoadXml(config.Navigator.OuterXml);
            return(new ControllerConfiguration(document.CreateNavigator()));
        }
Exemplo n.º 3
0
        public ControllerConfiguration Virtualize(string controllerName)
        {
            var config = this;

            if (!_navigator.CanEdit)
            {
                var doc = new XmlDocument();
                doc.LoadXml(_navigator.OuterXml);
                config = new ControllerConfiguration(doc.CreateNavigator());
            }
            var rules = CreateBusinessRules();

            if (rules != null)
            {
                rules.VirtualizeController(controllerName, config._navigator, config._namespaceManager);
                config.PendingAlterations = rules.PendingAlterations;
            }
            return(config);
        }
Exemplo n.º 4
0
 protected virtual void ProcessResult(ControllerConfiguration config, ActionResult result)
 {
     if (_pk == null)
     {
         foreach (var fvo in result.Values)
         {
             _commitResult.Values.Add(new ControllerFieldValue(config.ControllerName, fvo.Name, fvo.OldValue, fvo.NewValue));
         }
     }
     else
     {
         foreach (var fvo in result.Values)
         {
             if (fvo.Name == _pk.Name)
             {
                 ResolvePrimaryKey(config.ControllerName, fvo.Name, _pk.Value, fvo.Value);
                 break;
             }
         }
     }
 }
Exemplo n.º 5
0
        public void AssignContext(string controller, string view, ControllerConfiguration config)
        {
            _controller = controller;
            _view       = view;
            var referrer = string.Empty;

            if ((PageSize == 1000) && string.IsNullOrEmpty(this.SortExpression))
            {
                // we are processing a request to retrieve static lookup data
                var sortExpressionNode = config.SelectSingleNode("c:dataController/c:views/c:view[@id=\'{0}\']/@sortExpression", view);
                if ((sortExpressionNode != null) && !(string.IsNullOrEmpty(sortExpressionNode.Value)))
                {
                    this.SortExpression = sortExpressionNode.Value;
                }
            }
            if ((HttpContext.Current != null) && (HttpContext.Current.Request.UrlReferrer != null))
            {
                referrer = HttpContext.Current.Request.UrlReferrer.AbsolutePath;
            }
            this._contextKey = string.Format("{0}/{1}.{2}.{3}", referrer, controller, view, ContextKey);
        }
Exemplo n.º 6
0
        protected virtual void ProcessArguments(ControllerConfiguration config, ActionArgs args)
        {
            if (args.Values == null)
            {
                return;
            }
            var values = new FieldValueDictionary(args);

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

            if (pkNav != null)
            {
                FieldValue fvo = null;
                if (values.TryGetValue(pkNav.GetAttribute("name", string.Empty), out fvo))
                {
                    var value = 0;
                    if ((fvo.Value != null) && int.TryParse(Convert.ToString(fvo.Value), out value))
                    {
                        if (value < 0)
                        {
                            if (args.CommandName == "Insert")
                            {
                                // request a new row from business rules
                                var newRowRequest = new PageRequest();
                                newRowRequest.Controller       = args.Controller;
                                newRowRequest.View             = args.View;
                                newRowRequest.Inserting        = true;
                                newRowRequest.RequiresMetaData = true;
                                newRowRequest.MetadataFilter   = new string[] {
                                    "fields"
                                };
                                var page = ControllerFactory.CreateDataController().GetPage(newRowRequest.Controller, newRowRequest.View, newRowRequest);
                                if (page.NewRow != null)
                                {
                                    for (var i = 0; (i < page.NewRow.Length); i++)
                                    {
                                        var newValue = page.NewRow[i];
                                        if (newValue != null)
                                        {
                                            var field = page.Fields[i];
                                            if (field.IsPrimaryKey)
                                            {
                                                // resolve the value of the primary key
                                                ResolvePrimaryKey(args.Controller, fvo.Name, value, newValue);
                                                value        = 0;
                                                fvo.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
                                                {
                                                    var 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)
                            {
                                if (args.CommandName == "Insert")
                                {
                                    if (pkNav.SelectSingleNode("c:items/@dataController", config.Resolver) == null)
                                    {
                                        _pk          = new FieldValue(fvo.Name, value);
                                        fvo.NewValue = null;
                                        fvo.Modified = false;
                                    }
                                }
                                else
                                {
                                    // otherwise try to resolve the primary key
                                    object resolvedKey = null;
                                    if (_resolvedKeys.TryGetValue(string.Format("{0}${1}", args.Controller, fvo.Value), out resolvedKey))
                                    {
                                        if (fvo.Modified)
                                        {
                                            fvo.NewValue = resolvedKey;
                                        }
                                        else
                                        {
                                            fvo.OldValue = resolvedKey;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // resolve negative foreign keys
            if (_resolvedKeys.Count > 0)
            {
                var fkIterator = config.Select("/c:dataController/c:fields/c:field[c:items/@dataController]");
                while (fkIterator.MoveNext())
                {
                    FieldValue fvo = null;
                    if (values.TryGetValue(fkIterator.Current.GetAttribute("name", string.Empty), out fvo))
                    {
                        var    itemsDataControllerNav = fkIterator.Current.SelectSingleNode("c:items/@dataController", config.Resolver);
                        object resolvedKey            = null;
                        if (_resolvedKeys.TryGetValue(string.Format("{0}${1}", itemsDataControllerNav.Value, fvo.Value), out resolvedKey))
                        {
                            if (fvo.Modified)
                            {
                                fvo.NewValue = resolvedKey;
                            }
                            else
                            {
                                fvo.OldValue = resolvedKey;
                            }
                        }
                    }
                }
            }
            // scan resolved primary keys and look for the one that are matching the keys referenced in SelectedValues, ExternalFilter, or Filter of the action
            foreach (var resolvedKeyInfo in _resolvedKeys.Keys)
            {
                var    separatorIndex     = resolvedKeyInfo.IndexOf("$");
                var    resolvedController = resolvedKeyInfo.Substring(0, separatorIndex);
                var    unresolvedKeyValue = resolvedKeyInfo.Substring((separatorIndex + 1));
                object resolvedKeyValue   = null;
                if ((args.Controller == resolvedController) && _resolvedKeys.TryGetValue(resolvedKeyInfo, out resolvedKeyValue))
                {
                    var resolvedKeyValueAsString = resolvedKeyValue.ToString();
                    // resolve primary key references in SelectedValues
                    if (args.SelectedValues != null)
                    {
                        for (var selectedValueIndex = 0; (selectedValueIndex < args.SelectedValues.Length); selectedValueIndex++)
                        {
                            var selectedKey = Regex.Split(args.SelectedValues[selectedValueIndex], ",");
                            for (var keyValueIndex = 0; (keyValueIndex < selectedKey.Length); keyValueIndex++)
                            {
                                if (selectedKey[keyValueIndex] == unresolvedKeyValue)
                                {
                                    selectedKey[keyValueIndex] = resolvedKeyValueAsString;
                                    args.SelectedValues[selectedValueIndex] = string.Join(",", selectedKey);
                                    selectedKey = null;
                                    break;
                                }
                            }
                            if (selectedKey == null)
                            {
                                break;
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 7
0
        public virtual ControllerConfiguration EnsureVitalElements()
        {
            // verify that the data controller has views and actions
            var root = SelectSingleNode("/c:dataController[c:views/c:view and c:actions/c:actionGroup]");

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

            doc.LoadXml(_navigator.OuterXml);
            var config     = new ControllerConfiguration(doc.CreateNavigator());
            var 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");
            var viewsNode = config.SelectSingleNode("/c:dataController/c:views[not(c:view)]");

            if (viewsNode != null)
            {
                var sb = new StringBuilder("<view id=\"view1\" type=\"Form\" label=\"Form\"><categories><category id=\"c1\" flow=\"New" +
                                           "Column\"><dataFields>");
                var fieldIterator = config.Select("/c:dataController/c:fields/c:field");
                while (fieldIterator.MoveNext())
                {
                    var fieldName = fieldIterator.Current.GetAttribute("name", string.Empty);
                    var hidden    = (fieldName == "PrimaryKey");
                    var 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");
            var 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>");
            }
            var plugIn = config.SelectSingleNode("/c:dataController/@plugIn");

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