Javascript AngularJS$带延迟的资源缓存

我有一个$resource工厂，我利用缓存库（ngStorage）实现了它。我在localstorage中添加了资源缓存，并进行了检查以确保缓存是最新的和有效的

然而，我遇到了几个我正在努力纠正的问题。第一个是每次加载缓存数据时，缓存都会与服务器进行检查，以查看是否有新数据要检索和缓存。在它收集这些数据之后，我希望将最后一个数据点对象存储在缓存中，以便知道缓存中最后一个时间点是什么

第二个问题是我希望我的视图在routechange完成之前等待缓存的创建。我在控制器视图上设置了resolve属性，但是我不确定在哪里实现$q承诺，以便能够解析该承诺并确保数据存在

我的代码如下：

美元资源：

angular.module('resources.readings', ['ngResource', 'ngStorage']).
    factory('Reading', function($resource, $localStorage, $sessionStorage) {
        var resource = $resource('api/index.php/readings/:id', {}, {
            'update': {method: 'PUT'}
        });

        var readingsCache = $localStorage.$default({
            readings: [],
            lastReading: null,
            lastUpdate: null,
            newestReading: null,
            firstReading: null
        });

        var pageLimit = 1000;
function subtractDays(date, days) {
            var result = new Date(date);
            result.setDate(date.getDate() - days);
            return result;
        }

        var refreshCache = function(loadDefault) {
            var endDate = new Date(readingsCache.newestReading._time);
            if (loadDefault) {
                var startDate = subtractDays(endDate, 1).toISOString();
            } else {
                var startDate = new Date(readingsCache.lastReading._time).toISOString();
            }
            endDate = endDate.toISOString();
            resource.get({q: 'getCount', startDate: startDate, endDate: endDate}, function(response) {
                var numPages = Math.ceil(response.totalCount / pageLimit);
                for (var i = 0; i < numPages; i++) {
                    resource.query({startDate: startDate, endDate: endDate, limit: pageLimit, page: i}, function(response) {
                        response.forEach(function(val, index, theArray) {
                            readingsCache.readings.push(val);
                        });
                    }, function(data) {
                        //a single reading call has failed
                    });
                }
            }, function(data) {
                //failure of getting count
            });
        }

        resource.getLastUpdate = function() {
            resource.get({q: 'getLastUpdate'}, function(response) {
                //assume cache is empty and needs to be filled
                var loadDefault = true;
                //if we have cached data, and theres new data to get, don't load the default value of a day
                if (readingsCache.newestReading && readingsCache.newestReading._ID !== response._ID) {
                    readingsCache.lastReading = readingsCache.newestReading;
                    readingsCache.newestReading = response;
                    loadDefault = false;
                    refreshCache(loadDefault);
                } else if (!readingsCache.lastUpdate) {
                    readingsCache.newestReading = response;
                    refreshCache(loadDefault);
                }
                readingsCache.lastUpdate = new Date();
                //                readingsCache.firstReading = readingsCache.readings[readingsCache.readings.length - 1];
            }, function(data) {
                //timeout and try again
            });
            return readingsCache;
        }
return resource;
    });

---

我最终需要做的是为整个代码块创建一个返回承诺，但在资源查询服务器并在其上循环以填充缓存时，我需要在那里添加一个解析，以确保循环在允许在页面上呈现之前已完成填充缓存。这是我的“最终”代码：

var deferred=$q.deferred（）；
//假设缓存为空，需要填充
var loadDefault=true；
var=false；
获取（{q:'getLastUpdate'}）。$promise.then（函数（响应）{
//如果我们有缓存数据，并且有新数据要获取，不要加载默认值一小时
if（readingcache.newestReading&&readingcache.newestReading.\u ID==response.\u ID）{
缓存=真；
延迟。解析（ReadingCache）；
}else if（readingcache.newestReading&&readingcache.newestReading.\u ID=totalCount）{
如果（加载默认值）{
ReadingCache.firstReading=ReadingCache.readings[0]；
}
延迟。解析（ReadingCache）；
}
});
});
}
});
}
});
回报。承诺；
}

angular.module('temperature.readings', ['resources.readings', 'highcharts-ng'])
    .config(['$routeProvider', function($routeProvider) {
            var deferredReadingCache = ['Reading', '$q', function(Reading, $q) {
                    return Reading.getLastUpdate();
             }];
$routeProvider
                    .when('/readings', {
                        templateUrl: 'js/app/readings/reading-list.tpl.html',
                        controller: 'ReadingsListCtrl',
                        resolve: {
                            readingCache: deferredReadingCache
                        }
                    })
}])
    .controller('ReadingsListCtrl', ['$scope', '$location', '$route', 'Reading',     function($scope, $location, $route, Reading) {
            $scope.order = '_ID';
            $scope.reverse = false;
            $scope.readingCache = $route.current.locals.readingCache;

var deferred = $q.defer();
            //assume cache is empty and needs to be filled
            var loadDefault = true;
            var cached = false;
            resource.get({q: 'getLastUpdate'}).$promise.then(function(response) {
                //if we have cached data, and theres new data to get, don't load the default value of an hour
                if (readingsCache.newestReading && readingsCache.newestReading._ID === response._ID) {
                    cached = true;
                    deferred.resolve(readingsCache);
                } else if (readingsCache.newestReading && readingsCache.newestReading._ID < response._ID) {
                    readingsCache.lastReading = readingsCache.newestReading;
                    readingsCache.newestReading = response;
                    loadDefault = false;
                } else if (!readingsCache.lastUpdate) {
                    readingsCache.newestReading = response;
                }

                readingsCache.lastUpdate = new Date();

                endDate = new Date(readingsCache.newestReading._time);
                if (loadDefault) {
                    startDate = subtractMinutes(endDate, 60).toISOString();
                } else {
                    startDate = new Date(readingsCache.lastReading._time).toISOString();
                }
                endDate = endDate.toISOString();
                if (cached) {
                    deferred.resolve(readingsCache);
                } else {
                    var totalCount = null;
                    resource.get({q: 'getCount', startDate: startDate, endDate: endDate}).$promise.then(function(response) {
                        var numPages = Math.ceil(response.totalCount / pageLimit);
                        totalCount = response.totalCount;
                        for (var i = 0; i < numPages; i++) {
                            resource.query({startDate: startDate, endDate: endDate, limit: pageLimit, page: i}).$promise.then(
                                    function(response) {
                                        response.forEach(function(val, index, theArray) {
                                            readingsCache.readings.push(val);
                                            if (readingsCache.readings.length >= totalCount) {
                                                if (loadDefault) {
                                                    readingsCache.firstReading = readingsCache.readings[0];
                                                }
                                                deferred.resolve(readingsCache);
                                            }
                                        });
                                    });
                        }
                    });
                }
            });
            return deferred.promise;
        }