129 lines
3.6 KiB
JavaScript
129 lines
3.6 KiB
JavaScript
define("dstore/legacy/StoreAdapter", [
|
|
'dojo/_base/declare',
|
|
'dojo/_base/lang',
|
|
'dojo/_base/array',
|
|
'dojo/when',
|
|
'../Store',
|
|
'../QueryResults'
|
|
], function (declare, lang, arrayUtil, when, Store, QueryResults) {
|
|
// module:
|
|
// An adapter mixin that makes a legacy Dojo object store look like a dstore object.
|
|
|
|
var modifyDelegate = function (name) {
|
|
return function () {
|
|
var objectStore = this.objectStore;
|
|
return objectStore[name].apply(objectStore, arguments);
|
|
};
|
|
};
|
|
|
|
return declare(Store, {
|
|
|
|
// objectStore:
|
|
// The object store wrapped by this adapter
|
|
objectStore: null,
|
|
|
|
get: function () {
|
|
// summary:
|
|
// Retrieves an object by its identity
|
|
// id: Number
|
|
// The identity to use to lookup the object
|
|
// returns: Object
|
|
// The object in the store that matches the given id.
|
|
var self = this,
|
|
objectStore = this.objectStore;
|
|
return when(objectStore.get.apply(objectStore, arguments), function (object) {
|
|
return self._restore(object);
|
|
});
|
|
},
|
|
|
|
put: modifyDelegate('put'),
|
|
add: modifyDelegate('add'),
|
|
remove: modifyDelegate('remove'),
|
|
|
|
getIdentity: modifyDelegate('getIdentity'),
|
|
|
|
_setIdentity: function (object, identityArg) {
|
|
return (object[this.objectStore.idProperty] = identityArg);
|
|
},
|
|
|
|
fetch: function () {
|
|
// summary:
|
|
// Fetches the query results. Note that the fetch may occur asynchronously
|
|
// returns: Array|Promise
|
|
// The results or a promise for the results
|
|
|
|
// create an object store query and query options based on current collection
|
|
// information
|
|
return this.fetchRange();
|
|
},
|
|
|
|
fetchRange: function (rangeArgs) {
|
|
// summary:
|
|
// Fetches the query results with a range. Note that the fetch may occur asynchronously
|
|
// returns: Array|Promise
|
|
// The results or a promise for the results
|
|
|
|
// create an object store query and query options based on current collection
|
|
// information
|
|
var queryOptions = {},
|
|
queryLog = this.queryLog,
|
|
getQueryArguments = function (type) {
|
|
return arrayUtil.map(
|
|
arrayUtil.filter(queryLog, function (entry) { return entry.type === type; }),
|
|
function (entry) {
|
|
return entry.normalizedArguments[0];
|
|
}
|
|
);
|
|
};
|
|
|
|
// take the last sort since multiple sorts are not supported by dojo/store
|
|
var sorted = getQueryArguments('sort').pop();
|
|
if (sorted) {
|
|
queryOptions.sort = sorted;
|
|
|
|
if (sorted instanceof Array) {
|
|
// object stores expect an attribute property
|
|
for (var i = 0; i < sorted.length; i++) {
|
|
var sortSegment = sorted[i];
|
|
sortSegment.attribute = sortSegment.property;
|
|
}
|
|
}
|
|
}
|
|
if (rangeArgs) {
|
|
// set the range
|
|
queryOptions.count = rangeArgs.end - ((queryOptions.start = rangeArgs.start) || 0);
|
|
}
|
|
|
|
var queryObject = {};
|
|
applyFilter(getQueryArguments('filter'));
|
|
|
|
function applyFilter(filtered) {
|
|
for (var i = 0; i < filtered.length; i++) {
|
|
var filter = filtered[i];
|
|
var type = filter.type;
|
|
var args = filter.args;
|
|
if (type === 'and') {
|
|
applyFilter(args);
|
|
} else if (type === 'eq' || type === 'match') {
|
|
queryObject[args[0]] = args[1];
|
|
} else if (type === 'string') {
|
|
queryObject = args[0];
|
|
} else if (type) {
|
|
throw new Error('"' + type + ' operator can not be converted to a legacy store query');
|
|
}
|
|
// else if (!type) { no-op }
|
|
}
|
|
}
|
|
|
|
var results = this.objectStore.query(queryObject, queryOptions);
|
|
if (results) {
|
|
// apply the object restoration
|
|
return new QueryResults(when(results.map(this._restore, this)), {
|
|
totalLength: when(results.total)
|
|
});
|
|
}
|
|
return when(results);
|
|
}
|
|
});
|
|
});
|