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.

6 files changed, 26 insertions, 272 deletions

diff --git a/frontend/beta/js/Clipperz/PM/DataModel/Record.js b/frontend/beta/js/Clipperz/PM/DataModel/Record.js
index 270f2ae..ffb45de 100644
--- a/frontend/beta/js/Clipperz/PM/DataModel/Record.js
+++ b/frontend/beta/js/Clipperz/PM/DataModel/Record.js
@@ -186,204 +186,209 @@ Clipperz.PM.DataModel.Record.prototype = MochiKit.Base.update(null, {
 		return Clipperz.Base.serializeJSON(result);
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'shouldLoadData': function() {
 		return this._shouldLoadData;
 	},
 
 	'setShouldLoadData': function(aValue) {
 		this._shouldLoadData = aValue;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'shouldDecryptData': function() {
 		return this._shouldDecryptData;
 	},
 
 	'setShouldDecryptData': function(aValue) {
 		this._shouldDecryptData = aValue;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'shouldProcessData': function() {
 		return this._shouldProcessData;
 	},
 	
 	'setShouldProcessData': function(aValue) {
 		this._shouldProcessData = aValue;
 	},
 
 	//-------------------------------------------------------------------------
 	
 	'loadData': function() {
 		var result;
 		
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.loadData - this: " + this);
 		if (this.shouldLoadData()) {
 			var deferredResult;
 		
 			deferredResult = new MochiKit.Async.Deferred();
 			deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'loadingRecordData');
 			deferredResult.addCallback(MochiKit.Base.method(this.user().connection(), 'message'), 'getRecordDetail', {reference: this.reference()});
 			deferredResult.addCallback(MochiKit.Base.method(this,'setServerData'));
 			deferredResult.callback();
 			result = deferredResult;
 		} else {
 			result = MochiKit.Async.succeed(this.serverData());
 		}
 //MochiKit.Logging.logDebug("<<< [" + (new Date()).valueOf() + "] Record.loadData");
 
 		return result;
 	},
 
 	//-------------------------------------------------------------------------
 	
 	'decryptData': function(anEncryptedData) {
 		var result;
 		
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.decryptData - this: " + this + " (" + anEncryptedData + ")");
 		if (this.shouldDecryptData()) {
 			var deferredResult;
 		
 			deferredResult = new MochiKit.Async.Deferred();
 			deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'decryptingRecordData');
 			deferredResult.addCallback(Clipperz.PM.Crypto.deferredDecrypt, this.key(), anEncryptedData['data'], anEncryptedData['version']);
 			deferredResult.addCallback(function(anEncryptedData, someDecryptedValues) {
 				var	result;
 
 				result = anEncryptedData;
 				result['data'] = someDecryptedValues;
 			
 				return result;
 			}, anEncryptedData);
 			deferredResult.addCallback(MochiKit.Base.method(this, 'setDecryptedData'));
 			deferredResult.callback();
 
 			result = deferredResult;
 		} else {
 			result = MochiKit.Async.succeed(this.decryptedData());
 		}
 //MochiKit.Logging.logDebug("<<< [" + (new Date()).valueOf() + "] Record.decryptData");
 
 		return result;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'processData': function(someValues) {
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.processData");
 //MochiKit.Logging.logDebug("--- Record.processData: " + Clipperz.Base.serializeJSON(someValues));
 		if (this.shouldProcessData()) {
 			var currentVersionParameters;
 
+console.log("Record.processData", someValues);
 			this.processDataToExtractLegacyValues(someValues['data']);
 
 			if (typeof(someValues['data']['notes']) != 'undefined') {
 				this.setNotes(someValues['data']['notes']);
 			}
+
 			if (someValues['data']['currentVersionKey'] != null) {
 				this.setCurrentVersionKey(someValues['data']['currentVersionKey']);
 			} else {
 				this.setCurrentVersionKey(this.key());
 			}
 
-			currentVersionParameters = someValues['currentVersion'];
+//			currentVersionParameters = someValues['currentVersion'];
+			currentVersionParameters = someValues['versions'][someValues['currentVersion']];
+console.log("Record.processData - this.currentVersionKey()", this.currentVersionKey());
+console.log("Record.processData - currentVersionParameters", currentVersionParameters);
 			currentVersionParameters['key'] = this.currentVersionKey();
 			this.setCurrentVersion(new Clipperz.PM.DataModel.RecordVersion(this, currentVersionParameters));
 			
 			if (someValues['data']['directLogins'] != null) {
 				var	directLoginReference;
 			
 				for (directLoginReference in someValues['data']['directLogins']) {
 					var directLogin;
 					var directLoginParameters;
 				
 					directLoginParameters = someValues['data']['directLogins'][directLoginReference];
 					directLoginParameters.record = this;
 					directLoginParameters.reference = directLoginReference;
 				
 					directLogin = new Clipperz.PM.DataModel.DirectLogin(directLoginParameters);
 					this.addDirectLogin(directLogin, true);
 				}
 			}
 			this.setShouldProcessData(false);
 		}
 		
 		Clipperz.NotificationCenter.notify(this, 'recordDataReady');
 //MochiKit.Logging.logDebug("<<< [" + (new Date()).valueOf() + "] Record.processData");
 //MochiKit.Logging.logDebug("<<< Record.processData");
 		
 		return this;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'processDataToExtractLegacyValues': function(someValues) {
 //MochiKit.Logging.logDebug(">>> Record.processDataToExtractLegacyValues");
 		if (someValues['data'] != null) {
 			this.setNotes(someValues['data']);
 		}
 
 		if (
 				(typeof(someValues['loginFormData']) != "undefined")
 			&&	(typeof(someValues['loginBindings'] != "undefined"))
 			&&	(someValues['loginFormData'] != "")
 			&&	(someValues['loginBindings'] != "")
 		) {
 			var	directLogin;
 
 			directLogin = new Clipperz.PM.DataModel.DirectLogin({
 				record:this,
 				label:this.label() + Clipperz.PM.Strings['newDirectLoginLabelSuffix'],
 				reference:Clipperz.Crypto.SHA.sha256(new Clipperz.ByteArray(this.label() +
 																			someValues['loginFormData'] +
 																			someValues['loginBindings'])).toHexString().substring(2),
 				formData:Clipperz.Base.evalJSON(someValues['loginFormData']),
 				legacyBindingData:Clipperz.Base.evalJSON(someValues['loginBindings']),
 				bookmarkletVersion:'0.1'
 			});
 			this.addDirectLogin(directLogin, true);
 		}
 //MochiKit.Logging.logDebug("<<< Record.processDataToExtractLegacyValues");
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'getReadyBeforeUpdatingVersionValues': function() {
 	},
 
 	//-------------------------------------------------------------------------
 	
 	'addNewField': function() {
 		var	newField;
 
 //MochiKit.Logging.logDebug(">>> Record.addNewField - " + this);
 		this.getReadyBeforeUpdatingVersionValues();
 		newField = this.currentVersion().addNewField();
 		Clipperz.NotificationCenter.notify(this, 'recordUpdated');
 //MochiKit.Logging.logDebug("<<< Record.addNewField");
 		
 		return newField;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'removeField': function(aField) {
 		this.getReadyBeforeUpdatingVersionValues();
 		this.currentVersion().removeField(aField);
 		Clipperz.NotificationCenter.notify(this, 'recordUpdated');
 	},
 
 	'removeEmptyFields': function() {
 		MochiKit.Iter.forEach(MochiKit.Base.values(this.currentVersion().fields()), MochiKit.Base.bind(function(aField) {
 			if (aField.isEmpty()) {
 				this.removeField(aField);
 //				this.currentVersion().removeField(aField);
 			}
 		}, this));
 	},
 	
 	//-------------------------------------------------------------------------
diff --git a/frontend/beta/js/Clipperz/PM/Proxy.js b/frontend/beta/js/Clipperz/PM/Proxy.js
index f476196..bec9195 100644
--- a/frontend/beta/js/Clipperz/PM/Proxy.js
+++ b/frontend/beta/js/Clipperz/PM/Proxy.js
@@ -23,148 +23,147 @@ refer to http://www.clipperz.com.
 
 */
 
 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) {
 		var	deferredResult;
 
 //console.log(">>> Proxy.payToll", aRequestType, someParameters);
 		if (this.shouldPayTolls()) {
 			deferredResult = new MochiKit.Async.Deferred();
 
 			if (this.tolls()[aRequestType].length == 0) {
 				deferredResult.addCallback(MochiKit.Base.method(this, 'sendMessage', 'knock', {requestType:aRequestType}));
 				deferredResult.addCallback(MochiKit.Base.method(this, 'setTollCallback'));
 			}
 			deferredResult.addCallback(MochiKit.Base.method(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'];
-		return someParameters;
+		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) {
 		var	deferredResult;
 
 		deferredResult = new MochiKit.Async.Deferred();
 		deferredResult.addCallback(MochiKit.Base.method(this, 'payToll', aRequestType));
 		deferredResult.addCallback(MochiKit.Base.method(this, 'sendMessage', aFunctionName));
 		deferredResult.addCallback(MochiKit.Base.method(this, 'setTollCallback'));
 		deferredResult.callback(someParameters);
 		
 		return deferredResult;		
 	},
 
 	//=========================================================================
 
 	'sendMessage': function () {
 		throw Clipperz.Base.exception.AbstractMethod;		
 	},
 
 	//=========================================================================
 
 	'isReadOnly': function () {
 		return false;
 	},
 
 	//=========================================================================
 	__syntaxFix__: "syntax fix"
 	
 });
diff --git a/frontend/beta/js/Clipperz/PM/Proxy/Proxy.PHP.js b/frontend/beta/js/Clipperz/PM/Proxy/Proxy.PHP.js
deleted file mode 100755
index 34a10c2..0000000
--- a/frontend/beta/js/Clipperz/PM/Proxy/Proxy.PHP.js
+++ b/dev/null
@@ -1,262 +0,0 @@
-/*
-
-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.PHP = function(args) {
-	Clipperz.PM.Proxy.PHP.superclass.constructor.call(this, args);
-/*
-	this._tolls = {
-		'CONNECT':	[],
-		'REGISTER':	[],
-		'MESSAGE':	[]
-	};
-*/	
-	return this;
-}
-
-YAHOO.extendX(Clipperz.PM.Proxy.PHP, Clipperz.PM.Proxy, {
-
-	'toString': function() {
-		return "Clipperz.PM.Proxy.PHP - " + this.args();
-	},
-
-	//=========================================================================
-/*
-	'tolls': function() {
-		return this._tolls;
-	},
-*/
-	//-------------------------------------------------------------------------
-/*
-	'payToll': function(aRequestType, someParameters) {
-		var	deferredResult;
-
-//MochiKit.Logging.logDebug(">>> Proxy.DWR.payToll: " + aRequestType);
-		if (this.tolls()[aRequestType].length > 0) {
-			deferredResult = MochiKit.Async.succeed(this.tolls()[aRequestType].pop());
-		} else {
-//MochiKit.Logging.logDebug("### " + aRequestType + " toll NOT immediately available; request queued.");
-			deferredResult = new MochiKit.Async.Deferred();
-			deferredResult.addCallback(function(someParameters) {
-				return new Clipperz.PM.Toll(someParameters['toll']);
-			})
-			com_clipperz_pm_Proxy.knock(Clipperz.Base.serializeJSON({requestType:aRequestType}), {
-				callback:MochiKit.Base.method(deferredResult, 'callback'),
-				errorHandler:MochiKit.Base.method(deferredResult, 'errback')
-			});
-		}
-		
-		deferredResult.addCallback(function(aToll) {
-			return aToll.deferredPay();
-		});
-		deferredResult.addCallback(function(someParameters, aToll) {
-			var result;
-			
-			result = {
-				parameters: someParameters,
-				toll: aToll
-			}
-			
-			return result;
-		}, someParameters);
-		
-		return deferredResult;
-	},
-*/
-	//-------------------------------------------------------------------------
-/*
-	'addToll': function(aToll) {
-		this.tolls()[aToll.requestType()].push(aToll);
-	},
-*/
-	//=========================================================================
-/*
-	'setTollCallback': function(someParameters) {
-//MochiKit.Logging.logDebug(">>> Proxy.DWR.setTollCallback");
-//MochiKit.Logging.logDebug("--- Proxy.DWR.setTollCallback - " + Clipperz.Base.serializeJSON(someParameters));
-		if (typeof(someParameters['toll']) != 'undefined') {
-			this.addToll(new Clipperz.PM.Toll(someParameters['toll']));
-		}
-		return someParameters['result'];
-	},
-*/
-	//=========================================================================
-
-	'registration': function(someParameters) {
-		return this.sendMessage('registration', someParameters, 'REGISTER');
-	},
-
-	//-------------------------------------------------------------------------
-
-	'handshake': function(someParameters) {
-/*
-		_s = "e8a2162f29aeaabb729f5625e9740edbf0cd80ac77c6b19ab951ed6c88443b8c";
-		_v = new Clipperz.Crypto.BigInt("955e2db0f7844aca372f5799e5f7e51b5866718493096908bd66abcf1d068108", 16);
-		_b = new Clipperz.Crypto.BigInt("5761e6c84d22ea3c5649de01702d60f674ccfe79238540eb34c61cd020230c53", 16);
-
-		_B = _v.add(Clipperz.Crypto.SRP.g().powerModule(_b, Clipperz.Crypto.SRP.n()));
-		_u = new Clipperz.Crypto.BigInt(Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(_B.asString(10))).toHexString(), 16);
-		_A = new Clipperz.Crypto.BigInt("3b3567ec33d73673552e960872eb154d091a2488915941038aef759236a27e64", 16);
-		_S = (_A.multiply(_v.powerModule(_u, Clipperz.Crypto.SRP.n()))).powerModule(_b, Clipperz.Crypto.SRP.n());
-		_K = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(_S.asString(10))).toHexString().slice(2);
-		_M1 = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(_A.asString(10) + _B.asString(10) + _K)).toHexString().slice(2);
-		_M2 = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(_A.asString(10) + _M1 + _K)).toHexString().slice(2);
-		
-//		MochiKit.Logging.logDebug("b = " + _b.asString(16));
-//		MochiKit.Logging.logDebug("v = " + _v.asString(16));
-		MochiKit.Logging.logDebug("B = " + _B.asString(16));
-		MochiKit.Logging.logDebug("u = " + _u.asString(16));
-		MochiKit.Logging.logDebug("S = " + _S.asString(16));
-		MochiKit.Logging.logDebug("K = " + _K);
-		MochiKit.Logging.logDebug("M1 = " + _M1);
-		MochiKit.Logging.logDebug("M2 = " + _M2);
-//		MochiKit.Logging.logDebug("someParameters.version: " + someParameters.version);
-*/		
-		return this.sendMessage('handshake', someParameters, 'CONNECT');
-	},
-
-	//-------------------------------------------------------------------------
-
-	'message': function(someParameters) {
-		return this.sendMessage('message', someParameters, 'MESSAGE');
-	},
-
-	//-------------------------------------------------------------------------
-
-	'logout': function(someParameters) {
-//MochiKit.Logging.logDebug("=== Proxy.DWR.logout");
-		return this.sendMessage('logout', someParameters, 'MESSAGE');
-	},
-
-	//=========================================================================
-
-	'sendMessage': function(aFunctionName, someParameters, aRequestType) {
-/*
-		var	deferredResult;
-		var proxy;
-		
-//MochiKit.Logging.logDebug(">>> Proxy.DWR.sendMessage - " + aFunctionName + " - " + aRequestType);
-		proxy = this;
-		
-		deferredResult = new MochiKit.Async.Deferred();
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.1 Proxy.DWR.sendMessage - 1: " + res); return res;});
-		deferredResult.addCallback(MochiKit.Base.method(proxy, 'payToll'), aRequestType);
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.2 Proxy.DWR.sendMessage - 2: " + Clipperz.Base.serializeJSON(res)); return res;});
-		deferredResult.addCallback(MochiKit.Base.method(proxy, 'sendRemoteMessage'), aFunctionName);
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.3 Proxy.DWR.sendMessage - 3: " + res); return res;});
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.3 Proxy.DWR.sendMessage - 3: " + Clipperz.Base.serializeJSON(res)); return res;});
-		deferredResult.callback(someParameters);
-		
-//MochiKit.Logging.logDebug("<<< Proxy.DWR.sendMessage");
-		return deferredResult;		
-*/
-
-//		return this.sendRemoteMessage(aFunctionName, someParameters);
-
-
-		var	deferredResult;
-		var proxy;
-
-		proxy = this;
-
-		deferredResult = new MochiKit.Async.Deferred();
-		deferredResult.addCallback(MochiKit.Base.method(proxy, 'sendRemoteMessage'), aFunctionName);
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.3 Proxy.PHP.sendMessage - 3: " + res); return res;});
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("x.3 Proxy.PHP.sendMessage - 3.1: " + Clipperz.Base.serializeJSON(res)); return res;});
-
-		deferredResult.callback(someParameters);
-
-		return deferredResult;
-	},
-
-	//=========================================================================
-	
-	'sendRemoteMessage': function(aFunctionName, someParameters) {
-/*
-		var	deferredResult;
-
-//MochiKit.Logging.logDebug(">>> Proxy.DWR.sendRemoteMessage('" + aFunctionName + "', " + Clipperz.Base.serializeJSON(someParameters) + ") - " + this);
-		deferredResult = new MochiKit.Async.Deferred();
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Proxy.DWR.sendRemoteMessage - 1: " + res); return res;});
-//		deferredResult.addCallback(MochiKit.Base.method(this, 'setTollCallback'));
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Proxy.DWR.sendRemoteMessage - 2: " + res); return res;});
-		
-		com_clipperz_pm_Proxy[aFunctionName](Clipperz.Base.serializeJSON(someParameters), {
-			callback:MochiKit.Base.method(deferredResult, 'callback'),
-			errorHandler:MochiKit.Base.method(deferredResult, 'errback')
-		});
-//MochiKit.Logging.logDebug("<<< Proxy.PHP.sendRemoteMessage - result: " + deferredResult);
-
-		return deferredResult;
-*/
-
-		var	deferredResult;
-		var parameters;
-		
-//MochiKit.Logging.logDebug(">>> Proxy.PHP.sendRemoteMessage('" + aFunctionName + "', " + Clipperz.Base.serializeJSON(someParameters) + ") - " + this);
-		parameters = {};
-		parameters['method'] = aFunctionName;
-//		parameters['version'] = someParameters['version'];
-//		parameters['message'] = someParameters['message'];
-		parameters['parameters'] = Clipperz.Base.serializeJSON(someParameters);
-//MochiKit.Logging.logDebug("--- Proxy.PHP.sendRemoteMessage('" + Clipperz.Base.serializeJSON(parameters) + ") - " + this);
-		deferredResult = new MochiKit.Async.Deferred();
-		deferredResult.addCallback(MochiKit.Async.doXHR, "./php/index.php", {
-			method:'POST',
-			sendContent:MochiKit.Base.queryString(parameters),
-			headers:{"Content-Type":"application/x-www-form-urlencoded"}
-		});
-//deferredResult.addCallback(function(res) {MochiKit.Logging.logDebug("Proxy.PHP.response - 2: " + res.responseText); return res;});
-//deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("Proxy.PHP.response - ERROR: " + res); return res;});
-		deferredResult.addCallback(MochiKit.Async.evalJSONRequest);
-		deferredResult.addCallback(function (someValues) {
-			if (someValues['result'] == 'EXCEPTION') {
-				throw someValues['message'];
-			}
-			return someValues;
-		})
-		deferredResult.callback();
-
-		return deferredResult;
-	},
-
-	//=========================================================================
-
-	'isReadOnly': function() {
-		return false;
-	},
-
-	//=========================================================================
-	__syntaxFix__: "syntax fix"
-	
-});
-
-//=============================================================================
-
-//Clipperz.PM.Proxy.defaultProxy = new Clipperz.PM.Proxy.PHP("Proxy.PHP - async test");
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,216 +1,222 @@
 /*
 
 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("FAIL " + message + "-->"/*, aResult*/); return aResult;}
+			//	function(aResult) {Clipperz.log("-OK- " + 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("FAIL " + message + "<--", aResult); return aResult;}
+			//	function(aResult) {Clipperz.log("-OK- " + 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) {
@@ -313,192 +319,193 @@ Clipperz.Async.DeferredSynchronizer = function(aName, someMethods) {
 				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;
 			var	methodCalls;
 			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;
 			var	result;
 		
 			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);
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
@@ -49,121 +49,121 @@ Clipperz.PM.Proxy = function(args) {
 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) {
 		var	deferredResult;
 
 //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) {
 		var	deferredResult;
 
-		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"
 	
 });