<!DOCTYPE html>
|
<html>
|
<head>
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
<title>The source code</title>
|
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
|
<script type="text/javascript" src="../resources/prettify/prettify.js"></script>
|
<style type="text/css">
|
.highlight { display: block; background-color: #ddd; }
|
</style>
|
<script type="text/javascript">
|
function highlight() {
|
document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
|
}
|
</script>
|
</head>
|
<body onload="prettyPrint(); highlight();">
|
<pre class="prettyprint lang-js"><span id='Ext-data-association-Association'>/**
|
</span> * @author Ed Spencer
|
*
|
* Associations enable you to express relationships between different {@link Ext.data.Model Models}. Let's say we're
|
* writing an ecommerce system where Users can make Orders - there's a relationship between these Models that we can
|
* express like this:
|
*
|
* Ext.define('User', {
|
* extend: 'Ext.data.Model',
|
* fields: ['id', 'name', 'email'],
|
*
|
* hasMany: {model: 'Order', name: 'orders'}
|
* });
|
*
|
* Ext.define('Order', {
|
* extend: 'Ext.data.Model',
|
* fields: ['id', 'user_id', 'status', 'price'],
|
*
|
* belongsTo: 'User'
|
* });
|
*
|
* We've set up two models - User and Order - and told them about each other. You can set up as many associations on
|
* each Model as you need using the two default types - {@link Ext.data.HasManyAssociation hasMany} and {@link
|
* Ext.data.BelongsToAssociation belongsTo}. There's much more detail on the usage of each of those inside their
|
* documentation pages. If you're not familiar with Models already, {@link Ext.data.Model there is plenty on those too}.
|
*
|
* **Further Reading**
|
*
|
* - {@link Ext.data.association.HasMany hasMany associations}
|
* - {@link Ext.data.association.BelongsTo belongsTo associations}
|
* - {@link Ext.data.association.HasOne hasOne associations}
|
* - {@link Ext.data.Model using Models}
|
*
|
* # Self association models
|
*
|
* We can also have models that create parent/child associations between the same type. Below is an example, where
|
* groups can be nested inside other groups:
|
*
|
* // Server Data
|
* {
|
* "groups": {
|
* "id": 10,
|
* "parent_id": 100,
|
* "name": "Main Group",
|
* "parent_group": {
|
* "id": 100,
|
* "parent_id": null,
|
* "name": "Parent Group"
|
* },
|
* "nested" : {
|
* "child_groups": [{
|
* "id": 2,
|
* "parent_id": 10,
|
* "name": "Child Group 1"
|
* },{
|
* "id": 3,
|
* "parent_id": 10,
|
* "name": "Child Group 2"
|
* },{
|
* "id": 4,
|
* "parent_id": 10,
|
* "name": "Child Group 3"
|
* }]
|
* }
|
* }
|
* }
|
*
|
* // Client code
|
* Ext.define('Group', {
|
* extend: 'Ext.data.Model',
|
* fields: ['id', 'parent_id', 'name'],
|
* proxy: {
|
* type: 'ajax',
|
* url: 'data.json',
|
* reader: {
|
* type: 'json',
|
* root: 'groups'
|
* }
|
* },
|
* associations: [{
|
* type: 'hasMany',
|
* model: 'Group',
|
* primaryKey: 'id',
|
* foreignKey: 'parent_id',
|
* autoLoad: true,
|
* associationKey: 'nested.child_groups' // read child data from nested.child_groups
|
* }, {
|
* type: 'belongsTo',
|
* model: 'Group',
|
* primaryKey: 'id',
|
* foreignKey: 'parent_id',
|
* associationKey: 'parent_group' // read parent data from parent_group
|
* }]
|
* });
|
*
|
* Ext.onReady(function(){
|
*
|
* Group.load(10, {
|
* success: function(group){
|
* console.log(group.getGroup().get('name'));
|
*
|
* group.groups().each(function(rec){
|
* console.log(rec.get('name'));
|
* });
|
* }
|
* });
|
*
|
* });
|
*
|
*/
|
Ext.define('Ext.data.association.Association', {
|
alternateClassName: 'Ext.data.Association',
|
<span id='Ext-data-association-Association-cfg-ownerModel'> /**
|
</span> * @cfg {String} ownerModel
|
* The string name of the model that owns the association.
|
*
|
* **NB!** This config is required when instantiating the Association directly.
|
* However, it cannot be used at all when defining the association as a config
|
* object inside Model, because the name of the model itself will be supplied
|
* automatically as the value of this config.
|
*/
|
|
<span id='Ext-data-association-Association-cfg-associatedModel'> /**
|
</span> * @cfg {String} associatedModel
|
* The string name of the model that is being associated with.
|
*
|
* **NB!** This config is required when instantiating the Association directly.
|
* When defining the association as a config object inside Model, the #model
|
* configuration will shadow this config.
|
*/
|
|
<span id='Ext-data-association-Association-cfg-model'> /**
|
</span> * @cfg {String} model
|
* The string name of the model that is being associated with.
|
*
|
* This config option is to be used when defining the association as a config
|
* object within Model. The value is then mapped to #associatedModel when
|
* Association is instantiated inside Model.
|
*/
|
|
<span id='Ext-data-association-Association-cfg-primaryKey'> /**
|
</span> * @cfg {String} primaryKey
|
* The name of the primary key on the associated model. In general this will be the
|
* {@link Ext.data.Model#idProperty} of the Model.
|
*/
|
primaryKey: 'id',
|
|
<span id='Ext-data-association-Association-cfg-reader'> /**
|
</span> * @cfg {Ext.data.reader.Reader} reader
|
* A special reader to read associated data
|
*/
|
|
<span id='Ext-data-association-Association-cfg-associationKey'> /**
|
</span> * @cfg {String} associationKey
|
* The name of the property in the data to read the association from. Defaults to the name of the associated model.
|
*/
|
|
associationKeyFunction : null,
|
|
<span id='Ext-data-association-Association-property-defaultReaderType'> defaultReaderType: 'json',
|
</span>
|
<span id='Ext-data-association-Association-property-isAssociation'> isAssociation: true,
|
</span>
|
<span id='Ext-data-association-Association-property-initialConfig'> initialConfig: null,
|
</span>
|
statics: {
|
<span id='Ext-data-association-Association-property-AUTO_ID'> AUTO_ID: 1000,
|
</span>
|
<span id='Ext-data-association-Association-method-create'> create: function(association){
|
</span> if (Ext.isString(association)) {
|
association = {
|
type: association
|
};
|
}
|
|
switch (association.type) {
|
case 'belongsTo':
|
return new Ext.data.association.BelongsTo(association);
|
case 'hasMany':
|
return new Ext.data.association.HasMany(association);
|
case 'hasOne':
|
return new Ext.data.association.HasOne(association);
|
//TODO Add this back when it's fixed
|
// case 'polymorphic':
|
// return Ext.create('Ext.data.PolymorphicAssociation', association);
|
default:
|
//<debug>
|
Ext.Error.raise('Unknown Association type: "' + association.type + '"');
|
//</debug>
|
}
|
return association;
|
}
|
},
|
|
<span id='Ext-data-association-Association-method-constructor'> /**
|
</span> * Creates the Association object.
|
* @param {Object} [config] Config object.
|
*/
|
constructor: function(config) {
|
Ext.apply(this, config);
|
|
var me = this,
|
types = Ext.ModelManager.types,
|
ownerName = config.ownerModel,
|
associatedName = config.associatedModel,
|
ownerModel = types[ownerName],
|
associatedModel = types[associatedName],
|
associationKey = config.associationKey,
|
keyReIdx;
|
|
if (associationKey) {
|
keyReIdx = String(associationKey).search(/[\[\.]/);
|
|
if (keyReIdx >= 0) {
|
me.associationKeyFunction = Ext.functionFactory('obj', 'return obj' + (keyReIdx > 0 ? '.' : '') + associationKey);
|
}
|
}
|
|
me.initialConfig = config;
|
|
//<debug>
|
if (ownerModel === undefined) {
|
Ext.Error.raise("The configured ownerModel was not valid (you tried " + ownerName + ")");
|
}
|
if (associatedModel === undefined) {
|
Ext.Error.raise("The configured associatedModel was not valid (you tried " + associatedName + ")");
|
}
|
//</debug>
|
|
me.ownerModel = ownerModel;
|
me.associatedModel = associatedModel;
|
|
<span id='Ext-data-association-Association-property-ownerName'> /**
|
</span> * @property {String} ownerName
|
* The name of the model that 'owns' the association
|
*/
|
|
<span id='Ext-data-association-Association-property-associatedName'> /**
|
</span> * @property {String} associatedName
|
* The name of the model is on the other end of the association (e.g. if a User model hasMany Orders, this is
|
* 'Order')
|
*/
|
|
Ext.applyIf(me, {
|
ownerName : ownerName,
|
associatedName: associatedName
|
});
|
|
me.associationId = 'association' + (++me.statics().AUTO_ID);
|
},
|
|
<span id='Ext-data-association-Association-method-getReader'> /**
|
</span> * Get a specialized reader for reading associated data
|
* @return {Ext.data.reader.Reader} The reader, null if not supplied
|
*/
|
getReader: function(){
|
var me = this,
|
reader = me.reader,
|
model = me.associatedModel;
|
|
if (reader) {
|
if (Ext.isString(reader)) {
|
reader = {
|
type: reader
|
};
|
}
|
if (reader.isReader) {
|
reader.setModel(model);
|
} else {
|
Ext.applyIf(reader, {
|
model: model,
|
type : me.defaultReaderType
|
});
|
}
|
me.reader = Ext.createByAlias('reader.' + reader.type, reader);
|
}
|
return me.reader || null;
|
}
|
});
|
</pre>
|
</body>
|
</html>
|
