projects / project / luci.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
luci-base: tie cached system features to user session
[project/luci.git] / modules / luci-base / htdocs / luci-static / resources / luci.js
1 (function(window, document, undefined) {
2 'use strict';
3
4 /* Object.assign polyfill for IE */
5 if (typeof Object.assign !== 'function') {
6 Object.defineProperty(Object, 'assign', {
7 value: function assign(target, varArgs) {
8 if (target == null)
9 throw new TypeError('Cannot convert undefined or null to object');
10
11 var to = Object(target);
12
13 for (var index = 1; index < arguments.length; index++)
14 if (arguments[index] != null)
15 for (var nextKey in arguments[index])
16 if (Object.prototype.hasOwnProperty.call(arguments[index], nextKey))
17 to[nextKey] = arguments[index][nextKey];
18
19 return to;
20 },
21 writable: true,
22 configurable: true
23 });
24 }
25
26 /* Promise.finally polyfill */
27 if (typeof Promise.prototype.finally !== 'function') {
28 Promise.prototype.finally = function(fn) {
29 var onFinally = function(cb) {
30 return Promise.resolve(fn.call(this)).then(cb);
31 };
32
33 return this.then(
34 function(result) { return onFinally.call(this, function() { return result }) },
35 function(reason) { return onFinally.call(this, function() { return Promise.reject(reason) }) }
36 );
37 };
38 }
39
40 /*
41 * Class declaration and inheritance helper
42 */
43
44 var toCamelCase = function(s) {
45 return s.replace(/(?:^|[\. -])(.)/g, function(m0, m1) { return m1.toUpperCase() });
46 };
47
48 var superContext = null, Class = Object.assign(function() {}, {
49 extend: function(properties) {
50 var props = {
51 __base__: { value: this.prototype },
52 __name__: { value: properties.__name__ || 'anonymous' }
53 };
54
55 var ClassConstructor = function() {
56 if (!(this instanceof ClassConstructor))
57 throw new TypeError('Constructor must not be called without "new"');
58
59 if (Object.getPrototypeOf(this).hasOwnProperty('__init__')) {
60 if (typeof(this.__init__) != 'function')
61 throw new TypeError('Class __init__ member is not a function');
62
63 this.__init__.apply(this, arguments)
64 }
65 else {
66 this.super('__init__', arguments);
67 }
68 };
69
70 for (var key in properties)
71 if (!props[key] && properties.hasOwnProperty(key))
72 props[key] = { value: properties[key], writable: true };
73
74 ClassConstructor.prototype = Object.create(this.prototype, props);
75 ClassConstructor.prototype.constructor = ClassConstructor;
76 Object.assign(ClassConstructor, this);
77 ClassConstructor.displayName = toCamelCase(props.__name__.value + 'Class');
78
79 return ClassConstructor;
80 },
81
82 singleton: function(properties /*, ... */) {
83 return Class.extend(properties)
84 .instantiate(Class.prototype.varargs(arguments, 1));
85 },
86
87 instantiate: function(args) {
88 return new (Function.prototype.bind.apply(this,
89 Class.prototype.varargs(args, 0, null)))();
90 },
91
92 call: function(self, method) {
93 if (typeof(this.prototype[method]) != 'function')
94 throw new ReferenceError(method + ' is not defined in class');
95
96 return this.prototype[method].apply(self, self.varargs(arguments, 1));
97 },
98
99 isSubclass: function(_class) {
100 return (_class != null &&
101 typeof(_class) == 'function' &&
102 _class.prototype instanceof this);
103 },
104
105 prototype: {
106 varargs: function(args, offset /*, ... */) {
107 return Array.prototype.slice.call(arguments, 2)
108 .concat(Array.prototype.slice.call(args, offset));
109 },
110
111 super: function(key, callArgs) {
112 for (superContext = Object.getPrototypeOf(superContext ||
113 Object.getPrototypeOf(this));
114 superContext && !superContext.hasOwnProperty(key);
115 superContext = Object.getPrototypeOf(superContext)) { }
116
117 if (!superContext)
118 return null;
119
120 var res = superContext[key];
121
122 if (arguments.length > 1) {
123 if (typeof(res) != 'function')
124 throw new ReferenceError(key + ' is not a function in base class');
125
126 if (typeof(callArgs) != 'object')
127 callArgs = this.varargs(arguments, 1);
128
129 res = res.apply(this, callArgs);
130 }
131
132 superContext = null;
133
134 return res;
135 },
136
137 toString: function() {
138 var s = '[' + this.constructor.displayName + ']', f = true;
139 for (var k in this) {
140 if (this.hasOwnProperty(k)) {
141 s += (f ? ' {\n' : '') + ' ' + k + ': ' + typeof(this[k]) + '\n';
142 f = false;
143 }
144 }
145 return s + (f ? '' : '}');
146 }
147 }
148 });
149
150
151 /*
152 * HTTP Request helper
153 */
154
155 var Headers = Class.extend({
156 __name__: 'LuCI.XHR.Headers',
157 __init__: function(xhr) {
158 var hdrs = this.headers = {};
159 xhr.getAllResponseHeaders().split(/\r\n/).forEach(function(line) {
160 var m = /^([^:]+):(.*)$/.exec(line);
161 if (m != null)
162 hdrs[m[1].trim().toLowerCase()] = m[2].trim();
163 });
164 },
165
166 has: function(name) {
167 return this.headers.hasOwnProperty(String(name).toLowerCase());
168 },
169
170 get: function(name) {
171 var key = String(name).toLowerCase();
172 return this.headers.hasOwnProperty(key) ? this.headers[key] : null;
173 }
174 });
175
176 var Response = Class.extend({
177 __name__: 'LuCI.XHR.Response',
178 __init__: function(xhr, url, duration, headers, content) {
179 this.ok = (xhr.status >= 200 && xhr.status <= 299);
180 this.status = xhr.status;
181 this.statusText = xhr.statusText;
182 this.headers = (headers != null) ? headers : new Headers(xhr);
183 this.duration = duration;
184 this.url = url;
185 this.xhr = xhr;
186
187 if (content != null && typeof(content) == 'object') {
188 this.responseJSON = content;
189 this.responseText = null;
190 }
191 else if (content != null) {
192 this.responseJSON = null;
193 this.responseText = String(content);
194 }
195 else {
196 this.responseJSON = null;
197 this.responseText = xhr.responseText;
198 }
199 },
200
201 clone: function(content) {
202 var copy = new Response(this.xhr, this.url, this.duration, this.headers, content);
203
204 copy.ok = this.ok;
205 copy.status = this.status;
206 copy.statusText = this.statusText;
207
208 return copy;
209 },
210
211 json: function() {
212 if (this.responseJSON == null)
213 this.responseJSON = JSON.parse(this.responseText);
214
215 return this.responseJSON;
216 },
217
218 text: function() {
219 if (this.responseText == null && this.responseJSON != null)
220 this.responseText = JSON.stringify(this.responseJSON);
221
222 return this.responseText;
223 }
224 });
225
226
227 var requestQueue = [];
228
229 function isQueueableRequest(opt) {
230 if (!classes.rpc)
231 return false;
232
233 if (opt.method != 'POST' || typeof(opt.content) != 'object')
234 return false;
235
236 if (opt.nobatch === true)
237 return false;
238
239 var rpcBaseURL = Request.expandURL(classes.rpc.getBaseURL());
240
241 return (rpcBaseURL != null && opt.url.indexOf(rpcBaseURL) == 0);
242 }
243
244 function flushRequestQueue() {
245 if (!requestQueue.length)
246 return;
247
248 var reqopt = Object.assign({}, requestQueue[0][0], { content: [], nobatch: true }),
249 batch = [];
250
251 for (var i = 0; i < requestQueue.length; i++) {
252 batch[i] = requestQueue[i];
253 reqopt.content[i] = batch[i][0].content;
254 }
255
256 requestQueue.length = 0;
257
258 Request.request(rpcBaseURL, reqopt).then(function(reply) {
259 var json = null, req = null;
260
261 try { json = reply.json() }
262 catch(e) { }
263
264 while ((req = batch.shift()) != null)
265 if (Array.isArray(json) && json.length)
266 req[2].call(reqopt, reply.clone(json.shift()));
267 else
268 req[1].call(reqopt, new Error('No related RPC reply'));
269 }).catch(function(error) {
270 var req = null;
271
272 while ((req = batch.shift()) != null)
273 req[1].call(reqopt, error);
274 });
275 }
276
277 var Request = Class.singleton({
278 __name__: 'LuCI.Request',
279
280 interceptors: [],
281
282 expandURL: function(url) {
283 if (!/^(?:[^/]+:)?\/\//.test(url))
284 url = location.protocol + '//' + location.host + url;
285
286 return url;
287 },
288
289 request: function(target, options) {
290 var state = { xhr: new XMLHttpRequest(), url: this.expandURL(target), start: Date.now() },
291 opt = Object.assign({}, options, state),
292 content = null,
293 contenttype = null,
294 callback = this.handleReadyStateChange;
295
296 return new Promise(function(resolveFn, rejectFn) {
297 opt.xhr.onreadystatechange = callback.bind(opt, resolveFn, rejectFn);
298 opt.method = String(opt.method || 'GET').toUpperCase();
299
300 if ('query' in opt) {
301 var q = (opt.query != null) ? Object.keys(opt.query).map(function(k) {
302 if (opt.query[k] != null) {
303 var v = (typeof(opt.query[k]) == 'object')
304 ? JSON.stringify(opt.query[k])
305 : String(opt.query[k]);
306
307 return '%s=%s'.format(encodeURIComponent(k), encodeURIComponent(v));
308 }
309 else {
310 return encodeURIComponent(k);
311 }
312 }).join('&') : '';
313
314 if (q !== '') {
315 switch (opt.method) {
316 case 'GET':
317 case 'HEAD':
318 case 'OPTIONS':
319 opt.url += ((/\?/).test(opt.url) ? '&' : '?') + q;
320 break;
321
322 default:
323 if (content == null) {
324 content = q;
325 contenttype = 'application/x-www-form-urlencoded';
326 }
327 }
328 }
329 }
330
331 if (!opt.cache)
332 opt.url += ((/\?/).test(opt.url) ? '&' : '?') + (new Date()).getTime();
333
334 if (isQueueableRequest(opt)) {
335 requestQueue.push([opt, rejectFn, resolveFn]);
336 requestAnimationFrame(flushRequestQueue);
337 return;
338 }
339
340 if ('username' in opt && 'password' in opt)
341 opt.xhr.open(opt.method, opt.url, true, opt.username, opt.password);
342 else
343 opt.xhr.open(opt.method, opt.url, true);
344
345 opt.xhr.responseType = 'text';
346
347 if ('overrideMimeType' in opt.xhr)
348 opt.xhr.overrideMimeType('application/octet-stream');
349
350 if ('timeout' in opt)
351 opt.xhr.timeout = +opt.timeout;
352
353 if ('credentials' in opt)
354 opt.xhr.withCredentials = !!opt.credentials;
355
356 if (opt.content != null) {
357 switch (typeof(opt.content)) {
358 case 'function':
359 content = opt.content(xhr);
360 break;
361
362 case 'object':
363 if (!(opt.content instanceof FormData)) {
364 content = JSON.stringify(opt.content);
365 contenttype = 'application/json';
366 }
367 else {
368 content = opt.content;
369 }
370 break;
371
372 default:
373 content = String(opt.content);
374 }
375 }
376
377 if ('headers' in opt)
378 for (var header in opt.headers)
379 if (opt.headers.hasOwnProperty(header)) {
380 if (header.toLowerCase() != 'content-type')
381 opt.xhr.setRequestHeader(header, opt.headers[header]);
382 else
383 contenttype = opt.headers[header];
384 }
385
386 if ('progress' in opt && 'upload' in opt.xhr)
387 opt.xhr.upload.addEventListener('progress', opt.progress);
388
389 if (contenttype != null)
390 opt.xhr.setRequestHeader('Content-Type', contenttype);
391
392 try {
393 opt.xhr.send(content);
394 }
395 catch (e) {
396 rejectFn.call(opt, e);
397 }
398 });
399 },
400
401 handleReadyStateChange: function(resolveFn, rejectFn, ev) {
402 var xhr = this.xhr,
403 duration = Date.now() - this.start;
404
405 if (xhr.readyState !== 4)
406 return;
407
408 if (xhr.status === 0 && xhr.statusText === '') {
409 if (duration >= this.timeout)
410 rejectFn.call(this, new Error('XHR request timed out'));
411 else
412 rejectFn.call(this, new Error('XHR request aborted by browser'));
413 }
414 else {
415 var response = new Response(
416 xhr, xhr.responseURL || this.url, duration);
417
418 Promise.all(Request.interceptors.map(function(fn) { return fn(response) }))
419 .then(resolveFn.bind(this, response))
420 .catch(rejectFn.bind(this));
421 }
422 },
423
424 get: function(url, options) {
425 return this.request(url, Object.assign({ method: 'GET' }, options));
426 },
427
428 post: function(url, data, options) {
429 return this.request(url, Object.assign({ method: 'POST', content: data }, options));
430 },
431
432 addInterceptor: function(interceptorFn) {
433 if (typeof(interceptorFn) == 'function')
434 this.interceptors.push(interceptorFn);
435 return interceptorFn;
436 },
437
438 removeInterceptor: function(interceptorFn) {
439 var oldlen = this.interceptors.length, i = oldlen;
440 while (i--)
441 if (this.interceptors[i] === interceptorFn)
442 this.interceptors.splice(i, 1);
443 return (this.interceptors.length < oldlen);
444 },
445
446 poll: {
447 add: function(interval, url, options, callback) {
448 if (isNaN(interval) || interval <= 0)
449 throw new TypeError('Invalid poll interval');
450
451 var ival = interval >>> 0,
452 opts = Object.assign({}, options, { timeout: ival * 1000 - 5 });
453
454 return Poll.add(function() {
455 return Request.request(url, options).then(function(res) {
456 if (!Poll.active())
457 return;
458
459 try {
460 callback(res, res.json(), res.duration);
461 }
462 catch (err) {
463 callback(res, null, res.duration);
464 }
465 });
466 }, ival);
467 },
468
469 remove: function(entry) { return Poll.remove(entry) },
470 start: function() { return Poll.start() },
471 stop: function() { return Poll.stop() },
472 active: function() { return Poll.active() }
473 }
474 });
475
476 var Poll = Class.singleton({
477 __name__: 'LuCI.Poll',
478
479 queue: [],
480
481 add: function(fn, interval) {
482 if (interval == null || interval <= 0)
483 interval = window.L ? window.L.env.pollinterval : null;
484
485 if (isNaN(interval) || typeof(fn) != 'function')
486 throw new TypeError('Invalid argument to LuCI.Poll.add()');
487
488 for (var i = 0; i < this.queue.length; i++)
489 if (this.queue[i].fn === fn)
490 return false;
491
492 var e = {
493 r: true,
494 i: interval >>> 0,
495 fn: fn
496 };
497
498 this.queue.push(e);
499
500 if (this.tick != null && !this.active())
501 this.start();
502
503 return true;
504 },
505
506 remove: function(fn) {
507 if (typeof(fn) != 'function')
508 throw new TypeError('Invalid argument to LuCI.Poll.remove()');
509
510 var len = this.queue.length;
511
512 for (var i = len; i > 0; i--)
513 if (this.queue[i-1].fn === fn)
514 this.queue.splice(i-1, 1);
515
516 if (!this.queue.length && this.stop())
517 this.tick = 0;
518
519 return (this.queue.length != len);
520 },
521
522 start: function() {
523 if (this.active())
524 return false;
525
526 this.tick = 0;
527
528 if (this.queue.length) {
529 this.timer = window.setInterval(this.step, 1000);
530 this.step();
531 document.dispatchEvent(new CustomEvent('poll-start'));
532 }
533
534 return true;
535 },
536
537 stop: function() {
538 if (!this.active())
539 return false;
540
541 document.dispatchEvent(new CustomEvent('poll-stop'));
542 window.clearInterval(this.timer);
543 delete this.timer;
544 delete this.tick;
545 return true;
546 },
547
548 step: function() {
549 for (var i = 0, e = null; (e = Poll.queue[i]) != null; i++) {
550 if ((Poll.tick % e.i) != 0)
551 continue;
552
553 if (!e.r)
554 continue;
555
556 e.r = false;
557
558 Promise.resolve(e.fn()).finally((function() { this.r = true }).bind(e));
559 }
560
561 Poll.tick = (Poll.tick + 1) % Math.pow(2, 32);
562 },
563
564 active: function() {
565 return (this.timer != null);
566 }
567 });
568
569
570 var dummyElem = null,
571 domParser = null,
572 originalCBIInit = null,
573 rpcBaseURL = null,
574 sysFeatures = null,
575 classes = {};
576
577 var LuCI = Class.extend({
578 __name__: 'LuCI',
579 __init__: function(env) {
580
581 document.querySelectorAll('script[src*="/luci.js"]').forEach(function(s) {
582 if (env.base_url == null || env.base_url == '') {
583 var m = (s.getAttribute('src') || '').match(/^(.*)\/luci\.js(?:\?v=([^?]+))?$/);
584 if (m) {
585 env.base_url = m[1];
586 env.resource_version = m[2];
587 }
588 }
589 });
590
591 if (env.base_url == null)
592 this.error('InternalError', 'Cannot find url of luci.js');
593
594 Object.assign(this.env, env);
595
596 document.addEventListener('poll-start', function(ev) {
597 document.querySelectorAll('[id^="xhr_poll_status"]').forEach(function(e) {
598 e.style.display = (e.id == 'xhr_poll_status_off') ? 'none' : '';
599 });
600 });
601
602 document.addEventListener('poll-stop', function(ev) {
603 document.querySelectorAll('[id^="xhr_poll_status"]').forEach(function(e) {
604 e.style.display = (e.id == 'xhr_poll_status_on') ? 'none' : '';
605 });
606 });
607
608 var domReady = new Promise(function(resolveFn, rejectFn) {
609 document.addEventListener('DOMContentLoaded', resolveFn);
610 });
611
612 Promise.all([
613 domReady,
614 this.require('ui'),
615 this.require('rpc'),
616 this.require('form'),
617 this.probeRPCBaseURL()
618 ]).then(this.setupDOM.bind(this)).catch(this.error);
619
620 originalCBIInit = window.cbi_init;
621 window.cbi_init = function() {};
622 },
623
624 raise: function(type, fmt /*, ...*/) {
625 var e = null,
626 msg = fmt ? String.prototype.format.apply(fmt, this.varargs(arguments, 2)) : null,
627 stack = null;
628
629 if (type instanceof Error) {
630 e = type;
631
632 if (msg)
633 e.message = msg + ': ' + e.message;
634 }
635 else {
636 try { throw new Error('stacktrace') }
637 catch (e2) { stack = (e2.stack || '').split(/\n/) }
638
639 e = new (window[type || 'Error'] || Error)(msg || 'Unspecified error');
640 e.name = type || 'Error';
641 }
642
643 stack = (stack || []).map(function(frame) {
644 frame = frame.replace(/(.*?)@(.+):(\d+):(\d+)/g, 'at $1 ($2:$3:$4)').trim();
645 return frame ? ' ' + frame : '';
646 });
647
648 if (!/^ at /.test(stack[0]))
649 stack.shift();
650
651 if (/\braise /.test(stack[0]))
652 stack.shift();
653
654 if (/\berror /.test(stack[0]))
655 stack.shift();
656
657 if (stack.length)
658 e.message += '\n' + stack.join('\n');
659
660 if (window.console && console.debug)
661 console.debug(e);
662
663 throw e;
664 },
665
666 error: function(type, fmt /*, ...*/) {
667 try {
668 L.raise.apply(L, Array.prototype.slice.call(arguments));
669 }
670 catch (e) {
671 if (!e.reported) {
672 if (L.ui)
673 L.ui.addNotification(e.name || _('Runtime error'),
674 E('pre', {}, e.message), 'danger');
675 else
676 L.dom.content(document.querySelector('#maincontent'),
677 E('pre', { 'class': 'alert-message error' }, e.message));
678
679 e.reported = true;
680 }
681
682 throw e;
683 }
684 },
685
686 bind: function(fn, self /*, ... */) {
687 return Function.prototype.bind.apply(fn, this.varargs(arguments, 2, self));
688 },
689
690 /* Class require */
691 require: function(name, from) {
692 var L = this, url = null, from = from || [];
693
694 /* Class already loaded */
695 if (classes[name] != null) {
696 /* Circular dependency */
697 if (from.indexOf(name) != -1)
698 L.raise('DependencyError',
699 'Circular dependency: class "%s" depends on "%s"',
700 name, from.join('" which depends on "'));
701
702 return classes[name];
703 }
704
705 url = '%s/%s.js%s'.format(L.env.base_url, name.replace(/\./g, '/'), (L.env.resource_version ? '?v=' + L.env.resource_version : ''));
706 from = [ name ].concat(from);
707
708 var compileClass = function(res) {
709 if (!res.ok)
710 L.raise('NetworkError',
711 'HTTP error %d while loading class file "%s"', res.status, url);
712
713 var source = res.text(),
714 requirematch = /^require[ \t]+(\S+)(?:[ \t]+as[ \t]+([a-zA-Z_]\S*))?$/,
715 strictmatch = /^use[ \t]+strict$/,
716 depends = [],
717 args = '';
718
719 /* find require statements in source */
720 for (var i = 0, off = -1, quote = -1, esc = false; i < source.length; i++) {
721 var chr = source.charCodeAt(i);
722
723 if (esc) {
724 esc = false;
725 }
726 else if (chr == 92) {
727 esc = true;
728 }
729 else if (chr == quote) {
730 var s = source.substring(off, i),
731 m = requirematch.exec(s);
732
733 if (m) {
734 var dep = m[1], as = m[2] || dep.replace(/[^a-zA-Z0-9_]/g, '_');
735 depends.push(L.require(dep, from));
736 args += ', ' + as;
737 }
738 else if (!strictmatch.exec(s)) {
739 break;
740 }
741
742 off = -1;
743 quote = -1;
744 }
745 else if (quote == -1 && (chr == 34 || chr == 39)) {
746 off = i + 1;
747 quote = chr;
748 }
749 }
750
751 /* load dependencies and instantiate class */
752 return Promise.all(depends).then(function(instances) {
753 var _factory, _class;
754
755 try {
756 _factory = eval(
757 '(function(window, document, L%s) { %s })\n\n//# sourceURL=%s\n'
758 .format(args, source, res.url));
759 }
760 catch (error) {
761 L.raise('SyntaxError', '%s\n in %s:%s',
762 error.message, res.url, error.lineNumber || '?');
763 }
764
765 _factory.displayName = toCamelCase(name + 'ClassFactory');
766 _class = _factory.apply(_factory, [window, document, L].concat(instances));
767
768 if (!Class.isSubclass(_class))
769 L.error('TypeError', '"%s" factory yields invalid constructor', name);
770
771 if (_class.displayName == 'AnonymousClass')
772 _class.displayName = toCamelCase(name + 'Class');
773
774 var ptr = Object.getPrototypeOf(L),
775 parts = name.split(/\./),
776 instance = new _class();
777
778 for (var i = 0; ptr && i < parts.length - 1; i++)
779 ptr = ptr[parts[i]];
780
781 if (ptr)
782 ptr[parts[i]] = instance;
783
784 classes[name] = instance;
785
786 return instance;
787 });
788 };
789
790 /* Request class file */
791 classes[name] = Request.get(url, { cache: true }).then(compileClass);
792
793 return classes[name];
794 },
795
796 /* DOM setup */
797 probeRPCBaseURL: function() {
798 if (rpcBaseURL == null) {
799 try {
800 rpcBaseURL = window.sessionStorage.getItem('rpcBaseURL');
801 }
802 catch (e) { }
803 }
804
805 if (rpcBaseURL == null) {
806 var rpcFallbackURL = this.url('admin/ubus');
807
808 rpcBaseURL = Request.get('/ubus/').then(function(res) {
809 return (rpcBaseURL = (res.status == 400) ? '/ubus/' : rpcFallbackURL);
810 }, function() {
811 return (rpcBaseURL = rpcFallbackURL);
812 }).then(function(url) {
813 try {
814 window.sessionStorage.setItem('rpcBaseURL', url);
815 }
816 catch (e) { }
817
818 return url;
819 });
820 }
821
822 return Promise.resolve(rpcBaseURL);
823 },
824
825 probeSystemFeatures: function() {
826 var sessionid = classes.rpc.getSessionID();
827
828 if (sysFeatures == null) {
829 try {
830 var data = JSON.parse(window.sessionStorage.getItem('sysFeatures'));
831
832 if (this.isObject(data) && this.isObject(data[sessionid]))
833 sysFeatures = data[sessionid];
834 }
835 catch (e) {}
836 }
837
838 if (!this.isObject(sysFeatures)) {
839 sysFeatures = classes.rpc.declare({
840 object: 'luci',
841 method: 'getFeatures',
842 expect: { '': {} }
843 })().then(function(features) {
844 try {
845 var data = {};
846 data[sessionid] = features;
847
848 window.sessionStorage.setItem('sysFeatures', JSON.stringify(data));
849 }
850 catch (e) {}
851
852 sysFeatures = features;
853
854 return features;
855 });
856 }
857
858 return Promise.resolve(sysFeatures);
859 },
860
861 hasSystemFeature: function() {
862 var ft = sysFeatures[arguments[0]];
863
864 if (arguments.length == 2)
865 return this.isObject(ft) ? ft[arguments[1]] : null;
866
867 return (ft != null && ft != false);
868 },
869
870 notifySessionExpiry: function() {
871 Poll.stop();
872
873 L.ui.showModal(_('Session expired'), [
874 E('div', { class: 'alert-message warning' },
875 _('A new login is required since the authentication session expired.')),
876 E('div', { class: 'right' },
877 E('div', {
878 class: 'btn primary',
879 click: function() {
880 var loc = window.location;
881 window.location = loc.protocol + '//' + loc.host + loc.pathname + loc.search;
882 }
883 }, _('To login…')))
884 ]);
885
886 L.raise('SessionError', 'Login session is expired');
887 },
888
889 setupDOM: function(res) {
890 var domEv = res[0],
891 uiClass = res[1],
892 rpcClass = res[2],
893 formClass = res[3],
894 rpcBaseURL = res[4];
895
896 rpcClass.setBaseURL(rpcBaseURL);
897
898 rpcClass.addInterceptor(function(msg, req) {
899 if (!L.isObject(msg) || !L.isObject(msg.error) || msg.error.code != -32002)
900 return;
901
902 if (!L.isObject(req) || (req.object == 'session' && req.method == 'access'))
903 return;
904
905 return rpcClass.declare({
906 'object': 'session',
907 'method': 'access',
908 'params': [ 'scope', 'object', 'function' ],
909 'expect': { access: true }
910 })('uci', 'luci', 'read').catch(L.notifySessionExpiry);
911 });
912
913 Request.addInterceptor(function(res) {
914 var isDenied = false;
915
916 if (res.status == 403 && res.headers.get('X-LuCI-Login-Required') == 'yes')
917 isDenied = true;
918
919 if (!isDenied)
920 return;
921
922 L.notifySessionExpiry();
923 });
924
925 return this.probeSystemFeatures().finally(this.initDOM);
926 },
927
928 initDOM: function() {
929 originalCBIInit();
930 Poll.start();
931 document.dispatchEvent(new CustomEvent('luci-loaded'));
932 },
933
934 env: {},
935
936 /* URL construction helpers */
937 path: function(prefix, parts) {
938 var url = [ prefix || '' ];
939
940 for (var i = 0; i < parts.length; i++)
941 if (/^(?:[a-zA-Z0-9_.%,;-]+\/)*[a-zA-Z0-9_.%,;-]+$/.test(parts[i]))
942 url.push('/', parts[i]);
943
944 if (url.length === 1)
945 url.push('/');
946
947 return url.join('');
948 },
949
950 url: function() {
951 return this.path(this.env.scriptname, arguments);
952 },
953
954 resource: function() {
955 return this.path(this.env.resource, arguments);
956 },
957
958 location: function() {
959 return this.path(this.env.scriptname, this.env.requestpath);
960 },
961
962
963 /* Data helpers */
964 isObject: function(val) {
965 return (val != null && typeof(val) == 'object');
966 },
967
968 sortedKeys: function(obj, key, sortmode) {
969 if (obj == null || typeof(obj) != 'object')
970 return [];
971
972 return Object.keys(obj).map(function(e) {
973 var v = (key != null) ? obj[e][key] : e;
974
975 switch (sortmode) {
976 case 'addr':
977 v = (v != null) ? v.replace(/(?:^|[.:])([0-9a-fA-F]{1,4})/g,
978 function(m0, m1) { return ('000' + m1.toLowerCase()).substr(-4) }) : null;
979 break;
980
981 case 'num':
982 v = (v != null) ? +v : null;
983 break;
984 }
985
986 return [ e, v ];
987 }).filter(function(e) {
988 return (e[1] != null);
989 }).sort(function(a, b) {
990 return (a[1] > b[1]);
991 }).map(function(e) {
992 return e[0];
993 });
994 },
995
996 toArray: function(val) {
997 if (val == null)
998 return [];
999 else if (Array.isArray(val))
1000 return val;
1001 else if (typeof(val) == 'object')
1002 return [ val ];
1003
1004 var s = String(val).trim();
1005
1006 if (s == '')
1007 return [];
1008
1009 return s.split(/\s+/);
1010 },
1011
1012
1013 /* HTTP resource fetching */
1014 get: function(url, args, cb) {
1015 return this.poll(null, url, args, cb, false);
1016 },
1017
1018 post: function(url, args, cb) {
1019 return this.poll(null, url, args, cb, true);
1020 },
1021
1022 poll: function(interval, url, args, cb, post) {
1023 if (interval !== null && interval <= 0)
1024 interval = this.env.pollinterval;
1025
1026 var data = post ? { token: this.env.token } : null,
1027 method = post ? 'POST' : 'GET';
1028
1029 if (!/^(?:\/|\S+:\/\/)/.test(url))
1030 url = this.url(url);
1031
1032 if (args != null)
1033 data = Object.assign(data || {}, args);
1034
1035 if (interval !== null)
1036 return Request.poll.add(interval, url, { method: method, query: data }, cb);
1037 else
1038 return Request.request(url, { method: method, query: data })
1039 .then(function(res) {
1040 var json = null;
1041 if (/^application\/json\b/.test(res.headers.get('Content-Type')))
1042 try { json = res.json() } catch(e) {}
1043 cb(res.xhr, json, res.duration);
1044 });
1045 },
1046
1047 stop: function(entry) { return Poll.remove(entry) },
1048 halt: function() { return Poll.stop() },
1049 run: function() { return Poll.start() },
1050
1051 /* DOM manipulation */
1052 dom: Class.singleton({
1053 __name__: 'LuCI.DOM',
1054
1055 elem: function(e) {
1056 return (e != null && typeof(e) == 'object' && 'nodeType' in e);
1057 },
1058
1059 parse: function(s) {
1060 var elem;
1061
1062 try {
1063 domParser = domParser || new DOMParser();
1064 elem = domParser.parseFromString(s, 'text/html').body.firstChild;
1065 }
1066 catch(e) {}
1067
1068 if (!elem) {
1069 try {
1070 dummyElem = dummyElem || document.createElement('div');
1071 dummyElem.innerHTML = s;
1072 elem = dummyElem.firstChild;
1073 }
1074 catch (e) {}
1075 }
1076
1077 return elem || null;
1078 },
1079
1080 matches: function(node, selector) {
1081 var m = this.elem(node) ? node.matches || node.msMatchesSelector : null;
1082 return m ? m.call(node, selector) : false;
1083 },
1084
1085 parent: function(node, selector) {
1086 if (this.elem(node) && node.closest)
1087 return node.closest(selector);
1088
1089 while (this.elem(node))
1090 if (this.matches(node, selector))
1091 return node;
1092 else
1093 node = node.parentNode;
1094
1095 return null;
1096 },
1097
1098 append: function(node, children) {
1099 if (!this.elem(node))
1100 return null;
1101
1102 if (Array.isArray(children)) {
1103 for (var i = 0; i < children.length; i++)
1104 if (this.elem(children[i]))
1105 node.appendChild(children[i]);
1106 else if (children !== null && children !== undefined)
1107 node.appendChild(document.createTextNode('' + children[i]));
1108
1109 return node.lastChild;
1110 }
1111 else if (typeof(children) === 'function') {
1112 return this.append(node, children(node));
1113 }
1114 else if (this.elem(children)) {
1115 return node.appendChild(children);
1116 }
1117 else if (children !== null && children !== undefined) {
1118 node.innerHTML = '' + children;
1119 return node.lastChild;
1120 }
1121
1122 return null;
1123 },
1124
1125 content: function(node, children) {
1126 if (!this.elem(node))
1127 return null;
1128
1129 var dataNodes = node.querySelectorAll('[data-idref]');
1130
1131 for (var i = 0; i < dataNodes.length; i++)
1132 delete this.registry[dataNodes[i].getAttribute('data-idref')];
1133
1134 while (node.firstChild)
1135 node.removeChild(node.firstChild);
1136
1137 return this.append(node, children);
1138 },
1139
1140 attr: function(node, key, val) {
1141 if (!this.elem(node))
1142 return null;
1143
1144 var attr = null;
1145
1146 if (typeof(key) === 'object' && key !== null)
1147 attr = key;
1148 else if (typeof(key) === 'string')
1149 attr = {}, attr[key] = val;
1150
1151 for (key in attr) {
1152 if (!attr.hasOwnProperty(key) || attr[key] == null)
1153 continue;
1154
1155 switch (typeof(attr[key])) {
1156 case 'function':
1157 node.addEventListener(key, attr[key]);
1158 break;
1159
1160 case 'object':
1161 node.setAttribute(key, JSON.stringify(attr[key]));
1162 break;
1163
1164 default:
1165 node.setAttribute(key, attr[key]);
1166 }
1167 }
1168 },
1169
1170 create: function() {
1171 var html = arguments[0],
1172 attr = arguments[1],
1173 data = arguments[2],
1174 elem;
1175
1176 if (!(attr instanceof Object) || Array.isArray(attr))
1177 data = attr, attr = null;
1178
1179 if (Array.isArray(html)) {
1180 elem = document.createDocumentFragment();
1181 for (var i = 0; i < html.length; i++)
1182 elem.appendChild(this.create(html[i]));
1183 }
1184 else if (this.elem(html)) {
1185 elem = html;
1186 }
1187 else if (html.charCodeAt(0) === 60) {
1188 elem = this.parse(html);
1189 }
1190 else {
1191 elem = document.createElement(html);
1192 }
1193
1194 if (!elem)
1195 return null;
1196
1197 this.attr(elem, attr);
1198 this.append(elem, data);
1199
1200 return elem;
1201 },
1202
1203 registry: {},
1204
1205 data: function(node, key, val) {
1206 var id = node.getAttribute('data-idref');
1207
1208 /* clear all data */
1209 if (arguments.length > 1 && key == null) {
1210 if (id != null) {
1211 node.removeAttribute('data-idref');
1212 val = this.registry[id]
1213 delete this.registry[id];
1214 return val;
1215 }
1216
1217 return null;
1218 }
1219
1220 /* clear a key */
1221 else if (arguments.length > 2 && key != null && val == null) {
1222 if (id != null) {
1223 val = this.registry[id][key];
1224 delete this.registry[id][key];
1225 return val;
1226 }
1227
1228 return null;
1229 }
1230
1231 /* set a key */
1232 else if (arguments.length > 2 && key != null && val != null) {
1233 if (id == null) {
1234 do { id = Math.floor(Math.random() * 0xffffffff).toString(16) }
1235 while (this.registry.hasOwnProperty(id));
1236
1237 node.setAttribute('data-idref', id);
1238 this.registry[id] = {};
1239 }
1240
1241 return (this.registry[id][key] = val);
1242 }
1243
1244 /* get all data */
1245 else if (arguments.length == 1) {
1246 if (id != null)
1247 return this.registry[id];
1248
1249 return null;
1250 }
1251
1252 /* get a key */
1253 else if (arguments.length == 2) {
1254 if (id != null)
1255 return this.registry[id][key];
1256 }
1257
1258 return null;
1259 },
1260
1261 bindClassInstance: function(node, inst) {
1262 if (!(inst instanceof Class))
1263 L.error('TypeError', 'Argument must be a class instance');
1264
1265 return this.data(node, '_class', inst);
1266 },
1267
1268 findClassInstance: function(node) {
1269 var inst = null;
1270
1271 do {
1272 inst = this.data(node, '_class');
1273 node = node.parentNode;
1274 }
1275 while (!(inst instanceof Class) && node != null);
1276
1277 return inst;
1278 },
1279
1280 callClassMethod: function(node, method /*, ... */) {
1281 var inst = this.findClassInstance(node);
1282
1283 if (inst == null || typeof(inst[method]) != 'function')
1284 return null;
1285
1286 return inst[method].apply(inst, inst.varargs(arguments, 2));
1287 },
1288
1289 isEmpty: function(node, ignoreFn) {
1290 for (var child = node.firstElementChild; child != null; child = child.nextElementSibling)
1291 if (!child.classList.contains('hidden') && (!ignoreFn || !ignoreFn(child)))
1292 return false;
1293
1294 return true;
1295 }
1296 }),
1297
1298 Poll: Poll,
1299 Class: Class,
1300 Request: Request,
1301
1302 view: Class.extend({
1303 __name__: 'LuCI.View',
1304
1305 __init__: function() {
1306 var vp = document.getElementById('view');
1307
1308 L.dom.content(vp, E('div', { 'class': 'spinning' }, _('Loading view…')));
1309
1310 return Promise.resolve(this.load())
1311 .then(L.bind(this.render, this))
1312 .then(L.bind(function(nodes) {
1313 var vp = document.getElementById('view');
1314
1315 L.dom.content(vp, nodes);
1316 L.dom.append(vp, this.addFooter());
1317 }, this)).catch(L.error);
1318 },
1319
1320 load: function() {},
1321 render: function() {},
1322
1323 handleSave: function(ev) {
1324 var tasks = [];
1325
1326 document.getElementById('maincontent')
1327 .querySelectorAll('.cbi-map').forEach(function(map) {
1328 tasks.push(L.dom.callClassMethod(map, 'save'));
1329 });
1330
1331 return Promise.all(tasks);
1332 },
1333
1334 handleSaveApply: function(ev) {
1335 return this.handleSave(ev).then(function() {
1336 L.ui.changes.apply(true);
1337 });
1338 },
1339
1340 handleReset: function(ev) {
1341 var tasks = [];
1342
1343 document.getElementById('maincontent')
1344 .querySelectorAll('.cbi-map').forEach(function(map) {
1345 tasks.push(L.dom.callClassMethod(map, 'reset'));
1346 });
1347
1348 return Promise.all(tasks);
1349 },
1350
1351 addFooter: function() {
1352 var footer = E([]);
1353
1354 if (this.handleSaveApply || this.handleSave || this.handleReset) {
1355 footer.appendChild(E('div', { 'class': 'cbi-page-actions' }, [
1356 this.handleSaveApply ? E('button', {
1357 'class': 'cbi-button cbi-button-apply',
1358 'click': L.ui.createHandlerFn(this, 'handleSaveApply')
1359 }, [ _('Save & Apply') ]) : '', ' ',
1360 this.handleSave ? E('button', {
1361 'class': 'cbi-button cbi-button-save',
1362 'click': L.ui.createHandlerFn(this, 'handleSave')
1363 }, [ _('Save') ]) : '', ' ',
1364 this.handleReset ? E('button', {
1365 'class': 'cbi-button cbi-button-reset',
1366 'click': L.ui.createHandlerFn(this, 'handleReset')
1367 }, [ _('Reset') ]) : ''
1368 ]));
1369 }
1370
1371 return footer;
1372 }
1373 })
1374 });
1375
1376 var XHR = Class.extend({
1377 __name__: 'LuCI.XHR',
1378 __init__: function() {
1379 if (window.console && console.debug)
1380 console.debug('Direct use XHR() is deprecated, please use L.Request instead');
1381 },
1382
1383 _response: function(cb, res, json, duration) {
1384 if (this.active)
1385 cb(res, json, duration);
1386 delete this.active;
1387 },
1388
1389 get: function(url, data, callback, timeout) {
1390 this.active = true;
1391 L.get(url, data, this._response.bind(this, callback), timeout);
1392 },
1393
1394 post: function(url, data, callback, timeout) {
1395 this.active = true;
1396 L.post(url, data, this._response.bind(this, callback), timeout);
1397 },
1398
1399 cancel: function() { delete this.active },
1400 busy: function() { return (this.active === true) },
1401 abort: function() {},
1402 send_form: function() { L.error('InternalError', 'Not implemented') },
1403 });
1404
1405 XHR.get = function() { return window.L.get.apply(window.L, arguments) };
1406 XHR.post = function() { return window.L.post.apply(window.L, arguments) };
1407 XHR.poll = function() { return window.L.poll.apply(window.L, arguments) };
1408 XHR.stop = Request.poll.remove.bind(Request.poll);
1409 XHR.halt = Request.poll.stop.bind(Request.poll);
1410 XHR.run = Request.poll.start.bind(Request.poll);
1411 XHR.running = Request.poll.active.bind(Request.poll);
1412
1413 window.XHR = XHR;
1414 window.LuCI = LuCI;
1415 })(window, document);
Lua Configuration Interface (mirror)