Record.js
上传用户:shuoshiled
上传日期:2018-01-28
资源大小:10124k
文件大小:15k
源码类别:

中间件编程

开发平台:

JavaScript

  1. /*!
  2.  * Ext JS Library 3.0.0
  3.  * Copyright(c) 2006-2009 Ext JS, LLC
  4.  * licensing@extjs.com
  5.  * http://www.extjs.com/license
  6.  */
  7. /**
  8.  * @class Ext.data.Record
  9.  * <p>Instances of this class encapsulate both Record <em>definition</em> information, and Record
  10.  * <em>value</em> information for use in {@link Ext.data.Store} objects, or any code which needs
  11.  * to access Records cached in an {@link Ext.data.Store} object.</p>
  12.  * <p>Constructors for this class are generated by passing an Array of field definition objects to {@link #create}.
  13.  * Instances are usually only created by {@link Ext.data.Reader} implementations when processing unformatted data
  14.  * objects.</p>
  15.  * <p>Note that an instance of a Record class may only belong to one {@link Ext.data.Store Store} at a time.
  16.  * In order to copy data from one Store to another, use the {@link #copy} method to create an exact
  17.  * copy of the Record, and insert the new instance into the other Store.</p>
  18.  * <p>When serializing a Record for submission to the server, be aware that it contains many private
  19.  * properties, and also a reference to its owning Store which in turn holds references to its Records.
  20.  * This means that a whole Record may not be encoded using {@link Ext.util.JSON.encode}. Instead, use the
  21.  * <code>{@link #data}</code> and <code>{@link #id}</code> properties.</p>
  22.  * <p>Record objects generated by this constructor inherit all the methods of Ext.data.Record listed below.</p>
  23.  * @constructor
  24.  * This constructor should not be used to create Record objects. Instead, use {@link #create} to
  25.  * generate a subclass of Ext.data.Record configured with information about its constituent fields.
  26.  * @param {Object} data (Optional) An object, the properties of which provide values for the new Record's
  27.  * fields. If not specified the <code>{@link Ext.data.Field#defaultValue defaultValue}</code>
  28.  * for each field will be assigned.
  29.  * @param {Object} id (Optional) The id of the Record. This id should be unique, and is used by the
  30.  * {@link Ext.data.Store} object which owns the Record to index its collection of Records. If
  31.  * an <code>id</code> is not specified a <b><code>{@link #phantom}</code></b> Record will be created
  32.  * with an {@link #Record.id automatically generated id}.
  33.  */
  34. Ext.data.Record = function(data, id){
  35.     // if no id, call the auto id method
  36.     this.id = (id || id === 0) ? id : Ext.data.Record.id(this);
  37.     this.data = data || {};
  38. };
  39. /**
  40.  * Generate a constructor for a specific Record layout.
  41.  * @param {Array} o An Array of <b>{@link Ext.data.Field Field}</b> definition objects.
  42.  * The constructor generated by this method may be used to create new Record instances. The data
  43.  * object must contain properties named after the {@link Ext.data.Field field}
  44.  * <b><tt>{@link Ext.data.Field#name}s</tt></b>.  Example usage:<pre><code>
  45. // create a Record constructor from a description of the fields
  46. var TopicRecord = Ext.data.Record.create([ // creates a subclass of Ext.data.Record
  47.     {{@link Ext.data.Field#name name}: 'title', {@link Ext.data.Field#mapping mapping}: 'topic_title'},
  48.     {name: 'author', mapping: 'username', allowBlank: false},
  49.     {name: 'totalPosts', mapping: 'topic_replies', type: 'int'},
  50.     {name: 'lastPost', mapping: 'post_time', type: 'date'},
  51.     {name: 'lastPoster', mapping: 'user2'},
  52.     {name: 'excerpt', mapping: 'post_text', allowBlank: false},
  53.     // In the simplest case, if no properties other than <tt>name</tt> are required,
  54.     // a field definition may consist of just a String for the field name.
  55.     'signature'
  56. ]);
  57. // create Record instance
  58. var myNewRecord = new TopicRecord(
  59.     {
  60.         title: 'Do my job please',
  61.         author: 'noobie',
  62.         totalPosts: 1,
  63.         lastPost: new Date(),
  64.         lastPoster: 'Animal',
  65.         excerpt: 'No way dude!',
  66.         signature: ''
  67.     },
  68.     id // optionally specify the id of the record otherwise {@link #Record.id one is auto-assigned}
  69. );
  70. myStore.{@link Ext.data.Store#add add}(myNewRecord);
  71. </code></pre>
  72.  * @method create
  73.  * @return {function} A constructor which is used to create new Records according
  74.  * to the definition. The constructor has the same signature as {@link #Ext.data.Record}.
  75.  * @static
  76.  */
  77. Ext.data.Record.create = function(o){
  78.     var f = Ext.extend(Ext.data.Record, {});
  79.     var p = f.prototype;
  80.     p.fields = new Ext.util.MixedCollection(false, function(field){
  81.         return field.name;
  82.     });
  83.     for(var i = 0, len = o.length; i < len; i++){
  84.         p.fields.add(new Ext.data.Field(o[i]));
  85.     }
  86.     f.getField = function(name){
  87.         return p.fields.get(name);
  88.     };
  89.     return f;
  90. };
  91. Ext.data.Record.PREFIX = 'ext-record';
  92. Ext.data.Record.AUTO_ID = 1;
  93. Ext.data.Record.EDIT = 'edit';
  94. Ext.data.Record.REJECT = 'reject';
  95. Ext.data.Record.COMMIT = 'commit';
  96. /**
  97.  * Generates a sequential id. This method is typically called when a record is {@link #create}d
  98.  * and {@link #Record no id has been specified}. The returned id takes the form:
  99.  * <tt>&#123;PREFIX}-&#123;AUTO_ID}</tt>.<div class="mdetail-params"><ul>
  100.  * <li><b><tt>PREFIX</tt></b> : String<p class="sub-desc"><tt>Ext.data.Record.PREFIX</tt>
  101.  * (defaults to <tt>'ext-record'</tt>)</p></li>
  102.  * <li><b><tt>AUTO_ID</tt></b> : String<p class="sub-desc"><tt>Ext.data.Record.AUTO_ID</tt>
  103.  * (defaults to <tt>1</tt> initially)</p></li>
  104.  * </ul></div>
  105.  * @param {Record} rec The record being created.  The record does not exist, it's a {@link #phantom}.
  106.  * @return {String} auto-generated string id, <tt>"ext-record-i++'</tt>;
  107.  */
  108. Ext.data.Record.id = function(rec) {
  109.     rec.phantom = true;
  110.     return [Ext.data.Record.PREFIX, '-', Ext.data.Record.AUTO_ID++].join('');
  111. };
  112. Ext.data.Record.prototype = {
  113.     /**
  114.      * <p><b>This property is stored in the Record definition's <u>prototype</u></b></p>
  115.      * A MixedCollection containing the defined {@link Ext.data.Field Field}s for this Record.  Read-only.
  116.      * @property fields
  117.      * @type Ext.util.MixedCollection
  118.      */
  119.     /**
  120.      * An object hash representing the data for this Record. Every field name in the Record definition
  121.      * is represented by a property of that name in this object. Note that unless you specified a field
  122.      * with {@link Ext.data.Field#name name} "id" in the Record definition, this will <b>not</b> contain
  123.      * an <tt>id</tt> property.
  124.      * @property data
  125.      * @type {Object}
  126.      */
  127.     /**
  128.      * The unique ID of the Record {@link #Record as specified at construction time}.
  129.      * @property id
  130.      * @type {Object}
  131.      */
  132.     /**
  133.      * Readonly flag - true if this Record has been modified.
  134.      * @type Boolean
  135.      */
  136.     dirty : false,
  137.     editing : false,
  138.     error: null,
  139.     /**
  140.      * This object contains a key and value storing the original values of all modified
  141.      * fields or is null if no fields have been modified.
  142.      * @property modified
  143.      * @type {Object}
  144.      */
  145.     modified: null,
  146.     /**
  147.      * <tt>false</tt> when the record does not yet exist in a server-side database (see
  148.      * {@link #markDirty}).  Any record which has a real database pk set as its id property
  149.      * is NOT a phantom -- it's real.
  150.      * @property phantom
  151.      * @type {Boolean}
  152.      */
  153.     phantom : false,
  154.     // private
  155.     join : function(store){
  156.         /**
  157.          * The {@link Ext.data.Store} to which this Record belongs.
  158.          * @property store
  159.          * @type {Ext.data.Store}
  160.          */
  161.         this.store = store;
  162.     },
  163.     /**
  164.      * Set the {@link Ext.data.Field#name named field} to the specified value.  For example:
  165.      * <pre><code>
  166. // record has a field named 'firstname'
  167. var Employee = Ext.data.Record.{@link #create}([
  168.     {name: 'firstname'},
  169.     ...
  170. ]);
  171. // update the 2nd record in the store:
  172. var rec = myStore.{@link Ext.data.Store#getAt getAt}(1);
  173. // set the value (shows dirty flag):
  174. rec.set('firstname', 'Betty');
  175. // commit the change (removes dirty flag):
  176. rec.{@link #commit}();
  177. // update the record in the store, bypass setting dirty flag,
  178. // and do not store the change in the {@link Ext.data.Store#getModifiedRecords modified records}
  179. rec.{@link #data}['firstname'] = 'Wilma'); // updates record, but not the view
  180. rec.{@link #commit}(); // updates the view
  181.      * </code></pre>
  182.      * <b>Notes</b>:<div class="mdetail-params"><ul>
  183.      * <li>If the store has a writer and <code>autoSave=true</code>, each set()
  184.      * will execute an XHR to the server.</li>
  185.      * <li>Use <code>{@link #beginEdit}</code> to prevent the store's <code>update</code>
  186.      * event firing while using set().</li>
  187.      * <li>Use <code>{@link #endEdit}</code> to have the store's <code>update</code>
  188.      * event fire.</li>
  189.      * </ul></div>
  190.      * @param {String} name The {@link Ext.data.Field#name name of the field} to set.
  191.      * @param {Object} value The value to set the field to.
  192.      */
  193.     set : function(name, value){
  194.         var isObj = (typeof value === 'object');
  195.         if(!isObj && String(this.data[name]) === String(value)){
  196.             return;
  197.         } else if (isObj && Ext.encode(this.data[name]) === Ext.encode(value)) {
  198.             return;
  199.         }
  200.         this.dirty = true;
  201.         if(!this.modified){
  202.             this.modified = {};
  203.         }
  204.         if(typeof this.modified[name] == 'undefined'){
  205.             this.modified[name] = this.data[name];
  206.         }
  207.         this.data[name] = value;
  208.         if(!this.editing){
  209.             this.afterEdit();
  210.         }
  211.     },
  212.     // private
  213.     afterEdit: function(){
  214.         if(this.store){
  215.             this.store.afterEdit(this);
  216.         }
  217.     },
  218.     // private
  219.     afterReject: function(){
  220.         if(this.store){
  221.             this.store.afterReject(this);
  222.         }
  223.     },
  224.     // private
  225.     afterCommit: function(){
  226.         if(this.store){
  227.             this.store.afterCommit(this);
  228.         }
  229.     },
  230.     /**
  231.      * Get the value of the {@link Ext.data.Field#name named field}.
  232.      * @param {String} name The {@link Ext.data.Field#name name of the field} to get the value of.
  233.      * @return {Object} The value of the field.
  234.      */
  235.     get : function(name){
  236.         return this.data[name];
  237.     },
  238.     /**
  239.      * Begin an edit. While in edit mode, no events (e.g.. the <code>update</code> event)
  240.      * are relayed to the containing store.
  241.      * See also: <code>{@link #endEdit}</code> and <code>{@link #cancelEdit}</code>.
  242.      */
  243.     beginEdit : function(){
  244.         this.editing = true;
  245.         this.modified = this.modified || {};
  246.     },
  247.     /**
  248.      * Cancels all changes made in the current edit operation.
  249.      */
  250.     cancelEdit : function(){
  251.         this.editing = false;
  252.         delete this.modified;
  253.     },
  254.     /**
  255.      * End an edit. If any data was modified, the containing store is notified
  256.      * (ie, the store's <code>update</code> event will fire).
  257.      */
  258.     endEdit : function(){
  259.         this.editing = false;
  260.         if(this.dirty){
  261.             this.afterEdit();
  262.         }
  263.     },
  264.     /**
  265.      * Usually called by the {@link Ext.data.Store} which owns the Record.
  266.      * Rejects all changes made to the Record since either creation, or the last commit operation.
  267.      * Modified fields are reverted to their original values.
  268.      * <p>Developers should subscribe to the {@link Ext.data.Store#update} event
  269.      * to have their code notified of reject operations.</p>
  270.      * @param {Boolean} silent (optional) True to skip notification of the owning
  271.      * store of the change (defaults to false)
  272.      */
  273.     reject : function(silent){
  274.         var m = this.modified;
  275.         for(var n in m){
  276.             if(typeof m[n] != "function"){
  277.                 this.data[n] = m[n];
  278.             }
  279.         }
  280.         this.dirty = false;
  281.         delete this.modified;
  282.         this.editing = false;
  283.         if(silent !== true){
  284.             this.afterReject();
  285.         }
  286.     },
  287.     /**
  288.      * Usually called by the {@link Ext.data.Store} which owns the Record.
  289.      * Commits all changes made to the Record since either creation, or the last commit operation.
  290.      * <p>Developers should subscribe to the {@link Ext.data.Store#update} event
  291.      * to have their code notified of commit operations.</p>
  292.      * @param {Boolean} silent (optional) True to skip notification of the owning
  293.      * store of the change (defaults to false)
  294.      */
  295.     commit : function(silent){
  296.         this.dirty = false;
  297.         delete this.modified;
  298.         this.editing = false;
  299.         if(silent !== true){
  300.             this.afterCommit();
  301.         }
  302.     },
  303.     /**
  304.      * Gets a hash of only the fields that have been modified since this Record was created or commited.
  305.      * @return Object
  306.      */
  307.     getChanges : function(){
  308.         var m = this.modified, cs = {};
  309.         for(var n in m){
  310.             if(m.hasOwnProperty(n)){
  311.                 cs[n] = this.data[n];
  312.             }
  313.         }
  314.         return cs;
  315.     },
  316.     // private
  317.     hasError : function(){
  318.         return this.error !== null;
  319.     },
  320.     // private
  321.     clearError : function(){
  322.         this.error = null;
  323.     },
  324.     /**
  325.      * Creates a copy of this Record.
  326.      * @param {String} id (optional) A new Record id, defaults to {@link #Record.id autogenerating an id}.
  327.      * Note: if an <code>id</code> is not specified the copy created will be a
  328.      * <code>{@link #phantom}</code> Record.
  329.      * @return {Record}
  330.      */
  331.     copy : function(newId) {
  332.         return new this.constructor(Ext.apply({}, this.data), newId || this.id);
  333.     },
  334.     /**
  335.      * Returns <tt>true</tt> if the passed field name has been <code>{@link #modified}</code>
  336.      * since the load or last commit.
  337.      * @param {String} fieldName {@link Ext.data.Field.{@link Ext.data.Field#name}
  338.      * @return {Boolean}
  339.      */
  340.     isModified : function(fieldName){
  341.         return !!(this.modified && this.modified.hasOwnProperty(fieldName));
  342.     },
  343.     /**
  344.      * By default returns <tt>false</tt> if any {@link Ext.data.Field field} within the
  345.      * record configured with <tt>{@link Ext.data.Field#allowBlank} = false</tt> returns
  346.      * <tt>true</tt> from an {@link Ext}.{@link Ext#isEmpty isempty} test.
  347.      * @return {Boolean}
  348.      */
  349.     isValid : function() {
  350.         return this.fields.find(function(f) {
  351.             return (f.allowBlank === false && Ext.isEmpty(this.data[f.name])) ? true : false;
  352.         },this) ? false : true;
  353.     },
  354.     /**
  355.      * <p>Marks this <b>Record</b> as <code>{@link #dirty}</code>.  This method
  356.      * is used interally when adding <code>{@link #phantom}</code> records to a
  357.      * {@link Ext.data.Store#writer writer enabled store}.</p>
  358.      * <br><p>Marking a record <code>{@link #dirty}</code> causes the phantom to
  359.      * be returned by {@link Ext.data.Store#getModifiedRecords} where it will
  360.      * have a create action composed for it during {@link Ext.data.Store#save store save}
  361.      * operations.</p>
  362.      */
  363.     markDirty : function(){
  364.         this.dirty = true;
  365.         if(!this.modified){
  366.             this.modified = {};
  367.         }
  368.         this.fields.each(function(f) {
  369.             this.modified[f.name] = this.data[f.name];
  370.         },this);
  371.     }
  372. };