Fixed a bug that would "corrupt" header data when upgrading the crypto version used to process an account data

The problem being that only part of the header section would be re-encrypted, thus ending up with different sections encrypted using different crypto function versions.
And this would break when loading data back on next login.

1 files changed, 3 insertions, 1 deletions

diff --git a/frontend/beta/js/Clipperz/PM/DataModel/Header.js b/frontend/beta/js/Clipperz/PM/DataModel/Header.js
index 908d9f4..d577830 100644
--- a/frontend/beta/js/Clipperz/PM/DataModel/Header.js
+++ b/frontend/beta/js/Clipperz/PM/DataModel/Header.js
@@ -1,746 +1,748 @@
 /*
 
 Copyright 2008-2013 Clipperz Srl
 
 This file is part of Clipperz, the online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz 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 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. If not, see http://www.gnu.org/licenses/.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 if (typeof(Clipperz.PM.DataModel) == 'undefined') { Clipperz.PM.DataModel = {}; }
 
 
 //#############################################################################
 
 Clipperz.PM.DataModel.Header = function(args) {
         args = args || {};
 
         this._user = args.user;
 
         this._serverData = null;
         this._serverDataVersion = null;
         this._jsonEvaledServerData = null;
         
         this._decryptedLegacyServerData = null;
         this._isDecryptingLegacyServerData = false;
         this._decryptingLegacyServerDataPendingQueue = [];
 
         this.resetUpdatedSections();
         
         this._shouldLoadSections = {};
 
         Clipperz.NotificationCenter.register(this.user(), 'updatedSection', this, 'updatedSectionHandler');
         
         return this;
 }
 
 Clipperz.PM.DataModel.Header.prototype = MochiKit.Base.update(null, {
 
         //-------------------------------------------------------------------------
 
         'user': function() {
                 return this._user;
         },
                 
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         //-------------------------------------------------------------------------
         
         'updatedSections': function() {
                 return this._updatedSections;
         },
 
         'markSectionAsUpdated': function(aSectionName) {
                 this.updatedSections().push(aSectionName);
         },
         
         'resetUpdatedSections': function() {
                 this._updatedSections = []
         },
         
         'hasSectionBeenUpdated': function(aSectionName) {
-                return (this.updatedSections().join().indexOf(aSectionName) != -1);
+                        return(this.updatedSections().join().indexOf(aSectionName) != -1)
+                                ||(this.serverDataVersion() != Clipperz.PM.Crypto.encryptingFunctions.currentVersion);
         },
         
         'cachedServerDataSection': function(aSectionName) {
                 return (this.hasSectionBeenUpdated(aSectionName)) ? {} : this.jsonEvaledServerData()[aSectionName];
         },
         
         'updateAllSections': function() {
                 this.resetUpdatedSections();
                 this.markSectionAsUpdated('records');
                 this.markSectionAsUpdated('directLogins');
                 this.markSectionAsUpdated('preferences');
                 this.markSectionAsUpdated('oneTimePasswords');
                 
                 return MochiKit.Async.succeed(this);
         },
         
         'updatedSectionHandler': function(anEvent) {
                 this.markSectionAsUpdated(anEvent.parameters());
         },
         
         //-------------------------------------------------------------------------
         
         'getObjectKeyIndex': function(anObject) {
                 var result;
                         varitemReference;
                 var index;
                 
                 result = {};
                 index = 0;
 
                 for (itemReference in anObject) {
                         result[itemReference] = index.toString();
                         index ++;
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'serializedDataWithRecordAndDirectLoginIndexes': function(aRecordIndexes, aDirectLoginIndexs) {
                 var result;
                 var records;
                 var recordReference;
 
 //MochiKit.Logging.logDebug(">>> Header.serializedData");
                 result = {
                         'records': {},
                         'directLogins': {}
                 };
 
                 records = this.user().records();
                 for (recordReference in records) {
                         result['records'][aRecordIndexes[recordReference]] = this.user().records()[recordReference].headerData();
                 }
                 
                 for (directLoginReference in this.user().directLoginReferences()) {
                         var currentDirectLogin;
                                 vardirectLoginData;
                         
                         currentDirectLogin = this.user().directLoginReferences()[directLoginReference];
                         if (aRecordIndexes[currentDirectLogin.recordReference()] != null) {
                                 directLoginData = {
         //                              reference:  currentDirectLogin.reference(),
                                                 record:         aRecordIndexes[currentDirectLogin.recordReference()].toString(),
                                                 label:  currentDirectLogin.label(),
                                                 favicon:currentDirectLogin.favicon() || ""
                                 }
 
                                 result['directLogins'][aDirectLoginIndexs[directLoginReference]] = directLoginData;
                         }
                         
                 }
 //MochiKit.Logging.logDebug("<<< Header.serializedData - result: " + Clipperz.Base.serializeJSON(result));
 //MochiKit.Logging.logDebug("<<< Header.serializedData");
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
         
         'encryptedData': function() {
                 var deferredResult;
                 var recordIndex;
                 var directLoginIndex;
                         varserializedData;
                 var result;
 
 //MochiKit.Logging.logDebug(">>> [" + (new Date()).valueOf() + "] Header.encryptedData");
 //MochiKit.Logging.logDebug("### Header.encryptedData - " + Clipperz.Base.serializeJSON(this.updatedSections()));
                 result = {
                         'records': this.cachedServerDataSection('records'),
                         'directLogins': this.cachedServerDataSection('directLogins'),
                         'preferences': this.cachedServerDataSection('preferences'),
                         'oneTimePasswords': this.cachedServerDataSection('oneTimePasswords'),
                         'version': '0.1'
                 };
 
                 if (this.hasSectionBeenUpdated('records')) {
                         recordIndex = this.getObjectKeyIndex(this.user().records());
                         result['records']['index'] = recordIndex;
                 } else {
                         recordIndex = result['records']['index'];
                 }
                 
                 if (this.hasSectionBeenUpdated('directLogins')) {
                         directLoginIndex = this.getObjectKeyIndex(this.user().directLoginReferences());
                         result['directLogins']['index'] = directLoginIndex;
                 } else {
                         directLoginIndex = result['directLogins']['index'];
                 }
                 
                 if (this.hasSectionBeenUpdated('records') || this.hasSectionBeenUpdated('directLogins')) {
                         serializedData = this.serializedDataWithRecordAndDirectLoginIndexes(recordIndex, directLoginIndex);
                 }
                 
                 deferredResult = new MochiKit.Async.Deferred();
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 1: " + res); return res;});
                 if (this.hasSectionBeenUpdated('records')) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 1.1: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aSerializedData, aValue) {
                                 return Clipperz.PM.Crypto.deferredEncryptWithCurrentVersion(anHeader.user().passphrase(), aSerializedData['records']);
                         }, this, result, serializedData);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 1.2: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 aResult['records']['data'] = aValue;
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 1.3: " + res); return res;});
                 }
                 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 2: " + res); return res;});
                 if (this.hasSectionBeenUpdated('directLogins')) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 2.1: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aSerializedData, aValue) {
                                 return Clipperz.PM.Crypto.deferredEncryptWithCurrentVersion(anHeader.user().passphrase(), aSerializedData['directLogins']);
                         }, this, result, serializedData);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 2.2: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 aResult['directLogins']['data'] = aValue;
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 2.3: " + res); return res;});
                 }
                 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 3: " + res); return res;});
                 if (this.hasSectionBeenUpdated('preferences')) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 3.1: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 return Clipperz.PM.Crypto.deferredEncryptWithCurrentVersion(anHeader.user().passphrase(), anHeader.user().preferences().serializedData());
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 3.2: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 aResult['preferences']['data'] = aValue;
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 3.3: " + res); return res;});
                 }
 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 4: " + res); return res;});
                 if (this.hasSectionBeenUpdated('oneTimePasswords')) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 4.1: " + res); return res;});
         //              deferredResult.addCallback(MochiKit.Base.method(this, 'loadOneTimePasswords'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 4.2: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 return Clipperz.PM.Crypto.deferredEncryptWithCurrentVersion(anHeader.user().passphrase(), anHeader.user().oneTimePasswordManager().serializedData());
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 4.3: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aResult, aValue) {
                                 aResult['oneTimePasswords']['data'] = aValue;
                         }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 4.4: " + res); return res;});
                 }
                 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 5: " + res); return res;});
                 deferredResult.addCallback(function(anHeader, aResult, aValue) {
                         var serverData;
                         
                         serverData = Clipperz.Base.serializeJSON(aResult);
                         anHeader.setServerData(serverData);
                         
                         return serverData;
                 }, this, result);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.encryptedData - 6: " + res); return res;});
 
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< [" + (new Date()).valueOf() + "] Header.encryptedData");
 
                 return deferredResult;
         },
         
         //-------------------------------------------------------------------------
 
         'serverData': function() {
                 return this._serverData;
         },
         
         'setServerData': function(aValue) {
 //MochiKit.Logging.logDebug(">>> Header.setServerData");
 //MochiKit.Logging.logDebug("[start]=============================================");
 //MochiKit.Logging.logDebug("SERVER_DATA: " + aValue);
 //MochiKit.Logging.logDebug("[end]===============================================");
                 this._serverData = aValue;
 //MochiKit.Logging.logDebug("--- Header.setServerData - 1");
                 this.resetUpdatedSections();
 //MochiKit.Logging.logDebug("--- Header.setServerData - 2");
                 this.resetJsonEvaledServerData();
 //MochiKit.Logging.logDebug("<<< Header.setServerData");
         },
 
         'jsonEvaledServerData': function() {
                 if (this._jsonEvaledServerData == null) {
                         this._jsonEvaledServerData = Clipperz.Base.evalJSON(this.serverData());
                 }
                 
                 return this._jsonEvaledServerData;
         },
         
         'resetJsonEvaledServerData': function() {
                 this._jsonEvaledServerData = null;
         },
         
         //-------------------------------------------------------------------------
 
         'serverDataVersion': function() {
                 return this._serverDataVersion;
         },
         
         'setServerDataVersion': function(aValue) {
                 this._serverDataVersion = aValue;
         },
 
         //-------------------------------------------------------------------------
 
         'decryptedLegacyServerData': function() {
                 var deferredResult;
 
 //MochiKit.Logging.logDebug(">>> Header.decryptedLegacyServerData");
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'updateAllSections'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 if (this._decryptedLegacyServerData == null) {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_decryptingUserData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(Clipperz.PM.Crypto.deferredDecrypt, this.user().passphrase(), this.serverData(), this.serverDataVersion());
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(function(anHeader, aValue) {
                                 anHeader._decryptedLegacyServerData = aValue;
                         }, this);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 6: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 };
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 7: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 
                 deferredResult.addCallback(function(anHeader) {
                         return anHeader._decryptedLegacyServerData;
                 }, this);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.decryptedLegacyServerData 8: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< Header.decryptedLegacyServerData");
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'serverDataFormat': function() {
                 var result;
                 
 //MochiKit.Logging.logDebug(">>> Header.serverDataFormat");
                 if (this.serverData().charAt(0) == '{') {
                                 varserverData;
                         
                         serverData = Clipperz.Base.evalJSON(this.serverData());
                         result = serverData['version'];
                 } else {
                         result = 'LEGACY';
                 }
 //MochiKit.Logging.logDebug("<<< Header.serverDataFormat");
                 
                 return result;
         },
         
         //-------------------------------------------------------------------------
 
         'extractHeaderDataFromUserDetails': function(someUserDetails) {
                 if (this.serverData() == null) {
                         this.setServerData(someUserDetails['header']);
                         this.setServerDataVersion(someUserDetails['version'])
                 }
         },
 
         //-------------------------------------------------------------------------
 
         'extractDataWithKey': function(aKey) {
                 var deferredResult;
                 
 //MochiKit.Logging.logDebug(">>> Header.extractDataWithKey");
                 deferredResult = new MochiKit.Async.Deferred();
                 
                 switch (this.serverDataFormat()) {
                         case 'LEGACY':
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 deferredResult.addCallback(MochiKit.Base.method(this, 'decryptedLegacyServerData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 deferredResult.addCallback(function(someDecryptedValues) {
                                         return someDecryptedValues[aKey] || {};
                                 })
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 break;
                         case '0.1':
                                 var data;
 
         //#                     data = Clipperz.Base.evalJSON(this.serverData());
                                 data = this.jsonEvaledServerData();
                                 if (typeof(data[aKey]) != 'undefined') {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                         deferredResult.addCallback(Clipperz.NotificationCenter.deferredNotification, this, 'updatedProgressState', 'connection_decryptingUserData');
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 5: "/* + res*/); return res;});
+//deferredResult.addBoth(function(res) {console.log("aKey: " + aKey); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                         deferredResult.addCallback(Clipperz.PM.Crypto.deferredDecrypt, this.user().passphrase(), data[aKey]['data'], this.serverDataVersion());
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 6: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                         deferredResult.addCallback(function(/*anHeader,*/ aKey, aData, aRecordIndex, aValue) {
                                                 var result;
 //MochiKit.Logging.logDebug(">>> [start] ===============================================");
 //MochiKit.Logging.logDebug("--- extractDataWithKey - 0 [" + aKey + "]: " + Clipperz.Base.serializeJSON(aValue));
 //MochiKit.Logging.logDebug("<<< [end] =================================================");
                                                 if (aKey == 'records') {
                                                         var recordKey;
                                 
                                                         result = {};
                                                         for (recordKey in aData['index']) {
                                                                 result[recordKey] = aValue[aData['index'][recordKey]];
                                                         }
                                                 } else if (aKey == 'directLogins') {
                                                                 varrecordKeyReversedIndex;
                                                         var recordKey;
                                                         var directLoginKey;
                                 
                                                         result = {};
                                                         recordKeyReversedIndex = {};
         
                                                         for (recordKey in aRecordIndex) {
                                                                 recordKeyReversedIndex[aRecordIndex[recordKey]] = recordKey;
                                                         }
 
 //MochiKit.Logging.logDebug("--- extractDataWithKey - 1 - aData['index']: " + Clipperz.Base.serializeJSON(aData['index']));
                                                         for (directLoginKey in aData['index']) {
 try {
                                                                 if ((aData['index'][directLoginKey] != null) && (aValue[aData['index'][directLoginKey]] != null)) {
                                                                         result[directLoginKey] = aValue[aData['index'][directLoginKey]];
                                                                         result[directLoginKey]['record'] = recordKeyReversedIndex[result[directLoginKey]['record']];
                                                                 }
 } catch(exception) {
                 //result[directLoginKey] has no properties
         MochiKit.Logging.logDebug("[Header 391] EXCEPTION: " + exception);
         throw exception;
 }
                                                         }
 //MochiKit.Logging.logDebug("--- extractDataWithKey - 2");
                                                 } else {
                                                         result = aValue;
                                                 }
                         
                                                 return result;
                                         }, /*this,*/ aKey, data[aKey], data['records']['index']);
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 6: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 } else {
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 7: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                         deferredResult.addCallback(MochiKit.Async.succeed, {});
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 8: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                                 }
                                 break;
                 }
                 
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.extractDataWithKey 9: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.callback();
 //MochiKit.Logging.logDebug("<<< Header.extractDataWithKey");
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'processRecordData': function(someRecordData) {
                 var records;
                         varrecordReference;
 
 //console.log("HeaderRecordData parameters", someRecordData);
 //MochiKit.Logging.logDebug(">>> Header.processRecordData");
                 records = someRecordData;
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 1");
                 if (records != null) {
 //MochiKit.Logging.logDebug("--- Header.processRecordData - records: " + Clipperz.Base.serializeJSON(records));
                         for (recordReference in records) {
                                 var newRecord;
                                 var parameters;
         
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 2 - recordReference: " + recordReference);
                                 if (recordReference != "stacktrace") {
                                                 parameters = records[recordReference];//.slice();
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 3");
                                         if (typeof(parameters['notes']) != 'undefined') {
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 4");
                                                 if (parameters['notes'] != "") {
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 5");
                                                         parameters['headerNotes'] = parameters['notes'];
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 6");
                                                 }
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 7");
                                                 delete parameters['notes'];
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 8");
                                         }
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 9");
                                         parameters['reference'] = recordReference;
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 10");
                                         parameters['user'] = this.user();
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 11");
         
                                         newRecord = new Clipperz.PM.DataModel.Record(parameters);
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 12");
                                         this.user().addRecord(newRecord, true);
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 13");
                                 }
                         }
 
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 14");
                         Clipperz.NotificationCenter.notify(null, 'recordAdded', null, true);
 //MochiKit.Logging.logDebug("--- Header.processRecordData - 15");
                 }
 //MochiKit.Logging.logDebug("<<< Header.processRecordData");
                 
                 return this.user().records();
         },
         
         //-------------------------------------------------------------------------
 
         'processDirectLoginData': function(someDirectLoginData) {
                 var directLogins;
                 var directLoginReference;
                 
 //MochiKit.Logging.logDebug(">>> Header.processDirectLoginData");
                 directLogins = someDirectLoginData;
                 if (directLogins != null) {
                         for (directLoginReference in directLogins) {
                                 var directLoginReference;
                                 var parameters;
         
                                         parameters = directLogins[directLoginReference];//.slice();
                                 parameters.user = this.user();
                                 parameters.reference = directLoginReference;
                                 directLoginReference = new Clipperz.PM.DataModel.DirectLoginReference(parameters);
                                 if (directLoginReference.record() != null) {
                                         this.user().addDirectLoginReference(directLoginReference, true);
                                 }
                         }
                 }
 
                 Clipperz.NotificationCenter.notify(null, 'directLoginAdded', null, true);
 //MochiKit.Logging.logDebug("<<< Header.processDirectLoginData");
                 
                 return this.user().directLoginReferences();
         },
 
         //-------------------------------------------------------------------------
 
         'shouldLoadSections': function() {
                 return this._shouldLoadSections;
         },
         
         'shouldLoadSection': function(aSectionName) {
                 var result;
 
                 if (typeof(this.shouldLoadSections()[aSectionName]) != 'undefined') {
                         result = this.shouldLoadSections()[aSectionName];
                 } else {
                         result = true;
                 }
                 
                 return result;
         },
         
         'setShouldLoadSection': function(aSectionName, aValue) {
                 this.shouldLoadSections()[aSectionName] = aValue;
         },
         
         //-------------------------------------------------------------------------
         
         'loadRecords': function() {
                 var deferredResult;
 
                 if (this.shouldLoadSection('records') == true) {
                         this.setShouldLoadSection('records', false);
 
                         deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadRecords 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user(), 'getUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadRecords 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractHeaderDataFromUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadRecords 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractDataWithKey', 'records'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadRecords 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'processRecordData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadRecords 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.callback();
                 } else {
                         deferredResult = MochiKit.Async.succeed(this.user().records());
                 }
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
         
         'loadDirectLogins': function() {
                 var deferredResult;
 
                 if (this.shouldLoadSection('directLogins') == true) {
                         this.setShouldLoadSection('directLogins', false);
 
                         deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadDirectLogins - 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user(), 'getUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadDirectLogins - 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractHeaderDataFromUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadDirectLogins - 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractDataWithKey', 'directLogins'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadDirectLogins - 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'processDirectLoginData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadDirectLogins - 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.callback();
                 } else {
                         deferredResult = MochiKit.Async.succeed(this.user().directLoginReferences());
                 }
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'loadPreferences': function() {
                 var deferredResult;
 
                 if (this.shouldLoadSection('preferences') == true) {
                         this.setShouldLoadSection('preferences', false);
 
                         deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadPreferences - 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user(), 'getUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadPreferences - 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractHeaderDataFromUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadPreferences - 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractDataWithKey', 'preferences'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadPreferences - 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user().preferences(), 'updateWithData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadPreferences - 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.callback();
                 } else {
                         deferredResult = MochiKit.Async.succeed(this.user().preferences());
                 }
                 
                 return deferredResult;
         },
         
         //-------------------------------------------------------------------------
 
         'loadOneTimePasswords': function() {
                 var deferredResult;
                 
                 if (this.shouldLoadSection('oneTimePasswords') == true) {
                         this.setShouldLoadSection('oneTimePasswords', false);
 
                         deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user(), 'getUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractHeaderDataFromUserDetails'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this, 'extractDataWithKey', 'oneTimePasswords'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user().oneTimePasswordManager(), 'updateWithData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user().connection(), 'message'), 'getOneTimePasswordsDetails', {});
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 6: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.addCallback(MochiKit.Base.method(this.user().oneTimePasswordManager(), 'updateWithServerData'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadOneTimePasswords - 7: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                         deferredResult.callback();
                 } else {
                         deferredResult = MochiKit.Async.succeed(this.user().oneTimePasswordManager());
                 }
                 
                 return deferredResult;
         },
 
         //-------------------------------------------------------------------------
 
         'loadAllSections': function() {
                 var deferredResult;
 
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadAllSections - 1: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'loadRecords'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadAllSections - 2: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'loadDirectLogins'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadAllSections - 3: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'loadPreferences'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadAllSections - 4: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.addCallback(MochiKit.Base.method(this, 'loadOneTimePasswords'));
 //deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("Header.loadAllSections - 5: "/* + res*/); return res;});
 //deferredResult.addErrback(function(res) {MochiKit.Logging.logDebug("ERROR: " + res); return res;});
                 deferredResult.callback();
                 
                 return deferredResult;
         },
         
         //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
         
 });