Improve output: distinguish between failed assertions (failures) and unexpected exceptions (errors), and print a filtered stack trace for any exception.
This commit is contained in:
jeb228
commit
4f2e303079
1839 changed files with 235630 additions and 0 deletions
62
webapp/web/src/data/Attribute.js
Normal file
62
webapp/web/src/data/Attribute.js
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Attribute");
|
||||
dojo.require("dojo.data.Item");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Attribute = function(/* dojo.data.provider.Base */ dataProvider, /* string */ attributeId) {
|
||||
/**
|
||||
* summary:
|
||||
* An Attribute object represents something like a column in
|
||||
* a relational database.
|
||||
*/
|
||||
dojo.lang.assertType(dataProvider, [dojo.data.provider.Base, "optional"]);
|
||||
dojo.lang.assertType(attributeId, String);
|
||||
dojo.data.Item.call(this, dataProvider);
|
||||
this._attributeId = attributeId;
|
||||
};
|
||||
dojo.inherits(dojo.data.Attribute, dojo.data.Item);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Attribute.prototype.toString = function() {
|
||||
return this._attributeId; // string
|
||||
};
|
||||
|
||||
dojo.data.Attribute.prototype.getAttributeId = function() {
|
||||
/**
|
||||
* summary:
|
||||
* Returns the string token that uniquely identifies this
|
||||
* attribute within the context of a data provider.
|
||||
* For a data provider that accesses relational databases,
|
||||
* typical attributeIds might be tokens like "name", "age",
|
||||
* "ssn", or "dept_key".
|
||||
*/
|
||||
return this._attributeId; // string
|
||||
};
|
||||
|
||||
dojo.data.Attribute.prototype.getType = function() {
|
||||
/**
|
||||
* summary: Returns the data type of the values of this attribute.
|
||||
*/
|
||||
return this.get('type'); // dojo.data.Type or null
|
||||
};
|
||||
|
||||
dojo.data.Attribute.prototype.setType = function(/* dojo.data.Type or null */ type) {
|
||||
/**
|
||||
* summary: Sets the data type for this attribute.
|
||||
*/
|
||||
this.set('type', type);
|
||||
};
|
||||
332
webapp/web/src/data/Item.js
Normal file
332
webapp/web/src/data/Item.js
Normal file
|
|
@ -0,0 +1,332 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Item");
|
||||
dojo.require("dojo.data.Observable");
|
||||
dojo.require("dojo.data.Value");
|
||||
dojo.require("dojo.lang.common");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Item = function(/* dojo.data.provider.Base */ dataProvider) {
|
||||
/**
|
||||
* summary:
|
||||
* An Item has attributes and attribute values, sort of like
|
||||
* a record in a database, or a 'struct' in C. Instances of
|
||||
* the Item class know how to store and retrieve their
|
||||
* attribute values.
|
||||
*/
|
||||
dojo.lang.assertType(dataProvider, [dojo.data.provider.Base, "optional"]);
|
||||
dojo.data.Observable.call(this);
|
||||
this._dataProvider = dataProvider;
|
||||
this._dictionaryOfAttributeValues = {};
|
||||
};
|
||||
dojo.inherits(dojo.data.Item, dojo.data.Observable);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public class methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Item.compare = function(/* dojo.data.Item */ itemOne, /* dojo.data.Item */ itemTwo) {
|
||||
/**
|
||||
* summary:
|
||||
* Given two Items to compare, this method returns 0, 1, or -1.
|
||||
* This method is designed to be used by sorting routines, like
|
||||
* the JavaScript built-in Array sort() method.
|
||||
*
|
||||
* Example:
|
||||
* <pre>
|
||||
* var a = dataProvider.newItem("kermit");
|
||||
* var b = dataProvider.newItem("elmo");
|
||||
* var c = dataProvider.newItem("grover");
|
||||
* var array = new Array(a, b, c);
|
||||
* array.sort(dojo.data.Item.compare);
|
||||
* </pre>
|
||||
*/
|
||||
dojo.lang.assertType(itemOne, dojo.data.Item);
|
||||
if (!dojo.lang.isOfType(itemTwo, dojo.data.Item)) {
|
||||
return -1;
|
||||
}
|
||||
var nameOne = itemOne.getName();
|
||||
var nameTwo = itemTwo.getName();
|
||||
if (nameOne == nameTwo) {
|
||||
var attributeArrayOne = itemOne.getAttributes();
|
||||
var attributeArrayTwo = itemTwo.getAttributes();
|
||||
if (attributeArrayOne.length != attributeArrayTwo.length) {
|
||||
if (attributeArrayOne.length > attributeArrayTwo.length) {
|
||||
return 1;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
for (var i in attributeArrayOne) {
|
||||
var attribute = attributeArrayOne[i];
|
||||
var arrayOfValuesOne = itemOne.getValues(attribute);
|
||||
var arrayOfValuesTwo = itemTwo.getValues(attribute);
|
||||
dojo.lang.assert(arrayOfValuesOne && (arrayOfValuesOne.length > 0));
|
||||
if (!arrayOfValuesTwo) {
|
||||
return 1;
|
||||
}
|
||||
if (arrayOfValuesOne.length != arrayOfValuesTwo.length) {
|
||||
if (arrayOfValuesOne.length > arrayOfValuesTwo.length) {
|
||||
return 1;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
for (var j in arrayOfValuesOne) {
|
||||
var value = arrayOfValuesOne[j];
|
||||
if (!itemTwo.hasAttributeValue(value)) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (nameOne > nameTwo) {
|
||||
return 1;
|
||||
} else {
|
||||
return -1; // 0, 1, or -1
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Item.prototype.toString = function() {
|
||||
/**
|
||||
* Returns a simple string representation of the item.
|
||||
*/
|
||||
var arrayOfStrings = [];
|
||||
var attributes = this.getAttributes();
|
||||
for (var i in attributes) {
|
||||
var attribute = attributes[i];
|
||||
var arrayOfValues = this.getValues(attribute);
|
||||
var valueString;
|
||||
if (arrayOfValues.length == 1) {
|
||||
valueString = arrayOfValues[0];
|
||||
} else {
|
||||
valueString = '[';
|
||||
valueString += arrayOfValues.join(', ');
|
||||
valueString += ']';
|
||||
}
|
||||
arrayOfStrings.push(' ' + attribute + ': ' + valueString);
|
||||
}
|
||||
var returnString = '{ ';
|
||||
returnString += arrayOfStrings.join(',\n');
|
||||
returnString += ' }';
|
||||
return returnString; // string
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.compare = function(/* dojo.data.Item */ otherItem) {
|
||||
/**
|
||||
* summary: Compares this Item to another Item, and returns 0, 1, or -1.
|
||||
*/
|
||||
return dojo.data.Item.compare(this, otherItem); // 0, 1, or -1
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.isEqual = function(/* dojo.data.Item */ otherItem) {
|
||||
/**
|
||||
* summary: Returns true if this Item is equal to the otherItem, or false otherwise.
|
||||
*/
|
||||
return (this.compare(otherItem) == 0); // boolean
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.getName = function() {
|
||||
return this.get('name');
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.get = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
/**
|
||||
* summary: Returns a single literal value, like "foo" or 33.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
|
||||
if (dojo.lang.isUndefined(literalOrValueOrArray)) {
|
||||
return null; // null
|
||||
}
|
||||
if (literalOrValueOrArray instanceof dojo.data.Value) {
|
||||
return literalOrValueOrArray.getValue(); // literal
|
||||
}
|
||||
if (dojo.lang.isArray(literalOrValueOrArray)) {
|
||||
var dojoDataValue = literalOrValueOrArray[0];
|
||||
return dojoDataValue.getValue(); // literal
|
||||
}
|
||||
return literalOrValueOrArray; // literal
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.getValue = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
/**
|
||||
* summary: Returns a single instance of dojo.data.Value.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
|
||||
if (dojo.lang.isUndefined(literalOrValueOrArray)) {
|
||||
return null; // null
|
||||
}
|
||||
if (literalOrValueOrArray instanceof dojo.data.Value) {
|
||||
return literalOrValueOrArray; // dojo.data.Value
|
||||
}
|
||||
if (dojo.lang.isArray(literalOrValueOrArray)) {
|
||||
var dojoDataValue = literalOrValueOrArray[0];
|
||||
return dojoDataValue; // dojo.data.Value
|
||||
}
|
||||
var literal = literalOrValueOrArray;
|
||||
dojoDataValue = new dojo.data.Value(literal);
|
||||
this._dictionaryOfAttributeValues[attributeId] = dojoDataValue;
|
||||
return dojoDataValue; // dojo.data.Value
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.getValues = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
/**
|
||||
* summary: Returns an array of dojo.data.Value objects.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
|
||||
if (dojo.lang.isUndefined(literalOrValueOrArray)) {
|
||||
return null; // null
|
||||
}
|
||||
if (literalOrValueOrArray instanceof dojo.data.Value) {
|
||||
var array = [literalOrValueOrArray];
|
||||
this._dictionaryOfAttributeValues[attributeId] = array;
|
||||
return array; // Array
|
||||
}
|
||||
if (dojo.lang.isArray(literalOrValueOrArray)) {
|
||||
return literalOrValueOrArray; // Array
|
||||
}
|
||||
var literal = literalOrValueOrArray;
|
||||
var dojoDataValue = new dojo.data.Value(literal);
|
||||
array = [dojoDataValue];
|
||||
this._dictionaryOfAttributeValues[attributeId] = array;
|
||||
return array; // Array
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.load = function(/* string or dojo.data.Attribute */ attributeId, /* anything */ value) {
|
||||
/**
|
||||
* summary:
|
||||
* Used for loading an attribute value into an item when
|
||||
* the item is first being loaded into memory from some
|
||||
* data store (such as a file).
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
this._dataProvider.registerAttribute(attributeId);
|
||||
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
|
||||
if (dojo.lang.isUndefined(literalOrValueOrArray)) {
|
||||
this._dictionaryOfAttributeValues[attributeId] = value;
|
||||
return;
|
||||
}
|
||||
if (!(value instanceof dojo.data.Value)) {
|
||||
value = new dojo.data.Value(value);
|
||||
}
|
||||
if (literalOrValueOrArray instanceof dojo.data.Value) {
|
||||
var array = [literalOrValueOrArray, value];
|
||||
this._dictionaryOfAttributeValues[attributeId] = array;
|
||||
return;
|
||||
}
|
||||
if (dojo.lang.isArray(literalOrValueOrArray)) {
|
||||
literalOrValueOrArray.push(value);
|
||||
return;
|
||||
}
|
||||
var literal = literalOrValueOrArray;
|
||||
var dojoDataValue = new dojo.data.Value(literal);
|
||||
array = [dojoDataValue, value];
|
||||
this._dictionaryOfAttributeValues[attributeId] = array;
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.set = function(/* string or dojo.data.Attribute */ attributeId, /* anything */ value) {
|
||||
/**
|
||||
* summary:
|
||||
* Used for setting an attribute value as a result of a
|
||||
* user action.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
this._dataProvider.registerAttribute(attributeId);
|
||||
this._dictionaryOfAttributeValues[attributeId] = value;
|
||||
this._dataProvider.noteChange(this, attributeId, value);
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.setValue = function(/* string or dojo.data.Attribute */ attributeId, /* dojo.data.Value */ value) {
|
||||
this.set(attributeId, value);
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.addValue = function(/* string or dojo.data.Attribute */ attributeId, /* anything */ value) {
|
||||
/**
|
||||
* summary:
|
||||
* Used for adding an attribute value as a result of a
|
||||
* user action.
|
||||
*/
|
||||
this.load(attributeId, value);
|
||||
this._dataProvider.noteChange(this, attributeId, value);
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.setValues = function(/* string or dojo.data.Attribute */ attributeId, /* Array */ arrayOfValues) {
|
||||
/**
|
||||
* summary:
|
||||
* Used for setting an array of attribute values as a result of a
|
||||
* user action.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
dojo.lang.assertType(arrayOfValues, Array);
|
||||
this._dataProvider.registerAttribute(attributeId);
|
||||
var finalArray = [];
|
||||
this._dictionaryOfAttributeValues[attributeId] = finalArray;
|
||||
for (var i in arrayOfValues) {
|
||||
var value = arrayOfValues[i];
|
||||
if (!(value instanceof dojo.data.Value)) {
|
||||
value = new dojo.data.Value(value);
|
||||
}
|
||||
finalArray.push(value);
|
||||
this._dataProvider.noteChange(this, attributeId, value);
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.getAttributes = function() {
|
||||
/**
|
||||
* summary:
|
||||
* Returns an array containing all of the attributes for which
|
||||
* this item has attribute values.
|
||||
*/
|
||||
var arrayOfAttributes = [];
|
||||
for (var key in this._dictionaryOfAttributeValues) {
|
||||
arrayOfAttributes.push(this._dataProvider.getAttribute(key));
|
||||
}
|
||||
return arrayOfAttributes; // Array
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.hasAttribute = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
/**
|
||||
* summary: Returns true if the given attribute of the item has been assigned any value.
|
||||
*/
|
||||
// dojo.lang.assertType(attributeId, [String, dojo.data.Attribute]);
|
||||
for (var key in this._dictionaryOfAttributeValues) {
|
||||
if (key == attributeId) {
|
||||
return true; // boolean
|
||||
}
|
||||
}
|
||||
return false; // boolean
|
||||
};
|
||||
|
||||
dojo.data.Item.prototype.hasAttributeValue = function(/* string or dojo.data.Attribute */ attributeId, /* anything */ value) {
|
||||
/**
|
||||
* summary: Returns true if the given attribute of the item has been assigned the given value.
|
||||
*/
|
||||
var arrayOfValues = this.getValues(attributeId);
|
||||
for (var i in arrayOfValues) {
|
||||
var candidateValue = arrayOfValues[i];
|
||||
if (candidateValue.isEqual(value)) {
|
||||
return true; // boolean
|
||||
}
|
||||
}
|
||||
return false; // boolean
|
||||
};
|
||||
|
||||
|
||||
28
webapp/web/src/data/Kind.js
Normal file
28
webapp/web/src/data/Kind.js
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Kind");
|
||||
dojo.require("dojo.data.Item");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Kind = function(/* dojo.data.provider.Base */ dataProvider) {
|
||||
/**
|
||||
* summary:
|
||||
* A Kind represents a kind of item. In the dojo data model
|
||||
* the item Snoopy might belong to the 'kind' Dog, where in
|
||||
* a Java program the object Snoopy would belong to the 'class'
|
||||
* Dog, and in MySQL the record for Snoopy would be in the
|
||||
* table Dog.
|
||||
*/
|
||||
dojo.data.Item.call(this, dataProvider);
|
||||
};
|
||||
dojo.inherits(dojo.data.Kind, dojo.data.Item);
|
||||
59
webapp/web/src/data/Observable.js
Normal file
59
webapp/web/src/data/Observable.js
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Observable");
|
||||
dojo.require("dojo.lang.common");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Observable = function() {
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Observable.prototype.addObserver = function(/* object */ observer) {
|
||||
/**
|
||||
* summary: Registers an object as an observer of this item,
|
||||
* so that the object will be notified when the item changes.
|
||||
*/
|
||||
dojo.lang.assertType(observer, Object);
|
||||
dojo.lang.assertType(observer.observedObjectHasChanged, Function);
|
||||
if (!this._arrayOfObservers) {
|
||||
this._arrayOfObservers = [];
|
||||
}
|
||||
if (!dojo.lang.inArray(this._arrayOfObservers, observer)) {
|
||||
this._arrayOfObservers.push(observer);
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.Observable.prototype.removeObserver = function(/* object */ observer) {
|
||||
/**
|
||||
* summary: Removes the observer registration for a previously
|
||||
* registered object.
|
||||
*/
|
||||
if (!this._arrayOfObservers) {
|
||||
return;
|
||||
}
|
||||
var index = dojo.lang.indexOf(this._arrayOfObservers, observer);
|
||||
if (index != -1) {
|
||||
this._arrayOfObservers.splice(index, 1);
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.Observable.prototype.getObservers = function() {
|
||||
/**
|
||||
* summary: Returns an array with all the observers of this item.
|
||||
*/
|
||||
return this._arrayOfObservers; // Array or undefined
|
||||
};
|
||||
|
||||
70
webapp/web/src/data/ResultSet.js
Normal file
70
webapp/web/src/data/ResultSet.js
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.ResultSet");
|
||||
dojo.require("dojo.lang.assert");
|
||||
dojo.require("dojo.collections.Collections");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.ResultSet = function(/* dojo.data.provider.Base */ dataProvider, /* Array */ arrayOfItems) {
|
||||
/**
|
||||
* summary:
|
||||
* A ResultSet holds a collection of Items. A data provider
|
||||
* returns a ResultSet in reponse to a query.
|
||||
* (The name "Result Set" comes from the MySQL terminology.)
|
||||
*/
|
||||
dojo.lang.assertType(dataProvider, [dojo.data.provider.Base, "optional"]);
|
||||
dojo.lang.assertType(arrayOfItems, [Array, "optional"]);
|
||||
dojo.data.Observable.call(this);
|
||||
this._dataProvider = dataProvider;
|
||||
this._arrayOfItems = [];
|
||||
if (arrayOfItems) {
|
||||
this._arrayOfItems = arrayOfItems;
|
||||
}
|
||||
};
|
||||
dojo.inherits(dojo.data.ResultSet, dojo.data.Observable);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.ResultSet.prototype.toString = function() {
|
||||
var returnString = this._arrayOfItems.join(', ');
|
||||
return returnString; // string
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.toArray = function() {
|
||||
return this._arrayOfItems; // Array
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.getIterator = function() {
|
||||
return new dojo.collections.Iterator(this._arrayOfItems);
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.getLength = function() {
|
||||
return this._arrayOfItems.length; // integer
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.getItemAt = function(/* numeric */ index) {
|
||||
return this._arrayOfItems[index];
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.indexOf = function(/* dojo.data.Item */ item) {
|
||||
return dojo.lang.indexOf(this._arrayOfItems, item); // integer
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.contains = function(/* dojo.data.Item */ item) {
|
||||
return dojo.lang.inArray(this._arrayOfItems, item); // boolean
|
||||
};
|
||||
|
||||
dojo.data.ResultSet.prototype.getDataProvider = function() {
|
||||
return this._dataProvider; // dojo.data.provider.Base
|
||||
};
|
||||
25
webapp/web/src/data/Type.js
Normal file
25
webapp/web/src/data/Type.js
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Type");
|
||||
dojo.require("dojo.data.Item");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Type = function(/* dojo.data.provider.Base */ dataProvider) {
|
||||
/**
|
||||
* summary:
|
||||
* A Type represents a type of value, like Text, Number, Picture,
|
||||
* or Varchar.
|
||||
*/
|
||||
dojo.data.Item.call(this, dataProvider);
|
||||
};
|
||||
dojo.inherits(dojo.data.Type, dojo.data.Item);
|
||||
55
webapp/web/src/data/Value.js
Normal file
55
webapp/web/src/data/Value.js
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.Value");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Value = function(/* anything */ value) {
|
||||
/**
|
||||
* summary:
|
||||
* A Value represents a simple literal value (like "foo" or 334),
|
||||
* or a reference value (a pointer to an Item).
|
||||
*/
|
||||
this._value = value;
|
||||
this._type = null;
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.Value.prototype.toString = function() {
|
||||
return this._value.toString(); // string
|
||||
};
|
||||
|
||||
dojo.data.Value.prototype.getValue = function() {
|
||||
/**
|
||||
* summary: Returns the value itself.
|
||||
*/
|
||||
return this._value; // anything
|
||||
};
|
||||
|
||||
dojo.data.Value.prototype.getType = function() {
|
||||
/**
|
||||
* summary: Returns the data type of the value.
|
||||
*/
|
||||
dojo.unimplemented('dojo.data.Value.prototype.getType');
|
||||
return this._type; // dojo.data.Type
|
||||
};
|
||||
|
||||
dojo.data.Value.prototype.compare = function() {
|
||||
dojo.unimplemented('dojo.data.Value.prototype.compare');
|
||||
};
|
||||
|
||||
dojo.data.Value.prototype.isEqual = function() {
|
||||
dojo.unimplemented('dojo.data.Value.prototype.isEqual');
|
||||
};
|
||||
22
webapp/web/src/data/__package__.js
Normal file
22
webapp/web/src/data/__package__.js
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.require("dojo.experimental");
|
||||
|
||||
dojo.experimental("dojo.data.*");
|
||||
dojo.kwCompoundRequire({
|
||||
common: [
|
||||
"dojo.data.Item",
|
||||
"dojo.data.ResultSet",
|
||||
"dojo.data.provider.FlatFile"
|
||||
]
|
||||
});
|
||||
dojo.provide("dojo.data.*");
|
||||
|
||||
112
webapp/web/src/data/format/Csv.js
Normal file
112
webapp/web/src/data/format/Csv.js
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.format.Csv");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
|
||||
dojo.data.format.Csv = new function() {
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public functions
|
||||
// -------------------------------------------------------------------
|
||||
this.getArrayStructureFromCsvFileContents = function(/* string */ csvFileContents) {
|
||||
/**
|
||||
* Given a string containing CSV records, this method parses
|
||||
* the string and returns a data structure containing the parsed
|
||||
* content. The data structure we return is an array of length
|
||||
* R, where R is the number of rows (lines) in the CSV data. The
|
||||
* return array contains one sub-array for each CSV line, and each
|
||||
* sub-array contains C string values, where C is the number of
|
||||
* columns in the CSV data.
|
||||
*
|
||||
* For example, given this CSV string as input:
|
||||
* <pre>
|
||||
* "Title, Year, Producer \n Alien, 1979, Ridley Scott \n Blade Runner, 1982, Ridley Scott"
|
||||
* </pre>
|
||||
* We will return this data structure:
|
||||
* <pre>
|
||||
* [["Title", "Year", "Producer"]
|
||||
* ["Alien", "1979", "Ridley Scott"],
|
||||
* ["Blade Runner", "1982", "Ridley Scott"]]
|
||||
* </pre>
|
||||
*/
|
||||
dojo.lang.assertType(csvFileContents, String);
|
||||
|
||||
var lineEndingCharacters = new RegExp("\r\n|\n|\r");
|
||||
var leadingWhiteSpaceCharacters = new RegExp("^\\s+",'g');
|
||||
var trailingWhiteSpaceCharacters = new RegExp("\\s+$",'g');
|
||||
var doubleQuotes = new RegExp('""','g');
|
||||
var arrayOfOutputRecords = [];
|
||||
|
||||
var arrayOfInputLines = csvFileContents.split(lineEndingCharacters);
|
||||
for (var i in arrayOfInputLines) {
|
||||
var singleLine = arrayOfInputLines[i];
|
||||
if (singleLine.length > 0) {
|
||||
var listOfFields = singleLine.split(',');
|
||||
var j = 0;
|
||||
while (j < listOfFields.length) {
|
||||
var space_field_space = listOfFields[j];
|
||||
var field_space = space_field_space.replace(leadingWhiteSpaceCharacters, ''); // trim leading whitespace
|
||||
var field = field_space.replace(trailingWhiteSpaceCharacters, ''); // trim trailing whitespace
|
||||
var firstChar = field.charAt(0);
|
||||
var lastChar = field.charAt(field.length - 1);
|
||||
var secondToLastChar = field.charAt(field.length - 2);
|
||||
var thirdToLastChar = field.charAt(field.length - 3);
|
||||
if ((firstChar == '"') &&
|
||||
((lastChar != '"') ||
|
||||
((lastChar == '"') && (secondToLastChar == '"') && (thirdToLastChar != '"')) )) {
|
||||
if (j+1 === listOfFields.length) {
|
||||
// alert("The last field in record " + i + " is corrupted:\n" + field);
|
||||
return null;
|
||||
}
|
||||
var nextField = listOfFields[j+1];
|
||||
listOfFields[j] = field_space + ',' + nextField;
|
||||
listOfFields.splice(j+1, 1); // delete element [j+1] from the list
|
||||
} else {
|
||||
if ((firstChar == '"') && (lastChar == '"')) {
|
||||
field = field.slice(1, (field.length - 1)); // trim the " characters off the ends
|
||||
field = field.replace(doubleQuotes, '"'); // replace "" with "
|
||||
}
|
||||
listOfFields[j] = field;
|
||||
j += 1;
|
||||
}
|
||||
}
|
||||
arrayOfOutputRecords.push(listOfFields);
|
||||
}
|
||||
}
|
||||
return arrayOfOutputRecords; // Array
|
||||
};
|
||||
|
||||
this.loadDataProviderFromFileContents = function(/* dojo.data.provider.Base */ dataProvider, /* string */ csvFileContents) {
|
||||
dojo.lang.assertType(dataProvider, dojo.data.provider.Base);
|
||||
dojo.lang.assertType(csvFileContents, String);
|
||||
var arrayOfArrays = this.getArrayStructureFromCsvFileContents(csvFileContents);
|
||||
if (arrayOfArrays) {
|
||||
var arrayOfKeys = arrayOfArrays[0];
|
||||
for (var i = 1; i < arrayOfArrays.length; ++i) {
|
||||
var row = arrayOfArrays[i];
|
||||
var item = dataProvider.getNewItemToLoad();
|
||||
for (var j in row) {
|
||||
var value = row[j];
|
||||
var key = arrayOfKeys[j];
|
||||
item.load(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
this.getCsvStringFromResultSet = function(/* dojo.data.ResultSet */ resultSet) {
|
||||
dojo.unimplemented('dojo.data.format.Csv.getCsvStringFromResultSet');
|
||||
var csvString = null;
|
||||
return csvString; // String
|
||||
};
|
||||
|
||||
}();
|
||||
103
webapp/web/src/data/format/Json.js
Normal file
103
webapp/web/src/data/format/Json.js
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.format.Json");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
dojo.data.format.Json = new function() {
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public functions
|
||||
// -------------------------------------------------------------------
|
||||
this.loadDataProviderFromFileContents = function(/* dojo.data.provider.Base */ dataProvider, /* string */ jsonFileContents) {
|
||||
dojo.lang.assertType(dataProvider, dojo.data.provider.Base);
|
||||
dojo.lang.assertType(jsonFileContents, String);
|
||||
var arrayOfJsonData = eval("(" + jsonFileContents + ")");
|
||||
this.loadDataProviderFromArrayOfJsonData(dataProvider, arrayOfJsonData);
|
||||
};
|
||||
|
||||
this.loadDataProviderFromArrayOfJsonData = function(/* dojo.data.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
|
||||
dojo.lang.assertType(arrayOfJsonData, [Array, "optional"]);
|
||||
if (arrayOfJsonData && (arrayOfJsonData.length > 0)) {
|
||||
var firstRow = arrayOfJsonData[0];
|
||||
dojo.lang.assertType(firstRow, [Array, "pureobject"]);
|
||||
if (dojo.lang.isArray(firstRow)) {
|
||||
_loadDataProviderFromArrayOfArrays(dataProvider, arrayOfJsonData);
|
||||
} else {
|
||||
dojo.lang.assertType(firstRow, "pureobject");
|
||||
_loadDataProviderFromArrayOfObjects(dataProvider, arrayOfJsonData);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
this.getJsonStringFromResultSet = function(/* dojo.data.ResultSet */ resultSet) {
|
||||
dojo.unimplemented('dojo.data.format.Json.getJsonStringFromResultSet');
|
||||
var jsonString = null;
|
||||
return jsonString; // String
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Private functions
|
||||
// -------------------------------------------------------------------
|
||||
function _loadDataProviderFromArrayOfArrays(/* dojo.data.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
|
||||
/**
|
||||
* Example:
|
||||
* var arrayOfJsonStates = [
|
||||
* [ "abbr", "population", "name" ]
|
||||
* [ "WA", 5894121, "Washington" ],
|
||||
* [ "WV", 1808344, "West Virginia" ],
|
||||
* [ "WI", 5453896, "Wisconsin" ],
|
||||
* [ "WY", 493782, "Wyoming" ] ];
|
||||
* this._loadFromArrayOfArrays(arrayOfJsonStates);
|
||||
*/
|
||||
var arrayOfKeys = arrayOfJsonData[0];
|
||||
for (var i = 1; i < arrayOfJsonData.length; ++i) {
|
||||
var row = arrayOfJsonData[i];
|
||||
var item = dataProvider.getNewItemToLoad();
|
||||
for (var j in row) {
|
||||
var value = row[j];
|
||||
var key = arrayOfKeys[j];
|
||||
item.load(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function _loadDataProviderFromArrayOfObjects(/* dojo.data.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
|
||||
/**
|
||||
* Example:
|
||||
* var arrayOfJsonStates = [
|
||||
* { abbr: "WA", name: "Washington" },
|
||||
* { abbr: "WV", name: "West Virginia" },
|
||||
* { abbr: "WI", name: "Wisconsin", song: "On, Wisconsin!" },
|
||||
* { abbr: "WY", name: "Wyoming", cities: ["Lander", "Cheyenne", "Laramie"] } ];
|
||||
* this._loadFromArrayOfArrays(arrayOfJsonStates);
|
||||
*/
|
||||
// dojo.debug("_loadDataProviderFromArrayOfObjects");
|
||||
for (var i in arrayOfJsonData) {
|
||||
var row = arrayOfJsonData[i];
|
||||
var item = dataProvider.getNewItemToLoad();
|
||||
for (var key in row) {
|
||||
var value = row[key];
|
||||
if (dojo.lang.isArray(value)) {
|
||||
var arrayOfValues = value;
|
||||
for (var j in arrayOfValues) {
|
||||
value = arrayOfValues[j];
|
||||
item.load(key, value);
|
||||
// dojo.debug("loaded: " + key + " = " + value);
|
||||
}
|
||||
} else {
|
||||
item.load(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}();
|
||||
|
||||
183
webapp/web/src/data/provider/Base.js
Normal file
183
webapp/web/src/data/provider/Base.js
Normal file
|
|
@ -0,0 +1,183 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.provider.Base");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.Base = function() {
|
||||
/**
|
||||
* summary:
|
||||
* A Data Provider serves as a connection to some data source,
|
||||
* like a relational database. This data provider Base class
|
||||
* serves as an abstract superclass for other data provider
|
||||
* classes.
|
||||
*/
|
||||
this._countOfNestedTransactions = 0;
|
||||
this._changesInCurrentTransaction = null;
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.Base.prototype.beginTransaction = function() {
|
||||
/**
|
||||
* Marks the beginning of a transaction.
|
||||
*
|
||||
* Each time you call beginTransaction() you open a new transaction,
|
||||
* which you need to close later using endTransaction(). Transactions
|
||||
* may be nested, but the beginTransaction and endTransaction calls
|
||||
* always need to come in pairs.
|
||||
*/
|
||||
if (this._countOfNestedTransactions === 0) {
|
||||
this._changesInCurrentTransaction = [];
|
||||
}
|
||||
this._countOfNestedTransactions += 1;
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.endTransaction = function() {
|
||||
/**
|
||||
* Marks the end of a transaction.
|
||||
*/
|
||||
this._countOfNestedTransactions -= 1;
|
||||
dojo.lang.assert(this._countOfNestedTransactions >= 0);
|
||||
|
||||
if (this._countOfNestedTransactions === 0) {
|
||||
var listOfChangesMade = this._saveChanges();
|
||||
this._changesInCurrentTransaction = null;
|
||||
if (listOfChangesMade.length > 0) {
|
||||
// dojo.debug("endTransaction: " + listOfChangesMade.length + " changes made");
|
||||
this._notifyObserversOfChanges(listOfChangesMade);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.getNewItemToLoad = function() {
|
||||
return this._newItem(); // dojo.data.Item
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.newItem = function(/* string */ itemName) {
|
||||
/**
|
||||
* Creates a new item.
|
||||
*/
|
||||
dojo.lang.assertType(itemName, [String, "optional"]);
|
||||
var item = this._newItem();
|
||||
if (itemName) {
|
||||
item.set('name', itemName);
|
||||
}
|
||||
return item; // dojo.data.Item
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.newAttribute = function(/* string */ attributeId) {
|
||||
/**
|
||||
* Creates a new attribute.
|
||||
*/
|
||||
dojo.lang.assertType(attributeId, String); // FIXME: should be optional
|
||||
var attribute = this._newAttribute(attributeId);
|
||||
return attribute; // dojo.data.Attribute
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.getAttribute = function(/* string */ attributeId) {
|
||||
dojo.unimplemented('dojo.data.provider.Base');
|
||||
var attribute;
|
||||
return attribute; // dojo.data.Attribute
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.getAttributes = function() {
|
||||
dojo.unimplemented('dojo.data.provider.Base');
|
||||
return this._arrayOfAttributes; // Array
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.fetchArray = function() {
|
||||
dojo.unimplemented('dojo.data.provider.Base');
|
||||
return []; // Array
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.fetchResultSet = function() {
|
||||
dojo.unimplemented('dojo.data.provider.Base');
|
||||
var resultSet;
|
||||
return resultSet; // dojo.data.ResultSet
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.noteChange = function(/* dojo.data.Item */ item, /* string or dojo.data.Attribute */ attribute, /* anything */ value) {
|
||||
var change = {item: item, attribute: attribute, value: value};
|
||||
if (this._countOfNestedTransactions === 0) {
|
||||
this.beginTransaction();
|
||||
this._changesInCurrentTransaction.push(change);
|
||||
this.endTransaction();
|
||||
} else {
|
||||
this._changesInCurrentTransaction.push(change);
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.addItemObserver = function(/* dojo.data.Item */ item, /* object */ observer) {
|
||||
/**
|
||||
* summary: Registers an object as an observer of an item,
|
||||
* so that the object will be notified when the item changes.
|
||||
*/
|
||||
dojo.lang.assertType(item, dojo.data.Item);
|
||||
item.addObserver(observer);
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype.removeItemObserver = function(/* dojo.data.Item */ item, /* object */ observer) {
|
||||
/**
|
||||
* summary: Removes the observer registration for a previously
|
||||
* registered object.
|
||||
*/
|
||||
dojo.lang.assertType(item, dojo.data.Item);
|
||||
item.removeObserver(observer);
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Private instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.Base.prototype._newItem = function() {
|
||||
var item = new dojo.data.Item(this);
|
||||
return item; // dojo.data.Item
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype._newAttribute = function(/* String */ attributeId) {
|
||||
var attribute = new dojo.data.Attribute(this);
|
||||
return attribute; // dojo.data.Attribute
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype._saveChanges = function() {
|
||||
var arrayOfChangesMade = this._changesInCurrentTransaction;
|
||||
return arrayOfChangesMade; // Array
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype._notifyObserversOfChanges = function(/* Array */ arrayOfChanges) {
|
||||
var arrayOfResultSets = this._getResultSets();
|
||||
for (var i in arrayOfChanges) {
|
||||
var change = arrayOfChanges[i];
|
||||
var changedItem = change.item;
|
||||
var arrayOfItemObservers = changedItem.getObservers();
|
||||
for (var j in arrayOfItemObservers) {
|
||||
var observer = arrayOfItemObservers[j];
|
||||
observer.observedObjectHasChanged(changedItem, change);
|
||||
}
|
||||
for (var k in arrayOfResultSets) {
|
||||
var resultSet = arrayOfResultSets[k];
|
||||
var arrayOfResultSetObservers = resultSet.getObservers();
|
||||
for (var m in arrayOfResultSetObservers) {
|
||||
observer = arrayOfResultSetObservers[m];
|
||||
observer.observedObjectHasChanged(resultSet, change);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype._getResultSets = function() {
|
||||
dojo.unimplemented('dojo.data.provider.Base');
|
||||
return []; // Array
|
||||
};
|
||||
|
||||
85
webapp/web/src/data/provider/Delicious.js
Normal file
85
webapp/web/src/data/provider/Delicious.js
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.provider.Delicious");
|
||||
dojo.require("dojo.data.provider.FlatFile");
|
||||
dojo.require("dojo.data.format.Json");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.Delicious = function() {
|
||||
/**
|
||||
* summary:
|
||||
* The Delicious Data Provider can be used to take data from
|
||||
* del.icio.us and make it available as dojo.data.Items
|
||||
* In order to use the Delicious Data Provider, you need
|
||||
* to have loaded a script tag that looks like this:
|
||||
* <script type="text/javascript" src="http://del.icio.us/feeds/json/gumption?count=8"></script>
|
||||
*/
|
||||
dojo.data.provider.FlatFile.call(this);
|
||||
// Delicious = null;
|
||||
if (Delicious && Delicious.posts) {
|
||||
dojo.data.format.Json.loadDataProviderFromArrayOfJsonData(this, Delicious.posts);
|
||||
} else {
|
||||
// document.write("<script type='text/javascript'>dojo.data.provider.Delicious._fetchComplete()</script>");
|
||||
/*
|
||||
document.write("<script type='text/javascript'>alert('boo!');</script>");
|
||||
document.write("<script type='text/javascript'>var foo = 'not dojo'; alert('dojo == ' + foo);</script>");
|
||||
document.write("<script type='text/javascript'>var foo = fetchComplete; alert('dojo == ' + foo);</script>");
|
||||
fetchComplete();
|
||||
*/
|
||||
// dojo.debug("Delicious line 29: constructor");
|
||||
}
|
||||
var u = this.registerAttribute('u');
|
||||
var d = this.registerAttribute('d');
|
||||
var t = this.registerAttribute('t');
|
||||
|
||||
u.load('name', 'Bookmark');
|
||||
d.load('name', 'Description');
|
||||
t.load('name', 'Tags');
|
||||
|
||||
u.load('type', 'String');
|
||||
d.load('type', 'String');
|
||||
t.load('type', 'String');
|
||||
};
|
||||
dojo.inherits(dojo.data.provider.Delicious, dojo.data.provider.FlatFile);
|
||||
|
||||
/********************************************************************
|
||||
* FIXME: the rest of this is work in progress
|
||||
*
|
||||
|
||||
dojo.data.provider.Delicious.prototype.getNewItemToLoad = function() {
|
||||
var newItem = this._newItem();
|
||||
this._currentArray.push(newItem);
|
||||
return newItem; // dojo.data.Item
|
||||
};
|
||||
|
||||
dojo.data.provider.Delicious.prototype.fetchArray = function(query) {
|
||||
if (!query) {
|
||||
query = "gumption";
|
||||
}
|
||||
this._currentArray = [];
|
||||
alert("Delicious line 60: loadDataProviderFromArrayOfJsonData");
|
||||
alert("Delicious line 61: " + dojo);
|
||||
var sourceUrl = "http://del.icio.us/feeds/json/" + query + "?count=8";
|
||||
document.write("<script type='text/javascript' src='" + sourceUrl + "'></script>");
|
||||
document.write("<script type='text/javascript'>alert('line 63: ' + Delicious.posts[0].u);</script>");
|
||||
document.write("<script type='text/javascript'>callMe();</script>");
|
||||
alert("line 66");
|
||||
dojo.data.format.Json.loadDataProviderFromArrayOfJsonData(this, Delicious.posts);
|
||||
return this._currentArray; // Array
|
||||
};
|
||||
|
||||
callMe = function() {
|
||||
alert("callMe!");
|
||||
};
|
||||
|
||||
*/
|
||||
153
webapp/web/src/data/provider/FlatFile.js
Normal file
153
webapp/web/src/data/provider/FlatFile.js
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.provider.FlatFile");
|
||||
dojo.require("dojo.data.provider.Base");
|
||||
dojo.require("dojo.data.Item");
|
||||
dojo.require("dojo.data.Attribute");
|
||||
dojo.require("dojo.data.ResultSet");
|
||||
dojo.require("dojo.data.format.Json");
|
||||
dojo.require("dojo.data.format.Csv");
|
||||
dojo.require("dojo.lang.assert");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.FlatFile = function(/* keywords */ keywordParameters) {
|
||||
/**
|
||||
* summary:
|
||||
* A Json Data Provider knows how to read in simple JSON data
|
||||
* tables and make their contents accessable as Items.
|
||||
*/
|
||||
dojo.lang.assertType(keywordParameters, ["pureobject", "optional"]);
|
||||
dojo.data.provider.Base.call(this);
|
||||
this._arrayOfItems = [];
|
||||
this._resultSet = null;
|
||||
this._dictionaryOfAttributes = {};
|
||||
|
||||
if (keywordParameters) {
|
||||
var jsonObjects = keywordParameters["jsonObjects"];
|
||||
var jsonString = keywordParameters["jsonString"];
|
||||
var fileUrl = keywordParameters["url"];
|
||||
if (jsonObjects) {
|
||||
dojo.data.format.Json.loadDataProviderFromArrayOfJsonData(this, jsonObjects);
|
||||
}
|
||||
if (jsonString) {
|
||||
dojo.data.format.Json.loadDataProviderFromFileContents(this, jsonString);
|
||||
}
|
||||
if (fileUrl) {
|
||||
var arrayOfParts = fileUrl.split('.');
|
||||
var lastPart = arrayOfParts[(arrayOfParts.length - 1)];
|
||||
var formatParser = null;
|
||||
if (lastPart == "json") {
|
||||
formatParser = dojo.data.format.Json;
|
||||
}
|
||||
if (lastPart == "csv") {
|
||||
formatParser = dojo.data.format.Csv;
|
||||
}
|
||||
if (formatParser) {
|
||||
var fileContents = dojo.hostenv.getText(fileUrl);
|
||||
formatParser.loadDataProviderFromFileContents(this, fileContents);
|
||||
} else {
|
||||
dojo.lang.assert(false, "new dojo.data.provider.FlatFile({url: }) was passed a file without a .csv or .json suffix");
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
dojo.inherits(dojo.data.provider.FlatFile, dojo.data.provider.Base);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Public instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.FlatFile.prototype.getProviderCapabilities = function(/* string */ keyword) {
|
||||
dojo.lang.assertType(keyword, [String, "optional"]);
|
||||
if (!this._ourCapabilities) {
|
||||
this._ourCapabilities = {
|
||||
transactions: false,
|
||||
undo: false,
|
||||
login: false,
|
||||
versioning: false,
|
||||
anonymousRead: true,
|
||||
anonymousWrite: false,
|
||||
permissions: false,
|
||||
queries: false,
|
||||
strongTyping: false,
|
||||
datatypes: [String, Date, Number]
|
||||
};
|
||||
}
|
||||
if (keyword) {
|
||||
return this._ourCapabilities[keyword];
|
||||
} else {
|
||||
return this._ourCapabilities;
|
||||
}
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype.registerAttribute = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
var registeredAttribute = this.getAttribute(attributeId);
|
||||
if (!registeredAttribute) {
|
||||
var newAttribute = new dojo.data.Attribute(this, attributeId);
|
||||
this._dictionaryOfAttributes[attributeId] = newAttribute;
|
||||
registeredAttribute = newAttribute;
|
||||
}
|
||||
return registeredAttribute; // dojo.data.Attribute
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype.getAttribute = function(/* string or dojo.data.Attribute */ attributeId) {
|
||||
var attribute = (this._dictionaryOfAttributes[attributeId] || null);
|
||||
return attribute; // dojo.data.Attribute or null
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype.getAttributes = function() {
|
||||
var arrayOfAttributes = [];
|
||||
for (var key in this._dictionaryOfAttributes) {
|
||||
var attribute = this._dictionaryOfAttributes[key];
|
||||
arrayOfAttributes.push(attribute);
|
||||
}
|
||||
return arrayOfAttributes; // Array
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype.fetchArray = function(query) {
|
||||
/**
|
||||
* summary: Returns an Array containing all of the Items.
|
||||
*/
|
||||
return this._arrayOfItems; // Array
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype.fetchResultSet = function(query) {
|
||||
/**
|
||||
* summary: Returns a ResultSet containing all of the Items.
|
||||
*/
|
||||
if (!this._resultSet) {
|
||||
this._resultSet = new dojo.data.ResultSet(this, this.fetchArray(query));
|
||||
}
|
||||
return this._resultSet; // dojo.data.ResultSet
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Private instance methods
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.FlatFile.prototype._newItem = function() {
|
||||
var item = new dojo.data.Item(this);
|
||||
this._arrayOfItems.push(item);
|
||||
return item; // dojo.data.Item
|
||||
};
|
||||
|
||||
dojo.data.provider.FlatFile.prototype._newAttribute = function(/* String */ attributeId) {
|
||||
dojo.lang.assertType(attributeId, String);
|
||||
dojo.lang.assert(this.getAttribute(attributeId) === null);
|
||||
var attribute = new dojo.data.Attribute(this, attributeId);
|
||||
this._dictionaryOfAttributes[attributeId] = attribute;
|
||||
return attribute; // dojo.data.Attribute
|
||||
};
|
||||
|
||||
dojo.data.provider.Base.prototype._getResultSets = function() {
|
||||
return [this._resultSet]; // Array
|
||||
};
|
||||
|
||||
27
webapp/web/src/data/provider/JotSpot.js
Normal file
27
webapp/web/src/data/provider/JotSpot.js
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.provider.JotSpot");
|
||||
dojo.require("dojo.data.provider.Base");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.JotSpot = function() {
|
||||
/**
|
||||
* summary:
|
||||
* A JotSpot Data Provider knows how to read data from a JotSpot data
|
||||
* store and make the contents accessable as dojo.data.Items.
|
||||
*/
|
||||
dojo.unimplemented('dojo.data.provider.JotSpot');
|
||||
};
|
||||
|
||||
dojo.inherits(dojo.data.provider.JotSpot, dojo.data.provider.Base);
|
||||
|
||||
27
webapp/web/src/data/provider/MySql.js
Normal file
27
webapp/web/src/data/provider/MySql.js
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.data.provider.MySql");
|
||||
dojo.require("dojo.data.provider.Base");
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------
|
||||
dojo.data.provider.MySql = function() {
|
||||
/**
|
||||
* summary:
|
||||
* A MySql Data Provider knows how to connect to a MySQL database
|
||||
* on a server and and make the content records available as
|
||||
* dojo.data.Items.
|
||||
*/
|
||||
dojo.unimplemented('dojo.data.provider.MySql');
|
||||
};
|
||||
|
||||
dojo.inherits(dojo.data.provider.MySql, dojo.data.provider.Base);
|
||||
45
webapp/web/src/data/to_do.txt
Normal file
45
webapp/web/src/data/to_do.txt
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
Existing Features
|
||||
* can import data from .json or .csv format files
|
||||
* can import data from del.icio.us
|
||||
* can create and modify data programmatically
|
||||
* can bind data to dojo.widget.Chart
|
||||
* can bind data to dojo.widget.SortableTable
|
||||
* can bind one data set to multiple widgets
|
||||
* notifications: widgets are notified when data changes
|
||||
* notification available per-item or per-resultSet
|
||||
* can create ad-hoc attributes
|
||||
* attributes can be loosely-typed
|
||||
* attributes can have meta-data like type and display name
|
||||
* half-implemented support for sorting
|
||||
* half-implemented support for export to .json
|
||||
* API for getting data in simple arrays
|
||||
* API for getting ResultSets with iterators (precursor to support for something like the openrico.org live grid)
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
To-Do List
|
||||
* be able to import data from an html <table></table>
|
||||
* think about being able to import data from some type of XML
|
||||
* think about integration with dojo.undo.Manager
|
||||
* think more about how to represent the notion of different data types
|
||||
* think about what problems we'll run into when we have a MySQL data provider
|
||||
* in TableBindingHack, improve support for data types in the SortableTable binding
|
||||
* deal with ids (including MySQL multi-field keys)
|
||||
* add support for item-references: employeeItem.set('department', departmentItem);
|
||||
* deal with Attributes as instances of Items, not just subclasses of Items
|
||||
* unit tests for compare/sort code
|
||||
* unit tests for everything
|
||||
* implement item.toString('json') and item.toString('xml')
|
||||
* implement dataProvider.newItem({name: 'foo', age: 26})
|
||||
* deal better with transactions
|
||||
* add support for deleting items
|
||||
* don't send out multiple notifications to the same observer
|
||||
* deal with item versions
|
||||
* prototype a Yahoo data provider -- http://developer.yahoo.net/common/json.html
|
||||
* prototype a data provider that enforces strong typing
|
||||
* prototype a data provider that prevents ad-hoc attributes
|
||||
* prototype a data provider that enforces single-kind item
|
||||
* prototype a data provider that allows for login/authentication
|
||||
* have loosely typed result sets play nicely with widgets that expect strong typing
|
||||
* prototype an example of spreadsheet-style formulas or derivation rules
|
||||
* experiment with some sort of fetch() that returns only a subset of a data provider's items
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue