2017-01-14 19:43:59 +01:00
|
|
|
function LoginService(cryptoService, userService, apiService, settingsService) {
|
2017-01-04 00:40:07 +01:00
|
|
|
this.cryptoService = cryptoService;
|
|
|
|
this.userService = userService;
|
|
|
|
this.apiService = apiService;
|
2017-01-14 19:43:59 +01:00
|
|
|
this.settingsService = settingsService;
|
2017-01-04 00:40:07 +01:00
|
|
|
this.decryptedLoginCache = null;
|
|
|
|
|
|
|
|
initLoginService();
|
2017-07-14 21:34:05 +02:00
|
|
|
}
|
2017-01-04 00:40:07 +01:00
|
|
|
|
|
|
|
function initLoginService() {
|
|
|
|
LoginService.prototype.clearCache = function () {
|
2017-07-14 21:34:05 +02:00
|
|
|
this.decryptedLoginCache = null;
|
2017-01-04 00:40:07 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.encrypt = function (login) {
|
2017-06-27 05:55:51 +02:00
|
|
|
var self = this;
|
|
|
|
|
2017-01-04 00:40:07 +01:00
|
|
|
var model = {
|
|
|
|
id: login.id,
|
|
|
|
folderId: login.folderId,
|
2017-04-24 19:58:32 +02:00
|
|
|
favorite: login.favorite,
|
|
|
|
organizationId: login.organizationId
|
2017-01-04 00:40:07 +01:00
|
|
|
};
|
|
|
|
|
2017-04-24 19:58:32 +02:00
|
|
|
var orgKey = null;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.getOrgKey(login.organizationId).then(function (key) {
|
2017-04-24 19:58:32 +02:00
|
|
|
orgKey = key;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.encrypt(login.name, orgKey);
|
2017-04-24 19:58:32 +02:00
|
|
|
}).then(function (cs) {
|
2017-01-04 00:40:07 +01:00
|
|
|
model.name = cs;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.encrypt(login.uri, orgKey);
|
2017-01-04 00:40:07 +01:00
|
|
|
}).then(function (cs) {
|
|
|
|
model.uri = cs;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.encrypt(login.username, orgKey);
|
2017-01-04 00:40:07 +01:00
|
|
|
}).then(function (cs) {
|
|
|
|
model.username = cs;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.encrypt(login.password, orgKey);
|
2017-01-04 00:40:07 +01:00
|
|
|
}).then(function (cs) {
|
|
|
|
model.password = cs;
|
2017-06-27 05:55:51 +02:00
|
|
|
return self.cryptoService.encrypt(login.notes, orgKey);
|
2017-01-04 00:40:07 +01:00
|
|
|
}).then(function (cs) {
|
|
|
|
model.notes = cs;
|
2017-07-11 20:05:04 +02:00
|
|
|
return self.cryptoService.encrypt(login.totp, orgKey);
|
|
|
|
}).then(function (cs) {
|
|
|
|
model.totp = cs;
|
2017-01-04 00:40:07 +01:00
|
|
|
return model;
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.get = function (id, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
this.userService.getUserId(function (userId) {
|
|
|
|
var loginsKey = 'sites_' + userId;
|
2017-08-29 18:52:11 +02:00
|
|
|
var localDataKey = 'sitesLocalData';
|
2017-01-04 00:40:07 +01:00
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
chrome.storage.local.get(localDataKey, function (localDataObj) {
|
|
|
|
var localData = localDataObj[localDataKey];
|
|
|
|
if (!localData) {
|
|
|
|
localData = {};
|
2017-01-04 00:40:07 +01:00
|
|
|
}
|
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
chrome.storage.local.get(loginsKey, function (obj) {
|
|
|
|
var logins = obj[loginsKey];
|
|
|
|
if (logins && id in logins) {
|
|
|
|
callback(new Login(logins[id], false, localData[id]));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
callback(null);
|
|
|
|
});
|
2017-01-04 00:40:07 +01:00
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.getAll = function (callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
this.userService.getUserId(function (userId) {
|
|
|
|
var loginsKey = 'sites_' + userId;
|
2017-08-29 18:52:11 +02:00
|
|
|
var localDataKey = 'sitesLocalData';
|
2017-01-04 00:40:07 +01:00
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
chrome.storage.local.get(localDataKey, function (localDataObj) {
|
|
|
|
var localData = localDataObj[localDataKey];
|
|
|
|
if (!localData) {
|
|
|
|
localData = {};
|
2017-01-04 00:40:07 +01:00
|
|
|
}
|
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
chrome.storage.local.get(loginsKey, function (obj) {
|
|
|
|
var logins = obj[loginsKey];
|
|
|
|
var response = [];
|
|
|
|
for (var id in logins) {
|
|
|
|
if (!id) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
response.push(new Login(logins[id], false, localData[id]));
|
|
|
|
}
|
|
|
|
|
|
|
|
callback(response);
|
|
|
|
});
|
2017-01-04 00:40:07 +01:00
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.getAllDecrypted = function () {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
var self = this;
|
|
|
|
|
2017-06-27 05:55:51 +02:00
|
|
|
self.cryptoService.getKey().then(function (key) {
|
2017-01-04 00:40:07 +01:00
|
|
|
if (!key) {
|
|
|
|
deferred.reject();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (self.decryptedLoginCache) {
|
|
|
|
deferred.resolve(self.decryptedLoginCache);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
var promises = [];
|
|
|
|
var decLogins = [];
|
|
|
|
self.getAll(function (logins) {
|
|
|
|
for (var i = 0; i < logins.length; i++) {
|
|
|
|
promises.push(logins[i].decrypt().then(function (login) {
|
|
|
|
decLogins.push(login);
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
Q.all(promises).then(function () {
|
|
|
|
self.decryptedLoginCache = decLogins;
|
|
|
|
deferred.resolve(self.decryptedLoginCache);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.getAllDecryptedForFolder = function (folderId) {
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
return self.getAllDecrypted().then(function (logins) {
|
|
|
|
var loginsToReturn = [];
|
|
|
|
for (var i = 0; i < logins.length; i++) {
|
|
|
|
if (logins[i].folderId === folderId) {
|
|
|
|
loginsToReturn.push(logins[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return loginsToReturn;
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.getAllDecryptedForDomain = function (domain) {
|
|
|
|
var self = this;
|
|
|
|
|
2017-01-14 19:43:59 +01:00
|
|
|
var eqDomainsPromise = self.settingsService.getEquivalentDomains().then(function (eqDomains) {
|
|
|
|
var matchingDomains = [];
|
|
|
|
for (var i = 0; i < eqDomains.length; i++) {
|
2017-01-18 03:43:26 +01:00
|
|
|
if (eqDomains[i].length && eqDomains[i].indexOf(domain) >= 0) {
|
|
|
|
matchingDomains = matchingDomains.concat(eqDomains[i]);
|
2017-01-14 19:43:59 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-14 23:58:22 +01:00
|
|
|
if (!matchingDomains.length) {
|
|
|
|
matchingDomains.push(domain);
|
|
|
|
}
|
|
|
|
|
2017-01-14 19:43:59 +01:00
|
|
|
return matchingDomains;
|
|
|
|
});
|
|
|
|
|
|
|
|
var loginsPromise = self.getAllDecrypted().then(function (logins) {
|
|
|
|
return logins;
|
|
|
|
});
|
|
|
|
|
|
|
|
return Q.all([eqDomainsPromise, loginsPromise]).then(function (result) {
|
|
|
|
var matchingDomains = result[0];
|
|
|
|
var logins = result[1];
|
2017-01-04 00:40:07 +01:00
|
|
|
var loginsToReturn = [];
|
|
|
|
for (var i = 0; i < logins.length; i++) {
|
2017-01-14 19:43:59 +01:00
|
|
|
if (logins[i].domain && matchingDomains.indexOf(logins[i].domain) >= 0) {
|
2017-01-04 00:40:07 +01:00
|
|
|
loginsToReturn.push(logins[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return loginsToReturn;
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-09-08 05:26:56 +02:00
|
|
|
LoginService.prototype.getLastUsedForDomain = function (domain) {
|
|
|
|
var self = this;
|
|
|
|
var deferred = Q.defer();
|
|
|
|
self.getAllDecryptedForDomain(domain).then(function (logins) {
|
|
|
|
if (!logins.length) {
|
|
|
|
deferred.reject();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
var sortedLogins = logins.sort(self.sortLoginsByLastUsed);
|
|
|
|
deferred.resolve(sortedLogins[0]);
|
|
|
|
});
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
2017-01-04 00:40:07 +01:00
|
|
|
LoginService.prototype.saveWithServer = function (login) {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
|
|
|
|
var self = this,
|
2017-09-20 23:13:38 +02:00
|
|
|
request = new CipherRequest(login, 1); // 1 = Login
|
2017-01-04 00:40:07 +01:00
|
|
|
|
|
|
|
if (!login.id) {
|
2017-09-20 23:13:38 +02:00
|
|
|
self.apiService.postCipher(request, apiSuccess, function (response) {
|
2017-07-14 21:34:05 +02:00
|
|
|
handleError(response, deferred);
|
2017-01-04 00:40:07 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
else {
|
2017-09-20 23:13:38 +02:00
|
|
|
self.apiService.putCipher(login.id, request, apiSuccess, function (response) {
|
2017-07-14 21:34:05 +02:00
|
|
|
handleError(response, deferred);
|
2017-01-04 00:40:07 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function apiSuccess(response) {
|
|
|
|
login.id = response.id;
|
2017-07-11 20:05:04 +02:00
|
|
|
self.userService.getUserId(function (userId) {
|
2017-01-04 00:40:07 +01:00
|
|
|
var data = new LoginData(response, userId);
|
|
|
|
self.upsert(data, function () {
|
|
|
|
deferred.resolve(login);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.upsert = function (login, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
2017-06-27 05:55:51 +02:00
|
|
|
self.userService.getUserId(function (userId) {
|
2017-01-04 00:40:07 +01:00
|
|
|
var loginsKey = 'sites_' + userId;
|
|
|
|
|
|
|
|
chrome.storage.local.get(loginsKey, function (obj) {
|
|
|
|
var logins = obj[loginsKey];
|
|
|
|
if (!logins) {
|
|
|
|
logins = {};
|
|
|
|
}
|
|
|
|
|
|
|
|
if (login.constructor === Array) {
|
|
|
|
for (var i = 0; i < login.length; i++) {
|
|
|
|
logins[login[i].id] = login[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
logins[login.id] = login;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj[loginsKey] = logins;
|
|
|
|
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
self.decryptedLoginCache = null;
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
LoginService.prototype.updateLastUsedDate = function (id, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
var localDataKey = 'sitesLocalData';
|
|
|
|
|
|
|
|
chrome.storage.local.get(localDataKey, function (obj) {
|
|
|
|
var loginsLocalData = obj[localDataKey];
|
|
|
|
if (!loginsLocalData) {
|
|
|
|
loginsLocalData = {};
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loginsLocalData[id]) {
|
|
|
|
loginsLocalData[id].lastUsedDate = new Date().getTime();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
loginsLocalData[id] = {
|
|
|
|
lastUsedDate: new Date().getTime()
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
obj[localDataKey] = loginsLocalData;
|
|
|
|
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
if (self.decryptedLoginCache) {
|
|
|
|
for (var i = 0; i < self.decryptedLoginCache.length; i++) {
|
|
|
|
if (self.decryptedLoginCache[i].id === id) {
|
|
|
|
self.decryptedLoginCache[i].localData = loginsLocalData[id];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-01-04 00:40:07 +01:00
|
|
|
LoginService.prototype.replace = function (logins, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
2017-06-27 05:55:51 +02:00
|
|
|
self.userService.getUserId(function (userId) {
|
2017-01-04 00:40:07 +01:00
|
|
|
var obj = {};
|
|
|
|
obj['sites_' + userId] = logins;
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
self.decryptedLoginCache = null;
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.clear = function (userId, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
chrome.storage.local.remove('sites_' + userId, function () {
|
|
|
|
self.decryptedLoginCache = null;
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.delete = function (id, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
2017-06-27 05:55:51 +02:00
|
|
|
self.userService.getUserId(function (userId) {
|
2017-01-04 00:40:07 +01:00
|
|
|
var loginsKey = 'sites_' + userId;
|
|
|
|
|
|
|
|
chrome.storage.local.get(loginsKey, function (obj) {
|
|
|
|
var logins = obj[loginsKey];
|
|
|
|
if (!logins) {
|
|
|
|
callback();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id.constructor === Array) {
|
|
|
|
for (var i = 0; i < id.length; i++) {
|
|
|
|
if (id[i] in logins) {
|
|
|
|
delete logins[id[i]];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (id in logins) {
|
|
|
|
delete logins[id];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
callback();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj[loginsKey] = logins;
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
self.decryptedLoginCache = null;
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.deleteWithServer = function (id) {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
self.apiService.deleteCipher(id, function () {
|
|
|
|
self.delete(id, function () {
|
|
|
|
deferred.resolve();
|
|
|
|
});
|
|
|
|
}, function (response) {
|
2017-07-12 15:57:08 +02:00
|
|
|
handleError(response, deferred);
|
2017-01-04 00:40:07 +01:00
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
2017-06-13 19:59:16 +02:00
|
|
|
LoginService.prototype.saveNeverDomain = function (domain) {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
var neverKey = 'neverDomains';
|
|
|
|
|
|
|
|
if (!domain) {
|
|
|
|
deferred.resolve();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
chrome.storage.local.get(neverKey, function (obj) {
|
|
|
|
var domains = obj[neverKey];
|
|
|
|
if (!domains) {
|
|
|
|
domains = {};
|
|
|
|
}
|
|
|
|
|
|
|
|
domains[domain] = null;
|
|
|
|
obj[neverKey] = domains;
|
|
|
|
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
deferred.resolve();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
2017-07-12 15:57:08 +02:00
|
|
|
LoginService.prototype.saveAttachmentWithServer = function (login, unencryptedFile) {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
var key, encFileName;
|
|
|
|
var reader = new FileReader();
|
|
|
|
reader.readAsArrayBuffer(unencryptedFile);
|
|
|
|
reader.onload = function (evt) {
|
|
|
|
self.cryptoService.getOrgKey(login.organizationId).then(function (theKey) {
|
|
|
|
key = theKey;
|
|
|
|
return self.cryptoService.encrypt(unencryptedFile.name, key);
|
|
|
|
}).then(function (fileName) {
|
|
|
|
encFileName = fileName;
|
|
|
|
return self.cryptoService.encryptToBytes(evt.target.result, key);
|
|
|
|
}).then(function (encData) {
|
|
|
|
var fd = new FormData();
|
|
|
|
var blob = new Blob([encData], { type: 'application/octet-stream' });
|
|
|
|
fd.append('data', blob, encFileName.encryptedString);
|
|
|
|
|
|
|
|
self.apiService.postCipherAttachment(login.id, fd,
|
|
|
|
function (response) {
|
|
|
|
self.userService.getUserId(function (userId) {
|
|
|
|
var data = new LoginData(response, userId);
|
|
|
|
self.upsert(data, function () {
|
|
|
|
deferred.resolve(new Login(data));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
},
|
|
|
|
function (response) {
|
2017-07-12 19:38:06 +02:00
|
|
|
handleErrorMessage(response, deferred);
|
2017-07-12 15:57:08 +02:00
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
reader.onerror = function (evt) {
|
|
|
|
deferred.reject('Error reading file.');
|
|
|
|
};
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.deleteAttachment = function (id, attachmentId, callback) {
|
|
|
|
if (!callback || typeof callback !== 'function') {
|
|
|
|
throw 'callback function required';
|
|
|
|
}
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
self.userService.getUserId(function (userId) {
|
|
|
|
var loginsKey = 'sites_' + userId;
|
|
|
|
|
|
|
|
chrome.storage.local.get(loginsKey, function (obj) {
|
|
|
|
var logins = obj[loginsKey];
|
|
|
|
if (logins && id in logins && logins[id].attachments) {
|
|
|
|
for (var i = 0; i < logins[id].attachments.length; i++) {
|
|
|
|
if (logins[id].attachments[i].id === attachmentId) {
|
|
|
|
logins[id].attachments.splice(i, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
obj[loginsKey] = logins;
|
|
|
|
chrome.storage.local.set(obj, function () {
|
|
|
|
self.decryptedLoginCache = null;
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
else {
|
2017-07-14 21:34:05 +02:00
|
|
|
callback();
|
2017-07-12 15:57:08 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
LoginService.prototype.deleteAttachmentWithServer = function (id, attachmentId) {
|
|
|
|
var deferred = Q.defer();
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
self.apiService.deleteCipherAttachment(id, attachmentId, function () {
|
|
|
|
self.deleteAttachment(id, attachmentId, function () {
|
|
|
|
deferred.resolve();
|
|
|
|
});
|
|
|
|
}, function (response) {
|
2017-07-12 19:38:06 +02:00
|
|
|
handleErrorMessage(response, deferred);
|
2017-07-12 15:57:08 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
LoginService.prototype.sortLoginsByLastUsed = sortLoginsByLastUsed;
|
2017-08-29 18:52:11 +02:00
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
LoginService.prototype.sortLoginsByLastUsedThenName = function (a, b) {
|
|
|
|
var result = sortLoginsByLastUsed(a, b);
|
|
|
|
if (result !== 0) {
|
|
|
|
return result;
|
2017-08-29 18:52:11 +02:00
|
|
|
}
|
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
var nameA = (a.name + '_' + a.username).toUpperCase();
|
|
|
|
var nameB = (b.name + '_' + b.username).toUpperCase();
|
|
|
|
|
|
|
|
if (nameA < nameB) {
|
2017-08-29 19:03:08 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2017-08-30 14:43:06 +02:00
|
|
|
if (nameA > nameB) {
|
2017-08-29 19:03:08 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-08-29 18:52:11 +02:00
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
function sortLoginsByLastUsed(a ,b) {
|
|
|
|
var aLastUsed = a.localData && a.localData.lastUsedDate ? a.localData.lastUsedDate : null;
|
|
|
|
var bLastUsed = b.localData && b.localData.lastUsedDate ? b.localData.lastUsedDate : null;
|
2017-08-30 14:35:34 +02:00
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
if (aLastUsed && bLastUsed && aLastUsed < bLastUsed) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (aLastUsed && !bLastUsed) {
|
|
|
|
return -1;
|
|
|
|
}
|
2017-08-30 14:35:34 +02:00
|
|
|
|
2017-08-30 14:43:06 +02:00
|
|
|
if (bLastUsed && aLastUsed && aLastUsed > bLastUsed) {
|
2017-08-30 14:35:34 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2017-08-30 14:43:06 +02:00
|
|
|
if (bLastUsed && !aLastUsed) {
|
2017-08-30 14:35:34 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-08-30 14:43:06 +02:00
|
|
|
}
|
2017-08-30 14:35:34 +02:00
|
|
|
|
2017-01-04 00:40:07 +01:00
|
|
|
function handleError(error, deferred) {
|
|
|
|
deferred.reject(error);
|
|
|
|
}
|
2017-07-12 19:38:06 +02:00
|
|
|
|
|
|
|
function handleErrorMessage(error, deferred) {
|
|
|
|
if (error.validationErrors) {
|
|
|
|
for (var key in error.validationErrors) {
|
|
|
|
if (!error.validationErrors.hasOwnProperty(key)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (error.validationErrors[key].length) {
|
|
|
|
deferred.reject(error.validationErrors[key][0]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
deferred.reject(error.message);
|
|
|
|
return;
|
|
|
|
}
|
2017-07-14 21:34:05 +02:00
|
|
|
}
|