Integration of PHP backend with /beta and /gamma front ends

Fixed PHP backend and /beta code to handle request and data format compatible with /gamma. At the moment adding/deleting/editing records seem to work fine.
author: Giulio Cesare Solaroli <giulio.cesare@clipperz.com> 2011-10-23 17:36:57 (UTC)
committer: Giulio Cesare Solaroli <giulio.cesare@clipperz.com> 2011-10-23 17:36:57 (UTC)
commit: 67455b069c4c9ec493f9cef76017e172a430a7d4 (patch) (unidiff)
tree: 0b287debfeeb0819b3df9dd02860cd84103e25b3 /frontend/gamma
parent: b312e037ebba7c94abea9661bcf62c52b7d73fbf (diff)
download: clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.zip
clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.tar.gz
clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.tar.bz2
3 files changed, 19 insertions, 7 deletions
diff --git a/frontend/gamma/html/index_template.html b/frontend/gamma/html/index_template.html
index 8cf838c..bedb243 100644
--- a/frontend/gamma/html/index_template.html
+++ b/frontend/gamma/html/index_template.html
@@ -1,62 +1,67 @@
 <html>
 <head>
        <title>@page.title@</title>
        <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 <!--
 @copyright@
 -->
 @css@
        <link rel="shortcut icon" href="./clipperz.ico" />
        <meta name="description" content="Login to your web accounts with just one click. Never type a password again! Use multiple complex passwords and forget them. A password manager that enhances your online security." />
        <meta name="keywords" content="password manager,gestor de contraseñas,gerenciador de senhas,Kennwortmanager,passwords,security,privacy,cryptography" />
 <script>
        Clipperz_IEisBroken = false;
        Clipperz_normalizedNewLine = '\n';
        Clipperz_dumpUrl = "/dump/";
 </script>
 <!--[if IE]><script>
 Clipperz_IEisBroken = true;
 Clipperz_normalizedNewLine = '\x0d\x0a';
 </script><![endif]-->
 @js_DEBUG@
 </head>
 <body>
 <div id="mainDiv">
        <div id="loading">
                <a href="http://www.clipperz.com" target="_blank"><div id="logo"></div></a>
                <h5 class="clipperzPayoff">keep it to yourself!</h5>
                <h2>loading ...</h2>
        </div>
 @js_INSTALL@
 </div>
 <div id="applicationVersionType" class="@application.version.type@"></div>
+<script>
+        Clipperz.PM.Proxy.defaultProxy = new Clipperz.PM.Proxy.JSON({'url':'@request.path@', 'shouldPayTolls':@should.pay.toll@});
+        /*offline_data_placeholder*/
+</script>
 <!-- -->
 <div id="javaScriptAlert">
        <div class="mask"></div>
        <div class="message">
                <div class="header"></div>
                <div class="body">
                        <div class="alertLogo"></div>
                        <div class="alert">
                                <h1>Attention!</h1>
                                <p>If you can read this message, the chances are that your browser does not properly support JavaScript? or you have disabled this functionality yourself.</p>
                                <h3>Javascript is required to access Clipperz.</h3>
                                <h5>Please enable scripting or upgrade your browser.</h5>
                        </div>
                </div>
                <div class="footer"></div>
        </div>
 </div>
 <!-- -->
 </body>
 </html>
diff --git a/frontend/gamma/js/Clipperz/Async.js b/frontend/gamma/js/Clipperz/Async.js
index 7c9d783..97d8ecf 100644
--- a/frontend/gamma/js/Clipperz/Async.js
+++ b/frontend/gamma/js/Clipperz/Async.js
@@ -1,704 +1,711 @@
 /*
 Copyright 2008-2011 Clipperz Srl
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 * Clipperz Community Edition is free software: you can redistribute
  it and/or modify it under the terms of the GNU Affero General Public
  License as published by the Free Software Foundation, either version
  3 of the License, or (at your option) any later version.
 * Clipperz Community Edition is distributed in the hope that it will
  be useful, but WITHOUT ANY WARRANTY; without even the implied
  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Affero General Public License for more details.
 * You should have received a copy of the GNU Affero General Public
  License along with Clipperz Community Edition.  If not, see
  <http://www.gnu.org/licenses/>.
 */
 //Clipperz.Async = MochiKit.Async;
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.Async) == 'undefined') { Clipperz.Async = {}; }
 Clipperz.Async.VERSION = "0.1";
 Clipperz.Async.NAME = "Clipperz.Async";
 Clipperz.Async.Deferred = function(aName, args) {
        args = args || {};
        Clipperz.Async.Deferred.superclass.constructor.call(this, args.canceller);
        this._args = args;
        this._name = aName || "Anonymous deferred";
        this._count = 0;
        this._shouldTrace = ((CLIPPERZ_DEFERRED_TRACING_ENABLED === true) || (args.trace === true));
        this._vars = null;
        return this;
 }
 //=============================================================================
 Clipperz.Base.extend(Clipperz.Async.Deferred, MochiKit.Async.Deferred, {
        'name': function () {
                return this._name;
        },
        'args': function () {
                return this._args;
        },
        //-----------------------------------------------------------------------------
        'callback': function (aValue) {
                if (this._shouldTrace) {
-                        Clipperz.log("CALLBACK " + this._name, aValue);
+                        //Clipperz.log("CALLBACK " + this._name, aValue);
+                        console.log("CALLBACK " + this._name, aValue);
                }
                if (this.chained == false) {
                        var message;
                        
                        message = "ERROR [" + this._name + "]";
                        this.addErrback(function(aResult) {
                                if (! (aResult instanceof MochiKit.Async.CancelledError)) {
                                        Clipperz.log(message, aResult);
                                }
                                return aResult;
                        });
                        if (this._shouldTrace) {
                                var resultMessage;
                                resultMessage = "RESULT   " + this._name + " <==";
        //                      this.addCallback(function(aResult) {
                                Clipperz.Async.Deferred.superclass.addCallback.call(this, function(aResult) {
-                                        Clipperz.log(resultMessage, aResult);
+                                        //Clipperz.log(resultMessage, aResult);
+                                        console.log(resultMessage, aResult);
                                        return aResult;
                                });
                        }
                }
                if (CLIPPERZ_DEFERRED_CALL_LOGGING_ENABLED === true) {
                        Clipperz.log("callback " + this._name, this);
                }
                return Clipperz.Async.Deferred.superclass.callback.apply(this, arguments);
        },
        //-----------------------------------------------------------------------------
        'addCallback': function () {
                var message;
                
                if (this._shouldTrace) {
                        this._count ++;
                        message = "[" + this._count + "] " + this._name + " ";
        //              this.addBoth(function(aResult) {Clipperz.log(message + "-->", aResult); return aResult;});
                        this.addCallbacks(
-                                function(aResult) {Clipperz.log("-OK- " + message + "-->"/*, aResult*/); return aResult;},
+                                //function(aResult) {Clipperz.log("-OK- " + message + "-->"/*, aResult*/); return aResult;},
-                                function(aResult) {Clipperz.log("FAIL " + message + "-->"/*, aResult*/); return aResult;}
+                                function(aResult) {console.log("-OK- " + message + "-->"/*, aResult*/); return aResult;},
+                                //function(aResult) {Clipperz.log("FAIL " + message + "-->"/*, aResult*/); return aResult;}
+                                function(aResult) {console.log("FAIL " + message + "-->"/*, aResult*/); return aResult;}
                        );
                }
                Clipperz.Async.Deferred.superclass.addCallback.apply(this, arguments);
                if (this._shouldTrace) {
        //              this.addBoth(function(aResult) {Clipperz.log(message + "<--", aResult); return aResult;});
                        this.addCallbacks(
-                                function(aResult) {Clipperz.log("-OK- " + message + "<--", aResult); return aResult;},
+                                //function(aResult) {Clipperz.log("-OK- " + message + "<--", aResult); return aResult;},
-                                function(aResult) {Clipperz.log("FAIL " + message + "<--", aResult); return aResult;}
+                                function(aResult) {console.log("-OK- " + message + "<--", aResult); return aResult;},
+                                //function(aResult) {Clipperz.log("FAIL " + message + "<--", aResult); return aResult;}
+                                function(aResult) {console.log("FAIL " + message + "<--", aResult); return aResult;}
                        );
                }
        },
        //=============================================================================
        'addCallbackPass': function() {
                var passFunction;
                passFunction = MochiKit.Base.partial.apply(null, arguments);
                this.addCallback(function() {
                        var result;
                        result = arguments[arguments.length -1];
                        passFunction();
                        return result;
                });
        },
        //-----------------------------------------------------------------------------
        'addErrbackPass': function() {
                var passFunction;
                passFunction = MochiKit.Base.partial.apply(null, arguments);
                this.addErrback(function() {
                        var result;
                        result = arguments[arguments.length -1];
                        passFunction();
                        return result;
                });
        },
        //-----------------------------------------------------------------------------
        'addBothPass': function() {
                var passFunction;
                passFunction = MochiKit.Base.partial.apply(null, arguments);
                this.addBoth(function() {
                        var result;
                        result = arguments[arguments.length -1];
                        passFunction();
                        return result;
                });
        },
        //-----------------------------------------------------------------------------
        'addIf': function (aThenBlock, anElseBlock) {
                this.addCallback(MochiKit.Base.bind(function (aValue) {
                        var deferredResult;
                        if (!MochiKit.Base.isUndefinedOrNull(aValue) && aValue) {
                                deferredResult = Clipperz.Async.callbacks(this._name + " <then>", aThenBlock, null, aValue);
                        } else {
                                deferredResult = Clipperz.Async.callbacks(this._name + " <else>", anElseBlock, null, aValue);
                        }
                        
                        return deferredResult;
                }))
        },
        //-----------------------------------------------------------------------------
        'addMethod': function () {
                this.addCallback(MochiKit.Base.method.apply(this, arguments));
        },
        //-----------------------------------------------------------------------------
        'addMethodcaller': function () {
                this.addCallback(MochiKit.Base.methodcaller.apply(this, arguments));
        },
        //=============================================================================
        'addLog': function (aLog) {
                if (CLIPPERZ_DEFERRED_LOGGING_ENABLED) {
                        this.addBothPass(function(res) {Clipperz.log(aLog + " ", res);});
        //              this.addBothPass(function(res) {console.log(aLog + " ", res);});
                }
        },
        //=============================================================================
        
        'acquireLock': function (aLock) {
        //      this.addCallback(function (aResult) {
        //              return Clipperz.Async.callbacks("Clipperz.Async.acquireLock", [
        //                      MochiKit.Base.method(aLock, 'acquire'),
        //                      MochiKit.Base.partial(MochiKit.Async.succeed, aResult)
        //              ], {trace:false});
        //      });
                this.addCallback(MochiKit.Base.method(aLock, 'acquire'));
        },
        'releaseLock': function (aLock) {
        //      this.addCallback(function (aResult) {
        //              return Clipperz.Async.callbacks("Clipperz.Async.release <ok>", [
        //                      MochiKit.Base.method(aLock, 'release'),
        //                      MochiKit.Base.partial(MochiKit.Async.succeed, aResult)
        //              ], {trace:false});
        //      });
        //      this.addErrback(function (aResult) {
 ///console.log("releaseLock.addErrback:", aResult);
        //              return Clipperz.Async.callbacks("Clipperz.Async.release <fail>", [
        //                      MochiKit.Base.method(aLock, 'release'),
        //                      MochiKit.Base.partial(MochiKit.Async.fail, aResult)
        //              ], {trace:false});
        //      });
                
        //      this.addBothPass(MochiKit.Base.method(aLock, 'release'));
                this.addCallbackPass(MochiKit.Base.method(aLock, 'release'));
                this.addErrback(function (anError) {
                        aLock.release();
                        return anError;
                });
        },
        //=============================================================================
        'collectResults': function (someRequests) {
                this.addCallback(Clipperz.Async.collectResults(this._name + " <collect results>", someRequests, this._args));
        },
        'addCallbackList': function (aRequestList) {
                this.addCallback(Clipperz.Async.callbacks, this._name + " <callback list>", aRequestList, this._args);
        },
        //=============================================================================
        'vars': function () {
                if (this._vars == null) {
                        this._vars = {}
                }
                
                return this._vars;
        },
        'setValue': function (aKey) {
                this.addCallback(MochiKit.Base.bind(function (aValue) {
                        this.vars()[aKey] = aValue;
                        return aValue;
                }, this));
        },
        
        'getValue': function (aKey) {
                this.addCallback(MochiKit.Base.bind(function () {
                        return this.vars()[aKey];
                }, this));
        },
        //=============================================================================
        
        __syntaxFix__: "syntax fix"
 });
 //#############################################################################
 Clipperz.Async.DeferredSynchronizer = function(aName, someMethods) {
        this._name = aName || "Anonymous deferred Synchronizer";
        this._methods  = someMethods;
                this._numberOfMethodsDone= 0;
        this._methodResults = [];
        this._result = new Clipperz.Async.Deferred("Clipperz.Async.DeferredSynchronizer # " + this.name(), {trace:false});
        this._result.addMethod(this, 'methodResults');
        this._result.addCallback(function(someResults) {
                        varcancels;
                var errors;
                var result;
                cancels = MochiKit.Base.filter(function(aResult) { return (aResult instanceof MochiKit.Async.CancelledError)}, someResults);
                
                if (cancels.length == 0) {
                        errors = MochiKit.Base.filter(function(aResult) { return (aResult instanceof Error)}, someResults);
                
                        if (errors.length == 0) {
        //                      result = MochiKit.Async.succeed(someResults);
                                result = someResults;
                        } else {
                                result = MochiKit.Async.fail(someResults);
                        }
                } else {
                        result = MochiKit.Async.fail(cancels[0]);
                }
                return result;
        }/*, this._methodResults */);
        
        return this;
 }
 MochiKit.Base.update(Clipperz.Async.DeferredSynchronizer.prototype, {
        //-----------------------------------------------------------------------------
        'name': function() {
                return this._name;
        },
        //-----------------------------------------------------------------------------
        'methods': function() {
                return this._methods;
        },
        
        'methodResults': function() {
                return this._methodResults;
        },
        //-----------------------------------------------------------------------------
        'result': function() {
                return this._result;
        },
        //-----------------------------------------------------------------------------
        'numberOfMethodsDone':function() {
                return this._numberOfMethodsDone;
        },
        'incrementNumberOfMethodsDone': function() {
                this._numberOfMethodsDone ++;
        },
        //-----------------------------------------------------------------------------
        
        'run': function(args, aValue) {
                var deferredResults;
                var i, c;
                
                deferredResults = [];
                args = args || {};
                c = this.methods().length;
                for (i=0; i<c; i++) {
                        var deferredResult;
                                varmethodCalls;
                        var ii, cc;
 //console.log("TYPEOF", typeof(this.methods()[i]));
                        if (typeof(this.methods()[i]) == 'function') {
                                methodCalls = [ this.methods()[i] ];
                        } else {
                                methodCalls = this.methods()[i];
                        }
                        
                        cc = methodCalls.length;
                        deferredResult = new Clipperz.Async.Deferred("Clipperz.Async.DeferredSynchronizer.run => " + this.name() + "[" + i + "]", args);
                        for (ii=0; ii<cc; ii++) {
                                deferredResult.addCallback(methodCalls[ii]);
                        }
                        deferredResult.addBoth(MochiKit.Base.method(this, 'handleMethodCallDone', i));
                        deferredResults.push(deferredResult);
                }
                
                for (i=0; i<c; i++) {
                        deferredResults[i].callback(aValue);
                }
                
                return this.result();
        },
        
        //-----------------------------------------------------------------------------
        'handleMethodCallDone': function(anIndexValue, aResult) {
                this.incrementNumberOfMethodsDone();
                this.methodResults()[anIndexValue] = aResult;
                
                if (this.numberOfMethodsDone() < this.methods().length) {
                                //nothing to do here other than possibly log something
                } else if (this.numberOfMethodsDone() == this.methods().length) {
                        this.result().callback();
                } else if (this.numberOfMethodsDone() > this.methods().length) {
+                        alert("Clipperz.Async.Deferred.handleMethodCallDone -> WTF!");
                                //WTF!!! :(
                }
                
        },
        //-----------------------------------------------------------------------------
        __syntaxFix__: "syntax fix"
 });
 //#############################################################################
 MochiKit.Base.update(Clipperz.Async, {
        'callbacks': function (aName, someFunctions, someArguments, aCallbackValue) {
                var deferredResult;
                var i, c;
                
                deferredResult = new Clipperz.Async.Deferred(aName, someArguments);
                c = someFunctions.length;
                for (i=0; i<c; i++) {
                        deferredResult.addCallback(someFunctions[i]);
                }
                deferredResult.callback(aCallbackValue);
                return deferredResult;
        },
        //-------------------------------------------------------------------------
        'forkAndJoin': function (aName, someMethods, args) {
                return MochiKit.Base.partial(function (aName, someMethods, args, aValue) {
                        var synchronizer;
                                varresult;
                
                        args = args || {};
                        synchronizer = new Clipperz.Async.DeferredSynchronizer(aName, someMethods);
                        result = synchronizer.run(args, aValue);
                
                        return result;
                }, aName, someMethods, args);
        },
        
        //-------------------------------------------------------------------------
        'collectResults': function(aName, someRequests, args) {
                return MochiKit.Base.partial(function(aName, someRequests, args, aValue) {
                        var deferredResult;
                        var requestKeys;
                        var methods;
                        requestKeys = MochiKit.Base.keys(someRequests);
                        methods = MochiKit.Base.values(someRequests);
                        deferredResult = new Clipperz.Async.Deferred(aName, args);
                        deferredResult.addCallback(Clipperz.Async.forkAndJoin(aName + " [inner forkAndJoin]", methods, args));
                        deferredResult.addBoth(function(someResults) {
                                var returnFunction;
                                var results;
                                var i,c;
                                var result;
                                if (someResults instanceof MochiKit.Async.CancelledError) {
                                        returnFunction = MochiKit.Async.fail;
                                        result = someResults;
                                } else {
                                        if (someResults instanceof Error) {
                                                returnFunction = MochiKit.Async.fail;
                                                results = someResults['message'];
                                        } else {
                                                returnFunction = MochiKit.Async.succeed;
                                                results = someResults;
                                        }
                                        result = {};
                        
                                        c = requestKeys.length;
                                        for (i=0; i<c; i++) {
                                                result[requestKeys[i]] = results[i];
                                        }
                                } 
                                return returnFunction.call(null, result);
                        });
                        deferredResult.callback(aValue);
                
                        return deferredResult;
                }, aName, someRequests, args);
        },
        //-------------------------------------------------------------------------
        'collectAll': function (someDeferredObjects) {
                var deferredResult;
                
                deferredResult = new MochiKit.Async.DeferredList(someDeferredObjects, false, false, false);
                deferredResult.addCallback(function (aResultList) {
                        return MochiKit.Base.map(function (aResult) {
                                if (aResult[0]) {
                                        return aResult[1];
                        } else {
                                        throw aResult[1];
                                        }
                        }, aResultList);
                });
                
                return deferredResult;
        },
        //-------------------------------------------------------------------------
        'setItem': function (anObject, aKey, aValue) {
                anObject[aKey] = aValue;
                        
                return anObject;
        },
        'setItemOnObject': function (aKey, aValue, anObject) {
                anObject[aKey] = aValue;
                        
                return anObject;
        },
        'setDeferredItemOnObject': function (aKey, aDeferredFunction, anObject) {
                return Clipperz.Async.callbacks("Clipperz.Async.setDeferredItemOnObject", [
                        aDeferredFunction,
                        MochiKit.Base.partial(Clipperz.Async.setItem, anObject, aKey)
                ], {trace:false}, anObject);
        },
        //-------------------------------------------------------------------------
        'deferredIf': function (aName, aThenBlock, anElseBlock) {
                return function (aValue) {
                        var deferredResult;
                        if (!MochiKit.Base.isUndefinedOrNull(aValue) && aValue) {
                                deferredResult = Clipperz.Async.callbacks(aName + " <then>", aThenBlock, null, aValue);
                        } else {
                                deferredResult = Clipperz.Async.callbacks(aName + " <else>", anElseBlock, null, aValue);
                        }
                        
                        return deferredResult;
                }
        },
        //-------------------------------------------------------------------------
        'log': function(aMessage, aResult) {
                if (CLIPPERZ_DEFERRED_LOGGING_ENABLED) {
                        Clipperz.log(aMessage + " ", aResult);
                }
                
                return aResult;
        },
        
        //=========================================================================
        'deferredCompare': function (aComparator, aDeferred, bDeferred) {
                var deferredResult;
                deferredResult = new Clipperz.Async.Deferred("Clipperz.Async.deferredCompare", {trace:false});
                deferredResult.addCallback(Clipperz.Async.collectAll, [aDeferred, bDeferred]);
                deferredResult.addCallback(function (someResults) {
                        var result;
                        if (aComparator(someResults[0], someResults[1]) > 0) {
                                result = MochiKit.Async.succeed();
                        } else {
                                result = MochiKit.Async.fail();
                        };
                        return result;
                });
                deferredResult.callback();
                
                return deferredResult;
        },
        //-------------------------------------------------------------------------
        'insertIntoSortedArray': function (anObject, aDeferredComparator, aSortedResult) {
                var deferredResult;
                var i, c;
                if (aSortedResult.length == 0) {
                        deferredResult = MochiKit.Async.succeed([anObject]);
                } else {
                        deferredResult = new Clipperz.Async.Deferred("Clipperz.Async.insertIntoSortedArray", {trace:false});
                        c = aSortedResult.length + 1;
                        for (i=0; i<c; i++) {
                                deferredResult.addCallback(function (aDeferredComparator, aObject, bObject, aContext) {
                                        var innerDeferredResult;
                                        
                                        innerDeferredResult = new Clipperz.Async.Deferred("Clipperz.Async.insertIntoSortedArray <inner compare>", {trace:false});
                                        innerDeferredResult.addCallback(aDeferredComparator, aObject, bObject);
                                        innerDeferredResult.addErrback(MochiKit.Async.fail, aContext);
                                        innerDeferredResult.callback();
                                        
                                        return innerDeferredResult;
                                }, aDeferredComparator, anObject, aSortedResult[i], i);
                        }
                        deferredResult.addMethod(aSortedResult, 'push', anObject);
                        deferredResult.addErrback(function (anError) {
                                aSortedResult.splice(anError.message, 0, anObject);
                        })
                        deferredResult.addBoth(MochiKit.Async.succeed, aSortedResult);
                        deferredResult.callback();
                }
                
                return deferredResult;
        },
        
        //-------------------------------------------------------------------------
        'deferredSort': function (aDeferredComparator, someObjects) {
                var deferredResult;
                var i, c;
                                
                deferredResult = new Clipperz.Async.Deferred("Clipperz.Async.deferredSort", {trace:false});
                c = someObjects.length;
                for (i=0; i<c; i++) {
                        deferredResult.addCallback(Clipperz.Async.insertIntoSortedArray, someObjects[i], aDeferredComparator);
                        if ((i % 50) == 0) {
        //console.log("######### sort wait ##########");
                                deferredResult.addCallback(MochiKit.Async.wait, 0.5);
                        }
                        }       
                deferredResult.callback([]);
                return deferredResult;
        },
        //=========================================================================
        'deferredFilter': function (aFunction, someObjects) {
                        vardeferredResult;
                        vari, c;
                deferredResult = new Clipperz.Async.Deferred("Clipperz.Async.deferredFilter", {trace:false});
                c = someObjects.length;
                for (i=0; i<c; i++) {
                        deferredResult.addCallback(function (aFunction, anObject, anIndex, aResult) {
                                var innerDeferredResult;
                                
                                innerDeferredResult = new Clipperz.Async.Deferred("Clipperz.Async.deferredFilter <inner - " + anIndex + ">", {trace:false});
                                innerDeferredResult.addCallback(aFunction, anObject);
                                innerDeferredResult.addCallback(function (aFilterResult) {
                                        if (aFilterResult) {
                                                aResult.push(anObject);
                                        };
                                });
                                innerDeferredResult.addBoth(MochiKit.Async.succeed, aResult);
                                innerDeferredResult.callback();
                                return innerDeferredResult;
                        }, aFunction, someObjects[i], i);
                }
                deferredResult.callback([]);
                
                return deferredResult;
        },
        
        'forEach': function (aFunction) {
                return MochiKit.Base.partial(function (aFunction, anIterable) {
                        MochiKit.Iter.forEach(anIterable, aFunction);
                }, aFunction);
        },
        //=========================================================================
        'or': function (someValues) {
                return Clipperz.Async.callbacks("Clipperz.Async.or", [
                        MochiKit.Base.values,
                        MochiKit.Base.flattenArguments,
 //function (aValue) { console.log("Record.hasAnyCleanTextData - flatten", aValue); return aValue; },
                        function(someInnerValues) {
                                return MochiKit.Iter.some(someInnerValues, MochiKit.Base.operator.identity);
                        }
                ], {trace:false}, someValues);
        },
        //=========================================================================
        'clearResult': function () {},
        
        //=========================================================================
        __syntaxFix__: "syntax fix"
 });
 //#############################################################################
 CLIPPERZ_DEFERRED_LOGGING_ENABLED = true;
 CLIPPERZ_DEFERRED_TRACING_ENABLED = false;
 CLIPPERZ_DEFERRED_CALL_LOGGING_ENABLED = false;
diff --git a/frontend/gamma/js/Clipperz/PM/Proxy.js b/frontend/gamma/js/Clipperz/PM/Proxy.js
index 190bffd..9817eac 100644
--- a/frontend/gamma/js/Clipperz/PM/Proxy.js
+++ b/frontend/gamma/js/Clipperz/PM/Proxy.js
@@ -1,169 +1,169 @@
 /*
 Copyright 2008-2011 Clipperz Srl
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 * Clipperz Community Edition is free software: you can redistribute
  it and/or modify it under the terms of the GNU Affero General Public
  License as published by the Free Software Foundation, either version
  3 of the License, or (at your option) any later version.
 * Clipperz Community Edition is distributed in the hope that it will
  be useful, but WITHOUT ANY WARRANTY; without even the implied
  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Affero General Public License for more details.
 * You should have received a copy of the GNU Affero General Public
  License along with Clipperz Community Edition.  If not, see
  <http://www.gnu.org/licenses/>.
 */
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 //=============================================================================
 Clipperz.PM.Proxy = function(args) {
        args = args || {};
        this._shouldPayTolls = args.shouldPayTolls || false;
        this._tolls = {
                        'CONNECT':[],
                        'REGISTER':[],
                        'MESSAGE':[]
        };
        if (args.isDefault === true) {
                Clipperz.PM.Proxy.defaultProxy = this;
        }
        return this;
 }
 Clipperz.PM.Proxy.prototype = MochiKit.Base.update(null, {
        'toString': function() {
                return "Clipperz.PM.Proxy";
        },
        //=========================================================================
        'shouldPayTolls': function() {
                return this._shouldPayTolls;
        },
        //-------------------------------------------------------------------------
        'tolls': function() {
                return this._tolls;
        },
        //-------------------------------------------------------------------------
        'payToll': function(aRequestType, someParameters) {
                        vardeferredResult;
 //console.log(">>> Proxy.payToll", aRequestType, someParameters);
                if (this.shouldPayTolls()) {
                        deferredResult = new Clipperz.Async.Deferred("Proxy.payToll", {trace:false});
                        if (this.tolls()[aRequestType].length == 0) {
                                deferredResult.addMethod(this, 'sendMessage', 'knock', {requestType:aRequestType});
                                deferredResult.addMethod(this, 'setTollCallback');
                        }
                        deferredResult.addMethod(this.tolls()[aRequestType], 'pop');
                        deferredResult.addCallback(MochiKit.Base.methodcaller('deferredPay'));
                        deferredResult.addCallback(function(aToll) {
                                var result;
                        
                                result = {
                                        parameters: someParameters,
                                        toll: aToll
                                }
                                
                                return result;
                        });
                
                        deferredResult.callback();
                } else {
                        deferredResult = MochiKit.Async.succeed({parameters:someParameters});
                }
 //console.log("<<< Proxy.payToll");
                return deferredResult;
        },
        //-------------------------------------------------------------------------
        'addToll': function(aToll) {
 //console.log(">>> Proxy.addToll", aToll);
                this.tolls()[aToll.requestType()].push(aToll);
 //console.log("<<< Proxy.addToll");
        },
        //=========================================================================
        'setTollCallback': function(someParameters) {
 //console.log(">>> Proxy.setTollCallback", someParameters);
                if (typeof(someParameters['toll']) != 'undefined') {
 //console.log("added a new toll", someParameters['toll']);
                        this.addToll(new Clipperz.PM.Toll(someParameters['toll']));
                }
 //console.log("<<< Proxy.setTallCallback", someParameters['result']);
                return someParameters['result'];
        },
        //=========================================================================
        'registration': function (someParameters) {
                return this.processMessage('registration', someParameters, 'REGISTER');
        },
        'handshake': function (someParameters) {
                return this.processMessage('handshake', someParameters, 'CONNECT');
        },
        'message': function (someParameters) {
                return this.processMessage('message', someParameters, 'MESSAGE');
        },
        'logout': function (someParameters) {
                return this.processMessage('logout', someParameters, 'MESSAGE');
        },
        //=========================================================================
        'processMessage': function (aFunctionName, someParameters, aRequestType) {
                        vardeferredResult;
-                deferredResult = new Clipperz.Async.Deferred("Proxy.processMessage", {trace:false});
+                deferredResult = new Clipperz.Async.Deferred("Proxy.processMessage", {trace:true});
                deferredResult.addMethod(this, 'payToll', aRequestType);
                deferredResult.addMethod(this, 'sendMessage', aFunctionName);
                deferredResult.addMethod(this, 'setTollCallback');
                deferredResult.callback(someParameters);
                
                        return deferredResult;  
        },
        //=========================================================================
        'sendMessage': function () {
                        throw Clipperz.Base.exception.AbstractMethod;   
        },
        //=========================================================================
        'isReadOnly': function () {
                return false;
        },
        //=========================================================================
        __syntaxFix__: "syntax fix"
        
 });
author	Giulio Cesare Solaroli <giulio.cesare@clipperz.com>	2011-10-23 17:36:57 (UTC)
committer	Giulio Cesare Solaroli <giulio.cesare@clipperz.com>	2011-10-23 17:36:57 (UTC)
commit	67455b069c4c9ec493f9cef76017e172a430a7d4 (patch) (unidiff)
tree	0b287debfeeb0819b3df9dd02860cd84103e25b3 /frontend/gamma
parent	b312e037ebba7c94abea9661bcf62c52b7d73fbf (diff)
download	clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.zip clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.tar.gz clipperz-67455b069c4c9ec493f9cef76017e172a430a7d4.tar.bz2