示例#1
0
        public override RoboUIGridRequest CreateGridRequest(ControllerContext controllerContext)
        {
            var result  = new RoboUIGridRequest();
            var request = controllerContext.HttpContext.Request;

            var page = request.Form["page"];

            if (page != null)
            {
                result.PageIndex = Convert.ToInt32(page);
            }

            var pageSize = request.Form["pageSize"];

            if (pageSize != null)
            {
                result.PageSize = Convert.ToInt32(pageSize);
            }

            var bindingContext = new ModelBindingContext
            {
                ValueProvider = controllerContext.Controller.ValueProvider
            };

            string value;

            if (TryGetValue(bindingContext, "sort", out value))
            {
                result.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(value);
            }

            if (TryGetValue(bindingContext, "filter", out value))
            {
                if (!string.IsNullOrEmpty(value))
                {
                    // Process [today], [beginWeek], [endWeek], [beginMonth], [endMonth], [beginPrevMonth] tokens
                    var dtNow = DateTime.UtcNow.Date;
                    int startIndex;
                    var endIndex = 0;
                    while ((startIndex = value.IndexOf("[today", endIndex, StringComparison.Ordinal)) != -1)
                    {
                        endIndex = value.IndexOf("]", startIndex, StringComparison.Ordinal);
                        var days = value.Substring(startIndex + 6, endIndex - startIndex - 6);
                        value = value.Replace("[today" + days + "]", dtNow.AddDays(Convert.ToInt32(days)).ToString("O"));
                    }

                    value = value.Replace("[beginWeek]", dtNow.StartOfWeek(DayOfWeek.Monday).ToString("O"));
                    value = value.Replace("[endWeek]", dtNow.EndOfWeek(DayOfWeek.Sunday).AddDays(1).ToString("O"));
                    value = value.Replace("[beginMonth]", new DateTime(dtNow.Year, dtNow.Month, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
                    value = value.Replace("[endMonth]", new DateTime(dtNow.Year, dtNow.Month + 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
                    value = value.Replace("[beginPrevMonth]", new DateTime(dtNow.Year, dtNow.Month - 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
                    value = value.Replace("[beginYear]", new DateTime(dtNow.Year, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
                    value = value.Replace("[endYear]", new DateTime(dtNow.Year + 1, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));

                    result.Filters = FilterDescriptorFactory.Create(value);
                }
            }

            return(result);
        }
        public void Should_deserialize_descriptors()
        {
            var result = GridDescriptorSerializer.Deserialize <SortDescriptor>("foo-asc~bar-desc");

            result.Count.ShouldEqual(2);

            result.First().Member.ShouldNotBeNull();
            result.Last().Member.ShouldNotBeNull();
        }
示例#3
0
 public ValueProviderResult GetValue(string key)
 {
     if (key == GridUrlParameters.Sort)
     {
         var par = GridDescriptorSerializer.Serialize(sortDescriptors);
         return(new ValueProviderResult(par, par, CultureInfo.InvariantCulture));
     }
     return(null);
 }
示例#4
0
        private void AppendUngroupButton(IHtmlNode indicator, IGridUrlBuilder urlBuilder, List <GroupDescriptor> groups)
        {
            var button = new HtmlElement("a")
                         .Attribute("href", urlBuilder.SelectUrl(GridUrlParameters.Group,
                                                                 GridDescriptorSerializer.Serialize(groups)))
                         .AddClass(new[] { UIPrimitives.Button, UIPrimitives.ButtonIcon, UIPrimitives.ButtonBare })
                         .AppendTo(indicator);

            new HtmlElement("span")
            .AddClass(UIPrimitives.Icon, UIPrimitives.Icons.GroupDelete)
            .AppendTo(button);
        }
示例#5
0
        public static GridCommand Parse(int page, int pageSize, string orderBy, string groupBy, string filter)
        {
            GridCommand result = new GridCommand
            {
                Page              = page,
                PageSize          = pageSize,
                SortDescriptors   = GridDescriptorSerializer.Deserialize <SortDescriptor>(orderBy),
                FilterDescriptors = FilterDescriptorFactory.Create(filter),
                GroupDescriptors  = GridDescriptorSerializer.Deserialize <GroupDescriptor>(groupBy)
            };

            return(result);
        }
        public void Should_return_single_serialized_descriptors()
        {
            var descriptor = new Mock <IDescriptor>();

            descriptor.Setup(d => d.Serialize()).Returns("foo");

            var result = GridDescriptorSerializer.Serialize(new []
            {
                descriptor.Object
            });

            result.ShouldEqual("foo");
        }
示例#7
0
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            DataSourceRequest request = new DataSourceRequest();

            string sort, group, filter, aggregates;
            int    currentPage;
            int    pageSize;

            if (TryGetValue(bindingContext, GridUrlParameters.Sort, out sort))
            {
                request.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(sort);
            }

            if (TryGetValue(bindingContext, GridUrlParameters.Page, out currentPage))
            {
                request.Page = currentPage;
            }

            if (TryGetValue(bindingContext, GridUrlParameters.PageSize, out pageSize))
            {
                request.PageSize = pageSize;
            }

            if (TryGetValue(bindingContext, GridUrlParameters.Filter, out filter))
            {
                request.Filters = FilterDescriptorFactory.Create(filter);
            }
            else
            {
                request.Filters = new System.Collections.Generic.List <IFilterDescriptor>();
            }

            if (TryGetValue(bindingContext, GridUrlParameters.Group, out group))
            {
                request.Groups = GridDescriptorSerializer.Deserialize <GroupDescriptor>(group);
            }

            if (TryGetValue(bindingContext, GridUrlParameters.Aggregates, out aggregates))
            {
                request.Aggregates = GridDescriptorSerializer.Deserialize <AggregateDescriptor>(aggregates);
            }

            bindingContext.Model = request;
            return(true);
        }
示例#8
0
        public void OnActionExecuting(ActionExecutingContext filterContext)
        {
            string key = ActionParameterName;
            IEnumerable <KeyValuePair <string, object> > source = filterContext.ActionParameters.Where(parameter => parameter.Value is GridCommand);

            if (source.Count() == 1)
            {
                key = source.First().Key;
            }

            if (!filterContext.ActionParameters.ContainsKey(key))
            {
                return;
            }

            GridCommand gridCommand = (GridCommand)filterContext.ActionParameters[key] ?? new GridCommand();

            gridCommand.Page     = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.Page));
            gridCommand.PageSize = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.PageSize));

            string from1 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Sort));

            gridCommand.SortDescriptors.AddRange(GridDescriptorSerializer.Deserialize <SortDescriptor>(from1));

            string input = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Filter));

            if (input != null)
            {
                input = input.Replace('+', ' ');
            }
            gridCommand.FilterDescriptors.AddRange(FilterDescriptorFactory.Create(input));

            string from2 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Group));

            gridCommand.GroupDescriptors.AddRange(GridDescriptorSerializer.Deserialize <GroupDescriptor>(from2));

            string from3 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Aggregates));

            gridCommand.Aggregates.AddRange(GridDescriptorSerializer.Deserialize <AggregateDescriptor>(from3));

            filterContext.ActionParameters[ActionParameterName] = gridCommand;
        }
        public ActionResult Chart2()
        {
            ChartViewModel cvm = new ChartViewModel();

            DataSourceRequest request = new DataSourceRequest();

            request.Aggregates = GridDescriptorSerializer.Deserialize <Kendo.Mvc.AggregateDescriptor>("UnitsInStock-sum");
            request.Groups     = GridDescriptorSerializer.Deserialize <Kendo.Mvc.GroupDescriptor>("CategoryName-asc");

            using (var northwind = new NorthWindEntities1())
            {
                IQueryable <ProductViewModel> pvm = from p in northwind.Products
                                                    orderby p.ProductID
                                                    join c in northwind.Categories on p.CategoryID equals c.CategoryID
                                                    join s in northwind.Suppliers on p.SupplierID equals s.SupplierID
                                                    select new ProductViewModel
                {
                    ProductID       = p.ProductID,
                    ProductName     = p.ProductName,
                    CompanyName     = s.CompanyName,
                    CategoryName    = c.CategoryName,
                    QuantityPerUnit = p.QuantityPerUnit,
                    UnitPrice       = p.UnitPrice,
                    UnitsInStock    = p.UnitsInStock,
                    UnitsOnOrder    = p.UnitsOnOrder,
                    ReorderLevel    = p.ReorderLevel,
                    Discontinued    = p.Discontinued
                };

                DataSourceResult data = (pvm as IQueryable).ToDataSourceResult(request);

                var pieSections = (data.Data as List <Kendo.Mvc.Infrastructure.AggregateFunctionsGroup>).Select(p => new { Key = p.Key, Value = (int)((p.Aggregates["UnitsInStock"] as Dictionary <string, object>)["Sum"]) });

                var series = pieSections.Select(p => new ChartDataItem {
                    category = p.Key.ToString(), value = p.Value
                });

                cvm.series = series.ToList();
            }

            return(View(cvm));
        }
示例#10
0
        private void AppendSortLink(IHtmlNode indicator, GroupDescriptor group, List <GroupDescriptor> groups, IGridUrlBuilder urlBuilder, Func <string, string> title)
        {
            group.CycleSortDirection();

            var a = new HtmlElement("a")
                    .AddClass(UIPrimitives.Link)
                    .Attribute("href", urlBuilder.SelectUrl(GridUrlParameters.Group, GridDescriptorSerializer.Serialize(groups)))
                    .AppendTo(indicator);

            group.CycleSortDirection();

            new HtmlElement("span")
            .AddClass(UIPrimitives.Icon)
            .ToggleClass("k-si-arrow-n", group.SortDirection == ListSortDirection.Ascending)
            .ToggleClass("k-si-arrow-s", group.SortDirection == ListSortDirection.Descending)
            .AppendTo(a);

            groups.Remove(group);

            new TextNode(title(group.Member)).AppendTo(a);
        }
        public virtual void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var parameterName = ActionParameterName;

            var parametersOfGridCommandType = filterContext.ActionParameters
                                              .Where(parameter => parameter.Value is GridCommand);

            if (parametersOfGridCommandType.Count() == 1)
            {
                parameterName = parametersOfGridCommandType.First().Key;
            }

            if (filterContext.ActionParameters.ContainsKey(parameterName))
            {
                var command = ((GridCommand)filterContext.ActionParameters[parameterName] ?? new GridCommand());
                command.Page     = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.CurrentPage));
                command.PageSize = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.PageSize));

                var orderBy = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.OrderBy));

                command.SortDescriptors.AddRange(GridDescriptorSerializer.Deserialize <SortDescriptor>(orderBy));

                var filter = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Filter));

                command.FilterDescriptors.AddRange(FilterDescriptorFactory.Create(filter));

                var groupBy = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.GroupBy));

                command.GroupDescriptors.AddRange(GridDescriptorSerializer.Deserialize <GroupDescriptor>(groupBy));

                var aggregates = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Aggregates));

                command.Aggregates.AddRange(GridDescriptorSerializer.Deserialize <AggregateDescriptor>(aggregates));

                filterContext.ActionParameters[ActionParameterName] = command;
            }
        }
        public void Should_deserialize_empty_list()
        {
            var result = GridDescriptorSerializer.Deserialize <SortDescriptor>("");

            result.Count.ShouldEqual(0);
        }
        public void Should_return_tilde_if_no_descriptor_is_supplied()
        {
            var result = GridDescriptorSerializer.Serialize(new IDescriptor[0]);

            result.ShouldEqual("~");
        }