Changeset 5341 for trunk/prototype/app/datalayer.js

Timestamp:

01/10/12 11:25:51 (12 years ago)

Author:

wmerlotto

Message:

Ticket #2434 - Commit inicial do novo módulo de agenda do Expresso - expressoCalendar

File:

• trunk/prototype/app/datalayer.js (modified) (40 diffs)

trunk/prototype/app/datalayer.js

@@ -48 +48 @@
 $("form").live( "submit", function( event ){
 
-    var action = $(this).attr("action"), res = false;
+    var $this = $(this), action = $this.attr('action'), res = false,
+    
+    method = $this.attr( 'method' ),
+    
+    fileInputs = $this.find('input[type="file"]');
+    
+    if( fileInputs.length && !$this.is('[enctype="multipart/form-data"]') )
+    {
+        event.preventDefault();
+
+        DataLayer.send( action, 
+                        [ method, 'iframe json' ], {}, 
+                        //TODO: check the type for conversion
+                        DataLayer.receive, 
+                        false, { 'formData': $this.serializeArray(),  'fileInput': fileInputs } );
+
+        return( false );
+    }
     
     if( res = internalUrl.exec( action ) )
@@ -55 +72 @@
 
         var data = DataLayer.form( this );
+        
+        switch( method.toUpperCase() )
+        {
+          case 'GET':
+                DataLayer.get( res[0], data );
+
+          case 'POST':
         DataLayer.put( res[1], data );
+        }
 
         return( false );
@@ -63 +88 @@
 });
 
-$.storage = new $.store();
+this.storage = new $.store();
 
 DataLayer = {
@@ -113 +138 @@
     },
     
-    send: function( url, type, data, callback, sync ){
+    send: function( url, type, data, callback, sync, extraOptions ){
       
           var result = false, fired = false;
@@ -147 +172 @@
               envelope['dataType'] = type[1];
 
+          if( extraOptions )
+              envelope = $.extend( envelope, extraOptions );
+
           $.ajax( envelope );
       
@@ -152 +180 @@
     },
     
-    dispatch: function( dispatcher, data, callback, isPost ){
+    dispatch: function( dispatcher, data, callback, isPost, dataType ){
       
       return this.send( this.dispatchPath + dispatcher + ".php", 
-                        [ ( isPost ? 'post' : 'get' ), 'json' ],
+                        [ ( isPost ? 'post' : 'get' ), dataType || 'json' ],
                         data,
                         callback );
@@ -300 +328 @@
                         $.each( data[i][link], function( ii, el ){
 
-                                var isRef = false
+                                var isRef = false;
 
                                 if( isRef = ($.type(el) === "string") )
@@ -332 +360 @@
 
                 if( data[i].id )
-                    data[i] = this.merge(  concept, current[ data[i].id ], data[i] );
+                    data[i] = this.merge( current[ data[i].id ], data[i] );
 
                  current[ key ] = data[i];
@@ -344 +372 @@
             for( var setKey in updateSet )
             {
-                DataLayer.put( setKey, updateSet[ setKey ], false );
-
                 if( bothSides )
                     for( var i = 0; i < updateSet[ setKey ].length; i++ )
                       this.report( setKey, updateSet[ setKey ][i].id, updateSet[ setKey ][i] );
+                    
+                DataLayer.put( setKey, updateSet[ setKey ], false );
             }
         }
@@ -383 +411 @@
             current[ id ] = this.check( concept, id ) || {};
         
-        this.store( ':current', concept, current );
+        this.store( ':current', concept, current[ id ] );
 
         var diff = this.diff( current[ id ], data );
@@ -389 +417 @@
         var diffs = this.check( ':diff', concept ) || {};
 
+        if( diffs[ id ] )
+            diff = this.merge( diffs[ id ], diff );
+
+        if( !$.isEmptyObject( diff ) )
         diffs[ id ] = diff;
 
@@ -430 +462 @@
     prepareQ: function( queueName, concept, ids ){
       
+      var notArray = false;
+      
       if( notArray = ($.type(concept) !== "array") )
           concept = [ concept ];
+      
+      var q = {};
       
       for( var i = 0; i < concept.length; i++ )
@@ -437 +473 @@
           var queue = this.check( ':' + queueName, concept[i] || false );
           
+          if( !queue ) continue;
+
           if( ids )
           {
@@ -451 +489 @@
               queue = filtered;
           }
+
+          q[ concept[i] ] = queue;
       }
       
-      return( queue );
+      return( notArray ? q[ concept[0] ] : q );
     },
     
     clearQ: function( concept, ids ){
       
-        var current = this.check( ':current', concept || false );
+//              var current = this.check( ':current', concept || false );
         var diffs = this.check( ':diff', concept || false );
 
         if( !ids )
-            current = diffs = {};
+           /* current =*/ diffs = {};
         else
         {
@@ -470 +510 @@
             for( var i = 0; i < ids.length; i++ )
             {
-                delete current[ ids[i] ];
+//              delete current[ ids[i] ];
                 delete diffs[ ids[i] ];
             }
         }
 
-        this.store( ':current', concept, current );
+//      this.store( ':current', concept, current );
         this.store( ':diff', concept, diffs );
     },
@@ -483 +523 @@
         var queue = this.prepareQ( 'diff', concept, ids );
 
-        this.sync( queue, concept || false, callback );
+        this.sync( queue, !$.isArray(concept) && concept || false, callback );
     },
     
@@ -523 +563 @@
 //          }
 
+            var received = DataLayer.receive( data );
+
+            for( var URI in URIs )
+                if( typeof received[URI] !== "undefined" )
+                    DataLayer.clearQ( URIs[URI].concept, URIs[URI].id );
+
+            if( callback )
+                callback( received );
+
+//          for( var URI in data )
+//          { 
+//              var parsed = DataLayer.parseURI( URI ),
+//    
+//              concept = parsed[1], id = parsed[3];
+// 
+//              if( $.type(data[URI]) === "string" )
+//              {
+//                //TODO:threat the exception thrown
+//                DataLayer.rollback( concept, id );
+//                delete URIs[ URI ];
+//                continue;
+//              }
+// 
+//              if( data[URI] === false ){
+//                DataLayer.remove( concept, id, false );
+//                continue;
+//              }
+// 
+//              if( id !== data[URI].id )
+//                DataLayer.move( concept, id, data[URI].id );
+//              
+//              DataLayer.put( concept, id, data[URI], false );
+//          }
+//          
+//          for( var URI in URIs )
+//               DataLayer.clearQ( URIs[URI].concept, URIs[URI].id );
+//          
+//          if( callback )
+//              callback();
+
+        }, true );
+
+    },
+    
+    receive: function( data ){
+      
+        var received = {};
+        
             for( var URI in data )
             { 
                 var parsed = DataLayer.parseURI( URI ),
    
-                concept = parsed[1], id = parsed[3];
+            concept = parsed[4], id = parsed[5];
+
+            received[ URI ] = data[ URI ];
 
                 if( $.type(data[URI]) === "string" )
@@ -533 +623 @@
                   //TODO:threat the exception thrown
                   DataLayer.rollback( concept, id );
-                  delete URIs[ URI ];
                   continue;
                 }
@@ -548 +637 @@
             }
             
-            for( var URI in URIs )
-                 DataLayer.clearQ( URIs[URI].concept, URIs[URI].id );
+        return( received );
             
-            if( callback )
-                callback();
-
-        }, true );
-
-    },
-    
-    receive: function( concept, data ){
-      
-      this.put( concept, data, false );
-      
-//       if( typeof data.URI === "undefined" )
-//      {
-//          URI = this.add( concept, data, oneSide );
-//      }
-//      else if( data.URI === false )
-//      {
-//          status = this.remove( concept, URI, oneSide );
-//      }
-//      else
-//      {
-//          status = this.set( concept, URI, data, oneSide );
-//      }
-// 
-//      if( URI && data.URI && URI !== data.URI )
-//          this.move( concept, URI, data.URI );
+    },
+
+    
+
+    merge: function( current, data ){
+      
+        return this.copy(  data, current );
+
+//      return $.extend( current, data );
+
+    },
+    
+    // clone objects, skip other types.
+    clone: function(target) {
+            if ( typeof target == 'object' ) {
+                    Clone.prototype = target;
+                    return new Clone();
+            } else {
+                    return target;
+            }
+    },
+      
+    // Shallow Copy 
+    shallowCopy: function(target) {
+            if (typeof target !== 'object' ) {
+                    return target;  // non-object have value sematics, so target is already a copy.
+            } else {
+                    var value = target.valueOf();
+                    if (target != value) { 
+                            // the object is a standard object wrapper for a native type, say String.
+                            // we can make a copy by instantiating a new object around the value.
+                            return new target.constructor(value);
+                    } else {
+                            // ok, we have a normal object. If possible, we'll clone the original's prototype 
+                            // (not the original) to get an empty object with the same prototype chain as
+                            // the original.  If just copy the instance properties.  Otherwise, we have to 
+                            // copy the whole thing, property-by-property.
+                            if ( target instanceof target.constructor && target.constructor !== Object ) { 
+                                    var c = clone(target.constructor.prototype);
+      
+                                    // give the copy all the instance properties of target.  It has the same
+                                    // prototype as target, so inherited properties are already there.
+                                    for ( var property in target) { 
+                                            if (target.hasOwnProperty(property)) {
+                                                    c[property] = target[property];
+                                            } 
+                                    }
+                            } else {
+                                    var c = {};
+                                    for ( var property in target ) c[property] = target[property];
+                            }
+                            
+                            return c;
+                    }
+            }
+    },
+
+    // entry point for deep copy.
+    // source is the object to be deep copied.
+    // depth is an optional recursion limit. Defaults to 256.
+    // deep copy handles the simple cases itself: non-objects and object's we've seen before.
+    // For complex cases, it first identifies an appropriate DeepCopier, then delegate the details of copying the object to him.
+    copy: function(source, result, depth) {
+      
+            // null is a special case: it's the only value of type 'object' without properties.
+            if ( source === null ) return null;
+
+            // All non-objects use value semantics and don't need explict copying.
+            if ( typeof source !== 'object' ) return source;
+
+            if( !depth || !(depth instanceof RecursionHelper) ) depth = new RecursionHelper(depth);
+
+            var cachedResult = depth.getCachedResult(source);
+
+            // we've already seen this object during this deep copy operation
+            // so can immediately return the result.  This preserves the cyclic
+            // reference structure and protects us from infinite recursion.
+            if ( cachedResult ) return cachedResult;
+
+            // objects may need special handling depending on their class.  There is
+            // a class of handlers call "DeepCopiers"  that know how to copy certain
+            // objects.  There is also a final, generic deep copier that can handle any object.
+            for ( var i=0; i<this.comparators.length; i++ ) {
+
+                    var comparator = this.comparators[i];
+
+                    if ( comparator.can(source) ) {
         
-      
-    },
-
-    
-
-    merge: function( concept, current, data ){
-
-        return $.extend( current, data );
-
+                            // once we've identified which DeepCopier to use, we need to call it in a very
+                            // particular order: create, cache, populate.  This is the key to detecting cycles.
+                            // We also keep track of recursion depth when calling the potentially recursive
+                            // populate(): this is a fail-fast to prevent an infinite loop from consuming all
+                            // available memory and crashing or slowing down the browser.
+      
+                            if( !result )
+                                // Start by creating a stub object that represents the copy.
+                                result = comparator.create(source);
+                            else if( !comparator.can(result) )
+                                throw new Error("can't compare diferent kind of objects.");
+
+                            // we now know the deep copy of source should always be result, so if we encounter
+                            // source again during this deep copy we can immediately use result instead of
+                            // descending into it recursively.  
+                            depth.cacheResult(source, result);
+
+                            // only DeepCopier.populate() can recursively deep copy.  So, to keep track
+                            // of recursion depth, we increment this shared counter before calling it,
+                            // and decrement it afterwards.
+                            depth.depth++;
+                            if ( depth.depth > depth.maxDepth ) {
+                                    throw new Error("Exceeded max recursion depth in deep copy.");
+                            }
+
+                            var thisPass = this;
+
+                            // It's now safe to let the comparator recursively deep copy its properties.
+                            comparator.populate( function(source, result) { return thisPass.copy(source, result, depth); }, source, result );
+
+                            depth.depth--;
+
+                            return result;
+                    }
+            }
+            // the generic copier can handle anything, so we should never reach this line.
+            throw new Error("no DeepCopier is able to copy " + source);
+    },
+
+    // publicly expose the list of deepCopiers.
+    comparators: [],
+
+    // make deep copy() extensible by allowing others to 
+    // register their own custom Comparators.
+    registerComparator: function(comparatorOptions) {
+
+          // publicly expose the Comparator class.
+          var comparator = {
+
+              // determines if this Comparator can handle the given object.
+              can: function(source) { return false; },
+    
+              // starts the deep copying process by creating the copy object.  You
+              // can initialize any properties you want, but you can't call recursively
+              // into the copy().
+              create: function(source) { },
+
+              // Completes the deep copy of the source object by populating any properties
+              // that need to be recursively deep copied.  You can do this by using the
+              // provided deepCopyAlgorithm instance's copy() method.  This will handle
+              // cyclic references for objects already deepCopied, including the source object
+              // itself.  The "result" passed in is the object returned from create().
+              populate: function(deepCopyAlgorithm, source, result) {}
+          };
+
+          for ( var key in comparatorOptions ) comparator[key] = comparatorOptions[key];
+
+          this.comparators.unshift( comparator );
     },
  
     diff: function( base, toDiff ){
 
-//      var df = toDiff;
-//       
-//      for( var key in base ){
-// 
-//          if( base[key] === df[key] )
-//              delete df[key];
-// 
-//          
-//      }
+        if( typeof base === 'undefined' || $.isEmptyObject(base) )
+            return( toDiff );
+
         if( toDiff === false )
             return( false );
 
-        var toDiff = $.extend( {}, toDiff );
-
-        if( isGeneratedId.test( toDiff.id ) )
-            delete toDiff['id'];
+        toDiff = $.extend( {}, toDiff );
+
+        for( var key in toDiff )
+        {
+            switch( $.type(toDiff[key]) )
+            {
+              case 'object': 
+                if( $.isEmptyObject(toDiff[key] = this.diff( base[key], toDiff[key] )) )
+                  delete toDiff[key];
+              break;
+              case 'array':
+                if( base[key] && !(toDiff[key] = $.grep( toDiff[key], function( el, i ){ return( $.inArray( el, base[key] ) === -1 ); } )).length )
+                  delete toDiff[key];
+              break;
+              default:
+                if( base[key] == toDiff[key] )
+                  delete toDiff[key];
+            }
+        }
 
         return( toDiff );
@@ -733 +950 @@
             result = this.request( concept, id || filter.filter, filter.criteria );
 
-            if( result && bothSides )
+            if( result && bothSides && !filter.criteria.format )
             {
               var newResult = [];
@@ -807 +1024 @@
     },
     
+//     clone: function( object ){
+// 
+//      new { prototype: object };
+// 
+//     },
 
     check: function( namespace, keys ){
@@ -813 +1035 @@
             return( false );
 
-        var result = $.storage.get( namespace );
+        var result = this.storage.get( namespace );
 
         if( !keys || !result )
@@ -831 +1053 @@
     },
 
+    storage: {
+      
+        cache: {},
+      
+        set: function( key, value ){
+
+            this.cache[key] = value;
+
+        },
+        get: function( key ){
+
+            return DataLayer.copy( this.cache[key] );
+
+        },
+        del: function( key ){
+
+            delete this.cache[key];
+
+        }
+    },
+
+    flush: function(){
+
+    },
+    
+    restore: function(){
+      
+    },
+
     store: function( namespace, key, data ){
 
         if( !data )
-          return $.storage.set( namespace, key );
+          return this.storage.set( namespace, key );
 
         var res = this.check( namespace ) || {};
@@ -840 +1091 @@
         res[key] = data;
 
-        return $.storage.set( namespace, res );
+        return this.storage.set( namespace, res );
     },
 
@@ -846 +1097 @@
       
         if( !key )
-          return $.storage.del( namespace );
+          return this.storage.del( namespace );
 
         var res = this.check( namespace ) || {};
@@ -852 +1103 @@
         delete res[key];
 
-        return $.storage.set( namespace, res );
+        return this.storage.set( namespace, res );
       
     },
@@ -858 +1109 @@
      move: function( concept, oldId, newId ){
 
-        this.store( concept, newId, this.check( concept, oldId ) );
+        this.put( concept, newId, this.check( concept, oldId ), false );
 
         this.del( concept, oldId );
@@ -1308 +1559 @@
 // 
 //      if( !URI )
-//          return $.storage.del( concept );
+//          return this.storage.del( concept );
 // 
 //      var res = this.check( concept );
@@ -1499 +1750 @@
     register: function( kind, concept, deployable ){
 
+      if( arguments.length < 3 )
+      {
+          deployable = concept;
+          concept = kind;
+          kind = 'global';
+      }
+
       if( !this[ kind ][ concept ] )
             this[ kind ][ concept ] = [];
@@ -1522 +1780 @@
                   var result = tasks[i].task( now );
 
+                  if( tasks[i].factor )
                   DataLayer.schedule( tasks[i].task, tasks[i].factor );
               }
@@ -1531 +1790 @@
     },
     
+    task: function( timestamp, task, factor )
+    {
+        if( !this.tasks[ timestamp ] )
+            this.tasks[ timestamp ] = [];
+
+        this.tasks[ timestamp ][ this.tasks[ timestamp ].length ] = { task: task, factor: factor || false };
+    },
+
     schedule: function( task, time ){
 
@@ -1537 +1804 @@
         var index = parseInt( $.now() / 1000 ) + time;
 
-        if( !this.tasks[ index ] )
-            this.tasks[ index ] = [];
-
-        this.tasks[ index ][ this.tasks[ index ].length ] = { task: task, factor: time };
+        this.task( index, task, time );
     },
     
@@ -1565 +1829 @@
             this.basePath = this.dispatchPath + "REST.php?q=";
 
+        this.schedule( function( now ){
+
+            DataLayer.flush();
+
+        });
+
         this.start();
     }
 }
 
+// the re-usable constructor function used by clone().
+function Clone() {}
+
+//Recursion Helper
+function RecursionHelper(){ this.clear(); };
+
+RecursionHelper.prototype = {
+  
+        constructor: RecursionHelper,
+
+        // copiedObjects keeps track of objects already copied by this
+        // deepCopy operation, so we can correctly handle cyclic references.
+        copiedObjects: [],
+
+        depth: 0,
+
+        maxDepth: 256,
+
+        //reset the recursion helper cache
+        clear: function(){
+                this.copiedObjects = [];
+                this.depth = 0;
+        },
+
+        // add an object to the cache.  No attempt is made to filter duplicates;
+        // we always check getCachedResult() before calling it.
+        cacheResult: function(source, result) {
+                this.copiedObjects.push([source, result]);
+        },
+
+        // Returns the cached copy of a given object, or undefined if it's an
+        // object we haven't seen before.
+        getCachedResult: function(source) {
+
+                for ( var i=0; i<this.copiedObjects.length; i++ ) {
+                        if ( this.copiedObjects[i][0] === source ) {
+                                return this.copiedObjects[i][1];
+                        }
+                }
+
+                return undefined;
+        }
+};
+
+// Generic Object copier
+// the ultimate fallback DeepCopier, which tries to handle the generic case.  This
+// should work for base Objects and many user-defined classes.
+DataLayer.registerComparator({
+        can: function(source) { return true; },
+
+        create: function(source) {
+                if ( source instanceof source.constructor ) {
+                        return DataLayer.clone(source.constructor.prototype);
+                } else {
+                        return {};
+                }
+        },
+
+        populate: function(deepCopy, source, result) {
+                for ( var key in source ) {
+                        if ( source.hasOwnProperty(key) ) {
+                                result[key] = deepCopy(source[key], result[key]);
+                        }
+                }
+                return result;
+        }
+});
+
+// Array copier
+DataLayer.registerComparator({
+        can: function(source) {
+                return ( source instanceof Array );
+        },
+
+        create: function(source) {
+                return new source.constructor();
+        },
+
+        populate: function(deepCopy, source, result) {
+                for ( var i=0; i<source.length; i++) {
+                        result.push( deepCopy(source[i], result[i]) );
+                }
+                return result;
+        }
+});
+
+// Date copier
+DataLayer.registerComparator({
+        can: function(source) {
+                return ( source instanceof Date );
+        },
+
+        create: function(source) {
+                return new Date(source);
+        }
+});
+
+// HTML DOM Node copier
+DataLayer.registerComparator({
+
+        // function to detect Nodes.  In particular, we're looking
+        // for the cloneNode method.  The global document is also defined to
+        // be a Node, but is a special case in many ways.
+        can: function(source) { 
+          
+          if ( window.Node ) {
+                  return source instanceof Node;
+          } else {
+                  // the document is a special Node and doesn't have many of
+                  // the common properties so we use an identity check instead.
+                  if ( source === document ) return true;
+                  return (
+                          typeof source.nodeType === 'number' &&
+                          source.attributes &&
+                          source.childNodes &&
+                          source.cloneNode
+                  );
+          } 
+      },
+
+      create: function(source) {
+              // there can only be one (document).
+              if ( source === document ) return document;
+
+              // start with a shallow copy.  We'll handle the deep copy of
+              // its children ourselves.
+              return source.cloneNode(false);
+      },
+      
+      diff: function(base, source){
+        
+      },
+
+      populate: function(deepCopy, source, result) {
+              // we're not copying the global document, so don't have to populate it either.
+              if ( source === document ) return document;
+
+              // if this Node has children, deep copy them one-by-one.
+              if ( source.childNodes && source.childNodes.length ) {
+                      for ( var i=0; i<source.childNodes.length; i++ ) {
+                              var childCopy = deepCopy(source.childNodes[i], result.childNodes[i] || false );
+                              result.appendChild(childCopy);
+                      }
+              }
+      }
+});
+
 DataLayer.init();
 
@@ -1581 +1998 @@
 //     get: function( concept, filter ){
 // 
-//      var data = $.storage.get( concept );
+//      var data = this.storage.get( concept );
 // 
 //      if( !filter )
@@ -1672 +2089 @@
 //          data = [ data ];
 // 
-//      var target = $.storage.get( concept );
+//      var target = this.storage.get( concept );
 //      
 //      var diff = { New: {}, Update:{}, Delete: {} };
@@ -1698 +2115 @@
 //          data = $.extend( target, data );
 // 
-//      $.storage.set( concept, data );
+//      this.storage.set( concept, data );
 // 
 // //   return;
@@ -1754 +2171 @@
 //     get: function( concept, filter ){
 // 
-//      var data = $.storage.get( concept );
+//      var data = this.storage.get( concept );
 // 
 //      if( !filter )
@@ -1798 +2215 @@
 //          data = $.extend( target, data );
 //       
-//      $.storage.set( concept, data );
+//      this.storage.set( concept, data );
 //      
 //      //diff
@@ -1908 +2325 @@
 //          }
 
-//              var model = $.storage.get( concept );
+//              var model = this.storage.get( concept );
 // 
 //              $.each( model, function( i, o ){
@@ -1933 +2350 @@
 //              concept = uri.join( '.' );
 
-//              var model = $.storage.get( concept );
+//              var model = this.storage.get( concept );
 // 
 //              $.each( model, function( i, o ){