local class = luci.util.class
local instanceof = luci.util.instanceof
+FORM_NODATA = 0
+FORM_VALID = 1
+FORM_INVALID = -1
+
+CREATE_PREFIX = "cbi.cts."
+REMOVE_PREFIX = "cbi.rts."
-- Loads a CBI map from given file, creating an environment and returns it
-function load(cbimap)
+function load(cbimap, ...)
require("luci.fs")
require("luci.i18n")
require("luci.config")
- require("luci.sys")
+ require("luci.util")
- local cbidir = luci.sys.libpath() .. "/model/cbi/"
+ local cbidir = luci.util.libpath() .. "/model/cbi/"
local func, err = loadfile(cbidir..cbimap..".lua")
if not func then
luci.util.updfenv(func, luci.cbi)
luci.util.extfenv(func, "translate", luci.i18n.translate)
luci.util.extfenv(func, "translatef", luci.i18n.translatef)
+ luci.util.extfenv(func, "arg", {...})
- local map = func()
+ local maps = {func()}
- if not instanceof(map, Map) then
- error("CBI map returns no valid map object!")
- return nil
+ for i, map in ipairs(maps) do
+ if not instanceof(map, Node) then
+ error("CBI map returns no valid map object!")
+ return nil
+ end
end
- return map
+ return maps
end
-- Node pseudo abstract class
-- i18n loaded?
if type(luci.i18n) == "table" then
- local key = config:gsub("[^%w]+", "")
+ local key = config and config:gsub("[^%w]+", "") or ""
if section then key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
- if option then key = key .. "_" .. option:lower():gsub("[^%w]+", "") end
+ if option then key = key .. "_" .. tostring(option):lower():gsub("[^%w]+", "") end
self.title = title or luci.i18n.translate( key, option or section or config )
self.description = description or luci.i18n.translate( key .. "_desc", "" )
self.template = template
end
+function Template.render(self)
+ luci.template.render(self.template, {self=self})
+end
+
--[[
Map - A map describing a configuration file
Node._i18n(self, config, nil, nil, ...)
self.config = config
+ self.parsechain = {self.config}
self.template = "cbi/map"
- if not uci.load(self.config) then
+ if not uci.load_config(self.config) then
error("Unable to read UCI data: " .. self.config)
end
end
+function Map.render(self, ...)
+ if self.stateful then
+ uci.load_state(self.config)
+ else
+ uci.load_config(self.config)
+ end
+ Node.render(self, ...)
+end
+
+
+-- Chain foreign config
+function Map.chain(self, config)
+ table.insert(self.parsechain, config)
+end
+
-- Use optimized UCI writing
function Map.parse(self, ...)
+ if self.stateful then
+ uci.load_state(self.config)
+ else
+ uci.load_config(self.config)
+ end
+
Node.parse(self, ...)
- uci.save(self.config)
- uci.unload(self.config)
+
+ for i, config in ipairs(self.parsechain) do
+ uci.save_config(config)
+ end
+ if luci.http.formvalue("cbi.apply") then
+ for i, config in ipairs(self.parsechain) do
+ uci.commit(config)
+ if luci.config.uci_oncommit and luci.config.uci_oncommit[config] then
+ luci.util.exec(luci.config.uci_oncommit[config])
+ end
+
+ -- Refresh data because commit changes section names
+ uci.load_config(config)
+ end
+
+ -- Reparse sections
+ Node.parse(self, ...)
+
+ end
+ for i, config in ipairs(self.parsechain) do
+ uci.unload(config)
+ end
end
-- Creates a child section
--[[
+Page - A simple node
+]]--
+
+Page = class(Node)
+Page.__init__ = Node.__init__
+Page.parse = function() end
+
+
+--[[
+SimpleForm - A Simple non-UCI form
+]]--
+SimpleForm = class(Node)
+
+function SimpleForm.__init__(self, config, title, description, data)
+ Node.__init__(self, title, description)
+ self.config = config
+ self.data = data or {}
+ self.template = "cbi/simpleform"
+ self.dorender = true
+end
+
+function SimpleForm.parse(self, ...)
+ if luci.http.formvalue("cbi.submit") then
+ Node.parse(self, 1, ...)
+ end
+
+ local valid = true
+ for k, j in ipairs(self.children) do
+ for i, v in ipairs(j.children) do
+ valid = valid
+ and (not v.tag_missing or not v.tag_missing[1])
+ and (not v.tag_invalid or not v.tag_invalid[1])
+ end
+ end
+
+ local state =
+ not luci.http.formvalue("cbi.submit") and 0
+ or valid and 1
+ or -1
+
+ self.dorender = not self.handle or self:handle(state, self.data) ~= false
+end
+
+function SimpleForm.render(self, ...)
+ if self.dorender then
+ Node.render(self, ...)
+ end
+end
+
+function SimpleForm.section(self, class, ...)
+ if instanceof(class, AbstractSection) then
+ local obj = class(self, ...)
+ self:append(obj)
+ return obj
+ else
+ error("class must be a descendent of AbstractSection")
+ end
+end
+
+-- Creates a child field
+function SimpleForm.field(self, class, ...)
+ local section
+ for k, v in ipairs(self.children) do
+ if instanceof(v, SimpleSection) then
+ section = v
+ break
+ end
+ end
+ if not section then
+ section = self:section(SimpleSection)
+ end
+
+ if instanceof(class, AbstractValue) then
+ local obj = class(self, ...)
+ obj.track_missing = true
+ section:append(obj)
+ return obj
+ else
+ error("class must be a descendent of AbstractValue")
+ end
+end
+
+function SimpleForm.set(self, section, option, value)
+ self.data[option] = value
+end
+
+
+function SimpleForm.del(self, section, option)
+ self.data[option] = nil
+end
+
+
+function SimpleForm.get(self, section, option)
+ return self.data[option]
+end
+
+
+
+--[[
AbstractSection
]]--
AbstractSection = class(Node)
self.map = map
self.config = map.config
self.optionals = {}
+ self.defaults = {}
self.optional = true
self.addremove = false
-- Creates the section
function AbstractSection.create(self, section)
- return self.map:set(section, nil, self.sectiontype)
+ local stat
+
+ if section then
+ stat = self.map:set(section, nil, self.sectiontype)
+ else
+ section = self.map:add(self.sectiontype)
+ stat = section
+ end
+
+ if stat then
+ for k,v in pairs(self.children) do
+ if v.default then
+ self.map:set(section, v.option, v.default)
+ end
+ end
+
+ for k,v in pairs(self.defaults) do
+ self.map:set(section, k, v)
+ end
+ end
+
+ return stat
+end
+
+
+SimpleSection = class(AbstractSection)
+
+function SimpleSection.__init__(self, form, ...)
+ AbstractSection.__init__(self, form, nil, ...)
+ self.template = "cbi/nullsection"
+end
+
+
+Table = class(AbstractSection)
+
+function Table.__init__(self, form, data, ...)
+ local datasource = {}
+ datasource.config = "table"
+ self.data = data
+
+ function datasource.get(self, section, option)
+ return data[section] and data[section][option]
+ end
+
+ function datasource.del(...)
+ return true
+ end
+
+ AbstractSection.__init__(self, datasource, "table", ...)
+ self.template = "cbi/tblsection"
+ self.rowcolors = true
+ self.anonymous = true
+end
+
+function Table.parse(self)
+ for i, k in ipairs(self:cfgsections()) do
+ if luci.http.formvalue("cbi.submit") then
+ Node.parse(self, k)
+ end
+ end
+end
+
+function Table.cfgsections(self)
+ local sections = {}
+
+ for i, v in luci.util.kspairs(self.data) do
+ table.insert(sections, i)
+ end
+
+ return sections
end
function NamedSection.__init__(self, map, section, type, ...)
AbstractSection.__init__(self, map, type, ...)
Node._i18n(self, map.config, section, nil, ...)
-
+
self.template = "cbi/nsection"
self.section = section
self.addremove = false
return
end
else -- Create and apply default values
- if luci.http.formvalue("cbi.cns."..path) and self:create(s) then
- for k,v in pairs(self.children) do
- v:write(s, v.default)
- end
+ if luci.http.formvalue("cbi.cns."..path) then
+ self:create(s)
+ return
end
end
end
self.template = "cbi/tsection"
self.deps = {}
- self.excludes = {}
self.anonymous = false
end
function (section)
if self:checkscope(section[".name"]) then
table.insert(sections, section[".name"])
- end
+ end
end)
return sections
end
--- Creates a new section of this type with the given name (or anonymous)
-function TypedSection.create(self, name)
- if name then
- self.map:set(name, nil, self.sectiontype)
- else
- name = self.map:add(self.sectiontype)
- end
-
- for k,v in pairs(self.children) do
- if v.default then
- self.map:set(name, v.option, v.default)
- end
- end
-end
-
-- Limits scope to sections that have certain option => value pairs
function TypedSection.depends(self, option, value)
table.insert(self.deps, {option=option, value=value})
end
--- Excludes several sections by name
-function TypedSection.exclude(self, field)
- self.excludes[field] = true
-end
-
function TypedSection.parse(self)
if self.addremove then
-- Create
- local crval = "cbi.cts." .. self.config .. "." .. self.sectiontype
+ local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
local name = luci.http.formvalue(crval)
if self.anonymous then
if name then
end
-- Remove
- crval = "cbi.rts." .. self.config
+ crval = REMOVE_PREFIX .. self.config
name = luci.http.formvaluetable(crval)
for k,v in pairs(name) do
if self:cfgvalue(k) and self:checkscope(k) then
-- Verifies scope of sections
function TypedSection.checkscope(self, section)
-- Check if we are not excluded
- if self.excludes[section] then
+ if self.filter and not self:filter(section) then
return nil
end
self.map = map
self.config = map.config
self.tag_invalid = {}
+ self.tag_missing = {}
+ self.tag_error = {}
self.deps = {}
- self.rmempty = false
- self.default = nil
- self.size = nil
- self.optional = false
+ self.track_missing = false
+ self.rmempty = false
+ self.default = nil
+ self.size = nil
+ self.optional = false
end
-- Add a dependencie to another section field
function AbstractValue.depends(self, field, value)
- table.insert(self.deps, {field=field, value=value})
+ local deps
+ if type(field) == "string" then
+ deps = {}
+ deps[field] = value
+ else
+ deps = field
+ end
+
+ table.insert(self.deps, {deps=deps, add=""})
+end
+
+-- Generates the unique CBID
+function AbstractValue.cbid(self, section)
+ return "cbid."..self.map.config.."."..section.."."..self.option
end
-- Return whether this object should be created
-- Returns the formvalue for this object
function AbstractValue.formvalue(self, section)
- local key = "cbid."..self.map.config.."."..section.."."..self.option
- return luci.http.formvalue(key)
+ return luci.http.formvalue(self:cbid(section))
+end
+
+function AbstractValue.additional(self, value)
+ self.optional = value
+end
+
+function AbstractValue.mandatory(self, value)
+ self.rmempty = not value
end
function AbstractValue.parse(self, section)
local fvalue = self:formvalue(section)
+ local cvalue = self:cfgvalue(section)
if fvalue and fvalue ~= "" then -- If we have a form value, write it to UCI
- fvalue = self:validate(fvalue)
+ fvalue = self:transform(self:validate(fvalue, section))
if not fvalue then
self.tag_invalid[section] = true
end
- if fvalue and not (fvalue == self:cfgvalue(section)) then
+ if fvalue and not (fvalue == cvalue) then
self:write(section, fvalue)
end
else -- Unset the UCI or error
if self.rmempty or self.optional then
self:remove(section)
+ elseif self.track_missing and (not fvalue or fvalue ~= cvalue) then
+ self.tag_missing[section] = true
end
end
end
if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
scope = scope or {}
scope.section = s
-
+ scope.cbid = self:cbid(s)
+
+ scope.ifattr = function(cond,key,val)
+ if cond then
+ return string.format(
+ ' %s="%s"', tostring(key),
+ luci.util.pcdata(tostring( val
+ or scope[key]
+ or (type(self[key]) ~= "function" and self[key])
+ or "" ))
+ )
+ else
+ return ''
+ end
+ end
+
+ scope.attr = function(...)
+ return scope.ifattr( true, ... )
+ end
+
Node.render(self, scope)
end
end
return value
end
+AbstractValue.transform = AbstractValue.validate
+
+
-- Write to UCI
function AbstractValue.write(self, section, value)
return self.map:set(section, self.option, value)
function Value.__init__(self, ...)
AbstractValue.__init__(self, ...)
self.template = "cbi/value"
-
- self.maxlength = nil
+ self.keylist = {}
+ self.vallist = {}
end
--- This validation is a bit more complex
-function Value.validate(self, val)
- if self.maxlength and tostring(val):len() > self.maxlength then
- val = nil
- end
-
- return val
+function Value.value(self, key, val)
+ val = val or key
+ table.insert(self.keylist, tostring(key))
+ table.insert(self.vallist, tostring(val))
end
end
-function DummyValue.render(self, s)
- luci.template.render(self.template, {self=self, section=s})
-end
-
--[[
Flag - A flag being enabled or disabled
self.widget = "select"
end
-function ListValue.value(self, key, val)
+function ListValue.value(self, key, val, ...)
val = val or key
table.insert(self.keylist, tostring(key))
table.insert(self.vallist, tostring(val))
+
+ for i, deps in ipairs({...}) do
+ table.insert(self.deps, {add = "-"..key, deps=deps})
+ end
end
function ListValue.validate(self, val)
end
function MultiValue.validate(self, val)
- val = (type(val) == "table") and val or {val}
+ val = (type(val) == "table") and val or {val}
local result
return result
end
+
+--[[
+TextValue - A multi-line value
+ rows: Rows
+]]--
+TextValue = class(AbstractValue)
+
+function TextValue.__init__(self, ...)
+ AbstractValue.__init__(self, ...)
+ self.template = "cbi/tvalue"
+end
+
+--[[
+Button
+]]--
+Button = class(AbstractValue)
+
+function Button.__init__(self, ...)
+ AbstractValue.__init__(self, ...)
+ self.template = "cbi/button"
+ self.inputstyle = nil
+ self.rmempty = true
+end
\ No newline at end of file
projects / project / luci.git / blobdiff