* To import the class in views, use `'require dom'`, to import it in
* external JavaScript, use `L.require("dom").then(...)`.
*/
- var DOM = Class.singleton(/* @lends LuCI.dom.prototype */ {
+ var DOM = Class.singleton(/** @lends LuCI.dom.prototype */ {
__name__: 'LuCI.dom',
/**
*/
bindClassInstance: function(node, inst) {
if (!(inst instanceof Class))
- L.error('TypeError', 'Argument must be a class instance');
+ LuCI.prototype.error('TypeError', 'Argument must be a class instance');
return this.data(node, '_class', inst);
},
}
});
+ /**
+ * @class session
+ * @memberof LuCI
+ * @hideconstructor
+ * @classdesc
+ *
+ * The `session` class provides various session related functionality.
+ */
+ var Session = Class.singleton(/** @lends LuCI.session.prototype */ {
+ __name__: 'LuCI.session',
+
+ /**
+ * Retrieve the current session ID.
+ *
+ * @returns {string}
+ * Returns the current session ID.
+ */
+ getID: function() {
+ return env.sessionid || '00000000000000000000000000000000';
+ },
+
+ /**
+ * Retrieve the current session token.
+ *
+ * @returns {string|null}
+ * Returns the current session token or `null` if not logged in.
+ */
+ getToken: function() {
+ return env.token || null;
+ },
+
+ /**
+ * Retrieve data from the local session storage.
+ *
+ * @param {string} [key]
+ * The key to retrieve from the session data store. If omitted, all
+ * session data will be returned.
+ *
+ * @returns {*}
+ * Returns the stored session data or `null` if the given key wasn't
+ * found.
+ */
+ getLocalData: function(key) {
+ try {
+ var sid = this.getID(),
+ item = 'luci-session-store',
+ data = JSON.parse(window.sessionStorage.getItem(item));
+
+ if (!LuCI.prototype.isObject(data) || !data.hasOwnProperty(sid)) {
+ data = {};
+ data[sid] = {};
+ }
+
+ if (key != null)
+ return data[sid].hasOwnProperty(key) ? data[sid][key] : null;
+
+ return data[sid];
+ }
+ catch (e) {
+ return (key != null) ? null : {};
+ }
+ },
+
+ /**
+ * Set data in the local session storage.
+ *
+ * @param {string} key
+ * The key to set in the session data store.
+ *
+ * @param {*} value
+ * The value to store. It will be internally converted to JSON before
+ * being put in the session store.
+ *
+ * @returns {boolean}
+ * Returns `true` if the data could be stored or `false` on error.
+ */
+ setLocalData: function(key, value) {
+ if (key == null)
+ return false;
+
+ try {
+ var sid = this.getID(),
+ item = 'luci-session-store',
+ data = JSON.parse(window.sessionStorage.getItem(item));
+
+ if (!LuCI.prototype.isObject(data) || !data.hasOwnProperty(sid)) {
+ data = {};
+ data[sid] = {};
+ }
+
+ if (value != null)
+ data[sid][key] = value;
+ else
+ delete data[sid][key];
+
+ window.sessionStorage.setItem(item, JSON.stringify(data));
+
+ return true;
+ }
+ catch (e) {
+ return false;
+ }
+ }
+ });
+
/**
* @class view
* @memberof LuCI
* The `view` class forms the basis of views and provides a standard
* set of methods to inherit from.
*/
- var View = Class.extend(/* @lends LuCI.view.prototype */ {
+ var View = Class.extend(/** @lends LuCI.view.prototype */ {
__name__: 'LuCI.view',
__init__: function() {
DOM.content(vp, E('div', { 'class': 'spinning' }, _('Loading view…')));
return Promise.resolve(this.load())
- .then(L.bind(this.render, this))
- .then(L.bind(function(nodes) {
+ .then(LuCI.prototype.bind(this.render, this))
+ .then(LuCI.prototype.bind(function(nodes) {
var vp = document.getElementById('view');
DOM.content(vp, nodes);
DOM.append(vp, this.addFooter());
- }, this)).catch(L.error);
+ }, this)).catch(LuCI.prototype.error);
},
/**
*/
handleSaveApply: function(ev, mode) {
return this.handleSave(ev).then(function() {
- L.ui.changes.apply(mode == '0');
+ classes.ui.changes.apply(mode == '0');
});
},
* methods are overwritten with `null`.
*/
addFooter: function() {
- var footer = E([]);
+ var footer = E([]),
+ vp = document.getElementById('view'),
+ hasmap = false,
+ readonly = true;
+
+ vp.querySelectorAll('.cbi-map').forEach(function(map) {
+ var m = DOM.findClassInstance(map);
+ if (m) {
+ hasmap = true;
+
+ if (!m.readonly)
+ readonly = false;
+ }
+ });
- var saveApplyBtn = this.handleSaveApply ? new L.ui.ComboButton('0', {
+ if (!hasmap)
+ readonly = !LuCI.prototype.hasViewPermission();
+
+ var saveApplyBtn = this.handleSaveApply ? new classes.ui.ComboButton('0', {
0: [ _('Save & Apply') ],
1: [ _('Apply unchecked') ]
}, {
0: 'btn cbi-button cbi-button-apply important',
1: 'btn cbi-button cbi-button-negative important'
},
- click: L.ui.createHandlerFn(this, 'handleSaveApply')
+ click: classes.ui.createHandlerFn(this, 'handleSaveApply'),
+ disabled: readonly || null
}).render() : E([]);
if (this.handleSaveApply || this.handleSave || this.handleReset) {
saveApplyBtn, ' ',
this.handleSave ? E('button', {
'class': 'cbi-button cbi-button-save',
- 'click': L.ui.createHandlerFn(this, 'handleSave')
+ 'click': classes.ui.createHandlerFn(this, 'handleSave'),
+ 'disabled': readonly || null
}, [ _('Save') ]) : '', ' ',
this.handleReset ? E('button', {
'class': 'cbi-button cbi-button-reset',
- 'click': L.ui.createHandlerFn(this, 'handleReset')
+ 'click': classes.ui.createHandlerFn(this, 'handleReset'),
+ 'disabled': readonly || null
}, [ _('Reset') ]) : ''
]));
}
dom: DOM,
poll: Poll,
request: Request,
+ session: Session,
view: View
};
*/
error: function(type, fmt /*, ...*/) {
try {
- L.raise.apply(L, Array.prototype.slice.call(arguments));
+ LuCI.prototype.raise.apply(LuCI.prototype,
+ Array.prototype.slice.call(arguments));
}
catch (e) {
if (!e.reported) {
- if (L.ui)
- L.ui.addNotification(e.name || _('Runtime error'),
+ if (classes.ui)
+ classes.ui.addNotification(e.name || _('Runtime error'),
E('pre', {}, e.message), 'danger');
else
DOM.content(document.querySelector('#maincontent'),
if (classes[name] != null) {
/* Circular dependency */
if (from.indexOf(name) != -1)
- L.raise('DependencyError',
+ LuCI.prototype.raise('DependencyError',
'Circular dependency: class "%s" depends on "%s"',
name, from.join('" which depends on "'));
var compileClass = function(res) {
if (!res.ok)
- L.raise('NetworkError',
+ LuCI.prototype.raise('NetworkError',
'HTTP error %d while loading class file "%s"', res.status, url);
var source = res.text(),
if (m) {
var dep = m[1], as = m[2] || dep.replace(/[^a-zA-Z0-9_]/g, '_');
- depends.push(L.require(dep, from));
+ depends.push(LuCI.prototype.require(dep, from));
args += ', ' + as;
}
else if (!strictmatch.exec(s)) {
.format(args, source, res.url));
}
catch (error) {
- L.raise('SyntaxError', '%s\n in %s:%s',
+ LuCI.prototype.raise('SyntaxError', '%s\n in %s:%s',
error.message, res.url, error.lineNumber || '?');
}
_class = _factory.apply(_factory, [window, document, L].concat(instances));
if (!Class.isSubclass(_class))
- L.error('TypeError', '"%s" factory yields invalid constructor', name);
+ LuCI.prototype.error('TypeError', '"%s" factory yields invalid constructor', name);
if (_class.displayName == 'AnonymousClass')
_class.displayName = toCamelCase(name + 'Class');
/* DOM setup */
probeRPCBaseURL: function() {
- if (rpcBaseURL == null) {
- try {
- rpcBaseURL = window.sessionStorage.getItem('rpcBaseURL');
- }
- catch (e) { }
- }
+ if (rpcBaseURL == null)
+ rpcBaseURL = Session.getLocalData('rpcBaseURL');
if (rpcBaseURL == null) {
var rpcFallbackURL = this.url('admin/ubus');
}, function() {
return (rpcBaseURL = rpcFallbackURL);
}).then(function(url) {
- try {
- window.sessionStorage.setItem('rpcBaseURL', url);
- }
- catch (e) { }
-
+ Session.setLocalData('rpcBaseURL', url);
return url;
});
}
},
probeSystemFeatures: function() {
- var sessionid = classes.rpc.getSessionID();
-
- if (sysFeatures == null) {
- try {
- var data = JSON.parse(window.sessionStorage.getItem('sysFeatures'));
-
- if (this.isObject(data) && this.isObject(data[sessionid]))
- sysFeatures = data[sessionid];
- }
- catch (e) {}
- }
+ if (sysFeatures == null)
+ sysFeatures = Session.getLocalData('features');
if (!this.isObject(sysFeatures)) {
sysFeatures = classes.rpc.declare({
method: 'getFeatures',
expect: { '': {} }
})().then(function(features) {
- try {
- var data = {};
- data[sessionid] = features;
-
- window.sessionStorage.setItem('sysFeatures', JSON.stringify(data));
- }
- catch (e) {}
-
+ Session.setLocalData('features', features);
sysFeatures = features;
return features;
},
probePreloadClasses: function() {
- var sessionid = classes.rpc.getSessionID();
-
- if (preloadClasses == null) {
- try {
- var data = JSON.parse(window.sessionStorage.getItem('preloadClasses'));
-
- if (this.isObject(data) && this.isObject(data[sessionid]))
- preloadClasses = data[sessionid];
- }
- catch (e) {}
- }
+ if (preloadClasses == null)
+ preloadClasses = Session.getLocalData('preload');
if (!Array.isArray(preloadClasses)) {
preloadClasses = this.resolveDefault(classes.rpc.declare({
classes.push('preload.%s'.format(m[1]));
}
- try {
- var data = {};
- data[sessionid] = classes;
-
- window.sessionStorage.setItem('preloadClasses', JSON.stringify(data));
- }
- catch (e) {}
-
+ Session.setLocalData('preload', classes);
preloadClasses = classes;
return classes;
notifySessionExpiry: function() {
Poll.stop();
- L.ui.showModal(_('Session expired'), [
+ classes.ui.showModal(_('Session expired'), [
E('div', { class: 'alert-message warning' },
_('A new login is required since the authentication session expired.')),
E('div', { class: 'right' },
}, _('To login…')))
]);
- L.raise('SessionError', 'Login session is expired');
+ LuCI.prototype.raise('SessionError', 'Login session is expired');
},
/* private */
rpcClass.setBaseURL(rpcBaseURL);
rpcClass.addInterceptor(function(msg, req) {
- if (!L.isObject(msg) || !L.isObject(msg.error) || msg.error.code != -32002)
+ if (!LuCI.prototype.isObject(msg) ||
+ !LuCI.prototype.isObject(msg.error) ||
+ msg.error.code != -32002)
return;
- if (!L.isObject(req) || (req.object == 'session' && req.method == 'access'))
+ if (!LuCI.prototype.isObject(req) ||
+ (req.object == 'session' && req.method == 'access'))
return;
return rpcClass.declare({
'method': 'access',
'params': [ 'scope', 'object', 'function' ],
'expect': { access: true }
- })('uci', 'luci', 'read').catch(L.notifySessionExpiry);
+ })('uci', 'luci', 'read').catch(LuCI.prototype.notifySessionExpiry);
});
Request.addInterceptor(function(res) {
if (!isDenied)
return;
- L.notifySessionExpiry();
+ LuCI.prototype.notifySessionExpiry();
});
document.addEventListener('poll-start', function(ev) {
return Promise.all([
this.probeSystemFeatures(),
this.probePreloadClasses()
- ]).finally(L.bind(function() {
+ ]).finally(LuCI.prototype.bind(function() {
var tasks = [];
if (Array.isArray(preloadClasses))
});
},
+ /**
+ * Check whether a view has sufficient permissions.
+ *
+ * @return {boolean|null}
+ * Returns `null` if the current session has no permission at all to
+ * load resources required by the view. Returns `false` if readonly
+ * permissions are granted or `true` if at least one required ACL
+ * group is granted with write permissions.
+ */
+ hasViewPermission: function() {
+ if (!this.isObject(env.nodespec) || !env.nodespec.satisfied)
+ return null;
+
+ return !env.nodespec.readonly;
+ },
+
/**
* Deprecated wrapper around {@link LuCI.poll.remove Poll.remove()}.
*
*/
get: function(url, data, callback, timeout) {
this.active = true;
- L.get(url, data, this._response.bind(this, callback), timeout);
+ LuCI.prototype.get(url, data, this._response.bind(this, callback), timeout);
},
/**
*/
post: function(url, data, callback, timeout) {
this.active = true;
- L.post(url, data, this._response.bind(this, callback), timeout);
+ LuCI.prototype.post(url, data, this._response.bind(this, callback), timeout);
},
/**
* Throws an `InternalError` with the message `Not implemented`
* when invoked.
*/
- send_form: function() { L.error('InternalError', 'Not implemented') },
+ send_form: function() { LuCI.prototype.error('InternalError', 'Not implemented') },
});
- XHR.get = function() { return window.L.get.apply(window.L, arguments) };
- XHR.post = function() { return window.L.post.apply(window.L, arguments) };
- XHR.poll = function() { return window.L.poll.apply(window.L, arguments) };
+ XHR.get = function() { return LuCI.prototype.get.apply(LuCI.prototype, arguments) };
+ XHR.post = function() { return LuCI.prototype.post.apply(LuCI.prototype, arguments) };
+ XHR.poll = function() { return LuCI.prototype.poll.apply(LuCI.prototype, arguments) };
XHR.stop = Request.poll.remove.bind(Request.poll);
XHR.halt = Request.poll.stop.bind(Request.poll);
XHR.run = Request.poll.start.bind(Request.poll);
projects / project / luci.git / blobdiff