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