Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.data.CsvStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.data.CsvStore"] = true;

dojo.provide("dojox.data.CsvStore");

dojo.require("dojo.data.util.filter");

dojo.require("dojo.data.util.simpleFetch");

dojo.declare("dojox.data.CsvStore", null, {

	//	summary:

	//		The CsvStore implements the dojo.data.api.Read API and reads

	//		data from files in CSV (Comma Separated Values) format.

	//		All values are simple string values. References to other items

	//		are not supported as attribute values in this datastore.

	//

	//		Example data file:

	//		name, color, age, tagline

	//		Kermit, green, 12, "Hi, I'm Kermit the Frog."

	//		Fozzie Bear, orange, 10, "Wakka Wakka Wakka!"

	//		Miss Piggy, pink, 11, "Kermie!"

	//

	//		Note that values containing a comma must be enclosed with quotes ("")

	//		Also note that values containing quotes must be escaped with two consecutive quotes (""quoted"")

	/* examples:

	 *   var csvStore = new dojox.data.CsvStore({url:"movies.csv");

	 *   var csvStore = new dojox.data.CsvStore({url:"http://example.com/movies.csv");

	 */

	constructor: function(/* Object */ keywordParameters){

		// summary: initializer

		// keywordParameters: {url: String}

		// keywordParameters: {data: String}

		// keywordParameters: {label: String} The column label for the column to use for the label returned by getLabel.

		this._attributes = [];			// e.g. ["Title", "Year", "Producer"]

		this._attributeIndexes = {};	// e.g. {Title: 0, Year: 1, Producer: 2}

 		this._dataArray = [];			// e.g. [[<Item0>],[<Item1>],[<Item2>]]

 		this._arrayOfAllItems = [];		// e.g. [{_csvId:0,_csvStore:store},...]

		this._loadFinished = false;

		if(keywordParameters.url){

			this.url = keywordParameters.url;

		}

		this._csvData = keywordParameters.data;

		if(keywordParameters.label){

			this.label = keywordParameters.label;

		}else if(this.label === ""){

			this.label = undefined;

		}

		this._storeProp = "_csvStore";	// Property name for the store reference on every item.

		this._idProp = "_csvId"; 		// Property name for the Item Id on every item.

		this._features = {

			'dojo.data.api.Read': true,

			'dojo.data.api.Identity': true

		};

		this._loadInProgress = false;	//Got to track the initial load to prevent duelling loads of the dataset.

		this._queuedFetches = [];

	},

	url: "", //Declarative hook for setting Csv source url.

	label: "", //Declarative hook for setting the label attribute.

	_assertIsItem: function(/* item */ item){

		//	summary:

		//      This function tests whether the item passed in is indeed an item in the store.

		//	item:

		//		The item to test for being contained by the store.

		if(!this.isItem(item)){

			throw new Error("dojox.data.CsvStore: a function was passed an item argument that was not an item");

		}

	},

	_assertIsAttribute: function(/* item || String */ attribute){

		//	summary:

		//      This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.

		//	attribute:

		//		The attribute to test for being contained by the store.

		if(!dojo.isString(attribute)){

			throw new Error("dojox.data.CsvStore: a function was passed an attribute argument that was not an attribute object nor an attribute name string");

		}

	},

/***************************************

     dojo.data.api.Read API

***************************************/

	getValue: function(	/* item */ item,

						/* attribute || attribute-name-string */ attribute,

						/* value? */ defaultValue){

		//	summary:

		//      See dojo.data.api.Read.getValue()

		//		Note that for the CsvStore, an empty string value is the same as no value,

		// 		so the defaultValue would be returned instead of an empty string.

		this._assertIsItem(item);

		this._assertIsAttribute(attribute);

		var itemValue = defaultValue;

		if(this.hasAttribute(item, attribute)){

			var itemData = this._dataArray[this.getIdentity(item)];

			itemValue = itemData[this._attributeIndexes[attribute]];

		}

		return itemValue; //String

	},

	getValues: function(/* item */ item,

						/* attribute || attribute-name-string */ attribute){

		//	summary:

		//		See dojo.data.api.Read.getValues()

		// 		CSV syntax does not support multi-valued attributes, so this is just a

		// 		wrapper function for getValue().

		var value = this.getValue(item, attribute);

		return (value ? [value] : []); //Array

	},

	getAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getAttributes()

		this._assertIsItem(item);

		var attributes = [];

		var itemData = this._dataArray[this.getIdentity(item)];

		for(var i=0; i<itemData.length; i++){

			// Check for empty string values. CsvStore treats empty strings as no value.

			if(itemData[i] != ""){

				attributes.push(this._attributes[i]);

			}

		}

		return attributes; //Array

	},

	hasAttribute: function(	/* item */ item,

							/* attribute || attribute-name-string */ attribute){

		//	summary:

		//		See dojo.data.api.Read.hasAttribute()

		// 		The hasAttribute test is true if attribute has an index number within the item's array length

		// 		AND if the item has a value for that attribute. Note that for the CsvStore, an

		// 		empty string value is the same as no value.

		this._assertIsItem(item);

		this._assertIsAttribute(attribute);

		var attributeIndex = this._attributeIndexes[attribute];

		var itemData = this._dataArray[this.getIdentity(item)];

		return (typeof attributeIndex != "undefined" && attributeIndex < itemData.length && itemData[attributeIndex] != ""); //Boolean

	},

	containsValue: function(/* item */ item,

							/* attribute || attribute-name-string */ attribute,

							/* anything */ value){

		//	summary:

		//		See dojo.data.api.Read.containsValue()

		var regexp = undefined;

		if(typeof value === "string"){

		   regexp = dojo.data.util.filter.patternToRegExp(value, false);

		}

		return this._containsValue(item, attribute, value, regexp); //boolean.

	},

	_containsValue: function(	/* item */ item,

								/* attribute || attribute-name-string */ attribute,

								/* anything */ value,

								/* RegExp?*/ regexp){

		//	summary:

		//		Internal function for looking at the values contained by the item.

		//	description:

		//		Internal function for looking at the values contained by the item.  This

		//		function allows for denoting if the comparison should be case sensitive for

		//		strings or not (for handling filtering cases where string case should not matter)

		//

		//	item:

		//		The data item to examine for attribute values.

		//	attribute:

		//		The attribute to inspect.

		//	value:

		//		The value to match.

		//	regexp:

		//		Optional regular expression generated off value if value was of string type to handle wildcarding.

		//		If present and attribute values are string, then it can be used for comparison instead of 'value'

		var values = this.getValues(item, attribute);

		for(var i = 0; i < values.length; ++i){

			var possibleValue = values[i];

			if(typeof possibleValue === "string" && regexp){

				return (possibleValue.match(regexp) !== null);

			}else{

				//Non-string matching.

				if(value === possibleValue){

					return true; // Boolean

				}

			}

		}

		return false; // Boolean

	},

	isItem: function(/* anything */ something){

		//	summary:

		//		See dojo.data.api.Read.isItem()

		if(something && something[this._storeProp] === this){

			var identity = something[this._idProp];

			if(identity >= 0 && identity < this._dataArray.length){

				return true; //Boolean

			}

		}

		return false; //Boolean

	},

	isItemLoaded: function(/* anything */ something){

		//	summary:

		//		See dojo.data.api.Read.isItemLoaded()

		//		The CsvStore always loads all items, so if it's an item, then it's loaded.

		return this.isItem(something); //Boolean

	},

	loadItem: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.loadItem()

		//	description:

		//		The CsvStore always loads all items, so if it's an item, then it's loaded.

		//		From the dojo.data.api.Read.loadItem docs:

		//			If a call to isItemLoaded() returns true before loadItem() is even called,

		//			then loadItem() need not do any work at all and will not even invoke

		//			the callback handlers.

	},

	getFeatures: function(){

		//	summary:

		//		See dojo.data.api.Read.getFeatures()

		return this._features; //Object

	},

	getLabel: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getLabel()

		if(this.label && this.isItem(item)){

			return this.getValue(item,this.label); //String

		}

		return undefined; //undefined

	},

	getLabelAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getLabelAttributes()

		if(this.label){

			return [this.label]; //array

		}

		return null; //null

	},

	// The dojo.data.api.Read.fetch() function is implemented as

	// a mixin from dojo.data.util.simpleFetch.

	// That mixin requires us to define _fetchItems().

	_fetchItems: function(	/* Object */ keywordArgs,

							/* Function */ findCallback,

							/* Function */ errorCallback){

		//	summary:

		//		See dojo.data.util.simpleFetch.fetch()

		var self = this;

		var filter = function(requestArgs, arrayOfAllItems){

			var items = null;

			if(requestArgs.query){

				items = [];

				var ignoreCase = requestArgs.queryOptions ? requestArgs.queryOptions.ignoreCase : false;

				//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the

				//same value for each item examined.  Much more efficient.

				var regexpList = {};

				for(var key in requestArgs.query){

					var value = requestArgs.query[key];

					if(typeof value === "string"){

						regexpList[key] = dojo.data.util.filter.patternToRegExp(value, ignoreCase);

					}

				}

				for(var i = 0; i < arrayOfAllItems.length; ++i){

					var match = true;

					var candidateItem = arrayOfAllItems[i];

					for(var key in requestArgs.query){

						var value = requestArgs.query[key];

						if(!self._containsValue(candidateItem, key, value, regexpList[key])){

							match = false;

						}

					}

					if(match){

						items.push(candidateItem);

					}

				}

			}else{

				// We want a copy to pass back in case the parent wishes to sort the array.  We shouldn't allow resort

				// of the internal list so that multiple callers can get lists and sort without affecting each other.

				if(arrayOfAllItems.length> 0){

					items = arrayOfAllItems.slice(0,arrayOfAllItems.length);

				}

			}

			findCallback(items, requestArgs);

		};

		if(this._loadFinished){

			filter(keywordArgs, this._arrayOfAllItems);

		}else{

			if(this.url !== ""){

				//If fetches come in before the loading has finished, but while

				//a load is in progress, we have to defer the fetching to be

				//invoked in the callback.

				if(this._loadInProgress){

					this._queuedFetches.push({args: keywordArgs, filter: filter});

				}else{

					this._loadInProgress = true;

					var getArgs = {

							url: self.url,

							handleAs: "text"

						};

					var getHandler = dojo.xhrGet(getArgs);

					getHandler.addCallback(function(data){

						self._processData(data);

						filter(keywordArgs, self._arrayOfAllItems);

						self._handleQueuedFetches();

					});

					getHandler.addErrback(function(error){

						self._loadInProgress = false;

						throw error;

					});

				}

			}else if(this._csvData){

				this._processData(this._csvData);

				this._csvData = null;

				filter(keywordArgs, this._arrayOfAllItems);

			}else{

				throw new Error("dojox.data.CsvStore: No CSV source data was provided as either URL or String data input.");

			}

		}

	},

	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){

		 //	summary:

		 //		See dojo.data.api.Read.close()

	},

	// -------------------------------------------------------------------

	// Private methods

	_getArrayOfArraysFromCsvFileContents: function(/* string */ csvFileContents){

		/* summary:

		 *   Parses a string of CSV records into a nested array structure.

		 * description:

		 *   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.

		 */

		/* example:

		 *   For example, given this CSV string as input:

		 *     "Title, Year, Producer \n Alien, 1979, Ridley Scott \n Blade Runner, 1982, Ridley Scott"

		 *   this._dataArray will be set to:

		 *     [["Alien", "1979", "Ridley Scott"],

		 *      ["Blade Runner", "1982", "Ridley Scott"]]

		 *   And this._attributes will be set to:

		 *     ["Title", "Year", "Producer"]

		 *   And this._attributeIndexes will be set to:

		 *     { "Title":0, "Year":1, "Producer":2 }

		 */

		if(dojo.isString(csvFileContents)){

			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 = 0; i < arrayOfInputLines.length; ++i){

				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(field.length === 2 && field == "\"\""){

							listOfFields[j] = "";  //Special case empty string field.

						}else if((firstChar == '"') &&

								((lastChar != '"') ||

								 ((lastChar == '"') && (secondToLastChar == '"') && (thirdToLastChar != '"')))){

							if(j+1 === listOfFields.length){

								// alert("The last field in record " + i + " is corrupted:\n" + field);

								return null; //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);

				}

			}

			// The first item of the array must be the header row with attribute names.

			this._attributes = arrayOfOutputRecords.shift();

			for(var i=0; i<this._attributes.length; i++){

				// Store the index of each attribute

				this._attributeIndexes[this._attributes[i]] = i;

			}

			this._dataArray = arrayOfOutputRecords; //Array

		}

	},

	_processData: function(/* String */ data){

		this._getArrayOfArraysFromCsvFileContents(data);

		this._arrayOfAllItems = [];

		for(var i=0; i<this._dataArray.length; i++){

			this._arrayOfAllItems.push(this._createItemFromIdentity(i));

		}

		this._loadFinished = true;

		this._loadInProgress = false;

	},

	_createItemFromIdentity: function(/* String */ identity){

		var item = {};

		item[this._storeProp] = this;

		item[this._idProp] = identity;

		return item; //Object

	},

/***************************************

     dojo.data.api.Identity API

***************************************/

	getIdentity: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Identity.getIdentity()

		if(this.isItem(item)){

			return item[this._idProp]; //String

		}

		return null; //null

	},

	fetchItemByIdentity: function(/* Object */ keywordArgs){

		//	summary:

		//		See dojo.data.api.Identity.fetchItemByIdentity()

		//Hasn't loaded yet, we have to trigger the load.

		if(!this._loadFinished){

			var self = this;

			if(this.url !== ""){

				//If fetches come in before the loading has finished, but while

				//a load is in progress, we have to defer the fetching to be

				//invoked in the callback.

				if(this._loadInProgress){

					this._queuedFetches.push({args: keywordArgs});

				}else{

					this._loadInProgress = true;

					var getArgs = {

							url: self.url,

							handleAs: "text"

						};

					var getHandler = dojo.xhrGet(getArgs);

					getHandler.addCallback(function(data){

						var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

						try{

							self._processData(data);

							var item = self._createItemFromIdentity(keywordArgs.identity);

							if(!self.isItem(item)){

								item = null;

							}

							if(keywordArgs.onItem){

								keywordArgs.onItem.call(scope, item);

							}

							self._handleQueuedFetches();

						}catch(error){

							if(keywordArgs.onError){

								keywordArgs.onError.call(scope, error);

							}

						}

					});

					getHandler.addErrback(function(error){

						this._loadInProgress = false;

						if(keywordArgs.onError){

							var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

							keywordArgs.onError.call(scope, error);

						}

					});

				}

			}else if(this._csvData){

				self._processData(self._csvData);

				self._csvData = null;

				var item = self._createItemFromIdentity(keywordArgs.identity);

				if(!self.isItem(item)){

					item = null;

				}

				if(keywordArgs.onItem){

					var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

					keywordArgs.onItem.call(scope, item);

				}

			}

		}else{

			//Already loaded.  We can just look it up and call back.

			var item = this._createItemFromIdentity(keywordArgs.identity);

			if(!this.isItem(item)){

				item = null;

			}

			if(keywordArgs.onItem){

				var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;

				keywordArgs.onItem.call(scope, item);

			}

		}

	},

	getIdentityAttributes: function(/* item */ item){

		 //	summary:

		 //		See dojo.data.api.Identity.getIdentifierAttributes()

		 //Identity isn't a public attribute in the item, it's the row position index.

		 //So, return null.

		 return null;

	},

	_handleQueuedFetches: function(){

		//	summary:

		//		Internal function to execute delayed request in the store.

		//Execute any deferred fetches now.

		if (this._queuedFetches.length > 0) {

			for(var i = 0; i < this._queuedFetches.length; i++){

				var fData = this._queuedFetches[i];

				var delayedFilter = fData.filter;

				var delayedQuery = fData.args;

				if(delayedFilter){

					delayedFilter(delayedQuery, this._arrayOfAllItems);

				}else{

					this.fetchItemByIdentity(fData.args);

				}

			}

			this._queuedFetches = [];

		}

	}

});

//Mix in the simple fetch implementation to this class.

dojo.extend(dojox.data.CsvStore,dojo.data.util.simpleFetch);

}