283 lines
15 KiB
JavaScript
283 lines
15 KiB
JavaScript
/**
|
|
* Kendo UI v2016.1.226 (http://www.telerik.com/kendo-ui)
|
|
* Copyright 2016 Telerik AD. All rights reserved.
|
|
*
|
|
* Kendo UI commercial licenses may be obtained at
|
|
* http://www.telerik.com/purchase/license-agreement/kendo-ui-complete
|
|
* If you do not own a commercial license, this file shall be governed by the trial license terms.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
(function (f, define) {
|
|
define('kendo.data.odata', ['kendo.core'], f);
|
|
}(function () {
|
|
var __meta__ = {
|
|
id: 'data.odata',
|
|
name: 'OData',
|
|
category: 'framework',
|
|
depends: ['core'],
|
|
hidden: true
|
|
};
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, extend = $.extend, odataFilters = {
|
|
eq: 'eq',
|
|
neq: 'ne',
|
|
gt: 'gt',
|
|
gte: 'ge',
|
|
lt: 'lt',
|
|
lte: 'le',
|
|
contains: 'substringof',
|
|
doesnotcontain: 'substringof',
|
|
endswith: 'endswith',
|
|
startswith: 'startswith',
|
|
isnull: 'eq',
|
|
isnotnull: 'ne',
|
|
isempty: 'eq',
|
|
isnotempty: 'ne'
|
|
}, odataFiltersVersionFour = extend({}, odataFilters, { contains: 'contains' }), mappers = {
|
|
pageSize: $.noop,
|
|
page: $.noop,
|
|
filter: function (params, filter, useVersionFour) {
|
|
if (filter) {
|
|
filter = toOdataFilter(filter, useVersionFour);
|
|
if (filter) {
|
|
params.$filter = filter;
|
|
}
|
|
}
|
|
},
|
|
sort: function (params, orderby) {
|
|
var expr = $.map(orderby, function (value) {
|
|
var order = value.field.replace(/\./g, '/');
|
|
if (value.dir === 'desc') {
|
|
order += ' desc';
|
|
}
|
|
return order;
|
|
}).join(',');
|
|
if (expr) {
|
|
params.$orderby = expr;
|
|
}
|
|
},
|
|
skip: function (params, skip) {
|
|
if (skip) {
|
|
params.$skip = skip;
|
|
}
|
|
},
|
|
take: function (params, take) {
|
|
if (take) {
|
|
params.$top = take;
|
|
}
|
|
}
|
|
}, defaultDataType = { read: { dataType: 'jsonp' } };
|
|
function toOdataFilter(filter, useOdataFour) {
|
|
var result = [], logic = filter.logic || 'and', idx, length, field, type, format, operator, value, ignoreCase, filters = filter.filters;
|
|
for (idx = 0, length = filters.length; idx < length; idx++) {
|
|
filter = filters[idx];
|
|
field = filter.field;
|
|
value = filter.value;
|
|
operator = filter.operator;
|
|
if (filter.filters) {
|
|
filter = toOdataFilter(filter, useOdataFour);
|
|
} else {
|
|
ignoreCase = filter.ignoreCase;
|
|
field = field.replace(/\./g, '/');
|
|
filter = odataFilters[operator];
|
|
if (useOdataFour) {
|
|
filter = odataFiltersVersionFour[operator];
|
|
}
|
|
if (operator === 'isnull' || operator === 'isnotnull') {
|
|
filter = kendo.format('{0} {1} null', field, filter);
|
|
} else if (operator === 'isempty' || operator === 'isnotempty') {
|
|
filter = kendo.format('{0} {1} \'\'', field, filter);
|
|
} else if (filter && value !== undefined) {
|
|
type = $.type(value);
|
|
if (type === 'string') {
|
|
format = '\'{1}\'';
|
|
value = value.replace(/'/g, '\'\'');
|
|
if (ignoreCase === true) {
|
|
field = 'tolower(' + field + ')';
|
|
}
|
|
} else if (type === 'date') {
|
|
if (useOdataFour) {
|
|
format = '{1:yyyy-MM-ddTHH:mm:ss+00:00}';
|
|
} else {
|
|
format = 'datetime\'{1:yyyy-MM-ddTHH:mm:ss}\'';
|
|
}
|
|
} else {
|
|
format = '{1}';
|
|
}
|
|
if (filter.length > 3) {
|
|
if (filter !== 'substringof') {
|
|
format = '{0}({2},' + format + ')';
|
|
} else {
|
|
format = '{0}(' + format + ',{2})';
|
|
if (operator === 'doesnotcontain') {
|
|
if (useOdataFour) {
|
|
format = '{0}({2},\'{1}\') eq -1';
|
|
filter = 'indexof';
|
|
} else {
|
|
format += ' eq false';
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
format = '{2} {0} ' + format;
|
|
}
|
|
filter = kendo.format(format, filter, value, field);
|
|
}
|
|
}
|
|
result.push(filter);
|
|
}
|
|
filter = result.join(' ' + logic + ' ');
|
|
if (result.length > 1) {
|
|
filter = '(' + filter + ')';
|
|
}
|
|
return filter;
|
|
}
|
|
function stripMetadata(obj) {
|
|
for (var name in obj) {
|
|
if (name.indexOf('@odata') === 0) {
|
|
delete obj[name];
|
|
}
|
|
}
|
|
}
|
|
extend(true, kendo.data, {
|
|
schemas: {
|
|
odata: {
|
|
type: 'json',
|
|
data: function (data) {
|
|
return data.d.results || [data.d];
|
|
},
|
|
total: 'd.__count'
|
|
}
|
|
},
|
|
transports: {
|
|
odata: {
|
|
read: {
|
|
cache: true,
|
|
dataType: 'jsonp',
|
|
jsonp: '$callback'
|
|
},
|
|
update: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
contentType: 'application/json',
|
|
type: 'PUT'
|
|
},
|
|
create: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
contentType: 'application/json',
|
|
type: 'POST'
|
|
},
|
|
destroy: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
type: 'DELETE'
|
|
},
|
|
parameterMap: function (options, type, useVersionFour) {
|
|
var params, value, option, dataType;
|
|
options = options || {};
|
|
type = type || 'read';
|
|
dataType = (this.options || defaultDataType)[type];
|
|
dataType = dataType ? dataType.dataType : 'json';
|
|
if (type === 'read') {
|
|
params = { $inlinecount: 'allpages' };
|
|
if (dataType != 'json') {
|
|
params.$format = 'json';
|
|
}
|
|
for (option in options) {
|
|
if (mappers[option]) {
|
|
mappers[option](params, options[option], useVersionFour);
|
|
} else {
|
|
params[option] = options[option];
|
|
}
|
|
}
|
|
} else {
|
|
if (dataType !== 'json') {
|
|
throw new Error('Only json dataType can be used for ' + type + ' operation.');
|
|
}
|
|
if (type !== 'destroy') {
|
|
for (option in options) {
|
|
value = options[option];
|
|
if (typeof value === 'number') {
|
|
options[option] = value + '';
|
|
}
|
|
}
|
|
params = kendo.stringify(options);
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
extend(true, kendo.data, {
|
|
schemas: {
|
|
'odata-v4': {
|
|
type: 'json',
|
|
data: function (data) {
|
|
data = $.extend({}, data);
|
|
stripMetadata(data);
|
|
if (data.value) {
|
|
return data.value;
|
|
}
|
|
return [data];
|
|
},
|
|
total: function (data) {
|
|
return data['@odata.count'];
|
|
}
|
|
}
|
|
},
|
|
transports: {
|
|
'odata-v4': {
|
|
read: {
|
|
cache: true,
|
|
dataType: 'json'
|
|
},
|
|
update: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
contentType: 'application/json;IEEE754Compatible=true',
|
|
type: 'PUT'
|
|
},
|
|
create: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
contentType: 'application/json;IEEE754Compatible=true',
|
|
type: 'POST'
|
|
},
|
|
destroy: {
|
|
cache: true,
|
|
dataType: 'json',
|
|
type: 'DELETE'
|
|
},
|
|
parameterMap: function (options, type) {
|
|
var result = kendo.data.transports.odata.parameterMap(options, type, true);
|
|
if (type == 'read') {
|
|
result.$count = true;
|
|
delete result.$inlinecount;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}(window.kendo.jQuery));
|
|
return window.kendo;
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
})); |