Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.storage.GearsStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.storage.GearsStorageProvider"] = true;
dojo.provide("dojox.storage.GearsStorageProvider");
dojo.require("dojox.storage.Provider");
dojo.require("dojox.storage.manager");
dojo.require("dojox.sql");

if(dojo.isGears){
        
        (function(){
                // make sure we don't define the gears provider if we're not gears
                // enabled
                
                dojo.declare("dojox.storage.GearsStorageProvider", dojox.storage.Provider, {
                        // summary:
                        //              Storage provider that uses the features of Google Gears
                        //              to store data (it is saved into the local SQL database
                        //              provided by Gears, using dojox.sql)
                        // description: 
                        //              
                        //
                        //              You can disable this storage provider with the following djConfig
                        //              variable:
                        //              var djConfig = { disableGearsStorage: true };
                        //              
                        //              Authors of this storage provider-       
                        //                      Brad Neuberg, bkn3@columbia.edu 
                        constructor: function(){
                        },
                        // instance methods and properties
                        TABLE_NAME: "__DOJO_STORAGE",
                        initialized: false,
                        
                        _available: null,
                        
                        initialize: function(){
                                //console.debug("dojox.storage.GearsStorageProvider.initialize");
                                if(djConfig["disableGearsStorage"] == true){
                                        return;
                                }
                                
                                // partition our storage data so that multiple apps
                                // on the same host won't collide
                                this.TABLE_NAME = "__DOJO_STORAGE";
                                
                                // create the table that holds our data
                                try{
                                        dojox.sql("CREATE TABLE IF NOT EXISTS " + this.TABLE_NAME + "( "
                                                                + " namespace TEXT, "
                                                                + " key TEXT, "
                                                                + " value TEXT "
                                                                + ")"
                                                        );
                                        dojox.sql("CREATE UNIQUE INDEX IF NOT EXISTS namespace_key_index" 
                                                                + " ON " + this.TABLE_NAME
                                                                + " (namespace, key)");
                                }catch(e){
                                        console.debug("dojox.storage.GearsStorageProvider.initialize:", e);
                                        
                                        this.initialized = false; // we were unable to initialize
                                        dojox.storage.manager.loaded();
                                        return;
                                }
                                
                                // indicate that this storage provider is now loaded
                                this.initialized = true;
                                dojox.storage.manager.loaded(); 
                        },
                        
                        isAvailable: function(){
                                // is Google Gears available and defined?
                                return this._available = dojo.isGears;
                        },

                        put: function(key, value, resultsHandler, namespace){
                                if(this.isValidKey(key) == false){
                                        throw new Error("Invalid key given: " + key);
                                }
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                
                                // serialize the value;
                                // handle strings differently so they have better performance
                                if(dojo.isString(value)){
                                        value = "string:" + value;
                                }else{
                                        value = dojo.toJson(value);
                                }
                                
                                // try to store the value       
                                try{
                                        dojox.sql("DELETE FROM " + this.TABLE_NAME
                                                                + " WHERE namespace = ? AND key = ?",
                                                                namespace, key);
                                        dojox.sql("INSERT INTO " + this.TABLE_NAME
                                                                + " VALUES (?, ?, ?)",
                                                                namespace, key, value);
                                }catch(e){
                                        // indicate we failed
                                        console.debug("dojox.storage.GearsStorageProvider.put:", e);
                                        resultsHandler(this.FAILED, key, e.toString());
                                        return;
                                }
                                
                                if(resultsHandler){
                                        resultsHandler(dojox.storage.SUCCESS, key, null);
                                }
                        },

                        get: function(key, namespace){
                                if(this.isValidKey(key) == false){
                                        throw new Error("Invalid key given: " + key);
                                }
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                
                                // try to find this key in the database
                                var results = dojox.sql("SELECT * FROM " + this.TABLE_NAME
                                                                                        + " WHERE namespace = ? AND "
                                                                                        + " key = ?",
                                                                                        namespace, key);
                                if(!results.length){
                                        return null;
                                }else{
                                        results = results[0].value;
                                }
                                
                                // destringify the content back into a 
                                // real JavaScript object;
                                // handle strings differently so they have better performance
                                if(dojo.isString(results) && (/^string:/.test(results))){
                                        results = results.substring("string:".length);
                                }else{
                                        results = dojo.fromJson(results);
                                }
                                
                                return results;
                        },
                        
                        getNamespaces: function(){
                                var results = [ dojox.storage.DEFAULT_NAMESPACE ];
                                
                                var rs = dojox.sql("SELECT namespace FROM " + this.TABLE_NAME
                                                                        + " DESC GROUP BY namespace");
                                for(var i = 0; i < rs.length; i++){
                                        if(rs[i].namespace != dojox.storage.DEFAULT_NAMESPACE){
                                                results.push(rs[i].namespace);
                                        }
                                }
                                
                                return results;
                        },

                        getKeys: function(namespace){
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                if(this.isValidKey(namespace) == false){
                                        throw new Error("Invalid namespace given: " + namespace);
                                }
                                
                                var rs = dojox.sql("SELECT key FROM " + this.TABLE_NAME
                                                                        + " WHERE namespace = ?",
                                                                        namespace);
                                
                                var results = [];
                                for(var i = 0; i < rs.length; i++){
                                        results.push(rs[i].key);
                                }
                                
                                return results;
                        },

                        clear: function(namespace){
                                if(this.isValidKey(namespace) == false){
                                        throw new Error("Invalid namespace given: " + namespace);
                                }
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                
                                dojox.sql("DELETE FROM " + this.TABLE_NAME 
                                                        + " WHERE namespace = ?",
                                                        namespace);
                        },
                        
                        remove: function(key, namespace){
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                
                                dojox.sql("DELETE FROM " + this.TABLE_NAME 
                                                        + " WHERE namespace = ? AND"
                                                        + " key = ?",
                                                        namespace,
                                                        key);
                        },
                        
                        putMultiple: function(keys, values, resultsHandler, namespace) {
                                if(this.isValidKeyArray(keys) === false 
                                                || ! values instanceof Array 
                                                || keys.length != values.length){
                                        throw new Error("Invalid arguments: keys = [" 
                                                                        + keys + "], values = [" + values + "]");
                                }
                                
                                if(namespace == null || typeof namespace == "undefined"){
                                        namespace = dojox.storage.DEFAULT_NAMESPACE;            
                                }
        
                                if(this.isValidKey(namespace) == false){
                                        throw new Error("Invalid namespace given: " + namespace);
                                }
        
                                this._statusHandler = resultsHandler;

                                // try to store the value       
                                try{
                                        dojox.sql.open();
                                        dojox.sql.db.execute("BEGIN TRANSACTION");
                                        var _stmt = "REPLACE INTO " + this.TABLE_NAME + " VALUES (?, ?, ?)";
                                        for(var i=0;i<keys.length;i++) {
                                                // serialize the value;
                                                // handle strings differently so they have better performance
                                                var value = values[i];
                                                if(dojo.isString(value)){
                                                        value = "string:" + value;
                                                }else{
                                                        value = dojo.toJson(value);
                                                }
                                
                                                dojox.sql.db.execute( _stmt,
                                                        [namespace, keys[i], value]);
                                        }
                                        dojox.sql.db.execute("COMMIT TRANSACTION");
                                        dojox.sql.close();
                                }catch(e){
                                        // indicate we failed
                                        console.debug("dojox.storage.GearsStorageProvider.putMultiple:", e);
                                        if(resultsHandler){
                                                resultsHandler(this.FAILED, keys, e.toString());
                                        }
                                        return;
                                }
                                
                                if(resultsHandler){
                                        resultsHandler(dojox.storage.SUCCESS, key, null);
                                }
                        },

                        getMultiple: function(keys, namespace){
                                //      TODO: Maybe use SELECT IN instead

                                if(this.isValidKeyArray(keys) === false){
                                        throw new ("Invalid key array given: " + keys);
                                }
                                
                                if(namespace == null || typeof namespace == "undefined"){
                                        namespace = dojox.storage.DEFAULT_NAMESPACE;            
                                }
                                
                                if(this.isValidKey(namespace) == false){
                                        throw new Error("Invalid namespace given: " + namespace);
                                }
                
                                var _stmt = "SELECT * FROM " + this.TABLE_NAME  + 
                                        " WHERE namespace = ? AND "     + " key = ?";
                                
                                var results = [];
                                for(var i=0;i<keys.length;i++){
                                        var result = dojox.sql( _stmt, namespace, keys[i]);
                                                
                                        if( ! result.length){
                                                results[i] = null;
                                        }else{
                                                result = result[0].value;
                                                
                                                // destringify the content back into a 
                                                // real JavaScript object;
                                                // handle strings differently so they have better performance
                                                if(dojo.isString(result) && (/^string:/.test(result))){
                                                        results[i] = result.substring("string:".length);
                                                }else{
                                                        results[i] = dojo.fromJson(result);
                                                }
                                        }
                                }
                                
                                return results;
                        },
                        
                        removeMultiple: function(keys, namespace){
                                namespace = namespace||this.DEFAULT_NAMESPACE;
                                
                                dojox.sql.open();
                                dojox.sql.db.execute("BEGIN TRANSACTION");
                                var _stmt = "DELETE FROM " + this.TABLE_NAME + " WHERE namespace = ? AND key = ?";

                                for(var i=0;i<keys.length;i++){
                                        dojox.sql.db.execute( _stmt,
                                                [namespace, keys[i]]);
                                }
                                dojox.sql.db.execute("COMMIT TRANSACTION");
                                dojox.sql.close();
                        },                              
                        
                        isPermanent: function(){ return true; },

                        getMaximumSize: function(){ return this.SIZE_NO_LIMIT; },

                        hasSettingsUI: function(){ return false; },
                        
                        showSettingsUI: function(){
                                throw new Error(this.declaredClass 
                                                                        + " does not support a storage settings user-interface");
                        },
                        
                        hideSettingsUI: function(){
                                throw new Error(this.declaredClass 
                                                                        + " does not support a storage settings user-interface");
                        }
                });

                // register the existence of our storage providers
                dojox.storage.manager.register("dojox.storage.GearsStorageProvider",
                                                                                new dojox.storage.GearsStorageProvider());
        
                dojox.storage.manager.initialize();
        })();
}

}