1 files changed, 10 insertions, 16 deletions

diff --git a/frontend/gamma/js/Clipperz/PM/DataModel/EncryptedRemoteObject.js b/frontend/gamma/js/Clipperz/PM/DataModel/EncryptedRemoteObject.js
index cdeec8b..1aa7a52 100644
--- a/frontend/gamma/js/Clipperz/PM/DataModel/EncryptedRemoteObject.js
+++ b/frontend/gamma/js/Clipperz/PM/DataModel/EncryptedRemoteObject.js
@@ -1,118 +1,116 @@
 /*
 
-Copyright 2008-2011 Clipperz Srl
+Copyright 2008-2013 Clipperz Srl
 
-This file is part of Clipperz Community Edition.
-Clipperz Community Edition is an online password manager.
+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 Community Edition is free software: you can redistribute
-  it and/or modify it under the terms of the GNU Affero General Public
-  License as published by the Free Software Foundation, either version
-  3 of the License, or (at your option) any later version.
+* Clipperz is free software: you can redistribute it and/or modify it
+  under the terms of the GNU Affero General Public License as published
+  by the Free Software Foundation, either version 3 of the License, or 
+  (at your option) any later version.
 
-* Clipperz Community Edition is distributed in the hope that it will
-  be useful, but WITHOUT ANY WARRANTY; without even the implied
-  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* 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 Community Edition.  If not, see
-  <http://www.gnu.org/licenses/>.
+  License along with Clipperz. If not, see http://www.gnu.org/licenses/.
 
 */
 
 try { if (typeof(Clipperz.KeyValueObjectStore) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.PM.DataModel.EncryptedRemoteObject depends on Clipperz.KeyValueObjectStore!";
 }  
 
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 if (typeof(Clipperz.PM.DataModel) == 'undefined') { Clipperz.PM.DataModel = {}; }
 
 Clipperz.PM.DataModel.EncryptedRemoteObject = function(args) {
         args = args || {};
 
         this._name = args.name || null;
         this._reference = args.reference || Clipperz.PM.Crypto.randomKey();
         this._isBrandNew = ((args.reference == null) && (args.remoteData == null));
 
         if ((this._isBrandNew == false) && (args['retrieveKeyFunction'] == null)) {
                 Clipperz.Base.exception.raise('MandatoryParameter');
         } else {
                 this._retrieveKeyFunction = args['retrieveKeyFunction'];
         }
 
                 this._retrieveRemoteDataFunction        = args.retrieveRemoteDataFunction|| null;
                 this._remoteData                                        = args.remoteData                               || null;
         //      this._remoteData                                = args.remoteData ? Clipperz.Base.deepClone(args.remoteData) : null;
         if ((!this._isBrandNew) && ((this._retrieveRemoteDataFunction == null) && (this._remoteData == null))) {
                 Clipperz.Base.exception.raise('MandatoryParameter');
         }
 
 
                 this._encryptedDataKeypath                      = args.encryptedDataKeypath                     || 'data';      //Clipperz.Base.exception.raise('MandatoryParameter');
                 this._encryptedVersionKeypath           = args.encryptedVersionKeypath          || 'version';//Clipperz.Base.exception.raise('MandatoryParameter');
 
         
         this._transientState = null;
         this._deferredLocks = {};
 
         if (this._isBrandNew == true) {
                 this._objectDataStore = new Clipperz.KeyValueObjectStore(/*{'name':'EncryptedRemoteObject.objectDataStore [1]'}*/);
         } else {
                 this._objectDataStore = null;
         }
 
         return this;
 }
 
 //
         //  Basic data workflow
         //=======================
 //
         //getRemoteData
         //      unpackRemoteData
         //              getDecryptData [encryptedDataKeypath, encryptedVersionKeypath]
         //                      unpackData
         //                      
         //                      
         //      ??              packData
         //      ??      encryptDataWithKey
         //      ??packRemoteData [encryptedDataKeypath (?), encryptedVersionKeypath (?)]
 //
 
 Clipperz.PM.DataModel.EncryptedRemoteObject.prototype = MochiKit.Base.update(null, {
 
         'toString': function () {
                 return "Clipperz.PM.DataModel.EncryptedRemoteObject" + (this.name() != null ? " - " + this.name() : "");
         },
 
         //-------------------------------------------------------------------------
 
         'name': function () {
                 return this._name;
         },
 
         //-------------------------------------------------------------------------
 
         'reference': function () {
                 return this._reference;
         },
 
         'setReference': function (aValue) {
                 this._reference = aValue;
 
                 return this._reference;
         },
 
         //-------------------------------------------------------------------------
 
         'transientState': function () {
                 if (this._transientState == null) {
                         this._transientState = new Clipperz.KeyValueObjectStore(/*{'name':'EncryptedRemoteObject.transientState [2]'}*/);
                 }
                 
                 return this._transientState;
         },
 
@@ -318,196 +316,192 @@ Clipperz.PM.DataModel.EncryptedRemoteObject.prototype = MochiKit.Base.update(nul
                         MochiKit.Base.method(this, '_getObjectDataStore'),
                         MochiKit.Base.methodcaller('values')
                 ], {trace:false});
         },
 
         'setValues': function (someValues) {
                 return Clipperz.Async.callbacks("EncryptedRemoteObject.values", [
                         MochiKit.Base.method(this, '_getObjectDataStore'),
                         MochiKit.Base.methodcaller('setValues', someValues)
                 ], {trace:false});
         },
         
         //.........................................................................
 
         '_getObjectDataStore': function () {
                 var deferredResult;
                 var deferredLock;
                 
                 deferredLock = this.getDeferredLockForKey('objectDataStore');
                 
                 deferredResult = new Clipperz.Async.Deferred("EncryptedRemoteObject._getObjectDataStore", {trace:false});
                 deferredResult.acquireLock(deferredLock);
                 deferredResult.addCallback(MochiKit.Base.bind(function () {
                         var innerDeferredResult;
 
                         if (this._objectDataStore == null) {
                                 this._objectDataStore = new Clipperz.KeyValueObjectStore(/*{'name':'EncryptedRemoteObject.objectDataStore [4]'}*/);
 
                                 innerDeferredResult = new Clipperz.Async.Deferred("EncryptedRemoteObject._getObjectDataStore <inner deferred>", {trace:false});
                                 innerDeferredResult.addMethod(this, 'getDecryptedData');
                                 innerDeferredResult.addMethod(this._objectDataStore, 'initWithValues');
                                 innerDeferredResult.callback();
                         } else {
                                 innerDeferredResult = MochiKit.Async.succeed(this._objectDataStore);
                         }
 
                         return innerDeferredResult;
                 }, this));
                 deferredResult.releaseLock(deferredLock);
                 deferredResult.callback();
                 
                 return deferredResult;
         },
         
         'hasInitiatedObjectDataStore': function () {
                 return (this._objectDataStore != null);
         },
 
         //-------------------------------------------------------------------------
 
         'getDeferredLockForKey': function (aKey) {
                 var result;
                 
                 result = this._deferredLocks[aKey];
                 
                 if (typeof(result) == 'undefined') {
                         result = new MochiKit.Async.DeferredLock();
                         this._deferredLocks[aKey] = result;
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
                 'unpackData': function (someData) {     //++
                 return someData;
         },
         
                 'packData': function (someData) {       //++
                 return someData;
         },
 
         //-------------------------------------------------------------------------
         
         'hasPendingChanges': function () {
                 var deferredResult;
                 var tempObj = this;
 
                 if (this.isBrandNew()) {
         //              deferredResult = MochiKit.Async.succeed(true);
                         deferredResult = this.hasPendingChangesWhenBrandNew();
                 } else if (this.hasInitiatedObjectDataStore()) {
                         deferredResult = new Clipperz.Async.Deferred("EncryptedRemoteObject.hasPendingChanges", {trace:false});
                         deferredResult.collectResults({
                                 'decryptedData': [
                                         MochiKit.Base.method(this, 'getDecryptedData'),
                                         Clipperz.Base.serializeJSON
                                 ],
                                 'objectData': [
                                         MochiKit.Base.method(this, '_getObjectDataStore'),
                                         MochiKit.Base.methodcaller('values'),
                                         Clipperz.Base.serializeJSON
                                 ]
                         });
                         deferredResult.addCallback(function (someValues) {
-//if (someValues['decryptedData'] != someValues['objectData']) {
-        //console.log("ORIGINAL DATA", '[[[' + someValues['decryptedData'] + ']]]');
-        //console.log("CURRENT  DATA", '>>>' + someValues['objectData'] + '<<<');
-//}
                                 return (someValues['decryptedData'] != someValues['objectData']);
                         });
                         deferredResult.callback();
                 } else {
                         deferredResult = MochiKit.Async.succeed(false);
                 }
 
                 return deferredResult;
         },
 
         'hasPendingChangesWhenBrandNew': function () {
                 return MochiKit.Async.succeed(true);
         },
 
         //-------------------------------------------------------------------------
 
         'commitTransientState': function () {
                 var deferredResult;
 
         //      if (this.transientState().getValue('__prepareRemoteData') == true) {
                 if (this.transientState().getValue('packedRemoteData') != null) {
                         deferredResult = Clipperz.Async.callbacks("EncryptedRemoteObject.commitTransientState - prepareRemoteData", [
                                 MochiKit.Base.bind(function (someData) {
                                         this._remoteData = this.transientState().getValue('packedRemoteData');
                                 }, this),
 
                                 MochiKit.Base.method(this, '_getObjectDataStore'),
                                 MochiKit.Base.methodcaller('values'),
                                 Clipperz.Base.deepClone,
                                 MochiKit.Base.method(this.decryptedDataStore(), 'setValue', 'decryptedData'),
 
                                 MochiKit.Base.method(this, 'resetTransientState', true)
                         ], {trace:false});
 
                 } else {
                         deferredResult = Clipperz.Async.callbacks("EncryptedRemoteObject.commitTransientState - NO prepareRemoteData", [
                                 MochiKit.Base.method(this, 'resetTransientState', true)
                         ], {trace:false});
                 }
                 
                 this._isBrandNew = false;
 
                 return deferredResult;
         },
         
         //-------------------------------------------------------------------------
 
         'revertChanges': function () {
                 if (this.hasInitiatedObjectDataStore()) {
                         this._objectDataStore.removeAllData();
                         this._objectDataStore = null;
                 }
                 this.resetTransientState(false);
 
                 return MochiKit.Async.succeed();
         },
 
         //-------------------------------------------------------------------------
 
         'deleteAllCleanTextData': function () {
                 var deferredResult;
 
                 deferredResult = new Clipperz.Async.Deferred("EncryptedRemoteObject.deleteAllCleanTextData", {trace:false});
 
                 deferredResult.addMethod(this, 'resetTransientState', false);
 
                 deferredResult.acquireLock(this.getDeferredLockForKey('decryptedData'));
                 deferredResult.addCallback(MochiKit.Base.bind(function () {
                         if (this._decryptedDataStore != null) {
                                 this._decryptedDataStore.removeAllData();
                         }
                 }, this));
                 deferredResult.releaseLock(this.getDeferredLockForKey('decryptedData'));
                 
                 deferredResult.acquireLock(this.getDeferredLockForKey('objectDataStore'));
                 deferredResult.addCallback(MochiKit.Base.bind(function () {
                         if (this._objectDataStore != null) {
                                 this._objectDataStore.removeAllData();
                                 this._objectDataStore = null;
                         }
                 }, this));
                 deferredResult.releaseLock(this.getDeferredLockForKey('objectDataStore'));
 
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
         //.........................................................................
 
         'hasAnyCleanTextData': function () {
                 var result;
                 
                 result = false;
                 
                 result = result || (! this.decryptedDataStore().isEmpty());