refactoring with promises throughout

src/services/cryptoService.js

@@ -98,41 +98,39 @@ function initCryptoService() {
         });
     };
 
-    CryptoService.prototype.encrypt = function (plaintextValue, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
+    CryptoService.prototype.encrypt = function (plaintextValue) {
+        var deferred = Q.defer();
 
         if (plaintextValue === null || plaintextValue === undefined) {
-            callback(null);
-            return;
+            deferred.resolve(null);
+        }
+        else {
+            this.getKey(false, function (key) {
+                if (!key) {
+                    throw 'Encryption key unavailable.';
+                }
+
+                var response = {};
+                var params = {
+                    mode: "cbc",
+                    iv: sjcl.random.randomWords(4, 0)
+                };
+
+                var ctJson = sjcl.encrypt(key, plaintextValue, params, response);
+
+                var ct = ctJson.match(/"ct":"([^"]*)"/)[1];
+                var iv = sjcl.codec.base64.fromBits(response.iv);
+
+                var cs = new CipherString(iv + "|" + ct);
+                deferred.resolve(cs);
+            });
         }
 
-        this.getKey(false, function (key) {
-            if (!key) {
-                throw 'Encryption key unavailable.';
-            }
-
-            var response = {};
-            var params = {
-                mode: "cbc",
-                iv: sjcl.random.randomWords(4, 0)
-            };
-
-            var ctJson = sjcl.encrypt(key, plaintextValue, params, response);
-
-            var ct = ctJson.match(/"ct":"([^"]*)"/)[1];
-            var iv = sjcl.codec.base64.fromBits(response.iv);
-
-            var cs = new CipherString(iv + "|" + ct);
-            callback(cs);
-        });
+        return deferred.promise;
     };
 
-    CryptoService.prototype.decrypt = function (cipherString, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
+    CryptoService.prototype.decrypt = function (cipherString) {
+        var deferred = Q.defer();
 
         if (cipherString === null || cipherString === undefined || !cipherString.encryptedString) {
             throw 'cannot decrypt nothing';
@@ -148,7 +146,9 @@ function initCryptoService() {
 
             var decBits = sjcl.mode.cbc.decrypt(aes, ctBits, ivBits, null);
             var decValue = sjcl.codec.utf8String.fromBits(decBits);
-            callback(decValue);
+            deferred.resolve(decValue);
         });
+
+        return deferred.promise;
     };
 };

src/services/folderService.js

@@ -13,26 +13,12 @@ function initFolderService() {
             id: folder.id
         };
 
-        var deferred = Q.defer();
-
-        encryptWithPromise(folder.name).then(function (cs) {
+        return cryptoService.encrypt(folder.name).then(function (cs) {
             model.name = cs;
-            deferred.resolve(model);
+            return model;
         });
-
-        return deferred.promise;
     };
 
-    function encryptWithPromise(plaintextString) {
-        var deferred = Q.defer();
-
-        cryptoService.encrypt(plaintextString, function (cipherString) {
-            deferred.resolve(cipherString);
-        });
-
-        return deferred.promise;
-    }
-
     FolderService.prototype.get = function (id, callback) {
         if (!callback || typeof callback !== 'function') {
             throw 'callback function required';
@@ -101,10 +87,8 @@ function initFolderService() {
         return deferred.promise;
     };
 
-    FolderService.prototype.saveWithServer = function (folder, callback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
+    FolderService.prototype.saveWithServer = function (folder) {
+        var deferred = Q.defer();
 
         var self = this,
             request = new FolderRequest(folder);
@@ -121,10 +105,12 @@ function initFolderService() {
             userService.getUserId(function (userId) {
                 var data = new FolderData(response, userId);
                 self.upsert(data, function () {
-                    callback(folder);
+                    deferred.resolve(folder);
                 });
             });
         }
+
+        return deferred.promise;
     };
 
     FolderService.prototype.upsert = function (folder, callback) {

src/services/siteService.js

@@ -15,38 +15,24 @@ function initSiteService() {
             favorite: site.favorite
         };
 
-        var deferred = Q.defer();
-
-        encryptWithPromise(site.name).then(function (cs) {
+        return cryptoService.encrypt(site.name).then(function (cs) {
             model.name = cs;
-            return encryptWithPromise(site.uri);
+            return cryptoService.encrypt(site.uri);
         }).then(function (cs) {
             model.uri = cs;
-            return encryptWithPromise(site.username);
+            return cryptoService.encrypt(site.username);
         }).then(function (cs) {
             model.username = cs;
-            return encryptWithPromise(site.password);
+            return cryptoService.encrypt(site.password);
         }).then(function (cs) {
             model.password = cs;
-            return encryptWithPromise(site.notes);
+            return cryptoService.encrypt(site.notes);
         }).then(function (cs) {
             model.notes = cs;
-            deferred.resolve(model);
+            return model;
         });
-
-        return deferred.promise;
     };
 
-    function encryptWithPromise(plaintextString) {
-        var deferred = Q.defer();
-
-        cryptoService.encrypt(plaintextString, function (cipherString) {
-            deferred.resolve(cipherString);
-        });
-
-        return deferred.promise;
-    }
-
     SiteService.prototype.get = function (id, callback) {
         if (!callback || typeof callback !== 'function') {
             throw 'callback function required';
@@ -118,18 +104,20 @@ function initSiteService() {
         return deferred.promise;
     };
 
-    SiteService.prototype.saveWithServer = function (site, successCallback, errorCallback) {
+    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, errorCallback)
+                handleError(response, deferred)
             });
         }
         else {
             self.apiService.putSite(site.id, request, apiSuccess, function (response) {
-                handleError(response, errorCallback)
+                handleError(response, deferred)
             });
         }
 
@@ -138,12 +126,12 @@ function initSiteService() {
             userService.getUserId(function (userId) {
                 var data = new SiteData(response, userId);
                 self.upsert(data, function () {
-                    if (successCallback) {
-                        successCallback(site);
-                    }
+                    deferred.resolve(site);
                 });
             });
         }
+
+        return deferred.promise;
     };
 
     SiteService.prototype.upsert = function (site, callback) {
@@ -230,27 +218,26 @@ function initSiteService() {
         });
     };
 
-    SiteService.prototype.deleteWithServer = function (id, successCallback, errorCallback) {
-        if (!callback || typeof callback !== 'function') {
-            throw 'callback function required';
-        }
+    SiteService.prototype.deleteWithServer = function (id) {
+        var deferred = Q.defer();
 
         var self = this;
         self.apiService.deleteCipher(id, function (response) {
-            self.delete(id, successCallback);
+            self.delete(id, function () {
+                deferred.resolve();
+            });
         }, function (response) {
-            handleError(response, errorCallback)
+            handleError(response, deferred)
         });
+
+        return deferred.promise;
     };
 
-    function handleError(error, callback) {
+    function handleError(error, deferred) {
         if (error.status == 401 || error.status == 403) {
             // TODO: logout
-
         }
 
-        if (callback) {
-            callback(error);
-        }
+        deferred.reject(error);
     }
 };