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