resources.js.qpid.management.preference.PreferenceBrowserWidget.js Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
define(["dojo/_base/declare",
"dojo/_base/lang",
"dojo/json",
"dojo/Evented",
"dojo/Deferred",
"dojo/promise/all",
'dstore/Store',
'dstore/QueryResults',
"dstore/Memory",
"dstore/Trackable",
"dstore/Tree",
"dgrid/OnDemandGrid",
"dgrid/Keyboard",
"dgrid/Selection",
"dgrid/Tree",
"dgrid/extensions/DijitRegistry",
"dgrid/extensions/ColumnResizer",
"qpid/management/query/StoreUpdater",
"qpid/common/util",
"dojo/text!preference/PreferenceBrowserWidget.html",
"dojo/keys",
"dojox/html/entities",
"dijit/_WidgetBase",
"dijit/_TemplatedMixin",
"dijit/_WidgetsInTemplateMixin",
"dijit/form/Button",
"dijit/Toolbar",
"dijit/Dialog"],
function (declare,
lang,
json,
Evented,
Deferred,
all,
Store,
QueryResults,
Memory,
Trackable,
TreeStoreMixin,
OnDemandGrid,
Keyboard,
Selection,
Tree,
DijitRegistry,
ColumnResizer,
StoreUpdater,
util,
template,
keys,
entities)
{
var empty = new Deferred();
empty.resolve([]);
var PreferencesStore = declare("qpid.management.query.PreferencesStore",
[Store],
{
management: null,
transformer: null,
preferenceType: null,
fetch: function ()
{
var brokerPreferencesPromise = null;
var virtualHostsPreferencesPromise = null;
if (this.preferenceRoot)
{
var query = this.management.getVisiblePreferences(this.preferenceRoot, this.preferenceType);
var brokerDeferred = new Deferred();
brokerPreferencesPromise = brokerDeferred.promise;
brokerDeferred.resolve(null);
var virtualHostDeferred = new Deferred();
virtualHostsPreferencesPromise = virtualHostDeferred.promise;
query.then(function (data)
{
virtualHostDeferred.resolve([data]);
},
function (error)
{
virtualHostDeferred.cancel(error);
});
}
else
{
brokerPreferencesPromise = this.management.getVisiblePreferences({type: "broker"}, this.preferenceType);
virtualHostsPreferencesPromise = this.management.getVisiblePreferences({
type: "virtualhost",
name: "*",
parent: {
type: "virtualhostnode",
name: "*",
parent: {type: "broker"}
}
}, this.preferenceType);
}
var resultPromise = all({
brokerPreferences: brokerPreferencesPromise,
virtualHostsPreferences: virtualHostsPreferencesPromise
});
var deferred = new Deferred();
var successHandler = lang.hitch(this, function (preferences)
{
var transformedItems = this.transformer(preferences);
deferred.resolve(transformedItems);
});
var failureHandler = lang.hitch(this, function (error)
{
if (error && (!error.hasOwnProperty("response") || error.response.hasOwnProperty("status")))
{
this.management.errorHandler(error);
}
deferred.resolve([]);
});
resultPromise.then(successHandler, failureHandler);
return new QueryResults(deferred.promise, {
totalLength: deferred.promise.then(function (data)
{
return data.length;
}, function ()
{
return 0;
})
});
},
fetchRange: function ()
{
throw new Error("unsupported");
}
});
return declare([dijit._WidgetBase, dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin, Evented],
{
//Strip out the apache comment header from the template html as comments unsupported.
templateString: template.replace(//g, ""),
// attached automatically from template fields
preferenceBrowserGridNode: null,
allRadio: null,
mineRadio: null,
sharedWithMeRadio: null,
// passed automatically by constructor
manangement: null,
structure: null,
preferenceRoot: null,
preferenceType: null,
preferenceTypeFriendlySingular: null,
preferenceTypeFriendlyPlural: null,
// internal
_preferenceStore: null,
_gridStore: null,
_preferenceBrowserGrid: null,
postCreate: function ()
{
this.inherited(arguments);
this._gridStore = new (declare([Memory, TreeStoreMixin, Trackable]))();
this._preferenceStore = this._createPreferencesStore(this._gridStore);
this._buildGrid();
this._initFilter();
},
startup: function ()
{
this.inherited(arguments);
this._preferenceBrowserGrid.startup();
this.update();
},
_buildGrid: function ()
{
var columns = {
name: {
label: this.preferenceTypeFriendlySingular,
renderExpando: true,
sortable: false
},
description: {
label: "Description",
sortable: false
},
owner: {
label: "Owner",
sortable: false,
renderCell: this._renderOwner
},
visibilityList: {
label: "Shared with",
sortable: false,
renderCell: this._renderGroups
}
};
var Grid = declare([OnDemandGrid, Keyboard, Selection, Tree, DijitRegistry, ColumnResizer]);
var store = this._gridStore.filter({parent: undefined});
this._preferenceBrowserGrid = new Grid({
minRowsPerPage: Math.pow(2, 53) - 1,
columns: columns,
collection: store,
noDataMessage: 'No ' + this.preferenceTypeFriendlyPlural,
noDataMessages: {
all: "No " + this.preferenceTypeFriendlyPlural,
sharedWithMe: "No one has shared " + this.preferenceTypeFriendlyPlural + " with you",
mine: "You have no " + this.preferenceTypeFriendlyPlural
},
highlightRow: function ()
{
// Suppress row highlighting
},
shouldExpand: function ()
{
return true;
}
}, this.preferenceBrowserGridNode);
this._preferenceBrowserGrid.on('.dgrid-row:dblclick', lang.hitch(this, this._openPreference));
this._preferenceBrowserGrid.on('.dgrid-row:keypress', lang.hitch(this, function (event)
{
if (event.keyCode === keys.ENTER)
{
this._openPreference(event);
}
}));
},
resize: function ()
{
this.inherited(arguments);
if (this._preferenceBrowserGrid)
{
this._preferenceBrowserGrid.resize();
}
},
update: function ()
{
return this._preferenceStore.update();
},
_createPreferencesStore: function (targetStore)
{
var UpdatableStore = declare([PreferencesStore, StoreUpdater]);
var preferencesStore = new UpdatableStore({
targetStore: targetStore,
management: this.management,
structure: this.structure,
transformer: lang.hitch(this, this._preferencesTransformer),
preferenceRoot: this.preferenceRoot,
preferenceType: this.preferenceType
});
preferencesStore.on("unexpected", util.xhrErrorHandler);
return preferencesStore;
},
_openPreference: function (event)
{
var row = this._preferenceBrowserGrid.row(event);
if (row.data.value)
{
var item = this.structure.findById(row.data.associatedObject);
this.emit("open",
{
preference: row.data,
parentObject: item
});
}
},
_initFilter: function ()
{
var that = this;
this.allRadio.on("click", function (e)
{
that._modifyFilter(e, that.allRadio);
});
this.mineRadio.on("click", function (e)
{
that._modifyFilter(e, that.mineRadio);
});
this.sharedWithMeRadio.on("click", function (e)
{
that._modifyFilter(e, that.sharedWithMeRadio);
});
},
_modifyFilter: function (event, targetWidget)
{
var value = targetWidget.get("value");
this.filter = value;
if (this._preferenceBrowserGrid.noDataMessages[value])
{
this._preferenceBrowserGrid.noDataMessage = this._preferenceBrowserGrid.noDataMessages[value];
}
this.update();
this._preferenceBrowserGrid.refresh();
},
_preferencesTransformer: function (preferences)
{
var items = [];
if (preferences.brokerPreferences)
{
items = this._processPreferencesForObject(preferences.brokerPreferences);
}
if (preferences.virtualHostsPreferences)
{
for (var i = 0; i < preferences.virtualHostsPreferences.length; i++)
{
var virtualHostPreference = preferences.virtualHostsPreferences[i];
items = items.concat(this._processPreferencesForObject(virtualHostPreference));
}
}
return items;
},
_processPreferencesForObject: function (preferenceList)
{
if (this.filter != "all")
{
var authenticatedUser = this.management.getAuthenticatedUser();
for (var i = preferenceList.length - 1; i >= 0; i--)
{
var item = preferenceList[i];
if (this.filter == "mine" && item.owner != authenticatedUser)
{
preferenceList.splice(i, 1);
}
else if (this.filter == "sharedWithMe" && item.owner == authenticatedUser)
{
preferenceList.splice(i, 1);
}
}
}
if (preferenceList.length == 0)
{
return [];
}
// We know all the preferences will be associated with the same object, so we take the first
var root = this.structure.findById(preferenceList[0].associatedObject);
if (!root)
{
return [];
}
var items = [];
var rootName = util.generateName(root);
var rootItem = {
id: root.id,
name: rootName
};
items.push(rootItem);
var rootItemCategories = {};
for (var i = 0; i < preferenceList.length; i++)
{
var preferenceItem = preferenceList[i];
var categoryId = rootItem.id + preferenceItem.value.category;
var categoryItem = rootItemCategories[categoryId];
if (!categoryItem)
{
categoryItem = {
id: categoryId,
name: preferenceItem.value.category,
parent: rootItem.id
};
items.push(categoryItem);
rootItemCategories[categoryId] = categoryItem;
}
preferenceItem.hasChildren = false;
preferenceItem.parent = categoryItem.id;
items.push(preferenceItem);
}
return items;
},
_renderOwner: function (object, value, node)
{
if (value)
{
node.title = entities.encode(value);
node.appendChild(document.createTextNode(util.toFriendlyUserName(value)));
}
},
_renderGroups: function (object, value, node)
{
var data = "";
if (value instanceof Array)
{
var groupNames = [];
var friendlyGroupNames = [];
for (var i = 0; i < value.length; i++)
{
var group = value[i];
friendlyGroupNames.push(entities.encode(util.toFriendlyUserName(group)));
groupNames.push(group);
}
node.title = entities.encode(groupNames.join(",\n"));
data = friendlyGroupNames.join(", ")
}
node.appendChild(document.createTextNode(data));
}
});
});
© 2015 - 2025 Weber Informatics LLC | Privacy Policy