refactor out callbacks from folderService

src/popup/app/settings/settingsEditFolderController.js

@@ -1,18 +1,18 @@
 angular
     .module('bit.settings')
 
-    .controller('settingsEditFolderController', function ($scope, $stateParams, folderService, toastr, $q, $state, SweetAlert,
+    .controller('settingsEditFolderController', function ($scope, $stateParams, folderService, toastr, $state, SweetAlert,
         utilsService, $analytics, i18nService) {
         $scope.i18n = i18nService;
         $scope.folder = {};
         var folderId = $stateParams.folderId;
         $('#name').focus();
 
-        folderService.get(folderId, function (folder) {
+        folderService.get(folderId).then(function (folder) {
-            $q.when(folder.decrypt()).then(function (model) {
+            return folder.decrypt();
+        }).then(function (model) {
             $scope.folder = model;
         });
-        });
 
         utilsService.initListSectionItemListeners($(document), angular);
 
@@ -23,9 +23,9 @@
                 return;
             }
 
-            $scope.savePromise = $q.when(folderService.encrypt(model)).then(function (folderModel) {
+            $scope.savePromise = folderService.encrypt(model).then(function (folderModel) {
                 var folder = new Folder(folderModel, true);
-                return $q.when(folderService.saveWithServer(folder)).then(function (folder) {
+                return folderService.saveWithServer(folder).then(function (folder) {
                     $analytics.eventTrack('Edited Folder');
                     toastr.success(i18nService.editedFolder);
                     $state.go('folders', { animation: 'out-slide-down' });
@@ -42,7 +42,7 @@
                 cancelButtonText: i18nService.no
             }, function (confirmed) {
                 if (confirmed) {
-                    $q.when(folderService.deleteWithServer(folderId)).then(function () {
+                    folderService.deleteWithServer(folderId).then(function () {
                         $analytics.eventTrack('Deleted Folder');
                         toastr.success(i18nService.deletedFolder);
                         $state.go('folders', {

src/popup/app/settings/settingsFoldersController.js

@@ -7,8 +7,7 @@
 
         load();
         function load() {
-            var foldersPromise = $q.when(folderService.getAllDecrypted());
+            folderService.getAllDecrypted().then(function (folders) {
-            foldersPromise.then(function (folders) {
                 if (folders.length > 0 && folders[0].id === null) {
                     // remove the "none" folder
                     $scope.folders = folders.slice(1);

src/popup/app/tools/toolsExportController.js

@@ -45,14 +45,12 @@
             var decLogins = [];
             var promises = [];
 
-            var folderPromise = $q.when(folderService.getAllDecrypted());
+            var folderPromise = folderService.getAllDecrypted().then(function (folders) {
-            folderPromise.then(function (folders) {
                 decFolders = folders;
             });
             promises.push(folderPromise);
 
-            var loginPromise = $q.when(cipherService.getAllDecrypted());
+            var loginPromise = cipherService.getAllDecrypted().then(function (logins) {
-            loginPromise.then(function (logins) {
                 decLogins = logins;
             });
             promises.push(loginPromise);

src/popup/app/vault/vaultViewFolderController.js

@@ -29,14 +29,12 @@
             var promises = [];
 
             if ($scope.folder.id) {
-                var folderDeferred = $q.defer();
+                var getPromise = folderService.get($scope.folder.id).then(function (folder) {
-                folderService.get($scope.folder.id, function (folder) {
+                    return folder.decrypt();
-                    folder.decrypt().then(function (model) {
+                }).then(function (model) {
                     decFolder = model;
-                        folderDeferred.resolve();
                 });
-                });
+                promises.push(getPromise);
-                promises.push(folderDeferred.promise);
             }
 
             var cipherPromise = cipherService.getAllDecryptedForFolder($scope.folder.id).then(function (ciphers) {

src/services/apiService.js

@@ -191,8 +191,10 @@ function initApiService() {
 
     // Folder APIs
 
-    ApiService.prototype.postFolder = function (folderRequest, success, error) {
+    ApiService.prototype.postFolder = function (folderRequest) {
-        var self = this;
+        var self = this,
+            deferred = Q.defer();
+
         handleTokenState(self).then(function (tokenHeader) {
             $.ajax({
                 type: 'POST',
@@ -202,19 +204,21 @@ function initApiService() {
                 dataType: 'json',
                 headers: tokenHeader,
                 success: function (response) {
-                    success(new FolderResponse(response));
+                    deferred.resolve(new FolderResponse(response));
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
-                    handleError(error, jqXHR, false, self);
+                    handleError(deferred.reject, jqXHR, false, self);
                 }
             });
         }, function (jqXHR) {
-            handleError(error, jqXHR, true, self);
+            handleError(deferred.reject, jqXHR, true, self);
         });
     };
 
-    ApiService.prototype.putFolder = function (id, folderRequest, success, error) {
+    ApiService.prototype.putFolder = function (id, folderRequest) {
-        var self = this;
+        var self = this,
+            deferred = Q.defer();
+
         handleTokenState(self).then(function (tokenHeader) {
             $.ajax({
                 type: 'PUT',
@@ -224,19 +228,21 @@ function initApiService() {
                 dataType: 'json',
                 headers: tokenHeader,
                 success: function (response) {
-                    success(new FolderResponse(response));
+                    deferred.resolve(new FolderResponse(response));
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
-                    handleError(error, jqXHR, false, self);
+                    handleError(deferred.reject, jqXHR, false, self);
                 }
             });
         }, function (jqXHR) {
-            handleError(error, jqXHR, true, self);
+            handleError(deferred.reject, jqXHR, true, self);
         });
     };
 
-    ApiService.prototype.deleteFolder = function (id, success, error) {
+    ApiService.prototype.deleteFolder = function (id) {
-        var self = this;
+        var self = this,
+            deferred = Q.defer();
+
         handleTokenState(self).then(function (tokenHeader) {
             $.ajax({
                 type: 'DELETE',
@@ -244,14 +250,14 @@ function initApiService() {
                 dataType: 'text',
                 headers: tokenHeader,
                 success: function (response) {
-                    success();
+                    deferred.resolve();
                 },
                 error: function (jqXHR, textStatus, errorThrown) {
-                    handleError(error, jqXHR, false, self);
+                    handleError(deferred.reject, jqXHR, false, self);
                 }
             });
         }, function (jqXHR) {
-            handleError(error, jqXHR, true, self);
+            handleError(deferred.reject, jqXHR, true, self);
         });
     };
 

src/services/cipherService.js

@@ -222,7 +222,7 @@ function initCipherService() {
             return self.getAll();
         }).then(function (ciphers) {
             if (ciphers === true) {
-                return;
+                return true;
             }
 
             var promises = [];
@@ -405,7 +405,7 @@ function initCipherService() {
 
     CipherService.prototype.replace = function (ciphers) {
         var self = this;
-        self.userService.getUserIdPromise().then(function (userId) {
+        return self.userService.getUserIdPromise().then(function (userId) {
             return self.utilsService.saveObjToStorage('ciphers_' + userId, ciphers);
         }).then(function () {
             self.decryptedCipherCache = null;
@@ -423,7 +423,7 @@ function initCipherService() {
         var self = this,
             key = null;
 
-        self.userService.getUserIdPromise().then(function () {
+        return self.userService.getUserIdPromise().then(function () {
             key = 'ciphers_' + userId;
             return self.utilsService.getObjFromStorage(key);
         }).then(function (ciphers) {
@@ -535,7 +535,7 @@ function initCipherService() {
         var self = this,
             key = null;
 
-        self.userService.getUserIdPromise().then(function () {
+        return self.userService.getUserIdPromise().then(function () {
             key = 'ciphers_' + userId;
             return self.utilsService.getObjFromStorage(key);
         }).then(function (ciphers) {

src/services/folderService.js

@@ -25,68 +25,62 @@ function initFolderService() {
         });
     };
 
-    FolderService.prototype.get = function (id, callback) {
+    FolderService.prototype.get = function (id) {
-        if (!callback || typeof callback !== 'function') {
+        var self = this;
-            throw 'callback function required';
-        }
 
-        this.userService.getUserId(function (userId) {
+        return self.userService.getUserIdPromise().then(function (userId) {
-            var foldersKey = 'folders_' + userId;
+            return self.utilsService.getObjFromStorage('folders_' + userId);
-
+        }).then(function (folders) {
-            chrome.storage.local.get(foldersKey, function (obj) {
-                var folders = obj[foldersKey];
             if (folders && id in folders) {
-                    callback(new Folder(folders[id]));
+                return new Folder(folders[id]);
-                    return;
             }
 
-                callback(null);
+            return null;
-            });
         });
     };
 
-    FolderService.prototype.getAll = function (callback) {
+    FolderService.prototype.getAll = function () {
-        if (!callback || typeof callback !== 'function') {
+        var self = this;
-            throw 'callback function required';
-        }
 
-        this.userService.getUserId(function (userId) {
+        return self.userService.getUserIdPromise().then(function (userId) {
-            var foldersKey = 'folders_' + userId;
+            return self.utilsService.getObjFromStorage('folders_' + userId);
-
+        }).then(function (folders) {
-            chrome.storage.local.get(foldersKey, function (obj) {
-                var folders = obj[foldersKey];
             var response = [];
             for (var id in folders) {
                 var folder = folders[id];
                 response.push(new Folder(folder));
             }
 
-                callback(response);
+            return response;
-            });
         });
     };
 
     FolderService.prototype.getAllDecrypted = function () {
-        var deferred = Q.defer();
+        if (this.decryptedFolderCache) {
-        var self = this;
+            return Q(this.decryptedFolderCache);
+        }
+
+        var deferred = Q.defer(),
+            self = this,
+            decFolders = [{
+                id: null,
+                name: self.i18nService.noneFolder
+            }];
 
         self.cryptoService.getKey().then(function (key) {
             if (!key) {
                 deferred.reject();
-                return;
+                return true;
             }
 
-            if (self.decryptedFolderCache) {
+            return self.getAll();
-                deferred.resolve(self.decryptedFolderCache);
+
+        }).then(function (folders) {
+            if (folders === true) {
                 return;
             }
 
             var promises = [];
-            var decFolders = [{
-                id: null,
-                name: self.i18nService.noneFolder
-            }];
-            self.getAll(function (folders) {
             for (var i = 0; i < folders.length; i++) {
                 /* jshint ignore:start */
                 promises.push(folders[i].decrypt().then(function (folder) {
@@ -95,22 +89,22 @@ function initFolderService() {
                 /* jshint ignore:end */
             }
 
-                Q.all(promises).then(function () {
+            return Q.all(promises);
-                    if (decFolders.length > 0) {
+        }).then(function (stop) {
-                        self.decryptedFolderCache = decFolders;
+            if (stop === true) {
+                return;
             }
-                    deferred.resolve(decFolders);
+
-                });
+            self.decryptedFolderCache = decFolders;
-            });
+            deferred.resolve(self.decryptedFolderCache);
         });
 
         return deferred.promise;
     };
 
     FolderService.prototype.saveWithServer = function (folder) {
-        var deferred = Q.defer();
+        var deferred = Q.defer(),
-
+            self = this,
-        var self = this,
             request = new FolderRequest(folder);
 
         if (!folder.id) {
@@ -128,27 +122,23 @@ function initFolderService() {
             folder.id = response.id;
             self.userService.getUserId(function (userId) {
                 var data = new FolderData(response, userId);
-                self.upsert(data, function () {
+                return self.upsert(data);
+            }).then(function () {
                 deferred.resolve(folder);
             });
-            });
         }
 
         return deferred.promise;
     };
 
-    FolderService.prototype.upsert = function (folder, callback) {
+    FolderService.prototype.upsert = function (folder) {
-        if (!callback || typeof callback !== 'function') {
+        var self = this,
-            throw 'callback function required';
+            key = null;
-        }
 
-        var self = this;
+        return self.userService.getUserIdPromise(function (userId) {
-
+            key = 'folders_' + userId;
-        self.userService.getUserId(function (userId) {
+            return self.utilsService.getObjFromStorage(key);
-            var foldersKey = 'folders_' + userId;
+        }).then(function (folders) {
-
-            chrome.storage.local.get(foldersKey, function (obj) {
-                var folders = obj[foldersKey];
             if (!folders) {
                 folders = {};
             }
@@ -162,19 +152,15 @@ function initFolderService() {
                 folders[folder.id] = folder;
             }
 
-                obj[foldersKey] = folders;
+            return self.utilsService.saveObjToStorage(key, ciphers);
-
+        }).then(function () {
-                chrome.storage.local.set(obj, function () {
             self.decryptedFolderCache = null;
-                    callback();
-                });
-            });
         });
     };
 
     FolderService.prototype.replace = function (folders) {
         var self = this;
-        self.userService.getUserIdPromise().then(function (userId) {
+        return self.userService.getUserIdPromise().then(function (userId) {
             return self.utilsService.saveObjToStorage('folders_' + userId, folders);
         }).then(function () {
             self.decryptedFolderCache = null;
@@ -188,23 +174,18 @@ function initFolderService() {
         });
     };
 
-    FolderService.prototype.delete = function (id, callback) {
+    FolderService.prototype.delete = function (id) {
-        if (!callback || typeof callback !== 'function') {
+        var self = this,
-            throw 'callback function required';
+            key = null;
-        }
-
-        var self = this;
 
         // TODO: Delete folder reference for associated ciphers
 
-        self.userService.getUserId(function (userId) {
+        return self.userService.getUserIdPromise().then(function () {
-            var foldersKey = 'folders_' + userId;
+            key = 'folders_' + userId;
-
+            return self.utilsService.getObjFromStorage(key);
-            chrome.storage.local.get(foldersKey, function (obj) {
+        }).then(function (folders) {
-                var folders = obj[foldersKey];
             if (!folders) {
-                    callback();
+                return null;
-                    return;
             }
 
             if (id.constructor === Array) {
@@ -218,32 +199,28 @@ function initFolderService() {
                 delete folders[id];
             }
             else {
-                    callback();
+                return null;
-                    return;
             }
 
-                obj[foldersKey] = folders;
+            return folders;
-                chrome.storage.local.set(obj, function () {
+        }).then(function (folders) {
+            if (!folders) {
+                return false;
+            }
+
+            return self.utilsService.saveObjToStorage(key, folders);
+        }).then(function (clearCache) {
+            if (clearCache !== false) {
                 self.decryptedFolderCache = null;
-                    callback();
+            }
-                });
-            });
         });
     };
 
     FolderService.prototype.deleteWithServer = function (id) {
-        var deferred = Q.defer();
-
         var self = this;
-        self.apiService.deleteFolder(id, function () {
+        return self.apiService.deleteFolder(id).then(function () {
-            self.delete(id, function () {
+            return self.delete(id);
-                deferred.resolve();
         });
-        }, function (response) {
-            handleError(response, deferred);
-        });
-
-        return deferred.promise;
     };
 
     function handleError(error, deferred) {