/branches/v5.0-ouadji/api/js/dojo/src/data/old/Type.js |
---|
New file |
0,0 → 1,19 |
/* |
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.old.Type"); |
dojo.require("dojo.data.old.Item"); |
dojo.data.old.Type = function (dataProvider) { |
dojo.data.old.Item.call(this, dataProvider); |
}; |
dojo.inherits(dojo.data.old.Type, dojo.data.old.Item); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/Attribute.js |
---|
New file |
0,0 → 1,35 |
/* |
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.old.Attribute"); |
dojo.require("dojo.data.old.Item"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.Attribute = function (dataProvider, attributeId) { |
dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional:true}); |
dojo.lang.assertType(attributeId, String); |
dojo.data.old.Item.call(this, dataProvider); |
this._attributeId = attributeId; |
}; |
dojo.inherits(dojo.data.old.Attribute, dojo.data.old.Item); |
dojo.data.old.Attribute.prototype.toString = function () { |
return this._attributeId; |
}; |
dojo.data.old.Attribute.prototype.getAttributeId = function () { |
return this._attributeId; |
}; |
dojo.data.old.Attribute.prototype.getType = function () { |
return this.get("type"); |
}; |
dojo.data.old.Attribute.prototype.setType = function (type) { |
this.set("type", type); |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/Observable.js |
---|
New file |
0,0 → 1,40 |
/* |
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.old.Observable"); |
dojo.require("dojo.lang.common"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.Observable = function () { |
}; |
dojo.data.old.Observable.prototype.addObserver = function (observer) { |
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.old.Observable.prototype.removeObserver = function (observer) { |
if (!this._arrayOfObservers) { |
return; |
} |
var index = dojo.lang.indexOf(this._arrayOfObservers, observer); |
if (index != -1) { |
this._arrayOfObservers.splice(index, 1); |
} |
}; |
dojo.data.old.Observable.prototype.getObservers = function () { |
return this._arrayOfObservers; |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/Kind.js |
---|
New file |
0,0 → 1,19 |
/* |
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.old.Kind"); |
dojo.require("dojo.data.old.Item"); |
dojo.data.old.Kind = function (dataProvider) { |
dojo.data.old.Item.call(this, dataProvider); |
}; |
dojo.inherits(dojo.data.old.Kind, dojo.data.old.Item); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/__package__.js |
---|
New file |
0,0 → 1,17 |
/* |
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.old.*"); |
dojo.kwCompoundRequire({common:["dojo.data.old.Item", "dojo.data.old.ResultSet", "dojo.data.old.provider.FlatFile"]}); |
dojo.provide("dojo.data.old.*"); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/to_do.txt |
---|
New 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 |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/ResultSet.js |
---|
New file |
0,0 → 1,52 |
/* |
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.old.ResultSet"); |
dojo.require("dojo.lang.assert"); |
dojo.require("dojo.collections.Collections"); |
dojo.data.old.ResultSet = function (dataProvider, arrayOfItems) { |
dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional:true}); |
dojo.lang.assertType(arrayOfItems, Array, {optional:true}); |
dojo.data.old.Observable.call(this); |
this._dataProvider = dataProvider; |
this._arrayOfItems = []; |
if (arrayOfItems) { |
this._arrayOfItems = arrayOfItems; |
} |
}; |
dojo.inherits(dojo.data.old.ResultSet, dojo.data.old.Observable); |
dojo.data.old.ResultSet.prototype.toString = function () { |
var returnString = this._arrayOfItems.join(", "); |
return returnString; |
}; |
dojo.data.old.ResultSet.prototype.toArray = function () { |
return this._arrayOfItems; |
}; |
dojo.data.old.ResultSet.prototype.getIterator = function () { |
return new dojo.collections.Iterator(this._arrayOfItems); |
}; |
dojo.data.old.ResultSet.prototype.getLength = function () { |
return this._arrayOfItems.length; |
}; |
dojo.data.old.ResultSet.prototype.getItemAt = function (index) { |
return this._arrayOfItems[index]; |
}; |
dojo.data.old.ResultSet.prototype.indexOf = function (item) { |
return dojo.lang.indexOf(this._arrayOfItems, item); |
}; |
dojo.data.old.ResultSet.prototype.contains = function (item) { |
return dojo.lang.inArray(this._arrayOfItems, item); |
}; |
dojo.data.old.ResultSet.prototype.getDataProvider = function () { |
return this._dataProvider; |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/Value.js |
---|
New file |
0,0 → 1,35 |
/* |
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.old.Value"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.Value = function (value) { |
this._value = value; |
this._type = null; |
}; |
dojo.data.old.Value.prototype.toString = function () { |
return this._value.toString(); |
}; |
dojo.data.old.Value.prototype.getValue = function () { |
return this._value; |
}; |
dojo.data.old.Value.prototype.getType = function () { |
dojo.unimplemented("dojo.data.old.Value.prototype.getType"); |
return this._type; |
}; |
dojo.data.old.Value.prototype.compare = function () { |
dojo.unimplemented("dojo.data.old.Value.prototype.compare"); |
}; |
dojo.data.old.Value.prototype.isEqual = function () { |
dojo.unimplemented("dojo.data.old.Value.prototype.isEqual"); |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/format/Json.js |
---|
New file |
0,0 → 1,71 |
/* |
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.old.format.Json"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.format.Json = new function () { |
this.loadDataProviderFromFileContents = function (dataProvider, jsonFileContents) { |
dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base); |
dojo.lang.assertType(jsonFileContents, String); |
var arrayOfJsonData = eval("(" + jsonFileContents + ")"); |
this.loadDataProviderFromArrayOfJsonData(dataProvider, arrayOfJsonData); |
}; |
this.loadDataProviderFromArrayOfJsonData = function (dataProvider, arrayOfJsonData) { |
dojo.lang.assertType(arrayOfJsonData, Array, {optional:true}); |
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 (resultSet) { |
dojo.unimplemented("dojo.data.old.format.Json.getJsonStringFromResultSet"); |
var jsonString = null; |
return jsonString; |
}; |
function _loadDataProviderFromArrayOfArrays(dataProvider, arrayOfJsonData) { |
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(dataProvider, arrayOfJsonData) { |
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); |
} |
} else { |
item.load(key, value); |
} |
} |
} |
} |
}(); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/format/Csv.js |
---|
New file |
0,0 → 1,81 |
/* |
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.old.format.Csv"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.format.Csv = new function () { |
this.getArrayStructureFromCsvFileContents = function (csvFileContents) { |
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, ""); |
var field = field_space.replace(trailingWhiteSpaceCharacters, ""); |
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) { |
return null; |
} |
var nextField = listOfFields[j + 1]; |
listOfFields[j] = field_space + "," + nextField; |
listOfFields.splice(j + 1, 1); |
} else { |
if ((firstChar == "\"") && (lastChar == "\"")) { |
field = field.slice(1, (field.length - 1)); |
field = field.replace(doubleQuotes, "\""); |
} |
listOfFields[j] = field; |
j += 1; |
} |
} |
arrayOfOutputRecords.push(listOfFields); |
} |
} |
return arrayOfOutputRecords; |
}; |
this.loadDataProviderFromFileContents = function (dataProvider, csvFileContents) { |
dojo.lang.assertType(dataProvider, dojo.data.old.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 (resultSet) { |
dojo.unimplemented("dojo.data.old.format.Csv.getCsvStringFromResultSet"); |
var csvString = null; |
return csvString; |
}; |
}(); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/Item.js |
---|
New file |
0,0 → 1,223 |
/* |
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.old.Item"); |
dojo.require("dojo.data.old.Observable"); |
dojo.require("dojo.data.old.Value"); |
dojo.require("dojo.lang.common"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.Item = function (dataProvider) { |
dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional:true}); |
dojo.data.old.Observable.call(this); |
this._dataProvider = dataProvider; |
this._dictionaryOfAttributeValues = {}; |
}; |
dojo.inherits(dojo.data.old.Item, dojo.data.old.Observable); |
dojo.data.old.Item.compare = function (itemOne, itemTwo) { |
dojo.lang.assertType(itemOne, dojo.data.old.Item); |
if (!dojo.lang.isOfType(itemTwo, dojo.data.old.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; |
} |
} |
}; |
dojo.data.old.Item.prototype.toString = function () { |
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; |
}; |
dojo.data.old.Item.prototype.compare = function (otherItem) { |
return dojo.data.old.Item.compare(this, otherItem); |
}; |
dojo.data.old.Item.prototype.isEqual = function (otherItem) { |
return (this.compare(otherItem) == 0); |
}; |
dojo.data.old.Item.prototype.getName = function () { |
return this.get("name"); |
}; |
dojo.data.old.Item.prototype.get = function (attributeId) { |
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId]; |
if (dojo.lang.isUndefined(literalOrValueOrArray)) { |
return null; |
} |
if (literalOrValueOrArray instanceof dojo.data.old.Value) { |
return literalOrValueOrArray.getValue(); |
} |
if (dojo.lang.isArray(literalOrValueOrArray)) { |
var dojoDataValue = literalOrValueOrArray[0]; |
return dojoDataValue.getValue(); |
} |
return literalOrValueOrArray; |
}; |
dojo.data.old.Item.prototype.getValue = function (attributeId) { |
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId]; |
if (dojo.lang.isUndefined(literalOrValueOrArray)) { |
return null; |
} |
if (literalOrValueOrArray instanceof dojo.data.old.Value) { |
return literalOrValueOrArray; |
} |
if (dojo.lang.isArray(literalOrValueOrArray)) { |
var dojoDataValue = literalOrValueOrArray[0]; |
return dojoDataValue; |
} |
var literal = literalOrValueOrArray; |
dojoDataValue = new dojo.data.old.Value(literal); |
this._dictionaryOfAttributeValues[attributeId] = dojoDataValue; |
return dojoDataValue; |
}; |
dojo.data.old.Item.prototype.getValues = function (attributeId) { |
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId]; |
if (dojo.lang.isUndefined(literalOrValueOrArray)) { |
return null; |
} |
if (literalOrValueOrArray instanceof dojo.data.old.Value) { |
var array = [literalOrValueOrArray]; |
this._dictionaryOfAttributeValues[attributeId] = array; |
return array; |
} |
if (dojo.lang.isArray(literalOrValueOrArray)) { |
return literalOrValueOrArray; |
} |
var literal = literalOrValueOrArray; |
var dojoDataValue = new dojo.data.old.Value(literal); |
array = [dojoDataValue]; |
this._dictionaryOfAttributeValues[attributeId] = array; |
return array; |
}; |
dojo.data.old.Item.prototype.load = function (attributeId, value) { |
this._dataProvider.registerAttribute(attributeId); |
var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId]; |
if (dojo.lang.isUndefined(literalOrValueOrArray)) { |
this._dictionaryOfAttributeValues[attributeId] = value; |
return; |
} |
if (!(value instanceof dojo.data.old.Value)) { |
value = new dojo.data.old.Value(value); |
} |
if (literalOrValueOrArray instanceof dojo.data.old.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.old.Value(literal); |
array = [dojoDataValue, value]; |
this._dictionaryOfAttributeValues[attributeId] = array; |
}; |
dojo.data.old.Item.prototype.set = function (attributeId, value) { |
this._dataProvider.registerAttribute(attributeId); |
this._dictionaryOfAttributeValues[attributeId] = value; |
this._dataProvider.noteChange(this, attributeId, value); |
}; |
dojo.data.old.Item.prototype.setValue = function (attributeId, value) { |
this.set(attributeId, value); |
}; |
dojo.data.old.Item.prototype.addValue = function (attributeId, value) { |
this.load(attributeId, value); |
this._dataProvider.noteChange(this, attributeId, value); |
}; |
dojo.data.old.Item.prototype.setValues = function (attributeId, arrayOfValues) { |
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.old.Value)) { |
value = new dojo.data.old.Value(value); |
} |
finalArray.push(value); |
this._dataProvider.noteChange(this, attributeId, value); |
} |
}; |
dojo.data.old.Item.prototype.getAttributes = function () { |
var arrayOfAttributes = []; |
for (var key in this._dictionaryOfAttributeValues) { |
arrayOfAttributes.push(this._dataProvider.getAttribute(key)); |
} |
return arrayOfAttributes; |
}; |
dojo.data.old.Item.prototype.hasAttribute = function (attributeId) { |
return (attributeId in this._dictionaryOfAttributeValues); |
}; |
dojo.data.old.Item.prototype.hasAttributeValue = function (attributeId, value) { |
var arrayOfValues = this.getValues(attributeId); |
for (var i in arrayOfValues) { |
var candidateValue = arrayOfValues[i]; |
if (candidateValue.isEqual(value)) { |
return true; |
} |
} |
return false; |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/provider/JotSpot.js |
---|
New file |
0,0 → 1,19 |
/* |
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.old.provider.JotSpot"); |
dojo.require("dojo.data.old.provider.Base"); |
dojo.data.old.provider.JotSpot = function () { |
dojo.unimplemented("dojo.data.old.provider.JotSpot"); |
}; |
dojo.inherits(dojo.data.old.provider.JotSpot, dojo.data.old.provider.Base); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/provider/MySql.js |
---|
New file |
0,0 → 1,19 |
/* |
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.old.provider.MySql"); |
dojo.require("dojo.data.old.provider.Base"); |
dojo.data.old.provider.MySql = function () { |
dojo.unimplemented("dojo.data.old.provider.MySql"); |
}; |
dojo.inherits(dojo.data.old.provider.MySql, dojo.data.old.provider.Base); |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/provider/FlatFile.js |
---|
New file |
0,0 → 1,113 |
/* |
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.old.provider.FlatFile"); |
dojo.require("dojo.data.old.provider.Base"); |
dojo.require("dojo.data.old.Item"); |
dojo.require("dojo.data.old.Attribute"); |
dojo.require("dojo.data.old.ResultSet"); |
dojo.require("dojo.data.old.format.Json"); |
dojo.require("dojo.data.old.format.Csv"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.provider.FlatFile = function (keywordParameters) { |
dojo.lang.assertType(keywordParameters, "pureobject", {optional:true}); |
dojo.data.old.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.old.format.Json.loadDataProviderFromArrayOfJsonData(this, jsonObjects); |
} |
if (jsonString) { |
dojo.data.old.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.old.format.Json; |
} |
if (lastPart == "csv") { |
formatParser = dojo.data.old.format.Csv; |
} |
if (formatParser) { |
var fileContents = dojo.hostenv.getText(fileUrl); |
formatParser.loadDataProviderFromFileContents(this, fileContents); |
} else { |
dojo.lang.assert(false, "new dojo.data.old.provider.FlatFile({url: }) was passed a file without a .csv or .json suffix"); |
} |
} |
} |
}; |
dojo.inherits(dojo.data.old.provider.FlatFile, dojo.data.old.provider.Base); |
dojo.data.old.provider.FlatFile.prototype.getProviderCapabilities = function (keyword) { |
dojo.lang.assertType(keyword, String, {optional:true}); |
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.old.provider.FlatFile.prototype.registerAttribute = function (attributeId) { |
var registeredAttribute = this.getAttribute(attributeId); |
if (!registeredAttribute) { |
var newAttribute = new dojo.data.old.Attribute(this, attributeId); |
this._dictionaryOfAttributes[attributeId] = newAttribute; |
registeredAttribute = newAttribute; |
} |
return registeredAttribute; |
}; |
dojo.data.old.provider.FlatFile.prototype.getAttribute = function (attributeId) { |
var attribute = (this._dictionaryOfAttributes[attributeId] || null); |
return attribute; |
}; |
dojo.data.old.provider.FlatFile.prototype.getAttributes = function () { |
var arrayOfAttributes = []; |
for (var key in this._dictionaryOfAttributes) { |
var attribute = this._dictionaryOfAttributes[key]; |
arrayOfAttributes.push(attribute); |
} |
return arrayOfAttributes; |
}; |
dojo.data.old.provider.FlatFile.prototype.fetchArray = function (query) { |
return this._arrayOfItems; |
}; |
dojo.data.old.provider.FlatFile.prototype.fetchResultSet = function (query) { |
if (!this._resultSet) { |
this._resultSet = new dojo.data.old.ResultSet(this, this.fetchArray(query)); |
} |
return this._resultSet; |
}; |
dojo.data.old.provider.FlatFile.prototype._newItem = function () { |
var item = new dojo.data.old.Item(this); |
this._arrayOfItems.push(item); |
return item; |
}; |
dojo.data.old.provider.FlatFile.prototype._newAttribute = function (attributeId) { |
dojo.lang.assertType(attributeId, String); |
dojo.lang.assert(this.getAttribute(attributeId) === null); |
var attribute = new dojo.data.old.Attribute(this, attributeId); |
this._dictionaryOfAttributes[attributeId] = attribute; |
return attribute; |
}; |
dojo.data.old.provider.Base.prototype._getResultSets = function () { |
return [this._resultSet]; |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/provider/Base.js |
---|
New file |
0,0 → 1,124 |
/* |
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.old.provider.Base"); |
dojo.require("dojo.lang.assert"); |
dojo.data.old.provider.Base = function () { |
this._countOfNestedTransactions = 0; |
this._changesInCurrentTransaction = null; |
}; |
dojo.data.old.provider.Base.prototype.beginTransaction = function () { |
if (this._countOfNestedTransactions === 0) { |
this._changesInCurrentTransaction = []; |
} |
this._countOfNestedTransactions += 1; |
}; |
dojo.data.old.provider.Base.prototype.endTransaction = function () { |
this._countOfNestedTransactions -= 1; |
dojo.lang.assert(this._countOfNestedTransactions >= 0); |
if (this._countOfNestedTransactions === 0) { |
var listOfChangesMade = this._saveChanges(); |
this._changesInCurrentTransaction = null; |
if (listOfChangesMade.length > 0) { |
this._notifyObserversOfChanges(listOfChangesMade); |
} |
} |
}; |
dojo.data.old.provider.Base.prototype.getNewItemToLoad = function () { |
return this._newItem(); |
}; |
dojo.data.old.provider.Base.prototype.newItem = function (itemName) { |
dojo.lang.assertType(itemName, String, {optional:true}); |
var item = this._newItem(); |
if (itemName) { |
item.set("name", itemName); |
} |
return item; |
}; |
dojo.data.old.provider.Base.prototype.newAttribute = function (attributeId) { |
dojo.lang.assertType(attributeId, String, {optional:true}); |
var attribute = this._newAttribute(attributeId); |
return attribute; |
}; |
dojo.data.old.provider.Base.prototype.getAttribute = function (attributeId) { |
dojo.unimplemented("dojo.data.old.provider.Base"); |
var attribute; |
return attribute; |
}; |
dojo.data.old.provider.Base.prototype.getAttributes = function () { |
dojo.unimplemented("dojo.data.old.provider.Base"); |
return this._arrayOfAttributes; |
}; |
dojo.data.old.provider.Base.prototype.fetchArray = function () { |
dojo.unimplemented("dojo.data.old.provider.Base"); |
return []; |
}; |
dojo.data.old.provider.Base.prototype.fetchResultSet = function () { |
dojo.unimplemented("dojo.data.old.provider.Base"); |
var resultSet; |
return resultSet; |
}; |
dojo.data.old.provider.Base.prototype.noteChange = function (item, attribute, 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.old.provider.Base.prototype.addItemObserver = function (item, observer) { |
dojo.lang.assertType(item, dojo.data.old.Item); |
item.addObserver(observer); |
}; |
dojo.data.old.provider.Base.prototype.removeItemObserver = function (item, observer) { |
dojo.lang.assertType(item, dojo.data.old.Item); |
item.removeObserver(observer); |
}; |
dojo.data.old.provider.Base.prototype._newItem = function () { |
var item = new dojo.data.old.Item(this); |
return item; |
}; |
dojo.data.old.provider.Base.prototype._newAttribute = function (attributeId) { |
var attribute = new dojo.data.old.Attribute(this); |
return attribute; |
}; |
dojo.data.old.provider.Base.prototype._saveChanges = function () { |
var arrayOfChangesMade = this._changesInCurrentTransaction; |
return arrayOfChangesMade; |
}; |
dojo.data.old.provider.Base.prototype._notifyObserversOfChanges = function (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.old.provider.Base.prototype._getResultSets = function () { |
dojo.unimplemented("dojo.data.old.provider.Base"); |
return []; |
}; |
/branches/v5.0-ouadji/api/js/dojo/src/data/old/provider/Delicious.js |
---|
New file |
0,0 → 1,33 |
/* |
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.old.provider.Delicious"); |
dojo.require("dojo.data.old.provider.FlatFile"); |
dojo.require("dojo.data.old.format.Json"); |
dojo.data.old.provider.Delicious = function () { |
dojo.data.old.provider.FlatFile.call(this); |
if (Delicious && Delicious.posts) { |
dojo.data.old.format.Json.loadDataProviderFromArrayOfJsonData(this, Delicious.posts); |
} else { |
} |
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.old.provider.Delicious, dojo.data.old.provider.FlatFile); |
/branches/v5.0-ouadji/api/js/dojo/src/data/OpmlStore.js |
---|
New file |
0,0 → 1,166 |
/* |
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.OpmlStore"); |
dojo.require("dojo.data.core.Read"); |
dojo.require("dojo.data.core.Result"); |
dojo.require("dojo.lang.assert"); |
dojo.require("dojo.json"); |
dojo.require("dojo.experimental"); |
dojo.experimental("dojo.data.OpmlStore"); |
dojo.declare("dojo.data.OpmlStore", dojo.data.core.Read, {initializer:function (keywordParameters) { |
this._arrayOfTopLevelItems = []; |
this._metadataNodes = null; |
this._loadFinished = false; |
this._opmlFileUrl = keywordParameters["url"]; |
}, _assertIsItem:function (item) { |
if (!this.isItem(item)) { |
throw new Error("dojo.data.OpmlStore: a function was passed an item argument that was not an item"); |
} |
}, _removeChildNodesThatAreNotElementNodes:function (node, recursive) { |
var childNodes = node.childNodes; |
if (childNodes.length == 0) { |
return; |
} |
var nodesToRemove = []; |
var i, childNode; |
for (i = 0; i < childNodes.length; ++i) { |
childNode = childNodes[i]; |
if (childNode.nodeType != Node.ELEMENT_NODE) { |
nodesToRemove.push(childNode); |
} |
} |
for (i = 0; i < nodesToRemove.length; ++i) { |
childNode = nodesToRemove[i]; |
node.removeChild(childNode); |
} |
if (recursive) { |
for (i = 0; i < childNodes.length; ++i) { |
childNode = childNodes[i]; |
this._removeChildNodesThatAreNotElementNodes(childNode, recursive); |
} |
} |
}, _processRawXmlTree:function (rawXmlTree) { |
var headNodes = rawXmlTree.getElementsByTagName("head"); |
var headNode = headNodes[0]; |
this._removeChildNodesThatAreNotElementNodes(headNode); |
this._metadataNodes = headNode.childNodes; |
var bodyNodes = rawXmlTree.getElementsByTagName("body"); |
var bodyNode = bodyNodes[0]; |
this._removeChildNodesThatAreNotElementNodes(bodyNode, true); |
var bodyChildNodes = bodyNodes[0].childNodes; |
for (var i = 0; i < bodyChildNodes.length; ++i) { |
var node = bodyChildNodes[i]; |
if (node.tagName == "outline") { |
this._arrayOfTopLevelItems.push(node); |
} |
} |
}, get:function (item, attribute, defaultValue) { |
this._assertIsItem(item); |
if (attribute == "children") { |
return (item.firstChild || defaultValue); |
} else { |
var value = item.getAttribute(attribute); |
value = (value != undefined) ? value : defaultValue; |
return value; |
} |
}, getValues:function (item, attribute) { |
this._assertIsItem(item); |
if (attribute == "children") { |
var array = []; |
for (var i = 0; i < item.childNodes.length; ++i) { |
array.push(item.childNodes[i]); |
} |
return array; |
} else { |
return [item.getAttribute(attribute)]; |
} |
}, getAttributes:function (item) { |
this._assertIsItem(item); |
var attributes = []; |
var xmlNode = item; |
var xmlAttributes = xmlNode.attributes; |
for (var i = 0; i < xmlAttributes.length; ++i) { |
var xmlAttribute = xmlAttributes.item(i); |
attributes.push(xmlAttribute.nodeName); |
} |
if (xmlNode.childNodes.length > 0) { |
attributes.push("children"); |
} |
return attributes; |
}, hasAttribute:function (item, attribute) { |
return (this.getValues(item, attribute).length > 0); |
}, containsValue:function (item, attribute, value) { |
var values = this.getValues(item, attribute); |
for (var i = 0; i < values.length; ++i) { |
var possibleValue = values[i]; |
if (value == possibleValue) { |
return true; |
} |
} |
return false; |
}, isItem:function (something) { |
return (something && something.nodeType == Node.ELEMENT_NODE && something.tagName == "outline"); |
}, isItemAvailable:function (something) { |
return this.isItem(something); |
}, find:function (keywordArgs) { |
var result = null; |
if (keywordArgs instanceof dojo.data.core.Result) { |
result = keywordArgs; |
result.store = this; |
} else { |
result = new dojo.data.core.Result(keywordArgs, this); |
} |
var self = this; |
var bindHandler = function (type, data, evt) { |
var scope = result.scope || dj_global; |
if (type == "load") { |
self._processRawXmlTree(data); |
if (result.saveResult) { |
result.items = self._arrayOfTopLevelItems; |
} |
if (result.onbegin) { |
result.onbegin.call(scope, result); |
} |
for (var i = 0; i < self._arrayOfTopLevelItems.length; i++) { |
var item = self._arrayOfTopLevelItems[i]; |
if (result.onnext && !result._aborted) { |
result.onnext.call(scope, item, result); |
} |
} |
if (result.oncompleted && !result._aborted) { |
result.oncompleted.call(scope, result); |
} |
} else { |
if (type == "error" || type == "timeout") { |
var errorObject = data; |
if (result.onerror) { |
result.onerror.call(scope, data); |
} |
} |
} |
}; |
if (!this._loadFinished) { |
if (this._opmlFileUrl) { |
var bindRequest = dojo.io.bind({url:this._opmlFileUrl, handle:bindHandler, mimetype:"text/xml", sync:(result.sync || false)}); |
result._abortFunc = bindRequest.abort; |
} |
} |
return result; |
}, getIdentity:function (item) { |
dojo.unimplemented("dojo.data.OpmlStore.getIdentity()"); |
return null; |
}, findByIdentity:function (identity) { |
dojo.unimplemented("dojo.data.OpmlStore.findByIdentity()"); |
return null; |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/CsvStore.js |
---|
New file |
0,0 → 1,115 |
/* |
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.CsvStore"); |
dojo.require("dojo.data.core.RemoteStore"); |
dojo.require("dojo.lang.assert"); |
dojo.declare("dojo.data.CsvStore", dojo.data.core.RemoteStore, {_setupQueryRequest:function (result, requestKw) { |
var serverQueryUrl = this._serverQueryUrl ? this._serverQueryUrl : ""; |
var queryUrl = result.query ? result.query : ""; |
requestKw.url = serverQueryUrl + queryUrl; |
requestKw.method = "get"; |
}, _resultToQueryData:function (serverResponseData) { |
var csvFileContentString = serverResponseData; |
var arrayOfArrays = this._getArrayOfArraysFromCsvFileContents(csvFileContentString); |
var arrayOfObjects = this._getArrayOfObjectsFromArrayOfArrays(arrayOfArrays); |
var remoteStoreData = this._getRemoteStoreDataFromArrayOfObjects(arrayOfObjects); |
return remoteStoreData; |
}, _setupSaveRequest:function (saveKeywordArgs, requestKw) { |
}, _getArrayOfArraysFromCsvFileContents:function (csvFileContents) { |
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, ""); |
var field = field_space.replace(trailingWhiteSpaceCharacters, ""); |
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) { |
return null; |
} |
var nextField = listOfFields[j + 1]; |
listOfFields[j] = field_space + "," + nextField; |
listOfFields.splice(j + 1, 1); |
} else { |
if ((firstChar == "\"") && (lastChar == "\"")) { |
field = field.slice(1, (field.length - 1)); |
field = field.replace(doubleQuotes, "\""); |
} |
listOfFields[j] = field; |
j += 1; |
} |
} |
arrayOfOutputRecords.push(listOfFields); |
} |
} |
return arrayOfOutputRecords; |
}, _getArrayOfObjectsFromArrayOfArrays:function (arrayOfArrays) { |
dojo.lang.assertType(arrayOfArrays, Array); |
var arrayOfItems = []; |
if (arrayOfArrays.length > 1) { |
var arrayOfKeys = arrayOfArrays[0]; |
for (var i = 1; i < arrayOfArrays.length; ++i) { |
var row = arrayOfArrays[i]; |
var item = {}; |
for (var j in row) { |
var value = row[j]; |
var key = arrayOfKeys[j]; |
item[key] = value; |
} |
arrayOfItems.push(item); |
} |
} |
return arrayOfItems; |
}, _getRemoteStoreDataFromArrayOfObjects:function (arrayOfObjects) { |
dojo.lang.assertType(arrayOfObjects, Array); |
var output = {}; |
for (var i = 0; i < arrayOfObjects.length; ++i) { |
var object = arrayOfObjects[i]; |
for (var key in object) { |
var value = object[key]; |
object[key] = [value]; |
} |
output[i] = object; |
} |
return output; |
}, newItem:function (attributes, keywordArgs) { |
dojo.unimplemented("dojo.data.CsvStore.newItem"); |
}, deleteItem:function (item) { |
dojo.unimplemented("dojo.data.CsvStore.deleteItem"); |
}, setValues:function (item, attribute, values) { |
dojo.unimplemented("dojo.data.CsvStore.setValues"); |
}, set:function (item, attribute, value) { |
dojo.unimplemented("dojo.data.CsvStore.set"); |
}, unsetAttribute:function (item, attribute) { |
dojo.unimplemented("dojo.data.CsvStore.unsetAttribute"); |
}, save:function (keywordArgs) { |
dojo.unimplemented("dojo.data.CsvStore.save"); |
}, revert:function () { |
dojo.unimplemented("dojo.data.CsvStore.revert"); |
}, isDirty:function (item) { |
dojo.unimplemented("dojo.data.CsvStore.isDirty"); |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/RdfStore.js |
---|
New file |
0,0 → 1,185 |
/* |
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.RdfStore"); |
dojo.provide("dojo.data.RhizomeStore"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.data.core.RemoteStore"); |
dojo.require("dojo.experimental"); |
dojo.data.RdfDatatypeSerializer = function (type, convertFunc, uri) { |
this.type = type; |
this._converter = convertFunc; |
this.uri = uri; |
this.serialize = function (value) { |
return this._converter.call(value, value); |
}; |
}; |
dojo.declare("dojo.data.RdfStore", dojo.data.core.RemoteStore, {_datatypeMap:{literal:function (value) { |
var literal = value.value; |
if (value["xml:lang"]) { |
literal.lang = value["xml:lang"]; |
} |
return literal; |
}, uri:function (value) { |
return {id:value.value}; |
}, bnode:function (value) { |
return {id:"_:" + value.value}; |
}, "http://www.w3.org/2001/XMLSchema#int":function (value) { |
return parseInt(value.value); |
}, "http://www.w3.org/2001/XMLSchema#integer":function (value) { |
return parseInt(value.value); |
}, "http://www.w3.org/2001/XMLSchema#long":function (value) { |
return parseInt(value.value); |
}, "http://www.w3.org/2001/XMLSchema#float":function (value) { |
return parseFloat(value.value); |
}, "http://www.w3.org/2001/XMLSchema#double":function (value) { |
return parseFloat(value.value); |
}, "http://www.w3.org/2001/XMLSchema#boolean":function (value) { |
return !value || value == "false" || value == "0" ? false : true; |
}}, _datatypeSerializers:[new dojo.data.RdfDatatypeSerializer(Number, Number.toString, "http://www.w3.org/2001/XMLSchema#float"), new dojo.data.RdfDatatypeSerializer(Boolean, Boolean.toString, "http://www.w3.org/2001/XMLSchema#boolean")], _findDatatypeSerializer:function (value) { |
var length = this._datatypeSerializers.length; |
for (var i = 0; i < length; i++) { |
var datatype = this._datatypeSerializers[i]; |
if (value instanceof datatype.type) { |
return datatype; |
} |
} |
}, _toRDFValue:function (value) { |
var rdfvalue = {}; |
if (value.id) { |
if (value.id.slice(0, 2) == "_:") { |
rdfvalue.type = "bnode"; |
rdfvalue.value = value.id.substring(2); |
} else { |
rdfvalue.type = "uri"; |
rdfvalue.value = value.id; |
} |
} else { |
if (typeof value == "string" || value instanceof String) { |
rdfvalue.type = "literal"; |
rdfvalue.value = value; |
if (value.lang) { |
rdfvalue["xml:lang"] = value.lang; |
} |
} else { |
if (typeof value == "number") { |
value = new Number(value); |
} else { |
if (typeof value == "boolean") { |
value = new Boolean(value); |
} |
} |
var datatype = this._findDatatypeSerializer(value); |
if (datatype) { |
rdfvalue = {"type":"typed-literal", "datatype":datatype.uri, "value":value.toString()}; |
} else { |
rdfvalue = {"type":"literal", "value":value.toString()}; |
} |
} |
} |
return rdfvalue; |
}, _setupSaveRequest:function (saveKeywordArgs, requestKw) { |
var rdfResult = {"head":{"vars":["s", "p", "o"]}, "results":{"bindings":[]}}; |
var resources = []; |
for (var key in this._deleted) { |
resources.push(key); |
} |
rdfResult.results.deleted = resources; |
for (key in this._changed) { |
var subject = this._toRDFValue(this.getIdentity(key)); |
var attributes = this._changed[key]; |
for (var attr in attributes) { |
var predicate = {type:"uri", value:attr}; |
var values = attributes[attr]; |
if (!values.length) { |
continue; |
} |
var rdfvalues = []; |
for (var i = 0; i < values.length; i++) { |
var rdfvalue = this._toRDFValue(values[i]); |
rdfResult.results.bindings.push({s:subject, p:predicate, o:rdfvalue}); |
} |
} |
} |
var oldRegistry = dojo.json.jsonRegistry; |
dojo.json.jsonRegistry = this._jsonRegistry; |
var jsonString = dojo.json.serialize(rdfResult); |
dojo.json.jsonRegistry = oldRegistry; |
requestKw.postContent = jsonString; |
}, _resultToQueryMetadata:function (json) { |
return json.head; |
}, _resultToQueryData:function (json) { |
var items = {}; |
var stmts = json.results.bindings; |
for (var i = 0; i < stmts.length; i++) { |
var stmt = stmts[i]; |
var subject = stmt.s.value; |
if (stmt.s.type == "bnode") { |
subject = "_:" + subject; |
} |
var attributes = data[subject]; |
if (!attributes) { |
attributes = {}; |
data[stmt.s] = attributes; |
} |
var attr = attributes[stmt.p.value]; |
if (!attr) { |
attributes[stmt.p.value] = [stmt.o]; |
} else { |
attr.push(stmt.o); |
} |
} |
return items; |
}}); |
dojo.declare("dojo.data.RhizomeStore", dojo.data.RdfStore, {initializer:function (kwArgs) { |
this._serverQueryUrl = kwArgs.baseUrl + "search?view=json&searchType=RxPath&search="; |
this._serverSaveUrl = kwArgs.baseUrl + "save-metadata"; |
}, _resultToQueryMetadata:function (json) { |
return json; |
}, _resultToQueryData:function (json) { |
return json; |
}, _setupSaveRequest:function (saveKeywordArgs, requestKw) { |
requestKw.url = this._serverSaveUrl; |
requestKw.method = "post"; |
requestKw.mimetype = "text/plain"; |
var resources = []; |
for (var key in this._deleted) { |
resources.push(key); |
} |
var changes = {}; |
for (key in this._changed) { |
if (!this._added[key]) { |
resources.push(key); |
} |
var attributes = this._changed[key]; |
var rdfattributes = {}; |
for (var attr in attributes) { |
var values = attributes[attr]; |
if (!values.length) { |
continue; |
} |
var rdfvalues = []; |
for (var i = 0; i < values.length; i++) { |
var rdfvalue = this._toRDFValue(values[i]); |
rdfvalues.push(rdfvalue); |
} |
rdfattributes[attr] = rdfvalues; |
} |
changes[key] = rdfattributes; |
} |
var oldRegistry = dojo.json.jsonRegistry; |
dojo.json.jsonRegistry = this._jsonRegistry; |
var jsonString = dojo.json.serialize(changes); |
dojo.json.jsonRegistry = oldRegistry; |
requestKw.content = {rdfFormat:"json", resource:resources, metadata:jsonString}; |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/YahooStore.js |
---|
New file |
0,0 → 1,44 |
/* |
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.YahooStore"); |
dojo.require("dojo.data.core.RemoteStore"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.io.ScriptSrcIO"); |
dojo.declare("dojo.data.YahooStore", dojo.data.core.RemoteStore, {_setupQueryRequest:function (result, requestKw) { |
var start = 1; |
var count = 1; |
if (result) { |
start = result.start || start; |
count = result.count || count; |
} |
var sourceUrl = "http://api.search.yahoo.com/WebSearchService/V1/webSearch?appid=dojo&language=en&query=" + result.query + "&start=" + start + "&results=" + count + "&output=json"; |
requestKw.url = sourceUrl; |
requestKw.transport = "ScriptSrcTransport"; |
requestKw.mimetype = "text/json"; |
requestKw.jsonParamName = "callback"; |
}, _resultToQueryMetadata:function (json) { |
return json.ResultSet; |
}, _resultToQueryData:function (json) { |
var data = {}; |
for (var i = 0; i < json.ResultSet.totalResultsReturned; ++i) { |
var record = json.ResultSet.Result[i]; |
var item = {}; |
item["Url"] = [record.Url]; |
item["Title"] = [record.Title]; |
item["Summary"] = [record.Summary]; |
var arrayIndex = (json.ResultSet.firstResultPosition - 1) + i; |
data[arrayIndex.toString()] = item; |
} |
return data; |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/core/Write.js |
---|
New file |
0,0 → 1,44 |
/* |
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.core.Write"); |
dojo.require("dojo.data.core.Read"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.experimental"); |
dojo.experimental("dojo.data.core.Write"); |
dojo.declare("dojo.data.core.Write", dojo.data.core.Read, {newItem:function (keywordArgs) { |
var newItem; |
dojo.unimplemented("dojo.data.core.Write.newItem"); |
return newItem; |
}, deleteItem:function (item) { |
dojo.unimplemented("dojo.data.core.Write.deleteItem"); |
return false; |
}, set:function (item, attribute, value) { |
dojo.unimplemented("dojo.data.core.Write.set"); |
return false; |
}, setValues:function (item, attribute, values) { |
dojo.unimplemented("dojo.data.core.Write.setValues"); |
return false; |
}, unsetAttribute:function (item, attribute) { |
dojo.unimplemented("dojo.data.core.Write.clear"); |
return false; |
}, save:function () { |
dojo.unimplemented("dojo.data.core.Write.save"); |
return false; |
}, revert:function () { |
dojo.unimplemented("dojo.data.core.Write.revert"); |
return false; |
}, isDirty:function (item) { |
dojo.unimplemented("dojo.data.core.Write.isDirty"); |
return false; |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/core/Read.js |
---|
New 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.core.Read"); |
dojo.require("dojo.data.core.Result"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.experimental"); |
dojo.experimental("dojo.data.core.Read"); |
dojo.declare("dojo.data.core.Read", null, {get:function (item, attribute, defaultValue) { |
dojo.unimplemented("dojo.data.core.Read.get"); |
var attributeValue = null; |
return attributeValue; |
}, getValues:function (item, attribute) { |
dojo.unimplemented("dojo.data.core.Read.getValues"); |
var array = null; |
return array; |
}, getAttributes:function (item) { |
dojo.unimplemented("dojo.data.core.Read.getAttributes"); |
var array = null; |
return array; |
}, hasAttribute:function (item, attribute) { |
dojo.unimplemented("dojo.data.core.Read.hasAttribute"); |
return false; |
}, containsValue:function (item, attribute, value) { |
dojo.unimplemented("dojo.data.core.Read.containsValue"); |
return false; |
}, isItem:function (something) { |
dojo.unimplemented("dojo.data.core.Read.isItem"); |
return false; |
}, isItemAvailable:function (something) { |
dojo.unimplemented("dojo.data.core.Read.isItemAvailable"); |
return false; |
}, find:function (keywordArgs) { |
dojo.unimplemented("dojo.data.core.Read.find"); |
var result = null; |
return result; |
}, getIdentity:function (item) { |
dojo.unimplemented("dojo.data.core.Read.getIdentity"); |
var itemIdentifyString = null; |
return itemIdentifyString; |
}, findByIdentity:function (identity) { |
dojo.unimplemented("dojo.data.core.Read.getByIdentity"); |
var item = null; |
return item; |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/core/Result.js |
---|
New file |
0,0 → 1,36 |
/* |
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.core.Result"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.experimental"); |
dojo.experimental("dojo.data.core.Result"); |
dojo.declare("dojo.data.core.Result", null, {initializer:function (keywordArgs, store) { |
this.fromKwArgs(keywordArgs || {}); |
this.items = null; |
this.resultMetadata = null; |
this.length = -1; |
this.store = store; |
this._aborted = false; |
this._abortFunc = null; |
}, sync:true, abort:function () { |
this._aborted = true; |
if (this._abortFunc) { |
this._abortFunc(); |
} |
}, fromKwArgs:function (kwArgs) { |
if (typeof kwArgs.saveResult == "undefined") { |
this.saveResult = kwArgs.onnext ? false : true; |
} |
dojo.lang.mixin(this, kwArgs); |
}}); |
/branches/v5.0-ouadji/api/js/dojo/src/data/core/RemoteStore.js |
---|
New file |
0,0 → 1,354 |
/* |
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.core.RemoteStore"); |
dojo.require("dojo.data.core.Read"); |
dojo.require("dojo.data.core.Write"); |
dojo.require("dojo.data.core.Result"); |
dojo.require("dojo.experimental"); |
dojo.require("dojo.Deferred"); |
dojo.require("dojo.lang.declare"); |
dojo.require("dojo.json"); |
dojo.require("dojo.io.*"); |
dojo.experimental("dojo.data.core.RemoteStore"); |
dojo.lang.declare("dojo.data.core.RemoteStore", [dojo.data.core.Read, dojo.data.core.Write], {_datatypeMap:{}, _jsonRegistry:dojo.json.jsonRegistry, initializer:function (kwArgs) { |
if (!kwArgs) { |
kwArgs = {}; |
} |
this._serverQueryUrl = kwArgs.queryUrl || ""; |
this._serverSaveUrl = kwArgs.saveUrl || ""; |
this._deleted = {}; |
this._changed = {}; |
this._added = {}; |
this._results = {}; |
this._data = {}; |
this._numItems = 0; |
}, _setupQueryRequest:function (result, requestKw) { |
result.query = result.query || ""; |
requestKw.url = this._serverQueryUrl + encodeURIComponent(result.query); |
requestKw.method = "get"; |
requestKw.mimetype = "text/json"; |
}, _resultToQueryMetadata:function (serverResponseData) { |
return serverResponseData; |
}, _resultToQueryData:function (serverResponseData) { |
return serverResponseData.data; |
}, _remoteToLocalValues:function (attributes) { |
for (var key in attributes) { |
var values = attributes[key]; |
for (var i = 0; i < values.length; i++) { |
var value = values[i]; |
var type = value.datatype || value.type; |
if (type) { |
var localValue = value.value; |
if (this._datatypeMap[type]) { |
localValue = this._datatypeMap[type](value); |
} |
values[i] = localValue; |
} |
} |
} |
return attributes; |
}, _queryToQueryKey:function (query) { |
if (typeof query == "string") { |
return query; |
} else { |
return dojo.json.serialize(query); |
} |
}, _assertIsItem:function (item) { |
if (!this.isItem(item)) { |
throw new Error("dojo.data.RemoteStore: a function was passed an item argument that was not an item"); |
} |
}, get:function (item, attribute, defaultValue) { |
var valueArray = this.getValues(item, attribute); |
if (valueArray.length == 0) { |
return defaultValue; |
} |
return valueArray[0]; |
}, getValues:function (item, attribute) { |
var itemIdentity = this.getIdentity(item); |
this._assertIsItem(itemIdentity); |
var changes = this._changed[itemIdentity]; |
if (changes) { |
var newvalues = changes[attribute]; |
if (newvalues !== undefined) { |
return newvalues; |
} else { |
return []; |
} |
} |
return this._data[itemIdentity][0][attribute]; |
}, getAttributes:function (item) { |
var itemIdentity = this.getIdentity(item); |
if (!itemIdentity) { |
return undefined; |
} |
var atts = []; |
var attrDict = this._data[itemIdentity][0]; |
for (var att in attrDict) { |
atts.push(att); |
} |
return atts; |
}, hasAttribute:function (item, attribute) { |
var valueArray = this.getValues(item, attribute); |
return valueArray.length ? true : false; |
}, containsValue:function (item, attribute, value) { |
var valueArray = this.getValues(item, attribute); |
for (var i = 0; i < valueArray.length; i++) { |
if (valueArray[i] == value) { |
return true; |
} |
} |
return false; |
}, isItem:function (something) { |
if (!something) { |
return false; |
} |
var itemIdentity = something; |
if (this._deleted[itemIdentity]) { |
return false; |
} |
if (this._data[itemIdentity]) { |
return true; |
} |
if (this._added[itemIdentity]) { |
return true; |
} |
return false; |
}, find:function (keywordArgs) { |
var result = null; |
if (keywordArgs instanceof dojo.data.core.Result) { |
result = keywordArgs; |
result.store = this; |
} else { |
result = new dojo.data.core.Result(keywordArgs, this); |
} |
var query = result.query; |
var self = this; |
var bindfunc = function (type, data, evt) { |
var scope = result.scope || dj_global; |
if (type == "load") { |
result.resultMetadata = self._resultToQueryMetadata(data); |
var dataDict = self._resultToQueryData(data); |
if (result.onbegin) { |
result.onbegin.call(scope, result); |
} |
var count = 0; |
var resultData = []; |
var newItemCount = 0; |
for (var key in dataDict) { |
if (result._aborted) { |
break; |
} |
if (!self._deleted[key]) { |
var values = dataDict[key]; |
var attributeDict = self._remoteToLocalValues(values); |
var existingValue = self._data[key]; |
var refCount = 1; |
if (existingValue) { |
refCount = ++existingValue[1]; |
} else { |
newItemCount++; |
} |
self._data[key] = [attributeDict, refCount]; |
resultData.push(key); |
count++; |
if (result.onnext) { |
result.onnext.call(scope, key, result); |
} |
} |
} |
self._results[self._queryToQueryKey(query)] = resultData; |
self._numItems += newItemCount; |
result.length = count; |
if (result.saveResult) { |
result.items = resultData; |
} |
if (!result._aborted && result.oncompleted) { |
result.oncompleted.call(scope, result); |
} |
} else { |
if (type == "error" || type == "timeout") { |
dojo.debug("find error: " + dojo.json.serialize(data)); |
if (result.onerror) { |
result.onerror.call(scope, data); |
} |
} |
} |
}; |
var bindKw = keywordArgs.bindArgs || {}; |
bindKw.sync = result.sync; |
bindKw.handle = bindfunc; |
this._setupQueryRequest(result, bindKw); |
var request = dojo.io.bind(bindKw); |
result._abortFunc = request.abort; |
return result; |
}, getIdentity:function (item) { |
if (!this.isItem(item)) { |
return null; |
} |
return (item.id ? item.id : item); |
}, newItem:function (attributes, keywordArgs) { |
var itemIdentity = keywordArgs["identity"]; |
if (this._deleted[itemIdentity]) { |
delete this._deleted[itemIdentity]; |
} else { |
this._added[itemIdentity] = 1; |
} |
if (attributes) { |
for (var attribute in attributes) { |
var valueOrArrayOfValues = attributes[attribute]; |
if (dojo.lang.isArray(valueOrArrayOfValues)) { |
this.setValues(itemIdentity, attribute, valueOrArrayOfValues); |
} else { |
this.set(itemIdentity, attribute, valueOrArrayOfValues); |
} |
} |
} |
return {id:itemIdentity}; |
}, deleteItem:function (item) { |
var identity = this.getIdentity(item); |
if (!identity) { |
return false; |
} |
if (this._added[identity]) { |
delete this._added[identity]; |
} else { |
this._deleted[identity] = 1; |
} |
if (this._changed[identity]) { |
delete this._changed[identity]; |
} |
return true; |
}, setValues:function (item, attribute, values) { |
var identity = this.getIdentity(item); |
if (!identity) { |
return undefined; |
} |
var changes = this._changed[identity]; |
if (!changes) { |
changes = {}; |
this._changed[identity] = changes; |
} |
changes[attribute] = values; |
return true; |
}, set:function (item, attribute, value) { |
return this.setValues(item, attribute, [value]); |
}, unsetAttribute:function (item, attribute) { |
return this.setValues(item, attribute, []); |
}, _initChanges:function () { |
this._deleted = {}; |
this._changed = {}; |
this._added = {}; |
}, _setupSaveRequest:function (saveKeywordArgs, requestKw) { |
requestKw.url = this._serverSaveUrl; |
requestKw.method = "post"; |
requestKw.mimetype = "text/plain"; |
var deleted = []; |
for (var key in this._deleted) { |
deleted.push(key); |
} |
var saveStruct = {"changed":this._changed, "deleted":deleted}; |
var oldRegistry = dojo.json.jsonRegistry; |
dojo.json.jsonRegistry = this._jsonRegistry; |
var jsonString = dojo.json.serialize(saveStruct); |
dojo.json.jsonRegistry = oldRegistry; |
requestKw.postContent = jsonString; |
}, save:function (keywordArgs) { |
keywordArgs = keywordArgs || {}; |
var result = new dojo.Deferred(); |
var self = this; |
var bindfunc = function (type, data, evt) { |
if (type == "load") { |
if (result.fired == 1) { |
return; |
} |
var key = null; |
for (key in self._added) { |
if (!self._data[key]) { |
self._data[key] = [{}, 1]; |
} |
} |
for (key in self._changed) { |
var existing = self._data[key]; |
var changes = self._changed[key]; |
if (existing) { |
existing[0] = changes; |
} else { |
self._data[key] = [changes, 1]; |
} |
} |
for (key in self._deleted) { |
if (self._data[key]) { |
delete self._data[key]; |
} |
} |
self._initChanges(); |
result.callback(true); |
} else { |
if (type == "error" || type == "timeout") { |
result.errback(data); |
} |
} |
}; |
var bindKw = {sync:keywordArgs["sync"], handle:bindfunc}; |
this._setupSaveRequest(keywordArgs, bindKw); |
var request = dojo.io.bind(bindKw); |
result.canceller = function (deferred) { |
request.abort(); |
}; |
return result; |
}, revert:function () { |
this._initChanges(); |
return true; |
}, isDirty:function (item) { |
if (item) { |
var identity = item.id || item; |
return this._deleted[identity] || this._changed[identity]; |
} else { |
var key = null; |
for (key in this._changed) { |
return true; |
} |
for (key in this._deleted) { |
return true; |
} |
for (key in this._added) { |
return true; |
} |
return false; |
} |
}, createReference:function (idstring) { |
return {id:idstring}; |
}, getSize:function () { |
return this._numItems; |
}, forgetResults:function (query) { |
var queryKey = this._queryToQueryKey(query); |
var results = this._results[queryKey]; |
if (!results) { |
return false; |
} |
var removed = 0; |
for (var i = 0; i < results.length; i++) { |
var key = results[i]; |
var existingValue = this._data[key]; |
if (existingValue[1] <= 1) { |
delete this._data[key]; |
removed++; |
} else { |
existingValue[1] = --existingValue[1]; |
} |
} |
delete this._results[queryKey]; |
this._numItems -= removed; |
return true; |
}}); |