projects / project / luci.git / blob
? search:


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