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);

}