1 files changed, 10 insertions, 10 deletions

diff --git a/frontend/gamma/js/Clipperz/PM/DataModel/User.js b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
index 72d4006..646ce21 100644
--- a/frontend/gamma/js/Clipperz/PM/DataModel/User.js
+++ b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
@@ -23,106 +23,106 @@ refer to http://www.clipperz.com.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 if (typeof(Clipperz.PM.DataModel) == 'undefined') { Clipperz.PM.DataModel = {}; }
 
 
 //#############################################################################
 
 Clipperz.PM.DataModel.User = function (args) {
         args = args || {};
 
         Clipperz.PM.DataModel.User.superclass.constructor.apply(this, arguments);
 
         this._username = args.username || null;
         this._getPassphraseFunction = args.getPassphraseFunction || null;
 
         this._data = null;
 
         this._connection = null;
         this._connectionVersion = 'current';
 
         this._serverData = null;
-        this._serverLockValue = null;
+        //this._serverLockValue = null;
         this._transientState = null;
 
         this._deferredLocks = {
                         'passphrase':           new MochiKit.Async.DeferredLock(),
                         'serverData':           new MochiKit.Async.DeferredLock(),
         //              'recordsIndex':                 new MochiKit.Async.DeferredLock(),
         //              'directLoginsIndex':new MochiKit.Async.DeferredLock()
         //              'preferences':          new MochiKit.Async.DeferredLock()
         //              'oneTimePasswords':     new MochiKit.Async.DeferredLock()
                 '__syntaxFix__': 'syntax fix'
         };
 
         return this;
 }
 
 Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
 
         'toString': function () {
                 return "Clipperz.PM.DataModel.User - " + this.username();
         },
 
         //-------------------------------------------------------------------------
 
         'username': function () {
                 return this._username;
         },
 
         'setUsername': function (aValue) {
                 this._username = aValue;
         },
 
         //-------------------------------------------------------------------------
 
         'displayName': function() {
                 return "" + this.username() + "";
         },
         
         //-------------------------------------------------------------------------
 
         'data': function () {
                 if (this._data == null) {
                         this._data = new Clipperz.KeyValueObjectStore(/*{'name':'User.data [1]'}*/);
                 };
                 
                 return this._data;
         },
 
         //-------------------------------------------------------------------------
-
+/*
         'serverLockValue': function () {
                 return this._serverLockValue;
         },
         
         'setServerLockValue': function (aValue) {
                 this._serverLockValue = aValue;
         },
-
+*/
         //-------------------------------------------------------------------------
 
         'transientState': function () {
                 if (this._transientState == null) {
                         this._transientState = {}
                 }
                 
                 return this._transientState;
         },
 
         'resetTransientState': function (isCommitting) {
                 this._transientState = null;
         },
 
         //-------------------------------------------------------------------------
 
         'deferredLockForSection': function(aSectionName) {
                 return this._deferredLocks[aSectionName];
         },
 
         //-------------------------------------------------------------------------
 
         'getPassphrase': function() {
                 var deferredResult;
@@ -199,76 +199,76 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
                                         'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
                                 }),
                                 'oneTimePasswords': new Clipperz.PM.DataModel.User.Header.OneTimePasswords({
                                                 'name':'preferences',
                                         'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
                                 })
                         }
                 };
                 
         //      this._serverLockValue = Clipperz.PM.Crypto.randomKey();
         },
 
         //.........................................................................
 
         'registerAsNewAccount': function () {
                 var deferredResult;
 
                 deferredResult = new Clipperz.Async.Deferred("User.registerAsNewAccount", {trace:false});
                 deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'updateProgress', {'extraSteps':3});
                 deferredResult.addMethod(this, 'initialSetupWithNoData')
                 deferredResult.addMethod(this, 'getPassphrase');
                 deferredResult.addMethod(this, 'prepareRemoteDataWithKey');
                 deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
                 deferredResult.addMethod(this.connection(), 'register');
-                deferredResult.addCallback(MochiKit.Base.itemgetter('lock'));
-                deferredResult.addMethod(this, 'setServerLockValue');
+        //      deferredResult.addCallback(MochiKit.Base.itemgetter('lock'));
+        //      deferredResult.addMethod(this, 'setServerLockValue');
                         deferredResult.addCallbackPass(MochiKit.Signal.signal,Clipperz.Signal.NotificationCenter, 'userSuccessfullyRegistered');
 
         //      deferredResult.addErrback (MochiKit.Base.method(this, 'handleRegistrationFailure'));
 
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'login': function () {
                 var deferredResult;
 
                 deferredResult = new Clipperz.Async.Deferred("User.login", {trace:false});
                 deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'updateProgress', {'extraSteps':3});
                 deferredResult.addMethod(this, 'getPassphrase');
                 deferredResult.addCallback(Clipperz.PM.DataModel.OneTimePassword.isValidOneTimePasswordValue);
                 deferredResult.addCallback(Clipperz.Async.deferredIf("Is the passphrase an OTP", [
                         MochiKit.Base.partial(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'updateProgress', {'extraSteps':1}),
                         MochiKit.Base.method(this, 'getCredentials'),
                         MochiKit.Base.method(this.connection(), 'redeemOneTimePassword'),
                         MochiKit.Base.method(this.data(), 'setValue', 'passphrase')
                 ], []));
                 deferredResult.addErrback(MochiKit.Base.method(this, 'getPassphrase'));
-                deferredResult.addMethod(this.connection(), 'login');
+                deferredResult.addMethod(this.connection(), 'login', false);
                         deferredResult.addCallbackPass(MochiKit.Signal.signal,Clipperz.Signal.NotificationCenter, 'userSuccessfullyLoggedIn');
                 deferredResult.addErrback (MochiKit.Base.method(this, 'handleConnectionFallback'));
 
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
         //.........................................................................
 
         'handleConnectionFallback': function(aValue) {
                 var result;
 
                 if (aValue instanceof MochiKit.Async.CancelledError) {
                         result = aValue;
                 } else {
                         this.setConnectionVersion(Clipperz.PM.Connection.communicationProtocol.fallbackVersions[this.connectionVersion()]);
 
                         if (this.connectionVersion() != null) {
                                 result = new Clipperz.Async.Deferred("User.handleConnectionFallback - retry");
                                 
                                 result.addMethod(this, 'login');
                                 result.callback();
                         } else {
@@ -308,49 +308,49 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
                 
                 if (anHeader.charAt(0) == '{') {
                                 varheaderData;
                         
                         headerData = Clipperz.Base.evalJSON(anHeader);
                         result = headerData['version'];
                 } else {
                         result = 'LEGACY';
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'unpackServerData': function (someServerData) {
                 var unpackedData;
                 var headerVersion;
 
                         varrecordsIndex;
                 var preferences;
                 var oneTimePasswords;
 
 //console.log(">>> ***************** user.unpackServerData", someServerData);
-                this.setServerLockValue(someServerData['lock']);
+        //      this.setServerLockValue(someServerData['lock']);
 
                 headerVersion = this.headerFormatVersion(someServerData['header']);
         
                 switch (headerVersion) {
                         case 'LEGACY':
                                         varlegacyHeader;
                                 
                                 legacyHeader = new Clipperz.PM.DataModel.User.Header.Legacy({
                                         'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
                                         'remoteData': {
                                                 'data': someServerData['header'],
                                                 'version': someServerData['version'],
                                                 'recordsStats': someServerData['recordsStats']
                                         },
         //                                      'encryptedDataKeypath':                 'data',
         //                                      'encryptedVersionKeypath':      'version',
                                                 'retrieveRecordDetailFunction':MochiKit.Base.method(this, 'getRecordDetail')
                                 });
 
                                         recordsIndex    = legacyHeader;
                                         preferences             = legacyHeader;
                                         oneTimePasswords= legacyHeader;
                                 break;
                         case '0.1':
@@ -641,50 +641,50 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
                 deferredResult.collectResults({
                         'header': [
                                 MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'hasPendingChanges'),
                                 MochiKit.Base.values
                         ],
                         'records': MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'hasPendingChanges')
                 });
                 deferredResult.addCallback(Clipperz.Async.or);
                 deferredResult.callback();
         //              recordsIndex    = legacyHeader;
         //              preferences             = legacyHeader;
         //              oneTimePasswords= legacyHeader;
                 
                 return deferredResult;
         },
 
         //=========================================================================
 
         'commitTransientState': function () {
                 return Clipperz.Async.callbacks("User.commitTransientState", [
                         MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'commitTransientState'),
                         MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'commitTransientState'),
 
                         MochiKit.Base.method(this, 'transientState'),
-                        MochiKit.Base.itemgetter('lock'),
-                        MochiKit.Base.method(this, 'setServerLockValue'),
+        //              MochiKit.Base.itemgetter('lock'),
+        //              MochiKit.Base.method(this, 'setServerLockValue'),
                         MochiKit.Base.method(this, 'resetTransientState', true)
                 ], {trace:false});
         },
 
         //-------------------------------------------------------------------------
 
         'revertChanges': function () {
                 return Clipperz.Async.callbacks("User.revertChanges", [
                         MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'revertChanges'),
                         MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'revertChanges'),
                         MochiKit.Base.method(this, 'resetTransientState', false)
                 ], {trace:false});
         },
 
         //=========================================================================
 
         'deleteAllCleanTextData': function () {
                 return Clipperz.Async.callbacks("User.deleteAllCleanTextData", [
                         MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'deleteAllCleanTextData'),
                         MochiKit.Base.method(this, 'invokeMethodNamedOnHeader',  'deleteAllCleanTextData'),
 
                         MochiKit.Base.method(this.data(), 'removeAllData'),
                         MochiKit.Base.method(this, 'resetTransientState', false)
                 ], {trace:false});
@@ -719,49 +719,49 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
 
         'prepareRemoteDataWithKey': function (aKey /*, aCurrentKey*/) {
                 var deferredResult;
                         varresult;
 
                 result = {};
                 deferredResult = new Clipperz.Async.Deferred("User.prepareRemoteDataWithKey", {trace:false});
                 deferredResult.addMethod(this, 'invokeMethodNamedOnHeader', 'prepareRemoteDataWithKey', aKey /*, aCurrentKey*/);
                 deferredResult.addCallback(MochiKit.Base.bind(function (aResult, someHeaderPackedData) {
                         var header;
 
                         header = {};
                                 header['records']               = someHeaderPackedData['recordIndex']['records'];
                                 header['directLogins']  = someHeaderPackedData['recordIndex']['directLogins'];
                                 header['preferences']           = {'data': someHeaderPackedData['preferences']['data']};                //      this._serverData['header']['preferences'];              //      Clipperz.Base.evalJSON(this._serverData['header']['data'])['preferences'];              //???????????
                                 header['oneTimePasswords']      = {'data': someHeaderPackedData['oneTimePasswords']['data']};   //      this._serverData['header']['oneTimePasswords'];         //      Clipperz.Base.evalJSON(this._serverData['header']['data'])['oneTimePasswords'];         //???????????
                                 header['version']               = '0.1';
 
                                 aResult['header']       = Clipperz.Base.serializeJSON(header);
                                 aResult['statistics']   = this._serverData['statistics'];       //"someHeaderPackedData['statistics']['data']";
                         
                         return aResult;
                 }, this), result);
                 deferredResult.addCallback(Clipperz.Async.setItem, result, 'version', Clipperz.PM.Crypto.encryptingFunctions.currentVersion);
-                deferredResult.addCallback(Clipperz.Async.setItem, result, 'lock', this.serverLockValue());
+        //      deferredResult.addCallback(Clipperz.Async.setItem, result, 'lock', this.serverLockValue());
                 deferredResult.callback();
 
                 return deferredResult;
         },
 
         //=========================================================================
 
         'saveChanges': function () {
                         vardeferredResult;
                 var messageParameters;
                 
                 messageParameters = {};
 
                 deferredResult = new Clipperz.Async.Deferred("User.saveChangaes", {trace:false});
 
                 deferredResult.addMethod(this, 'getHeaderIndex', 'recordsIndex');
                 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
                 deferredResult.addCallback(Clipperz.Async.setItem, messageParameters, 'records');
                 deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
 
                 deferredResult.addMethod(this, 'getPassphrase');
                 deferredResult.addMethod(this, 'prepareRemoteDataWithKey');
                 deferredResult.addCallback(Clipperz.Async.setItem, messageParameters, 'user');
                 deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');