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 require("luci.util")
  31 require("luci.http")
  32 require("luci.uvl")
  33
  34 local uci        = require("luci.model.uci")
  35 local class      = luci.util.class
  36 local instanceof = luci.util.instanceof
  37
  38 FORM_NODATA  =  0
  39 FORM_VALID   =  1
  40 FORM_INVALID = -1
  41
  42 AUTO = true
  43
  44 CREATE_PREFIX = "cbi.cts."
  45 REMOVE_PREFIX = "cbi.rts."
  46
  47 -- Loads a CBI map from given file, creating an environment and returns it
  48 function load(cbimap, ...)
  49         require("luci.fs")
  50         require("luci.i18n")
  51         require("luci.config")
  52         require("luci.util")
  53
  54         local cbidir = luci.util.libpath() .. "/model/cbi/"
  55         local func, err = loadfile(cbimap) or loadfile(cbidir..cbimap..".lua")
  56         assert(func, err)
  57
  58         luci.i18n.loadc("cbi")
  59
  60         luci.util.resfenv(func)
  61         luci.util.updfenv(func, luci.cbi)
  62         luci.util.extfenv(func, "translate", luci.i18n.translate)
  63         luci.util.extfenv(func, "translatef", luci.i18n.translatef)
  64         luci.util.extfenv(func, "arg", {...})
  65
  66         local maps = {func()}
  67
  68         for i, map in ipairs(maps) do
  69                 if not instanceof(map, Node) then
  70                         error("CBI map returns no valid map object!")
  71                         return nil
  72                 end
  73         end
  74
  75         return maps
  76 end
  77
  78 local function _uvl_validate_section(node, name)
  79         local co = node.map:get()
  80
  81         luci.uvl.STRICT_UNKNOWN_OPTIONS = false
  82         luci.uvl.STRICT_UNKNOWN_SECTIONS = false
  83
  84         local stat, err = node.map.validator:validate_section(node.config, name, co)
  85         if err then
  86                 node.map.save = false
  87                 if err:is(luci.uvl.errors.ERR_DEPENDENCY) then
  88                         node.tag_deperror[name] = true
  89                 else
  90                         node.tag_invalid[name] = true
  91                 end
  92                 for i, v in ipairs(err.childs) do
  93                         if v.option and node.fields[v.option] then
  94                                 if v:is(luci.uvl.errors.ERR_DEPENDENCY) then
  95                                         node.fields[v.option].tag_reqerror[name] = true
  96                                 elseif v:is(luci.uvl.errors.ERR_OPT_REQUIRED) then
  97                                         node.fields[v.option].tag_missing[name] = true
  98                                         node.tag_deperror[name] = true
  99                                 elseif v:is(luci.uvl.errors.ERR_OPTION) then
 100                                         node.fields[v.option].tag_invalid[name] = true
 101                                 end
 102                         end
 103                 end
 104         end
 105
 106 end
 107
 108 local function _uvl_strip_remote_dependencies(deps)
 109         local clean = {}
 110
 111         for k, v in pairs(deps) do
 112                 k = k:gsub("%$config%.%$section%.", "")
 113                 if k:match("^[%w_]+$") and type(v) == "string" then
 114                         clean[k] = v
 115                 end
 116         end
 117
 118         return clean
 119 end
 120
 121
 122 -- Node pseudo abstract class
 123 Node = class()
 124
 125 function Node.__init__(self, title, description)
 126         self.children = {}
 127         self.title = title or ""
 128         self.description = description or ""
 129         self.template = "cbi/node"
 130 end
 131
 132 -- i18n helper
 133 function Node._i18n(self, config, section, option, title, description)
 134
 135         -- i18n loaded?
 136         if type(luci.i18n) == "table" then
 137
 138                 local key = config and config:gsub("[^%w]+", "") or ""
 139
 140                 if section then key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
 141                 if option  then key = key .. "_" .. tostring(option):lower():gsub("[^%w]+", "")  end
 142
 143                 self.title = title or luci.i18n.translate( key, option or section or config )
 144                 self.description = description or luci.i18n.translate( key .. "_desc", "" )
 145         end
 146 end
 147
 148 -- Append child nodes
 149 function Node.append(self, obj)
 150         table.insert(self.children, obj)
 151 end
 152
 153 -- Parse this node and its children
 154 function Node.parse(self, ...)
 155         for k, child in ipairs(self.children) do
 156                 child:parse(...)
 157         end
 158 end
 159
 160 -- Render this node
 161 function Node.render(self, scope)
 162         scope = scope or {}
 163         scope.self = self
 164
 165         luci.template.render(self.template, scope)
 166 end
 167
 168 -- Render the children
 169 function Node.render_children(self, ...)
 170         for k, node in ipairs(self.children) do
 171                 node:render(...)
 172         end
 173 end
 174
 175
 176 --[[
 177 A simple template element
 178 ]]--
 179 Template = class(Node)
 180
 181 function Template.__init__(self, template)
 182         Node.__init__(self)
 183         self.template = template
 184 end
 185
 186 function Template.render(self)
 187         luci.template.render(self.template, {self=self})
 188 end
 189
 190
 191 --[[
 192 Map - A map describing a configuration file
 193 ]]--
 194 Map = class(Node)
 195
 196 function Map.__init__(self, config, ...)
 197         Node.__init__(self, ...)
 198         Node._i18n(self, config, nil, nil, ...)
 199
 200         self.config = config
 201         self.parsechain = {self.config}
 202         self.template = "cbi/map"
 203         self.uci = uci.cursor()
 204         self.save = true
 205         if not self.uci:load(self.config) then
 206                 error("Unable to read UCI data: " .. self.config)
 207         end
 208
 209         self.validator = luci.uvl.UVL()
 210         self.scheme = self.validator:get_scheme(self.config)
 211
 212 end
 213
 214 function Map.get_scheme(self, sectiontype, option)
 215         if not option then
 216                 return self.scheme and self.scheme.sections[sectiontype]
 217         else
 218                 return self.scheme and self.scheme.variables[sectiontype]
 219                  and self.scheme.variables[sectiontype][option]
 220         end
 221 end
 222
 223
 224 -- Chain foreign config
 225 function Map.chain(self, config)
 226         table.insert(self.parsechain, config)
 227 end
 228
 229 -- Use optimized UCI writing
 230 function Map.parse(self, ...)
 231         Node.parse(self, ...)
 232
 233         if self.save then
 234                 for i, config in ipairs(self.parsechain) do
 235                         self.uci:save(config)
 236                 end
 237                 if luci.http.formvalue("cbi.apply") then
 238                         for i, config in ipairs(self.parsechain) do
 239                                 self.uci:commit(config)
 240                                 self.uci:apply(config)
 241
 242                                 -- Refresh data because commit changes section names
 243                                 self.uci:load(config)
 244                         end
 245
 246                         -- Reparse sections
 247                         Node.parse(self, ...)
 248
 249                 end
 250                 for i, config in ipairs(self.parsechain) do
 251                         self.uci:unload(config)
 252                 end
 253         end
 254 end
 255
 256 -- Creates a child section
 257 function Map.section(self, class, ...)
 258         if instanceof(class, AbstractSection) then
 259                 local obj  = class(self, ...)
 260                 self:append(obj)
 261                 return obj
 262         else
 263                 error("class must be a descendent of AbstractSection")
 264         end
 265 end
 266
 267 -- UCI add
 268 function Map.add(self, sectiontype)
 269         return self.uci:add(self.config, sectiontype)
 270 end
 271
 272 -- UCI set
 273 function Map.set(self, section, option, value)
 274         if option then
 275                 return self.uci:set(self.config, section, option, value)
 276         else
 277                 return self.uci:set(self.config, section, value)
 278         end
 279 end
 280
 281 -- UCI del
 282 function Map.del(self, section, option)
 283         if option then
 284                 return self.uci:delete(self.config, section, option)
 285         else
 286                 return self.uci:delete(self.config, section)
 287         end
 288 end
 289
 290 -- UCI get
 291 function Map.get(self, section, option)
 292         if not section then
 293                 return self.uci:get_all(self.config)
 294         elseif option then
 295                 return self.uci:get(self.config, section, option)
 296         else
 297                 return self.uci:get_all(self.config, section)
 298         end
 299 end
 300
 301
 302 --[[
 303 Page - A simple node
 304 ]]--
 305
 306 Page = class(Node)
 307 Page.__init__ = Node.__init__
 308 Page.parse    = function() end
 309
 310
 311 --[[
 312 SimpleForm - A Simple non-UCI form
 313 ]]--
 314 SimpleForm = class(Node)
 315
 316 function SimpleForm.__init__(self, config, title, description, data)
 317         Node.__init__(self, title, description)
 318         self.config = config
 319         self.data = data or {}
 320         self.template = "cbi/simpleform"
 321         self.dorender = true
 322 end
 323
 324 function SimpleForm.parse(self, ...)
 325         if luci.http.formvalue("cbi.submit") then
 326                 Node.parse(self, 1, ...)
 327         end
 328
 329         local valid = true
 330         for k, j in ipairs(self.children) do
 331                 for i, v in ipairs(j.children) do
 332                         valid = valid
 333                          and (not v.tag_missing or not v.tag_missing[1])
 334                          and (not v.tag_invalid or not v.tag_invalid[1])
 335                 end
 336         end
 337
 338         local state =
 339                 not luci.http.formvalue("cbi.submit") and 0
 340                 or valid and 1
 341                 or -1
 342
 343         self.dorender = not self.handle or self:handle(state, self.data) ~= false
 344 end
 345
 346 function SimpleForm.render(self, ...)
 347         if self.dorender then
 348                 Node.render(self, ...)
 349         end
 350 end
 351
 352 function SimpleForm.section(self, class, ...)
 353         if instanceof(class, AbstractSection) then
 354                 local obj  = class(self, ...)
 355                 self:append(obj)
 356                 return obj
 357         else
 358                 error("class must be a descendent of AbstractSection")
 359         end
 360 end
 361
 362 -- Creates a child field
 363 function SimpleForm.field(self, class, ...)
 364         local section
 365         for k, v in ipairs(self.children) do
 366                 if instanceof(v, SimpleSection) then
 367                         section = v
 368                         break
 369                 end
 370         end
 371         if not section then
 372                 section = self:section(SimpleSection)
 373         end
 374
 375         if instanceof(class, AbstractValue) then
 376                 local obj  = class(self, section, ...)
 377                 obj.track_missing = true
 378                 section:append(obj)
 379                 return obj
 380         else
 381                 error("class must be a descendent of AbstractValue")
 382         end
 383 end
 384
 385 function SimpleForm.set(self, section, option, value)
 386         self.data[option] = value
 387 end
 388
 389
 390 function SimpleForm.del(self, section, option)
 391         self.data[option] = nil
 392 end
 393
 394
 395 function SimpleForm.get(self, section, option)
 396         return self.data[option]
 397 end
 398
 399
 400 function SimpleForm.get_scheme()
 401         return nil
 402 end
 403
 404
 405
 406 --[[
 407 AbstractSection
 408 ]]--
 409 AbstractSection = class(Node)
 410
 411 function AbstractSection.__init__(self, map, sectiontype, ...)
 412         Node.__init__(self, ...)
 413         self.sectiontype = sectiontype
 414         self.map = map
 415         self.config = map.config
 416         self.optionals = {}
 417         self.defaults = {}
 418         self.fields = {}
 419         self.tag_error = {}
 420         self.tag_invalid = {}
 421         self.tag_deperror = {}
 422
 423         self.optional = true
 424         self.addremove = false
 425         self.dynamic = false
 426 end
 427
 428 -- Appends a new option
 429 function AbstractSection.option(self, class, option, ...)
 430         -- Autodetect from UVL
 431         if class == true and self.map:get_scheme(self.sectiontype, option) then
 432                 local vs = self.map:get_scheme(self.sectiontype, option)
 433                 if vs.type == "boolean" then
 434                         class = Flag
 435                 elseif vs.type == "list" then
 436                         class = DynamicList
 437                 elseif vs.type == "enum" or vs.type == "reference" then
 438                         class = ListValue
 439                 else
 440                         class = Value
 441                 end
 442         end
 443
 444         if instanceof(class, AbstractValue) then
 445                 local obj  = class(self.map, self, option, ...)
 446
 447                 Node._i18n(obj, self.config, self.section or self.sectiontype, option, ...)
 448
 449                 self:append(obj)
 450                 self.fields[option] = obj
 451                 return obj
 452         elseif class == true then
 453                 error("No valid class was given and autodetection failed.")
 454         else
 455                 error("class must be a descendant of AbstractValue")
 456         end
 457 end
 458
 459 -- Parse optional options
 460 function AbstractSection.parse_optionals(self, section)
 461         if not self.optional then
 462                 return
 463         end
 464
 465         self.optionals[section] = {}
 466
 467         local field = luci.http.formvalue("cbi.opt."..self.config.."."..section)
 468         for k,v in ipairs(self.children) do
 469                 if v.optional and not v:cfgvalue(section) then
 470                         if field == v.option then
 471                                 field = nil
 472                         else
 473                                 table.insert(self.optionals[section], v)
 474                         end
 475                 end
 476         end
 477
 478         if field and #field > 0 and self.dynamic then
 479                 self:add_dynamic(field)
 480         end
 481 end
 482
 483 -- Add a dynamic option
 484 function AbstractSection.add_dynamic(self, field, optional)
 485         local o = self:option(Value, field, field)
 486         o.optional = optional
 487 end
 488
 489 -- Parse all dynamic options
 490 function AbstractSection.parse_dynamic(self, section)
 491         if not self.dynamic then
 492                 return
 493         end
 494
 495         local arr  = luci.util.clone(self:cfgvalue(section))
 496         local form = luci.http.formvaluetable("cbid."..self.config.."."..section)
 497         for k, v in pairs(form) do
 498                 arr[k] = v
 499         end
 500
 501         for key,val in pairs(arr) do
 502                 local create = true
 503
 504                 for i,c in ipairs(self.children) do
 505                         if c.option == key then
 506                                 create = false
 507                         end
 508                 end
 509
 510                 if create and key:sub(1, 1) ~= "." then
 511                         self:add_dynamic(key, true)
 512                 end
 513         end
 514 end
 515
 516 -- Returns the section's UCI table
 517 function AbstractSection.cfgvalue(self, section)
 518         return self.map:get(section)
 519 end
 520
 521 -- Removes the section
 522 function AbstractSection.remove(self, section)
 523         return self.map:del(section)
 524 end
 525
 526 -- Creates the section
 527 function AbstractSection.create(self, section)
 528         local stat
 529
 530         if section then
 531                 stat = self.map:set(section, nil, self.sectiontype)
 532         else
 533                 section = self.map:add(self.sectiontype)
 534                 stat = section
 535         end
 536
 537         if stat then
 538                 for k,v in pairs(self.children) do
 539                         if v.default then
 540                                 self.map:set(section, v.option, v.default)
 541                         end
 542                 end
 543
 544                 for k,v in pairs(self.defaults) do
 545                         self.map:set(section, k, v)
 546                 end
 547         end
 548
 549         return stat
 550 end
 551
 552
 553 SimpleSection = class(AbstractSection)
 554
 555 function SimpleSection.__init__(self, form, ...)
 556         AbstractSection.__init__(self, form, nil, ...)
 557         self.template = "cbi/nullsection"
 558 end
 559
 560
 561 Table = class(AbstractSection)
 562
 563 function Table.__init__(self, form, data, ...)
 564         local datasource = {}
 565         datasource.config = "table"
 566         self.data = data
 567
 568         function datasource.get(self, section, option)
 569                 return data[section] and data[section][option]
 570         end
 571
 572         function datasource.del(...)
 573                 return true
 574         end
 575
 576         function datasource.get_scheme()
 577                 return nil
 578         end
 579
 580         AbstractSection.__init__(self, datasource, "table", ...)
 581         self.template = "cbi/tblsection"
 582         self.rowcolors = true
 583         self.anonymous = true
 584 end
 585
 586 function Table.parse(self)
 587         for i, k in ipairs(self:cfgsections()) do
 588                 if luci.http.formvalue("cbi.submit") then
 589                         Node.parse(self, k)
 590                 end
 591         end
 592 end
 593
 594 function Table.cfgsections(self)
 595         local sections = {}
 596
 597         for i, v in luci.util.kspairs(self.data) do
 598                 table.insert(sections, i)
 599         end
 600
 601         return sections
 602 end
 603
 604
 605
 606 --[[
 607 NamedSection - A fixed configuration section defined by its name
 608 ]]--
 609 NamedSection = class(AbstractSection)
 610
 611 function NamedSection.__init__(self, map, section, stype, ...)
 612         AbstractSection.__init__(self, map, stype, ...)
 613         Node._i18n(self, map.config, section, nil, ...)
 614
 615         -- Defaults
 616         self.addremove = false
 617
 618         -- Use defaults from UVL
 619         if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
 620                 local vs = self.map:get_scheme(self.sectiontype)
 621                 self.addremove = not vs.unique and not vs.required
 622                 self.dynamic   = vs.dynamic
 623                 self.title       = self.title or vs.title
 624                 self.description = self.description or vs.descr
 625         end
 626
 627         self.template = "cbi/nsection"
 628         self.section = section
 629 end
 630
 631 function NamedSection.parse(self)
 632         local s = self.section
 633         local active = self:cfgvalue(s)
 634
 635         if self.addremove then
 636                 local path = self.config.."."..s
 637                 if active then -- Remove the section
 638                         if luci.http.formvalue("cbi.rns."..path) and self:remove(s) then
 639                                 return
 640                         end
 641                 else           -- Create and apply default values
 642                         if luci.http.formvalue("cbi.cns."..path) then
 643                                 self:create(s)
 644                                 return
 645                         end
 646                 end
 647         end
 648
 649         if active then
 650                 AbstractSection.parse_dynamic(self, s)
 651                 if luci.http.formvalue("cbi.submit") then
 652                         Node.parse(self, s)
 653
 654                         if not self.override_scheme and self.map.scheme then
 655                                 _uvl_validate_section(self, s)
 656                         end
 657                 end
 658                 AbstractSection.parse_optionals(self, s)
 659         end
 660 end
 661
 662
 663 --[[
 664 TypedSection - A (set of) configuration section(s) defined by the type
 665         addremove:      Defines whether the user can add/remove sections of this type
 666         anonymous:  Allow creating anonymous sections
 667         validate:       a validation function returning nil if the section is invalid
 668 ]]--
 669 TypedSection = class(AbstractSection)
 670
 671 function TypedSection.__init__(self, map, type, ...)
 672         AbstractSection.__init__(self, map, type, ...)
 673         Node._i18n(self, map.config, type, nil, ...)
 674
 675         self.template  = "cbi/tsection"
 676         self.deps = {}
 677         self.anonymous = false
 678
 679         -- Use defaults from UVL
 680         if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
 681                 local vs = self.map:get_scheme(self.sectiontype)
 682                 self.addremove = not vs.unique and not vs.required
 683                 self.dynamic   = vs.dynamic
 684                 self.anonymous = not vs.named
 685                 self.title       = self.title or vs.title
 686                 self.description = self.description or vs.descr
 687         end
 688 end
 689
 690 -- Return all matching UCI sections for this TypedSection
 691 function TypedSection.cfgsections(self)
 692         local sections = {}
 693         self.map.uci:foreach(self.map.config, self.sectiontype,
 694                 function (section)
 695                         if self:checkscope(section[".name"]) then
 696                                 table.insert(sections, section[".name"])
 697                         end
 698                 end)
 699
 700         return sections
 701 end
 702
 703 -- Limits scope to sections that have certain option => value pairs
 704 function TypedSection.depends(self, option, value)
 705         table.insert(self.deps, {option=option, value=value})
 706 end
 707
 708 function TypedSection.parse(self)
 709         if self.addremove then
 710                 -- Remove
 711                 local crval = REMOVE_PREFIX .. self.config
 712                 local name = luci.http.formvaluetable(crval)
 713                 for k,v in pairs(name) do
 714                         if k:sub(-2) == ".x" then
 715                                 k = k:sub(1, #k - 2)
 716                         end
 717                         if self:cfgvalue(k) and self:checkscope(k) then
 718                                 self:remove(k)
 719                         end
 720                 end
 721         end
 722
 723         local co
 724         for i, k in ipairs(self:cfgsections()) do
 725                 AbstractSection.parse_dynamic(self, k)
 726                 if luci.http.formvalue("cbi.submit") then
 727                         Node.parse(self, k)
 728
 729                         if not self.override_scheme and self.map.scheme then
 730                                 _uvl_validate_section(self, k)
 731                         end
 732                 end
 733                 AbstractSection.parse_optionals(self, k)
 734         end
 735
 736         if self.addremove then
 737                 -- Create
 738                 local created
 739                 local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
 740                 local name  = luci.http.formvalue(crval)
 741                 if self.anonymous then
 742                         if name then
 743                                 created = self:create()
 744                         end
 745                 else
 746                         if name then
 747                                 -- Ignore if it already exists
 748                                 if self:cfgvalue(name) then
 749                                         name = nil;
 750                                 end
 751
 752                                 name = self:checkscope(name)
 753
 754                                 if not name then
 755                                         self.err_invalid = true
 756                                 end
 757
 758                                 if name and #name > 0 then
 759                                         created = self:create(name) and name
 760                                 end
 761                         end
 762                 end
 763
 764                 if created then
 765                         AbstractSection.parse_optionals(self, created)
 766                 end
 767         end
 768 end
 769
 770 -- Verifies scope of sections
 771 function TypedSection.checkscope(self, section)
 772         -- Check if we are not excluded
 773         if self.filter and not self:filter(section) then
 774                 return nil
 775         end
 776
 777         -- Check if at least one dependency is met
 778         if #self.deps > 0 and self:cfgvalue(section) then
 779                 local stat = false
 780
 781                 for k, v in ipairs(self.deps) do
 782                         if self:cfgvalue(section)[v.option] == v.value then
 783                                 stat = true
 784                         end
 785                 end
 786
 787                 if not stat then
 788                         return nil
 789                 end
 790         end
 791
 792         return self:validate(section)
 793 end
 794
 795
 796 -- Dummy validate function
 797 function TypedSection.validate(self, section)
 798         return section
 799 end
 800
 801
 802 --[[
 803 AbstractValue - An abstract Value Type
 804         null:           Value can be empty
 805         valid:          A function returning the value if it is valid otherwise nil
 806         depends:        A table of option => value pairs of which one must be true
 807         default:        The default value
 808         size:           The size of the input fields
 809         rmempty:        Unset value if empty
 810         optional:       This value is optional (see AbstractSection.optionals)
 811 ]]--
 812 AbstractValue = class(Node)
 813
 814 function AbstractValue.__init__(self, map, section, option, ...)
 815         Node.__init__(self, ...)
 816         self.section = section
 817         self.option  = option
 818         self.map     = map
 819         self.config  = map.config
 820         self.tag_invalid = {}
 821         self.tag_missing = {}
 822         self.tag_reqerror = {}
 823         self.tag_error = {}
 824         self.deps = {}
 825         self.cast = "string"
 826
 827         self.track_missing = false
 828         self.rmempty   = false
 829         self.default   = nil
 830         self.size      = nil
 831         self.optional  = false
 832
 833         -- Use defaults from UVL
 834         if not self.override_scheme
 835          and self.map:get_scheme(self.section.sectiontype, self.option) then
 836                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
 837                 self.rmempty     = not vs.required
 838                 self.cast        = (vs.type == "list") and "list" or "string"
 839                 self.title       = self.title or vs.title
 840                 self.description = self.description or vs.descr
 841
 842                 if vs.depends and not self.override_dependencies then
 843                         for i, deps in ipairs(vs.depends) do
 844                                 deps = _uvl_strip_remote_dependencies(deps)
 845                                 if next(deps) then
 846                                         self:depends(deps)
 847                                 end
 848                         end
 849                 end
 850         end
 851 end
 852
 853 -- Add a dependencie to another section field
 854 function AbstractValue.depends(self, field, value)
 855         local deps
 856         if type(field) == "string" then
 857                 deps = {}
 858                 deps[field] = value
 859         else
 860                 deps = field
 861         end
 862
 863         table.insert(self.deps, {deps=deps, add=""})
 864 end
 865
 866 -- Generates the unique CBID
 867 function AbstractValue.cbid(self, section)
 868         return "cbid."..self.map.config.."."..section.."."..self.option
 869 end
 870
 871 -- Return whether this object should be created
 872 function AbstractValue.formcreated(self, section)
 873         local key = "cbi.opt."..self.config.."."..section
 874         return (luci.http.formvalue(key) == self.option)
 875 end
 876
 877 -- Returns the formvalue for this object
 878 function AbstractValue.formvalue(self, section)
 879         return luci.http.formvalue(self:cbid(section))
 880 end
 881
 882 function AbstractValue.additional(self, value)
 883         self.optional = value
 884 end
 885
 886 function AbstractValue.mandatory(self, value)
 887         self.rmempty = not value
 888 end
 889
 890 function AbstractValue.parse(self, section)
 891         local fvalue = self:formvalue(section)
 892         local cvalue = self:cfgvalue(section)
 893
 894         if fvalue and fvalue ~= "" then -- If we have a form value, write it to UCI
 895                 fvalue = self:transform(self:validate(fvalue, section))
 896                 if not fvalue then
 897                         self.tag_invalid[section] = true
 898                 end
 899                 if fvalue and not (fvalue == cvalue) then
 900                         self:write(section, fvalue)
 901                 end
 902         else                                                    -- Unset the UCI or error
 903                 if self.rmempty or self.optional then
 904                         self:remove(section)
 905                 elseif self.track_missing and (not fvalue or fvalue ~= cvalue) then
 906                         self.tag_missing[section] = true
 907                 end
 908         end
 909 end
 910
 911 -- Render if this value exists or if it is mandatory
 912 function AbstractValue.render(self, s, scope)
 913         if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
 914                 scope = scope or {}
 915                 scope.section   = s
 916                 scope.cbid      = self:cbid(s)
 917                 scope.striptags = luci.util.striptags
 918
 919                 scope.ifattr = function(cond,key,val)
 920                         if cond then
 921                                 return string.format(
 922                                         ' %s="%s"', tostring(key),
 923                                         luci.util.pcdata(tostring( val
 924                                          or scope[key]
 925                                          or (type(self[key]) ~= "function" and self[key])
 926                                          or "" ))
 927                                 )
 928                         else
 929                                 return ''
 930                         end
 931                 end
 932
 933                 scope.attr = function(...)
 934                         return scope.ifattr( true, ... )
 935                 end
 936
 937                 Node.render(self, scope)
 938         end
 939 end
 940
 941 -- Return the UCI value of this object
 942 function AbstractValue.cfgvalue(self, section)
 943         local value = self.map:get(section, self.option)
 944         if not self.cast or self.cast == type(value) then
 945                 return value
 946         elseif self.cast == "string" then
 947                 if type(value) == "table" then
 948                         return value[1]
 949                 end
 950         elseif self.cast == "table" then
 951                 return {value}
 952         end
 953 end
 954
 955 -- Validate the form value
 956 function AbstractValue.validate(self, value)
 957         return value
 958 end
 959
 960 AbstractValue.transform = AbstractValue.validate
 961
 962
 963 -- Write to UCI
 964 function AbstractValue.write(self, section, value)
 965         return self.map:set(section, self.option, value)
 966 end
 967
 968 -- Remove from UCI
 969 function AbstractValue.remove(self, section)
 970         return self.map:del(section, self.option)
 971 end
 972
 973
 974
 975
 976 --[[
 977 Value - A one-line value
 978         maxlength:      The maximum length
 979 ]]--
 980 Value = class(AbstractValue)
 981
 982 function Value.__init__(self, ...)
 983         AbstractValue.__init__(self, ...)
 984         self.template  = "cbi/value"
 985         self.keylist = {}
 986         self.vallist = {}
 987 end
 988
 989 function Value.value(self, key, val)
 990         val = val or key
 991         table.insert(self.keylist, tostring(key))
 992         table.insert(self.vallist, tostring(val))
 993 end
 994
 995
 996 -- DummyValue - This does nothing except being there
 997 DummyValue = class(AbstractValue)
 998
 999 function DummyValue.__init__(self, ...)
1000         AbstractValue.__init__(self, ...)
1001         self.template = "cbi/dvalue"
1002         self.value = nil
1003 end
1004
1005 function DummyValue.parse(self)
1006
1007 end
1008
1009
1010 --[[
1011 Flag - A flag being enabled or disabled
1012 ]]--
1013 Flag = class(AbstractValue)
1014
1015 function Flag.__init__(self, ...)
1016         AbstractValue.__init__(self, ...)
1017         self.template  = "cbi/fvalue"
1018
1019         self.enabled = "1"
1020         self.disabled = "0"
1021 end
1022
1023 -- A flag can only have two states: set or unset
1024 function Flag.parse(self, section)
1025         local fvalue = self:formvalue(section)
1026
1027         if fvalue then
1028                 fvalue = self.enabled
1029         else
1030                 fvalue = self.disabled
1031         end
1032
1033         if fvalue == self.enabled or (not self.optional and not self.rmempty) then
1034                 if not(fvalue == self:cfgvalue(section)) then
1035                         self:write(section, fvalue)
1036                 end
1037         else
1038                 self:remove(section)
1039         end
1040 end
1041
1042
1043
1044 --[[
1045 ListValue - A one-line value predefined in a list
1046         widget: The widget that will be used (select, radio)
1047 ]]--
1048 ListValue = class(AbstractValue)
1049
1050 function ListValue.__init__(self, ...)
1051         AbstractValue.__init__(self, ...)
1052         self.template  = "cbi/lvalue"
1053
1054         self.keylist = {}
1055         self.vallist = {}
1056         self.size   = 1
1057         self.widget = "select"
1058
1059         if not self.override_scheme
1060          and self.map:get_scheme(self.section.sectiontype, self.option) then
1061                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1062                 if self.value and vs.values and not self.override_values then
1063                         if self.rmempty or self.optional then
1064                                 self:value("")
1065                         end
1066                         for k, v in pairs(vs.values) do
1067                                 local deps = {}
1068                                 if not self.override_dependencies
1069                                  and vs.enum_depends and vs.enum_depends[k] then
1070                                         for i, dep in ipairs(vs.enum_depends[k]) do
1071                                                 table.insert(deps, _uvl_strip_remote_dependencies(dep))
1072                                         end
1073                                 end
1074                                 self:value(k, v, unpack(deps))
1075                         end
1076                 end
1077         end
1078 end
1079
1080 function ListValue.value(self, key, val, ...)
1081         if luci.util.contains(self.keylist, key) then
1082                 return
1083         end
1084
1085         val = val or key
1086         table.insert(self.keylist, tostring(key))
1087         table.insert(self.vallist, tostring(val))
1088
1089         for i, deps in ipairs({...}) do
1090                 table.insert(self.deps, {add = "-"..key, deps=deps})
1091         end
1092 end
1093
1094 function ListValue.validate(self, val)
1095         if luci.util.contains(self.keylist, val) then
1096                 return val
1097         else
1098                 return nil
1099         end
1100 end
1101
1102
1103
1104 --[[
1105 MultiValue - Multiple delimited values
1106         widget: The widget that will be used (select, checkbox)
1107         delimiter: The delimiter that will separate the values (default: " ")
1108 ]]--
1109 MultiValue = class(AbstractValue)
1110
1111 function MultiValue.__init__(self, ...)
1112         AbstractValue.__init__(self, ...)
1113         self.template = "cbi/mvalue"
1114
1115         self.keylist = {}
1116         self.vallist = {}
1117
1118         self.widget = "checkbox"
1119         self.delimiter = " "
1120 end
1121
1122 function MultiValue.render(self, ...)
1123         if self.widget == "select" and not self.size then
1124                 self.size = #self.vallist
1125         end
1126
1127         AbstractValue.render(self, ...)
1128 end
1129
1130 function MultiValue.value(self, key, val)
1131         if luci.util.contains(self.keylist, key) then
1132                 return
1133         end
1134
1135         val = val or key
1136         table.insert(self.keylist, tostring(key))
1137         table.insert(self.vallist, tostring(val))
1138 end
1139
1140 function MultiValue.valuelist(self, section)
1141         local val = self:cfgvalue(section)
1142
1143         if not(type(val) == "string") then
1144                 return {}
1145         end
1146
1147         return luci.util.split(val, self.delimiter)
1148 end
1149
1150 function MultiValue.validate(self, val)
1151         val = (type(val) == "table") and val or {val}
1152
1153         local result
1154
1155         for i, value in ipairs(val) do
1156                 if luci.util.contains(self.keylist, value) then
1157                         result = result and (result .. self.delimiter .. value) or value
1158                 end
1159         end
1160
1161         return result
1162 end
1163
1164
1165 StaticList = class(MultiValue)
1166
1167 function StaticList.__init__(self, ...)
1168         MultiValue.__init__(self, ...)
1169         self.cast = "table"
1170         self.valuelist = self.cfgvalue
1171
1172         if not self.override_scheme
1173          and self.map:get_scheme(self.section.sectiontype, self.option) then
1174                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1175                 if self.value and vs.values and not self.override_values then
1176                         for k, v in pairs(vs.values) do
1177                                 self:value(k, v)
1178                         end
1179                 end
1180         end
1181 end
1182
1183 function StaticList.validate(self, value)
1184         value = (type(value) == "table") and value or {value}
1185
1186         local valid = {}
1187         for i, v in ipairs(value) do
1188                 if luci.util.contains(self.valuelist, v) then
1189                         table.insert(valid, v)
1190                 end
1191         end
1192         return valid
1193 end
1194
1195
1196 DynamicList = class(AbstractValue)
1197
1198 function DynamicList.__init__(self, ...)
1199         AbstractValue.__init__(self, ...)
1200         self.template  = "cbi/dynlist"
1201         self.cast = "table"
1202         self.keylist = {}
1203         self.vallist = {}
1204 end
1205
1206 function DynamicList.value(self, key, val)
1207         val = val or key
1208         table.insert(self.keylist, tostring(key))
1209         table.insert(self.vallist, tostring(val))
1210 end
1211
1212 function DynamicList.validate(self, value, section)
1213         value = (type(value) == "table") and value or {value}
1214
1215         local valid = {}
1216         for i, v in ipairs(value) do
1217                 if v and #v > 0
1218                  and not luci.http.formvalue("cbi.rle."..section.."."..self.option.."."..i)
1219                  and not luci.http.formvalue("cbi.rle."..section.."."..self.option.."."..i..".x") then
1220                         table.insert(valid, v)
1221                 end
1222         end
1223
1224         return valid
1225 end
1226
1227
1228 --[[
1229 TextValue - A multi-line value
1230         rows:   Rows
1231 ]]--
1232 TextValue = class(AbstractValue)
1233
1234 function TextValue.__init__(self, ...)
1235         AbstractValue.__init__(self, ...)
1236         self.template  = "cbi/tvalue"
1237 end
1238
1239 --[[
1240 Button
1241 ]]--
1242 Button = class(AbstractValue)
1243
1244 function Button.__init__(self, ...)
1245         AbstractValue.__init__(self, ...)
1246         self.template  = "cbi/button"
1247         self.inputstyle = nil
1248         self.rmempty = true
1249 end