Ext JS Sencha Docs

Ext.data.Model

Alternate names

Ext.data.Record

Hierarchy

Ext.Base
Ext.data.Model

Requires

Ext.data.field.*
Ext.data.operation.*

Subclasses

Uses

Files

A Model or Entity represents some object that your application manages. For example, one might define a Model for Users, Products, Cars, or other real-world object that we want to model in the system. Models are used by stores, which are in turn used by many of the data-bound components in Ext.

Fields

Models are defined as a set of fields and any arbitrary methods and properties relevant to the model. For example:

Ext.define('User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'name',  type: 'string'},
        {name: 'age',   type: 'int', convert: null},
        {name: 'phone', type: 'string'},
        {name: 'alive', type: 'boolean', defaultValue: true, convert: null}
    ],

    changeName: function() {
        var oldName = this.get('name'),
            newName = oldName + " The Barbarian";

        this.set('name', newName);
    }
});

Now we can create instances of our User model and call any model logic we defined:

var user = Ext.create('User', {
    id   : 'ABCD12345',
    name : 'Conan',
    age  : 24,
    phone: '555-555-5555'
});

user.changeName();
user.get('name'); //returns "Conan The Barbarian"

By default, the built in field types such as number and boolean coerce string values in the raw data by virtue of their Ext.data.field.Field.convert method. When the server can be relied upon to send data in a format that does not need to be converted, disabling this can improve performance. The Json and Array readers are likely candidates for this optimization. To disable field conversions you simply specify null for the field's convert config.

The "id" Field and idProperty

A Model definition always has an identifying field which should yield a unique key for each instance. By default, a field named "id" will be created with a mapping of "id". This happens because of the default idProperty provided in Model definitions.

To alter which field is the identifying field, use the idProperty config.

Validators

Models have built-in support for field validators. Validators are added to models as in the follow example:

Ext.define('User', {
    extend: 'Ext.data.Model',
    fields: [
        { name: 'name',     type: 'string' },
        { name: 'age',      type: 'int' },
        { name: 'phone',    type: 'string' },
        { name: 'gender',   type: 'string' },
        { name: 'username', type: 'string' },
        { name: 'alive',    type: 'boolean', defaultValue: true }
    ],

    validators: {
        age: 'presence',
        name: { type: 'length', min: 2 },
        gender: { type: 'inclusion', list: ['Male', 'Female'] },
        username: [
            { type: 'exclusion', list: ['Admin', 'Operator'] },
            { type: 'format', matcher: /([a-z]+)[0-9]{2,3}/i }
        ]
    }
});

The derived type of Ext.data.field.Field can also provide validation. If validators need to be duplicated on multiple fields, instead consider creating a custom field type.

Validation

The results of the validators can be retrieved via the "associated" validation record:

var instance = Ext.create('User', {
    name: 'Ed',
    gender: 'Male',
    username: 'edspencer'
});

var validation = instance.getValidation();

The returned object is an instance of Ext.data.Validation and has as its fields the result of the field validators. The validation object is "dirty" if there are one or more validation errors present.

This record is also available when using data binding as a "pseudo-association" called "validation". This pseudo-association can be hidden by an explicitly declared association by the same name (for compatibility reasons), but doing so is not recommended.

The Ext.Component.modelValidation config can be used to enable automatic binding from the "validation" of a record to the form fields that may be bound to its values.

Associations

Models often have associations with other Models. These associations can be defined by fields (often called "foreign keys") or by other data such as a many-to-many (or "matrix").

Foreign-Key Associations - One-to-Many

The simplest way to define an association from one Model to another is to add a reference config to the appropriate field.

 Ext.define('Post', {
     extend: 'Ext.data.Model',

     fields: [
         { name: 'user_id', reference: 'User' }
     ]
 });

 Ext.define('Comment', {
     extend: 'Ext.data.Model',

     fields: [
         { name: 'user_id', reference: 'User' },
         { name: 'post_id', reference: 'Post' }
     ]
 });

 Ext.define('User', {
     extend: 'Ext.data.Model',

     fields: [
         'name'
     ]
 });

The placement of reference on the appropriate fields tells the Model which field has the foreign-key and the type of Model it identifies. That is, the value of these fields is set to value of the idProperty field of the target Model.

One-to-Many Without Foreign-Keys

To define an association without a foreign-key field, you will need to use either the hasMany or belongsTo.

 Ext.define('Post', {
     extend: 'Ext.data.Model',

     belongsTo: 'User'
 });

 Ext.define('Comment', {
     extend: 'Ext.data.Model',

     belongsTo: [ 'Post', 'User' ]
 });

 // User is as above

These declarations have changed slightly from previous releases. In previous releases both "sides" of an association had to declare their particular roles. This is now only required if the defaults assumed for names are not satisfactory.

Foreign-Key Associations - One-to-One

A special case of one-to-many associations is the one-to-one case. This is defined as a unique reference.

 Ext.define('Address', {
     extend: 'Ext.data.Model',

     fields: [
         'address',
         'city',
         'state'
     ]
 });

 Ext.define('User', {
     extend: 'Ext.data.Model',

     fields: [{
         name: 'addressId',
         reference: 'Address',
         unique: true
     }]
 });

Many-to-Many

The classic use case for many-to-many is a User and Group. Users can belong to many Groups and Groups can contain many Users. This association is declared using the manyToMany config like so:

 Ext.define('User', {
     extend: 'Ext.data.Model',

     fields: [
         'name'
     ],

     manyToMany: 'Group'
 });

 Ext.define('Group', {
     extend: 'Ext.data.Model',

     fields: [
         'name'
     ],

     manyToMany: 'User'
 });

As with other associations, only one "side" needs to be declared.

To manage the relationship between a manyToMany relationship, a Ext.data.Session must be used.

Using a Proxy

Models are great for representing types of data and relationships, but sooner or later we're going to want to load or save that data somewhere. All loading and saving of data is handled via a Proxy, which can be set directly on the Model:

Ext.define('User', {
    extend: 'Ext.data.Model',
    fields: ['id', 'name', 'email'],

    proxy: {
        type: 'rest',
        url : '/users'
    }
});

Here we've set up a Rest Proxy, which knows how to load and save data to and from a RESTful backend. Let's see how this works:

var user = Ext.create('User', {name: 'Ed Spencer', email: 'ed@sencha.com'});

user.save(); //POST /users

Calling save on the new Model instance tells the configured RestProxy that we wish to persist this Model's data onto our server. RestProxy figures out that this Model hasn't been saved before because it doesn't have an id, and performs the appropriate action - in this case issuing a POST request to the url we configured (/users). We configure any Proxy on any Model and always follow this API - see Ext.data.proxy.Proxy for a full list.

Loading data via the Proxy is accomplished with the static load method:

//Uses the configured RestProxy to make a GET request to /users/123
User.load(123, {
    success: function(user) {
        console.log(user.getId()); //logs 123
    }
});

Models can also be updated and destroyed easily:

//the user Model we loaded in the last snippet:
user.set('name', 'Edward Spencer');

//tells the Proxy to save the Model. In this case it will perform a PUT request to /users/123 as this Model already has an id
user.save({
    success: function() {
        console.log('The User was updated');
    }
});

//tells the Proxy to destroy the Model. Performs a DELETE request to /users/123
user.erase({
    success: function() {
        console.log('The User was destroyed!');
    }
});

HTTP Parameter names when using a Ajax proxy

By default, the model ID is specified in an HTTP parameter named id. To change the name of this parameter use the Proxy's idParam configuration.

Parameters for other commonly passed values such as page number or start row may also be configured.

Usage in Stores

It is very common to want to load a set of Model instances to be displayed and manipulated in the UI. We do this by creating a Store:

var store = Ext.create('Ext.data.Store', {
    model: 'User'
});

//uses the Proxy we set up on Model to load the Store data
store.load();

A Store is just a collection of Model instances - usually loaded from a server somewhere. Store can also maintain a set of added, updated and removed Model instances to be synchronized with the server via the Proxy. See the Store docs for more information on Stores.

Defined By

Config options

An array of associations for this model.

An array of associations for this model.

One or more BelongsTo associations for this model.

One or more BelongsTo associations for this model.

The name of the property a server will use to send back a client-generated id in a create or update operation. ...

The name of the property a server will use to send back a client-generated id in a create or update operation.

If specified, this property cannot have the same name as any other field.

For example:

 Ext.define('Person', {
     idProperty: 'id',  // this is the default value (for clarity)

     clientIdProperty: 'clientId',

     identifier: 'negative', // to generate -1, -2 etc on the client

     fields: [ 'name' ]
 });

 var person = new Person({
     // no id provided, so -1 is generated
     name: 'Clark Kent'
 });

The server is given this data during the create:

 {
     id: -1,
     name: 'Clark Kent'
 }

The server allocates a real id and responds like so:

 {
     id: 427,
     clientId: -1
 }

This property is most useful when creating multiple entities in a single call to the server in a create operation. Alternatively, the server could respond with records that correspond one-to-one to those sent in the operation.

For example the client could send a create with this data:

 [ { id: -1, name: 'Clark Kent' },
   { id: -2, name: 'Peter Parker' },
   { id: -3, name: 'Bruce Banner' } ]

And the server could respond in the same order:

 [ { id: 427 },      // updates id = -1
   { id: 428 },      // updates id = -2
   { id: 429 } ]     // updates id = -3

Or using clientIdProperty the server could respond in arbitrary order:

 [ { id: 427, clientId: -3 },
   { id: 428, clientId: -1 },
   { id: 429, clientId: -2 } ]

IMPORTANT: When upgrading from previous versions be aware that this property used to perform the role of Ext.data.writer.Writer.clientIdProperty as well as that described above. To continue send a client-generated id as other than the idProperty, set clientIdProperty on the writer. A better solution, however, is most likely a properly configured identifier as that would work better with associations.

Set to false to prevent any converters from being called during a set operation. ...

Set to false to prevent any converters from being called during a set operation.

Defaults to: true

Ext.data.Model
view source
: Object[]/String[]
The fields for this model. ...

The fields for this model. This is an Array of Ext.data.field.Field definition objects or simply the field name. If just a name is given, the field type defaults to auto.

One or more HasMany associations for this model.

One or more HasMany associations for this model.

The name of the field treated as this Model's unique id. ...

The name of the field treated as this Model's unique id.

If defining an abstract base Model class, the idProperty may be configured as null which will mean that no identifying field will be generated. Concrete derived classes must eventually provide a value for this property.

The data values for this field must be unique or there will be id value collisions in the Store.

Defaults to: 'id'

The id generator to use for this model. ...

The id generator to use for this model. The default id generator does not generate values for the idProperty.

This can be overridden at the model level to provide a custom generator for a model. The simplest form of this would be:

 Ext.define('MyApp.data.MyModel', {
     extend: 'Ext.data.Model',
     requires: ['Ext.data.identifier.Sequential'],
     identifier: 'sequential',
     ...
 });

The above would generate sequential id's such as 1, 2, 3 etc..

Another useful id generator is Ext.data.identifier.Uuid:

 Ext.define('MyApp.data.MyModel', {
     extend: 'Ext.data.Model',
     requires: ['Ext.data.identifier.Uuid'],
     identifier: 'uuid',
     ...
 });

An id generator can also be further configured:

 Ext.define('MyApp.data.MyModel', {
     extend: 'Ext.data.Model',
     identifier: {
         type: 'sequential',
         seed: 1000,
         prefix: 'ID_'
     }
 });

The above would generate id's such as ID_1000, ID_1001, ID_1002 etc..

If multiple models share an id space, a single generator can be shared:

 Ext.define('MyApp.data.MyModelX', {
     extend: 'Ext.data.Model',
     identifier: {
         type: 'sequential',
         id: 'xy'
     }
 });

 Ext.define('MyApp.data.MyModelY', {
     extend: 'Ext.data.Model',
     identifier: {
         type: 'sequential',
         id: 'xy'
     }
 });

For more complex, shared id generators, a custom generator is the best approach. See Ext.data.identifier.Generator for details on creating custom id generators.

The proxy to use for this class.

The proxy to use for this class.

The name of the schema to which this entity and its associations belong. ...

The name of the schema to which this entity and its associations belong. For details on custom schemas see Ext.data.schema.Schema.

Defaults to: 'default'

If specified this property is used to concatenate multiple errors for each field as reported by the validators. ...

If specified this property is used to concatenate multiple errors for each field as reported by the validators.

Defaults to: null

Ext.data.Model
view source
: Object[]

An array of validators for this model.

An array of validators for this model.

If specified, this is the name of the property that contains the entity "version". ...

If specified, this is the name of the property that contains the entity "version". The version property is used to manage a long-running transaction and allows the detection of simultaneous modification.

The way a version property is used is that the client receives the version as it would any other entity property. When saving an entity, this property is always included in the request and the server uses the value in a "conditional update". If the current version of the entity on the server matches the version property sent by the client, the update is allowed. Otherwise, the update fails.

On successful update, both the client and server increment the version. This is done on the server in the conditional update and on the client when it receives a success on its update request.

Properties

Defined By

Instance properties

...

Defaults to: 'Ext.Base'

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_")...

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_") character. A value of false stores config values as properties using their exact name (no prefix).

Defaults to: false

Available since: 5.0.0

Overrides: Ext.Component.$configPrefixed, Ext.layout.Layout.$configPrefixed, Ext.data.AbstractStore.$configPrefixed, Ext.layout.container.boxOverflow.None.$configPrefixed

The value true instructs the initConfig method to only honor values for properties declared in the config block of a ...

The value true instructs the initConfig method to only honor values for properties declared in the config block of a class. When false, properties that are not declared in a config block will be placed on the instance.

Defaults to: true

Available since: 5.0.0

Overrides: Ext.Component.$configStrict, Ext.layout.Layout.$configStrict, Ext.data.AbstractStore.$configStrict, Ext.layout.container.boxOverflow.None.$configStrict

Ext.data.Model
view source
: Objectprivate
...

Defaults to: {convert: false, commit: true, silent: true}

Ext.data.Model
view source
: Objectprivate
This object is used whenever the set() method is called and given a string as the first argument. ...

This object is used whenever the set() method is called and given a string as the first argument. This approach saves memory (and GC costs) since we could be called a lot.

Defaults to: {}

Ext.data.Model
view source
: Objectprivate
Ext.data.Model
view source
: Booleanreadonly
True if this record has been modified. ...

True if this record has been modified.

Defaults to: false

Ext.data.Model
view source
: Booleanreadonly
True if this record is pending delete on the server. ...

True if this record is pending delete on the server. This is set by the drop method and transmitted to the server by the save method.

Defaults to: false

Ext.data.Model
view source
: Booleanreadonly
Internal flag used to track whether or not the model instance is currently being edited. ...

Internal flag used to track whether or not the model instance is currently being edited.

Defaults to: false

The short name of this entity class. ...

The short name of this entity class. This name is derived from the namespace of the associated schema and this class name. By default, a class is not given a shortened name.

All entities in a given schema must have a unique entityName.

For more details see "Relative Naming" in Ext.data.schema.Schema.

Ext.data.Model
view source
: Booleanreadonly
True if this record has been erased on the server. ...

True if this record has been erased on the server. This flag is set of the erase method.

Defaults to: false

Ext.data.Model
view source
: Booleanprivate
...

Defaults to: false

Ext.data.Model
view source
: Objectprivatereadonly
This property is indexed by field name and contains the ordinal of that field. ...

This property is indexed by field name and contains the ordinal of that field. The ordinal often has meaning to servers and is derived based on the position in the fields array.

This can be used like so:

 Ext.define('MyApp.models.User', {
     extend: 'Ext.data.Model',

     fields: [
         { name: 'name' }
     ]
 });

 var nameOrdinal = MyApp.models.User.fieldOrdinals.name;

 // or, if you have an instance:

 var user = new MyApp.models.User();
 var nameOrdinal = user.fieldOrdinals.name;
Ext.data.Model
view source
: Ext.data.field.Field[]privatereadonly
An array fields defined for this Model (including fields defined in superclasses) in ordinal order; that is in declar...

An array fields defined for this Model (including fields defined in superclasses) in ordinal order; that is in declaration order.

Ext.data.Model
view source
: Numberreadonly
This property is incremented on each modification of a record. ...

This property is incremented on each modification of a record.

Defaults to: 1

Available since: 5.0.0

This property is set to true during the call to initConfig. ...

This property is set to true during the call to initConfig.

Defaults to: false

Available since: 5.0.0

Ext.data.Model
view source
: Booleanreadonly
The value true to identify this class and its subclasses. ...

The value true to identify this class and its subclasses.

Defaults to: true

This property is set to true if this instance is the first of its class. ...

This property is set to true if this instance is the first of its class.

Defaults to: false

Available since: 5.0.0

This value is true and is used to identify plain objects from instances of a defined class. ...

This value is true and is used to identify plain objects from instances of a defined class.

Defaults to: true

Ext.data.Model
view source
: Booleanreadonly
The value true to identify this class and its subclasses. ...

The value true to identify this class and its subclasses.

Defaults to: true

Ext.data.Model
view source
: Object

A hash of field values which holds the initial values of fields before a set of edits are committed.

A hash of field values which holds the initial values of fields before a set of edits are committed.

Ext.data.Model
view source
: Stringprivate
...

Defaults to: 'record'

Ext.data.Model
view source
: Boolean
True when the record does not yet exist in a server-side database. ...

True when the record does not yet exist in a server-side database. Any record which has a real database identity set as its idProperty is NOT a phantom -- it's real.

Defaults to: false

Ext.data.Model
view source
: Objectprivatereadonly
This object is similar to the modified object except it holds the data values as they were prior to the most recent c...

This object is similar to the modified object except it holds the data values as they were prior to the most recent change.

Ext.data.Model
view source
: Objectprivate


The Ext.data.schema.Schema to which this entity and its associations belong. ...

The Ext.data.schema.Schema to which this entity and its associations belong.

Defaults to: 'default'

Get the reference to the current class from which this object was instantiated. ...

Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See statics for a detailed comparison

Ext.define('My.Cat', {
    statics: {
        speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
    },

    constructor: function() {
        alert(this.self.speciesName); // dependent on 'this'
    },

    clone: function() {
        return new this.self();
    }
});


Ext.define('My.SnowLeopard', {
    extend: 'My.Cat',
    statics: {
        speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
    }
});

var cat = new My.Cat();                     // alerts 'Cat'
var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'

var clone = snowLeopard.clone();
alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'
Ext.data.Model
view source
: Ext.data.Sessionreadonly

The Ext.data.Session for this record.

The Ext.data.Session for this record.

The Store to which this instance belongs. ...

The Store to which this instance belongs. NOTE: If this instance is bound to multiple stores, this property will reference only the first. To examine all the stores, use the stores property instead.

Ext.data.Model
view source
: Objectprivate

Record ids are more flexible.

Record ids are more flexible.

Defined By

Static properties

...

Defaults to: []

Ext.data.Model
view source
: Stringdeprecatedprivatereadonlystatic
...

Defaults to: 'commit'

This property has been deprecated

The update operation of type 'commit'. Used by Store.update event.

Ext.data.Model
view source
: Stringdeprecatedprivatereadonlystatic
...

Defaults to: 'edit'

This property has been deprecated

The update operation of type 'edit'. Used by Store.update event.

Ext.data.Model
view source
: Stringdeprecatedprivatereadonlystatic
...

Defaults to: 'reject'

This property has been deprecated

The update operation of type 'reject'. Used by Store.update event.

Methods

Defined By

Instance methods

Ext.data.Model
view source
new( data, session ) : Ext.data.Model
...

Parameters

Returns

Fires

    Ext.data.Model
    view source
    ( )
    Aborts a pending load operation. ...

    Aborts a pending load operation. If the record is not loading, this does nothing.

    ( deprecations )private
    This method applies a versioned, deprecation declaration to this class. ...

    This method applies a versioned, deprecation declaration to this class. This is typically called by the deprecated config.

    Parameters

    Ext.data.Model
    view source
    ( )
    Begins an edit. ...

    Begins an edit. While in edit mode, no events (e.g.. the update event) are relayed to the containing store. When an edit has begun, it must be followed by either endEdit or cancelEdit.

    Ext.data.Model
    view source
    ( funcName, [args] )private
    Helper function used by afterEdit, afterReject and afterCommit. ...

    Helper function used by afterEdit, afterReject and afterCommit. Calls the given method on the Ext.data.Store that this instance has joined, if any. The store function will always be called with the model instance as its single argument. If this model is joined to a Ext.data.NodeStore, then this method calls the given method on the NodeStore and the associated Ext.data.TreeStore.

    Parameters

    • funcName : String

      The name function to call on each store.

    • args : Array (optional)

      The arguments to pass to the method. This instance is always inserted as the first argument.

    ( args ) : Objectdeprecatedprotected
    Call the original method that was previously overridden with override Ext.define('My.Cat', { constructor: functi...

    Call the original method that was previously overridden with override

    Ext.define('My.Cat', {
        constructor: function() {
            alert("I'm a cat!");
        }
    });
    
    My.Cat.override({
        constructor: function() {
            alert("I'm going to be a cat!");
    
            this.callOverridden();
    
            alert("Meeeeoooowwww");
        }
    });
    
    var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                              // alerts "I'm a cat!"
                              // alerts "Meeeeoooowwww"
    

    This method has been deprecated

    Use callParent instead.

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callOverridden(arguments)

    Returns

    • Object

      Returns the result of calling the overridden method

    Call the "parent" method of the current method. ...

    Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext.define).

     Ext.define('My.Base', {
         constructor: function (x) {
             this.x = x;
         },
    
         statics: {
             method: function (x) {
                 return x;
             }
         }
     });
    
     Ext.define('My.Derived', {
         extend: 'My.Base',
    
         constructor: function () {
             this.callParent([21]);
         }
     });
    
     var obj = new My.Derived();
    
     alert(obj.x);  // alerts 21
    

    This can be used with an override as follows:

     Ext.define('My.DerivedOverride', {
         override: 'My.Derived',
    
         constructor: function (x) {
             this.callParent([x*2]); // calls original My.Derived constructor
         }
     });
    
     var obj = new My.Derived();
    
     alert(obj.x);  // now alerts 42
    

    This also works with static methods.

     Ext.define('My.Derived2', {
         extend: 'My.Base',
    
         statics: {
             method: function (x) {
                 return this.callParent([x*2]); // calls My.Base.method
             }
         }
     });
    
     alert(My.Base.method(10));     // alerts 10
     alert(My.Derived2.method(10)); // alerts 20
    

    Lastly, it also works with overridden static methods.

     Ext.define('My.Derived2Override', {
         override: 'My.Derived2',
    
         statics: {
             method: function (x) {
                 return this.callParent([x*2]); // calls My.Derived2.method
             }
         }
     });
    
     alert(My.Derived2.method(10); // now alerts 40
    

    To override a method and replace it and also call the superclass method, use callSuper. This is often done to patch a method to fix a bug.

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments)

    Returns

    • Object

      Returns the result of calling the parent method

    This method is used by an override to call the superclass method but bypass any overridden method. ...

    This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.

    Consider:

     Ext.define('Ext.some.Class', {
         method: function () {
             console.log('Good');
         }
     });
    
     Ext.define('Ext.some.DerivedClass', {
         extend: 'Ext.some.Class',
    
         method: function () {
             console.log('Bad');
    
             // ... logic but with a bug ...
    
             this.callParent();
         }
     });
    

    To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an override:

     Ext.define('App.patches.DerivedClass', {
         override: 'Ext.some.DerivedClass',
    
         method: function () {
             console.log('Fixed');
    
             // ... logic but with bug fixed ...
    
             this.callSuper();
         }
     });
    

    The patch method cannot use callParent to call the superclass method since that would call the overridden method containing the bug. In other words, the above patch would only produce "Fixed" then "Good" in the console log, whereas, using callParent would produce "Fixed" then "Bad" then "Good".

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments)

    Returns

    • Object

      Returns the result of calling the superclass method

    Ext.data.Model
    view source
    ( )
    Cancels all changes made in the current edit operation. ...

    Cancels all changes made in the current edit operation.

    Ext.data.Model
    view source
    ( )private
    ...
    Ext.data.Model
    view source
    ( [session] ) : Ext.data.Model
    Creates a clone of this record. ...

    Creates a clone of this record. States like dropped, phantom and dirty are all preserved in the cloned record.

    Parameters

    • session : Ext.data.session.Session (optional)

      The session to which the new record belongs.

    Returns

    Fires

      Ext.data.Model
      view source
      ( [silent], [modifiedFieldNames] )
      Usually called by the Ext.data.Store which owns the model instance. ...

      Usually called by the Ext.data.Store which owns the model instance. Commits all changes made to the instance since either creation or the last commit operation.

      Developers should subscribe to the Ext.data.Store.update event to have their code notified of commit operations.

      Parameters

      • silent : Boolean (optional)

        Pass true to skip notification of the owning store of the change.

        Defaults to: false

      • modifiedFieldNames : String[] (optional)

        Array of field names changed during sync with server if known. Omit or pass null if unknown. An empty array means that it is known that no fields were modified by the server's response. Defaults to false.

      Fires

        Ext.data.Model
        view source
        ( [newId], [session] ) : Ext.data.Model
        Creates a clean copy of this record. ...

        Creates a clean copy of this record. The returned record will not consider any its fields as modified.

        To generate a phantom instance with a new id pass null:

        var rec = record.copy(null); // clone the record but no id (one is generated)
        

        Parameters

        • newId : String (optional)

          A new id, defaults to the id of the instance being copied. See id.

        • session : Ext.data.Session (optional)

          The session to which the new record belongs.

        Returns

        Ext.data.Model
        view source
        ( sourceRecord ) : String[]private
        Copies data from the passed record into this record. ...

        Copies data from the passed record into this record. If the passed record is undefined, does nothing.

        If this is a phantom record (represented only in the client, with no corresponding database entry), and the source record is not a phantom, then this record acquires the id of the source record.

        Parameters

        Returns

        • String[]

          The names of the fields which changed value.

        Fires

          This method is called to cleanup an object and its resources. ...
          Ext.data.Model
          view source
          ( [cascade] )
          Marks this record as dropped and waiting to be deleted on the server. ...

          Marks this record as dropped and waiting to be deleted on the server. When a record is dropped, it is automatically removed from all association stores and any child records associated to this record are also dropped (a "cascade delete") depending on the cascade parameter.

          Available since: 5.0.0

          Parameters

          • cascade : Boolean (optional)

            Pass false to disable the cascade to drop child records.

            Defaults to: true

          Fires

            Ext.data.Model
            view source
            ( [silent], [modifiedFieldNames] )
            Ends an edit. ...

            Ends an edit. If any data was modified, the containing store is notified (ie, the store's update event will fire).

            Parameters

            • silent : Boolean (optional)

              True to not notify any stores of the change.

            • modifiedFieldNames : String[] (optional)

              Array of field names changed during edit.

            Fires

              Destroys the model using the configured proxy. ...

              Destroys the model using the configured proxy.

              Parameters

              Returns

              Fires

                Ext.data.Model
                view source
                ( fieldName ) : Object
                Returns the value of the given field. ...

                Returns the value of the given field.

                Parameters

                • fieldName : String

                  The name of the field.

                Returns

                • Object

                  The value of the specified field.

                Ext.data.Model
                view source
                ( [result] ) : Object
                Gets all of the data from this Models loaded associations. ...

                Gets all of the data from this Models loaded associations. It does this recursively. For example if we have a User which hasMany Orders, and each Order hasMany OrderItems, it will return an object like this:

                {
                    orders: [
                        {
                            id: 123,
                            status: 'shipped',
                            orderItems: [
                                ...
                            ]
                        }
                    ]
                }
                

                Parameters

                • result : Object (optional)

                  The object on to which the associations will be added. If no object is passed one is created. This object is then returned.

                Returns

                • Object

                  The nested data set for the Model's loaded associations.

                Ext.data.Model
                view source
                ( ) : Object
                Gets an object of only the fields that have been modified since this record was created or committed. ...

                Gets an object of only the fields that have been modified since this record was created or committed. Only persistent fields are tracked in the modified set so this method will only return changes to persistent fields.

                For more control over the returned data, see getData.

                Returns

                Fires

                  Returns a specified config property value. ...

                  Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.

                  Parameters

                  • name : String (optional)

                    The name of the config property to get.

                  • peek : Boolean (optional)

                    true to peek at the raw value without calling the getter.

                    Defaults to: false

                  Returns

                  • Object

                    The config property value.

                  Returns the array of fields that are declared as critical (must always send). ...

                  Returns the array of fields that are declared as critical (must always send).

                  Returns

                  Ext.data.Model
                  view source
                  ( [options] ) : Object
                  Gets all values for each field in this model and returns an object containing the current data. ...

                  Gets all values for each field in this model and returns an object containing the current data. This can be tuned by passing an options object with various properties describing the desired result. Passing true simply returns all fields and all associated record data.

                  Parameters

                  • options : Boolean/Object (optional)

                    An object containing options describing the data desired. If true is passed it is treated as an object with associated set to true.

                    • associated : Boolean (optional)

                      Pass true to include associated data. This is equivalent to pass true as the only argument. See getAssociatedData.

                      Defaults to: false

                    • changes : Boolean (optional)

                      Pass true to only include fields that have been modified. Note that field modifications are only tracked for fields that are not declared with persist set to false. In other words, only persistent fields have changes tracked so passing true for this means options.persist is redundant.

                      Defaults to: false

                    • critical : Boolean (optional)

                      Pass true to include fields set as critical. This is only meaningful when options.changes is true since critical fields may not have been modified.

                    • persist : Boolean (optional)

                      Pass true to only return persistent fields. This is implied when options.changes is set to true.

                    • serialize : Boolean (optional)

                      Pass true to invoke the serialize method on the returned fields.

                      Defaults to: false

                  Returns

                  • Object

                    An object containing all the values in this model.

                  Fires

                    Ext.data.Model
                    view source
                    ( name )private
                    ...

                    Parameters

                    Get the fields array for this model. ...

                    Get the fields array for this model.

                    Returns

                    Ext.data.Model
                    view source
                    ( )private
                    ...
                    Ext.data.Model
                    view source
                    ( ) : Number/String
                    Returns the unique ID allocated to this model instance as defined by idProperty. ...

                    Returns the unique ID allocated to this model instance as defined by idProperty.

                    Returns

                    Ext.data.Model
                    view source
                    ( ) : String
                    Get the idProperty for this model. ...

                    Get the idProperty for this model.

                    Returns

                    Returns the initial configuration passed to constructor when instantiating this class. ...

                    Returns the initial configuration passed to constructor when instantiating this class.

                    Parameters

                    • name : String (optional)

                      Name of the config option to return.

                    Returns

                    • Object/Mixed

                      The full config object or a single config value when name parameter specified.

                    Ext.data.Model
                    view source
                    ( fieldName ) : Object
                    Returns the original value of a modified field. ...

                    Returns the original value of a modified field. If there is no modified value, undefined will be return. Also see isModified.

                    Parameters

                    Returns

                    Fires

                      Ext.data.Model
                      view source
                      ( [old] ) : String[]private
                      Gets the names of all the fields that were modified during an edit. ...

                      Gets the names of all the fields that were modified during an edit.

                      Parameters

                      • old : Object (optional)

                        The saved data from beginEdit.

                      Returns

                      • String[]

                        The array of modified field names.

                      Fires

                        Ext.data.Model
                        view source
                        ( )protected
                        Return a unique observable ID. ...

                        Return a unique observable ID. Model is not observable but tree nodes (Ext.data.NodeInterface) are, so they must be globally unique within the observableType.

                        Ext.data.Model
                        view source
                        ( fieldName ) : Object
                        This method returns the value of a field given its name prior to its most recent change. ...

                        This method returns the value of a field given its name prior to its most recent change.

                        Parameters

                        Returns

                        • Object

                          The value of the given field prior to its current value. undefined if there is no previous value;

                        Returns the configured Proxy for this Model. ...

                        Returns the configured Proxy for this Model.

                        Returns

                        Returns the array of fields that are declared as non-persist or "transient". ...

                        Returns the array of fields that are declared as non-persist or "transient".

                        Available since: 5.0.0

                        Returns

                        Ext.data.Model
                        view source
                        ( [refresh] ) : Ext.data.Validation
                        Returns the Ext.data.Validation record holding the results of this record's validators. ...

                        Returns the Ext.data.Validation record holding the results of this record's validators. This record is lazily created on first request and is then kept on this record to be updated later.

                        See the class description for more about validators.

                        Available since: 5.0.0

                        Parameters

                        • refresh : Boolean (optional)

                          Pass false to not call the refresh method on the validation instance prior to returning it. Pass true to force a refresh of the validation instance. By default the returned record is only refreshed if changes have been made to this record.

                        Returns

                        ...

                        Parameters

                        ( config ) : Ext.Basechainableprotected
                        Initialize configuration for this class. ...

                        Initialize configuration for this class. a typical example:

                        Ext.define('My.awesome.Class', {
                            // The default config
                            config: {
                                name: 'Awesome',
                                isAwesome: true
                            },
                        
                            constructor: function(config) {
                                this.initConfig(config);
                            }
                        });
                        
                        var awesome = new My.awesome.Class({
                            name: 'Super Awesome'
                        });
                        
                        alert(awesome.getName()); // 'Super Awesome'
                        

                        Parameters

                        Returns

                        Fires

                          Ext.data.Model
                          view source
                          ( lhs, rhs ) : Booleanprivate
                          Checks if two values are equal, taking into account certain special factors, for example dates. ...

                          Checks if two values are equal, taking into account certain special factors, for example dates.

                          Parameters

                          Returns

                          • Boolean

                            True if the values are equal.

                          Ext.data.Model
                          view source
                          ( ) : Boolean
                          Checks whether this model is loading data from the proxy. ...

                          Checks whether this model is loading data from the proxy.

                          Returns

                          • Boolean

                            true if in a loading state.

                          Ext.data.Model
                          view source
                          ( fieldName ) : Boolean
                          Returns true if the passed field name has been modified since the load or last commit. ...

                          Returns true if the passed field name has been modified since the load or last commit.

                          Parameters

                          Returns

                          Ext.data.Model
                          view source
                          ( ) : Boolean
                          Checks if the model is valid. ...

                          Checks if the model is valid. See getValidation.

                          Returns

                          • Boolean

                            True if the model is valid.

                          Fires

                            Ext.data.Model
                            view source
                            ( item )
                            Tells this model instance that an observer is looking at it. ...

                            Tells this model instance that an observer is looking at it.

                            Parameters

                            Ext.data.Model
                            view source
                            ( [options] ) : Ext.data.Operation
                            Load the model instance using the configured proxy. ...

                            Load the model instance using the configured proxy.

                            Ext.define('MyApp.User', {
                                extend: 'Ext.data.Model',
                                fields: [
                                    {name: 'id', type: 'int'},
                                    {name: 'name', type: 'string'}
                                ]
                            });
                            
                            var user = new MyApp.User();
                            user.load({
                                scope: this,
                                failure: function(record, operation) {
                                    //do something if the load failed
                                },
                                success: function(record, operation) {
                                    //do something if the load succeeded
                                },
                                callback: function(record, operation, success) {
                                    //do something whether the load succeeded or failed
                                }
                            });
                            

                            Parameters

                            • options : Object (optional)

                              Config options for this load.

                              • success : Function

                                A function to be called when the model is loaded successfully. The callback is passed the following parameters:

                                Parameters

                              • failure : Function

                                A function to be called when the model is unable to be loadedy. The callback is passed the following parameters:

                                Parameters

                              • callback : Function

                                A function to be called after a load, whether it was successful or not. The callback is passed the following parameters:

                                Parameters

                              • scope : Object

                                The scope in which to execute the callback functions.

                            Returns

                            Fires

                              Ext.data.Model
                              view source
                              ( cls ) : Functionprivate
                              This method produces the initializeFn for this class. ...

                              This method produces the initializeFn for this class. If there are no fields requiring conversion and no fields requiring a default value then this method will return null.

                              Parameters

                              Returns

                              • Function

                                The initializeFn for this class (or null).

                              Ext.data.Model
                              view source
                              ( )protectedtemplate
                              This method is called by the Ext.data.reader.Reader after loading a model from the server. ...

                              This method is called by the Ext.data.reader.Reader after loading a model from the server. This is after processing any inline associations that are available.

                              This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

                              Ext.data.Model
                              view source
                              ( [silent] )
                              Usually called by the Ext.data.Store to which this model instance has been joined. ...

                              Usually called by the Ext.data.Store to which this model instance has been joined. Rejects all changes made to the model instance since either creation, or the last commit operation. Modified fields are reverted to their original values.

                              Developers should subscribe to the Ext.data.Store.update event to have their code notified of reject operations.

                              Parameters

                              • silent : Boolean (optional)

                                true to skip notification of the owning store of the change.

                                Defaults to: false

                              Fires

                                Ext.data.Model
                                view source
                                ( [options] ) : Ext.data.operation.Operation
                                Saves the model instance using the configured proxy. ...

                                Saves the model instance using the configured proxy.

                                Parameters

                                Returns

                                Fires

                                  Ext.data.Model
                                  view source
                                  ( fieldName, newValue, [options] ) : String[]
                                  Sets the given field to the given value, marks the instance as dirty ...

                                  Sets the given field to the given value, marks the instance as dirty

                                  Parameters

                                  • fieldName : String/Object

                                    The field to set, or an object containing key/value pairs

                                  • newValue : Object

                                    The value for the field (if fieldName is a string).

                                  • options : Object (optional)

                                    Options for governing this update.

                                    • convert : Boolean (optional)

                                      Set to false to prevent any converters from being called during the set operation. This may be useful when setting a large bunch of raw values.

                                      Defaults to: true

                                    • dirty : Boolean (optional)

                                      Pass false if the field values are to be understood as non-dirty (fresh from the server). When true, this change will be reflected in the modified collection.

                                      Defaults to: true

                                    • commit : Boolean (optional)

                                      Pass true to call the commit method after setting fields. If this option is passed, the usual after change processing will be bypassed. Commit will be called even if there are no field changes.

                                      Defaults to: false

                                    • silent : Boolean (optional)

                                      Pass true to suppress notification of any changes made by this call. Use with caution.

                                      Defaults to: false

                                  Returns

                                  • String[]

                                    The array of modified field names or null if nothing was modified.

                                  Fires

                                    ( name, [value] ) : Ext.Basechainable
                                    Sets a single/multiple configuration options. ...

                                    Sets a single/multiple configuration options.

                                    Parameters

                                    • name : String/Object

                                      The name of the property to set, or a set of key value pairs to set.

                                    • value : Object (optional)

                                      The value to set for the name parameter.

                                    Returns

                                    Fires

                                      Ext.data.Model
                                      view source
                                      ( )private
                                      ...

                                      Fires

                                        Ext.data.Model
                                        view source
                                        ( id )
                                        Sets the model instance's id field to the given id. ...

                                        Sets the model instance's id field to the given id.

                                        Parameters

                                        Fires

                                          Ext.data.Model
                                          view source
                                          ( session )
                                          Set the session for this record. ...

                                          Set the session for this record.

                                          Parameters

                                          Get the reference to the class from which this object was instantiated. ...

                                          Get the reference to the class from which this object was instantiated. Note that unlike self, this.statics() is scope-independent and it always returns the class from which it was called, regardless of what this points to during run-time

                                          Ext.define('My.Cat', {
                                              statics: {
                                                  totalCreated: 0,
                                                  speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
                                              },
                                          
                                              constructor: function() {
                                                  var statics = this.statics();
                                          
                                                  alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
                                                                                  // equivalent to: My.Cat.speciesName
                                          
                                                  alert(this.self.speciesName);   // dependent on 'this'
                                          
                                                  statics.totalCreated++;
                                              },
                                          
                                              clone: function() {
                                                  var cloned = new this.self();   // dependent on 'this'
                                          
                                                  cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
                                          
                                                  return cloned;
                                              }
                                          });
                                          
                                          
                                          Ext.define('My.SnowLeopard', {
                                              extend: 'My.Cat',
                                          
                                              statics: {
                                                  speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
                                              },
                                          
                                              constructor: function() {
                                                  this.callParent();
                                              }
                                          });
                                          
                                          var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
                                          
                                          var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
                                          
                                          var clone = snowLeopard.clone();
                                          alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
                                          alert(clone.groupName);                 // alerts 'Cat'
                                          
                                          alert(My.Cat.totalCreated);             // alerts 3
                                          

                                          Returns

                                          Ext.data.Model
                                          view source
                                          ( ) : String
                                          Returns a url-suitable string for this model instance. ...

                                          Returns a url-suitable string for this model instance. By default this just returns the name of the Model class followed by the instance ID - for example an instance of MyApp.model.User with ID 123 will return 'user/123'.

                                          Returns

                                          • String

                                            The url string for this model instance.

                                          Fires

                                            Ext.data.Model
                                            view source
                                            ( store )
                                            Tells this model instance that it has been removed from the store. ...

                                            Tells this model instance that it has been removed from the store.

                                            Parameters

                                            • store : Ext.data.Store

                                              The store from which this model has been removed.

                                            Ext.data.Model
                                            view source
                                            ( ) : Ext.data.ErrorCollectiondeprecated
                                            Validates the current data against all of its configured validators. ...

                                            Validates the current data against all of its configured validators. The returned collection holds an object for each reported problem from a validator.

                                            This method has been deprecated since 5.0

                                            Use getValidation instead.

                                            Returns

                                            Defined By

                                            Static methods

                                            ( config, [mixinClass] )privatestatic
                                            Adds new config properties to this class. ...

                                            Adds new config properties to this class. This is called for classes when they are declared, then for any mixins that class may define and finally for any overrides defined that target the class.

                                            Parameters

                                            • config : Object
                                            • mixinClass : Class (optional)

                                              The mixin class if the configs are from a mixin.

                                            Ext.data.Model
                                            view source
                                            ( newFields )protectedstatic
                                            This method adds the given set of fields to this model class. ...

                                            This method adds the given set of fields to this model class.

                                            Available since: 5.0.0

                                            Parameters

                                            • newFields : String[]/Object[]

                                              The new fields to add. Based on the name of a field this may replace a previous field definition.

                                            ( members )chainableprivatestatic
                                            ...

                                            Parameters

                                            ( name, member )chainableprivatestatic
                                            ...

                                            Parameters

                                            ( members, [isStatic], [privacy] )chainablestatic
                                            Add methods / properties to the prototype of this class. ...

                                            Add methods / properties to the prototype of this class.

                                            Ext.define('My.awesome.Cat', {
                                                constructor: function() {
                                                    ...
                                                }
                                            });
                                            
                                             My.awesome.Cat.addMembers({
                                                 meow: function() {
                                                    alert('Meowww...');
                                                 }
                                             });
                                            
                                             var kitty = new My.awesome.Cat();
                                             kitty.meow();
                                            

                                            Parameters

                                            • members : Object

                                              The members to add to this class.

                                            • isStatic : Boolean (optional)

                                              Pass true if the members are static.

                                              Defaults to: false

                                            • privacy : Boolean (optional)

                                              Pass true if the members are private. This only has meaning in debug mode and only for methods.

                                              Defaults to: false

                                            ( members ) : Ext.Basechainablestatic
                                            Add / override static properties of this class. ...

                                            Add / override static properties of this class.

                                            Ext.define('My.cool.Class', {
                                                ...
                                            });
                                            
                                            My.cool.Class.addStatics({
                                                someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
                                                method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
                                                method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
                                            });
                                            

                                            Parameters

                                            Returns

                                            ( fromClass, members ) : Ext.Baseprivatestatic
                                            Borrow another class' members to the prototype of this class. ...

                                            Borrow another class' members to the prototype of this class.

                                            Ext.define('Bank', {
                                                money: '$$$',
                                                printMoney: function() {
                                                    alert('$$$$$$$');
                                                }
                                            });
                                            
                                            Ext.define('Thief', {
                                                ...
                                            });
                                            
                                            Thief.borrow(Bank, ['money', 'printMoney']);
                                            
                                            var steve = new Thief();
                                            
                                            alert(steve.money); // alerts '$$$'
                                            steve.printMoney(); // alerts '$$$$$$$'
                                            

                                            Parameters

                                            • fromClass : Ext.Base

                                              The class to borrow members from

                                            • members : Array/String

                                              The names of the members to borrow

                                            Returns

                                            ( args )protectedstatic
                                            ...

                                            Parameters

                                            ( args )protectedstatic
                                            ...

                                            Parameters

                                            Create a new instance of this Class. ...

                                            Create a new instance of this Class.

                                            Ext.define('My.cool.Class', {
                                                ...
                                            });
                                            
                                            My.cool.Class.create({
                                                someConfig: true
                                            });
                                            

                                            All parameters are passed to the constructor of the class.

                                            Returns

                                            ( alias, origin )static
                                            Create aliases for existing prototype methods. ...

                                            Create aliases for existing prototype methods. Example:

                                            Ext.define('My.cool.Class', {
                                                method1: function() { ... },
                                                method2: function() { ... }
                                            });
                                            
                                            var test = new My.cool.Class();
                                            
                                            My.cool.Class.createAlias({
                                                method3: 'method1',
                                                method4: 'method2'
                                            });
                                            
                                            test.method3(); // test.method1()
                                            
                                            My.cool.Class.createAlias('method5', 'method3');
                                            
                                            test.method5(); // test.method3() -> test.method1()
                                            

                                            Parameters

                                            Ext.data.Model
                                            view source
                                            ( id, data, session )privatestatic
                                            ...

                                            Parameters

                                            ( config )privatestatic
                                            ...

                                            Parameters

                                            Returns the Ext.Configurator for this class. ...

                                            Returns the Ext.Configurator for this class.

                                            Returns

                                            Ext.data.Model
                                            view source
                                            ( name )privatestatic
                                            ...

                                            Parameters

                                            Ext.data.Model
                                            view source
                                            ( )privatestatic
                                            ...
                                            Ext.data.Model
                                            view source
                                            ( )privatestatic
                                            ...
                                            Ext.data.Model
                                            view source
                                            ( data )privatestatic
                                            ...

                                            Parameters

                                            Get the current class' name in string format. ...

                                            Get the current class' name in string format.

                                            Ext.define('My.cool.Class', {
                                                constructor: function() {
                                                    alert(this.self.getName()); // alerts 'My.cool.Class'
                                                }
                                            });
                                            
                                            My.cool.Class.getName(); // 'My.cool.Class'
                                            

                                            Returns

                                            Ext.data.Model
                                            view source
                                            ( ) : Ext.data.proxy.Proxystatic
                                            Returns the configured Proxy for this Model. ...

                                            Returns the configured Proxy for this Model.

                                            Returns

                                            Ext.data.Model
                                            view source
                                            ( id, [options], session ) : Ext.data.Modelstatic
                                            Asynchronously loads a model instance by id. ...

                                            Asynchronously loads a model instance by id. Sample usage:

                                            Ext.define('MyApp.User', {
                                                extend: 'Ext.data.Model',
                                                fields: [
                                                    {name: 'id', type: 'int'},
                                                    {name: 'name', type: 'string'}
                                                ]
                                            });
                                            
                                            MyApp.User.load(10, {
                                                scope: this,
                                                failure: function(record, operation) {
                                                    //do something if the load failed
                                                },
                                                success: function(record, operation) {
                                                    //do something if the load succeeded
                                                },
                                                callback: function(record, operation, success) {
                                                    //do something whether the load succeeded or failed
                                                }
                                            });
                                            

                                            Parameters

                                            • id : Number/String

                                              The id of the model to load

                                            • options : Object (optional)

                                              Config options for this load.

                                              • success : Function

                                                A function to be called when the model is loaded successfully. The callback is passed the following parameters:

                                                Parameters

                                              • failure : Function

                                                A function to be called when the model is unable to be loadedy. The callback is passed the following parameters:

                                                Parameters

                                              • callback : Function

                                                A function to be called after a load, whether it was successful or not. The callback is passed the following parameters:

                                                Parameters

                                              • scope : Object

                                                The scope in which to execute the callback functions.

                                            • session : Ext.data.Session

                                              The session for this record.

                                            Returns

                                            • Ext.data.Model

                                              The newly created model. Note that the model will (probably) still be loading once it is returned from this method. To do any post-processing on the data, the appropriate place to do see is in the callback.

                                            ( name, mixinClass )privatestatic
                                            Used internally by the mixins pre-processor ...

                                            Used internally by the mixins pre-processor

                                            Parameters

                                            ( fn, scope )chainableprivatestatic
                                            ...

                                            Parameters

                                            Override members of this class. ...

                                            Override members of this class. Overridden methods can be invoked via callParent.

                                            Ext.define('My.Cat', {
                                                constructor: function() {
                                                    alert("I'm a cat!");
                                                }
                                            });
                                            
                                            My.Cat.override({
                                                constructor: function() {
                                                    alert("I'm going to be a cat!");
                                            
                                                    this.callParent(arguments);
                                            
                                                    alert("Meeeeoooowwww");
                                                }
                                            });
                                            
                                            var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                                                                      // alerts "I'm a cat!"
                                                                      // alerts "Meeeeoooowwww"
                                            

                                            Direct use of this method should be rare. Use Ext.define instead:

                                            Ext.define('My.CatOverride', {
                                                override: 'My.Cat',
                                                constructor: function() {
                                                    alert("I'm going to be a cat!");
                                            
                                                    this.callParent(arguments);
                                            
                                                    alert("Meeeeoooowwww");
                                                }
                                            });
                                            

                                            The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

                                            Parameters

                                            • members : Object

                                              The properties to add to this class. This should be specified as an object literal containing one or more properties.

                                            Returns

                                            Ext.data.Model
                                            view source
                                            ( removeFields )protectedstatic
                                            Removes the given set of fields from this model. ...

                                            Removes the given set of fields from this model.

                                            Available since: 5.0.0

                                            Parameters

                                            • removeFields : Boolean/String[]

                                              The names of fields to remove or true to remove all existing fields. Removes are processed first followed by adds so if a field name appears in newFields as well that field will effectively be added (however, in that case there is no need to include the field in this array).

                                            Ext.data.Model
                                            view source
                                            ( newFields, removeFields )protectedstatic
                                            This method replaces the specified set of fields with a given set of new fields. ...

                                            This method replaces the specified set of fields with a given set of new fields. Fields should normally be considered immutable, but if the timing is right (that is, before derived classes are declared), it is permissible to change the fields collection.

                                            Available since: 5.0.0

                                            Parameters

                                            • newFields : String[]/Object[]

                                              The new fields to add. Based on the name of a field this may replace a previous field definition.

                                            • removeFields : Boolean/String[]

                                              The names of fields to remove or true to remove all existing fields. Removes are processed first followed by adds so if a field name appears in newFields as well that field will effectively be added (however, in that case there is no need to include the field in this array).

                                            Ext.data.Model
                                            view source
                                            ( proxy ) : Ext.data.proxy.Proxystatic
                                            Sets the Proxy to use for this model. ...

                                            Sets the Proxy to use for this model. Accepts any options that can be accepted by Ext.createByAlias.

                                            Parameters

                                            Returns