722 lines
No EOL
34 KiB
JavaScript
722 lines
No EOL
34 KiB
JavaScript
/**
|
|
* Kendo UI v2016.1.420 (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('aspnetmvc/kendo.data.aspnetmvc', [
|
|
'kendo.data',
|
|
'kendo.combobox',
|
|
'kendo.multiselect',
|
|
'kendo.validator'
|
|
], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, escapeQuoteRegExp = /'/gi, extend = $.extend, isArray = $.isArray, isPlainObject = $.isPlainObject, POINT = '.';
|
|
function parameterMap(options, operation, serializationOptions) {
|
|
var result = {};
|
|
if (options.sort) {
|
|
result[this.options.prefix + 'sort'] = $.map(options.sort, function (sort) {
|
|
return sort.field + '-' + sort.dir;
|
|
}).join('~');
|
|
delete options.sort;
|
|
} else {
|
|
result[this.options.prefix + 'sort'] = '';
|
|
}
|
|
if (options.page) {
|
|
result[this.options.prefix + 'page'] = options.page;
|
|
delete options.page;
|
|
}
|
|
if (options.pageSize) {
|
|
result[this.options.prefix + 'pageSize'] = options.pageSize;
|
|
delete options.pageSize;
|
|
}
|
|
if (options.group) {
|
|
result[this.options.prefix + 'group'] = $.map(options.group, function (group) {
|
|
return group.field + '-' + group.dir;
|
|
}).join('~');
|
|
delete options.group;
|
|
} else {
|
|
result[this.options.prefix + 'group'] = '';
|
|
}
|
|
if (options.aggregate) {
|
|
result[this.options.prefix + 'aggregate'] = $.map(options.aggregate, function (aggregate) {
|
|
return aggregate.field + '-' + aggregate.aggregate;
|
|
}).join('~');
|
|
delete options.aggregate;
|
|
}
|
|
if (options.filter) {
|
|
result[this.options.prefix + 'filter'] = serializeFilter(options.filter, serializationOptions.encode);
|
|
delete options.filter;
|
|
} else {
|
|
result[this.options.prefix + 'filter'] = '';
|
|
delete options.filter;
|
|
}
|
|
delete options.take;
|
|
delete options.skip;
|
|
var serializer = new Serializer(serializationOptions);
|
|
serializer.serialize(result, options, '');
|
|
return result;
|
|
}
|
|
var Serializer = function (options) {
|
|
options = options || {};
|
|
this.culture = options.culture || kendo.culture();
|
|
this.stringifyDates = options.stringifyDates;
|
|
this.decimalSeparator = this.culture.numberFormat[POINT];
|
|
};
|
|
Serializer.prototype = Serializer.fn = {
|
|
serialize: function (result, data, prefix) {
|
|
var valuePrefix;
|
|
for (var key in data) {
|
|
valuePrefix = prefix ? prefix + '.' + key : key;
|
|
this.serializeField(result, data[key], data, key, valuePrefix);
|
|
}
|
|
},
|
|
serializeField: function (result, value, data, key, prefix) {
|
|
if (isArray(value)) {
|
|
this.serializeArray(result, value, prefix);
|
|
} else if (isPlainObject(value)) {
|
|
this.serialize(result, value, prefix);
|
|
} else {
|
|
if (result[prefix] === undefined) {
|
|
result[prefix] = data[key] = this.serializeValue(value);
|
|
}
|
|
}
|
|
},
|
|
serializeArray: function (result, data, prefix) {
|
|
var value, key, valuePrefix;
|
|
for (var sourceIndex = 0, destinationIndex = 0; sourceIndex < data.length; sourceIndex++) {
|
|
value = data[sourceIndex];
|
|
key = '[' + destinationIndex + ']';
|
|
valuePrefix = prefix + key;
|
|
this.serializeField(result, value, data, key, valuePrefix);
|
|
destinationIndex++;
|
|
}
|
|
},
|
|
serializeValue: function (value) {
|
|
if (value instanceof Date) {
|
|
if (this.stringifyDates) {
|
|
value = kendo.stringify(value).replace(/"/g, '');
|
|
} else {
|
|
value = kendo.toString(value, 'G', this.culture.name);
|
|
}
|
|
} else if (typeof value === 'number') {
|
|
value = value.toString().replace(POINT, this.decimalSeparator);
|
|
}
|
|
return value;
|
|
}
|
|
};
|
|
function serializeFilter(filter, encode) {
|
|
if (filter.filters) {
|
|
return $.map(filter.filters, function (f) {
|
|
var hasChildren = f.filters && f.filters.length > 1, result = serializeFilter(f, encode);
|
|
if (result && hasChildren) {
|
|
result = '(' + result + ')';
|
|
}
|
|
return result;
|
|
}).join('~' + filter.logic + '~');
|
|
}
|
|
if (filter.field) {
|
|
return filter.field + '~' + filter.operator + '~' + encodeFilterValue(filter.value, encode);
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
function encodeFilterValue(value, encode) {
|
|
if (typeof value === 'string') {
|
|
if (value.indexOf('Date(') > -1) {
|
|
value = new Date(parseInt(value.replace(/^\/Date\((.*?)\)\/$/, '$1'), 10));
|
|
} else {
|
|
value = value.replace(escapeQuoteRegExp, '\'\'');
|
|
if (encode) {
|
|
value = encodeURIComponent(value);
|
|
}
|
|
return '\'' + value + '\'';
|
|
}
|
|
}
|
|
if (value && value.getTime) {
|
|
return 'datetime\'' + kendo.format('{0:yyyy-MM-ddTHH-mm-ss}', value) + '\'';
|
|
}
|
|
return value;
|
|
}
|
|
function valueOrDefault(value, defaultValue) {
|
|
return typeof value !== 'undefined' ? value : defaultValue;
|
|
}
|
|
function translateGroup(group) {
|
|
var hasSubgroups = group.HasSubgroups || group.hasSubgroups || false;
|
|
var items = group.Items || group.items;
|
|
return {
|
|
value: valueOrDefault(group.Key, valueOrDefault(group.key, group.value)),
|
|
field: group.Member || group.member || group.field,
|
|
hasSubgroups: hasSubgroups,
|
|
aggregates: translateAggregate(group.Aggregates || group.aggregates),
|
|
items: hasSubgroups ? $.map(items, translateGroup) : items
|
|
};
|
|
}
|
|
function translateAggregateResults(aggregate) {
|
|
var obj = {};
|
|
obj[aggregate.AggregateMethodName.toLowerCase()] = aggregate.Value;
|
|
return obj;
|
|
}
|
|
function translateAggregate(aggregates) {
|
|
var functionResult = {}, key, functionName, aggregate;
|
|
for (key in aggregates) {
|
|
functionResult = {};
|
|
aggregate = aggregates[key];
|
|
for (functionName in aggregate) {
|
|
functionResult[functionName.toLowerCase()] = aggregate[functionName];
|
|
}
|
|
aggregates[key] = functionResult;
|
|
}
|
|
return aggregates;
|
|
}
|
|
function convertAggregates(aggregates) {
|
|
var idx, length, aggregate;
|
|
var result = {};
|
|
for (idx = 0, length = aggregates.length; idx < length; idx++) {
|
|
aggregate = aggregates[idx];
|
|
result[aggregate.Member] = extend(true, result[aggregate.Member], translateAggregateResults(aggregate));
|
|
}
|
|
return result;
|
|
}
|
|
extend(true, kendo.data, {
|
|
schemas: {
|
|
'aspnetmvc-ajax': {
|
|
groups: function (data) {
|
|
return $.map(this._dataAccessFunction(data), translateGroup);
|
|
},
|
|
aggregates: function (data) {
|
|
data = data.d || data;
|
|
var aggregates = data.AggregateResults || [];
|
|
if (!$.isArray(aggregates)) {
|
|
for (var key in aggregates) {
|
|
aggregates[key] = convertAggregates(aggregates[key]);
|
|
}
|
|
return aggregates;
|
|
}
|
|
return convertAggregates(aggregates);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
extend(true, kendo.data, {
|
|
transports: {
|
|
'aspnetmvc-ajax': kendo.data.RemoteTransport.extend({
|
|
init: function (options) {
|
|
var that = this, stringifyDates = (options || {}).stringifyDates;
|
|
kendo.data.RemoteTransport.fn.init.call(this, extend(true, {}, this.options, options, {
|
|
parameterMap: function (options, operation) {
|
|
return parameterMap.call(that, options, operation, {
|
|
encode: false,
|
|
stringifyDates: stringifyDates
|
|
});
|
|
}
|
|
}));
|
|
},
|
|
read: function (options) {
|
|
var data = this.options.data, url = this.options.read.url;
|
|
if (isPlainObject(data)) {
|
|
if (url) {
|
|
this.options.data = null;
|
|
}
|
|
if (!data.Data.length && url) {
|
|
kendo.data.RemoteTransport.fn.read.call(this, options);
|
|
} else {
|
|
options.success(data);
|
|
}
|
|
} else {
|
|
kendo.data.RemoteTransport.fn.read.call(this, options);
|
|
}
|
|
},
|
|
options: {
|
|
read: { type: 'POST' },
|
|
update: { type: 'POST' },
|
|
create: { type: 'POST' },
|
|
destroy: { type: 'POST' },
|
|
parameterMap: parameterMap,
|
|
prefix: ''
|
|
}
|
|
})
|
|
}
|
|
});
|
|
extend(true, kendo.data, { schemas: { 'webapi': kendo.data.schemas['aspnetmvc-ajax'] } });
|
|
extend(true, kendo.data, {
|
|
transports: {
|
|
'webapi': kendo.data.RemoteTransport.extend({
|
|
init: function (options) {
|
|
var that = this;
|
|
var stringifyDates = (options || {}).stringifyDates;
|
|
if (options.update) {
|
|
var updateUrl = typeof options.update === 'string' ? options.update : options.update.url;
|
|
options.update = extend(options.update, {
|
|
url: function (data) {
|
|
return kendo.format(updateUrl, data[options.idField]);
|
|
}
|
|
});
|
|
}
|
|
if (options.destroy) {
|
|
var destroyUrl = typeof options.destroy === 'string' ? options.destroy : options.destroy.url;
|
|
options.destroy = extend(options.destroy, {
|
|
url: function (data) {
|
|
return kendo.format(destroyUrl, data[options.idField]);
|
|
}
|
|
});
|
|
}
|
|
if (options.create && typeof options.create === 'string') {
|
|
options.create = { url: options.create };
|
|
}
|
|
kendo.data.RemoteTransport.fn.init.call(this, extend(true, {}, this.options, options, {
|
|
parameterMap: function (options, operation) {
|
|
return parameterMap.call(that, options, operation, {
|
|
encode: false,
|
|
stringifyDates: stringifyDates,
|
|
culture: kendo.cultures['en-US']
|
|
});
|
|
}
|
|
}));
|
|
},
|
|
read: function (options) {
|
|
var data = this.options.data, url = this.options.read.url;
|
|
if (isPlainObject(data)) {
|
|
if (url) {
|
|
this.options.data = null;
|
|
}
|
|
if (!data.Data.length && url) {
|
|
kendo.data.RemoteTransport.fn.read.call(this, options);
|
|
} else {
|
|
options.success(data);
|
|
}
|
|
} else {
|
|
kendo.data.RemoteTransport.fn.read.call(this, options);
|
|
}
|
|
},
|
|
options: {
|
|
read: { type: 'GET' },
|
|
update: { type: 'PUT' },
|
|
create: { type: 'POST' },
|
|
destroy: { type: 'DELETE' },
|
|
parameterMap: parameterMap,
|
|
prefix: ''
|
|
}
|
|
})
|
|
}
|
|
});
|
|
extend(true, kendo.data, {
|
|
transports: {
|
|
'aspnetmvc-server': kendo.data.RemoteTransport.extend({
|
|
init: function (options) {
|
|
var that = this;
|
|
kendo.data.RemoteTransport.fn.init.call(this, extend(options, {
|
|
parameterMap: function (options, operation) {
|
|
return parameterMap.call(that, options, operation, { encode: true });
|
|
}
|
|
}));
|
|
},
|
|
read: function (options) {
|
|
var url, prefix = this.options.prefix, params = [
|
|
prefix + 'sort',
|
|
prefix + 'page',
|
|
prefix + 'pageSize',
|
|
prefix + 'group',
|
|
prefix + 'aggregate',
|
|
prefix + 'filter'
|
|
], regExp = new RegExp('(' + params.join('|') + ')=[^&]*&?', 'g'), query;
|
|
query = location.search.replace(regExp, '').replace('?', '');
|
|
if (query.length && !/&$/.test(query)) {
|
|
query += '&';
|
|
}
|
|
options = this.setup(options, 'read');
|
|
url = options.url;
|
|
if (url.indexOf('?') >= 0) {
|
|
query = query.replace(/(.*?=.*?)&/g, function (match) {
|
|
if (url.indexOf(match.substr(0, match.indexOf('='))) >= 0) {
|
|
return '';
|
|
}
|
|
return match;
|
|
});
|
|
url += '&' + query;
|
|
} else {
|
|
url += '?' + query;
|
|
}
|
|
url += $.map(options.data, function (value, key) {
|
|
return key + '=' + value;
|
|
}).join('&');
|
|
location.href = url;
|
|
}
|
|
})
|
|
}
|
|
});
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('aspnetmvc/kendo.combobox.aspnetmvc', ['aspnetmvc/kendo.data.aspnetmvc'], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, ui = kendo.ui;
|
|
if (ui && ui.ComboBox) {
|
|
ui.ComboBox.requestData = function (selector) {
|
|
var combobox = $(selector).data('kendoComboBox');
|
|
if (!combobox) {
|
|
return;
|
|
}
|
|
var filter = combobox.dataSource.filter();
|
|
var value = combobox.input.val();
|
|
if (!filter || !filter.filters.length) {
|
|
value = '';
|
|
}
|
|
return { text: value };
|
|
};
|
|
}
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('aspnetmvc/kendo.dropdownlist.aspnetmvc', ['aspnetmvc/kendo.data.aspnetmvc'], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, ui = kendo.ui;
|
|
if (ui && ui.DropDownList) {
|
|
ui.DropDownList.requestData = function (selector) {
|
|
var dropdownlist = $(selector).data('kendoDropDownList');
|
|
if (!dropdownlist) {
|
|
return;
|
|
}
|
|
var filter = dropdownlist.dataSource.filter();
|
|
var filterInput = dropdownlist.filterInput;
|
|
var value = filterInput ? filterInput.val() : '';
|
|
if (!filter || !filter.filters.length) {
|
|
value = '';
|
|
}
|
|
return { text: value };
|
|
};
|
|
}
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('aspnetmvc/kendo.multiselect.aspnetmvc', ['aspnetmvc/kendo.combobox.aspnetmvc'], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, ui = kendo.ui;
|
|
if (ui && ui.MultiSelect) {
|
|
ui.MultiSelect.requestData = function (selector) {
|
|
var multiselect = $(selector).data('kendoMultiSelect');
|
|
if (!multiselect) {
|
|
return;
|
|
}
|
|
var text = multiselect.input.val();
|
|
return { text: text !== multiselect.options.placeholder ? text : '' };
|
|
};
|
|
}
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('aspnetmvc/kendo.imagebrowser.aspnetmvc', ['aspnetmvc/kendo.multiselect.aspnetmvc'], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var kendo = window.kendo, extend = $.extend, isFunction = $.isFunction;
|
|
extend(true, kendo.data, {
|
|
schemas: {
|
|
'imagebrowser-aspnetmvc': {
|
|
data: function (data) {
|
|
return data || [];
|
|
},
|
|
model: {
|
|
id: 'name',
|
|
fields: {
|
|
name: { field: 'Name' },
|
|
size: { field: 'Size' },
|
|
type: {
|
|
field: 'EntryType',
|
|
parse: function (value) {
|
|
return value == 0 ? 'f' : 'd';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
extend(true, kendo.data, { schemas: { 'filebrowser-aspnetmvc': kendo.data.schemas['imagebrowser-aspnetmvc'] } });
|
|
extend(true, kendo.data, {
|
|
transports: {
|
|
'imagebrowser-aspnetmvc': kendo.data.RemoteTransport.extend({
|
|
init: function (options) {
|
|
kendo.data.RemoteTransport.fn.init.call(this, $.extend(true, {}, this.options, options));
|
|
},
|
|
_call: function (type, options) {
|
|
options.data = $.extend({}, options.data, { path: this.options.path() });
|
|
if (isFunction(this.options[type])) {
|
|
this.options[type].call(this, options);
|
|
} else {
|
|
kendo.data.RemoteTransport.fn[type].call(this, options);
|
|
}
|
|
},
|
|
read: function (options) {
|
|
this._call('read', options);
|
|
},
|
|
create: function (options) {
|
|
this._call('create', options);
|
|
},
|
|
destroy: function (options) {
|
|
this._call('destroy', options);
|
|
},
|
|
update: function () {
|
|
},
|
|
options: {
|
|
read: { type: 'POST' },
|
|
update: { type: 'POST' },
|
|
create: { type: 'POST' },
|
|
destroy: { type: 'POST' },
|
|
parameterMap: function (options, type) {
|
|
if (type != 'read') {
|
|
options.EntryType = options.EntryType === 'f' ? 0 : 1;
|
|
}
|
|
return options;
|
|
}
|
|
}
|
|
})
|
|
}
|
|
});
|
|
extend(true, kendo.data, { transports: { 'filebrowser-aspnetmvc': kendo.data.transports['imagebrowser-aspnetmvc'] } });
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('aspnetmvc/kendo.validator.aspnetmvc', ['aspnetmvc/kendo.imagebrowser.aspnetmvc'], f);
|
|
}(function () {
|
|
(function ($, undefined) {
|
|
var nameSpecialCharRegExp = /("|\%|'|\[|\]|\$|\.|\,|\:|\;|\+|\*|\&|\!|\#|\(|\)|<|>|\=|\?|\@|\^|\{|\}|\~|\/|\||`)/g;
|
|
function generateMessages() {
|
|
var name, messages = {};
|
|
for (name in validationRules) {
|
|
messages['mvc' + name] = createMessage(name);
|
|
}
|
|
return messages;
|
|
}
|
|
function generateRules() {
|
|
var name, rules = {};
|
|
for (name in validationRules) {
|
|
rules['mvc' + name] = createRule(name);
|
|
}
|
|
return rules;
|
|
}
|
|
function extractParams(input, ruleName) {
|
|
var params = {}, index, data = input.data(), length = ruleName.length, rule, key;
|
|
for (key in data) {
|
|
rule = key.toLowerCase();
|
|
index = rule.indexOf(ruleName);
|
|
if (index > -1) {
|
|
rule = rule.substring(index + length, key.length);
|
|
if (rule) {
|
|
params[rule] = data[key];
|
|
}
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
function rulesFromData(metadata) {
|
|
var idx, length, fields = metadata.Fields || [], rules = {};
|
|
for (idx = 0, length = fields.length; idx < length; idx++) {
|
|
$.extend(true, rules, rulesForField(fields[idx]));
|
|
}
|
|
return rules;
|
|
}
|
|
function rulesForField(field) {
|
|
var rules = {}, messages = {}, fieldName = field.FieldName, fieldRules = field.ValidationRules, validationType, validationParams, idx, length;
|
|
for (idx = 0, length = fieldRules.length; idx < length; idx++) {
|
|
validationType = fieldRules[idx].ValidationType;
|
|
validationParams = fieldRules[idx].ValidationParameters;
|
|
rules[fieldName + validationType] = createMetaRule(fieldName, validationType, validationParams);
|
|
messages[fieldName + validationType] = createMetaMessage(fieldRules[idx].ErrorMessage);
|
|
}
|
|
return {
|
|
rules: rules,
|
|
messages: messages
|
|
};
|
|
}
|
|
function createMessage(rule) {
|
|
return function (input) {
|
|
return input.attr('data-val-' + rule);
|
|
};
|
|
}
|
|
function createRule(ruleName) {
|
|
return function (input) {
|
|
if (input.filter('[data-val-' + ruleName + ']').length) {
|
|
return validationRules[ruleName](input, extractParams(input, ruleName));
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
function createMetaMessage(message) {
|
|
return function () {
|
|
return message;
|
|
};
|
|
}
|
|
function createMetaRule(fieldName, type, params) {
|
|
return function (input) {
|
|
if (input.filter('[name=' + fieldName + ']').length) {
|
|
return validationRules[type](input, params);
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
function patternMatcher(value, pattern) {
|
|
if (typeof pattern === 'string') {
|
|
pattern = new RegExp('^(?:' + pattern + ')$');
|
|
}
|
|
return pattern.test(value);
|
|
}
|
|
var validationRules = {
|
|
required: function (input) {
|
|
var value = input.val(), checkbox = input.filter('[type=checkbox]'), name;
|
|
if (checkbox.length) {
|
|
name = checkbox[0].name.replace(nameSpecialCharRegExp, '\\$1');
|
|
var hiddenSelector = 'input:hidden[name=\'' + name + '\']';
|
|
var hidden = checkbox.next(hiddenSelector);
|
|
if (!hidden.length) {
|
|
hidden = checkbox.next('label.k-checkbox-label').next(hiddenSelector);
|
|
}
|
|
if (hidden.length) {
|
|
value = hidden.val();
|
|
} else {
|
|
value = input.attr('checked') === 'checked';
|
|
}
|
|
}
|
|
return !(value === '' || !value);
|
|
},
|
|
number: function (input) {
|
|
return input.val() === '' || input.val() == null || kendo.parseFloat(input.val()) !== null;
|
|
},
|
|
regex: function (input, params) {
|
|
if (input.val() !== '') {
|
|
return patternMatcher(input.val(), params.pattern);
|
|
}
|
|
return true;
|
|
},
|
|
range: function (input, params) {
|
|
if (input.val() !== '') {
|
|
return this.min(input, params) && this.max(input, params);
|
|
}
|
|
return true;
|
|
},
|
|
min: function (input, params) {
|
|
var min = parseFloat(params.min) || 0, val = kendo.parseFloat(input.val());
|
|
return min <= val;
|
|
},
|
|
max: function (input, params) {
|
|
var max = parseFloat(params.max) || 0, val = kendo.parseFloat(input.val());
|
|
return val <= max;
|
|
},
|
|
date: function (input) {
|
|
return input.val() === '' || kendo.parseDate(input.val()) !== null;
|
|
},
|
|
length: function (input, params) {
|
|
if (input.val() !== '') {
|
|
var len = $.trim(input.val()).length;
|
|
return (!params.min || len >= (params.min || 0)) && (!params.max || len <= (params.max || 0));
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
$.extend(true, kendo.ui.validator, {
|
|
rules: generateRules(),
|
|
messages: generateMessages(),
|
|
messageLocators: {
|
|
mvcLocator: {
|
|
locate: function (element, fieldName) {
|
|
fieldName = fieldName.replace(nameSpecialCharRegExp, '\\$1');
|
|
return element.find('.field-validation-valid[data-valmsg-for=\'' + fieldName + '\'], .field-validation-error[data-valmsg-for=\'' + fieldName + '\']');
|
|
},
|
|
decorate: function (message, fieldName) {
|
|
message.addClass('field-validation-error').attr('data-valmsg-for', fieldName || '');
|
|
}
|
|
},
|
|
mvcMetadataLocator: {
|
|
locate: function (element, fieldName) {
|
|
fieldName = fieldName.replace(nameSpecialCharRegExp, '\\$1');
|
|
return element.find('#' + fieldName + '_validationMessage.field-validation-valid');
|
|
},
|
|
decorate: function (message, fieldName) {
|
|
message.addClass('field-validation-error').attr('id', fieldName + '_validationMessage');
|
|
}
|
|
}
|
|
},
|
|
ruleResolvers: {
|
|
mvcMetaDataResolver: {
|
|
resolve: function (element) {
|
|
var metadata = window.mvcClientValidationMetadata || [];
|
|
if (metadata.length) {
|
|
element = $(element);
|
|
for (var idx = 0; idx < metadata.length; idx++) {
|
|
if (metadata[idx].FormId == element.attr('id')) {
|
|
return rulesFromData(metadata[idx]);
|
|
}
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}(window.kendo.jQuery));
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
}));
|
|
(function (f, define) {
|
|
define('kendo.aspnetmvc', [
|
|
'kendo.data',
|
|
'kendo.combobox',
|
|
'kendo.dropdownlist',
|
|
'kendo.multiselect',
|
|
'kendo.validator',
|
|
'aspnetmvc/kendo.data.aspnetmvc',
|
|
'aspnetmvc/kendo.combobox.aspnetmvc',
|
|
'aspnetmvc/kendo.dropdownlist.aspnetmvc',
|
|
'aspnetmvc/kendo.multiselect.aspnetmvc',
|
|
'aspnetmvc/kendo.imagebrowser.aspnetmvc',
|
|
'aspnetmvc/kendo.validator.aspnetmvc'
|
|
], f);
|
|
}(function () {
|
|
var __meta__ = {
|
|
id: 'aspnetmvc',
|
|
name: 'ASP.NET MVC',
|
|
category: 'wrappers',
|
|
description: 'Scripts required by Telerik UI for ASP.NET MVC',
|
|
depends: [
|
|
'data',
|
|
'combobox',
|
|
'dropdownlist',
|
|
'multiselect',
|
|
'validator'
|
|
]
|
|
};
|
|
}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {
|
|
(a3 || a2)();
|
|
})); |