- Author:
- David Nickerson <david.nickerson@gmail.com>
- Date:
- 2021-09-17 15:39:51+12:00
- Desc:
- tweak html formatting
- Permanent Source URI:
- https://models.fieldml.org/workspace/a1/rawfile/c47db6b2fedb368422c7f4d5191aeb9f319ad684/dojo-presentation/js/dojo/dojox/data/FileStore.js
dojo.provide("dojox.data.FileStore");
dojo.declare("dojox.data.FileStore", null, {
constructor: function(/*Object*/args){
// summary:
// A simple store that provides a datastore interface to a filesystem.
// description:
// A simple store that provides a datastore interface to a filesystem. It takes a few parameters
// for initialization:
// url: The URL of the service which provides the file store serverside implementation.
// label: The attribute of the file to use as the huma-readable text. Default is 'name'.
// The purpose of this store is to represent a file as a datastore item. The
// datastore item by default has the following attributes that can be examined on it.
// directory: Boolean indicating if the file item represents a directory.
// name: The filename with no path informatiom.
// path: The file complete file path including name, relative to the location the
// file service scans from
// size: The size of the file, in bytes.
// parentDir: The parent directory path.
// children: Any child files contained by a directory file item.
//
// Note that the store's server call pattern is RESTlike.
//
// The store also supports the passing of configurable options to the back end service, such as
// expanding all child files (no lazy load), displaying hidden files, displaying only directories, and so on.
// These are defined through a comma-separated list in declarative, or through setting the options array in programmatic.
// example: options="expand,dirsOnly,showHiddenFiles"
if(args && args.label){
this.label = args.label;
}
if(args && args.url){
this.url = args.url;
}
if (args && args.options) {
if (dojo.isArray(args.options)) {
this.options = args.options;
}else{
if (dojo.isString(args.options)) {
this.options = args.options.split(",");
}
}
}
if (args && args.pathAsQueryParam) {
this.pathAsQueryParam = true;
}
},
url: "", //The URL to the file path service.
_storeRef: "_S", //Internal variable used to denote an item came from this store instance.
label: "name", //Default attribute to use to represent the item as a user-readable string. Public, so users can change it.
_identifier: "path", //Default attribute to use to represent the item's identifier.
//Path should always be unique in the store instance.
_attributes: ["children", "directory", "name", "path", "modified", "size", "parentDir"], //Attributes all file items should have.
pathSeparator: "/", //The path separator to use when chaining requests for children - can be overriden by the server on initial load
options: [], //Array of options to always send when doing requests. Back end service controls this, like 'dirsOnly', 'showHiddenFiles', 'expandChildren', etc.
_assertIsItem: function(/* item */ item){
// summary:
// This function tests whether the item passed in is indeed an item in the store.
// item:
// The item to test for being contained by the store.
if(!this.isItem(item)){
throw new Error("dojox.data.FileStore: a function was passed an item argument that was not an item");
}
},
_assertIsAttribute: function(/* attribute-name-string */ attribute){
// summary:
// This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
// attribute:
// The attribute to test for being contained by the store.
if(typeof attribute !== "string"){
throw new Error("dojox.data.FileStore: a function was passed an attribute argument that was not an attribute name string");
}
},
pathAsQueryParam: false, //Function to switch between REST style URL lookups and passing the path to specific items as a query param: 'path'.
getFeatures: function(){
// summary:
// See dojo.data.api.Read.getFeatures()
return {
'dojo.data.api.Read': true, 'dojo.data.api.Identity':true
};
},
getValue: function(item, attribute, defaultValue){
// summary:
// See dojo.data.api.Read.getValue()
var values = this.getValues(item, attribute);
var value = defaultValue;
if(values && values.length > 0){
value = values[0];
}
return value;
},
getAttributes: function(item){
// summary:
// See dojo.data.api.Read.getAttributes()
return this._attributes;
},
hasAttribute: function(item, attribute){
// summary:
// See dojo.data.api.Read.hasAttributes()
if(this.getValue(item,attribute)){
return true;
}
return false;
},
getIdentity: function(/* item */ item){
// summary:
// See dojo.data.api.Identity.getIdentity()
return this.getValue(item, this._identifier);
},
getIdentityAttributes: function(item){
// summary:
// See dojo.data.api.Read.getLabelAttributes()
return [this._identifier];
},
isItemLoaded: function(item){
// summary:
// See dojo.data.api.Read.isItemLoaded()
var loaded = this.isItem(item);
if (loaded && typeof item._loaded == "boolean" && !item._loaded){
loaded = false;
}
return loaded;
},
loadItem: function(keywordArgs){
// summary:
// See dojo.data.api.Read.loadItem()
var item = keywordArgs.item;
var self = this;
var scope = keywordArgs.scope || dojo.global;
var content = {};
if (this.options.length > 0) {
content.options = dojo.toJson(this.options);
}
if (this.pathAsQueryParam) {
content.path = item.parentPath + this.pathSeparator + item.name;
}
var xhrData = {
url: this.pathAsQueryParam? this.url : this.url + "/" + item.parentPath + "/" + item.name,
handleAs: "json-comment-optional",
content: content,
preventCache: true
};
var deferred = dojo.xhrGet(xhrData);
deferred.addErrback(function(error){
if(keywordArgs.onError){
keywordArgs.onError.call(scope, error);
}
});
deferred.addCallback(function(data){
delete item.parentPath;
delete item._loaded;
dojo.mixin(item, data);
self._processItem(item);
if (keywordArgs.onItem){
keywordArgs.onItem.call(scope, item);
}
});
},
getLabel: function(item){
// summary:
// See dojo.data.api.Read.getLabel()
return this.getValue(item,this.label);
},
getLabelAttributes: function(item){
// summary:
// See dojo.data.api.Read.getLabelAttributes()
return [this.label];
},
containsValue: function(item, attribute, value){
// summary:
// See dojo.data.api.Read.containsValue()
var values = this.getValues(item,attribute);
for(var i = 0; i < values.length; i++){
if(values[i] == value){
return true;
}
}
return false;
},
getValues: function(item, attribute){
// summary:
// See dojo.data.api.Read.getValue()
this._assertIsItem(item);
this._assertIsAttribute(attribute);
var value = item[attribute];
if(typeof value !== "undefined" && !dojo.isArray(value)){
value = [value];
}else if (typeof value === "undefined"){
value = [];
}
return value;
},
isItem: function(item){
// summary:
// See dojo.data.api.Read.isItem()
if(item && item[this._storeRef] === this){
return true;
}
return false;
},
close: function(request){
// summary:
// See dojo.data.api.Read.close()
},
fetch: function(request){
// summary:
// Fetch items that match to a query
// request:
// A request object
// fetchHandler:
// A function to call for fetched items
// errorHandler:
// A function to call on error
request = request || {};
if(!request.store){
request.store = this;
}
var self = this;
var scope = request.scope || dojo.global;
//Generate what will be sent over.
var reqParams = {};
if(request.query){
reqParams.query = dojo.toJson(request.query);
}
if(request.sort){
reqParams.sort = dojo.toJson(request.sort);
}
if(request.queryOptions){
reqParams.queryOptions = dojo.toJson(request.queryOptions);
}
if(typeof request.start == "number"){
reqParams.start = "" + request.start;
}
if(typeof request.count == "number"){
reqParams.count = "" + request.count;
}
if (this.options.length > 0) {
reqParams.options = dojo.toJson(this.options);
}
var getArgs = {
url: this.url,
preventCache: true,
handleAs: "json-comment-optional",
content: reqParams
};
var deferred = dojo.xhrGet(getArgs);
deferred.addCallback(function(data){self._processResult(data, request);});
deferred.addErrback(function(error){
if (request.onError){
request.onError.call(scope, error, request);
}
});
},
fetchItemByIdentity: function(keywordArgs){
// summary:
// See dojo.data.api.Read.loadItem()
var path = keywordArgs.identity;
var self = this;
var scope = keywordArgs.scope || dojo.global;
var content = {};
if (this.options.length > 0) {
content.options = dojo.toJson(this.options);
}
if (this.pathAsQueryParam) {
content.path = path;
}
var xhrData = {
url: this.pathAsQueryParam? this.url : this.url + "/" + path,
handleAs: "json-comment-optional",
content: content,
preventCache: true
};
var deferred = dojo.xhrGet(xhrData);
deferred.addErrback(function(error){
if(keywordArgs.onError){
keywordArgs.onError.call(scope, error);
}
});
deferred.addCallback(function(data){
var item = self._processItem(data);
if (keywordArgs.onItem){
keywordArgs.onItem.call(scope, item);
}
});
},
_processResult: function(data, request){
var scope = request.scope || dojo.global;
try{
//If the data contains a path separator, set ours
if(data.pathSeparator){
this.pathSeparator = data.pathSeparator;
}
//Invoke the onBegin handler, if any, to return the
//size of the dataset as indicated by the service.
if(request.onBegin){
request.onBegin.call(scope, data.total, request);
}
//Now process all the returned items thro
var items = this._processItemArray(data.items);
if(request.onItem){
var i;
for (i = 0; i < items.length; i++) {
request.onItem.call(scope, items[i], request);
}
items = null;
}
if(request.onComplete){
request.onComplete.call(scope, items, request);
}
}catch (e){
if (request.onError) {
request.onError.call(scope, e, request);
}else{
console.debug(e);
}
}
},
_processItemArray: function(itemArray){
// summary:
// Internal function for processing an array of items for return.
var i;
for(i = 0; i < itemArray.length; i++){
this._processItem(itemArray[i]);
}
return itemArray;
},
_processItem: function(item){
// summary:
// Internal function for processing an item returned from the store.
// It sets up the store ref as well as sets up the attributes necessary
// to invoke a lazy load on a child, if there are any.
if(!item){return null;}
item[this._storeRef] = this;
if(item.children && item.directory){
if(dojo.isArray(item.children)){
var children = item.children;
var i;
for (i = 0; i < children.length; i++ ){
var name = children[i];
if (dojo.isObject(name)) {
children[i] = this._processItem(name);
}else{
children[i] = {name: name, _loaded: false, parentPath: item.path};
children[i][this._storeRef] = this;
}
}
}else{
delete item.children;
}
}
return item;
}
});
