summaryrefslogtreecommitdiff
path: root/frontend/gamma/js/Clipperz/PM/DataModel/User.js
Side-by-side diff
Diffstat (limited to 'frontend/gamma/js/Clipperz/PM/DataModel/User.js') (more/less context) (ignore whitespace changes)
-rw-r--r--frontend/gamma/js/Clipperz/PM/DataModel/User.js4
1 files changed, 2 insertions, 2 deletions
diff --git a/frontend/gamma/js/Clipperz/PM/DataModel/User.js b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
index fd18faf..b94fe4c 100644
--- a/frontend/gamma/js/Clipperz/PM/DataModel/User.js
+++ b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
@@ -345,466 +345,466 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
// 'encryptedVersionKeypath': 'version',
'retrieveRecordDetailFunction': MochiKit.Base.method(this, 'getRecordDetail')
});
recordsIndex = legacyHeader;
preferences = legacyHeader;
oneTimePasswords = legacyHeader;
break;
case '0.1':
var headerData;
headerData = Clipperz.Base.evalJSON(someServerData['header']);
recordsIndex = new Clipperz.PM.DataModel.User.Header.RecordIndex({
'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
'recordsData': headerData['records'],
'recordsStats': someServerData['recordsStats'],
'directLoginsData': headerData['directLogins'],
'encryptedDataVersion': someServerData['version'],
'retrieveRecordDetailFunction': MochiKit.Base.method(this, 'getRecordDetail')
});
// Still missing a test case that actually fais with the old version of the code, where the check for undefined was missing
if (typeof(headerData['preferences']) != 'undefined') {
preferences = new Clipperz.PM.DataModel.User.Header.Preferences({
'name': 'preferences',
'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
'remoteData': {
'data': headerData['preferences']['data'],
'version': someServerData['version']
}
});
} else {
preferences = new Clipperz.PM.DataModel.User.Header.Preferences({
'name': 'preferences',
'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
});
}
if (typeof(headerData['oneTimePasswords']) != 'undefined') {
oneTimePasswords = new Clipperz.PM.DataModel.User.Header.OneTimePasswords({
'name': 'preferences',
'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
'remoteData': {
'data': headerData['oneTimePasswords']['data'],
'version': someServerData['version']
}
});
} else {
oneTimePasswords = new Clipperz.PM.DataModel.User.Header.OneTimePasswords({
'name': 'preferences',
'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
});
}
break;
}
unpackedData = {
'version': someServerData['version'],
'statistics': someServerData['statistics'],
'header': {
'data': someServerData['header'],
'version': headerVersion,
'recordsIndex': recordsIndex,
'preferences': preferences,
'oneTimePasswords': oneTimePasswords
}
};
this._serverData = unpackedData;
return this._serverData;
},
//-------------------------------------------------------------------------
'getServerData': function() {
var deferredResult;
deferredResult = new Clipperz.Async.Deferred("User.getServerData", {trace:false});
deferredResult.acquireLock(this.deferredLockForSection('serverData'));
deferredResult.addCallback(MochiKit.Base.bind(function(aResult) {
var innerDeferredResult;
innerDeferredResult = new Clipperz.Async.Deferred("User.getUserDetails.innerDeferred", {trace:false});
if (this._serverData == null) {
innerDeferredResult.addCallbackPass(MochiKit.Signal.signal, this, 'loadingUserDetails');
innerDeferredResult.addMethod(this.connection(), 'message', 'getUserDetails');
innerDeferredResult.addMethod(this, 'unpackServerData');
innerDeferredResult.addCallbackPass(MochiKit.Signal.signal, this, 'loadedUserDetails');
}
innerDeferredResult.addCallback(MochiKit.Base.bind(function () {
return this._serverData;
},this));
innerDeferredResult.callback();
return innerDeferredResult;
}, this));
deferredResult.releaseLock(this.deferredLockForSection('serverData'));
deferredResult.callback();
return deferredResult;
},
//-------------------------------------------------------------------------
'connectionVersion': function() {
return this._connectionVersion;
},
'setConnectionVersion': function(aValue) {
if (this._connectionVersion != aValue) {
this.resetConnection();
}
this._connectionVersion = aValue;
},
//-------------------------------------------------------------------------
'connection': function() {
if ((this._connection == null) && (this.connectionVersion() != null) ){
this._connection = new Clipperz.PM.Connection.communicationProtocol.versions[this.connectionVersion()]({
getCredentialsFunction: MochiKit.Base.method(this, 'getCredentials')
});
}
return this._connection;
},
'resetConnection': function(aValue) {
if (this._connection != null) {
this._connection.reset();
}
this._connection = null;
},
//=========================================================================
'getHeaderIndex': function (aKey) {
return Clipperz.Async.callbacks("User.getHeaderIndex", [
MochiKit.Base.method(this, 'getServerData'),
MochiKit.Base.itemgetter('header'),
MochiKit.Base.itemgetter(aKey)
], {trace:false})
},
//=========================================================================
'getRecords': function () {
return Clipperz.Async.callbacks("User.getRecords", [
MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
MochiKit.Base.methodcaller('records'),
MochiKit.Base.values
], {trace:false});
},
'recordWithLabel': function (aLabel) {
return Clipperz.Async.callbacks("User.recordWithLabel", [
MochiKit.Base.method(this, 'getRecords'),
MochiKit.Base.partial(Clipperz.Async.deferredFilter, function (aRecord) {
return Clipperz.Async.callbacks("User.recordWithLabel - check record label", [
MochiKit.Base.methodcaller('label'),
MochiKit.Base.partial(MochiKit.Base.operator.eq, aLabel)
], {trace:false}, aRecord);
}),
function (someFilteredResults) {
var result;
switch (someFilteredResults.length) {
case 0:
result = null;
break;
case 1:
result = someFilteredResults[0];
break;
default:
WTF = TODO;
break;
}
return result;
}
], {trace:false});
},
//-------------------------------------------------------------------------
'getRecord': function (aRecordReference) {
return Clipperz.Async.callbacks("User.getRecord", [
MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
MochiKit.Base.methodcaller('records'),
MochiKit.Base.itemgetter(aRecordReference),
Clipperz.Async.deferredIf("record != null", [
MochiKit.Base.operator.identity
], [
function () { throw "Record does not exists"}
])
], {trace:false});
},
//-------------------------------------------------------------------------
'getRecordDetail': function (aRecordReference) {
return this.connection().message('getRecordDetail', {reference: aRecordReference});
},
//-------------------------------------------------------------------------
'deleteRecord': function (aRecord) {
return Clipperz.Async.callbacks("User.deleteRecord", [
MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
MochiKit.Base.methodcaller('deleteRecord', aRecord)
], {trace:false});
},
//-------------------------------------------------------------------------
'createNewRecord': function () {
return Clipperz.Async.callbacks("User.createNewRecord", [
MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
MochiKit.Base.methodcaller('createNewRecord')
], {trace:false});
},
//=========================================================================
'getDirectLogins': function() {
var deferredResult;
deferredResult = new Clipperz.Async.Deferred("User.getDirectLogins", {trace:false});
deferredResult.addMethod(this, 'getRecords');
deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.compose(MochiKit.Base.values, MochiKit.Base.methodcaller('directLogins')));
deferredResult.addCallback(MochiKit.Base.flattenArray);
deferredResult.callback();
return deferredResult;
},
//=========================================================================
'getOneTimePasswords': function () {
return Clipperz.Async.callbacks("User.getOneTimePasswords", [
MochiKit.Base.method(this, 'getHeaderIndex', 'oneTimePasswords'),
MochiKit.Base.methodcaller('oneTimePasswords'),
MochiKit.Base.values
], {trace:false});
},
//=========================================================================
'invokeMethodNamedOnHeader': function (aMethodName, aValue) {
return Clipperz.Async.collectResults("User.invokeMethodNamedOnHeader [" + aMethodName + "]", {
'recordIndex': [
MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
MochiKit.Base.methodcaller(aMethodName, aValue)
],
'preferences': [
MochiKit.Base.method(this, 'getHeaderIndex', 'preferences'),
MochiKit.Base.methodcaller(aMethodName, aValue)
],
'oneTimePasswords': [
MochiKit.Base.method(this, 'getHeaderIndex', 'oneTimePasswords'),
MochiKit.Base.methodcaller(aMethodName, aValue)
]//,
// 'statistics': [
// MochiKit.Base.method(this, 'getStatistics'),
// MochiKit.Base.methodcaller(aMethodName, aValue)
// ]
}, {trace:false})();
},
//-------------------------------------------------------------------------
'invokeMethodNamedOnRecords': function (aMethodName, aValue) {
return Clipperz.Async.callbacks("User.invokeMethodNamedOnRecords[" + aMethodName + "]", [
MochiKit.Base.method(this, 'getRecords'),
MochiKit.Base.partial(MochiKit.Base.map, MochiKit.Base.methodcaller(aMethodName, aValue)),
Clipperz.Async.collectAll
], {trace:false});
},
//=========================================================================
'hasPendingChanges': function () {
var deferredResult;
deferredResult = new Clipperz.Async.Deferred("User.hasPendingChanges", {trace:false});
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.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});
},
//-------------------------------------------------------------------------
'hasAnyCleanTextData': function () {
var deferredResult;
deferredResult = new Clipperz.Async.Deferred("User.hasAnyCleanTextData", {trace:false});
deferredResult.collectResults({
'header': [
MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'hasAnyCleanTextData'),
MochiKit.Base.values
],
'records': MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'hasAnyCleanTextData'),
'data': MochiKit.Base.bind(function () {
return MochiKit.Async.succeed(! this.data().isEmpty());
}, this),
'transientState': MochiKit.Base.bind(function () {
return MochiKit.Async.succeed(MochiKit.Base.keys(this.transientState()).length != 0);
}, this)
});
deferredResult.addCallback(Clipperz.Async.or);
deferredResult.callback();
return deferredResult;
},
//=========================================================================
'prepareRemoteDataWithKey': function (aKey /*, aCurrentKey*/) {
var deferredResult;
var result;
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['preferences'] = {'data': someHeaderPackedData['preferences']['data']};
+ header['oneTimePasswords'] = {'data': someHeaderPackedData['oneTimePasswords']['data']};
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.callback();
return deferredResult;
},
//=========================================================================
'saveChanges': function () {
var deferredResult;
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');
deferredResult.addCallback(MochiKit.Async.succeed, messageParameters);
deferredResult.addMethod(this.connection(), 'message', 'saveChanges');
deferredResult.addCallback(MochiKit.Base.update, this.transientState())
deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
deferredResult.addMethod(this, 'commitTransientState');
deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'userDataSuccessfullySaved');
deferredResult.addErrbackPass(MochiKit.Base.method(this, 'revertChanges'));
deferredResult.addErrbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'failureWhileSavingUserData');
deferredResult.callback();
return deferredResult;
},
//=========================================================================
__syntaxFix__: "syntax fix"
});
//-----------------------------------------------------------------------------
Clipperz.PM.DataModel.User.registerNewAccount = function (anUsername, aPassphraseFunction) {
var deferredResult;
var user;
user = new Clipperz.PM.DataModel.User({'username':anUsername, 'getPassphraseFunction':aPassphraseFunction});
deferredResult = new Clipperz.Async.Deferred("Clipperz.PM.DataModel.User.registerNewAccount", {trace:false});
deferredResult.addMethod(user, 'registerAsNewAccount');
deferredResult.addMethod(user, 'login');
deferredResult.addCallback(MochiKit.Async.succeed, user);
deferredResult.callback();
return deferredResult;
}
//-----------------------------------------------------------------------------
Clipperz.PM.DataModel.User.exception = {
LoginFailed: new MochiKit.Base.NamedError("Clipperz.PM.DataModel.User.exception.LoginFailed"),
CredentialUpgradeFailed: new MochiKit.Base.NamedError("Clipperz.PM.DataModel.User.exception.CredentialUpgradeFailed")
};
//-----------------------------------------------------------------------------