3 files changed, 24 insertions, 14 deletions

diff --git a/frontend/beta/js/Clipperz/PM/Connection.js b/frontend/beta/js/Clipperz/PM/Connection.js
index 85aea21..e81c7a6 100644
--- a/frontend/beta/js/Clipperz/PM/Connection.js
+++ b/frontend/beta/js/Clipperz/PM/Connection.js
@@ -203,197 +203,201 @@ Clipperz.PM.Connection.SRP['1.0'].prototype = MochiKit.Base.update(new Clipperz.
                         args.message = "completeRegistration";
 
                         return args;
                 }, parameters, this.user());
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.register - 6: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(Clipperz.PM.Proxy.defaultProxy, 'registration'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.register - 7: " + Clipperz.Base.serializeJSON(res)); return res;});
                 deferredResult.addCallback(MochiKit.Base.bind(function(res) {
                         this.user().setLock(res['lock']);
 
                         return res;
                 }, this));
                 deferredResult.callback(anInvitationCode);
 //MochiKit.Logging.logError("<<< Connection.register");
                 
                 return deferredResult;
         },
 
         //=========================================================================
 
         'login': function(isReconnecting) {
                         vardeferredResult;
                 
 //MochiKit.Logging.logDebug(">>> Connection.login: "/* + this*/);
 //MochiKit.Logging.logDebug("--- Connection.login - isReconnecting: " + (isReconnecting == true));
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.1 - Connection.login - 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_sendingCredentials');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.2 - Connection.login - 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(function(aConnection) {
                         var args;
                         
                         args = {};
                         args.message = 'connect';
                         args.version = aConnection.clipperz_pm_crypto_version();
                         args.parameters = {};
 //MochiKit.Logging.logDebug("=== Connection.login - username: " + aConnection.srpConnection().C());
                         args.parameters['C'] = aConnection.srpConnection().C();
                         args.parameters['A'] = aConnection.srpConnection().A().asString(16);
                         
                         if (isReconnecting == true) {
 //MochiKit.Logging.logDebug("--- Connection.login - reconnecting");
         //#                     args.parameters['reconnecting'] = "yes";
                                 args.parameters['reconnecting'] = aConnection.connectionId();
                         }
 //MochiKit.Logging.logDebug("--- Connection.login - args: " + Clipperz.Base.serializeJSON(args));
 //MochiKit.Logging.logDebug("--- Connection.login - srp.a: " + aConnection.srpConnection().a().asString(16));
 
                         return args;
                 });
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.3 - Connection.login - 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(Clipperz.PM.Proxy.defaultProxy, 'handshake'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.4 - Connection.login - 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_credentialVerification');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.5 - Connection.login - 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
 deferredResult.addErrback(MochiKit.Base.bind(function(res) {MochiKit.Logging.logDebug("ERROR - c: " + this.srpConnection().C() + " # version: " + this.clipperz_pm_crypto_version()); return res;}, this));
                 deferredResult.addCallback(MochiKit.Base.bind(function(someParameters) {
                         var args;
 
                         this.srpConnection().set_s(new Clipperz.Crypto.BigInt(someParameters['s'], 16));
                         this.srpConnection().set_B(new Clipperz.Crypto.BigInt(someParameters['B'], 16));
 
                         if (typeof(someParameters['oneTimePassword']) != 'undefined') {
                                 this.setOneTimePassword(someParameters['oneTimePassword']);
                         }
                         
                         args = {};
                         args.message = 'credentialCheck';
                         args.version = this.clipperz_pm_crypto_version();
                         args.parameters = {};
                         args.parameters['M1'] = this.srpConnection().M1();
 
                         return args;
                 }, this));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.6 - Connection.login - 6: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(Clipperz.PM.Proxy.defaultProxy, 'handshake'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.7 - Connection.login - 7: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
         //#     deferredResult.addCallback(MochiKit.Base.method(this, 'loginDone'));
                 deferredResult.addCallback(MochiKit.Base.bind(function(someParameters) {
                         var result;
                 
 //MochiKit.Logging.logDebug(">>> Connection.loginDone: " + this + " (M2: " + this.srpConnection().M2() + ")");
                         if (someParameters['M2'] == this.srpConnection().M2()) {
                                 result = new MochiKit.Async.Deferred();
                                 
 //MochiKit.Logging.logDebug("--- Connection.loginDone - someParameters: " + Clipperz.Base.serializeJSON(someParameters));
                                 this.setConnectionId(someParameters['connectionId']);
                                 this.user().setLoginInfo(someParameters['loginInfo']);
                                 this.user().setShouldDownloadOfflineCopy(someParameters['offlineCopyNeeded']);
-                                this.user().setLock(someParameters['lock']);
+
+                                if ((isReconnecting == true) && (this.user().lock() != someParameters['lock'])) {
+                                        throw Clipperz.PM.Connection.exception.StaleData;
+                                }
                         
                                 if (this.oneTimePassword() != null) {
                                         result.addCallback(MochiKit.Base.method(this.user().oneTimePasswordManager(), 'archiveOneTimePassword', this.oneTimePassword()));
                                 }
+
                                 result.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_loggedIn');
                                 result.addCallback(MochiKit.Async.succeed, someParameters);
                                 
                                 result.callback();
 //MochiKit.Logging.logDebug("--- Connection.loginDone - 1 - result: "/* + Clipperz.Base.serializeJSON(result)*/);
                         } else {
 //MochiKit.Logging.logDebug("--- Connection.loginDone - 2 - ERROR");
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 result = MochiKit.Async.fail(Clipperz.PM.Connection.exception.WrongChecksum);
                         }
 //MochiKit.Logging.logDebug("<<< Connection.loginDone - result: " + Clipperz.Base.serializeJSON(result));
 
                         return result;
                 }, this));
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.3.8 - Connection.login - 8: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.callback(this);
 //MochiKit.Logging.logDebug("<<< Connection.login");
                 
                 return deferredResult;
         },
 
         //=========================================================================
 
         'logout': function() {
                 var deferredResult;
 
 //MochiKit.Logging.logDebug(">>> Connection.logout: " + this);
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.logout - 1: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(Clipperz.PM.Proxy.defaultProxy, 'logout'), {});
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.logout - 2: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'resetSrpConnection'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.logout - 3: " + res); return res;});
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< Connection.logout");
                 
                 return deferredResult;
         },
         
         //=========================================================================
 
         'message': function(aMessageName, someParameters) {
                 var args;
                 var deferredResult;
                 
 //MochiKit.Logging.logDebug(">>> Connection.message: " + this);
                 args = {}
                 args['message'] = aMessageName;
                 args['srpSharedSecret'] = this.srpConnection().K();
         //      args['lock'] = this.user().lock();
 
                 if (someParameters != null) {
                         args['parameters'] = someParameters;
                 } else {
                         args['parameters'] = {};
                 } 
 //MochiKit.Logging.logDebug("--- Connection.message - args: " + Clipperz.Base.serializeJSON(args));
 
         //              deferredResult = new MochiKit.Async.Deferred();                 //### ?????????????
                 
                 return this.sendMessage(args);
         },
 
         //-------------------------------------------------------------------------
 
         'sendMessage': function(someArguments) {
                         vardeferredResult;
                 
 //MochiKit.Logging.logDebug(">>> Connection.sendMessage: " + this);
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.sendMessage - 1: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(Clipperz.PM.Proxy.defaultProxy, 'message'), someArguments);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.sendMessage - 2: " + res); return res;});
 
                 deferredResult.addCallback(MochiKit.Base.bind(function(res) {
                         if (typeof(res['lock']) != 'undefined') {
                                 this.user().setLock(res['lock']);
                         }
                         return res;
                 }, this));
 
                 deferredResult.addErrback(MochiKit.Base.method(this, 'messageExceptionHandler'), someArguments);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.sendMessage - 3: " + res); return res;});
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Connection.sendMessage - 3: " + Clipperz.Base.serializeJSON(res)); return res;});
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< Connection.sendMessage");
                 
                 return deferredResult
         },
         
         //-------------------------------------------------------------------------
 
         'messageExceptionHandler': function(anOriginalMessageArguments, anError) {
                 var result;
@@ -484,98 +488,99 @@ deferredResult.addErrback(MochiKit.Base.bind(function(res) {MochiKit.Logging.log
                         this._C = this.hash()(new Clipperz.ByteArray(this.user().username())).toHexString().substring(2);
                 }
                 
                 return this._C;
         },
 
         //-----------------------------------------------------------------------------
 
         'P': function() {
                 if (this._P == null) {
                         this._P = this.hash()(new Clipperz.ByteArray(this.user().passphrase() + this.user().username())).toHexString().substring(2);
                 }
                 
                 return this._P;
         },
 
         //-----------------------------------------------------------------------------
 
         'hash': function() {
                 return Clipperz.PM.Crypto.encryptingFunctions.versions['0.1'].hash;
         },
         
         //-----------------------------------------------------------------------------
 
         'srpConnection': function() {
                 if (this._srpConnection == null) {
                         this._srpConnection = new Clipperz.Crypto.SRP.Connection({ C:this.C(), P:this.P(), hash:this.hash() });
                 }
                 
                 return this._srpConnection;
         },
         
         'resetSrpConnection': function() {
                 this._C = null;
                 this._P = null;
                 this._srpConnection = null;
         },
         
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 
 });
 
 
 
 //-----------------------------------------------------------------------------
 //
         //      S R P [ 1 . 1 ]    C O N N E C T I O N   class
 //
 //-----------------------------------------------------------------------------
 
 Clipperz.PM.Connection.SRP['1.1'] = function (args) {
         args = args || {};
         Clipperz.PM.Connection.SRP['1.0'].call(this, args);
         
         return this;
 }
 
 Clipperz.PM.Connection.SRP['1.1'].prototype = MochiKit.Base.update(new Clipperz.PM.Connection.SRP['1.0'](), {
 
         'version': function() {
                 return '1.1';
         },
 
         //-----------------------------------------------------------------------------
 
         'C': function() {
                 if (this._C == null) {
                         this._C = this.hash()(new Clipperz.ByteArray(this.user().username() + this.user().passphrase())).toHexString().substring(2);
                 }
                 
                 return this._C;
         },
 
         //-----------------------------------------------------------------------------
 
         'P': function() {
                 if (this._P == null) {
                         this._P = this.hash()(new Clipperz.ByteArray(this.user().passphrase() + this.user().username())).toHexString().substring(2);
                 }
                 
                 return this._P;
         },
         
         //-----------------------------------------------------------------------------
 
         'hash': function() {
                 return Clipperz.PM.Crypto.encryptingFunctions.versions['0.2'].hash;
         },
 
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 
 });
 
 Clipperz.PM.Connection.exception = {
-        WrongChecksum: new MochiKit.Base.NamedError("Clipperz.ByteArray.exception.InvalidValue")
+        WrongChecksum: new MochiKit.Base.NamedError("Clipperz.ByteArray.exception.InvalidValue"),
+        StaleData: new MochiKit.Base.NamedError("Stale data")
 };
diff --git a/frontend/beta/js/Clipperz/PM/DataModel/Record.js b/frontend/beta/js/Clipperz/PM/DataModel/Record.js
index ffb45de..ecb6c37 100644
--- a/frontend/beta/js/Clipperz/PM/DataModel/Record.js
+++ b/frontend/beta/js/Clipperz/PM/DataModel/Record.js
@@ -546,197 +546,199 @@ console.log("Record.processData - currentVersionParameters", currentVersionParam
 
         //-------------------------------------------------------------------------
 
         'headerData': function() {
                 var result;
                 
                 result = {
                                 'label':        this.label(),
                                 'key':          this.key()
                 };
 
                 if (this.headerNotes() != null) {
                         result['headerNotes'] = this.headerNotes();
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
         
         'serializedData': function() {
                 var result;
                 var directLoginReference;
 
                 result = {};
                 result['currentVersionKey'] = this.currentVersion().key();
                 
                 result['directLogins'] = {};
                 for (directLoginReference in this.directLogins()) {
                         result['directLogins'][directLoginReference] = this.directLogins()[directLoginReference].serializedData();
                 }
                 result['notes'] = this.notes();
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'encryptedData': function() {
                 var deferredResult;
                         varresult;
                 
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.encryptedData");
                 result = {}
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 1");
                 deferredResult = new MochiKit.Async.Deferred();
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 2");
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Record.encryptedData - 1: " + res); return res;});
                 deferredResult.addCallback(function(aResult, aRecord) {
                         aResult['reference'] = aRecord.reference();
                         return aResult;
                 }, result, this);
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 3");
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Record.encryptedData - 2: " + res); return res;});
                 deferredResult.addCallback(Clipperz.PM.Crypto.deferredEncryptWithCurrentVersion, this.key(), this.serializedData());
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 4");
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Record.encryptedData - 3: " + res); return res;});
                 deferredResult.addCallback(function(aResult, res) {
                         aResult['data'] = res;
                         return aResult;
                 }, result);
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 5");
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Record.encryptedData - 4: " + res); return res;});
                 deferredResult.addCallback(function(aResult) {
                         aResult['version'] = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
                         return aResult;
                 }, result);
 //MochiKit.Logging.logDebug("--- Record.encryptedData - 6");
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Record.encryptedData - 5: " + res); return res;});
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< [" + (new Date()).valueOf() + "] Record.encryptedData");
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'syncDirectLoginReferenceValues': function() {
 //MochiKit.Logging.logDebug(">>> Record.syncDirectLoginReferenceValues");
                 MochiKit.Iter.forEach(MochiKit.Base.values(this.directLogins()), function(aDirectLogin) {
                         aDirectLogin.record().user().synchronizeDirectLogin(aDirectLogin);
                 });
 
                 MochiKit.Iter.forEach(this.removedDirectLogins(), function(aDirectLogin) {
                         aDirectLogin.record().user().removeDirectLogin(aDirectLogin);
                 });
                 
                 this.resetRemovedDirectLogins();
 //MochiKit.Logging.logDebug("<<< Record.syncDirectLoginReferenceValues");
         },
         
         //-------------------------------------------------------------------------
 
         'saveChanges': function() {
                 var result;
                 
-                if (this.isBrandNew() == false) {
-                        result = this.user().saveRecords([this], 'updateData');
-                } else {
-                        result = this.user().saveRecords([this], 'addNewRecords');
-                }
+        //      if (this.isBrandNew() == false) {
+        //              result = this.user().saveRecords([this], 'updateData');
+        //      } else {
+        //              result = this.user().saveRecords([this], 'addNewRecords');
+        //      }
+
+                result = this.user().saveRecords([this]);
                 
                 return result;
         },
         
 /*
         'saveChanges': function() {
                 var deferredResult;
                         varresult;
 
                 Clipperz.NotificationCenter.notify(this.user(), 'updatedSection', 'records', true);
 //MochiKit.Logging.logDebug(">>> Record.saveChanges");
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.saveChanges");
                 if (this.headerNotes() != null) {
                         this.setNotes(this.headerNotes());
                 }
                 this.syncDirectLoginReferenceValues();
                 this.currentVersion().createNewVersion();
 
                 result = {'records': [{}]};
                 
                 deferredResult = new MochiKit.Async.Deferred();
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_collectRecordInfo');
                 deferredResult.addCallback(MochiKit.Base.method(this, 'updateKey'));
 
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_encryptUserData');
                 deferredResult.addCallback(MochiKit.Base.method(this.user(), 'encryptedData'));
                 deferredResult.addCallback(function(aResult, res) {
                         aResult['user'] = res;
                         return aResult;
                 }, result);
 
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_encryptRecordData');
                 deferredResult.addCallback(MochiKit.Base.method(this, 'encryptedData'));
                 deferredResult.addCallback(function(aResult, res) {
         //#             aResult['record'] = res;
                         aResult['records'][0]['record'] = res;
                         return aResult;
                 }, result);
 
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_encryptRecordVersions');
                 deferredResult.addCallback(MochiKit.Base.method(this.currentVersion(), 'encryptedData'));
                 deferredResult.addCallback(function(aResult, res) {
         //              aResult['currentRecordVersion'] = res;
                         aResult['records'][0]['currentRecordVersion'] = res;
                         return aResult;
                 }, result);
 
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_sendingData');
                 if (this.isBrandNew() == false) {
                         deferredResult.addCallback(MochiKit.Base.method(this.user().connection(), 'message'), 'updateData');
                 } else {
         //#             deferredResult.addCallback(MochiKit.Base.method(this.user().connection(), 'message'), 'addNewRecord');
                         deferredResult.addCallback(MochiKit.Base.method(this.user().connection(), 'message'), 'addNewRecords');
                 }
 
                 deferredResult.addCallback(MochiKit.Base.method(this, 'takeSnapshotOfCurrentData'));
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_updatingInterface');
                 deferredResult.addCallback(MochiKit.Base.method(this, 'setIsBrandNew'), false);
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'recordUpdated');
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'directLoginUpdated');
                 deferredResult.callback();
                 
                 return deferredResult;
         },
         */
         //-------------------------------------------------------------------------
 
         'cancelChanges': function() {
 //MochiKit.Logging.logDebug(">>> Record.cancelChanges");
 //MochiKit.Logging.logDebug("--- Record.cancelChanges - cachedData: " + Clipperz.Base.serializeJSON(this.cachedData()));
                 if (this.isBrandNew()) {
                         this.user().removeRecord(this);
                 } else {
                         this.restoreValuesFromSnapshot(this.cachedData());
                 }
 //MochiKit.Logging.logDebug("<<< Record.cancelChanges");
         },
         
         //-------------------------------------------------------------------------
 
         'restoreValuesFromSnapshot': function(someSnapshotData) {
                         varsnapshotData;
                 
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Record.restoreValuesFromSnapshot");
                 snapshotData = Clipperz.Base.evalJSON(someSnapshotData);
 //MochiKit.Logging.logDebug("--- Record.restoreValuesFromSnapshot - someSnapshotData (1): " + Clipperz.Base.serializeJSON(someSnapshotData));
                 this.setLabel(snapshotData['label']);
                 this.resetDirectLogins();
                 this.setShouldProcessData(true);
                 this.processData(snapshotData);
 //MochiKit.Logging.logDebug("--- Record.restoreValuesFromSnapshot - snapshotData: (2)" + Clipperz.Base.serializeJSON(snapshotData));
                 
                 this.resetRemovedDirectLogins();
                 
                 {
                         var currentSnapshot;
diff --git a/frontend/beta/js/Clipperz/PM/DataModel/User.js b/frontend/beta/js/Clipperz/PM/DataModel/User.js
index dbbe9a0..b065557 100644
--- a/frontend/beta/js/Clipperz/PM/DataModel/User.js
+++ b/frontend/beta/js/Clipperz/PM/DataModel/User.js
@@ -192,356 +192,359 @@ MochiKit.Logging.logError("- User.errorHandler: " + anErrorString + " (" + anExc
                 }
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.2.7 - User.connect - 7: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'userConnected', null);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.2.8 - User.connect - 8: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addErrback(MochiKit.Base.method(this, 'handleConnectionFallback'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("1.2.9 - User.connect - 9: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
 
                 deferredResult.callback(aValue);
 //MochiKit.Logging.logDebug("<<< User.connect");
                 
                 return deferredResult;
         },
 
         //.........................................................................
 
         'handleConnectionFallback': function(aValue) {
                 var result;
 //MochiKit.Logging.logDebug(">>> User.handleConnectionFallback");
                 if (aValue instanceof MochiKit.Async.CancelledError) {
 //MochiKit.Logging.logDebug("--- User.handleConnectionFallback - operation cancelled");
                         result = aValue;
                 } else {
                         
 //MochiKit.Logging.logDebug("--- User.handleConnectionFallback - an ERROR has occurred - " + aValue);
                         this.resetConnection();
                         this.setConnectionVersion(Clipperz.PM.Crypto.communicationProtocol.fallbackVersions[this.connectionVersion()]);
 
                         if (this.connectionVersion() != null) {
                                 result = new MochiKit.Async.Deferred();
                                 
                                 result.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_tryOlderSchema');
                                 result.addCallback(MochiKit.Base.method(this, 'connect'));
                                 result.callback();
                         } else {
                                 result = MochiKit.Async.fail(Clipperz.PM.DataModel.User.exception.LoginFailed);
                         }
                 }
 //MochiKit.Logging.logDebug("<<< User.handleConnectionFallback");
                 return result;
         },
 
         //=========================================================================
 
         'header': function() {
                 if (this._header == null) {
                         this._header = new Clipperz.PM.DataModel.Header({user:this});
                 }
                 return this._header;
         },
 
         //-------------------------------------------------------------------------
         
         'statistics': function() {
                 if (this._statistics == null) {
                         this._statistics = new Clipperz.PM.DataModel.Statistics({user:this});
                 }
                 return this._statistics;
         },
 
         //-------------------------------------------------------------------------
 
         'records': function() {
                 return this._records;
         },
 
         //.........................................................................
         
         'addRecord': function(aValue, isBatchUpdate) {
                 this.records()[aValue.reference()] = aValue;
                 
                 if (isBatchUpdate != true) {
                         Clipperz.NotificationCenter.notify(aValue, 'recordAdded', null, true);
                         Clipperz.NotificationCenter.notify(this, 'updatedSection', 'records', true);
                 }
         },
 
         //-----------------------------------------------------------------------------
 
         'addNewRecord': function() {
                         varrecord;
                 
 //MochiKit.Logging.logDebug(">>> User.addNewRecord");
                 record = new Clipperz.PM.DataModel.Record({user:this});
                 this.addRecord(record);
                 Clipperz.NotificationCenter.notify(this, 'updatedSection', 'records', true);
 //MochiKit.Logging.logDebug("<<< User.addNewRecord");
 
                 return record;
         },
 
         //-------------------------------------------------------------------------
 
-        'saveRecords': function(someRecords, aMethodName) {
+        'saveRecords': function(someRecords /*, aMethodName*/) {
                 var deferredResult;
-                var methodName;
+        //      var methodName;
                         varresult;
                 var i,c;
 
 //console.log("User.saveRecords - someRecords", someRecords);
-                methodName = aMethodName || 'addNewRecords';
+        //      methodName = aMethodName || 'addNewRecords';
                 
                 Clipperz.NotificationCenter.notify(this, 'updatedSection', 'records', true);
 //MochiKit.Logging.logDebug(">>> User.saveRecords");
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] User.saveRecords");
 /*
 MochiKit.Logging.logDebug("--- User.saveRecords - 1");
                 MochiKit.Iter.forEach(someRecords, function(aRecord) {
                         if (aRecord.headerNotes() != null) {
                                 aRecord.setNotes(aRecord.headerNotes());
                         }
                         aRecord.syncDirectLoginReferenceValues();
                         aRecord.currentVersion().createNewVersion();
                         aRecord.updateKey();
                 });
 MochiKit.Logging.logDebug("--- User.saveRecords - 2");
 */
 
                 result = {'records': []};
                 
                 deferredResult = new MochiKit.Async.Deferred();
                 c = someRecords.length;
                 for (i=0; i<c; i++) {
                         deferredResult.addCallback(function(aRecord) {
                                 if (aRecord.headerNotes() != null) {
                                         aRecord.setNotes(aRecord.headerNotes());
                                 }
                                 aRecord.syncDirectLoginReferenceValues();
                                 aRecord.currentVersion().createNewVersion();
                                 aRecord.updateKey();
                         }, someRecords[i]);
                         deferredResult.addCallback(MochiKit.Async.wait, 0.1);
                 }
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 1 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_collectRecordInfo');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 2 " + res); return res;});
 
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_encryptUserData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 3 " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 4 " + res); return res;});
                 deferredResult.addCallback(function(aResult, res) {
                         aResult['user'] = res;
                         return aResult;
                 }, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 5 " + res); return res;});
 
                 c = someRecords.length;
                 for (i=0; i<c; i++) {
                         var recordData;
                         
                         recordData = {};
                         
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.1 " + res); return res;});
                         deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_encryptRecordData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.2 " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(someRecords[i], 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.3 " + res); return res;});
                         deferredResult.addCallback(function(aResult, res) {
                                 aResult['record'] = res;
                                 return aResult;
                         }, recordData);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.4 " + res); return res;});
 
                         deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', {} /*'saveCard_encryptRecordVersions'*/);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.5 " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(someRecords[i].currentVersion(), 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.6 " + res); return res;});
                         deferredResult.addCallback(function(aResult, res) {
                                 aResult['currentRecordVersion'] = res;
                                 return aResult;
                         }, recordData);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.7 " + res); return res;});
 
                         deferredResult.addCallback(function(aResult, res) {
-                                aResult['records'].push(res);
+                                aResult['records'] = { 'updated': [res] };
                                 return aResult;
                         }, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 6.8 " + res); return res;});
                 }
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 7 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'saveCard_sendingData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 8 " + res); return res;});
-                deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), methodName);
+        //      deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), methodName);
+                deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), 'saveChanges');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 9 " + res); return res;});
 
                 for (i=0; i<c; i++) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 9.1 " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(someRecords[i], 'takeSnapshotOfCurrentData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 9.2 " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(someRecords[i], 'setIsBrandNew'), false);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 9.3 " + res); return res;});
                 }
                 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 10 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'recordUpdated');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 11 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'notify', 'directLoginUpdated');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.saveRecords - 12 " + res); return res;});
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'removeRecord': function(aRecord) {
 //MochiKit.Logging.logDebug(">>> User.removeRecord");
                 delete this.records()[aRecord.reference()];
 //MochiKit.Logging.logDebug("--- User.removeRecord - 1");
                 Clipperz.NotificationCenter.notify(aRecord, 'recordRemoved', null, false);
                 Clipperz.NotificationCenter.notify(this, 'updatedSection', 'records', true);
 //MochiKit.Logging.logDebug("<<< User.removeRecord");
         },
 
         //-------------------------------------------------------------------------
 
         'deleteRecordsAction': function(someRecords) {
                         vardeferredResult;
                 var parameters;
                 
 //MochiKit.Logging.logDebug(">>> User.deleteRecordsAction - someRecords.length: " + someRecords.length);
                 parameters = {};
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 1 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'deleteRecord_collectData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 2 " + res); return res;});
                 deferredResult.addCallback(function(someParameters, someRecords) {
                         var recordReferences;
 
                         recordReferences = MochiKit.Base.map(function(aRecord) {
                                 var result;
                                 
                                 result = aRecord.reference();
                                 aRecord.remove();
 
                                 return result;
                         }, someRecords);
-                        someParameters.recordReferences = recordReferences;
+        //              someParameters.recordReferences = recordReferences;
+                        someParameters['records'] = { 'deleted': recordReferences};
                         
                         return someParameters;
                 }, parameters);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 3 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'deleteRecord_encryptData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 4 " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 5 " + res); return res;});
                 deferredResult.addCallback(function(someParameters, anUserEncryptedData) {
                         someParameters.user = anUserEncryptedData;
                         return someParameters;
                 }, parameters);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 6 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'deleteRecord_sendingData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecords parameters: " + Clipperz.Base.serializeJSON(res)); return res;});
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 7 " + res); return res;});
-                deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), 'deleteRecords');
+        //      deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), 'deleteRecords');
+                deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), 'saveChanges');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 8 " + res); return res;});
                 deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'deleteRecord_updatingInterface');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.deleteRecordsAction - 9 " + res); return res;});
                 deferredResult.callback(someRecords);
 //MochiKit.Logging.logDebug("<<< User.deleteRecordsAction");
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'resetAllLocalData': function() {
                 this.resetConnection();
 
                 this.setUsername("");
                 this.setPassphrase("");
 
                 this._header = null;
                 this._statistics = null;
                 this._preferences = null;
                 this._records = {};
                 this._directLoginReferences = {};
         },
         
         //-------------------------------------------------------------------------
 
         'deleteAccountAction': function() {
                 var deferredResult;
                 
 //MochiKit.Logging.logDebug(">>> user.deleteAccountAction - " + this);
                 deferredResult = new MochiKit.Async.Deferred();
                 deferredResult.addCallback(MochiKit.Base.method(this.connection(), 'message'), 'deleteUser');
                 deferredResult.addCallback(MochiKit.Base.method(this, 'resetAllLocalData'));
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< user.deleteAccountAction - " + this);
 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'encryptedData': function() {
                 var deferredResult;
                         varresult;
 
                 result = {};
                 
                 deferredResult = new MochiKit.Async.Deferred();
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 0: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this.header(), 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 1: " + res); return res;});
                 deferredResult.addCallback(function(aResult, aValue) {
                         aResult['header'] = aValue;
                 }, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 2: " + res); return res;});
 
                 deferredResult.addCallback(MochiKit.Base.method(this.statistics(), 'encryptedData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 3: " + res); return res;});
                 deferredResult.addCallback(function(aResult, aValue) {
                         aResult['statistics'] = aValue;
                 }, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 4: " + res); return res;});
 
                 deferredResult.addCallback(MochiKit.Base.bind(function(aResult, aValue) {
                         aResult['version'] = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
                         aResult['lock'] = this.lock();
 
                         return aResult;
                 }, this), result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("User.encryptedData - 5: " + res); return res;});
                 deferredResult.callback();
                 
                 return deferredResult;
         },
         
         //-------------------------------------------------------------------------
 
         'preferences': function() {
                 if (this._preferences == null) {
                         this._preferences = new Clipperz.PM.DataModel.UserPreferences({user:this});
                 }
                 
                 return this._preferences;
         },
 /*
         'setPreferences': function(aValue) {
                 this._preferences = aValue;
 
                 if (this._preferences.preferredLanguage() != null) {
                         Clipperz.PM.Strings.Languages.setSelectedLanguage(this._preferences.preferredLanguage());
                 } else {
 //MochiKit.Logging.logDebug("### keepping the browser selected language: " + Clipperz.PM.Strings.selectedLanguage);
                 }
         },
 */