It would be good user interaction when multiple node selection is implemented.It saves lot of rework

http://odata.github.io/WebApi/#04-26-InOperator

OData v4 now supports the IN operator as a short hand for multiple or queries (as of http://docs.oasis-open.org/odata/new-in-odata/v4.01/cn01/new-in-odata-v4.01-cn01.html#_Toc485385090 ). This could help to change code such as:

var selectedStations = $("#cmbStations").data("kendoMultiSelect").dataItems();
            var stationIds = [];
            for (var i = 0; i < selectedStations.length; i++) {
                stationIds.push({
                    field: "StationId",
                    operator: "eq",
                    value: stationId
                });
            }
            dataSource.filter({
                logic: "or",
                filters: stationIds
            });

into a much cleaner:

var selectedStations = $("#cmbStations").data("kendoMultiSelect").dataItems();
            var stationIds = [];
            for (var i = 0; i < selectedStations.length; i++) {
                stationIds.push(selectedStations[i].StationId);
            }
            dataSource.filter({
                field: "StationId",
                operator: "in",
                value: stationId
            });

Excellent work, I think (one/two way) form data binding with JSON/XML serialization will be very helpful. Templates are good but need to support attribute based data binding expressions without templates.

If my callback takes 10ms or 300ms I still get the control whiting itself out and showing a loading animation.  Problem though is if it takes 10ms it looks like the control is flickering. 

Let me set a min duration before the animation shows up.  So I could say only show the loading animation if it's taking longer than 100ms.

Currently when I choose a column filter and click on the filter button, a request is sent to the server and data is bound. However, if I work with large data sources and I know in advance that I want to filter by FirstName and LastName, for example, I would like to choose both the filters first, and when filter settings are finalized, I would like to rebind the grid with a button click, for example.

This would enable to bind only once the grid, instead of n times, if the user chooses lazy filtering which would be very useful, especially in the case of large data sources

As discussed here:
http://www.kendoui.com/forums/framework/mvvm/min-max-bindings-for-datepicker-and-timepicker.aspx

Provide a way to bind the minimum and maximum dates to a model, so that changing the model changes the min and max dates. This would be useful in creating a date range selector where the start date must be prior to the end date.

Currently if i set filter on my remote data source it fetches the data immediately, so if i want a callback i have to call fetch which will talk to server again.
What be really good is to be able to set sorting/filter and receive a callback when data is retrieved from server. 
E.g.
dataSource.fetch({
  filter: {},
  sorting: {}
}) // returns a promise
  .done(function(e){})
  .fail(function(e){});

Would be good to have ability to to something like this on an observable object:
o.set({ a: 1 })
I.e. pass an object to the set function to update/add properties in o from that object.

As it stands only during a read the aggregate are fetched from the server via the dataSource. This is incomplete behavior. A grid should, if requested by the programmer,  fetch the aggregates on each update of a row in the grid. That way the aggregates will always reflect the sum(), etc.. correctly.

There are several undocumented methods on the data source which provide some really nice functionality. The DataSource is able to store multiple 'pages' of data in an internal collections of ranges that can be accessed and populated by the range() and prefetch() methods. It looks like this is used mostly to support virtual grid scrolling, but I have found it very useful for other applications where a data source uses server operations. This is a really great feature and I'd like to see it officially supported in the future!

I ran into this problem wherein I receive a 'Maximum stack size exceeded error' when I try to bind a collection with circular references  to kendo ui grids and data viz charts.  My Angular SPA is using breeze to fetch server-side entity models. As these are entity models, they do have circular references. I am also using the angular-kendo library for the directives.

Current fixes include manual removal of such entities from the collection. It would be great if the controls can handle such collections.

<span data-format="dd MMM yyyy" data-bind="text: Created"></span>

Spits out (as text inside the span)...
   Fri Aug 01 2014 01:00:00 GMT+0100 (GMT Daylight Time)

Whereas ...
<input class="k-input" data-bind="value: Created" data-format="dd MMM yyyy" data-role="datepicker">

Spits out "01 Aug 2014" in the editable field.

Feedback from telerik: "span doesn't have data-format support".

Databinding telerik obervables to templates appears to be working in a completely different way to binding to telerik controls, this is confusing and causes a lot of frustration.

var model = { any js object };
var component = $("anything");
kendo.bind(component, model);

This should result in the same output no matter what model is (datasource, observable, flat js object).

Using: 
   $("selector").kendoControl({ options }); 

should behave the same as:  
<div id="myThing" data-bind=" options " />

kendo.bind($("myThing"), model);

Currently kendo.DataSource.get() and kendo.Datasource.getByUid() methods are very slow in case there some non-trivial amount of data stored. Actually, these methods loop on all items in dataSource on each call.
Why not add index for id field? Indexed access can boost up many real-life scenarios.
I prepared following jsfiddle to demonstrate the slowness:
http://jsfiddle.net/terikon/eb3tsjzf/9/

Hi, I am using the AJAX data source for grid which is great since I don't have to requery for filter, sort, and paging functions.  However, if the grid could use this same datasource for the filter autocomplete feature, I would greatly appreciate it because right now the grid is re-hitting the datasource for this.

When using serverFiltering=true on a listview, if you type quickly 'abcd' the datasource.read is fired 4 consecutive times, making 4 consecutive server requests. There is no cap. 'abcd' can be typed within even 1 second, that will result in 4 server request per second. Now imagine 20 users at the same time typing to filter and each keystroke firing a server request is kind of an unnecessary overload.

It would be great to implement the "has" operator for OData V4 enum filter scenarios.

See http://www.telerik.com/forums/datasource---odata-v4---enums-not-supported-yet

Regards,
Kasimier Buchcik

Ignore language specific characters when filtering. Example: search phrase "Deja" should find word "Déjà".

JSON data sources should be nested rather than having to define and parse flat data structures.

We use a DataSource with a custom transport and read method to filter some data on the server.

return new kendo.data.DataSource({
    pageSize: 10,
    serverPaging: true,
    serverSorting: true,
    serverFiltering: true,
    type: "json",
    sort: {
      field: "name",
      dir: "asc"
    },
    transport: {
      read: function (options) {}....

As the user types we issue a read request but it would be nice to have a way to cancel the last read request with a method call (ie. abortRequest() or abortReadRequest() ). We can implement a work around as shown here https://dojo.telerik.com/@Dimitar-Goshev/IxaLUtIw but I think it would be reasonable feature to simply have this internalized into the DataSource code so that the abort logic is internal to the DataSource class.