3 * @class Ext.data.reader.Xml
4 * @extends Ext.data.reader.Reader
6 * <p>The XML Reader is used by a Proxy to read a server response that is sent back in XML format. This usually
7 * happens as a result of loading a Store - for example we might create something like this:</p>
11 extend: 'Ext.data.Model',
12 fields: ['id', 'name', 'email']
15 var store = new Ext.data.Store({
28 * <p>The example above creates a 'User' model. Models are explained in the {@link Ext.data.Model Model} docs if you're
29 * not already familiar with them.</p>
31 * <p>We created the simplest type of XML Reader possible by simply telling our {@link Ext.data.Store Store}'s
32 * {@link Ext.data.proxy.Proxy Proxy} that we want a XML Reader. The Store automatically passes the configured model to the
33 * Store, so it is as if we passed this instead:
43 * <p>The reader we set up is ready to read data from our server - at the moment it will accept a response like this:</p>
46 <?xml version="1.0" encoding="UTF-8"?>
48 <id>1</id>
49 <name>Ed Spencer</name>
50 <email>ed@sencha.com</email>
53 <id>2</id>
54 <name>Abe Elias</name>
55 <email>abe@sencha.com</email>
59 * <p>The XML Reader uses the configured {@link #record} option to pull out the data for each record - in this case we
60 * set record to 'user', so each <user> above will be converted into a User model.</p>
62 * <p><u>Reading other XML formats</u></p>
64 * <p>If you already have your XML format defined and it doesn't look quite like what we have above, you can usually
65 * pass XmlReader a couple of configuration options to make it parse your format. For example, we can use the
66 * {@link #root} configuration to parse data that comes back like this:</p>
69 <?xml version="1.0" encoding="UTF-8"?>
72 <id>1</id>
73 <name>Ed Spencer</name>
74 <email>ed@sencha.com</email>
77 <id>2</id>
78 <name>Abe Elias</name>
79 <email>abe@sencha.com</email>
84 * <p>To parse this we just pass in a {@link #root} configuration that matches the 'users' above:</p>
94 * <p>Note that XmlReader doesn't care whether your {@link #root} and {@link #record} elements are nested deep inside
95 * a larger structure, so a response like this will still work:
98 <?xml version="1.0" encoding="UTF-8"?>
104 <id>1</id>
105 <name>Ed Spencer</name>
106 <email>ed@sencha.com</email>
109 <id>2</id>
110 <name>Abe Elias</name>
111 <email>abe@sencha.com</email>
119 * <p><u>Response metadata</u></p>
121 * <p>The server can return additional data in its response, such as the {@link #totalProperty total number of records}
122 * and the {@link #successProperty success status of the response}. These are typically included in the XML response
126 <?xml version="1.0" encoding="UTF-8"?>
127 <total>100</total>
128 <success>true</success>
131 <id>1</id>
132 <name>Ed Spencer</name>
133 <email>ed@sencha.com</email>
136 <id>2</id>
137 <name>Abe Elias</name>
138 <email>abe@sencha.com</email>
143 * <p>If these properties are present in the XML response they can be parsed out by the XmlReader and used by the
144 * Store that loaded it. We can set up the names of these properties by specifying a final pair of configuration
151 totalProperty : 'total',
152 successProperty: 'success'
156 * <p>These final options are not necessary to make the Reader work, but can be useful when the server needs to report
157 * an error or if it needs to indicate that there is a lot of data available of which only a subset is currently being
160 * <p><u>Response format</u></p>
162 * <p><b>Note:</b> in order for the browser to parse a returned XML document, the Content-Type header in the HTTP
163 * response must be set to "text/xml" or "application/xml". This is very important - the XmlReader will not
164 * work correctly otherwise.</p>
166 Ext.define('Ext.data.reader.Xml', {
167 extend: 'Ext.data.reader.Reader',
168 alternateClassName: 'Ext.data.XmlReader',
169 alias : 'reader.xml',
172 * @cfg {String} record The DomQuery path to the repeated element which contains record information.
177 * Creates a function to return some particular key of data from a response. The totalProperty and
178 * successProperty are treated as special cases for type casting, everything else is just a simple selector.
179 * @param {String} key
182 createAccessor: function(expr) {
185 if (Ext.isEmpty(expr)) {
189 if (Ext.isFunction(expr)) {
193 return function(root) {
194 var node = Ext.DomQuery.selectNode(expr, root),
195 val = me.getNodeValue(node);
197 return Ext.isEmpty(val) ? null : val;
201 getNodeValue: function(node) {
203 if (node && node.firstChild) {
204 val = node.firstChild.nodeValue;
210 getResponseData: function(response) {
211 var xml = response.responseXML;
217 msg: 'XML data not found in the response'
226 * Normalizes the data object
227 * @param {Object} data The raw data object
228 * @return {Object} Returns the documentElement property of the data object if present, or the same object if not
230 getData: function(data) {
231 return data.documentElement || data;
236 * Given an XML object, returns the Element that represents the root as configured by the Reader's meta data
237 * @param {Object} data The XML data object
238 * @return {Element} The root node element
240 getRoot: function(data) {
241 var nodeName = data.nodeName,
244 if (!root || (nodeName && nodeName == root)) {
246 } else if (Ext.DomQuery.isXml(data)) {
247 // This fix ensures we have XML data
248 // Related to TreeStore calling getRoot with the root node, which isn't XML
249 // Probably should be resolved in TreeStore at some point
250 return Ext.DomQuery.selectNode(root, data);
256 * We're just preparing the data for the superclass by pulling out the record nodes we want
257 * @param {Element} root The XML root node
258 * @return {Array} The records
260 extractData: function(root) {
261 var recordName = this.record;
265 Ext.Error.raise('Record is a required parameter');
269 if (recordName != root.nodeName) {
270 root = Ext.DomQuery.select(recordName, root);
274 return this.callParent([root]);
279 * See Ext.data.reader.Reader's getAssociatedDataRoot docs
280 * @param {Mixed} data The raw data object
281 * @param {String} associationName The name of the association to get data for (uses associationKey if present)
282 * @return {Mixed} The root
284 getAssociatedDataRoot: function(data, associationName) {
285 return Ext.DomQuery.select(associationName, data)[0];
289 * Parses an XML document and returns a ResultSet containing the model instances
290 * @param {Object} doc Parsed XML document
291 * @return {Ext.data.ResultSet} The parsed result set
293 readRecords: function(doc) {
294 //it's possible that we get passed an array here by associations. Make sure we strip that out (see Ext.data.reader.Reader#readAssociated)
295 if (Ext.isArray(doc)) {
300 * DEPRECATED - will be removed in Ext JS 5.0. This is just a copy of this.rawData - use that instead
305 return this.callParent([doc]);