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


33b0c7cb474914c2066d91143d7ff02d5a73e36a
[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 fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
1334 fvalue = self:transform(self:validate(fvalue, section))
1335 if not fvalue and not novld then
1336 if self.error then
1337 self.error[section] = "invalid"
1338 else
1339 self.error = { [section] = "invalid" }
1340 end
1341 if self.section.error then
1342 table.insert(self.section.error[section], "invalid")
1343 else
1344 self.section.error = {[section] = {"invalid"}}
1345 end
1346 self.map.save = false
1347 end
1348 if fvalue and not (fvalue == cvalue) then
1349 if self:write(section, fvalue) then
1350 -- Push events
1351 self.section.changed = true
1352 --luci.util.append(self.map.events, self.events)
1353 end
1354 end
1355 else -- Unset the UCI or error
1356 if self.rmempty or self.optional then
1357 if self:remove(section) then
1358 -- Push events
1359 self.section.changed = true
1360 --luci.util.append(self.map.events, self.events)
1361 end
1362 elseif cvalue ~= fvalue and not novld then
1363 self:write(section, fvalue or "")
1364 if self.error then
1365 self.error[section] = "missing"
1366 else
1367 self.error = { [section] = "missing" }
1368 end
1369 self.map.save = false
1370 end
1371 end
1372 end
1373
1374 -- Render if this value exists or if it is mandatory
1375 function AbstractValue.render(self, s, scope)
1376 if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
1377 scope = scope or {}
1378 scope.section = s
1379 scope.cbid = self:cbid(s)
1380 scope.striptags = luci.util.striptags
1381 scope.pcdata = luci.util.pcdata
1382
1383 scope.ifattr = function(cond,key,val)
1384 if cond then
1385 return string.format(
1386 ' %s="%s"', tostring(key),
1387 luci.util.pcdata(tostring( val
1388 or scope[key]
1389 or (type(self[key]) ~= "function" and self[key])
1390 or "" ))
1391 )
1392 else
1393 return ''
1394 end
1395 end
1396
1397 scope.attr = function(...)
1398 return scope.ifattr( true, ... )
1399 end
1400
1401 Node.render(self, scope)
1402 end
1403 end
1404
1405 -- Return the UCI value of this object
1406 function AbstractValue.cfgvalue(self, section)
1407 local value = self.map:get(section, self.option)
1408 if not value then
1409 return nil
1410 elseif not self.cast or self.cast == type(value) then
1411 return value
1412 elseif self.cast == "string" then
1413 if type(value) == "table" then
1414 return value[1]
1415 end
1416 elseif self.cast == "table" then
1417 return luci.util.split(value, "%s+", nil, true)
1418 end
1419 end
1420
1421 -- Validate the form value
1422 function AbstractValue.validate(self, value)
1423 return value
1424 end
1425
1426 AbstractValue.transform = AbstractValue.validate
1427
1428
1429 -- Write to UCI
1430 function AbstractValue.write(self, section, value)
1431 return self.map:set(section, self.option, value)
1432 end
1433
1434 -- Remove from UCI
1435 function AbstractValue.remove(self, section)
1436 return self.map:del(section, self.option)
1437 end
1438
1439
1440
1441
1442 --[[
1443 Value - A one-line value
1444 maxlength: The maximum length
1445 ]]--
1446 Value = class(AbstractValue)
1447
1448 function Value.__init__(self, ...)
1449 AbstractValue.__init__(self, ...)
1450 self.template = "cbi/value"
1451 self.keylist = {}
1452 self.vallist = {}
1453 end
1454
1455 function Value.value(self, key, val)
1456 val = val or key
1457 table.insert(self.keylist, tostring(key))
1458 table.insert(self.vallist, tostring(val))
1459 end
1460
1461
1462 -- DummyValue - This does nothing except being there
1463 DummyValue = class(AbstractValue)
1464
1465 function DummyValue.__init__(self, ...)
1466 AbstractValue.__init__(self, ...)
1467 self.template = "cbi/dvalue"
1468 self.value = nil
1469 end
1470
1471 function DummyValue.cfgvalue(self, section)
1472 local value
1473 if self.value then
1474 if type(self.value) == "function" then
1475 value = self:value(section)
1476 else
1477 value = self.value
1478 end
1479 else
1480 value = AbstractValue.cfgvalue(self, section)
1481 end
1482 return value
1483 end
1484
1485 function DummyValue.parse(self)
1486
1487 end
1488
1489
1490 --[[
1491 Flag - A flag being enabled or disabled
1492 ]]--
1493 Flag = class(AbstractValue)
1494
1495 function Flag.__init__(self, ...)
1496 AbstractValue.__init__(self, ...)
1497 self.template = "cbi/fvalue"
1498
1499 self.enabled = "1"
1500 self.disabled = "0"
1501 end
1502
1503 -- A flag can only have two states: set or unset
1504 function Flag.parse(self, section)
1505 local fvalue = self:formvalue(section)
1506
1507 if fvalue then
1508 fvalue = self.enabled
1509 else
1510 fvalue = self.disabled
1511 end
1512
1513 if fvalue == self.enabled or (not self.optional and not self.rmempty) then
1514 if not(fvalue == self:cfgvalue(section)) then
1515 self:write(section, fvalue)
1516 end
1517 else
1518 self:remove(section)
1519 end
1520 end
1521
1522
1523
1524 --[[
1525 ListValue - A one-line value predefined in a list
1526 widget: The widget that will be used (select, radio)
1527 ]]--
1528 ListValue = class(AbstractValue)
1529
1530 function ListValue.__init__(self, ...)
1531 AbstractValue.__init__(self, ...)
1532 self.template = "cbi/lvalue"
1533
1534 self.keylist = {}
1535 self.vallist = {}
1536 self.size = 1
1537 self.widget = "select"
1538 end
1539
1540 function ListValue.prepare(self, ...)
1541 AbstractValue.prepare(self, ...)
1542 if not self.override_scheme
1543 and self.map:get_scheme(self.section.sectiontype, self.option) then
1544 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1545 if self.value and vs.valuelist and not self.override_values then
1546 for k, v in ipairs(vs.valuelist) do
1547 local deps = {}
1548 if not self.override_dependencies
1549 and vs.enum_depends and vs.enum_depends[v.value] then
1550 for i, dep in ipairs(vs.enum_depends[v.value]) do
1551 table.insert(deps, _uvl_strip_remote_dependencies(dep))
1552 end
1553 end
1554 self:value(v.value, v.title or v.value, unpack(deps))
1555 end
1556 end
1557 end
1558 end
1559
1560 function ListValue.value(self, key, val, ...)
1561 if luci.util.contains(self.keylist, key) then
1562 return
1563 end
1564
1565 val = val or key
1566 table.insert(self.keylist, tostring(key))
1567 table.insert(self.vallist, tostring(val))
1568
1569 for i, deps in ipairs({...}) do
1570 table.insert(self.deps, {add = "-"..key, deps=deps})
1571 end
1572 end
1573
1574 function ListValue.validate(self, val)
1575 if luci.util.contains(self.keylist, val) then
1576 return val
1577 else
1578 return nil
1579 end
1580 end
1581
1582
1583
1584 --[[
1585 MultiValue - Multiple delimited values
1586 widget: The widget that will be used (select, checkbox)
1587 delimiter: The delimiter that will separate the values (default: " ")
1588 ]]--
1589 MultiValue = class(AbstractValue)
1590
1591 function MultiValue.__init__(self, ...)
1592 AbstractValue.__init__(self, ...)
1593 self.template = "cbi/mvalue"
1594
1595 self.keylist = {}
1596 self.vallist = {}
1597
1598 self.widget = "checkbox"
1599 self.delimiter = " "
1600 end
1601
1602 function MultiValue.render(self, ...)
1603 if self.widget == "select" and not self.size then
1604 self.size = #self.vallist
1605 end
1606
1607 AbstractValue.render(self, ...)
1608 end
1609
1610 function MultiValue.value(self, key, val)
1611 if luci.util.contains(self.keylist, key) then
1612 return
1613 end
1614
1615 val = val or key
1616 table.insert(self.keylist, tostring(key))
1617 table.insert(self.vallist, tostring(val))
1618 end
1619
1620 function MultiValue.valuelist(self, section)
1621 local val = self:cfgvalue(section)
1622
1623 if not(type(val) == "string") then
1624 return {}
1625 end
1626
1627 return luci.util.split(val, self.delimiter)
1628 end
1629
1630 function MultiValue.validate(self, val)
1631 val = (type(val) == "table") and val or {val}
1632
1633 local result
1634
1635 for i, value in ipairs(val) do
1636 if luci.util.contains(self.keylist, value) then
1637 result = result and (result .. self.delimiter .. value) or value
1638 end
1639 end
1640
1641 return result
1642 end
1643
1644
1645 StaticList = class(MultiValue)
1646
1647 function StaticList.__init__(self, ...)
1648 MultiValue.__init__(self, ...)
1649 self.cast = "table"
1650 self.valuelist = self.cfgvalue
1651
1652 if not self.override_scheme
1653 and self.map:get_scheme(self.section.sectiontype, self.option) then
1654 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1655 if self.value and vs.values and not self.override_values then
1656 for k, v in pairs(vs.values) do
1657 self:value(k, v)
1658 end
1659 end
1660 end
1661 end
1662
1663 function StaticList.validate(self, value)
1664 value = (type(value) == "table") and value or {value}
1665
1666 local valid = {}
1667 for i, v in ipairs(value) do
1668 if luci.util.contains(self.keylist, v) then
1669 table.insert(valid, v)
1670 end
1671 end
1672 return valid
1673 end
1674
1675
1676 DynamicList = class(AbstractValue)
1677
1678 function DynamicList.__init__(self, ...)
1679 AbstractValue.__init__(self, ...)
1680 self.template = "cbi/dynlist"
1681 self.cast = "table"
1682 self.keylist = {}
1683 self.vallist = {}
1684 end
1685
1686 function DynamicList.value(self, key, val)
1687 val = val or key
1688 table.insert(self.keylist, tostring(key))
1689 table.insert(self.vallist, tostring(val))
1690 end
1691
1692 function DynamicList.write(self, ...)
1693 self.map.proceed = true
1694 return AbstractValue.write(self, ...)
1695 end
1696
1697 function DynamicList.formvalue(self, section)
1698 local value = AbstractValue.formvalue(self, section)
1699 value = (type(value) == "table") and value or {value}
1700
1701 local valid = {}
1702 for i, v in ipairs(value) do
1703 if v and #v > 0
1704 and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i)
1705 and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i..".x") then
1706 table.insert(valid, v)
1707 end
1708 end
1709
1710 return valid
1711 end
1712
1713
1714 --[[
1715 TextValue - A multi-line value
1716 rows: Rows
1717 ]]--
1718 TextValue = class(AbstractValue)
1719
1720 function TextValue.__init__(self, ...)
1721 AbstractValue.__init__(self, ...)
1722 self.template = "cbi/tvalue"
1723 end
1724
1725 --[[
1726 Button
1727 ]]--
1728 Button = class(AbstractValue)
1729
1730 function Button.__init__(self, ...)
1731 AbstractValue.__init__(self, ...)
1732 self.template = "cbi/button"
1733 self.inputstyle = nil
1734 self.rmempty = true
1735 end
1736
1737
1738 FileUpload = class(AbstractValue)
1739
1740 function FileUpload.__init__(self, ...)
1741 AbstractValue.__init__(self, ...)
1742 self.template = "cbi/upload"
1743 if not self.map.upload_fields then
1744 self.map.upload_fields = { self }
1745 else
1746 self.map.upload_fields[#self.map.upload_fields+1] = self
1747 end
1748 end
1749
1750 function FileUpload.formcreated(self, section)
1751 return AbstractValue.formcreated(self, section) or
1752 self.map:formvalue("cbi.rlf."..section.."."..self.option) or
1753 self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1754 end
1755
1756 function FileUpload.cfgvalue(self, section)
1757 local val = AbstractValue.cfgvalue(self, section)
1758 if val and fs.access(val) then
1759 return val
1760 end
1761 return nil
1762 end
1763
1764 function FileUpload.formvalue(self, section)
1765 local val = AbstractValue.formvalue(self, section)
1766 if val then
1767 if not self.map:formvalue("cbi.rlf."..section.."."..self.option) and
1768 not self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1769 then
1770 return val
1771 end
1772 fs.unlink(val)
1773 self.value = nil
1774 end
1775 return nil
1776 end
1777
1778 function FileUpload.remove(self, section)
1779 local val = AbstractValue.formvalue(self, section)
1780 if val and fs.access(val) then fs.unlink(val) end
1781 return AbstractValue.remove(self, section)
1782 end
1783
1784
1785 FileBrowser = class(AbstractValue)
1786
1787 function FileBrowser.__init__(self, ...)
1788 AbstractValue.__init__(self, ...)
1789 self.template = "cbi/browser"
1790 end
Lua Configuration Interface (mirror)