lpmp 1.0.0

data/public/ext-3.0.0/src/data/DataReader.js

@@ -0,0 +1,160 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.data.DataReader
+ * Abstract base class for reading structured data from a data source and converting
+ * it into an object containing {@link Ext.data.Record} objects and metadata for use
+ * by an {@link Ext.data.Store}.  This class is intended to be extended and should not
+ * be created directly. For existing implementations, see {@link Ext.data.ArrayReader},
+ * {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}.
+ * @constructor Create a new DataReader
+ * @param {Object} meta Metadata configuration options (implementation-specific).
+ * @param {Array/Object} recordType
+ * <p>Either an Array of {@link Ext.data.Field Field} definition objects (which
+ * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+ * constructor created using {@link Ext.data.Record#create}.</p>
+ */
+Ext.data.DataReader = function(meta, recordType){
+    /**
+     * This DataReader's configured metadata as passed to the constructor.
+     * @type Mixed
+     * @property meta
+     */
+    this.meta = meta;
+    /**
+     * @cfg {Array/Object} fields
+     * <p>Either an Array of {@link Ext.data.Field Field} definition objects (which
+     * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+     * constructor created from {@link Ext.data.Record#create}.</p>
+     */
+    this.recordType = Ext.isArray(recordType) ?
+        Ext.data.Record.create(recordType) : recordType;
+};
+
+Ext.data.DataReader.prototype = {
+
+    /**
+     * Abstract method, overridden in {@link Ext.data.JsonReader}
+     */
+    buildExtractors : Ext.emptyFn,
+
+    /**
+     * Used for un-phantoming a record after a successful database insert.  Sets the records pk along with new data from server.
+     * You <b>must</b> return at least the database pk using the idProperty defined in your DataReader configuration.  The incoming
+     * data from server will be merged with the data in the local record.
+     * In addition, you <b>must</b> return record-data from the server in the same order received.
+     * Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be suppressed.
+     * @param {Record/Record[]} record The phantom record to be realized.
+     * @param {Object/Object[]} data The new record data to apply.  Must include the primary-key from database defined in idProperty field.
+     */
+    realize: function(rs, data){
+        if (Ext.isArray(rs)) {
+            for (var i = rs.length - 1; i >= 0; i--) {
+                // recurse
+                if (Ext.isArray(data)) {
+                    this.realize(rs.splice(i,1).shift(), data.splice(i,1).shift());
+                }
+                else {
+                    // weird...rs is an array but data isn't??  recurse but just send in the whole invalid data object.
+                    // the else clause below will detect !this.isData and throw exception.
+                    this.realize(rs.splice(i,1).shift(), data);
+                }
+            }
+        }
+        else {
+            // If rs is NOT an array but data IS, see if data contains just 1 record.  If so extract it and carry on.
+            if (Ext.isArray(data) && data.length == 1) {
+                data = data.shift();
+            }
+            if (!this.isData(data)) {
+                // TODO: Let exception-handler choose to commit or not rather than blindly rs.commit() here.
+                //rs.commit();
+                throw new Ext.data.DataReader.Error('realize', rs);
+            }
+            this.buildExtractors();
+            var values = this.extractValues(data, rs.fields.items, rs.fields.items.length);
+            rs.phantom = false; // <-- That's what it's all about
+            rs._phid = rs.id;  // <-- copy phantom-id -> _phid, so we can remap in Store#onCreateRecords
+            rs.id = data[this.meta.idProperty];
+            rs.data = values;
+            rs.commit();
+        }
+    },
+
+    /**
+     * Used for updating a non-phantom or "real" record's data with fresh data from server after remote-save.
+     * You <b>must</b> return a complete new record from the server.  If you don't, your local record's missing fields
+     * will be populated with the default values specified in your Ext.data.Record.create specification.  Without a defaultValue,
+     * local fields will be populated with empty string "".  So return your entire record's data after both remote create and update.
+     * In addition, you <b>must</b> return record-data from the server in the same order received.
+     * Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be suppressed as the record receives
+     * a fresh new data-hash.
+     * @param {Record/Record[]} rs
+     * @param {Object/Object[]} data
+     */
+    update : function(rs, data) {
+        if (Ext.isArray(rs)) {
+            for (var i=rs.length-1; i >= 0; i--) {
+                if (Ext.isArray(data)) {
+                    this.update(rs.splice(i,1).shift(), data.splice(i,1).shift());
+                }
+                else {
+                    // weird...rs is an array but data isn't??  recurse but just send in the whole data object.
+                    // the else clause below will detect !this.isData and throw exception.
+                    this.update(rs.splice(i,1).shift(), data);
+                }
+            }
+        }
+        else {
+                     // If rs is NOT an array but data IS, see if data contains just 1 record.  If so extract it and carry on.
+            if (Ext.isArray(data) && data.length == 1) {
+                data = data.shift();
+            }
+            if (!this.isData(data)) {
+                // TODO: create custom Exception class to return record in thrown exception.  Allow exception-handler the choice
+                // to commit or not rather than blindly rs.commit() here.
+                rs.commit();
+                throw new Ext.data.DataReader.Error('update', rs);
+            }
+            this.buildExtractors();
+            rs.data = this.extractValues(Ext.apply(rs.data, data), rs.fields.items, rs.fields.items.length);
+            rs.commit();
+        }
+    },
+
+    /**
+     * Returns true if the supplied data-hash <b>looks</b> and quacks like data.  Checks to see if it has a key
+     * corresponding to idProperty defined in your DataReader config containing non-empty pk.
+     * @param {Object} data
+     * @return {Boolean}
+     */
+    isData : function(data) {
+        return (data && Ext.isObject(data) && !Ext.isEmpty(data[this.meta.idProperty])) ? true : false;
+    }
+};
+
+/**
+ * @class Ext.data.DataReader.Error
+ * @extends Ext.Error
+ * General error class for Ext.data.DataReader
+ */
+Ext.data.DataReader.Error = Ext.extend(Ext.Error, {
+    constructor : function(message, arg) {
+        this.arg = arg;
+        Ext.Error.call(this, message);
+    },
+    name: 'Ext.data.DataReader'
+});
+Ext.apply(Ext.data.DataReader.Error.prototype, {
+    lang : {
+        'update': "#update received invalid data from server.  Please see docs for DataReader#update and review your DataReader configuration.",
+        'realize': "#realize was called with invalid remote-data.  Please see the docs for DataReader#realize and review your DataReader configuration.",
+        'invalid-response': "#readResponse received an invalid response from the server."
+    }
+});
+
+

data/public/ext-3.0.0/src/data/DataWriter.js

@@ -0,0 +1,201 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.data.DataWriter
+ * <p>Ext.data.DataWriter facilitates create, update, and destroy actions between
+ * an Ext.data.Store and a server-side framework. A Writer enabled Store will
+ * automatically manage the Ajax requests to perform CRUD actions on a Store.</p>
+ * <p>Ext.data.DataWriter is an abstract base class which is intended to be extended
+ * and should not be created directly. For existing implementations, see
+ * {@link Ext.data.JsonWriter}.</p>
+ * <p>Creating a writer is simple:</p>
+ * <pre><code>
+var writer = new Ext.data.JsonWriter();
+ * </code></pre>
+ * <p>The proxy for a writer enabled store can be configured with a simple <code>url</code>:</p>
+ * <pre><code>
+// Create a standard HttpProxy instance.
+var proxy = new Ext.data.HttpProxy({
+    url: 'app.php/users'
+});
+ * </code></pre>
+ * <p>For finer grained control, the proxy may also be configured with an <code>api</code>:</p>
+ * <pre><code>
+// Use the api specification
+var proxy = new Ext.data.HttpProxy({
+    api: {
+        read    : 'app.php/users/read',
+        create  : 'app.php/users/create',
+        update  : 'app.php/users/update',
+        destroy : 'app.php/users/destroy'
+    }
+});
+ * </code></pre>
+ * <p>Creating a Writer enabled store:</p>
+ * <pre><code>
+var store = new Ext.data.Store({
+    proxy: proxy,
+    reader: reader,
+    writer: writer
+});
+ * </code></pre>
+ * @constructor Create a new DataWriter
+ * @param {Object} meta Metadata configuration options (implementation-specific)
+ * @param {Object} recordType Either an Array of field definition objects as specified
+ * in {@link Ext.data.Record#create}, or an {@link Ext.data.Record} object created
+ * using {@link Ext.data.Record#create}.
+ */
+Ext.data.DataWriter = function(config){
+    /**
+     * This DataWriter's configured metadata as passed to the constructor.
+     * @type Mixed
+     * @property meta
+     */
+    Ext.apply(this, config);
+};
+
+Ext.data.DataWriter.prototype = {
+
+    /**
+     * @cfg {Boolean} writeAllFields
+     * <tt>false</tt> by default.  Set <tt>true</tt> to have DataWriter return ALL fields of a modified
+     * record -- not just those that changed.
+     * <tt>false</tt> to have DataWriter only request modified fields from a record.
+     */
+    writeAllFields : false,
+    /**
+     * @cfg {Boolean} listful
+     * <tt>false</tt> by default.  Set <tt>true</tt> to have the DataWriter <b>always</b> write HTTP params as a list,
+     * even when acting upon a single record.
+     */
+    listful : false,    // <-- listful is actually not used internally here in DataWriter.  @see Ext.data.Store#execute.
+
+    /**
+     * Writes data in preparation for server-write action.  Simply proxies to DataWriter#update, DataWriter#create
+     * DataWriter#destroy.
+     * @param {String} action [CREATE|UPDATE|DESTROY]
+     * @param {Object} params The params-hash to write-to
+     * @param {Record/Record[]} rs The recordset write.
+     */
+    write : function(action, params, rs) {
+        this.render(action, rs, params, this[action](rs));
+    },
+
+    /**
+     * abstract method meant to be overridden by all DataWriter extensions.  It's the extension's job to apply the "data" to the "params".
+     * The data-object provided to render is populated with data according to the meta-info defined in the user's DataReader config,
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Record[]} rs Store recordset
+     * @param {Object} params Http params to be sent to server.
+     * @param {Object} data object populated according to DataReader meta-data.
+     */
+    render : Ext.emptyFn,
+
+    /**
+     * update
+     * @param {Object} p Params-hash to apply result to.
+     * @param {Record/Record[]} rs Record(s) to write
+     * @private
+     */
+    update : function(rs) {
+        var params = {};
+        if (Ext.isArray(rs)) {
+            var data = [],
+                ids = [];
+            Ext.each(rs, function(val){
+                ids.push(val.id);
+                data.push(this.updateRecord(val));
+            }, this);
+            params[this.meta.idProperty] = ids;
+            params[this.meta.root] = data;
+        }
+        else if (rs instanceof Ext.data.Record) {
+            params[this.meta.idProperty] = rs.id;
+            params[this.meta.root] = this.updateRecord(rs);
+        }
+        return params;
+    },
+
+    /**
+     * @cfg {Function} saveRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#saveRecord JsonWriter.saveRecord}
+     */
+    updateRecord : Ext.emptyFn,
+
+    /**
+     * create
+     * @param {Object} p Params-hash to apply result to.
+     * @param {Record/Record[]} rs Record(s) to write
+     * @private
+     */
+    create : function(rs) {
+        var params = {};
+        if (Ext.isArray(rs)) {
+            var data = [];
+            Ext.each(rs, function(val){
+                data.push(this.createRecord(val));
+            }, this);
+            params[this.meta.root] = data;
+        }
+        else if (rs instanceof Ext.data.Record) {
+            params[this.meta.root] = this.createRecord(rs);
+        }
+        return params;
+    },
+
+    /**
+     * @cfg {Function} createRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#createRecord JsonWriter.createRecord})
+     */
+    createRecord : Ext.emptyFn,
+
+    /**
+     * destroy
+     * @param {Object} p Params-hash to apply result to.
+     * @param {Record/Record[]} rs Record(s) to write
+     * @private
+     */
+    destroy : function(rs) {
+        var params = {};
+        if (Ext.isArray(rs)) {
+            var data = [],
+                ids = [];
+            Ext.each(rs, function(val){
+                data.push(this.destroyRecord(val));
+            }, this);
+            params[this.meta.root] = data;
+        } else if (rs instanceof Ext.data.Record) {
+            params[this.meta.root] = this.destroyRecord(rs);
+        }
+        return params;
+    },
+
+    /**
+     * @cfg {Function} destroyRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#destroyRecord JsonWriter.destroyRecord})
+     */
+    destroyRecord : Ext.emptyFn,
+
+    /**
+     * Converts a Record to a hash
+     * @param {Record}
+     * @private
+     */
+    toHash : function(rec) {
+        var map = rec.fields.map,
+            data = {},
+            raw = (this.writeAllFields === false && rec.phantom === false) ? rec.getChanges() : rec.data,
+            m;
+        Ext.iterate(raw, function(prop, value){
+            if((m = map[prop])){
+                data[m.mapping ? m.mapping : m.name] = value;
+            }
+        });
+        data[this.meta.idProperty] = rec.id;
+        return data;
+    }
+};

data/public/ext-3.0.0/src/data/DirectProxy.js

@@ -0,0 +1,141 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.data.DirectProxy
+ * @extends Ext.data.DataProxy
+ */
+Ext.data.DirectProxy = function(config){
+    Ext.apply(this, config);
+    if(typeof this.paramOrder == 'string'){
+        this.paramOrder = this.paramOrder.split(/[\s,|]/);
+    }
+    Ext.data.DirectProxy.superclass.constructor.call(this, config);
+};
+
+Ext.extend(Ext.data.DirectProxy, Ext.data.DataProxy, {
+    /**
+     * @cfg {Array/String} paramOrder Defaults to <tt>undefined</tt>. A list of params to be executed
+     * server side.  Specify the params in the order in which they must be executed on the server-side
+     * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace,
+     * comma, or pipe. For example,
+     * any of the following would be acceptable:<pre><code>
+paramOrder: ['param1','param2','param3']
+paramOrder: 'param1 param2 param3'
+paramOrder: 'param1,param2,param3'
+paramOrder: 'param1|param2|param'
+     </code></pre>
+     */
+    paramOrder: undefined,
+
+    /**
+     * @cfg {Boolean} paramsAsHash
+     * Send parameters as a collection of named arguments (defaults to <tt>true</tt>). Providing a
+     * <tt>{@link #paramOrder}</tt> nullifies this configuration.
+     */
+    paramsAsHash: true,
+
+    /**
+     * @cfg {Function} directFn
+     * Function to call when executing a request.  directFn is a simple alternative to defining the api configuration-parameter
+     * for Store's which will not implement a full CRUD api.
+     */
+    directFn : undefined,
+
+    // protected
+    doRequest : function(action, rs, params, reader, callback, scope, options) {
+        var args = [];
+        var directFn = this.api[action] || this.directFn;
+
+        switch (action) {
+            case Ext.data.Api.actions.create:
+                args.push(params[reader.meta.root]);		// <-- create(Hash)
+                break;
+            case Ext.data.Api.actions.read:
+                if(this.paramOrder){
+                    for(var i = 0, len = this.paramOrder.length; i < len; i++){
+                        args.push(params[this.paramOrder[i]]);
+                    }
+                }else if(this.paramsAsHash){
+                    args.push(params);
+                }
+                break;
+            case Ext.data.Api.actions.update:
+                args.push(params[reader.meta.idProperty]);  // <-- save(Integer/Integer[], Hash/Hash[])
+                args.push(params[reader.meta.root]);
+                break;
+            case Ext.data.Api.actions.destroy:
+                args.push(params[reader.meta.root]);        // <-- destroy(Int/Int[])
+                break;
+        }
+
+        var trans = {
+            params : params || {},
+            callback : callback,
+            scope : scope,
+            arg : options,
+            reader: reader
+        };
+
+        args.push(this.createCallback(action, rs, trans), this);
+        directFn.apply(window, args);
+    },
+
+    // private
+    createCallback : function(action, rs, trans) {
+        return function(result, res) {
+            if (!res.status) {
+                // @deprecated fire loadexception
+                if (action === Ext.data.Api.actions.read) {
+                    this.fireEvent("loadexception", this, trans, res, null);
+                }
+                this.fireEvent('exception', this, 'remote', action, trans, res, null);
+                trans.callback.call(trans.scope, null, trans.arg, false);
+                return;
+            }
+            if (action === Ext.data.Api.actions.read) {
+                this.onRead(action, trans, result, res);
+            } else {
+                this.onWrite(action, trans, result, res, rs);
+            }
+        };
+    },
+    /**
+     * Callback for read actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @private
+     */
+    onRead : function(action, trans, result, res) {
+        var records;
+        try {
+            records = trans.reader.readRecords(result);
+        }
+        catch (ex) {
+            // @deprecated: Fire old loadexception for backwards-compat.
+            this.fireEvent("loadexception", this, trans, res, ex);
+
+            this.fireEvent('exception', this, 'response', action, trans, res, ex);
+            trans.callback.call(trans.scope, null, trans.arg, false);
+            return;
+        }
+        this.fireEvent("load", this, res, trans.arg);
+        trans.callback.call(trans.scope, records, trans.arg, true);
+    },
+    /**
+     * Callback for write actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @private
+     */
+    onWrite : function(action, trans, result, res, rs) {
+        this.fireEvent("write", this, action, result, res, rs, trans.arg);
+        trans.callback.call(trans.scope, result, res, true);
+    }
+});
+