/**
Data source collection
@namespace dataSource
@class Collection
@extends dataSource.JSON
@constructor
@param {Object} config
@example
dataSource:{
url:'data-source/grid.php',
id:'myDataSource',
paging:{
size:12,
remotePaging:false,
cache:false,
cacheTimeout:1000
},
searchConfig:{
index:['capital', 'country']
},
listeners:{
select:function (record) {
console.log(record);
}
}
}
*/
ludo.dataSource.Collection = new Class({
Extends:ludo.dataSource.JSON,
/**
custom sort functions, which should return -1 if record a is smaller than
record b and 1 if record b is larger than record a.
@config {Function} sortFn
@default {}
@example
sortFn:{
'population':{
'asc' : function(a,b){
return parseInt(a.population) < parseInt(b.population) ? -1 : 1
},
'desc' : function(a,b){
return parseInt(a.population) > parseInt(b.population) ? -1 : 1
}
}
}
*/
sortFn:{},
selectedRecords:[],
/**
* Primary key for records
* @config {String} primaryKey
* @default "id"
* @optional
*/
primaryKey:'id',
/**
Use paging, i.e. only load a number of records from the server
@attribute {Object} paging
@example
paging:{
size:10, // Number of rows per page
remotePaging:true, // Load only records per page from server, i.e. new request per page
cache : true, // Store pages in cache, i.e no request if data for page is in cache,
cacheTimeout:30 // Optional time in second before cache is considered out of date, i.e. new server request
}
*/
paging:undefined,
dataCache:{},
sortedBy:{
column:undefined,
order:undefined
},
/**
Configuration object for {{#crossLink "dataSource.CollectionSearch"}}{{/crossLink}}. This is
the class which searchs and filters data in the collection.
@config searchConfig
@type Object
@example
searchConfig:{
index:['city','country'],
delay:.5
}
which makes the record keys/columns "city" and "country" searchable. It waits .5 seconds
before the search is executed. This is useful when searching large collections and you
want to delay the search until the user has finished entering into a search box.
*/
searchConfig:undefined,
statefulProperties:['sortedBy', 'paging'],
index:undefined,
searcherType:'dataSource.CollectionSearch',
uidMap:{},
/**
* Reference to record to select by default once data has been loaded
* @config {Object|String} selected
* @default undefined
*/
selected:undefined,
ludoConfig:function (config) {
this.parent(config);
this.setConfigParams(config, ['searchConfig','sortFn','primaryKey','sortedBy','paging','selected']);
if (this.primaryKey && !ludo.util.isArray(this.primaryKey))this.primaryKey = [this.primaryKey];
if (this.paging) {
this.paging.offset = this.paging.offset || 0;
this.paging.initialOffset = this.paging.offset;
if (this.paging.initialOffset !== undefined) {
this.fireEvent('page', (this.paging.initialOffset / this.paging.size) + 1);
}
if (this.isCacheEnabled()) {
this.addEvent('load', this.populateCache.bind(this));
}
}
this.addEvent('parsedata', this.createIndex.bind(this));
if(this.selected){
this.addEvent('firstLoad', this.setInitialSelected.bind(this));
}
if(this.data && !this.index)this.createIndex();
},
hasRemoteSearch:function(){
return this.paging && this.paging.remotePaging;
},
setInitialSelected:function(){
this.selectRecord(this.selected);
},
/**
* Returns 1) If search is specified: number of records in search result, or 2) number of records in entire collection.
* @method getCount
* @return {Number} count
*/
getCount:function () {
if (this.paging && this.paging.rows)return this.paging.rows;
if (this.searcher && this.searcher.hasData())return this.searcher.getCount();
return this.data ? this.data.length : 0;
},
isCacheEnabled:function () {
return this.paging && this.paging['remotePaging'] && this.paging.cache;
},
/**
* Resort data-source
* @method sort
* @return void
*/
sort:function () {
if (this.sortedBy.column && this.sortedBy.order) {
this.sortBy(this.sortedBy.column, this.sortedBy.order);
}
},
/**
Set sorted by column
@method by
@param {String} column
@return {dataSource.Collection} this
@example
collection.by('country').ascending().sort();
or
@example
collection.by('country').sort();
*/
by:function(column){
this.sortedBy.column = column;
this.sortedBy.order = this.getSortOrderFor(column);
return this;
},
/**
Set sort order to ascending
@method ascending
@return {dataSource.Collection} this
@example
collection.by('country').ascending().sort();
*/
ascending:function(){
this.sortedBy.order = 'asc';
return this;
},
/**
Set sort order to descending
@method descending
@return {dataSource.Collection} this
@example
collection.by('country').descending().sort();
*/
descending:function(){
this.sortedBy.order = 'desc';
return this;
},
/**
Sort by column and order
The second argument(order) is optional
@method sortBy
@param {String} column
@param {String} order
@optional
@return {dataSource.Collection} this
@example
grid.getDataSource().sortBy('firstname', 'desc');
which also can be written as
@example
grid.getDataSource().by('firstname').descending().sort();
*/
sortBy:function (column, order) {
order = order || this.getSortOrderFor(column);
this.sortedBy = {
column:column,
order:order
};
if (this.paging) {
this.paging.offset = this.paging.initialOffset || 0;
this.fireEvent('page', Math.round(this.paging.offset / this.paging.size) + 1);
}
if (this.shouldSortOnServer()) {
this.loadOrGetFromCache();
} else {
var data = this._getData();
data.sort(this.getSortFnFor(column, order));
this.fireEvent('change');
}
/**
* Event fired when a data has been sorted,
* param example: { column:'country',order:'asc' }
* @event sort
* @param {Object} sortedBy
*/
this.fireEvent('sort', this.sortedBy);
if(this.paging)this.firePageEvents();
this.fireEvent('state');
return this;
},
/**
* Return current sorted by column
* @method getSortedBy
* @return {String} column
*/
getSortedBy:function () {
return this.sortedBy.column;
},
/**
* Return current sort order (asc|desc)
* @method getSortOrder
* @return {String} order
*/
getSortOrder:function () {
return this.sortedBy.order;
},
shouldSortOnServer:function () {
return this.paging && this.paging.remotePaging;
},
getSortFnFor:function (column, order) {
if (this.sortFn[column] !== undefined) {
return this.sortFn[column][order];
}
if (order === 'asc') {
return function (a, b) {
return a[column] + '_' + a[this.primaryKey] < b[column] + '_' + b[this.primaryKey] ? -1 : 1
};
} else {
return function (a, b) {
return a[column] + '_' + a[this.primaryKey] < b[column] + '_' + b[this.primaryKey] ? 1 : -1
};
}
},
getSortOrderFor:function (column) {
if (this.sortedBy.column === column) {
return this.sortedBy.order === 'asc' ? 'desc' : 'asc';
}
return 'asc';
},
/**
* Add a record to data-source
* @method addRecord
* @param record
* @return {Object} record
*/
addRecord:function (record) {
this.data = this.data || [];
this.data.push(record);
if(!this.index)this.createIndex();
/**
* Event fired when a record is added to the collection
* @event add
* @param {Object} record
*/
this.fireEvent('add', record);
return this.createRecord(record);
},
/**
* Returns plain object for a record from search. To get a
* {{#crossLink "dataSource.Record"}}{{/crossLink}} object
* use {{#crossLink "dataSource.Collection/getRecord"}}{{/crossLink}}
*
* collection.find({ capital : 'Oslo' });
*
* @method findRecord
* @param {Object} search
* @return {Object|undefined} record
*/
findRecord:function (search) {
if (!this.data)return undefined;
if(search['getUID'] !== undefined)search = search.getUID();
if(search.uid)search = search.uid;
var rec = this.getById(search);
if(rec)return rec;
var searchMethod = ludo.util.isObject(search) ? 'isRecordMatchingSearch' : 'hasMatchInPrimaryKey';
for (var i = 0; i < this.data.length; i++) {
if (this[searchMethod](this.data[i], search)) {
return this.data[i];
}
}
return undefined;
},
isRecordMatchingSearch:function (record, search) {
for (var key in search) {
if (search.hasOwnProperty(key)) {
if (record[key] !== search[key]) {
return false;
}
}
}
return true;
},
hasMatchInPrimaryKey:function(record, search){
if(this.primaryKey){
for(var j=0;j<this.primaryKey.length;j++){
if(record[this.primaryKey[j]] === search)return true;
}
}
return false;
},
/**
* Find specific records, example:
* var records = collection.findRecords({ country:'Norway'});
* @method findRecords
* @param {Object} search
* @return {Array} records
*/
findRecords:function (search) {
var ret = [];
for (var i = 0; i < this.data.length; i++) {
if (this.isRecordMatchingSearch(this.data[i], search)) {
ret.push(this.data[i]);
}
}
return ret;
},
getLinearData:function(){
return this.data;
},
/**
* Select a specific record
* @method selectRecord
* @param {Object} search
* @return {Object|undefined} record
*/
selectRecord:function (search) {
var rec = this.findRecord(search);
if (rec) {
this._setSelectedRecord(rec);
return rec;
}
return undefined;
},
/**
* Select a collection of records
* @method selectRecords
* @param {Object} search
* @return {Array} records
*/
selectRecords:function (search) {
this.selectedRecords = this.findRecords(search);
for (var i = 0; i < this.selectedRecords.length; i++) {
this.fireSelect(this.selectedRecords[i]);
}
return this.selectedRecords;
},
/**
* Select a specific record by index
* @method selectRecordIndex
* @param {number} index
*/
selectRecordIndex:function (index) {
var data = this._getData();
if (data.length && index >= 0 && index < data.length) {
var rec = data[index];
this._setSelectedRecord(rec);
return rec;
}
return undefined;
},
_getData:function () {
if (this.hasSearchResult())return this.searcher.getData();
return this.data;
},
getRecordByIndex:function (index) {
if (this.data.length && index >= 0 && index < this.data.length) {
return this.data[index];
}
return undefined;
},
/**
* Select previous record. If no record is currently selected, first record will be selected
* @method previous
* @return {Object} record
*/
previous:function () {
var rec = this.getPreviousOf(this.getSelectedRecord());
if (rec) {
this._setSelectedRecord(rec);
}
return rec;
},
/**
* Returns previous record of given record
* @method getPreviousOf
* @param {Object} record
* @return {Object} previous record
*/
getPreviousOf:function (record) {
var data = this._getData();
if (record) {
var index = data.indexOf(record);
return index > 0 ? data[index-1] : undefined;
} else {
return data.length > 0 ? data[0] : undefined;
}
},
/**
* Select next record. If no record is currently selected, first record will be selected
* @method next
* @return {Object} record
*/
next:function () {
var rec = this.getNextOf(this.getSelectedRecord());
if (rec) {
this._setSelectedRecord(rec);
}
return rec;
},
/**
* Returns next record of given record.
* @method getNextOf
* @param {Object} record
* @return {Object} next record
*/
getNextOf:function (record) {
var data = this._getData();
if (record) {
var index = data.indexOf(record);
return index < data.length - 1 ? data[index+1] : undefined;
} else {
return data.length > 0 ? data[0] : undefined;
}
},
_setSelectedRecord:function (rec) {
if (this.selectedRecords.length) {
/**
* Event fired when a record is selected
* @event deselect
* @param {Object} record
*/
this.fireEvent('deselect', this.selectedRecords[0]);
}
this.selectedRecords = [rec];
/**
Event fired when a record is selected
@event select
@param {Object} record
@example
...
listeners:{
'select' : function(record){
console.log(record);
}
}
*/
this.fireSelect(Object.clone(rec));
},
/**
* Return selected record
* @method getSelectedRecord
* @return {Object|undefined} record
*/
getSelectedRecord:function () {
return this.selectedRecords.length > 0 ? this.selectedRecords[0] : undefined;
},
/**
* Return selected records
* @method getSelectedRecords
* @return {Array} records
*/
getSelectedRecords:function () {
return this.selectedRecords;
},
/**
Delete records matching search,
@method deleteRecords
@param {Object} search
@example
grid.getDataSource().deleteRecords({ country: 'Norway' });
will delete all records from collection where country is equal to "Norway". A delete event
will be fired for each deleted record.
*/
deleteRecords:function (search) {
var records = this.findRecords(search);
for (var i = 0; i < records.length; i++) {
this.data.erase(records[i]);
this.fireEvent('delete', records[i]);
}
},
/**
Delete a single record. Deletes first match when
multiple matches found.
@method deleteRecord
@param {Object} search
@example
grid.getDataSource().deleteRecord({ country: 'Norway' });
Will delete first found record where country is equal to Norway. It will fire a
delete event if a record is found and deleted.
*/
deleteRecord:function (search) {
var rec = this.findRecord(search);
if (rec) {
this.data.erase(rec);
/**
* Event fired when a record is deleted
* @event delete
* @param {Object} record
*/
this.fireEvent('delete', rec);
}
},
/**
Select records from current selected record to record matching search,
@method selectTo
@param {Object} search
@example
collection.selectRecord({ country: 'Norway' });
collection.selectTo({country: 'Denmark'});
var selectedRecords = collection.getSelectedRecords();
*/
selectTo:function (search) {
var selected = this.getSelectedRecord();
if (!selected) {
this.selectRecord(search);
return;
}
var rec = this.findRecord(search);
if (rec) {
this.selectedRecords = [];
var index = this.data.indexOf(rec);
var indexSelected = this.data.indexOf(selected);
var i;
if (index > indexSelected) {
for (i = indexSelected; i <= index; i++) {
this.selectedRecords.push(this.data[i]);
this.fireSelect(this.data[i]);
}
} else {
for (i = indexSelected; i >= index; i--) {
this.selectedRecords.push(this.data[i]);
this.fireSelect(this.data[i]);
}
}
}
},
/**
* Update a record
* @method updateRecord
* @param {Object} search
* @param {Object} updates
* @return {dataSource.Record} record
*/
updateRecord:function (search, updates) {
var rec = this.getRecord(search);
if (rec) {
rec.setProperties(updates);
}
return rec;
},
getPostData:function () {
if (!this.paging) {
return this.parent();
}
var ret = this.postData || {};
ret._paging = {
size:this.paging.size,
offset:this.paging.offset
};
ret._sort = this.sortedBy;
return ret;
},
/**
* When paging is enabled, go to previous page.
* fire previousPage event
* @method previousPage
*/
previousPage:function () {
if (!this.paging || this.isOnFirstPage())return;
this.paging.offset -= this.paging.size;
/**
* Event fired when moving to previous page
* @event previousPage
*/
this.onPageChange('previousPage');
},
/**
* When paging is enabled, go to next page
* fire nextPage event
* @method nextPage
*/
nextPage:function () {
if (!this.paging || this.isOnLastPage())return;
this.paging.offset += this.paging.size;
/**
* Event fired when moving to next page
* @event nextPage
*/
this.onPageChange('nextPage');
},
/**
* Go to last page
* @method lastPage
*/
lastPage:function () {
if (!this.paging || this.isOnLastPage())return;
var count = this.getCount();
var decr = count % this.paging.size;
if(decr === 0) decr = this.paging.size;
this.paging.offset = count - decr;
this.onPageChange('lastPage');
},
firstPage:function () {
if (!this.paging || this.isOnFirstPage())return;
this.paging.offset = 0;
/**
* Event fired when moving to first page
* @event firstPage
*/
this.onPageChange('firstPage');
},
isOnFirstPage:function () {
if (!this.paging)return true;
return this.paging.offset === undefined || this.paging.offset === 0;
},
isOnLastPage:function () {
return this.paging.size + this.paging.offset >= this.getCount();
},
onPageChange:function (event) {
if (this.paging['remotePaging']) {
this.loadOrGetFromCache();
}
this.fireEvent('change');
this.fireEvent(event);
this.firePageEvents();
},
loadOrGetFromCache:function () {
if (this.isDataInCache()) {
this.data = this.dataCache[this.getCacheKey()].data;
this.fireEvent('change');
} else {
this.load();
}
},
populateCache:function () {
if (this.isCacheEnabled()) {
this.dataCache[this.getCacheKey()] = {
data:this.data,
time:new Date().getTime()
}
}
},
isDataInCache:function () {
return this.dataCache[this.getCacheKey()] !== undefined && !this.isCacheOutOfDate();
},
clearCache:function(){
this.dataCache = {};
},
isCacheOutOfDate:function () {
if (!this.paging['cacheTimeout'])return false;
var created = this.dataCache[this.getCacheKey()].time;
return created + (this.paging['cacheTimeout'] * 1000) < (new Date().getTime());
},
getCacheKey:function () {
var keys = [
'key', this.paging.offset, this.sortedBy.column, this.sortedBy.order
];
if (this.searcher !== undefined && this.searcher.hasData())keys.push(this.searcher.searchToString());
return keys.join('|');
},
hasData:function(){
return this.data && this.data.length > 0;
},
firePageEvents:function (skipState) {
if (this.isOnLastPage()) {
/**
* Event fired when moving to last page
* @event lastPage
*/
this.fireEvent('lastPage');
} else {
/**
* Event fired when moving to a different page than last page
* @event notLastPage
*/
this.fireEvent('notLastPage');
}
if (this.isOnFirstPage()) {
this.fireEvent('firstPage');
} else {
/**
* Event fired when moving to a different page than last page
* @event notFirstPage
*/
this.fireEvent('notFirstPage');
}
/**
* Event fired when moving to a page
* @event page
* @param {Number} page number
*/
this.fireEvent('page', this.getPageNumber());
if (skipState === undefined)this.fireEvent('state');
},
/**
* Go to a specific page
* @method toPage
* @param {Number} pageNumber
* @return {Boolean} success
*/
toPage:function (pageNumber) {
if (pageNumber > 0 && pageNumber <= this.getPageCount() && !this.isOnPage(pageNumber)) {
this.paging.offset = (pageNumber - 1) * this.paging.size;
/**
* Event fired when moving to a specific page
* @event toPage
*/
this.onPageChange('toPage');
return true;
}
return false;
},
setPageSize:function(size){
if(this.paging){
this.dataCache = {};
this.paging.size = parseInt(size);
this.paging.offset = 0;
this.onPageChange('toPage');
}
},
/**
* True if on given page
* @method isOnPage
* @param {Number} pageNumber
* @return {Boolean}
*/
isOnPage:function (pageNumber) {
return pageNumber == this.getPageNumber();
},
/**
* Return current page number
* @method getPageNumber
* @return {Number} page
*/
getPageNumber:function () {
return this.paging ? Math.floor(this.paging.offset / this.paging.size) + 1 : 1;
},
/**
* Return number of pages
* @method getPageCount
* @return {Number}
*/
getPageCount:function () {
return this.paging ? Math.ceil(this.getCount() / this.paging.size) : 1;
},
getData:function () {
if (this.hasSearchResult()){
if (this.paging && this.paging.size) {
return this.getDataForPage(this.searcher.getData());
}
return this.searcher.getData();
}
if (!this.paging || this.paging.remotePaging) {
return this.parent();
}
return this.getDataForPage(this.data);
},
getDataForPage:function (data) {
if (!data || data.length == 0)return [];
var offset = this.paging.initialOffset || this.paging.offset;
if (offset > data.length) {
this.toPage(this.getPageCount());
offset = (this.getPageCount() - 1) * this.paging.size;
}
this.resetInitialOffset.delay(200, this);
return data.slice(offset, Math.min(data.length, offset + this.paging.size));
},
resetInitialOffset:function () {
this.paging.initialOffset = undefined;
},
loadComplete:function (data, json) {
// TODO refactor this
if (this.paging && json.rows !==undefined)this.paging.rows = json.rows;
if (this.paging && json.response && json.response.rows !==undefined)this.paging.rows = json.response.rows;
this.parent(data, json);
this.fireEvent('count', this.getCount());
if (this.shouldSortAfterLoad()) {
this.sort();
} else {
this.fireEvent('change');
}
if (this.paging !== undefined) {
this.firePageEvents(true);
}
},
createIndex:function () {
this.index = {};
this.indexBranch(this.data);
},
indexBranch:function(branch, parent){
for (var i = 0; i < branch.length; i++) {
this.indexRecord(branch[i], parent);
if(branch[i].children && branch[i].children.length)this.indexBranch(branch[i].children, branch[i]);
}
},
indexRecord:function(record, parent){
if(!this.index)this.createIndex();
if(parent)record.parentUid = parent.uid;
var pk = this.getPrimaryKeyIndexFor(record);
if(pk)this.index[pk] = record;
if(!record.uid)record.uid = ['uid_', String.uniqueID()].join('');
this.index[record.uid] = record;
},
shouldSortAfterLoad:function(){
if(this.paging && this.paging.remotePaging)return false;
return this.sortedBy !== undefined && this.sortedBy.column && this.sortedBy.order;
},
/**
Filter collection based on given search term. To filter on multiple search terms, you should
get a reference to the {{#crossLink "dataSource.CollectionSearch"}}{{/crossLink}} object and
use the available {{#crossLink "dataSource.CollectionSearch"}}{{/crossLink}} methods to add
multiple search terms.
@method Search
@param {String} search
@example
ludo.get('myCollection').search('New York');
// or with the {{#crossLink "dataSource.CollectionSearch/add"}}{{/crossLink}} method
var searcher = ludo.get('myCollection').getSearcher();
searcher.where('New York').execute();
searcher.execute();
*/
search:function (search) {
this.getSearcher().search(search);
},
/**
* Executes a remote search for records with the given data
* @method remoteSearch
* @param {String|Object} search
*/
remoteSearch:function(search){
this.postData = this.postData || {};
this.postData.search = search;
this.toPage(1);
this.load();
},
afterSearch:function(){
var searcher = this.getSearcher();
this.fireEvent('count', searcher.hasData() ? searcher.getCount() : this.getCount());
if (this.paging !== undefined) {
this.paging.offset = 0;
this.firePageEvents(true);
this.fireEvent('pageCount', this.getPageCount());
}
this.fireEvent('change');
},
searcher:undefined,
/**
* Returns a {{#crossLink "dataSource.CollectionSearch"}}{{/crossLink}} object which
* you can use to filter a collection.
* @method getSearcher
* @return {dataSource.CollectionSearch}
*/
getSearcher:function () {
if (this.searcher === undefined) {
this.searchConfig = this.searchConfig || {};
var config = Object.merge({
type:this.searcherType,
dataSource:this
}, this.searchConfig);
this.searcher = ludo._new(config);
this.addSearcherEvents();
}
return this.searcher;
},
addSearcherEvents:function(){
this.searcher.addEvent('search', this.afterSearch.bind(this));
this.searcher.addEvent('deleteSearch', this.afterSearch.bind(this));
},
hasSearchResult:function(){
return this.searcher !== undefined && this.searcher.hasData();
},
/**
Return record by id or undefined if not found. Records are indexed by id. This method
gives you quick access to a record by it's id. The method returns a reference to the
actual record. You can use Object.clone(record) to create a copy of it in case you
want to update the record but not make those changes to the collection.
@method getById
@param {String|Number|Object} id
@return {Object} record
@example
var collection = new ludo.dataSource.Collection({
url : 'get-countries.php',
primaryKey:'country'
});
var record = collection.getById('Japan'); // Returns record for Japan if it exists.
You can also define multiple keys as id
@example
var collection = new ludo.dataSource.Collection({
url : 'get-countries.php',
primaryKey:['id', 'country']
});
var record = collection.getById({ id:1, country:'Japan' });
This is especially useful when you have a {{#crossLink "dataSource.TreeCollection"}}{{/crossLink}}
where child nodes may have same numeric id as it's parent.
@example
{ id:1, type:'country', title : 'Japan',
children:[ { id:1, type:'city', title:'Tokyo }]
By setting primaryKey to ['id', 'type'] will make it possible to distinguish between countries and cities.
*/
getById:function(id){
if(this.index[id] !== undefined){
return this.index[id];
}
if(this.primaryKey.length===1){
return this.index[id];
}else{
var key = [];
for(var i=0;i<this.primaryKey.length;i++){
key.push(id[this.primaryKey[i]]);
}
return this.index[key.join('')];
}
},
recordObjects:{},
/**
Returns {{#crossLink "dataSource.Record"}}{{/crossLink}} object for a record.
If you want to update a record, you should
first get a reference to {{#crossLink "dataSource.Record"}}{{/crossLink}} and then call one
of it's methods.
@method getRecord
@param {String|Object} search
@return {dataSource.Record|undefined}
@example
var collection = new ludo.dataSource.Collection({
url : 'get-countries.php',
primaryKey:'country'
});
collection.getRecord('Japan').set('capital', 'tokyo');
*/
getRecord:function(search){
var rec = this.findRecord(search);
if(rec){
return this.createRecord(rec);
}
return undefined;
},
createRecord:function(data){
var id = data.uid;
if(!this.recordObjects[id]){
this.recordObjects[id] = this.recordInstance(data, this);
this.addRecordEvents(this.recordObjects[id]);
}
return this.recordObjects[id];
},
recordInstance:function(data){
return new ludo.dataSource.Record(data, this);
},
addRecordEvents:function(record){
record.addEvent('update', this.onRecordUpdate.bind(this));
record.addEvent('dispose', this.onRecordDispose.bind(this));
record.addEvent('select', this.selectRecord.bind(this));
},
fireSelect:function(record){
this.fireEvent('select', record);
},
onRecordUpdate:function(record){
this.indexRecord(record);
this.fireEvent('update', record);
},
onRecordDispose:function(record){
var branch = this.getBranchFor(record);
if(branch){
var index = branch.indexOf(record);
if(index !== -1){
branch.splice(index,1);
}
this.removeFromIndex(record);
this.fireEvent('dispose', record);
}
},
getBranchFor:function(record){
if(record.parentUid){
var parent = this.findRecord(record.parentUid);
return parent ? parent.children : undefined;
}else{
return this.data;
}
},
removeFromIndex:function(record){
this.recordObjects[record.uid] = undefined;
this.index[record.uid] = undefined;
var pk = this.getPrimaryKeyIndexFor(record);
if(pk)this.index[pk] = undefined;
},
getPrimaryKeyIndexFor:function(record){
if(this.primaryKey){
var key = [];
for(var j=0;j<this.primaryKey.length;j++){
key.push(record[this.primaryKey[j]]);
}
return key.join('');
}
return undefined;
}
});
ludo.factory.registerClass('dataSource.Collection', ludo.dataSource.Collection);
