Repository navigation
Expand file tree
/
Copy pathQueryResults.js
More file actions
123 lines (110 loc) · 4.23 KB
/
Copy pathQueryResults.js
File metadata and controls
123 lines (110 loc) · 4.23 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*global define: true */
define([
"dojo/_base/array",
"dojo/_base/lang",
"dojo/Deferred",
"dojo/promise/Promise",
"dojo/when"
], function (
array,
lang,
Deferred,
Promise,
when
) {
"use strict";
var QueryResults = function (results, modelCreatorCallback) {
// summary:
// A function that wraps the results of a store query with additional
// methods.
// description:
// QueryResults behaves just like dojo/store/util/QueryResults and
// is a basic wrapper that allows for array-like iteration
// over any kind of returned data from a query. While the simplest store
// will return a plain array of data, other stores may return deferreds or
// promises; this wrapper makes sure that *all* results can be treated
// the same.
//
// Additional methods include `forEach`, `filter` and `map`.
//
// In constrast to dojo/store/util/QueryResults, this function
// initializes model objects for the returned data
//
// results: Array|dojo/promise/Promise
// The result set as an array, or a promise for an array.
// returns:
// An array-like object that can be used for iterating over.
// example:
// Query a store and iterate over the results.
//
// | store.query({ prime: true }).forEach(function (item) {
// | // do something with model class
// | });
var deferred = null,
createModels = function (items) {
var models = [], model = null;
array.forEach(items, function (item) {
model = modelCreatorCallback();
model.deserialize(item);
models[models.length] = model;
});
return models;
},
addIterativeMethodToPromise = function (promise, method) {
promise[method] = function () {
var args = arguments;
return promise.then(function (items) {
Array.prototype.unshift.call(args, createModels(items));
return QueryResults(array[method].apply(array, args), modelCreatorCallback);
});
};
},
addIterativeMethodToArray = function(models, method) {
if (!models[method]) {
models[method] = function () {
var args = arguments;
Array.prototype.unshift.call(args, models);
return array[method].apply(array, args);
};
}
}
;
if (!results) {
return results;
} else if (!results.then) {
results = createModels(results);
addIterativeMethodToArray(results, "forEach");
addIterativeMethodToArray(results, "filter");
addIterativeMethodToArray(results, "map");
} else {
deferred = new Deferred();
// intercept callbacks of promise returned by store.query()
results.then(
function (r) {
deferred.resolve(createModels(r));
},
function (error) {
deferred.reject(error);
},
function (update) {
deferred.progress(update);
}
);
results = lang.delegate(new Promise(), deferred.promise); // work around frozen deferred.promise
addIterativeMethodToPromise(results, "forEach");
addIterativeMethodToPromise(results, "filter");
addIterativeMethodToPromise(results, "map");
}
if (!results.total) {
results.total = when(results, function (results) {
return results.length;
});
}
if (results.then && Object.freeze) {
// don't freeze it - otherwise Observable can't add observe() method
//Object.freeze(results);
}
return results;
};
return QueryResults;
});