It should be possible to specify a validate() method on each viewmodel that gets triggered each time a new model value is .set(). In case of an unsuccessful validation an error event or binding could be triggered.

Like many other Kendo components, the treeview is not mature enough to be considered to display dynamic hierarchical data in a LOB application (features limit its use to a static web site).

I can only recommend to urgently add databinding to a datasource. Then you will have to consider loading the dataSource on demand. See http://demos.telerik.com/aspnet-mvc/treeview/ajaxloading

Add full support for syncing of changes made to the HierarchicalDataSource in a TreeView and Grid. Currently, sync() does not perform the correct sequence of CRUD operations that represent the changes made to the data source or control.

See this forum post for details: http://www.kendoui.com/forums/framework/mvvm/getting-access-to-array-index-while-binding-an-array-source.aspx

Currently Kendo MVVM only supports a very simple binding syntax, one view attribute can be bound to one model attribute. I'd like to have real javascript expressions or function calls in bindings to support more complex scenarios, e.g. you only want to show the "submit" button in a form when all fields have been completed.

KnockOutJS supports this: http://knockoutjs.com/documentation/visible-binding.html#note_using_functions_and_expressions_to_control_element_visibility

With the current hierchical datasource, a simple file system type use case can not be supported... or an email service with nested folders.  e.g. a folder might have subfolders OR files... or and email folder might have emails OR subfolders.  Its is rare that you would ever know how many nestings there are ahead of time.


If the Node object provided some form of a type field/string/object/function to describe the corresponding model that would be very valuable. the library could instantiate the appropriate type at run time. This would also be useful for templating where a simple switch statement could be used to present templates based on the type. I imagine there would be challenges with the datasource fetch as there could be multiple service endpoints a cross the children of a node based on the number of child types. You might consider solving this by changes children from an array to an array of arrays. And you could populated children with the number o possible types, each type having its own endpoint. Anyway it's a pretty common use case so please forward to product management for roadmap consideration. I'd probably consider that #1 on my list.

I would like to be able to dynamically update the text in my button by binding to a viewmodel.

Thanks

Create a datasource with a schema that has number fields.

Try to filter by one of these fields using a "contains" and an ignorecase and kendoui creates an expression like

(function(d, __f, __o) {
return ((d.MyNumber || '').toLowerCase().indexOf('12') >= 0)
})

this errors because the number does not have a toLowerCase() method.

Our code is generic and we do not want to have to change ignorecase depending on the data-type, as sometime the filter will be on a string and sometimes on a number. Can a fix be put in place to allow this combination to run without error.

Thanks.

In the context of MVVM bindings, it would be great to have a way to evaluate certain conditions/expressions, especially within template bindings, by "navigating" to other properties of the ViewModel, or to other properties of the currently iterated object.

For example:

<ul data-role="listview" data-bind="source: anObservableObject" data-template="some-template"></ul>
<script id="some-template" type="text/x-kendo-template">
    <li data-bind="text: whatever, visible: $source.someProperty == $data.otherProperty"></li>
</script>

In this example, $data refers to the current iteration data, and $source refers to the source. So the visible binding would be true/false according to the expression which would evaluate an arbitrary property on the source and an arbitrary property on the iterated object.

This is similar to Knockout's mechanism and it allows for greater flexibility within templates.

Signalr is a push technology, but your current implementation is not robust enough to allow data from an outside source to be pushed to your grid. A stop measure for this would be to include the ability to use a function in addition to a string for the server read function. This would enable a developer to chain a server call to refresh data when data changes are coming from a source outside your grids. A full implementation of signalr would be to code your grid to accept a signalr call from the server hub that directly updates client data from any source, as long as it conforms to the model for the grid. This could be possibly done through the use of a signalr grid group, that the server could push to. This group should be a group of one that maps to a specific grid. This would also allow multiple grids on a page/form to be independently updated. Currently your signalr grids interfere with each other if the calls are running at the same time on that same page/form, both synchronously and asynchronously. 

We use the new version of SignalR which is 2.2.3 currently and it seems the Kendo DataSource cannot bind to it. It would be awesome if Kendo supported it. 
Here is a link: https://www.nuget.org/packages/Microsoft.AspNet.SignalR.Core/

For easy using local arrays with kendo DataSource it would be good to have a functionallity to assign an array (kendo.obersvableHierarchy) without configure transport for CRUD operations.
When using Kendo MVVM it's easy then to define a grid the columns and field, and bind only the observable array as datasource.

And it would be great to have the possibility to assing depended arrays as field in an array that will be used as datasource for a grid or dropdown. Then we can assing the depended array of a selected dataitem to another control. So there is an need to have a special datatype like "dependedArray" and changes to this depended array has no effect to all ohter controls that where the viewmodel was bound.
Then we have more time to develope business logic. 

Add functionality that will allow adding shared datasource to multiple components with individual filters.

This way we will be able to have one data source and multiple grids showing different part od data.

The DataSource Model including validation should come from the server and not defined within javascript where possible.  There should be two primary ways to populate the model using the DataSource widget.

1.) Retrieved from the DataSource call itself as a JSON property off of the data call.  You should be able to define a schema: { parseModel: function(data) { return data.model } } to retrieve the model directly from the data call.

2.) You should be able to specify the schema: { model: new DataSource({ ... }) }.  The model itself should be DataSourcable so you can retrieve (with ETag/Last-Modified and Cache-Control) the model as a separate request alongside the data.

Given that you should be able to retrieve the model as a separate request,  you should be given the opportunity to augment/modify the model within the client side using something like schema: { changeModel: function(model) { // Supplement Model here
} }

As of today, it is possible to create custom "simple" bindings as per this code sample:

http://demos.kendoui.com/web/mvvm/custom.html

This works fine, but it would be appreciated to be able to create custom bindings with "complex" syntax, such as this:

data-bind="foo: {condition: somePropertyOnViewModel, option1: A, option2: B }"

When using aggregates, it should be possible to define your own aggregate function, or even set it globally for kendo, so it could be used in other places. i.e. 

currently you can only specify the function name like 'sum', 'avg', etc. with this idea you could give the whole function like function(arguments...) {}

Also from what I saw it would be nice to have the `functions` object from kendo.data.js accessible, so you could add your custom functions, like:
`kendo.data.aggregate_functions['median'] = function(arguments...) {}` 

When the grid is configured for working with UTC on the server-side, the value sent from the filter menu on the client-side would not be properly sent to the server. 

If the stringifyDates option of the transport of the data source is set, the value would still be sent in a localized date format without information for the time zone, for instance, GMT(+0300).

In case the value sent from the client is modified, the parameterMap would be called afterward and would override the modified value. 

Moreover, the Kendo UI Binder on the server-side is not configured to be working with dates that have additional data for the time zone appended to the end. Therefore, sending the modified data would not be parsed correctly and FormatException error would be thrown.

The DataSource schema must be given a total value in order to page correctly. However, DataSource expects this value to come from a response body field. In some cases, we must work with systems that return the total value as a custom field in the response header. We need a way to read custom response header values. 

Yes, the DataSource transport uses jQuery.ajax, so we can implement a custom complete function to read the response headers from the jqXHR. However, complete fires AFTER schema.total is set so it does no good.

Will you be doing something like KnockoutJS?

Visual Studio plugin to generate javascript proxy classes for communicating with web services. 

Normally in ASP.Net the .Net proxy classes would be generated for me, but since I am now moving towards building RIA applications most of the WS calls now take place client side. The process of manually setting up service calls is a bit cumbersome so if KendoUI could include a tool for this it would be great.