Angular UI Router不能在另一个服务之前解析一个服务

Question

我正在尝试创建一个充满类别的标签布局，但我没有收到我的身份验证，因为我正在尝试在我的路由器中解析该服务。

这是我的路由器代码

(function () {
    'use strict';

    angular
        .module('learningApp')
        .config(sslRouter);

    // Minification safe dependency Injection
    sslRouter.$inject = ['$stateProvider'];

    function sslRouter ($stateProvider) {
        // SSL Route Definition
        $stateProvider.state('ssl', {
            parent: 'policy',
            url: '/ssl',
            data: {
                roles: ['USER']
            },
            views: {
                'policyConfig': {
                    templateUrl: 'components/configuration/service/policy/ssl/ssl.tpl.html',
                    controller: 'SSL'
                }
            },
            resolve: {
                'sslServiceData': function(sslService) {
                    return sslService.promise;
                }
            }
        });

    }
}());

这是我的服务

   (function() {
        'use strict';

        angular
            .module('learningApp')
            .factory('sslService', sslResource);

        sslResource.$inject = ['Principal', '$resource', 'BASE_URL', 'exDomainService'];

        function sslResource (Principal, $resource, BASE_URL, exDomainService) {
            debugger;

            var res = $resource(BASE_URL + '/api/companies/' + Principal.company() + '/sconfig/ssl/sslConfiguration', {}, {
                query: {
                    method: 'GET',
                    isArray: false
                },
                update: {
                    method: 'PUT'
                }
            });

            var data = {};
            var servicePromise = _initService();
            servicePromise.$promise.then(function (d) {
                data = d;
                if (!data.excludedCategories) {
                    data.excludedCategories = [];
                }
                if (!data.excludedDomains) {
                    data.excludedDomains = [];
                }
                exDomainService.tableData = getExcludedDomains();
            });

            function _initService () {
                return res.query();
            }

              return {
                promise: servicePromise,
                rest: res
            }

        }

}());

这是我的控制器

(function() {
    'use strict';

    angular
        .module('learningApp')
        .controller('SSL', SSLController);

    SSLController.$inject = ['$scope', 'sslService', 'preDefinedCategoryService', '$timeout', 'exDialog', 'exDomainService'];
    function SSLController ($scope, sslService, preDefinedCategoryService, $timeout, exDialog, exDomainService) {

        var vm = $scope;

        /**
         * @desc Flags for different type checks
         * Booleans and Categories
         */
        vm.flags = {
            // By default true
            enableInspectSSLTraffic: sslService.getSSlInspectionFlag(),
            allowUntrustedCertificates: sslService.getUntrustedCertificatesFlag(),
            allowHostnameMismatch: sslService.getHostnameMismatchFlag(),
            selectedCategory: undefined,
            initializing: true
        };

        vm.excludedCategories = sslService.getExcludedCategories();
        vm.predefinedCategories = preDefinedCategoryService.rest.query();

        vm.predefinedCategories.$promise.then(function() {
            vm.categories = _processedCategories(vm.predefinedCategories, vm.excludedCategories);
        });
    }

}());

所以基本上问题是，我将Principal.Identity视为未定义，但如果我从路由器中删除分辨率，我获得了身份，但后来我丢失了来自服务的数据。我希望我的服务在其Controller之前完全加载，并且我希望在服务之前加载我的主要服务。

参考，这是我的校长班

'use strict';

angular.module('learningApp')
    .service('Principal',['$q', 'Account', 'localStorageService', function Principal($q, Account, localStorageService) {
        var _identity,
            _authenticated = false;

        return {
            isIdentityResolved: function () {
                return angular.isDefined(_identity);
            },
            isAuthenticated: function () {
                return _authenticated;
            },
            isInRole: function (role) {
                if (!_authenticated || !_identity || !_identity.roles) {
                    return false;
                }

                return _identity.roles.indexOf(role) !== -1;
            },
            isInAnyRole: function (roles) {
                if (!_authenticated || !_identity.roles) {
                    return false;
                }

                for (var i = 0; i < roles.length; i++) {
                    if (this.isInRole(roles[i])) {
                        return true;
                    }
                }

                return false;
            },
            company: function () {
                debugger;
                if (_identity) return _identity.companyId;  
            },
            authenticate: function (identity) {
                _identity = identity;
                _authenticated = identity !== null;
            },
            identity: function (force) {
                var deferred = $q.defer();

                if (force === true) {
                    _identity = undefined;
                }

                // check and see if we have retrieved the identity data from the server.
                // if we have, reuse it by immediately resolving
                if (angular.isDefined(_identity)) {
                    deferred.resolve(_identity);

                    return deferred.promise;
                }

                // rather than retrieving from server, use cookie or whatever method

                var cookieFound = UTIL.cookie("token");
                if (cookieFound) {
                    var response = JSON.parse(JSON.parse(cookieFound));                    
                    var expiredAt = new Date();                    
                    expiredAt.setSeconds(expiredAt.getSeconds() + response.expires_in);
                    response.expires_at = expiredAt.getTime();
                    localStorageService.set('token', response);
                }

                // retrieve the identity data from the server, update the identity object, and then resolve.
                Account.get().$promise
                    .then(function (account) {                        
                        account.data.roles = ["ADMIN", 'USER'];
                        account.data.langKey = "en";
                        _identity = account.data;
                        _authenticated = true;
                        deferred.resolve(_identity);                        
                    })
                    .catch(function() {
                        _identity = null;
                        _authenticated = false;
                        deferred.resolve(_identity);
                    });
                return deferred.promise;
            }
        };
    }]);