luci-0.11: merge outstanding trunk changes
[project/luci.git] / libs / web / luasrc / cbi.lua
1 --[[
2 LuCI - Configuration Bind Interface
3
4 Description:
5 Offers an interface for binding configuration values to certain
6 data types. Supports value and range validation and basic dependencies.
7
8 FileId:
9 $Id$
10
11 License:
12 Copyright 2008 Steven Barth <steven@midlink.org>
13
14 Licensed under the Apache License, Version 2.0 (the "License");
15 you may not use this file except in compliance with the License.
16 You may obtain a copy of the License at
17
18 http://www.apache.org/licenses/LICENSE-2.0
19
20 Unless required by applicable law or agreed to in writing, software
21 distributed under the License is distributed on an "AS IS" BASIS,
22 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
23 See the License for the specific language governing permissions and
24 limitations under the License.
25
26 ]]--
27 module("luci.cbi", package.seeall)
28
29 require("luci.template")
30 local util = require("luci.util")
31 require("luci.http")
32
33
34 --local event = require "luci.sys.event"
35 local fs = require("nixio.fs")
36 local uci = require("luci.model.uci")
37 local datatypes = require("luci.cbi.datatypes")
38 local class = util.class
39 local instanceof = util.instanceof
40
41 FORM_NODATA = 0
42 FORM_PROCEED = 0
43 FORM_VALID = 1
44 FORM_DONE = 1
45 FORM_INVALID = -1
46 FORM_CHANGED = 2
47 FORM_SKIP = 4
48
49 AUTO = true
50
51 CREATE_PREFIX = "cbi.cts."
52 REMOVE_PREFIX = "cbi.rts."
53 RESORT_PREFIX = "cbi.sts."
54 FEXIST_PREFIX = "cbi.cbe."
55
56 -- Loads a CBI map from given file, creating an environment and returns it
57 function load(cbimap, ...)
58 local fs = require "nixio.fs"
59 local i18n = require "luci.i18n"
60 require("luci.config")
61 require("luci.util")
62
63 local upldir = "/lib/uci/upload/"
64 local cbidir = luci.util.libpath() .. "/model/cbi/"
65 local func, err
66
67 if fs.access(cbidir..cbimap..".lua") then
68 func, err = loadfile(cbidir..cbimap..".lua")
69 elseif fs.access(cbimap) then
70 func, err = loadfile(cbimap)
71 else
72 func, err = nil, "Model '" .. cbimap .. "' not found!"
73 end
74
75 assert(func, err)
76
77 local env = {
78 translate=i18n.translate,
79 translatef=i18n.translatef,
80 arg={...}
81 }
82
83 setfenv(func, setmetatable(env, {__index =
84 function(tbl, key)
85 return rawget(tbl, key) or _M[key] or _G[key]
86 end}))
87
88 local maps = { func() }
89 local uploads = { }
90 local has_upload = false
91
92 for i, map in ipairs(maps) do
93 if not instanceof(map, Node) then
94 error("CBI map returns no valid map object!")
95 return nil
96 else
97 map:prepare()
98 if map.upload_fields then
99 has_upload = true
100 for _, field in ipairs(map.upload_fields) do
101 uploads[
102 field.config .. '.' ..
103 (field.section.sectiontype or '1') .. '.' ..
104 field.option
105 ] = true
106 end
107 end
108 end
109 end
110
111 if has_upload then
112 local uci = luci.model.uci.cursor()
113 local prm = luci.http.context.request.message.params
114 local fd, cbid
115
116 luci.http.setfilehandler(
117 function( field, chunk, eof )
118 if not field then return end
119 if field.name and not cbid then
120 local c, s, o = field.name:gmatch(
121 "cbid%.([^%.]+)%.([^%.]+)%.([^%.]+)"
122 )()
123
124 if c and s and o then
125 local t = uci:get( c, s ) or s
126 if uploads[c.."."..t.."."..o] then
127 local path = upldir .. field.name
128 fd = io.open(path, "w")
129 if fd then
130 cbid = field.name
131 prm[cbid] = path
132 end
133 end
134 end
135 end
136
137 if field.name == cbid and fd then
138 fd:write(chunk)
139 end
140
141 if eof and fd then
142 fd:close()
143 fd = nil
144 cbid = nil
145 end
146 end
147 )
148 end
149
150 return maps
151 end
152
153 --
154 -- Compile a datatype specification into a parse tree for evaluation later on
155 --
156 local cdt_cache = { }
157
158 function compile_datatype(code)
159 local i
160 local pos = 0
161 local esc = false
162 local depth = 0
163 local stack = { }
164
165 for i = 1, #code+1 do
166 local byte = code:byte(i) or 44
167 if esc then
168 esc = false
169 elseif byte == 92 then
170 esc = true
171 elseif byte == 40 or byte == 44 then
172 if depth <= 0 then
173 if pos < i then
174 local label = code:sub(pos, i-1)
175 :gsub("\\(.)", "%1")
176 :gsub("^%s+", "")
177 :gsub("%s+$", "")
178
179 if #label > 0 and tonumber(label) then
180 stack[#stack+1] = tonumber(label)
181 elseif label:match("^'.*'$") or label:match('^".*"$') then
182 stack[#stack+1] = label:gsub("[\"'](.*)[\"']", "%1")
183 elseif type(datatypes[label]) == "function" then
184 stack[#stack+1] = datatypes[label]
185 stack[#stack+1] = { }
186 else
187 error("Datatype error, bad token %q" % label)
188 end
189 end
190 pos = i + 1
191 end
192 depth = depth + (byte == 40 and 1 or 0)
193 elseif byte == 41 then
194 depth = depth - 1
195 if depth <= 0 then
196 if type(stack[#stack-1]) ~= "function" then
197 error("Datatype error, argument list follows non-function")
198 end
199 stack[#stack] = compile_datatype(code:sub(pos, i-1))
200 pos = i + 1
201 end
202 end
203 end
204
205 return stack
206 end
207
208 function verify_datatype(dt, value)
209 if dt and #dt > 0 then
210 if not cdt_cache[dt] then
211 local c = compile_datatype(dt)
212 if c and type(c[1]) == "function" then
213 cdt_cache[dt] = c
214 else
215 error("Datatype error, not a function expression")
216 end
217 end
218 if cdt_cache[dt] then
219 return cdt_cache[dt][1](value, unpack(cdt_cache[dt][2]))
220 end
221 end
222 return true
223 end
224
225
226 -- Node pseudo abstract class
227 Node = class()
228
229 function Node.__init__(self, title, description)
230 self.children = {}
231 self.title = title or ""
232 self.description = description or ""
233 self.template = "cbi/node"
234 end
235
236 -- hook helper
237 function Node._run_hook(self, hook)
238 if type(self[hook]) == "function" then
239 return self[hook](self)
240 end
241 end
242
243 function Node._run_hooks(self, ...)
244 local f
245 local r = false
246 for _, f in ipairs(arg) do
247 if type(self[f]) == "function" then
248 self[f](self)
249 r = true
250 end
251 end
252 return r
253 end
254
255 -- Prepare nodes
256 function Node.prepare(self, ...)
257 for k, child in ipairs(self.children) do
258 child:prepare(...)
259 end
260 end
261
262 -- Append child nodes
263 function Node.append(self, obj)
264 table.insert(self.children, obj)
265 end
266
267 -- Parse this node and its children
268 function Node.parse(self, ...)
269 for k, child in ipairs(self.children) do
270 child:parse(...)
271 end
272 end
273
274 -- Render this node
275 function Node.render(self, scope)
276 scope = scope or {}
277 scope.self = self
278
279 luci.template.render(self.template, scope)
280 end
281
282 -- Render the children
283 function Node.render_children(self, ...)
284 local k, node
285 for k, node in ipairs(self.children) do
286 node.last_child = (k == #self.children)
287 node:render(...)
288 end
289 end
290
291
292 --[[
293 A simple template element
294 ]]--
295 Template = class(Node)
296
297 function Template.__init__(self, template)
298 Node.__init__(self)
299 self.template = template
300 end
301
302 function Template.render(self)
303 luci.template.render(self.template, {self=self})
304 end
305
306 function Template.parse(self, readinput)
307 self.readinput = (readinput ~= false)
308 return Map.formvalue(self, "cbi.submit") and FORM_DONE or FORM_NODATA
309 end
310
311
312 --[[
313 Map - A map describing a configuration file
314 ]]--
315 Map = class(Node)
316
317 function Map.__init__(self, config, ...)
318 Node.__init__(self, ...)
319
320 self.config = config
321 self.parsechain = {self.config}
322 self.template = "cbi/map"
323 self.apply_on_parse = nil
324 self.readinput = true
325 self.proceed = false
326 self.flow = {}
327
328 self.uci = uci.cursor()
329 self.save = true
330
331 self.changed = false
332
333 if not self.uci:load(self.config) then
334 error("Unable to read UCI data: " .. self.config)
335 end
336 end
337
338 function Map.formvalue(self, key)
339 return self.readinput and luci.http.formvalue(key)
340 end
341
342 function Map.formvaluetable(self, key)
343 return self.readinput and luci.http.formvaluetable(key) or {}
344 end
345
346 function Map.get_scheme(self, sectiontype, option)
347 if not option then
348 return self.scheme and self.scheme.sections[sectiontype]
349 else
350 return self.scheme and self.scheme.variables[sectiontype]
351 and self.scheme.variables[sectiontype][option]
352 end
353 end
354
355 function Map.submitstate(self)
356 return self:formvalue("cbi.submit")
357 end
358
359 -- Chain foreign config
360 function Map.chain(self, config)
361 table.insert(self.parsechain, config)
362 end
363
364 function Map.state_handler(self, state)
365 return state
366 end
367
368 -- Use optimized UCI writing
369 function Map.parse(self, readinput, ...)
370 self.readinput = (readinput ~= false)
371 self:_run_hooks("on_parse")
372
373 if self:formvalue("cbi.skip") then
374 self.state = FORM_SKIP
375 return self:state_handler(self.state)
376 end
377
378 Node.parse(self, ...)
379
380 if self.save then
381 self:_run_hooks("on_save", "on_before_save")
382 for i, config in ipairs(self.parsechain) do
383 self.uci:save(config)
384 end
385 self:_run_hooks("on_after_save")
386 if self:submitstate() and ((not self.proceed and self.flow.autoapply) or luci.http.formvalue("cbi.apply")) then
387 self:_run_hooks("on_before_commit")
388 for i, config in ipairs(self.parsechain) do
389 self.uci:commit(config)
390
391 -- Refresh data because commit changes section names
392 self.uci:load(config)
393 end
394 self:_run_hooks("on_commit", "on_after_commit", "on_before_apply")
395 if self.apply_on_parse then
396 self.uci:apply(self.parsechain)
397 self:_run_hooks("on_apply", "on_after_apply")
398 else
399 -- This is evaluated by the dispatcher and delegated to the
400 -- template which in turn fires XHR to perform the actual
401 -- apply actions.
402 self.apply_needed = true
403 end
404
405 -- Reparse sections
406 Node.parse(self, true)
407
408 end
409 for i, config in ipairs(self.parsechain) do
410 self.uci:unload(config)
411 end
412 if type(self.commit_handler) == "function" then
413 self:commit_handler(self:submitstate())
414 end
415 end
416
417 if self:submitstate() then
418 if not self.save then
419 self.state = FORM_INVALID
420 elseif self.proceed then
421 self.state = FORM_PROCEED
422 else
423 self.state = self.changed and FORM_CHANGED or FORM_VALID
424 end
425 else
426 self.state = FORM_NODATA
427 end
428
429 return self:state_handler(self.state)
430 end
431
432 function Map.render(self, ...)
433 self:_run_hooks("on_init")
434 Node.render(self, ...)
435 end
436
437 -- Creates a child section
438 function Map.section(self, class, ...)
439 if instanceof(class, AbstractSection) then
440 local obj = class(self, ...)
441 self:append(obj)
442 return obj
443 else
444 error("class must be a descendent of AbstractSection")
445 end
446 end
447
448 -- UCI add
449 function Map.add(self, sectiontype)
450 return self.uci:add(self.config, sectiontype)
451 end
452
453 -- UCI set
454 function Map.set(self, section, option, value)
455 if type(value) ~= "table" or #value > 0 then
456 if option then
457 return self.uci:set(self.config, section, option, value)
458 else
459 return self.uci:set(self.config, section, value)
460 end
461 else
462 return Map.del(self, section, option)
463 end
464 end
465
466 -- UCI del
467 function Map.del(self, section, option)
468 if option then
469 return self.uci:delete(self.config, section, option)
470 else
471 return self.uci:delete(self.config, section)
472 end
473 end
474
475 -- UCI get
476 function Map.get(self, section, option)
477 if not section then
478 return self.uci:get_all(self.config)
479 elseif option then
480 return self.uci:get(self.config, section, option)
481 else
482 return self.uci:get_all(self.config, section)
483 end
484 end
485
486 --[[
487 Compound - Container
488 ]]--
489 Compound = class(Node)
490
491 function Compound.__init__(self, ...)
492 Node.__init__(self)
493 self.template = "cbi/compound"
494 self.children = {...}
495 end
496
497 function Compound.populate_delegator(self, delegator)
498 for _, v in ipairs(self.children) do
499 v.delegator = delegator
500 end
501 end
502
503 function Compound.parse(self, ...)
504 local cstate, state = 0
505
506 for k, child in ipairs(self.children) do
507 cstate = child:parse(...)
508 state = (not state or cstate < state) and cstate or state
509 end
510
511 return state
512 end
513
514
515 --[[
516 Delegator - Node controller
517 ]]--
518 Delegator = class(Node)
519 function Delegator.__init__(self, ...)
520 Node.__init__(self, ...)
521 self.nodes = {}
522 self.defaultpath = {}
523 self.pageaction = false
524 self.readinput = true
525 self.allow_reset = false
526 self.allow_cancel = false
527 self.allow_back = false
528 self.allow_finish = false
529 self.template = "cbi/delegator"
530 end
531
532 function Delegator.set(self, name, node)
533 assert(not self.nodes[name], "Duplicate entry")
534
535 self.nodes[name] = node
536 end
537
538 function Delegator.add(self, name, node)
539 node = self:set(name, node)
540 self.defaultpath[#self.defaultpath+1] = name
541 end
542
543 function Delegator.insert_after(self, name, after)
544 local n = #self.chain + 1
545 for k, v in ipairs(self.chain) do
546 if v == after then
547 n = k + 1
548 break
549 end
550 end
551 table.insert(self.chain, n, name)
552 end
553
554 function Delegator.set_route(self, ...)
555 local n, chain, route = 0, self.chain, {...}
556 for i = 1, #chain do
557 if chain[i] == self.current then
558 n = i
559 break
560 end
561 end
562 for i = 1, #route do
563 n = n + 1
564 chain[n] = route[i]
565 end
566 for i = n + 1, #chain do
567 chain[i] = nil
568 end
569 end
570
571 function Delegator.get(self, name)
572 local node = self.nodes[name]
573
574 if type(node) == "string" then
575 node = load(node, name)
576 end
577
578 if type(node) == "table" and getmetatable(node) == nil then
579 node = Compound(unpack(node))
580 end
581
582 return node
583 end
584
585 function Delegator.parse(self, ...)
586 if self.allow_cancel and Map.formvalue(self, "cbi.cancel") then
587 if self:_run_hooks("on_cancel") then
588 return FORM_DONE
589 end
590 end
591
592 if not Map.formvalue(self, "cbi.delg.current") then
593 self:_run_hooks("on_init")
594 end
595
596 local newcurrent
597 self.chain = self.chain or self:get_chain()
598 self.current = self.current or self:get_active()
599 self.active = self.active or self:get(self.current)
600 assert(self.active, "Invalid state")
601
602 local stat = FORM_DONE
603 if type(self.active) ~= "function" then
604 self.active:populate_delegator(self)
605 stat = self.active:parse()
606 else
607 self:active()
608 end
609
610 if stat > FORM_PROCEED then
611 if Map.formvalue(self, "cbi.delg.back") then
612 newcurrent = self:get_prev(self.current)
613 else
614 newcurrent = self:get_next(self.current)
615 end
616 elseif stat < FORM_PROCEED then
617 return stat
618 end
619
620
621 if not Map.formvalue(self, "cbi.submit") then
622 return FORM_NODATA
623 elseif stat > FORM_PROCEED
624 and (not newcurrent or not self:get(newcurrent)) then
625 return self:_run_hook("on_done") or FORM_DONE
626 else
627 self.current = newcurrent or self.current
628 self.active = self:get(self.current)
629 if type(self.active) ~= "function" then
630 self.active:populate_delegator(self)
631 local stat = self.active:parse(false)
632 if stat == FORM_SKIP then
633 return self:parse(...)
634 else
635 return FORM_PROCEED
636 end
637 else
638 return self:parse(...)
639 end
640 end
641 end
642
643 function Delegator.get_next(self, state)
644 for k, v in ipairs(self.chain) do
645 if v == state then
646 return self.chain[k+1]
647 end
648 end
649 end
650
651 function Delegator.get_prev(self, state)
652 for k, v in ipairs(self.chain) do
653 if v == state then
654 return self.chain[k-1]
655 end
656 end
657 end
658
659 function Delegator.get_chain(self)
660 local x = Map.formvalue(self, "cbi.delg.path") or self.defaultpath
661 return type(x) == "table" and x or {x}
662 end
663
664 function Delegator.get_active(self)
665 return Map.formvalue(self, "cbi.delg.current") or self.chain[1]
666 end
667
668 --[[
669 Page - A simple node
670 ]]--
671
672 Page = class(Node)
673 Page.__init__ = Node.__init__
674 Page.parse = function() end
675
676
677 --[[
678 SimpleForm - A Simple non-UCI form
679 ]]--
680 SimpleForm = class(Node)
681
682 function SimpleForm.__init__(self, config, title, description, data)
683 Node.__init__(self, title, description)
684 self.config = config
685 self.data = data or {}
686 self.template = "cbi/simpleform"
687 self.dorender = true
688 self.pageaction = false
689 self.readinput = true
690 end
691
692 SimpleForm.formvalue = Map.formvalue
693 SimpleForm.formvaluetable = Map.formvaluetable
694
695 function SimpleForm.parse(self, readinput, ...)
696 self.readinput = (readinput ~= false)
697
698 if self:formvalue("cbi.skip") then
699 return FORM_SKIP
700 end
701
702 if self:formvalue("cbi.cancel") and self:_run_hooks("on_cancel") then
703 return FORM_DONE
704 end
705
706 if self:submitstate() then
707 Node.parse(self, 1, ...)
708 end
709
710 local valid = true
711 for k, j in ipairs(self.children) do
712 for i, v in ipairs(j.children) do
713 valid = valid
714 and (not v.tag_missing or not v.tag_missing[1])
715 and (not v.tag_invalid or not v.tag_invalid[1])
716 and (not v.error)
717 end
718 end
719
720 local state =
721 not self:submitstate() and FORM_NODATA
722 or valid and FORM_VALID
723 or FORM_INVALID
724
725 self.dorender = not self.handle
726 if self.handle then
727 local nrender, nstate = self:handle(state, self.data)
728 self.dorender = self.dorender or (nrender ~= false)
729 state = nstate or state
730 end
731 return state
732 end
733
734 function SimpleForm.render(self, ...)
735 if self.dorender then
736 Node.render(self, ...)
737 end
738 end
739
740 function SimpleForm.submitstate(self)
741 return self:formvalue("cbi.submit")
742 end
743
744 function SimpleForm.section(self, class, ...)
745 if instanceof(class, AbstractSection) then
746 local obj = class(self, ...)
747 self:append(obj)
748 return obj
749 else
750 error("class must be a descendent of AbstractSection")
751 end
752 end
753
754 -- Creates a child field
755 function SimpleForm.field(self, class, ...)
756 local section
757 for k, v in ipairs(self.children) do
758 if instanceof(v, SimpleSection) then
759 section = v
760 break
761 end
762 end
763 if not section then
764 section = self:section(SimpleSection)
765 end
766
767 if instanceof(class, AbstractValue) then
768 local obj = class(self, section, ...)
769 obj.track_missing = true
770 section:append(obj)
771 return obj
772 else
773 error("class must be a descendent of AbstractValue")
774 end
775 end
776
777 function SimpleForm.set(self, section, option, value)
778 self.data[option] = value
779 end
780
781
782 function SimpleForm.del(self, section, option)
783 self.data[option] = nil
784 end
785
786
787 function SimpleForm.get(self, section, option)
788 return self.data[option]
789 end
790
791
792 function SimpleForm.get_scheme()
793 return nil
794 end
795
796
797 Form = class(SimpleForm)
798
799 function Form.__init__(self, ...)
800 SimpleForm.__init__(self, ...)
801 self.embedded = true
802 end
803
804
805 --[[
806 AbstractSection
807 ]]--
808 AbstractSection = class(Node)
809
810 function AbstractSection.__init__(self, map, sectiontype, ...)
811 Node.__init__(self, ...)
812 self.sectiontype = sectiontype
813 self.map = map
814 self.config = map.config
815 self.optionals = {}
816 self.defaults = {}
817 self.fields = {}
818 self.tag_error = {}
819 self.tag_invalid = {}
820 self.tag_deperror = {}
821 self.changed = false
822
823 self.optional = true
824 self.addremove = false
825 self.dynamic = false
826 end
827
828 -- Define a tab for the section
829 function AbstractSection.tab(self, tab, title, desc)
830 self.tabs = self.tabs or { }
831 self.tab_names = self.tab_names or { }
832
833 self.tab_names[#self.tab_names+1] = tab
834 self.tabs[tab] = {
835 title = title,
836 description = desc,
837 childs = { }
838 }
839 end
840
841 -- Check whether the section has tabs
842 function AbstractSection.has_tabs(self)
843 return (self.tabs ~= nil) and (next(self.tabs) ~= nil)
844 end
845
846 -- Appends a new option
847 function AbstractSection.option(self, class, option, ...)
848 if instanceof(class, AbstractValue) then
849 local obj = class(self.map, self, option, ...)
850 self:append(obj)
851 self.fields[option] = obj
852 return obj
853 elseif class == true then
854 error("No valid class was given and autodetection failed.")
855 else
856 error("class must be a descendant of AbstractValue")
857 end
858 end
859
860 -- Appends a new tabbed option
861 function AbstractSection.taboption(self, tab, ...)
862
863 assert(tab and self.tabs and self.tabs[tab],
864 "Cannot assign option to not existing tab %q" % tostring(tab))
865
866 local l = self.tabs[tab].childs
867 local o = AbstractSection.option(self, ...)
868
869 if o then l[#l+1] = o end
870
871 return o
872 end
873
874 -- Render a single tab
875 function AbstractSection.render_tab(self, tab, ...)
876
877 assert(tab and self.tabs and self.tabs[tab],
878 "Cannot render not existing tab %q" % tostring(tab))
879
880 local k, node
881 for k, node in ipairs(self.tabs[tab].childs) do
882 node.last_child = (k == #self.tabs[tab].childs)
883 node:render(...)
884 end
885 end
886
887 -- Parse optional options
888 function AbstractSection.parse_optionals(self, section)
889 if not self.optional then
890 return
891 end
892
893 self.optionals[section] = {}
894
895 local field = self.map:formvalue("cbi.opt."..self.config.."."..section)
896 for k,v in ipairs(self.children) do
897 if v.optional and not v:cfgvalue(section) and not self:has_tabs() then
898 if field == v.option then
899 field = nil
900 self.map.proceed = true
901 else
902 table.insert(self.optionals[section], v)
903 end
904 end
905 end
906
907 if field and #field > 0 and self.dynamic then
908 self:add_dynamic(field)
909 end
910 end
911
912 -- Add a dynamic option
913 function AbstractSection.add_dynamic(self, field, optional)
914 local o = self:option(Value, field, field)
915 o.optional = optional
916 end
917
918 -- Parse all dynamic options
919 function AbstractSection.parse_dynamic(self, section)
920 if not self.dynamic then
921 return
922 end
923
924 local arr = luci.util.clone(self:cfgvalue(section))
925 local form = self.map:formvaluetable("cbid."..self.config.."."..section)
926 for k, v in pairs(form) do
927 arr[k] = v
928 end
929
930 for key,val in pairs(arr) do
931 local create = true
932
933 for i,c in ipairs(self.children) do
934 if c.option == key then
935 create = false
936 end
937 end
938
939 if create and key:sub(1, 1) ~= "." then
940 self.map.proceed = true
941 self:add_dynamic(key, true)
942 end
943 end
944 end
945
946 -- Returns the section's UCI table
947 function AbstractSection.cfgvalue(self, section)
948 return self.map:get(section)
949 end
950
951 -- Push events
952 function AbstractSection.push_events(self)
953 --luci.util.append(self.map.events, self.events)
954 self.map.changed = true
955 end
956
957 -- Removes the section
958 function AbstractSection.remove(self, section)
959 self.map.proceed = true
960 return self.map:del(section)
961 end
962
963 -- Creates the section
964 function AbstractSection.create(self, section)
965 local stat
966
967 if section then
968 stat = section:match("^[%w_]+$") and self.map:set(section, nil, self.sectiontype)
969 else
970 section = self.map:add(self.sectiontype)
971 stat = section
972 end
973
974 if stat then
975 for k,v in pairs(self.children) do
976 if v.default then
977 self.map:set(section, v.option, v.default)
978 end
979 end
980
981 for k,v in pairs(self.defaults) do
982 self.map:set(section, k, v)
983 end
984 end
985
986 self.map.proceed = true
987
988 return stat
989 end
990
991
992 SimpleSection = class(AbstractSection)
993
994 function SimpleSection.__init__(self, form, ...)
995 AbstractSection.__init__(self, form, nil, ...)
996 self.template = "cbi/nullsection"
997 end
998
999
1000 Table = class(AbstractSection)
1001
1002 function Table.__init__(self, form, data, ...)
1003 local datasource = {}
1004 local tself = self
1005 datasource.config = "table"
1006 self.data = data or {}
1007
1008 datasource.formvalue = Map.formvalue
1009 datasource.formvaluetable = Map.formvaluetable
1010 datasource.readinput = true
1011
1012 function datasource.get(self, section, option)
1013 return tself.data[section] and tself.data[section][option]
1014 end
1015
1016 function datasource.submitstate(self)
1017 return Map.formvalue(self, "cbi.submit")
1018 end
1019
1020 function datasource.del(...)
1021 return true
1022 end
1023
1024 function datasource.get_scheme()
1025 return nil
1026 end
1027
1028 AbstractSection.__init__(self, datasource, "table", ...)
1029 self.template = "cbi/tblsection"
1030 self.rowcolors = true
1031 self.anonymous = true
1032 end
1033
1034 function Table.parse(self, readinput)
1035 self.map.readinput = (readinput ~= false)
1036 for i, k in ipairs(self:cfgsections()) do
1037 if self.map:submitstate() then
1038 Node.parse(self, k)
1039 end
1040 end
1041 end
1042
1043 function Table.cfgsections(self)
1044 local sections = {}
1045
1046 for i, v in luci.util.kspairs(self.data) do
1047 table.insert(sections, i)
1048 end
1049
1050 return sections
1051 end
1052
1053 function Table.update(self, data)
1054 self.data = data
1055 end
1056
1057
1058
1059 --[[
1060 NamedSection - A fixed configuration section defined by its name
1061 ]]--
1062 NamedSection = class(AbstractSection)
1063
1064 function NamedSection.__init__(self, map, section, stype, ...)
1065 AbstractSection.__init__(self, map, stype, ...)
1066
1067 -- Defaults
1068 self.addremove = false
1069 self.template = "cbi/nsection"
1070 self.section = section
1071 end
1072
1073 function NamedSection.parse(self, novld)
1074 local s = self.section
1075 local active = self:cfgvalue(s)
1076
1077 if self.addremove then
1078 local path = self.config.."."..s
1079 if active then -- Remove the section
1080 if self.map:formvalue("cbi.rns."..path) and self:remove(s) then
1081 self:push_events()
1082 return
1083 end
1084 else -- Create and apply default values
1085 if self.map:formvalue("cbi.cns."..path) then
1086 self:create(s)
1087 return
1088 end
1089 end
1090 end
1091
1092 if active then
1093 AbstractSection.parse_dynamic(self, s)
1094 if self.map:submitstate() then
1095 Node.parse(self, s)
1096 end
1097 AbstractSection.parse_optionals(self, s)
1098
1099 if self.changed then
1100 self:push_events()
1101 end
1102 end
1103 end
1104
1105
1106 --[[
1107 TypedSection - A (set of) configuration section(s) defined by the type
1108 addremove: Defines whether the user can add/remove sections of this type
1109 anonymous: Allow creating anonymous sections
1110 validate: a validation function returning nil if the section is invalid
1111 ]]--
1112 TypedSection = class(AbstractSection)
1113
1114 function TypedSection.__init__(self, map, type, ...)
1115 AbstractSection.__init__(self, map, type, ...)
1116
1117 self.template = "cbi/tsection"
1118 self.deps = {}
1119 self.anonymous = false
1120 end
1121
1122 -- Return all matching UCI sections for this TypedSection
1123 function TypedSection.cfgsections(self)
1124 local sections = {}
1125 self.map.uci:foreach(self.map.config, self.sectiontype,
1126 function (section)
1127 if self:checkscope(section[".name"]) then
1128 table.insert(sections, section[".name"])
1129 end
1130 end)
1131
1132 return sections
1133 end
1134
1135 -- Limits scope to sections that have certain option => value pairs
1136 function TypedSection.depends(self, option, value)
1137 table.insert(self.deps, {option=option, value=value})
1138 end
1139
1140 function TypedSection.parse(self, novld)
1141 if self.addremove then
1142 -- Remove
1143 local crval = REMOVE_PREFIX .. self.config
1144 local name = self.map:formvaluetable(crval)
1145 for k,v in pairs(name) do
1146 if k:sub(-2) == ".x" then
1147 k = k:sub(1, #k - 2)
1148 end
1149 if self:cfgvalue(k) and self:checkscope(k) then
1150 self:remove(k)
1151 end
1152 end
1153 end
1154
1155 local co
1156 for i, k in ipairs(self:cfgsections()) do
1157 AbstractSection.parse_dynamic(self, k)
1158 if self.map:submitstate() then
1159 Node.parse(self, k, novld)
1160 end
1161 AbstractSection.parse_optionals(self, k)
1162 end
1163
1164 if self.addremove then
1165 -- Create
1166 local created
1167 local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
1168 local origin, name = next(self.map:formvaluetable(crval))
1169 if self.anonymous then
1170 if name then
1171 created = self:create(nil, origin)
1172 end
1173 else
1174 if name then
1175 -- Ignore if it already exists
1176 if self:cfgvalue(name) then
1177 name = nil;
1178 end
1179
1180 name = self:checkscope(name)
1181
1182 if not name then
1183 self.err_invalid = true
1184 end
1185
1186 if name and #name > 0 then
1187 created = self:create(name, origin) and name
1188 if not created then
1189 self.invalid_cts = true
1190 end
1191 end
1192 end
1193 end
1194
1195 if created then
1196 AbstractSection.parse_optionals(self, created)
1197 end
1198 end
1199
1200 if self.sortable then
1201 local stval = RESORT_PREFIX .. self.config .. "." .. self.sectiontype
1202 local order = self.map:formvalue(stval)
1203 if order and #order > 0 then
1204 local sid
1205 local num = 0
1206 for sid in util.imatch(order) do
1207 self.map.uci:reorder(self.config, sid, num)
1208 num = num + 1
1209 end
1210 self.changed = (num > 0)
1211 end
1212 end
1213
1214 if created or self.changed then
1215 self:push_events()
1216 end
1217 end
1218
1219 -- Verifies scope of sections
1220 function TypedSection.checkscope(self, section)
1221 -- Check if we are not excluded
1222 if self.filter and not self:filter(section) then
1223 return nil
1224 end
1225
1226 -- Check if at least one dependency is met
1227 if #self.deps > 0 and self:cfgvalue(section) then
1228 local stat = false
1229
1230 for k, v in ipairs(self.deps) do
1231 if self:cfgvalue(section)[v.option] == v.value then
1232 stat = true
1233 end
1234 end
1235
1236 if not stat then
1237 return nil
1238 end
1239 end
1240
1241 return self:validate(section)
1242 end
1243
1244
1245 -- Dummy validate function
1246 function TypedSection.validate(self, section)
1247 return section
1248 end
1249
1250
1251 --[[
1252 AbstractValue - An abstract Value Type
1253 null: Value can be empty
1254 valid: A function returning the value if it is valid otherwise nil
1255 depends: A table of option => value pairs of which one must be true
1256 default: The default value
1257 size: The size of the input fields
1258 rmempty: Unset value if empty
1259 optional: This value is optional (see AbstractSection.optionals)
1260 ]]--
1261 AbstractValue = class(Node)
1262
1263 function AbstractValue.__init__(self, map, section, option, ...)
1264 Node.__init__(self, ...)
1265 self.section = section
1266 self.option = option
1267 self.map = map
1268 self.config = map.config
1269 self.tag_invalid = {}
1270 self.tag_missing = {}
1271 self.tag_reqerror = {}
1272 self.tag_error = {}
1273 self.deps = {}
1274 self.subdeps = {}
1275 --self.cast = "string"
1276
1277 self.track_missing = false
1278 self.rmempty = true
1279 self.default = nil
1280 self.size = nil
1281 self.optional = false
1282 end
1283
1284 function AbstractValue.prepare(self)
1285 self.cast = self.cast or "string"
1286 end
1287
1288 -- Add a dependencie to another section field
1289 function AbstractValue.depends(self, field, value)
1290 local deps
1291 if type(field) == "string" then
1292 deps = {}
1293 deps[field] = value
1294 else
1295 deps = field
1296 end
1297
1298 table.insert(self.deps, {deps=deps, add=""})
1299 end
1300
1301 -- Generates the unique CBID
1302 function AbstractValue.cbid(self, section)
1303 return "cbid."..self.map.config.."."..section.."."..self.option
1304 end
1305
1306 -- Return whether this object should be created
1307 function AbstractValue.formcreated(self, section)
1308 local key = "cbi.opt."..self.config.."."..section
1309 return (self.map:formvalue(key) == self.option)
1310 end
1311
1312 -- Returns the formvalue for this object
1313 function AbstractValue.formvalue(self, section)
1314 return self.map:formvalue(self:cbid(section))
1315 end
1316
1317 function AbstractValue.additional(self, value)
1318 self.optional = value
1319 end
1320
1321 function AbstractValue.mandatory(self, value)
1322 self.rmempty = not value
1323 end
1324
1325 function AbstractValue.add_error(self, section, type, msg)
1326 self.error = self.error or { }
1327 self.error[section] = msg or type
1328
1329 self.section.error = self.section.error or { }
1330 self.section.error[section] = self.section.error[section] or { }
1331 table.insert(self.section.error[section], msg or type)
1332
1333 if type == "invalid" then
1334 self.tag_invalid[section] = true
1335 elseif type == "missing" then
1336 self.tag_missing[section] = true
1337 end
1338
1339 self.tag_error[section] = true
1340 self.map.save = false
1341 end
1342
1343 function AbstractValue.parse(self, section, novld)
1344 local fvalue = self:formvalue(section)
1345 local cvalue = self:cfgvalue(section)
1346
1347 -- If favlue and cvalue are both tables and have the same content
1348 -- make them identical
1349 if type(fvalue) == "table" and type(cvalue) == "table" then
1350 local equal = #fvalue == #cvalue
1351 if equal then
1352 for i=1, #fvalue do
1353 if cvalue[i] ~= fvalue[i] then
1354 equal = false
1355 end
1356 end
1357 end
1358 if equal then
1359 fvalue = cvalue
1360 end
1361 end
1362
1363 if fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
1364 local val_err
1365 fvalue, val_err = self:validate(fvalue, section)
1366 fvalue = self:transform(fvalue)
1367
1368 if not fvalue and not novld then
1369 self:add_error(section, "invalid", val_err)
1370 end
1371
1372 if fvalue and (self.forcewrite or not (fvalue == cvalue)) then
1373 if self:write(section, fvalue) then
1374 -- Push events
1375 self.section.changed = true
1376 --luci.util.append(self.map.events, self.events)
1377 end
1378 end
1379 else -- Unset the UCI or error
1380 if self.rmempty or self.optional then
1381 if self:remove(section) then
1382 -- Push events
1383 self.section.changed = true
1384 --luci.util.append(self.map.events, self.events)
1385 end
1386 elseif cvalue ~= fvalue and not novld then
1387 -- trigger validator with nil value to get custom user error msg.
1388 local _, val_err = self:validate(nil, section)
1389 self:add_error(section, "missing", val_err)
1390 end
1391 end
1392 end
1393
1394 -- Render if this value exists or if it is mandatory
1395 function AbstractValue.render(self, s, scope)
1396 if not self.optional or self.section:has_tabs() or self:cfgvalue(s) or self:formcreated(s) then
1397 scope = scope or {}
1398 scope.section = s
1399 scope.cbid = self:cbid(s)
1400 Node.render(self, scope)
1401 end
1402 end
1403
1404 -- Return the UCI value of this object
1405 function AbstractValue.cfgvalue(self, section)
1406 local value
1407 if self.tag_error[section] then
1408 value = self:formvalue(section)
1409 else
1410 value = self.map:get(section, self.option)
1411 end
1412
1413 if not value then
1414 return nil
1415 elseif not self.cast or self.cast == type(value) then
1416 return value
1417 elseif self.cast == "string" then
1418 if type(value) == "table" then
1419 return value[1]
1420 end
1421 elseif self.cast == "table" then
1422 return { value }
1423 end
1424 end
1425
1426 -- Validate the form value
1427 function AbstractValue.validate(self, value)
1428 if self.datatype and value then
1429 if type(value) == "table" then
1430 local v
1431 for _, v in ipairs(value) do
1432 if v and #v > 0 and not verify_datatype(self.datatype, v) then
1433 return nil
1434 end
1435 end
1436 else
1437 if not verify_datatype(self.datatype, value) then
1438 return nil
1439 end
1440 end
1441 end
1442
1443 return value
1444 end
1445
1446 AbstractValue.transform = AbstractValue.validate
1447
1448
1449 -- Write to UCI
1450 function AbstractValue.write(self, section, value)
1451 return self.map:set(section, self.option, value)
1452 end
1453
1454 -- Remove from UCI
1455 function AbstractValue.remove(self, section)
1456 return self.map:del(section, self.option)
1457 end
1458
1459
1460
1461
1462 --[[
1463 Value - A one-line value
1464 maxlength: The maximum length
1465 ]]--
1466 Value = class(AbstractValue)
1467
1468 function Value.__init__(self, ...)
1469 AbstractValue.__init__(self, ...)
1470 self.template = "cbi/value"
1471 self.keylist = {}
1472 self.vallist = {}
1473 end
1474
1475 function Value.reset_values(self)
1476 self.keylist = {}
1477 self.vallist = {}
1478 end
1479
1480 function Value.value(self, key, val)
1481 val = val or key
1482 table.insert(self.keylist, tostring(key))
1483 table.insert(self.vallist, tostring(val))
1484 end
1485
1486
1487 -- DummyValue - This does nothing except being there
1488 DummyValue = class(AbstractValue)
1489
1490 function DummyValue.__init__(self, ...)
1491 AbstractValue.__init__(self, ...)
1492 self.template = "cbi/dvalue"
1493 self.value = nil
1494 end
1495
1496 function DummyValue.cfgvalue(self, section)
1497 local value
1498 if self.value then
1499 if type(self.value) == "function" then
1500 value = self:value(section)
1501 else
1502 value = self.value
1503 end
1504 else
1505 value = AbstractValue.cfgvalue(self, section)
1506 end
1507 return value
1508 end
1509
1510 function DummyValue.parse(self)
1511
1512 end
1513
1514
1515 --[[
1516 Flag - A flag being enabled or disabled
1517 ]]--
1518 Flag = class(AbstractValue)
1519
1520 function Flag.__init__(self, ...)
1521 AbstractValue.__init__(self, ...)
1522 self.template = "cbi/fvalue"
1523
1524 self.enabled = "1"
1525 self.disabled = "0"
1526 self.default = self.disabled
1527 end
1528
1529 -- A flag can only have two states: set or unset
1530 function Flag.parse(self, section)
1531 local fexists = self.map:formvalue(
1532 FEXIST_PREFIX .. self.config .. "." .. section .. "." .. self.option)
1533
1534 if fexists then
1535 local fvalue = self:formvalue(section) and self.enabled or self.disabled
1536 if fvalue ~= self.default or (not self.optional and not self.rmempty) then
1537 self:write(section, fvalue)
1538 else
1539 self:remove(section)
1540 end
1541 else
1542 self:remove(section)
1543 end
1544 end
1545
1546 function Flag.cfgvalue(self, section)
1547 return AbstractValue.cfgvalue(self, section) or self.default
1548 end
1549
1550
1551 --[[
1552 ListValue - A one-line value predefined in a list
1553 widget: The widget that will be used (select, radio)
1554 ]]--
1555 ListValue = class(AbstractValue)
1556
1557 function ListValue.__init__(self, ...)
1558 AbstractValue.__init__(self, ...)
1559 self.template = "cbi/lvalue"
1560
1561 self.keylist = {}
1562 self.vallist = {}
1563 self.size = 1
1564 self.widget = "select"
1565 end
1566
1567 function ListValue.reset_values(self)
1568 self.keylist = {}
1569 self.vallist = {}
1570 end
1571
1572 function ListValue.value(self, key, val, ...)
1573 if luci.util.contains(self.keylist, key) then
1574 return
1575 end
1576
1577 val = val or key
1578 table.insert(self.keylist, tostring(key))
1579 table.insert(self.vallist, tostring(val))
1580
1581 for i, deps in ipairs({...}) do
1582 self.subdeps[#self.subdeps + 1] = {add = "-"..key, deps=deps}
1583 end
1584 end
1585
1586 function ListValue.validate(self, val)
1587 if luci.util.contains(self.keylist, val) then
1588 return val
1589 else
1590 return nil
1591 end
1592 end
1593
1594
1595
1596 --[[
1597 MultiValue - Multiple delimited values
1598 widget: The widget that will be used (select, checkbox)
1599 delimiter: The delimiter that will separate the values (default: " ")
1600 ]]--
1601 MultiValue = class(AbstractValue)
1602
1603 function MultiValue.__init__(self, ...)
1604 AbstractValue.__init__(self, ...)
1605 self.template = "cbi/mvalue"
1606
1607 self.keylist = {}
1608 self.vallist = {}
1609
1610 self.widget = "checkbox"
1611 self.delimiter = " "
1612 end
1613
1614 function MultiValue.render(self, ...)
1615 if self.widget == "select" and not self.size then
1616 self.size = #self.vallist
1617 end
1618
1619 AbstractValue.render(self, ...)
1620 end
1621
1622 function MultiValue.reset_values(self)
1623 self.keylist = {}
1624 self.vallist = {}
1625 end
1626
1627 function MultiValue.value(self, key, val)
1628 if luci.util.contains(self.keylist, key) then
1629 return
1630 end
1631
1632 val = val or key
1633 table.insert(self.keylist, tostring(key))
1634 table.insert(self.vallist, tostring(val))
1635 end
1636
1637 function MultiValue.valuelist(self, section)
1638 local val = self:cfgvalue(section)
1639
1640 if not(type(val) == "string") then
1641 return {}
1642 end
1643
1644 return luci.util.split(val, self.delimiter)
1645 end
1646
1647 function MultiValue.validate(self, val)
1648 val = (type(val) == "table") and val or {val}
1649
1650 local result
1651
1652 for i, value in ipairs(val) do
1653 if luci.util.contains(self.keylist, value) then
1654 result = result and (result .. self.delimiter .. value) or value
1655 end
1656 end
1657
1658 return result
1659 end
1660
1661
1662 StaticList = class(MultiValue)
1663
1664 function StaticList.__init__(self, ...)
1665 MultiValue.__init__(self, ...)
1666 self.cast = "table"
1667 self.valuelist = self.cfgvalue
1668
1669 if not self.override_scheme
1670 and self.map:get_scheme(self.section.sectiontype, self.option) then
1671 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1672 if self.value and vs.values and not self.override_values then
1673 for k, v in pairs(vs.values) do
1674 self:value(k, v)
1675 end
1676 end
1677 end
1678 end
1679
1680 function StaticList.validate(self, value)
1681 value = (type(value) == "table") and value or {value}
1682
1683 local valid = {}
1684 for i, v in ipairs(value) do
1685 if luci.util.contains(self.keylist, v) then
1686 table.insert(valid, v)
1687 end
1688 end
1689 return valid
1690 end
1691
1692
1693 DynamicList = class(AbstractValue)
1694
1695 function DynamicList.__init__(self, ...)
1696 AbstractValue.__init__(self, ...)
1697 self.template = "cbi/dynlist"
1698 self.cast = "table"
1699 self.keylist = {}
1700 self.vallist = {}
1701 end
1702
1703 function DynamicList.reset_values(self)
1704 self.keylist = {}
1705 self.vallist = {}
1706 end
1707
1708 function DynamicList.value(self, key, val)
1709 val = val or key
1710 table.insert(self.keylist, tostring(key))
1711 table.insert(self.vallist, tostring(val))
1712 end
1713
1714 function DynamicList.write(self, section, value)
1715 local t = { }
1716
1717 if type(value) == "table" then
1718 local x
1719 for _, x in ipairs(value) do
1720 if x and #x > 0 then
1721 t[#t+1] = x
1722 end
1723 end
1724 else
1725 t = { value }
1726 end
1727
1728 if self.cast == "string" then
1729 value = table.concat(t, " ")
1730 else
1731 value = t
1732 end
1733
1734 return AbstractValue.write(self, section, value)
1735 end
1736
1737 function DynamicList.cfgvalue(self, section)
1738 local value = AbstractValue.cfgvalue(self, section)
1739
1740 if type(value) == "string" then
1741 local x
1742 local t = { }
1743 for x in value:gmatch("%S+") do
1744 if #x > 0 then
1745 t[#t+1] = x
1746 end
1747 end
1748 value = t
1749 end
1750
1751 return value
1752 end
1753
1754 function DynamicList.formvalue(self, section)
1755 local value = AbstractValue.formvalue(self, section)
1756
1757 if type(value) == "string" then
1758 if self.cast == "string" then
1759 local x
1760 local t = { }
1761 for x in value:gmatch("%S+") do
1762 t[#t+1] = x
1763 end
1764 value = t
1765 else
1766 value = { value }
1767 end
1768 end
1769
1770 return value
1771 end
1772
1773
1774 --[[
1775 TextValue - A multi-line value
1776 rows: Rows
1777 ]]--
1778 TextValue = class(AbstractValue)
1779
1780 function TextValue.__init__(self, ...)
1781 AbstractValue.__init__(self, ...)
1782 self.template = "cbi/tvalue"
1783 end
1784
1785 --[[
1786 Button
1787 ]]--
1788 Button = class(AbstractValue)
1789
1790 function Button.__init__(self, ...)
1791 AbstractValue.__init__(self, ...)
1792 self.template = "cbi/button"
1793 self.inputstyle = nil
1794 self.rmempty = true
1795 end
1796
1797
1798 FileUpload = class(AbstractValue)
1799
1800 function FileUpload.__init__(self, ...)
1801 AbstractValue.__init__(self, ...)
1802 self.template = "cbi/upload"
1803 if not self.map.upload_fields then
1804 self.map.upload_fields = { self }
1805 else
1806 self.map.upload_fields[#self.map.upload_fields+1] = self
1807 end
1808 end
1809
1810 function FileUpload.formcreated(self, section)
1811 return AbstractValue.formcreated(self, section) or
1812 self.map:formvalue("cbi.rlf."..section.."."..self.option) or
1813 self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1814 end
1815
1816 function FileUpload.cfgvalue(self, section)
1817 local val = AbstractValue.cfgvalue(self, section)
1818 if val and fs.access(val) then
1819 return val
1820 end
1821 return nil
1822 end
1823
1824 function FileUpload.formvalue(self, section)
1825 local val = AbstractValue.formvalue(self, section)
1826 if val then
1827 if not self.map:formvalue("cbi.rlf."..section.."."..self.option) and
1828 not self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1829 then
1830 return val
1831 end
1832 fs.unlink(val)
1833 self.value = nil
1834 end
1835 return nil
1836 end
1837
1838 function FileUpload.remove(self, section)
1839 local val = AbstractValue.formvalue(self, section)
1840 if val and fs.access(val) then fs.unlink(val) end
1841 return AbstractValue.remove(self, section)
1842 end
1843
1844
1845 FileBrowser = class(AbstractValue)
1846
1847 function FileBrowser.__init__(self, ...)
1848 AbstractValue.__init__(self, ...)
1849 self.template = "cbi/browser"
1850 end