Refactored rename of Sites => Logins

src/services/apiService.js

@@ -97,9 +97,9 @@ function initApiService() {
         });
     };
 
-    // Site APIs
+    // Login APIs
 
-    ApiService.prototype.getSite = function (id, success, error) {
+    ApiService.prototype.getLogin = function (id, success, error) {
         var self = this;
         this.tokenService.getToken(function (token) {
             $.ajax({
@@ -107,7 +107,7 @@ function initApiService() {
                 url: self.baseUrl + '/sites/' + id + '?access_token=' + token,
                 dataType: 'json',
                 success: function (response) {
-                    success(new SiteResponse(response));
+                    success(new LoginResponse(response));
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
                     handleError(error, jqXHR, textStatus, errorThrown);
@@ -116,17 +116,17 @@ function initApiService() {
         });
     };
 
-    ApiService.prototype.postSite = function (siteRequest, success, error) {
+    ApiService.prototype.postLogin = function (loginRequest, success, error) {
         var self = this;
         this.tokenService.getToken(function (token) {
             $.ajax({
                 type: 'POST',
                 url: self.baseUrl + '/sites?access_token=' + token,
-                data: JSON.stringify(siteRequest),
+                data: JSON.stringify(loginRequest),
                 contentType: 'application/json; charset=utf-8',
                 dataType: 'json',
                 success: function (response) {
-                    success(new SiteResponse(response));
+                    success(new LoginResponse(response));
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
                     handleError(error, jqXHR, textStatus, errorThrown);
@@ -135,17 +135,17 @@ function initApiService() {
         });
     };
 
-    ApiService.prototype.putSite = function (id, siteRequest, success, error) {
+    ApiService.prototype.putLogin = function (id, loginRequest, success, error) {
         var self = this;
         this.tokenService.getToken(function (token) {
             $.ajax({
                 type: 'POST',
                 url: self.baseUrl + '/sites/' + id + '?access_token=' + token,
-                data: JSON.stringify(siteRequest),
+                data: JSON.stringify(loginRequest),
                 contentType: 'application/json; charset=utf-8',
                 dataType: 'json',
                 success: function (response) {
-                    success(new SiteResponse(response));
+                    success(new LoginResponse(response));
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
                     handleError(error, jqXHR, textStatus, errorThrown);

src/services/constantsService.js

@@ -1,7 +1,7 @@
 function ConstantsService() {
     return {
         disableGaKey: 'disableGa',
-        disableAddSiteNotificationKey: 'disableAddSiteNotification',
+        disableAddLoginNotificationKey: 'disableAddLoginNotification',
         lockOptionKey: 'lockOption',
         lastActiveKey: 'lastActive'
     };

src/services/loginService.js

@@ -0,0 +1,302 @@
+function LoginService(cryptoService, userService, apiService) {
+    this.cryptoService = cryptoService;
+    this.userService = userService;
+    this.apiService = apiService;
+    this.decryptedLoginCache = null;
+
+    initLoginService();
+};
+
+function initLoginService() {
+    LoginService.prototype.clearCache = function () {
+        this.decryptedLoginCache = null
+    };
+
+    LoginService.prototype.encrypt = function (login) {
+        var model = {
+            id: login.id,
+            folderId: login.folderId,
+            favorite: login.favorite
+        };
+
+        return cryptoService.encrypt(login.name).then(function (cs) {
+            model.name = cs;
+            return cryptoService.encrypt(login.uri);
+        }).then(function (cs) {
+            model.uri = cs;
+            return cryptoService.encrypt(login.username);
+        }).then(function (cs) {
+            model.username = cs;
+            return cryptoService.encrypt(login.password);
+        }).then(function (cs) {
+            model.password = cs;
+            return cryptoService.encrypt(login.notes);
+        }).then(function (cs) {
+            model.notes = cs;
+            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;
+
+            chrome.storage.local.get(loginsKey, function (obj) {
+                var logins = obj[loginsKey];
+                if (logins && id in logins) {
+                    callback(new Login(logins[id]));
+                    return;
+                }
+
+                callback(null);
+            });
+        });
+    };
+
+    LoginService.prototype.getAll = function (callback) {
+        if (!callback || typeof callback !== 'function') {
+            throw 'callback function required';
+        }
+
+        this.userService.getUserId(function (userId) {
+            var loginsKey = 'sites_' + userId;
+
+            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]));
+                }
+
+                callback(response);
+            });
+        });
+    };
+
+    LoginService.prototype.getAllDecrypted = function () {
+        var deferred = Q.defer();
+        var self = this;
+
+        cryptoService.getKey(false, function (key) {
+            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;
+
+        return self.getAllDecrypted().then(function (logins) {
+            var loginsToReturn = [];
+            for (var i = 0; i < logins.length; i++) {
+                if (logins[i].domain === domain) {
+                    loginsToReturn.push(logins[i]);
+                }
+            }
+
+            return loginsToReturn;
+        });
+    };
+
+    LoginService.prototype.saveWithServer = function (login) {
+        var deferred = Q.defer();
+
+        var self = this,
+            request = new LoginRequest(login);
+
+        if (!login.id) {
+            self.apiService.postLogin(request, apiSuccess, function (response) {
+                handleError(response, deferred)
+            });
+        }
+        else {
+            self.apiService.putLogin(login.id, request, apiSuccess, function (response) {
+                handleError(response, deferred)
+            });
+        }
+
+        function apiSuccess(response) {
+            login.id = response.id;
+            userService.getUserId(function (userId) {
+                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;
+
+        userService.getUserId(function (userId) {
+            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();
+                });
+            });
+        });
+    };
+
+    LoginService.prototype.replace = function (logins, callback) {
+        if (!callback || typeof callback !== 'function') {
+            throw 'callback function required';
+        }
+
+        var self = this;
+
+        userService.getUserId(function (userId) {
+            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;
+
+        userService.getUserId(function (userId) {
+            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) {
+            handleError(response, deferred)
+        });
+
+        return deferred.promise;
+    };
+
+    function handleError(error, deferred) {
+        deferred.reject(error);
+    }
+};

src/services/siteService.js

@@ -1,302 +0,0 @@
-function SiteService(cryptoService, userService, apiService) {
-    this.cryptoService = cryptoService;
-    this.userService = userService;
-    this.apiService = apiService;
-    this.decryptedSiteCache = null;
-
-    initSiteService();
-};
-
-function initSiteService() {
-    SiteService.prototype.clearCache = function () {
-        this.decryptedSiteCache = null
-    };
-
-    SiteService.prototype.encrypt = function (site) {
-        var model = {
-            id: site.id,
-            folderId: site.folderId,
-            favorite: site.favorite
-        };
-
-        return cryptoService.encrypt(site.name).then(function (cs) {
-            model.name = cs;
-            return cryptoService.encrypt(site.uri);
-        }).then(function (cs) {
-            model.uri = cs;
-            return cryptoService.encrypt(site.username);
-        }).then(function (cs) {
-            model.username = cs;
-            return cryptoService.encrypt(site.password);
-        }).then(function (cs) {
-            model.password = cs;
-            return cryptoService.encrypt(site.notes);
-        }).then(function (cs) {
-            model.notes = cs;
-            return model;
-        });
-    };
-
-    SiteService.prototype.get = function (id, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
-
-        this.userService.getUserId(function (userId) {
-            var sitesKey = 'sites_' + userId;
-
-            chrome.storage.local.get(sitesKey, function (obj) {
-                var sites = obj[sitesKey];
-                if (sites && id in sites) {
-                    callback(new Site(sites[id]));
-                    return;
-                }
-
-                callback(null);
-            });
-        });
-    };
-
-    SiteService.prototype.getAll = function (callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
-
-        this.userService.getUserId(function (userId) {
-            var sitesKey = 'sites_' + userId;
-
-            chrome.storage.local.get(sitesKey, function (obj) {
-                var sites = obj[sitesKey];
-                var response = [];
-                for (var id in sites) {
-                    if (!id) {
-                        continue;
-                    }
-
-                    response.push(new Site(sites[id]));
-                }
-
-                callback(response);
-            });
-        });
-    };
-
-    SiteService.prototype.getAllDecrypted = function () {
-        var deferred = Q.defer();
-        var self = this;
-
-        cryptoService.getKey(false, function (key) {
-            if (!key) {
-                deferred.reject();
-                return;
-            }
-
-            if (self.decryptedSiteCache) {
-                deferred.resolve(self.decryptedSiteCache);
-                return;
-            }
-
-            var promises = [];
-            var decSites = [];
-            self.getAll(function (sites) {
-                for (var i = 0; i < sites.length; i++) {
-                    promises.push(sites[i].decrypt().then(function (site) {
-                        decSites.push(site);
-                    }));
-                }
-
-                Q.all(promises).then(function () {
-                    self.decryptedSiteCache = decSites;
-                    deferred.resolve(self.decryptedSiteCache);
-                });
-            });
-        });
-
-        return deferred.promise;
-    };
-
-    SiteService.prototype.getAllDecryptedForFolder = function (folderId) {
-        var self = this;
-
-        return self.getAllDecrypted().then(function (sites) {
-            var sitesToReturn = [];
-            for (var i = 0; i < sites.length; i++) {
-                if (sites[i].folderId === folderId) {
-                    sitesToReturn.push(sites[i]);
-                }
-            }
-
-            return sitesToReturn;
-        });
-    };
-
-    SiteService.prototype.getAllDecryptedForDomain = function (domain) {
-        var self = this;
-
-        return self.getAllDecrypted().then(function (sites) {
-            var sitesToReturn = [];
-            for (var i = 0; i < sites.length; i++) {
-                if (sites[i].domain === domain) {
-                    sitesToReturn.push(sites[i]);
-                }
-            }
-
-            return sitesToReturn;
-        });
-    };
-
-    SiteService.prototype.saveWithServer = function (site) {
-        var deferred = Q.defer();
-
-        var self = this,
-            request = new SiteRequest(site);
-
-        if (!site.id) {
-            self.apiService.postSite(request, apiSuccess, function (response) {
-                handleError(response, deferred)
-            });
-        }
-        else {
-            self.apiService.putSite(site.id, request, apiSuccess, function (response) {
-                handleError(response, deferred)
-            });
-        }
-
-        function apiSuccess(response) {
-            site.id = response.id;
-            userService.getUserId(function (userId) {
-                var data = new SiteData(response, userId);
-                self.upsert(data, function () {
-                    deferred.resolve(site);
-                });
-            });
-        }
-
-        return deferred.promise;
-    };
-
-    SiteService.prototype.upsert = function (site, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
-
-        var self = this;
-
-        userService.getUserId(function (userId) {
-            var sitesKey = 'sites_' + userId;
-
-            chrome.storage.local.get(sitesKey, function (obj) {
-                var sites = obj[sitesKey];
-                if (!sites) {
-                    sites = {};
-                }
-
-                if (site.constructor === Array) {
-                    for (var i = 0; i < site.length; i++) {
-                        sites[site[i].id] = site[i];
-                    }
-                }
-                else {
-                    sites[site.id] = site;
-                }
-
-                obj[sitesKey] = sites;
-
-                chrome.storage.local.set(obj, function () {
-                    self.decryptedSiteCache = null;
-                    callback();
-                });
-            });
-        });
-    };
-
-    SiteService.prototype.replace = function (sites, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
-
-        var self = this;
-
-        userService.getUserId(function (userId) {
-            var obj = {};
-            obj['sites_' + userId] = sites;
-            chrome.storage.local.set(obj, function () {
-                self.decryptedSiteCache = null;
-                callback();
-            });
-        });
-    };
-
-    SiteService.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.decryptedSiteCache = null;
-            callback();
-        });
-    };
-
-    SiteService.prototype.delete = function (id, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
-
-        var self = this;
-
-        userService.getUserId(function (userId) {
-            var sitesKey = 'sites_' + userId;
-
-            chrome.storage.local.get(sitesKey, function (obj) {
-                var sites = obj[sitesKey];
-                if (!sites) {
-                    callback();
-                    return;
-                }
-
-                if (id.constructor === Array) {
-                    for (var i = 0; i < id.length; i++) {
-                        if (id[i] in sites) {
-                            delete sites[id[i]];
-                        }
-                    }
-                }
-                else if (id in sites) {
-                    delete sites[id];
-                }
-                else {
-                    callback();
-                    return;
-                }
-
-                obj[sitesKey] = sites;
-                chrome.storage.local.set(obj, function () {
-                    self.decryptedSiteCache = null;
-                    callback();
-                });
-            });
-        });
-    };
-
-    SiteService.prototype.deleteWithServer = function (id) {
-        var deferred = Q.defer();
-
-        var self = this;
-        self.apiService.deleteCipher(id, function () {
-            self.delete(id, function () {
-                deferred.resolve();
-            });
-        }, function (response) {
-            handleError(response, deferred)
-        });
-
-        return deferred.promise;
-    };
-
-    function handleError(error, deferred) {
-        deferred.reject(error);
-    }
-};

src/services/syncService.js

@@ -1,5 +1,5 @@
-function SyncService(siteService, folderService, userService, apiService) {
-    this.siteService = siteService;
+function SyncService(loginService, folderService, userService, apiService) {
+    this.loginService = loginService;
     this.folderService = folderService;
     this.userService = userService;
     this.apiService = apiService;
@@ -27,13 +27,13 @@ function initSyncService() {
             self.userService.getUserId(function (userId) {
                 var now = new Date();
                 var ciphers = self.apiService.getCiphers(function (response) {
-                    var sites = {};
+                    var logins = {};
                     var folders = {};
 
                     for (var i = 0; i < response.data.length; i++) {
                         var data = response.data[i];
                         if (data.type === 1) {
-                            sites[data.id] = new SiteData(data, userId);
+                            logins[data.id] = new LoginData(data, userId);
                         }
                         else if (data.type === 0) {
                             folders[data.id] = new FolderData(data, userId);
@@ -41,7 +41,7 @@ function initSyncService() {
                     }
 
                     self.folderService.replace(folders, function () {
-                        self.siteService.replace(sites, function () {
+                        self.loginService.replace(logins, function () {
                             self.setLastSync(now, function () {
                                 self.syncCompleted(true);
                                 callback(true);
@@ -95,7 +95,7 @@ function initSyncService() {
         });
     }
 
-    function syncSites(serverSites, callback) {
+    function syncLogins(serverLogins, callback) {
         var self = this;
 
         self.userService.isAuthenticated(function (isAuthenticated) {
@@ -105,23 +105,23 @@ function initSyncService() {
             }
 
             self.userService.getUserId(function (userId) {
-                self.siteService.getAll(function (sites) {
-                    var localSites = {};
-                    for (var i = 0; i < sites.length; i++) {
-                        localSites[sites[i].id] = sites[i];
+                self.loginService.getAll(function (logins) {
+                    var localLogins = {};
+                    for (var i = 0; i < logins.length; i++) {
+                        localLogins[logins[i].id] = logins[i];
                     }
 
                     var data = [];
-                    for (var j = 0; j < serverSites.length; j++) {
-                        var serverSite = serverSites[j];
-                        var existingLocalSite = localSites[serverSite.id];
+                    for (var j = 0; j < serverLogins.length; j++) {
+                        var serverLogin = serverLogins[j];
+                        var existingLocalLogin = localLogins[serverLogin.id];
 
-                        if (!existingLocalSite || existingLocalSite.RevisionDate !== serverSite.RevisionDate) {
-                            data.push(new SiteData(serverSite, userId));
+                        if (!existingLocalLogin || existingLocalLogin.RevisionDate !== serverLogin.RevisionDate) {
+                            data.push(new LoginData(serverLogin, userId));
                         }
                     }
 
-                    self.siteService.upsert(data, function () {
+                    self.loginService.upsert(data, function () {
                         callback();
                     });
                 });