ExtReact Docs Help

Introduction

The documentation for the ExtReact product diverges somewhat from the documentation of other Sencha products. The sections below describe documentation for all products except where indicated as unique to ExtReact.

Terms, Icons, and Labels

Many classes have shortcut names used when creating (instantiating) a class with a configuration object. The shortcut name is referred to as an alias (or xtype if the class extends Ext.Component). The alias/xtype is listed next to the class name of applicable classes for quick reference.

ExtReact component classes list the configurable name prominently at the top of the API class doc followed by the fully-qualified class name.

Access Levels

Framework classes or their members may be specified as private or protected. Else, the class / member is public. Public, protected, and private are access descriptors used to convey how and when the class or class member should be used.

Member Types

Member Syntax

Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).

lookupComponent ( item ) : Ext.Component
protected

Called when a raw config object is added to this container either during initialization of the items config, or when new items are added), or {@link #insert inserted.

This method converts the passed object into an instanced child component.

This may be overridden in subclasses when special processing needs to be applied to child creation.

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

Let's look at each part of the member row:

Member Flags

The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.

Class Icons

- Indicates a framework class

- A singleton framework class. *See the singleton flag for more information

- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)

- Indicates that the class, member, or guide is new in the currently viewed version

Member Icons

- Indicates a class member of type config

Or in the case of an ExtReact component class this indicates a member of type prop

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

- Indicates that the class, member, or guide is new in the currently viewed version

Class Member Quick-Nav Menu

Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.

Getter and Setter Methods

Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.

ExtReact component classes do not hoist the getter / setter methods into the prop. All methods will be described in the Methods section

History Bar

Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.

Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.

If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.

Search and Filters

Both API docs and guides can be searched for using the search field at the top of the page.

On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.

The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.

Clicking on an empty search field will show your last 10 searches for quick navigation.

API Doc Class Metadata

Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:

Expanding and Collapsing Examples and Class Members

Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.

Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.

Desktop -vs- Mobile View

Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:

Viewing the Class Source

The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.

ExtReact 6.6.0


top

Summary

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 Ext.data.Store, 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#method-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 Ext.data.reader.Json and Ext.data.reader.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"). See Ext.data.schema.Association for information about configuring and using associations.

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 Ext.data.proxy.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 Ext.data.proxy.Rest, 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: '[email protected]'});

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 Ext.data.proxy.Ajax

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 Ext.data.Store:

let store = new 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 Ext.data.Store for more information on Stores.

No members found using the current filters

configs

Optional Configs

belongsTo : String / Object / String[] / Object[]

One or more Ext.data.schema.BelongsTo associations for this model.

clientIdProperty : String

The name of the property a server will use to send back a client-generated id in a create or update Ext.data.operation.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 Ext.data.operation.Create. 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.

Defaults to:

null

convertOnSet : Boolean

Set to false to prevent any converters from being called on fields specified in a set operation.

Note: Setting the config to false will only prevent the convert / calculate call when the set fieldName param matches the field's name. In the following example the calls to set salary will not execute the convert method on set while the calls to set vested will execute the convert method on the initial read as well as on set.

Example model definition:

Ext.define('MyApp.model.Employee', {
    extend: 'Ext.data.Model',
    fields: ['yearsOfService', {
        name: 'salary',
        convert: function (val) {
            var startingBonus = val * .1;
            return val + startingBonus;
        }
    }, {
        name: 'vested',
        convert: function (val, record) {
            return record.get('yearsOfService') >= 4;
        },
        depends: 'yearsOfService'
    }],
    convertOnSet: false
});

var tina = Ext.create('MyApp.model.Employee', {
    salary: 50000,
    yearsOfService: 3
});

console.log(tina.get('salary')); // logs 55000
console.log(tina.get('vested')); // logs false

tina.set({
    salary: 60000,
    yearsOfService: 4
});
console.log(tina.get('salary')); // logs 60000
console.log(tina.get('vested')); // logs true

Defaults to:

true

fields : Object[] / String[]

An Array of Ext.data.field.Field config objects, simply the field name, or a mix of config objects and strings. If just a name is given, the field type defaults to auto.

In a Ext.data.field.Field config object you may pass the alias of the Ext.data.field.* type using the type config option.

// two fields are set:
// - an 'auto' field with a name of 'firstName'
// - and an Ext.data.field.Integer field with a name of 'age'
fields: ['firstName', {
    type: 'int',
    name: 'age'
}]

Fields will automatically be created at read time for any for any keys in the data passed to the Model's proxy's Ext.data.reader.Reader whose name is not explicitly configured in the fields config.

Extending a Model class will inherit all the fields from the superclass / ancestor classes.

getFields Ext.data.field.Field[]

Get the fields array for this model.

Returns

:Ext.data.field.Field[]

The fields array

hasMany : String / Object / String[] / Object[]

One or more Ext.data.schema.HasMany associations for this model.

hasOne : String / Object / String[] / Object[]

One or more Ext.data.schema.HasOne associations for this model.

identifier : String / Object

The id generator to use for this model. The identifier generates values for the idProperty when no value is given. Records with client-side generated values for idProperty are called phantom records since they are not yet known to the server.

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 Ext.data.identifier.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.

Defaults to:

null

idProperty : String

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

If changing the idProperty in a subclass, the generated id field will replace the one generated by the superclass, for example;

 Ext.define('Super', {
     extend: 'Ext.data.Model',
     fields: ['name']
 });

 Ext.define('Sub', {
     extend: 'Super',
     idProperty: 'customId'
 });

 var fields = Super.getFields();
 // Has 2 fields, "name" & "id"
 console.log(fields[0].name, fields[1].name, fields.length);

 fields = Sub.getFields();
 // Has 2 fields, "name" & "customId", "id" is replaced
 console.log(fields[0].name, fields[1].name, fields.length);

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

Defaults to:

'id'

getIdProperty String

Get the idProperty for this model.

Returns

:String

The idProperty

manyToMany : Object

A config object for a Ext.data.schema.ManyToMany association. See the class description for Ext.data.schema.ManyToMany for configuration examples.

Defaults to:

null

proxy : String / Object / Ext.data.proxy.Proxy

The Ext.data.proxy.Proxy to use for this class.

Defaults to:

undefined

getProxy Ext.data.proxy.Proxy

Returns the configured Proxy for this Model.

Returns

:Ext.data.proxy.Proxy

The proxy

schema : String / Object

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

Defaults to:

'default'

validationSeparator : String

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

Defaults to:

null

versionProperty : String

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.

Defaults to:

null

properties

Instance Properties

entityName : String

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.

Defaults to:

false

modified : Object

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

phantom : Boolean

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

methods

Instance Methods

abort

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

beginEdit

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.

cancelEdit

Cancels all changes made in the current edit operation.

clone ( [session] ) : Ext.data.Model

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

Parameters

session :  Ext.data.Session (optional)

The session to which the new record belongs.

Returns

:Ext.data.Model

The cloned record.

commit ( [silent], [modifiedFieldNames] )

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#event-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.

copy ( [newId], [session] ) : Ext.data.Model

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 idProperty.

session :  Ext.data.Session (optional)

The session to which the new record belongs.

Returns

:Ext.data.Model

drop ( [cascade] )

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

endEdit ( [silent], [modifiedFieldNames] )

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.

erase ( [options] ) : Ext.data.operation.Destroy

Destroys the model using the configured proxy. The erase action is asynchronous. Any processing of the erased record should be done in a callback.

Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'id', type: 'int'},
        {name: 'name', type: 'string'}
    ],
    proxy: {
        type: 'ajax',
        url: 'server.url'
    }
});

var user = new MyApp.model.User({
    name: 'Foo'
});

// pass the phantom record data to the server to be saved
user.save({
    success: function(record, operation) {
        // do something if the save succeeded
        // erase the created record
        record.erase({
            failure: function(record, operation) {
                // do something if the erase failed
            },
            success: function(record, operation) {
                // do something if the erase succeeded
            },
            callback: function(record, operation, success) {
                // do something if the erase succeeded or failed
            }
        });
    }
});

NOTE: If a phantom record is erased it will not be processed via the proxy. However, any passed success or callback functions will be called.

The options param is an Ext.data.operation.Destroy config object containing success, failure and callback functions, plus optional scope.

Parameters

options :  Object (optional)

Options to pass to the proxy.

success :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

failure :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

callback :  Function

A function to be called whether the proxy transaction was successful or not. The callback is passed the following parameters:

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

success :  Boolean

true if the operation was successful.

scope :  Object

The scope in which to execute the callback functions. Defaults to the model instance.

Returns

:Ext.data.operation.Destroy

The destroy operation

get ( fieldName ) : Object

Returns the value of the given field.

Parameters

fieldName :  String

The name of the field.

Returns

:Object

The value of the specified field.

getAssociatedData ( [result], [options] ) : Object

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.

options :  Boolean/Object (optional)

An object containing options describing the data desired.

associated :  Boolean (optional)

Pass true to include associated data from other associated records.

Defaults to:

true

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

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

getChanges Object

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

:Object

getCriticalFields Ext.data.field.Field[]

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

Returns

:Ext.data.field.Field[]

getData ( [options] ) : Object

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.

getId Number/String

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

Returns

:Number/String

The id

getModified ( fieldName ) : Object

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

Parameters

fieldName :  String

The name of the field for which to return the original value.

Returns

:Object

modified

getPrevious ( fieldName ) : Object

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

Parameters

fieldName :  String

The field's name.

Returns

:Object

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

getTransientFields Ext.data.field.Field[]

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

Available since: 5.0.0

Returns

:Ext.data.field.Field[]

getValidation ( [refresh] ) : Ext.data.Validation

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

:Ext.data.Validation

The Validation record for this record.

isLoading Boolean

Checks whether this model is loading data from the proxy.

Returns

:Boolean

true if in a loading state.

isModified ( fieldName ) : Boolean

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

Parameters

fieldName :  String

The field's name.

Returns

:Boolean

isValid Boolean

Checks if the model is valid. See getValidation.

Returns

:Boolean

True if the model is valid.

join ( owner )

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

Parameters

owner :  Ext.data.Store

The store or other owner object to which this model has been added.

load ( [options] ) : Ext.data.operation.Read

Loads the model instance using the configured proxy. The load action is asynchronous. Any processing of the loaded record should be done in a callback.

Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'id', type: 'int'},
        {name: 'name', type: 'string'}
    ],
    proxy: {
        type: 'ajax',
        url: 'server.url'
    }
});

var user = new MyApp.model.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
    }
});

The options param is an Ext.data.operation.Read config object containing success, failure and callback functions, plus optional scope.

Parameters

options :  Object (optional)

Options to pass to the proxy.

success :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

failure :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

callback :  Function

A function to be called whether the proxy transaction was successful or not. The callback is passed the following parameters:

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

success :  Boolean

true if the operation was successful.

scope :  Object

The scope in which to execute the callback functions. Defaults to the model instance.

Returns

:Ext.data.operation.Read

The read operation.

reject ( [silent] )

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#event-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

save ( [options] ) : Ext.data.operation.Create/Ext.data.operation.Update/Ext.data.operation.Destroy

Saves the model instance using the configured proxy. The save action is asynchronous. Any processing of the saved record should be done in a callback.

Create example:

Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'id', type: 'int'},
        {name: 'name', type: 'string'}
    ],
    proxy: {
        type: 'ajax',
        url: 'server.url'
    }
});

var user = new MyApp.model.User({
    name: 'Foo'
});

// pass the phantom record data to the server to be saved
user.save({
    failure: function(record, operation) {
        // do something if the save failed
    },
    success: function(record, operation) {
        // do something if the save succeeded
    },
    callback: function(record, operation, success) {
        // do something whether the save succeeded or failed
    }
});

The response from a create operation should include the ID for the newly created record:

// sample response
{
    success: true,
    id: 1
}

// the id may be nested if the proxy's reader has a rootProperty config
Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    proxy: {
        type: 'ajax',
        url: 'server.url',
        reader: {
            type: 'ajax',
            rootProperty: 'data'
        }
    }
});

// sample nested response
{
    success: true,
    data: {
        id: 1
    }
}

(Create + ) Update example:

Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'id', type: 'int'},
        {name: 'name', type: 'string'}
    ],
    proxy: {
        type: 'ajax',
        url: 'server.url'
    }
});

var user = new MyApp.model.User({
    name: 'Foo'
});
user.save({
    success: function(record, operation) {
        record.set('name', 'Bar');
        // updates the remote record via the proxy
        record.save();
    }
});

(Create + ) Destroy example - see also erase:

Ext.define('MyApp.model.User', {
    extend: 'Ext.data.Model',
    fields: [
        {name: 'id', type: 'int'},
        {name: 'name', type: 'string'}
    ],
    proxy: {
        type: 'ajax',
        url: 'server.url'
    }
});

var user = new MyApp.model.User({
    name: 'Foo'
});
user.save({
    success: function(record, operation) {
        record.drop();
        // destroys the remote record via the proxy
        record.save();
    }
});

NOTE: If a phantom record is dropped and subsequently saved it will not be processed via the proxy. However, any passed success or callback functions will be called.

The options param is an Operation config object containing success, failure and callback functions, plus optional scope. The type of Operation depends on the state of the model being saved.

Parameters

options :  Object (optional)

Options to pass to the proxy.

success :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

failure :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

callback :  Function

A function to be called whether the proxy transaction was successful or not. The callback is passed the following parameters:

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

success :  Boolean

true if the operation was successful.

scope :  Object

The scope in which to execute the callback functions. Defaults to the model instance.

Returns

:Ext.data.operation.Create/Ext.data.operation.Update/Ext.data.operation.Destroy

The operation instance for saving this model. The type of operation returned depends on the model state at the time of the action.

set ( fieldName, newValue, [options] ) : String[]

Sets the given field to the given value. For example:

 record.set('name', 'value');

This method can also be passed an object containing multiple values to set at once. For example:

 record.set({
     name: 'value',
     age: 42
 });

The following store events are fired when the modified record belongs to a store:

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.

setId ( id, [options] )

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

Parameters

id :  Number/String

The new id.

options :  Object (optional)

See set.

toUrl String

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.

unjoin ( owner )

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

Parameters

owner :  Ext.data.Store

The store or other owner object from which this model has been removed.

Static Methods

getProxy Ext.data.proxy.Proxy
static sta

Returns the configured Proxy for this Model.

Returns

:Ext.data.proxy.Proxy

The proxy

load ( id, [options], [session] ) : Ext.data.Model
static sta

Asynchronously loads a model instance by id. Any processing of the loaded record should be done in a callback.

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. NOTE: The model returned must have an ID matching the param in the load request.

options :  Object (optional)

The options param is an Ext.data.operation.Read config object containing success, failure and callback functions, plus optional scope.

success :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

failure :  Function

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

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

callback :  Function

A function to be called whether the proxy transaction was successful or not. The callback is passed the following parameters:

record :  Ext.data.Model

The record.

operation :  Ext.data.operation.Operation

The operation.

success :  Boolean

true if the operation was successful.

scope :  Object

The scope in which to execute the callback functions. Defaults to the model instance.

session :  Ext.data.Session (optional)

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.

loadData ( data, [session] ) : Ext.data.Model
static sta

Create a model while also parsing any data for associations.

Available since: 6.5.0

Parameters

data :  Object

The model data, including any associated data if required. The type of data should correspond to what the configured data reader would expect.

session :  Ext.data.Session (optional)

The session.

Returns

:Ext.data.Model

The model.

override ( members ) : Ext.Base
static sta

Override members of this class. Overridden methods can be invoked via Ext.Base#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.Base

this class

setProxy ( proxy ) : Ext.data.proxy.Proxy
static sta

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

Parameters

proxy :  String/Object/Ext.data.proxy.Proxy

The proxy

Returns

:Ext.data.proxy.Proxy

ExtReact 6.6.0