/** * @author Ed Spencer * @class Ext.data.Store * @extends Ext.data.AbstractStore * * <p>The Store class encapsulates a client side cache of {@link Ext.data.Model Model} objects. Stores load * data via a {@link Ext.data.proxy.Proxy Proxy}, and also provide functions for {@link #sort sorting}, * {@link #filter filtering} and querying the {@link Ext.data.Model model} instances contained within it.</p> * * <p>Creating a Store is easy - we just tell it the Model and the Proxy to use to load and save its data:</p> * <pre><code> // Set up a {@link Ext.data.Model model} to use in our Store Ext.define('User', { extend: 'Ext.data.Model', fields: [ {name: 'firstName', type: 'string'}, {name: 'lastName', type: 'string'}, {name: 'age', type: 'int'}, {name: 'eyeColor', type: 'string'} ] }); var myStore = new Ext.data.Store({ model: 'User', proxy: { type: 'ajax', url : '/users.json', reader: { type: 'json', root: 'users' } }, autoLoad: true }); </code></pre> * <p>In the example above we configured an AJAX proxy to load data from the url '/users.json'. We told our Proxy * to use a {@link Ext.data.reader.Json JsonReader} to parse the response from the server into Model object - * {@link Ext.data.reader.Json see the docs on JsonReader} for details.</p> * * <p><u>Inline data</u></p> * * <p>Stores can also load data inline. Internally, Store converts each of the objects we pass in as {@link #data} * into Model instances:</p> * <pre><code> new Ext.data.Store({ model: 'User', data : [ {firstName: 'Ed', lastName: 'Spencer'}, {firstName: 'Tommy', lastName: 'Maintz'}, {firstName: 'Aaron', lastName: 'Conran'}, {firstName: 'Jamie', lastName: 'Avins'} ] }); </code></pre> * * <p>Loading inline data using the method above is great if the data is in the correct format already (e.g. it doesn't need * to be processed by a {@link Ext.data.reader.Reader reader}). If your inline data requires processing to decode the data structure, * use a {@link Ext.data.proxy.Memory MemoryProxy} instead (see the {@link Ext.data.proxy.Memory MemoryProxy} docs for an example).</p> * * <p>Additional data can also be loaded locally using {@link #add}.</p> * * <p><u>Loading Nested Data</u></p> * * <p>Applications often need to load sets of associated data - for example a CRM system might load a User and her Orders. * Instead of issuing an AJAX request for the User and a series of additional AJAX requests for each Order, we can load a nested dataset * and allow the Reader to automatically populate the associated models. Below is a brief example, see the {@link Ext.data.reader.Reader} intro * docs for a full explanation:</p> * <pre><code> var store = new Ext.data.Store({ autoLoad: true, model: "User", proxy: { type: 'ajax', url : 'users.json', reader: { type: 'json', root: 'users' } } }); </code></pre> * * <p>Which would consume a response like this:</p> * <pre><code> { "users": [ { "id": 1, "name": "Ed", "orders": [ { "id": 10, "total": 10.76, "status": "invoiced" }, { "id": 11, "total": 13.45, "status": "shipped" } ] } ] } </code></pre> * * <p>See the {@link Ext.data.reader.Reader} intro docs for a full explanation.</p> * * <p><u>Filtering and Sorting</u></p> * * <p>Stores can be sorted and filtered - in both cases either remotely or locally. The {@link #sorters} and {@link #filters} are * held inside {@link Ext.util.MixedCollection MixedCollection} instances to make them easy to manage. Usually it is sufficient to * either just specify sorters and filters in the Store configuration or call {@link #sort} or {@link #filter}: * <pre><code> var store = new Ext.data.Store({ model: 'User', sorters: [ { property : 'age', direction: 'DESC' }, { property : 'firstName', direction: 'ASC' } ], filters: [ { property: 'firstName', value : /Ed/ } ] }); </code></pre> * * <p>The new Store will keep the configured sorters and filters in the MixedCollection instances mentioned above. By default, sorting * and filtering are both performed locally by the Store - see {@link #remoteSort} and {@link #remoteFilter} to allow the server to * perform these operations instead.</p> * * <p>Filtering and sorting after the Store has been instantiated is also easy. Calling {@link #filter} adds another filter to the Store * and automatically filters the dataset (calling {@link #filter} with no arguments simply re-applies all existing filters). Note that by * default {@link #sortOnFilter} is set to true, which means that your sorters are automatically reapplied if using local sorting.</p> * <pre><code> store.filter('eyeColor', 'Brown'); </code></pre> * * <p>Change the sorting at any time by calling {@link #sort}:</p> * <pre><code> store.sort('height', 'ASC'); </code></pre> * * <p>Note that all existing sorters will be removed in favor of the new sorter data (if {@link #sort} is called with no arguments, * the existing sorters are just reapplied instead of being removed). To keep existing sorters and add new ones, just add them * to the MixedCollection:</p> * <pre><code> store.sorters.add(new Ext.util.Sorter({ property : 'shoeSize', direction: 'ASC' })); store.sort(); </code></pre> * * <p><u>Registering with StoreManager</u></p> * * <p>Any Store that is instantiated with a {@link #storeId} will automatically be registed with the {@link Ext.data.StoreManager StoreManager}. * This makes it easy to reuse the same store in multiple views:</p> * <pre><code> //this store can be used several times new Ext.data.Store({ model: 'User', storeId: 'usersStore' }); new Ext.List({ store: 'usersStore', //other config goes here }); new Ext.view.View({ store: 'usersStore', //other config goes here }); </code></pre> * * <p><u>Further Reading</u></p> * * <p>Stores are backed up by an ecosystem of classes that enables their operation. To gain a full understanding of these * pieces and how they fit together, see:</p> * * <ul style="list-style-type: disc; padding-left: 25px"> * <li>{@link Ext.data.proxy.Proxy Proxy} - overview of what Proxies are and how they are used</li> * <li>{@link Ext.data.Model Model} - the core class in the data package</li> * <li>{@link Ext.data.reader.Reader Reader} - used by any subclass of {@link Ext.data.proxy.Server ServerProxy} to read a response</li> * </ul> * * @constructor * @param {Object} config Optional config object */ Ext.define('Ext.data.Store', { extend: 'Ext.data.AbstractStore', alias: 'store.store', requires: ['Ext.ModelManager', 'Ext.data.Model', 'Ext.util.Grouper'], uses: ['Ext.data.proxy.Memory'], /** * @cfg {Boolean} remoteSort * True to defer any sorting operation to the server. If false, sorting is done locally on the client. Defaults to <tt>false</tt>. */ remoteSort: false, /** * @cfg {Boolean} remoteFilter * True to defer any filtering operation to the server. If false, filtering is done locally on the client. Defaults to <tt>false</tt>. */ remoteFilter: false, /** * @cfg {Boolean} remoteGroup * True if the grouping should apply on the server side, false if it is local only (defaults to false). If the * grouping is local, it can be applied immediately to the data. If it is remote, then it will simply act as a * helper, automatically sending the grouping information to the server. */ remoteGroup : false, /** * @cfg {String/Ext.data.proxy.Proxy/Object} proxy The Proxy to use for this Store. This can be either a string, a config * object or a Proxy instance - see {@link #setProxy} for details. */ /** * @cfg {Array} data Optional array of Model instances or data objects to load locally. See "Inline data" above for details. */ /** * @cfg {String} model The {@link Ext.data.Model} associated with this store */ /** * The (optional) field by which to group data in the store. Internally, grouping is very similar to sorting - the * groupField and {@link #groupDir} are injected as the first sorter (see {@link #sort}). Stores support a single * level of grouping, and groups can be fetched via the {@link #getGroups} method. * @property groupField * @type String */ groupField: undefined, /** * The direction in which sorting should be applied when grouping. Defaults to "ASC" - the other supported value is "DESC" * @property groupDir * @type String */ groupDir: "ASC", /** * @cfg {Number} pageSize * The number of records considered to form a 'page'. This is used to power the built-in * paging using the nextPage and previousPage functions. Defaults to 25. */ pageSize: 25, /** * The page that the Store has most recently loaded (see {@link #loadPage}) * @property currentPage * @type Number */ currentPage: 1, /** * @cfg {Boolean} clearOnPageLoad True to empty the store when loading another page via {@link #loadPage}, * {@link #nextPage} or {@link #previousPage} (defaults to true). Setting to false keeps existing records, allowing * large data sets to be loaded one page at a time but rendered all together. */ clearOnPageLoad: true, /** * True if the Store is currently loading via its Proxy * @property loading * @type Boolean * @private */ loading: false, /** * @cfg {Boolean} sortOnFilter For local filtering only, causes {@link #sort} to be called whenever {@link #filter} is called, * causing the sorters to be reapplied after filtering. Defaults to true */ sortOnFilter: true, /** * @cfg {Boolean} buffered * Allow the store to buffer and pre-fetch pages of records. This is to be used in conjunction with a view will * tell the store to pre-fetch records ahead of a time. */ buffered: false, /** * @cfg {Number} purgePageCount * The number of pages to keep in the cache before purging additional records. A value of 0 indicates to never purge the prefetched data. * This option is only relevant when the {@link #buffered} option is set to true. */ purgePageCount: 5, isStore: true, //documented above constructor: function(config) { config = config || {}; var me = this, groupers = config.groupers || me.groupers, groupField = config.groupField || me.groupField, proxy, data; if (config.buffered || me.buffered) { me.prefetchData = Ext.create('Ext.util.MixedCollection', false, function(record) { return record.index; }); me.pendingRequests = []; me.pagesRequested = []; me.sortOnLoad = false; me.filterOnLoad = false; } me.addEvents( /** * @event beforeprefetch * Fires before a prefetch occurs. Return false to cancel. * @param {Ext.data.store} this * @param {Ext.data.Operation} operation The associated operation */ 'beforeprefetch', /** * @event groupchange * Fired whenever the grouping in the grid changes * @param {Ext.data.Store} store The store * @param {Array} groupers The array of grouper objects */ 'groupchange', /** * @event load * Fires whenever records have been prefetched * @param {Ext.data.store} this * @param {Array} records An array of records * @param {Boolean} successful True if the operation was successful. * @param {Ext.data.Operation} operation The associated operation */ 'prefetch' ); data = config.data || me.data; /** * The MixedCollection that holds this store's local cache of records * @property data * @type Ext.util.MixedCollection */ me.data = Ext.create('Ext.util.MixedCollection', false, function(record) { return record.internalId; }); if (data) { me.inlineData = data; delete config.data; } if (!groupers && groupField) { groupers = [{ property : groupField, direction: config.groupDir || me.groupDir }]; } delete config.groupers; /** * The collection of {@link Ext.util.Grouper Groupers} currently applied to this Store * @property groupers * @type Ext.util.MixedCollection */ me.groupers = Ext.create('Ext.util.MixedCollection'); me.groupers.addAll(me.decodeGroupers(groupers)); this.callParent([config]); // don't use *config* anymore from here on... use *me* instead... if (me.groupers.items.length) { me.sort(me.groupers.items, 'prepend', false); } proxy = me.proxy; data = me.inlineData; if (data) { if (proxy instanceof Ext.data.proxy.Memory) { proxy.data = data; me.read(); } else { me.add.apply(me, data); } me.sort(); delete me.inlineData; } else if (me.autoLoad) { Ext.defer(me.load, 10, me, [typeof me.autoLoad === 'object' ? me.autoLoad: undefined]); // Remove the defer call, we may need reinstate this at some point, but currently it's not obvious why it's here. // this.load(typeof this.autoLoad == 'object' ? this.autoLoad : undefined); } }, onBeforeSort: function() { this.sort(this.groupers.items, 'prepend', false); }, /** * @private * Normalizes an array of grouper objects, ensuring that they are all Ext.util.Grouper instances * @param {Array} groupers The groupers array * @return {Array} Array of Ext.util.Grouper objects */ decodeGroupers: function(groupers) { if (!Ext.isArray(groupers)) { if (groupers === undefined) { groupers = []; } else { groupers = [groupers]; } } var length = groupers.length, Grouper = Ext.util.Grouper, config, i; for (i = 0; i < length; i++) { config = groupers[i]; if (!(config instanceof Grouper)) { if (Ext.isString(config)) { config = { property: config }; } Ext.applyIf(config, { root : 'data', direction: "ASC" }); //support for 3.x style sorters where a function can be defined as 'fn' if (config.fn) { config.sorterFn = config.fn; } //support a function to be passed as a sorter definition if (typeof config == 'function') { config = { sorterFn: config }; } groupers[i] = new Grouper(config); } } return groupers; }, /** * Group data in the store * @param {String|Array} groupers Either a string name of one of the fields in this Store's configured {@link Ext.data.Model Model}, * or an Array of grouper configurations. * @param {String} direction The overall direction to group the data by. Defaults to "ASC". */ group: function(groupers, direction) { var me = this, grouper, newGroupers; if (Ext.isArray(groupers)) { newGroupers = groupers; } else if (Ext.isObject(groupers)) { newGroupers = [groupers]; } else if (Ext.isString(groupers)) { grouper = me.groupers.get(groupers); if (!grouper) { grouper = { property : groupers, direction: direction }; newGroupers = [grouper]; } else if (direction === undefined) { grouper.toggle(); } else { grouper.setDirection(direction); } } if (newGroupers && newGroupers.length) { newGroupers = me.decodeGroupers(newGroupers); me.groupers.clear(); me.groupers.addAll(newGroupers); } if (me.remoteGroup) { me.load({ scope: me, callback: me.fireGroupChange }); } else { me.sort(); me.fireEvent('groupchange', me, me.groupers); } }, /** * Clear any groupers in the store */ clearGrouping: function(){ var me = this; // Clear any groupers we pushed on to the sorters me.groupers.each(function(grouper){ me.sorters.remove(grouper); }); me.groupers.clear(); if (me.remoteGroup) { me.load({ scope: me, callback: me.fireGroupChange }); } else { me.sort(); me.fireEvent('groupchange', me, me.groupers); } }, /** * Checks if the store is currently grouped * @return {Boolean} True if the store is grouped. */ isGrouped: function() { return this.groupers.getCount() > 0; }, /** * Fires the groupchange event. Abstracted out so we can use it * as a callback * @private */ fireGroupChange: function(){ this.fireEvent('groupchange', this, this.groupers); }, /** * Returns an object containing the result of applying grouping to the records in this store. See {@link #groupField}, * {@link #groupDir} and {@link #getGroupString}. Example for a store containing records with a color field: <pre><code> var myStore = new Ext.data.Store({ groupField: 'color', groupDir : 'DESC' }); myStore.getGroups(); //returns: [ { name: 'yellow', children: [ //all records where the color field is 'yellow' ] }, { name: 'red', children: [ //all records where the color field is 'red' ] } ] </code></pre> * @param {String} groupName (Optional) Pass in an optional groupName argument to access a specific group as defined by {@link #getGroupString} * @return {Array} The grouped data */ getGroups: function(requestGroupString) { var records = this.data.items, length = records.length, groups = [], pointers = {}, record, groupStr, group, i; for (i = 0; i < length; i++) { record = records[i]; groupStr = this.getGroupString(record); group = pointers[groupStr]; if (group === undefined) { group = { name: groupStr, children: [] }; groups.push(group); pointers[groupStr] = group; } group.children.push(record); } return requestGroupString ? pointers[requestGroupString] : groups; }, /** * @private * For a given set of records and a Grouper, returns an array of arrays - each of which is the set of records * matching a certain group. */ getGroupsForGrouper: function(records, grouper) { var length = records.length, groups = [], oldValue, newValue, record, group, i; for (i = 0; i < length; i++) { record = records[i]; newValue = grouper.getGroupString(record); if (newValue !== oldValue) { group = { name: newValue, grouper: grouper, records: [] }; groups.push(group); } group.records.push(record); oldValue = newValue; } return groups; }, /** * @private * This is used recursively to gather the records into the configured Groupers. The data MUST have been sorted for * this to work properly (see {@link #getGroupData} and {@link #getGroupsForGrouper}) Most of the work is done by * {@link #getGroupsForGrouper} - this function largely just handles the recursion. * @param {Array} records The set or subset of records to group * @param {Number} grouperIndex The grouper index to retrieve * @return {Array} The grouped records */ getGroupsForGrouperIndex: function(records, grouperIndex) { var me = this, groupers = me.groupers, grouper = groupers.getAt(grouperIndex), groups = me.getGroupsForGrouper(records, grouper), length = groups.length, i; if (grouperIndex + 1 < groupers.length) { for (i = 0; i < length; i++) { groups[i].children = me.getGroupsForGrouperIndex(groups[i].records, grouperIndex + 1); } } for (i = 0; i < length; i++) { groups[i].depth = grouperIndex; } return groups; }, /** * @private * <p>Returns records grouped by the configured {@link #groupers grouper} configuration. Sample return value (in * this case grouping by genre and then author in a fictional books dataset):</p> <pre><code> [ { name: 'Fantasy', depth: 0, records: [ //book1, book2, book3, book4 ], children: [ { name: 'Rowling', depth: 1, records: [ //book1, book2 ] }, { name: 'Tolkein', depth: 1, records: [ //book3, book4 ] } ] } ] </code></pre> * @param {Boolean} sort True to call {@link #sort} before finding groups. Sorting is required to make grouping * function correctly so this should only be set to false if the Store is known to already be sorted correctly * (defaults to true) * @return {Array} The group data */ getGroupData: function(sort) { var me = this; if (sort !== false) { me.sort(); } return me.getGroupsForGrouperIndex(me.data.items, 0); }, /** * <p>Returns the string to group on for a given model instance. The default implementation of this method returns * the model's {@link #groupField}, but this can be overridden to group by an arbitrary string. For example, to * group by the first letter of a model's 'name' field, use the following code:</p> <pre><code> new Ext.data.Store({ groupDir: 'ASC', getGroupString: function(instance) { return instance.get('name')[0]; } }); </code></pre> * @param {Ext.data.Model} instance The model instance * @return {String} The string to compare when forming groups */ getGroupString: function(instance) { var group = this.groupers.first(); if (group) { return instance.get(group.property); } return ''; }, /** * Inserts Model instances into the Store at the given index and fires the {@link #add} event. * See also <code>{@link #add}</code>. * @param {Number} index The start index at which to insert the passed Records. * @param {Ext.data.Model[]} records An Array of Ext.data.Model objects to add to the cache. */ insert: function(index, records) { var me = this, sync = false, i, record, len; records = [].concat(records); for (i = 0, len = records.length; i < len; i++) { record = me.createModel(records[i]); record.set(me.modelDefaults); // reassign the model in the array in case it wasn't created yet records[i] = record; me.data.insert(index + i, record); record.join(me); sync = sync || record.phantom === true; } if (me.snapshot) { me.snapshot.addAll(records); } me.fireEvent('add', me, records, index); me.fireEvent('datachanged', me); if (me.autoSync && sync) { me.sync(); } }, /** * Adds Model instances to the Store by instantiating them based on a JavaScript object. When adding already- * instantiated Models, use {@link #insert} instead. The instances will be added at the end of the existing collection. * This method accepts either a single argument array of Model instances or any number of model instance arguments. * Sample usage: * <pre><code> myStore.add({some: 'data'}, {some: 'other data'}); </code></pre> * * @param {Object} data The data for each model * @return {Array} The array of newly created model instances */ add: function(records) { //accept both a single-argument array of records, or any number of record arguments if (!Ext.isArray(records)) { records = Array.prototype.slice.apply(arguments); } var me = this, i = 0, length = records.length, record; for (; i < length; i++) { record = me.createModel(records[i]); // reassign the model in the array in case it wasn't created yet records[i] = record; } me.insert(me.data.length, records); return records; }, /** * Converts a literal to a model, if it's not a model already * @private * @param record {Ext.data.Model/Object} The record to create * @return {Ext.data.Model} */ createModel: function(record) { if (!record.isModel) { record = Ext.ModelManager.create(record, this.model); } return record; }, /** * Calls the specified function for each of the {@link Ext.data.Model Records} in the cache. * @param {Function} fn The function to call. The {@link Ext.data.Model Record} is passed as the first parameter. * Returning <tt>false</tt> aborts and exits the iteration. * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. * Defaults to the current {@link Ext.data.Model Record} in the iteration. */ each: function(fn, scope) { this.data.each(fn, scope); }, /** * Removes the given record from the Store, firing the 'remove' event for each instance that is removed, plus a single * 'datachanged' event after removal. * @param {Ext.data.Model/Array} records The Ext.data.Model instance or array of instances to remove */ remove: function(records, /* private */ isMove) { if (!Ext.isArray(records)) { records = [records]; } /* * Pass the isMove parameter if we know we're going to be re-inserting this record */ isMove = isMove === true; var me = this, sync = false, i = 0, length = records.length, isPhantom, index, record; for (; i < length; i++) { record = records[i]; index = me.data.indexOf(record); if (me.snapshot) { me.snapshot.remove(record); } if (index > -1) { isPhantom = record.phantom === true; if (!isMove && !isPhantom) { // don't push phantom records onto removed me.removed.push(record); } record.unjoin(me); me.data.remove(record); sync = sync || !isPhantom; me.fireEvent('remove', me, record, index); } } me.fireEvent('datachanged', me); if (!isMove && me.autoSync && sync) { me.sync(); } }, /** * Removes the model instance at the given index * @param {Number} index The record index */ removeAt: function(index) { var record = this.getAt(index); if (record) { this.remove(record); } }, /** * <p>Loads data into the Store via the configured {@link #proxy}. This uses the Proxy to make an * asynchronous call to whatever storage backend the Proxy uses, automatically adding the retrieved * instances into the Store and calling an optional callback if required. Example usage:</p> * <pre><code> store.load({ scope : this, callback: function(records, operation, success) { //the {@link Ext.data.Operation operation} object contains all of the details of the load operation console.log(records); } }); </code></pre> * * <p>If the callback scope does not need to be set, a function can simply be passed:</p> * <pre><code> store.load(function(records, operation, success) { console.log('loaded records'); }); </code></pre> * * @param {Object/Function} options Optional config object, passed into the Ext.data.Operation object before loading. */ load: function(options) { var me = this; options = options || {}; if (Ext.isFunction(options)) { options = { callback: options }; } Ext.applyIf(options, { groupers: me.groupers.items, page: me.currentPage, start: (me.currentPage - 1) * me.pageSize, limit: me.pageSize, addRecords: false }); return me.callParent([options]); }, /** * @private * Called internally when a Proxy has completed a load request */ onProxyLoad: function(operation) { var me = this, resultSet = operation.getResultSet(), records = operation.getRecords(), successful = operation.wasSuccessful(); if (resultSet) { me.totalCount = resultSet.total; } if (successful) { me.loadRecords(records, operation); } me.loading = false; me.fireEvent('load', me, records, successful); //TODO: deprecate this event, it should always have been 'load' instead. 'load' is now documented, 'read' is not. //People are definitely using this so can't deprecate safely until 2.x me.fireEvent('read', me, records, operation.wasSuccessful()); //this is a callback that would have been passed to the 'read' function and is optional Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]); }, /** * Create any new records when a write is returned from the server. * @private * @param {Array} records The array of new records * @param {Ext.data.Operation} operation The operation that just completed * @param {Boolean} success True if the operation was successful */ onCreateRecords: function(records, operation, success) { if (success) { var i = 0, data = this.data, snapshot = this.snapshot, length = records.length, originalRecords = operation.records, record, original, index; /* * Loop over each record returned from the server. Assume they are * returned in order of how they were sent. If we find a matching * record, replace it with the newly created one. */ for (; i < length; ++i) { record = records[i]; original = originalRecords[i]; if (original) { index = data.indexOf(original); if (index > -1) { data.removeAt(index); data.insert(index, record); } if (snapshot) { index = snapshot.indexOf(original); if (index > -1) { snapshot.removeAt(index); snapshot.insert(index, record); } } record.phantom = false; record.join(this); } } } }, /** * Update any records when a write is returned from the server. * @private * @param {Array} records The array of updated records * @param {Ext.data.Operation} operation The operation that just completed * @param {Boolean} success True if the operation was successful */ onUpdateRecords: function(records, operation, success){ if (success) { var i = 0, length = records.length, data = this.data, snapshot = this.snapshot, record; for (; i < length; ++i) { record = records[i]; data.replace(record); if (snapshot) { snapshot.replace(record); } record.join(this); } } }, /** * Remove any records when a write is returned from the server. * @private * @param {Array} records The array of removed records * @param {Ext.data.Operation} operation The operation that just completed * @param {Boolean} success True if the operation was successful */ onDestroyRecords: function(records, operation, success){ if (success) { var me = this, i = 0, length = records.length, data = me.data, snapshot = me.snapshot, record; for (; i < length; ++i) { record = records[i]; record.unjoin(me); data.remove(record); if (snapshot) { snapshot.remove(record); } } me.removed = []; } }, //inherit docs getNewRecords: function() { return this.data.filterBy(this.filterNew).items; }, //inherit docs getUpdatedRecords: function() { return this.data.filterBy(this.filterUpdated).items; }, /** * Filters the loaded set of records by a given set of filters. * @param {Mixed} filters The set of filters to apply to the data. These are stored internally on the store, * but the filtering itself is done on the Store's {@link Ext.util.MixedCollection MixedCollection}. See * MixedCollection's {@link Ext.util.MixedCollection#filter filter} method for filter syntax. Alternatively, * pass in a property string * @param {String} value Optional value to filter by (only if using a property string as the first argument) */ filter: function(filters, value) { if (Ext.isString(filters)) { filters = { property: filters, value: value }; } var me = this, decoded = me.decodeFilters(filters), i = 0, doLocalSort = me.sortOnFilter && !me.remoteSort, length = decoded.length; for (; i < length; i++) { me.filters.replace(decoded[i]); } if (me.remoteFilter) { //the load function will pick up the new filters and request the filtered data from the proxy me.load(); } else { /** * A pristine (unfiltered) collection of the records in this store. This is used to reinstate * records when a filter is removed or changed * @property snapshot * @type Ext.util.MixedCollection */ if (me.filters.getCount()) { me.snapshot = me.snapshot || me.data.clone(); me.data = me.data.filter(me.filters.items); if (doLocalSort) { me.sort(); } // fire datachanged event if it hasn't already been fired by doSort if (!doLocalSort || me.sorters.length < 1) { me.fireEvent('datachanged', me); } } } }, /** * Revert to a view of the Record cache with no filtering applied. * @param {Boolean} suppressEvent If <tt>true</tt> the filter is cleared silently without firing the * {@link #datachanged} event. */ clearFilter: function(suppressEvent) { var me = this; me.filters.clear(); if (me.remoteFilter) { me.load(); } else if (me.isFiltered()) { me.data = me.snapshot.clone(); delete me.snapshot; if (suppressEvent !== true) { me.fireEvent('datachanged', me); } } }, /** * Returns true if this store is currently filtered * @return {Boolean} */ isFiltered: function() { var snapshot = this.snapshot; return !! snapshot && snapshot !== this.data; }, /** * Filter by a function. The specified function will be called for each * Record in this Store. If the function returns <tt>true</tt> the Record is included, * otherwise it is filtered out. * @param {Function} fn The function to be called. It will be passed the following parameters:<ul> * <li><b>record</b> : Ext.data.Model<p class="sub-desc">The {@link Ext.data.Model record} * to test for filtering. Access field values using {@link Ext.data.Model#get}.</p></li> * <li><b>id</b> : Object<p class="sub-desc">The ID of the Record passed.</p></li> * </ul> * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to this Store. */ filterBy: function(fn, scope) { var me = this; me.snapshot = me.snapshot || me.data.clone(); me.data = me.queryBy(fn, scope || me); me.fireEvent('datachanged', me); }, /** * Query the cached records in this Store using a filtering function. The specified function * will be called with each record in this Store. If the function returns <tt>true</tt> the record is * included in the results. * @param {Function} fn The function to be called. It will be passed the following parameters:<ul> * <li><b>record</b> : Ext.data.Model<p class="sub-desc">The {@link Ext.data.Model record} * to test for filtering. Access field values using {@link Ext.data.Model#get}.</p></li> * <li><b>id</b> : Object<p class="sub-desc">The ID of the Record passed.</p></li> * </ul> * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to this Store. * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records **/ queryBy: function(fn, scope) { var me = this, data = me.snapshot || me.data; return data.filterBy(fn, scope || me); }, /** * Loads an array of data straight into the Store * @param {Array} data Array of data to load. Any non-model instances will be cast into model instances first * @param {Boolean} append True to add the records to the existing records in the store, false to remove the old ones first */ loadData: function(data, append) { var model = this.model, length = data.length, i, record; //make sure each data element is an Ext.data.Model instance for (i = 0; i < length; i++) { record = data[i]; if (! (record instanceof Ext.data.Model)) { data[i] = Ext.ModelManager.create(record, model); } } this.loadRecords(data, {addRecords: append}); }, /** * Loads an array of {@Ext.data.Model model} instances into the store, fires the datachanged event. This should only usually * be called internally when loading from the {@link Ext.data.proxy.Proxy Proxy}, when adding records manually use {@link #add} instead * @param {Array} records The array of records to load * @param {Object} options {addRecords: true} to add these records to the existing records, false to remove the Store's existing records first */ loadRecords: function(records, options) { var me = this, i = 0, length = records.length; options = options || {}; if (!options.addRecords) { delete me.snapshot; me.data.clear(); } me.data.addAll(records); //FIXME: this is not a good solution. Ed Spencer is totally responsible for this and should be forced to fix it immediately. for (; i < length; i++) { if (options.start !== undefined) { records[i].index = options.start + i; } records[i].join(me); } /* * this rather inelegant suspension and resumption of events is required because both the filter and sort functions * fire an additional datachanged event, which is not wanted. Ideally we would do this a different way. The first * datachanged event is fired by the call to this.add, above. */ me.suspendEvents(); if (me.filterOnLoad && !me.remoteFilter) { me.filter(); } if (me.sortOnLoad && !me.remoteSort) { me.sort(); } me.resumeEvents(); me.fireEvent('datachanged', me, records); }, // PAGING METHODS /** * Loads a given 'page' of data by setting the start and limit values appropriately. Internally this just causes a normal * load operation, passing in calculated 'start' and 'limit' params * @param {Number} page The number of the page to load */ loadPage: function(page) { var me = this; me.currentPage = page; me.read({ page: page, start: (page - 1) * me.pageSize, limit: me.pageSize, addRecords: !me.clearOnPageLoad }); }, /** * Loads the next 'page' in the current data set */ nextPage: function() { this.loadPage(this.currentPage + 1); }, /** * Loads the previous 'page' in the current data set */ previousPage: function() { this.loadPage(this.currentPage - 1); }, // private clearData: function() { this.data.each(function(record) { record.unjoin(); }); this.data.clear(); }, // Buffering /** * Prefetches data the Store using its configured {@link #proxy}. * @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading. * See {@link #load} */ prefetch: function(options) { var me = this, operation, requestId = me.getRequestId(); options = options || {}; Ext.applyIf(options, { action : 'read', filters: me.filters.items, sorters: me.sorters.items, requestId: requestId }); me.pendingRequests.push(requestId); operation = Ext.create('Ext.data.Operation', options); // HACK to implement loadMask support. //if (operation.blocking) { // me.fireEvent('beforeload', me, operation); //} if (me.fireEvent('beforeprefetch', me, operation) !== false) { me.loading = true; me.proxy.read(operation, me.onProxyPrefetch, me); } return me; }, /** * Prefetches a page of data. * @param {Number} page The page to prefetch * @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading. * See {@link #load} * @param */ prefetchPage: function(page, options) { var me = this, pageSize = me.pageSize, start = (page - 1) * me.pageSize, end = start + pageSize; // Currently not requesting this page and range isn't already satisified if (Ext.Array.indexOf(me.pagesRequested, page) === -1 && !me.rangeSatisfied(start, end)) { options = options || {}; me.pagesRequested.push(page); Ext.applyIf(options, { page : page, start: start, limit: pageSize, callback: me.onWaitForGuarantee, scope: me }); me.prefetch(options); } }, /** * Returns a unique requestId to track requests. * @private */ getRequestId: function() { this.requestSeed = this.requestSeed || 1; return this.requestSeed++; }, /** * Handles a success pre-fetch * @private * @param {Ext.data.Operation} operation The operation that completed */ onProxyPrefetch: function(operation) { var me = this, resultSet = operation.getResultSet(), records = operation.getRecords(), successful = operation.wasSuccessful(); if (resultSet) { me.totalCount = resultSet.total; me.fireEvent('totalcountchange', me.totalCount); } if (successful) { me.cacheRecords(records, operation); } Ext.Array.remove(me.pendingRequests, operation.requestId); if (operation.page) { Ext.Array.remove(me.pagesRequested, operation.page); } me.loading = false; me.fireEvent('prefetch', me, records, successful, operation); // HACK to support loadMask if (operation.blocking) { me.fireEvent('load', me, records, successful); } //this is a callback that would have been passed to the 'read' function and is optional Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]); }, /** * Caches the records in the prefetch and stripes them with their server-side * index. * @private * @param {Array} records The records to cache * @param {Ext.data.Operation} The associated operation */ cacheRecords: function(records, operation) { var me = this, i = 0, length = records.length, start = operation ? operation.start : 0; if (!Ext.isDefined(me.totalCount)) { me.totalCount = records.length; me.fireEvent('totalcountchange', me.totalCount); } for (; i < length; i++) { // this is the true index, not the viewIndex records[i].index = start + i; } me.prefetchData.addAll(records); if (me.purgePageCount) { me.purgeRecords(); } }, /** * Purge the least recently used records in the prefetch if the purgeCount * has been exceeded. */ purgeRecords: function() { var me = this, prefetchCount = me.prefetchData.getCount(), purgeCount = me.purgePageCount * me.pageSize, numRecordsToPurge = prefetchCount - purgeCount - 1, i = 0; for (; i <= numRecordsToPurge; i++) { me.prefetchData.removeAt(0); } }, /** * Determines if the range has already been satisfied in the prefetchData. * @private * @param {Number} start The start index * @param {Number} end The end index in the range */ rangeSatisfied: function(start, end) { var me = this, i = start, satisfied = true; for (; i < end; i++) { if (!me.prefetchData.getByKey(i)) { satisfied = false; //<debug> if (end - i > me.pageSize) { Ext.Error.raise("A single page prefetch could never satisfy this request."); } //</debug> break; } } return satisfied; }, /** * Determines the page from a record index * @param {Number} index The record index * @return {Number} The page the record belongs to */ getPageFromRecordIndex: function(index) { return Math.floor(index / this.pageSize) + 1; }, /** * Handles a guaranteed range being loaded * @private */ onGuaranteedRange: function() { var me = this, totalCount = me.getTotalCount(), start = me.requestStart, end = ((totalCount - 1) < me.requestEnd) ? totalCount - 1 : me.requestEnd, range = [], record, i = start; //<debug> if (start > end) { Ext.Error.raise("Start (" + start + ") was greater than end (" + end + ")"); } //</debug> if (start !== me.guaranteedStart && end !== me.guaranteedEnd) { me.guaranteedStart = start; me.guaranteedEnd = end; for (; i <= end; i++) { record = me.prefetchData.getByKey(i); //<debug> if (!record) { Ext.Error.raise("Record was not found and store said it was guaranteed"); } //</debug> range.push(record); } me.fireEvent('guaranteedrange', range, start, end); if (me.cb) { me.cb.call(me.scope || me, range); } } me.unmask(); }, // hack to support loadmask mask: function() { this.masked = true; this.fireEvent('beforeload'); }, // hack to support loadmask unmask: function() { if (this.masked) { this.fireEvent('load'); } }, /** * Returns the number of pending requests out. */ hasPendingRequests: function() { return this.pendingRequests.length; }, // wait until all requests finish, until guaranteeing the range. onWaitForGuarantee: function() { if (!this.hasPendingRequests()) { this.onGuaranteedRange(); } }, /** * Guarantee a specific range, this will load the store with a range (that * must be the pageSize or smaller) and take care of any loading that may * be necessary. */ guaranteeRange: function(start, end, cb, scope) { //<debug> if (start && end) { if (end - start > this.pageSize) { Ext.Error.raise({ start: start, end: end, pageSize: this.pageSize, msg: "Requested a bigger range than the specified pageSize" }); } } //</debug> end = (end > this.totalCount) ? this.totalCount - 1 : end; var me = this, i = start, prefetchData = me.prefetchData, range = [], startLoaded = !!prefetchData.getByKey(start), endLoaded = !!prefetchData.getByKey(end), startPage = me.getPageFromRecordIndex(start), endPage = me.getPageFromRecordIndex(end); me.cb = cb; me.scope = scope; me.requestStart = start; me.requestEnd = end; // neither beginning or end are loaded if (!startLoaded || !endLoaded) { // same page, lets load it if (startPage === endPage) { me.mask(); me.prefetchPage(startPage, { //blocking: true, callback: me.onWaitForGuarantee, scope: me }); // need to load two pages } else { me.mask(); me.prefetchPage(startPage, { //blocking: true, callback: me.onWaitForGuarantee, scope: me }); me.prefetchPage(endPage, { //blocking: true, callback: me.onWaitForGuarantee, scope: me }); } // Request was already satisfied via the prefetch } else { me.onGuaranteedRange(); } }, // because prefetchData is stored by index // this invalidates all of the prefetchedData sort: function() { var me = this, prefetchData = me.prefetchData, sorters, start, end, range; if (me.buffered) { if (me.remoteSort) { prefetchData.clear(); me.callParent(arguments); } else { sorters = me.getSorters(); start = me.guaranteedStart; end = me.guaranteedEnd; if (sorters.length) { prefetchData.sort(sorters); range = prefetchData.getRange(); prefetchData.clear(); me.cacheRecords(range); delete me.guaranteedStart; delete me.guaranteedEnd; me.guaranteeRange(start, end); } me.callParent(arguments); } } else { me.callParent(arguments); } }, // overriden to provide striping of the indexes as sorting occurs. // this cannot be done inside of sort because datachanged has already // fired and will trigger a repaint of the bound view. doSort: function(sorterFn) { var me = this; if (me.remoteSort) { //the load function will pick up the new sorters and request the sorted data from the proxy me.load(); } else { me.data.sortBy(sorterFn); if (!me.buffered) { var range = me.getRange(), ln = range.length, i = 0; for (; i < ln; i++) { range[i].index = i; } } me.fireEvent('datachanged', me); } }, /** * Finds the index of the first matching Record in this store by a specific field value. * @param {String} fieldName The name of the Record field to test. * @param {String/RegExp} value Either a string that the field value * should begin with, or a RegExp to test against the field. * @param {Number} startIndex (optional) The index to start searching at * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning * @param {Boolean} caseSensitive (optional) True for case sensitive comparison * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. * @return {Number} The matched index or -1 */ find: function(property, value, start, anyMatch, caseSensitive, exactMatch) { var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch); return fn ? this.data.findIndexBy(fn, null, start) : -1; }, /** * Finds the first matching Record in this store by a specific field value. * @param {String} fieldName The name of the Record field to test. * @param {String/RegExp} value Either a string that the field value * should begin with, or a RegExp to test against the field. * @param {Number} startIndex (optional) The index to start searching at * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning * @param {Boolean} caseSensitive (optional) True for case sensitive comparison * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. * @return {Ext.data.Model} The matched record or null */ findRecord: function() { var me = this, index = me.find.apply(me, arguments); return index !== -1 ? me.getAt(index) : null; }, /** * @private * Returns a filter function used to test a the given property's value. Defers most of the work to * Ext.util.MixedCollection's createValueMatcher function * @param {String} property The property to create the filter function for * @param {String/RegExp} value The string/regex to compare the property value to * @param {Boolean} anyMatch True if we don't care if the filter value is not the full value (defaults to false) * @param {Boolean} caseSensitive True to create a case-sensitive regex (defaults to false) * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. * Ignored if anyMatch is true. */ createFilterFn: function(property, value, anyMatch, caseSensitive, exactMatch) { if (Ext.isEmpty(value)) { return false; } value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch); return function(r) { return value.test(r.data[property]); }; }, /** * Finds the index of the first matching Record in this store by a specific field value. * @param {String} fieldName The name of the Record field to test. * @param {Mixed} value The value to match the field against. * @param {Number} startIndex (optional) The index to start searching at * @return {Number} The matched index or -1 */ findExact: function(property, value, start) { return this.data.findIndexBy(function(rec) { return rec.get(property) === value; }, this, start); }, /** * Find the index of the first matching Record in this Store by a function. * If the function returns <tt>true</tt> it is considered a match. * @param {Function} fn The function to be called. It will be passed the following parameters:<ul> * <li><b>record</b> : Ext.data.Model<p class="sub-desc">The {@link Ext.data.Model record} * to test for filtering. Access field values using {@link Ext.data.Model#get}.</p></li> * <li><b>id</b> : Object<p class="sub-desc">The ID of the Record passed.</p></li> * </ul> * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to this Store. * @param {Number} startIndex (optional) The index to start searching at * @return {Number} The matched index or -1 */ findBy: function(fn, scope, start) { return this.data.findIndexBy(fn, scope, start); }, /** * Collects unique values for a particular dataIndex from this store. * @param {String} dataIndex The property to collect * @param {Boolean} allowNull (optional) Pass true to allow null, undefined or empty string values * @param {Boolean} bypassFilter (optional) Pass true to collect from all records, even ones which are filtered * @return {Array} An array of the unique values **/ collect: function(dataIndex, allowNull, bypassFilter) { var me = this, data = (bypassFilter === true && me.snapshot) ? me.snapshot: me.data; return data.collect(dataIndex, 'data', allowNull); }, /** * Gets the number of cached records. * <p>If using paging, this may not be the total size of the dataset. If the data object * used by the Reader contains the dataset size, then the {@link #getTotalCount} function returns * the dataset size. <b>Note</b>: see the Important note in {@link #load}.</p> * @return {Number} The number of Records in the Store's cache. */ getCount: function() { return this.data.length || 0; }, /** * Returns the total number of {@link Ext.data.Model Model} instances that the {@link Ext.data.proxy.Proxy Proxy} * indicates exist. This will usually differ from {@link #getCount} when using paging - getCount returns the * number of records loaded into the Store at the moment, getTotalCount returns the number of records that * could be loaded into the Store if the Store contained all data * @return {Number} The total number of Model instances available via the Proxy */ getTotalCount: function() { return this.totalCount; }, /** * Get the Record at the specified index. * @param {Number} index The index of the Record to find. * @return {Ext.data.Model} The Record at the passed index. Returns undefined if not found. */ getAt: function(index) { return this.data.getAt(index); }, /** * Returns a range of Records between specified indices. * @param {Number} startIndex (optional) The starting index (defaults to 0) * @param {Number} endIndex (optional) The ending index (defaults to the last Record in the Store) * @return {Ext.data.Model[]} An array of Records */ getRange: function(start, end) { return this.data.getRange(start, end); }, /** * Get the Record with the specified id. * @param {String} id The id of the Record to find. * @return {Ext.data.Model} The Record with the passed id. Returns undefined if not found. */ getById: function(id) { return (this.snapshot || this.data).findBy(function(record) { return record.getId() === id; }); }, /** * Get the index within the cache of the passed Record. * @param {Ext.data.Model} record The Ext.data.Model object to find. * @return {Number} The index of the passed Record. Returns -1 if not found. */ indexOf: function(record) { return this.data.indexOf(record); }, /** * Get the index within the entire dataset. From 0 to the totalCount. * @param {Ext.data.Model} record The Ext.data.Model object to find. * @return {Number} The index of the passed Record. Returns -1 if not found. */ indexOfTotal: function(record) { return record.index || this.indexOf(record); }, /** * Get the index within the cache of the Record with the passed id. * @param {String} id The id of the Record to find. * @return {Number} The index of the Record. Returns -1 if not found. */ indexOfId: function(id) { return this.data.indexOfKey(id); }, /** * Remove all items from the store. * @param {Boolean} silent Prevent the `clear` event from being fired. */ removeAll: function(silent) { var me = this; me.clearData(); if (me.snapshot) { me.snapshot.clear(); } if (silent !== true) { me.fireEvent('clear', me); } }, /* * Aggregation methods */ /** * Convenience function for getting the first model instance in the store * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the first record being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Ext.data.Model/undefined} The first model instance in the store, or undefined */ first: function(grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(function(records) { return records.length ? records[0] : undefined; }, me, true); } else { return me.data.first(); } }, /** * Convenience function for getting the last model instance in the store * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the last record being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Ext.data.Model/undefined} The last model instance in the store, or undefined */ last: function(grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(function(records) { var len = records.length; return len ? records[len - 1] : undefined; }, me, true); } else { return me.data.last(); } }, /** * Sums the value of <tt>property</tt> for each {@link Ext.data.Model record} between <tt>start</tt> * and <tt>end</tt> and returns the result. * @param {String} field A field in each record * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the sum for that group being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Number} The sum */ sum: function(field, grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(me.getSum, me, true, [field]); } else { return me.getSum(me.data.items, field); } }, // @private, see sum getSum: function(records, field) { var total = 0, i = 0, len = records.length; for (; i < len; ++i) { total += records[i].get(field); } return total; }, /** * Gets the count of items in the store. * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the count for each group being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Number} the count */ count: function(grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(function(records) { return records.length; }, me, true); } else { return me.getCount(); } }, /** * Gets the minimum value in the store. * @param {String} field The field in each record * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the minimum in the group being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Mixed/undefined} The minimum value, if no items exist, undefined. */ min: function(field, grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(me.getMin, me, true, [field]); } else { return me.getMin(me.data.items, field); } }, // @private, see min getMin: function(records, field){ var i = 1, len = records.length, value, min; if (len > 0) { min = records[0].get(field); } for (; i < len; ++i) { value = records[i].get(field); if (value < min) { min = value; } } return min; }, /** * Gets the maximum value in the store. * @param {String} field The field in each record * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the maximum in the group being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Mixed/undefined} The maximum value, if no items exist, undefined. */ max: function(field, grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(me.getMax, me, true, [field]); } else { return me.getMax(me.data.items, field); } }, // @private, see max getMax: function(records, field) { var i = 1, len = records.length, value, max; if (len > 0) { max = records[0].get(field); } for (; i < len; ++i) { value = records[i].get(field); if (value > max) { max = value; } } return max; }, /** * Gets the average value in the store. * @param {String} field The field in each record * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the group average being the value. The grouped parameter is only honored if * the store has a groupField. * @return {Mixed/undefined} The average value, if no items exist, 0. */ average: function(field, grouped) { var me = this; if (grouped && me.isGrouped()) { return me.aggregate(me.getAverage, me, true, [field]); } else { return me.getAverage(me.data.items, field); } }, // @private, see average getAverage: function(records, field) { var i = 0, len = records.length, sum = 0; if (records.length > 0) { for (; i < len; ++i) { sum += records[i].get(field); } return sum / len; } return 0; }, /** * Runs the aggregate function for all the records in the store. * @param {Function} fn The function to execute. The function is called with a single parameter, * an array of records for that group. * @param {Object} scope (optional) The scope to execute the function in. Defaults to the store. * @param {Boolean} grouped (Optional) True to perform the operation for each group * in the store. The value returned will be an object literal with the key being the group * name and the group average being the value. The grouped parameter is only honored if * the store has a groupField. * @param {Array} args (optional) Any arguments to append to the function call * @return {Object} An object literal with the group names and their appropriate values. */ aggregate: function(fn, scope, grouped, args) { args = args || []; if (grouped && this.isGrouped()) { var groups = this.getGroups(), i = 0, len = groups.length, out = {}, group; for (; i < len; ++i) { group = groups[i]; out[group.name] = fn.apply(scope || this, [group.children].concat(args)); } return out; } else { return fn.apply(scope || this, [this.data.items].concat(args)); } } });