566 lines
16 KiB
JavaScript
566 lines
16 KiB
JavaScript
//>>built
|
|
define("dojox/data/HtmlStore", ["dojo/_base/declare", "dojo/_base/array", "dojo/_base/lang", "dojo/dom", "dojo/_base/xhr", "dojo/_base/window",
|
|
"dojo/data/util/simpleFetch", "dojo/data/util/filter", "dojox/xml/parser"],
|
|
function(declare, array, lang, dom, xhr, winUtil, simpleFetch, filter, xmlParser) {
|
|
|
|
var HtmlStore = declare("dojox.data.HtmlStore", null, {
|
|
constructor: function(/*Object*/args){
|
|
// summary:
|
|
// Initializer for the HTML table store.
|
|
// description:
|
|
// The HtmlStore can be created in one of two ways: a) by parsing an existing
|
|
// table or list DOM node on the current page or b) by referencing an external url and giving
|
|
// the id of the table or list in that page. The remote url will be parsed as an html page.
|
|
//
|
|
// The HTML table or list should be of the following form:
|
|
//
|
|
// | <table id="myTable">
|
|
// | <thead>
|
|
// | <tr>
|
|
// | <th>Attribute1</th>
|
|
// | <th>Attribute2</th>
|
|
// | </tr>
|
|
// | </thead>
|
|
// | <tbody>
|
|
// | <tr>
|
|
// | <td>Value1.1</td>
|
|
// | <td>Value1.2</td>
|
|
// | </tr>
|
|
// | <tr>
|
|
// | <td>Value2.1</td>
|
|
// | <td>Value2.2</td>
|
|
// | </tr>
|
|
// | </tbody>
|
|
// | </table>
|
|
//
|
|
// -or-
|
|
//
|
|
// | <ul id="myUnorderedList">
|
|
// | <li>Value.1</li>
|
|
// | <li>Value.2</li>
|
|
// | </ul>
|
|
//
|
|
// -or-
|
|
//
|
|
// | <ol id="myOrderedList">
|
|
// | <li>Value.1</li>
|
|
// | <li>Value.2</li>
|
|
// | </ol>
|
|
//
|
|
// args:
|
|
// An anonymous object to initialize properties. It expects the following values:
|
|
// dataId: The id of the HTML table to use.
|
|
// OR
|
|
// url: The url of the remote page to load
|
|
// dataId: The id of the table element in the remote page
|
|
// and the option:
|
|
// trimWhitespace: Trim off any surrounding whitespace from the headers (attribute
|
|
// names) and text content of the items in question. Default is false for
|
|
// backwards compatibility.
|
|
if(args && "urlPreventCache" in args){
|
|
this.urlPreventCache = args.urlPreventCache?true:false;
|
|
}
|
|
if(args && "trimWhitespace" in args){
|
|
this.trimWhitespace = args.trimWhitespace?true:false;
|
|
}
|
|
if(args.url){
|
|
if(!args.dataId){
|
|
throw new Error("dojo.data.HtmlStore: Cannot instantiate using url without an id!");
|
|
}
|
|
this.url = args.url;
|
|
this.dataId = args.dataId;
|
|
}else{
|
|
if(args.dataId){
|
|
this.dataId = args.dataId;
|
|
}
|
|
}
|
|
if(args && "fetchOnCreate" in args){
|
|
this.fetchOnCreate = args.fetchOnCreate?true:false;
|
|
}
|
|
if(this.fetchOnCreate && this.dataId){
|
|
this.fetch();
|
|
}
|
|
},
|
|
|
|
// url: [public] string
|
|
// The URL from which to load an HTML document for data loading
|
|
url: "",
|
|
|
|
// dataId: [public] string
|
|
// The id in the document for an element from which to get the data.
|
|
dataId: "",
|
|
|
|
// trimWhitepace: [public] boolean
|
|
// Boolean flag to denote if the store should trim whitepace around
|
|
// header and data content of a node. This matters if reformatters
|
|
// alter the white spacing around the tags. The default is false for
|
|
// backwards compat.
|
|
trimWhitespace: false,
|
|
|
|
// urlPreventCache: [public] boolean
|
|
// Flag to denote if peventCache should be used on xhrGet calls.
|
|
urlPreventCache: false,
|
|
|
|
// fetchOnCreate: [public] boolean
|
|
// Flag to denote if it should try to load from a data id (nested in the page)
|
|
// The moment the store is created, instead of waiting for first
|
|
// fetch call.
|
|
fetchOnCreate: false,
|
|
|
|
_indexItems: function(){
|
|
// summary:
|
|
// Function to index items found under the id.
|
|
// tags:
|
|
// private
|
|
this._getHeadings();
|
|
if(this._rootNode.rows){//tables
|
|
if(this._rootNode.tBodies && this._rootNode.tBodies.length > 0){
|
|
this._rootNode = this._rootNode.tBodies[0];
|
|
}
|
|
var i;
|
|
for(i=0; i<this._rootNode.rows.length; i++){
|
|
this._rootNode.rows[i]._ident = i+1;
|
|
}
|
|
}else{//lists
|
|
var c=1;
|
|
for(i=0; i<this._rootNode.childNodes.length; i++){
|
|
if(this._rootNode.childNodes[i].nodeType === 1){
|
|
this._rootNode.childNodes[i]._ident = c;
|
|
c++;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
_getHeadings: function(){
|
|
// summary:
|
|
// Function to load the attribute names from the table header so that the
|
|
// attributes (cells in a row), can have a reasonable name.
|
|
// For list items, returns single implicit heading, ["name"]
|
|
this._headings = [];
|
|
if(this._rootNode.tHead){
|
|
array.forEach(this._rootNode.tHead.rows[0].cells, lang.hitch(this, function(th){
|
|
var text = xmlParser.textContent(th);
|
|
this._headings.push(this.trimWhitespace?lang.trim(text):text);
|
|
}));
|
|
}else{
|
|
this._headings = ["name"];
|
|
}
|
|
},
|
|
|
|
_getAllItems: function(){
|
|
// summary:
|
|
// Function to return all rows in the table as an array of items.
|
|
var items = [];
|
|
var i;
|
|
if(this._rootNode.rows){//table
|
|
for(i=0; i<this._rootNode.rows.length; i++){
|
|
items.push(this._rootNode.rows[i]);
|
|
}
|
|
}else{ //list
|
|
for(i=0; i<this._rootNode.childNodes.length; i++){
|
|
if(this._rootNode.childNodes[i].nodeType === 1){
|
|
items.push(this._rootNode.childNodes[i]);
|
|
}
|
|
}
|
|
}
|
|
return items; //array
|
|
},
|
|
|
|
_assertIsItem: function(/* item */ item){
|
|
// summary:
|
|
// This function tests whether the item passed in is indeed an item in the store.
|
|
// item:
|
|
// The item to test for being contained by the store.
|
|
if(!this.isItem(item)){
|
|
throw new Error("dojo.data.HtmlStore: a function was passed an item argument that was not an item");
|
|
}
|
|
},
|
|
|
|
_assertIsAttribute: function(/* String */ attribute){
|
|
// summary:
|
|
// This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
|
|
// attribute:
|
|
// The attribute to test for being contained by the store.
|
|
//
|
|
// returns:
|
|
// Returns the index (column) that the attribute resides in the row.
|
|
if(typeof attribute !== "string"){
|
|
throw new Error("dojo.data.HtmlStore: a function was passed an attribute argument that was not an attribute name string");
|
|
return -1;
|
|
}
|
|
return array.indexOf(this._headings, attribute); //int
|
|
},
|
|
|
|
/***************************************
|
|
dojo.data.api.Read API
|
|
***************************************/
|
|
|
|
getValue: function( /* item */ item,
|
|
/* attribute-name-string */ attribute,
|
|
/* value? */ defaultValue){
|
|
// summary:
|
|
// See dojo.data.api.Read.getValue()
|
|
var values = this.getValues(item, attribute);
|
|
return (values.length > 0)?values[0]:defaultValue; //Object || int || Boolean
|
|
},
|
|
|
|
getValues: function(/* item */ item,
|
|
/* attribute-name-string */ attribute){
|
|
// summary:
|
|
// See dojo.data.api.Read.getValues()
|
|
|
|
this._assertIsItem(item);
|
|
var index = this._assertIsAttribute(attribute);
|
|
if(index>-1){
|
|
var text;
|
|
if(item.cells){
|
|
text = xmlParser.textContent(item.cells[index]);
|
|
}else{//return Value for lists
|
|
text = xmlParser.textContent(item);
|
|
}
|
|
return [this.trimWhitespace?lang.trim(text):text];
|
|
}
|
|
return []; //Array
|
|
},
|
|
|
|
getAttributes: function(/* item */ item){
|
|
// summary:
|
|
// See dojo.data.api.Read.getAttributes()
|
|
this._assertIsItem(item);
|
|
var attributes = [];
|
|
for(var i=0; i<this._headings.length; i++){
|
|
if(this.hasAttribute(item, this._headings[i]))
|
|
attributes.push(this._headings[i]);
|
|
}
|
|
return attributes; //Array
|
|
},
|
|
|
|
hasAttribute: function( /* item */ item,
|
|
/* attribute-name-string */ attribute){
|
|
// summary:
|
|
// See dojo.data.api.Read.hasAttribute()
|
|
return this.getValues(item, attribute).length > 0;
|
|
},
|
|
|
|
containsValue: function(/* item */ item,
|
|
/* attribute-name-string */ attribute,
|
|
/* anything */ value){
|
|
// summary:
|
|
// See dojo.data.api.Read.containsValue()
|
|
var regexp = undefined;
|
|
if(typeof value === "string"){
|
|
regexp = filter.patternToRegExp(value, false);
|
|
}
|
|
return this._containsValue(item, attribute, value, regexp); //boolean.
|
|
},
|
|
|
|
_containsValue: function( /* item */ item,
|
|
/* attribute-name-string */ attribute,
|
|
/* anything */ value,
|
|
/* RegExp?*/ regexp){
|
|
// summary:
|
|
// Internal function for looking at the values contained by the item.
|
|
// description:
|
|
// Internal function for looking at the values contained by the item. This
|
|
// function allows for denoting if the comparison should be case sensitive for
|
|
// strings or not (for handling filtering cases where string case should not matter)
|
|
//
|
|
// item:
|
|
// The data item to examine for attribute values.
|
|
// attribute:
|
|
// The attribute to inspect.
|
|
// value:
|
|
// The value to match.
|
|
// regexp:
|
|
// Optional regular expression generated off value if value was of string type to handle wildcarding.
|
|
// If present and attribute values are string, then it can be used for comparison instead of 'value'
|
|
var values = this.getValues(item, attribute);
|
|
for(var i = 0; i < values.length; ++i){
|
|
var possibleValue = values[i];
|
|
if(typeof possibleValue === "string" && regexp){
|
|
return (possibleValue.match(regexp) !== null);
|
|
}else{
|
|
//Non-string matching.
|
|
if(value === possibleValue){
|
|
return true; // Boolean
|
|
}
|
|
}
|
|
}
|
|
return false; // Boolean
|
|
},
|
|
|
|
isItem: function(/* anything */ something){
|
|
// summary:
|
|
// See dojo.data.api.Read.isItem()
|
|
return something && dom.isDescendant(something, this._rootNode);
|
|
},
|
|
|
|
isItemLoaded: function(/* anything */ something){
|
|
// summary:
|
|
// See dojo.data.api.Read.isItemLoaded()
|
|
return this.isItem(something);
|
|
},
|
|
|
|
loadItem: function(/* Object */ keywordArgs){
|
|
// summary:
|
|
// See dojo.data.api.Read.loadItem()
|
|
this._assertIsItem(keywordArgs.item);
|
|
},
|
|
|
|
_fetchItems: function(request, fetchHandler, errorHandler){
|
|
// summary:
|
|
// Fetch items (XML elements) that match to a query
|
|
// description:
|
|
// If '_fetchUrl' is specified, it is used to load an XML document
|
|
// with a query string.
|
|
// Otherwise and if 'url' is specified, the XML document is
|
|
// loaded and list XML elements that match to a query (set of element
|
|
// names and their text attribute values that the items to contain).
|
|
// A wildcard, "*" can be used to query values to match all
|
|
// occurrences.
|
|
// If '_rootItem' is specified, it is used to fetch items.
|
|
// request:
|
|
// A request object
|
|
// fetchHandler:
|
|
// A function to call for fetched items
|
|
// errorHandler:
|
|
// A function to call on error
|
|
|
|
if(this._rootNode){
|
|
this._finishFetchItems(request, fetchHandler, errorHandler);
|
|
}else{
|
|
if(!this.url){
|
|
this._rootNode = dom.byId(this.dataId);
|
|
this._indexItems();
|
|
this._finishFetchItems(request, fetchHandler, errorHandler);
|
|
}else{
|
|
var getArgs = {
|
|
url: this.url,
|
|
handleAs: "text",
|
|
preventCache: this.urlPreventCache
|
|
};
|
|
var self = this;
|
|
var getHandler = xhr.get(getArgs);
|
|
getHandler.addCallback(function(data){
|
|
var findNode = function(node, id){
|
|
if(node.id == id){
|
|
return node; //object
|
|
}
|
|
if(node.childNodes){
|
|
for(var i=0; i<node.childNodes.length; i++){
|
|
var returnNode = findNode(node.childNodes[i], id);
|
|
if(returnNode){
|
|
return returnNode; //object
|
|
}
|
|
}
|
|
}
|
|
return null; //null
|
|
}
|
|
|
|
var d = document.createElement("div");
|
|
d.innerHTML = data;
|
|
self._rootNode = findNode(d, self.dataId);
|
|
self._indexItems();
|
|
self._finishFetchItems(request, fetchHandler, errorHandler);
|
|
});
|
|
getHandler.addErrback(function(error){
|
|
errorHandler(error, request);
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
_finishFetchItems: function(request, fetchHandler, errorHandler){
|
|
// summary:
|
|
// Internal function for processing the passed in request and locating the requested items.
|
|
var items = [];
|
|
var arrayOfAllItems = this._getAllItems();
|
|
if(request.query){
|
|
var ignoreCase = request.queryOptions ? request.queryOptions.ignoreCase : false;
|
|
items = [];
|
|
|
|
//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the
|
|
//same value for each item examined. Much more efficient.
|
|
var regexpList = {};
|
|
var key;
|
|
var value;
|
|
for(key in request.query){
|
|
value = request.query[key]+'';
|
|
if(typeof value === "string"){
|
|
regexpList[key] = filter.patternToRegExp(value, ignoreCase);
|
|
}
|
|
}
|
|
|
|
for(var i = 0; i < arrayOfAllItems.length; ++i){
|
|
var match = true;
|
|
var candidateItem = arrayOfAllItems[i];
|
|
for(key in request.query){
|
|
value = request.query[key]+'';
|
|
if(!this._containsValue(candidateItem, key, value, regexpList[key])){
|
|
match = false;
|
|
}
|
|
}
|
|
if(match){
|
|
items.push(candidateItem);
|
|
}
|
|
}
|
|
fetchHandler(items, request);
|
|
}else{
|
|
// We want a copy to pass back in case the parent wishes to sort the array. We shouldn't allow resort
|
|
// of the internal list so that multiple callers can get listsand sort without affecting each other.
|
|
if(arrayOfAllItems.length> 0){
|
|
items = arrayOfAllItems.slice(0,arrayOfAllItems.length);
|
|
}
|
|
fetchHandler(items, request);
|
|
}
|
|
},
|
|
|
|
getFeatures: function(){
|
|
// summary:
|
|
// See dojo.data.api.Read.getFeatures()
|
|
return {
|
|
'dojo.data.api.Read': true,
|
|
'dojo.data.api.Identity': true
|
|
};
|
|
},
|
|
|
|
close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
|
|
// summary:
|
|
// See dojo.data.api.Read.close()
|
|
// nothing to do here!
|
|
},
|
|
|
|
getLabel: function(/* item */ item){
|
|
// summary:
|
|
// See dojo.data.api.Read.getLabel()
|
|
if(this.isItem(item)){
|
|
if(item.cells){
|
|
return "Item #" + this.getIdentity(item);
|
|
}else{
|
|
return this.getValue(item,"name");
|
|
}
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
getLabelAttributes: function(/* item */ item){
|
|
// summary:
|
|
// See dojo.data.api.Read.getLabelAttributes()
|
|
if(item.cells){
|
|
return null;
|
|
}else{
|
|
return ["name"];
|
|
}
|
|
},
|
|
|
|
/***************************************
|
|
dojo.data.api.Identity API
|
|
***************************************/
|
|
|
|
getIdentity: function(/* item */ item){
|
|
// summary:
|
|
// See dojo.data.api.Identity.getIdentity()
|
|
this._assertIsItem(item);
|
|
if(this.hasAttribute(item, "name")){
|
|
return this.getValue(item,"name");
|
|
}else{
|
|
return item._ident;
|
|
}
|
|
},
|
|
|
|
getIdentityAttributes: function(/* item */ item){
|
|
// summary:
|
|
// See dojo.data.api.Identity.getIdentityAttributes()
|
|
//Identity isn't taken from a public attribute.
|
|
return null;
|
|
},
|
|
|
|
fetchItemByIdentity: function(keywordArgs){
|
|
// summary:
|
|
// See dojo.data.api.Identity.fetchItemByIdentity()
|
|
var identity = keywordArgs.identity;
|
|
var self = this;
|
|
var item = null;
|
|
var scope = null;
|
|
if(!this._rootNode){
|
|
if(!this.url){
|
|
this._rootNode = dom.byId(this.dataId);
|
|
this._indexItems();
|
|
if(self._rootNode.rows){ //Table
|
|
item = this._rootNode.rows[identity + 1];
|
|
}else{ //Lists
|
|
for(var i = 0; i < self._rootNode.childNodes.length; i++){
|
|
if(self._rootNode.childNodes[i].nodeType === 1 && identity === xmlParser.textContent(self._rootNode.childNodes[i])){
|
|
item = self._rootNode.childNodes[i];
|
|
}
|
|
}
|
|
}
|
|
if(keywordArgs.onItem){
|
|
scope = keywordArgs.scope?keywordArgs.scope:winUtil.global;
|
|
keywordArgs.onItem.call(scope, item);
|
|
}
|
|
|
|
}else{
|
|
var getArgs = {
|
|
url: this.url,
|
|
handleAs: "text"
|
|
};
|
|
var getHandler = xhr.get(getArgs);
|
|
getHandler.addCallback(function(data){
|
|
var findNode = function(node, id){
|
|
if(node.id == id){
|
|
return node; //object
|
|
}
|
|
if(node.childNodes){
|
|
for(var i=0; i<node.childNodes.length; i++){
|
|
var returnNode = findNode(node.childNodes[i], id);
|
|
if(returnNode){
|
|
return returnNode; //object
|
|
}
|
|
}
|
|
}
|
|
return null; //null
|
|
}
|
|
var d = document.createElement("div");
|
|
d.innerHTML = data;
|
|
self._rootNode = findNode(d, self.dataId);
|
|
self._indexItems();
|
|
if(self._rootNode.rows && identity <= self._rootNode.rows.length){ //Table
|
|
item = self._rootNode.rows[identity-1];
|
|
}else{ //List
|
|
for(var i = 0; i < self._rootNode.childNodes.length; i++){
|
|
if(self._rootNode.childNodes[i].nodeType === 1 && identity === xmlParser.textContent(self._rootNode.childNodes[i])){
|
|
item = self._rootNode.childNodes[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(keywordArgs.onItem){
|
|
scope = keywordArgs.scope?keywordArgs.scope:winUtil.global;
|
|
keywordArgs.onItem.call(scope, item);
|
|
}
|
|
});
|
|
getHandler.addErrback(function(error){
|
|
if(keywordArgs.onError){
|
|
scope = keywordArgs.scope?keywordArgs.scope:winUtil.global;
|
|
keywordArgs.onError.call(scope, error);
|
|
|
|
}
|
|
});
|
|
}
|
|
}else{
|
|
if(this._rootNode.rows[identity+1]){
|
|
item = this._rootNode.rows[identity+1];
|
|
if(keywordArgs.onItem){
|
|
scope = keywordArgs.scope?keywordArgs.scope:winUtil.global;
|
|
keywordArgs.onItem.call(scope, item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
lang.extend(HtmlStore, simpleFetch);
|
|
return HtmlStore;
|
|
});
|