Merge pull request #1735 from sumpfralle/olsr-jsoninfo-parser-handle-empty-result
[oweals/luci.git] / modules / luci-base / htdocs / luci-static / resources / luci.js
index a9ddccf359b23599b50704975a9e36ef4d78488e..4e3c8445a94dc0013a20708e4744f622e7c9c951 100644 (file)
                                                break;
 
                                        case 'object':
-                                               content = JSON.stringify(opt.content);
-                                               contenttype = 'application/json';
+                                               if (!(opt.content instanceof FormData)) {
+                                                       content = JSON.stringify(opt.content);
+                                                       contenttype = 'application/json';
+                                               }
+                                               else {
+                                                       content = opt.content;
+                                               }
                                                break;
 
                                        default:
                },
 
                handleReadyStateChange: function(resolveFn, rejectFn, ev) {
-                       var xhr = this.xhr;
+                       var xhr = this.xhr,
+                           duration = Date.now() - this.start;
 
                        if (xhr.readyState !== 4)
                                return;
 
                        if (xhr.status === 0 && xhr.statusText === '') {
-                               rejectFn.call(this, new Error('XHR request aborted by browser'));
+                               if (duration >= this.timeout)
+                                       rejectFn.call(this, new Error('XHR request timed out'));
+                               else
+                                       rejectFn.call(this, new Error('XHR request aborted by browser'));
                        }
                        else {
                                var response = new Response(
-                                       xhr, xhr.responseURL || this.url, Date.now() - this.start);
+                                       xhr, xhr.responseURL || this.url, duration);
 
                                Promise.all(Request.interceptors.map(function(fn) { return fn(response) }))
                                        .then(resolveFn.bind(this, response))
                __init__: function(env) {
 
                        document.querySelectorAll('script[src*="/luci.js"]').forEach(function(s) {
-                               if (env.base_url == null || env.base_url == '')
-                                       env.base_url = s.getAttribute('src').replace(/\/luci\.js(?:\?v=[^?]+)?$/, '');
+                               if (env.base_url == null || env.base_url == '') {
+                                       var m = (s.getAttribute('src') || '').match(/^(.*)\/luci\.js(?:\?v=([^?]+))?$/);
+                                       if (m) {
+                                               env.base_url = m[1];
+                                               env.resource_version = m[2];
+                                       }
+                               }
                        });
 
                        if (env.base_url == null)
 
                        if (type instanceof Error) {
                                e = type;
-                               stack = (e.stack || '').split(/\n/);
 
                                if (msg)
                                        e.message = msg + ': ' + e.message;
                        }
                        else {
+                               try { throw new Error('stacktrace') }
+                               catch (e2) { stack = (e2.stack || '').split(/\n/) }
+
                                e = new (window[type || 'Error'] || Error)(msg || 'Unspecified error');
                                e.name = type || 'Error';
                        }
 
+                       stack = (stack || []).map(function(frame) {
+                               frame = frame.replace(/(.*?)@(.+):(\d+):(\d+)/g, 'at $1 ($2:$3:$4)').trim();
+                               return frame ? '  ' + frame : '';
+                       });
+
+                       if (!/^  at /.test(stack[0]))
+                               stack.shift();
+
+                       if (/\braise /.test(stack[0]))
+                               stack.shift();
+
+                       if (/\berror /.test(stack[0]))
+                               stack.shift();
+
+                       if (stack.length)
+                               e.message += '\n' + stack.join('\n');
+
                        if (window.console && console.debug)
                                console.debug(e);
 
                                L.raise.apply(L, Array.prototype.slice.call(arguments));
                        }
                        catch (e) {
-                               var stack = (e.stack || '').split(/\n/).map(function(frame) {
-                                       frame = frame.replace(/(.*?)@(.+):(\d+):(\d+)/g, 'at $1 ($2:$3:$4)').trim();
-                                       return frame ? '  ' + frame : '';
-                               });
-
-                               if (!/^  at /.test(stack[0]))
-                                       stack.shift();
-
-                               if (/\braise /.test(stack[0]))
-                                       stack.shift();
-
-                               if (/\berror /.test(stack[0]))
-                                       stack.shift();
-
-                               stack = stack.length ? '\n' + stack.join('\n') : '';
+                               if (!e.reported) {
+                                       if (L.ui)
+                                               L.ui.addNotification(e.name || _('Runtime error'),
+                                                       E('pre', {}, e.message), 'danger');
+                                       else
+                                               L.dom.content(document.querySelector('#maincontent'),
+                                                       E('pre', { 'class': 'alert-message error' }, e.message));
 
-                               if (L.ui)
-                                       L.ui.showModal(e.name || _('Runtime error'),
-                                               E('pre', { 'class': 'alert-message error' }, e.message + stack));
-                               else
-                                       L.dom.content(document.querySelector('#maincontent'),
-                                               E('pre', { 'class': 'alert-message error' }, e + stack));
+                                       e.reported = true;
+                               }
 
                                throw e;
                        }
                                return classes[name];
                        }
 
-                       url = '%s/%s.js'.format(L.env.base_url, name.replace(/\./g, '/'));
+                       url = '%s/%s.js%s'.format(L.env.base_url, name.replace(/\./g, '/'), (L.env.resource_version ? '?v=' + L.env.resource_version : ''));
                        from = [ name ].concat(from);
 
                        var compileClass = function(res) {
                },
 
                probeSystemFeatures: function() {
+                       var sessionid = classes.rpc.getSessionID();
+
                        if (sysFeatures == null) {
                                try {
-                                       sysFeatures = JSON.parse(window.sessionStorage.getItem('sysFeatures'));
+                                       var data = JSON.parse(window.sessionStorage.getItem('sysFeatures'));
+
+                                       if (this.isObject(data) && this.isObject(data[sessionid]))
+                                               sysFeatures = data[sessionid];
                                }
                                catch (e) {}
                        }
                                        expect: { '': {} }
                                })().then(function(features) {
                                        try {
-                                               window.sessionStorage.setItem('sysFeatures', JSON.stringify(features));
+                                               var data = {};
+                                                   data[sessionid] = features;
+
+                                               window.sessionStorage.setItem('sysFeatures', JSON.stringify(data));
                                        }
                                        catch (e) {}
 
                        return (ft != null && ft != false);
                },
 
+               notifySessionExpiry: function() {
+                       Poll.stop();
+
+                       L.ui.showModal(_('Session expired'), [
+                               E('div', { class: 'alert-message warning' },
+                                       _('A new login is required since the authentication session expired.')),
+                               E('div', { class: 'right' },
+                                       E('div', {
+                                               class: 'btn primary',
+                                               click: function() {
+                                                       var loc = window.location;
+                                                       window.location = loc.protocol + '//' + loc.host + loc.pathname + loc.search;
+                                               }
+                                       }, _('To login…')))
+                       ]);
+
+                       L.raise('SessionError', 'Login session is expired');
+               },
+
                setupDOM: function(res) {
                        var domEv = res[0],
                            uiClass = res[1],
 
                        rpcClass.setBaseURL(rpcBaseURL);
 
-                       Request.addInterceptor(function(res) {
-                               if (res.status != 403 || res.headers.get('X-LuCI-Login-Required') != 'yes')
+                       rpcClass.addInterceptor(function(msg, req) {
+                               if (!L.isObject(msg) || !L.isObject(msg.error) || msg.error.code != -32002)
                                        return;
 
-                               Poll.stop();
-
-                               L.ui.showModal(_('Session expired'), [
-                                       E('div', { class: 'alert-message warning' },
-                                               _('A new login is required since the authentication session expired.')),
-                                       E('div', { class: 'right' },
-                                               E('div', {
-                                                       class: 'btn primary',
-                                                       click: function() {
-                                                               var loc = window.location;
-                                                               window.location = loc.protocol + '//' + loc.host + loc.pathname + loc.search;
-                                                       }
-                                               }, _('To login…')))
-                               ]);
+                               if (!L.isObject(req) || (req.object == 'session' && req.method == 'access'))
+                                       return;
+
+                               return rpcClass.declare({
+                                       'object': 'session',
+                                       'method': 'access',
+                                       'params': [ 'scope', 'object', 'function' ],
+                                       'expect': { access: true }
+                               })('uci', 'luci', 'read').catch(L.notifySessionExpiry);
+                       });
+
+                       Request.addInterceptor(function(res) {
+                               var isDenied = false;
+
+                               if (res.status == 403 && res.headers.get('X-LuCI-Login-Required') == 'yes')
+                                       isDenied = true;
+
+                               if (!isDenied)
+                                       return;
 
-                               throw 'Session expired';
+                               L.notifySessionExpiry();
                        });
 
                        return this.probeSystemFeatures().finally(this.initDOM);
                        },
 
                        addFooter: function() {
-                               var footer = E([]),
-                                   mc = document.getElementById('maincontent');
+                               var footer = E([]);
 
-                               if (mc.querySelector('.cbi-map')) {
+                               if (this.handleSaveApply || this.handleSave || this.handleReset) {
                                        footer.appendChild(E('div', { 'class': 'cbi-page-actions' }, [
-                                               E('input', {
+                                               this.handleSaveApply ? E('button', {
                                                        'class': 'cbi-button cbi-button-apply',
-                                                       'type': 'button',
-                                                       'value': _('Save & Apply'),
-                                                       'click': L.bind(this.handleSaveApply, this)
-                                               }), ' ',
-                                               E('input', {
+                                                       'click': L.ui.createHandlerFn(this, 'handleSaveApply')
+                                               }, [ _('Save & Apply') ]) : '', ' ',
+                                               this.handleSave ? E('button', {
                                                        'class': 'cbi-button cbi-button-save',
-                                                       'type': 'submit',
-                                                       'value': _('Save'),
-                                                       'click': L.bind(this.handleSave, this)
-                                               }), ' ',
-                                               E('input', {
+                                                       'click': L.ui.createHandlerFn(this, 'handleSave')
+                                               }, [ _('Save') ]) : '', ' ',
+                                               this.handleReset ? E('button', {
                                                        'class': 'cbi-button cbi-button-reset',
-                                                       'type': 'button',
-                                                       'value': _('Reset'),
-                                                       'click': L.bind(this.handleReset, this)
-                                               })
+                                                       'click': L.ui.createHandlerFn(this, 'handleReset')
+                                               }, [ _('Reset') ]) : ''
                                        ]));
                                }