Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.grid.tests.databaseModel"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.grid.tests.databaseModel"] = true;
dojo.provide("dojox.grid.tests.databaseModel");
dojo.require("dojox.grid._data.model");

// Provides a sparse array that is also traversable inorder 
// with basic Array:
//   - iterating by index is slow for large sparse arrays
//   - for...in iteration is in order of element creation 
// maintains a secondary index for interating
// over sparse elements inorder
dojo.declare("dojox.grid.Sparse", null, {
        constructor: function() {
                this.clear();
        },
        clear: function() {
                this.indices = [];
                this.values = [];
        },
        length: function() {
                return this.indices.length;
        },
        set: function(inIndex, inValue) {
                for (var i=0,l=this.indices.length; i<l; i++) {
                        if (this.indices[i] >= inIndex) 
                                break;
                }
                if (this.indices[i] != inIndex) 
                        this.indices.splice(i, 0, inIndex);
                this.values[inIndex] = inValue;
        },
        get: function(inIndex) {
                return this.values[inIndex];
        },
        remove: function(inIndex) {
                for (var i=0,l=this.indices.length; i<l; i++) 
                        if (this.indices[i] == inIndex) {
                                this.indices.splice(i, 1);
                                break;
                        }
                delete this.values[inIndex];
        },
        inorder: function(inFor) {
                for (var i=0,l=this.indices.length, ix; i<l; i++) {
                        ix = this.indices[i];
                        if (inFor(this.values[ix], ix) === false)
                                break;
                }
        }
});

// sample custom model implementation that works with mysql server.
dojo.declare("dojox.grid.data.DbTable", dojox.grid.data.Dynamic, {
        delayedInsertCommit: true,
        constructor: function(inFields, inData, inServer, inDatabase, inTable) {
                this.server = inServer;
                this.database = inDatabase;
                this.table = inTable;
                this.stateNames = ['inflight', 'inserting', 'removing', 'error'];
                this.clearStates();
                this.clearSort();
        },
        clearData: function() {
                this.cache = [ ];
                this.clearStates();
                this.inherited(arguments);
        },
        clearStates: function() {
                this.states = {};
                for (var i=0, s; (s=this.stateNames[i]); i++) {
                        delete this.states[s];
                        this.states[s] = new dojox.grid.Sparse();
                }
        },
        // row state information
        getState: function(inRowIndex) {
                for (var i=0, r={}, s; (s=this.stateNames[i]); i++)
                        r[s] = this.states[s].get(inRowIndex);
                return r;
        },
        setState: function(inRowIndex, inState, inValue) {
                this.states[inState].set(inRowIndex, inValue||true);
        },
        clearState: function(inRowIndex, inState) {
                if (arguments.length == 1) {
                        for (var i=0, s; (s=this.stateNames[i]); i++)
                                this.states[s].remove(inRowIndex);
                }       else {
                        for (var i=1, l=arguments.length, arg; (i<l) &&((arg=arguments[i])!=undefined); i++)
                                this.states[arg].remove(inRowIndex);
                }
        },
        setStateForIndexes: function(inRowIndexes, inState, inValue) {
                for (var i=inRowIndexes.length-1, k; (i>=0) && ((k=inRowIndexes[i])!=undefined); i--)
                        this.setState(k, inState, inValue);
        },
        clearStateForIndexes: function(inRowIndexes, inState) {
                for (var i=inRowIndexes.length-1, k; (i>=0) && ((k=inRowIndexes[i])!=undefined); i--)
                        this.clearState(k, inState);
        },
        //$ Return boolean stating whether or not an operation is in progress that may change row indexing.
        isAddRemoving: function() {
                return Boolean(this.states['inserting'].length() || this.states['removing'].length());
        },
        isInflight: function() {
                return Boolean(this.states['inflight'].length());
        },
        //$ Return boolean stating if the model is currently undergoing any type of edit.
        isEditing: function() {
                for (var i=0, r={}, s; (s=this.stateNames[i]); i++)
                        if (this.states[s].length())
                                return true;
        },
        //$ Return true if ok to modify the given row. Override as needed, using model editing state information.
        canModify: function(inRowIndex) {
                return !this.getState(inRowIndex).inflight && !(this.isInflight() && this.isAddRemoving());
        },
        // server send / receive
        getSendParams: function(inParams) {
                var p = {
                        database: this.database || '',
                        table: this.table || ''
                }
                return dojo.mixin(p, inParams || {});
        },
        send: function(inAsync, inParams, inCallbacks) {
                //console.log('send', inParams.command);
                var p = this.getSendParams(inParams);
                var d = dojo.xhrPost({
                        url: this.server,
                        content: p,
                        handleAs: 'json-comment-filtered',
                        contentType: "application/x-www-form-urlencoded; charset=utf-8",
                        sync: !inAsync
                });
                d.addCallbacks(dojo.hitch(this, "receive", inCallbacks), dojo.hitch(this, "receiveError", inCallbacks));
                return d;
        },
        _callback: function(cb, eb, data) {
                try{ cb && cb(data); } 
                catch(e){ eb && eb(data, e); }
        },
        receive: function(inCallbacks, inData) {
                inCallbacks && this._callback(inCallbacks.callback, inCallbacks.errback, inData);
        },
        receiveError: function(inCallbacks, inErr) {
                this._callback(inCallbacks.errback, null, inErr)
        },
        encodeRow: function(inParams, inRow, inPrefix) {
                for (var i=0, l=inRow.length; i < l; i++)
                        inParams['_' + (inPrefix ? inPrefix : '') + i] = (inRow[i] ? inRow[i] : '');
        },
        measure: function() {
                this.send(true, { command: 'info' }, { callback: dojo.hitch(this, this.callbacks.info) });
        },
        fetchRowCount: function(inCallbacks) {
                this.send(true, { command: 'count' }, inCallbacks);
        },
        // server commits
        commitEdit: function(inOldData, inNewData, inRowIndex, inCallbacks) {
                this.setState(inRowIndex, "inflight", true);
                var params = {command: 'update'};
                this.encodeRow(params, inOldData, 'o');
                this.encodeRow(params, inNewData);
                this.send(true, params, inCallbacks);
        },
        commitInsert: function(inRowIndex, inNewData, inCallbacks) {
                this.setState(inRowIndex, "inflight", true);
                var params = {command: 'insert'};
                this.encodeRow(params, inNewData);
                this.send(true, params, inCallbacks);
        },
        // NOTE: supported only in tables with pk
        commitDelete: function(inRows, inCallbacks) {
                var params = { 
                        command: 'delete',
                        count: inRows.length
                }       
                var pk = this.getPkIndex();
                if (pk < 0)
                        return;
                for (var i=0; i < inRows.length; i++)   {
                        params['_' + i] = inRows[i][pk];
                }       
                this.send(true, params, inCallbacks);
        },
        getUpdateCallbacks: function(inRowIndex) {
                return {
                        callback: dojo.hitch(this, this.callbacks.update, inRowIndex), 
                        errback: dojo.hitch(this, this.callbacks.updateError, inRowIndex)
                };
        },
        // primary key from fields
        getPkIndex: function() {
                for (var i=0, l=this.fields.count(), f; (i<l) && (f=this.fields.get(i)); i++)
                        if (f.Key = 'PRI')
                                return i;
                return -1;              
        },
        // model implementations
        update: function(inOldData, inNewData, inRowIndex) {
                var cbs = this.getUpdateCallbacks(inRowIndex);
                if (this.getState(inRowIndex).inserting)
                        this.commitInsert(inRowIndex, inNewData, cbs);
                else
                        this.commitEdit(this.cache[inRowIndex] || inOldData, inNewData, inRowIndex, cbs);
                // set push data immediately to model   so reflectd while committing
                this.setRow(inNewData, inRowIndex);
        },
        insert: function(inData, inRowIndex) {
                this.setState(inRowIndex, 'inserting', true);
                if (!this.delayedInsertCommit)
                        this.commitInsert(inRowIndex, inData, this.getUpdateCallbacks(inRowIndex));
                return this.inherited(arguments);
        },
        remove: function(inRowIndexes) {
                var rows = [];
                for (var i=0, r=0, indexes=[]; (r=inRowIndexes[i]) !== undefined; i++)
                        if (!this.getState(r).inserting) {
                                rows.push(this.getRow(r));
                                indexes.push(r);
                                this.setState(r, 'removing');
                        }
                var cbs = {
                        callback: dojo.hitch(this, this.callbacks.remove, indexes),
                        errback: dojo.hitch(this, this.callbacks.removeError, indexes)
                };
                this.commitDelete(rows, cbs);
                dojox.grid.data.Dynamic.prototype.remove.apply(this, arguments);
        },
        cancelModifyRow: function(inRowIndex) {
                if (this.isDelayedInsert(inRowIndex)) {
                        this.removeInsert(inRowIndex);
                } else
                        this.finishUpdate(inRowIndex);
        },      
        finishUpdate: function(inRowIndex, inData) {
                this.clearState(inRowIndex);
                var d = (inData&&inData[0]) || this.cache[inRowIndex];
                if (d)
                        this.setRow(d, inRowIndex);
                delete this.cache[inRowIndex];
        },
        isDelayedInsert: function(inRowIndex) {
                return (this.delayedInsertCommit && this.getState(inRowIndex).inserting);
        },
        removeInsert: function(inRowIndex) {
                this.clearState(inRowIndex);
                dojox.grid.data.Dynamic.prototype.remove.call(this, [inRowIndex]);
        },
        // request data 
        requestRows: function(inRowIndex, inCount)      {
                var params = { 
                        command: 'select',
                        orderby: this.sortField, 
                        desc: (this.sortDesc ? "true" : ''),
                        offset: inRowIndex, 
                        limit: inCount
                }
                this.send(true, params, {callback: dojo.hitch(this, this.callbacks.rows, inRowIndex)});
        },
        // sorting
        canSort: function () { 
                return true; 
        },
        setSort: function(inSortIndex) {
                this.sortField = this.fields.get(Math.abs(inSortIndex) - 1).name || inSortIndex;
                this.sortDesc = (inSortIndex < 0);
        },
        sort: function(inSortIndex) {
                this.setSort(inSortIndex);
                this.clearData();
        },
        clearSort: function(){
                this.sortField = '';
                this.sortDesc = false;
        },
        endModifyRow: function(inRowIndex){
                var cache = this.cache[inRowIndex];
                var m = false;
                if(cache){
                        var data = this.getRow(inRowIndex);
                        if(!dojox.grid.arrayCompare(cache, data)){
                                m = true;
                                this.update(cache, data, inRowIndex);
                        }       
                }
                if (!m)
                        this.cancelModifyRow(inRowIndex);
        },
        // server callbacks (called with this == model)
        callbacks: {
                update: function(inRowIndex, inData) {
                        console.log('received update', arguments);
                        if (inData.error)
                                this.updateError(inData)
                        else
                                this.finishUpdate(inRowIndex, inData);
                },
                updateError: function(inRowIndex) {
                        this.clearState(inRowIndex, 'inflight');
                        this.setState(inRowIndex, "error", "update failed: " + inRowIndex);
                        this.rowChange(this.getRow(inRowIndex), inRowIndex);
                },
                remove: function(inRowIndexes) {
                        this.clearStateForIndexes(inRowIndexes);
                },
                removeError: function(inRowIndexes) {
                        this.clearStateForIndexes(inRowIndexes);
                        alert('Removal error. Please refresh.');
                },
                rows: function(inRowIndex, inData) {
                        //this.beginUpdate();
                        for (var i=0, l=inData.length; i<l; i++)
                                this.setRow(inData[i], inRowIndex + i);
                        //this.endUpdate();
                        //this.allChange();
                },
                count: function(inRowCount) {
                        this.count = Number(inRowCount);
                        this.clearData();
                },
                info: function(inInfo) {
                        this.fields.clear();
                        for (var i=0, c; (c=inInfo.columns[i]); i++) {
                                c.name = c.Field;
                                this.fields.set(i, c);
                        }
                        this.table = inInfo.table;
                        this.database = inInfo.database;
                        this.notify("MetaData", arguments);
                        this.callbacks.count.call(this, inInfo.count);
                }
        }
});

}