return table.concat(url, "")
end
+function _ordered_children(node)
+ local name, child, children = nil, nil, {}
+
+ for name, child in pairs(node.nodes) do
+ children[#children+1] = {
+ name = name,
+ node = child,
+ order = child.order or 100
+ }
+ end
+
+ table.sort(children, function(a, b)
+ if a.order == b.order then
+ return a.name < b.name
+ else
+ return a.order < b.order
+ end
+ end)
+
+ return children
+end
+
+local function dependencies_satisfied(node)
+ if type(node.file_depends) == "table" then
+ for _, file in ipairs(node.file_depends) do
+ local ftype = fs.stat(file, "type")
+ if ftype == "dir" then
+ local empty = true
+ for e in (fs.dir(file) or function() end) do
+ empty = false
+ end
+ if empty then
+ return false
+ end
+ elseif ftype == nil then
+ return false
+ end
+ end
+ end
+
+ if type(node.uci_depends) == "table" then
+ for config, expect_sections in pairs(node.uci_depends) do
+ if type(expect_sections) == "table" then
+ for section, expect_options in pairs(expect_sections) do
+ if type(expect_options) == "table" then
+ for option, expect_value in pairs(expect_options) do
+ local val = uci:get(config, section, option)
+ if expect_value == true and val == nil then
+ return false
+ elseif type(expect_value) == "string" then
+ if type(val) == "table" then
+ local found = false
+ for _, subval in ipairs(val) do
+ if subval == expect_value then
+ found = true
+ end
+ end
+ if not found then
+ return false
+ end
+ elseif val ~= expect_value then
+ return false
+ end
+ end
+ end
+ else
+ local val = uci:get(config, section)
+ if expect_options == true and val == nil then
+ return false
+ elseif type(expect_options) == "string" and val ~= expect_options then
+ return false
+ end
+ end
+ end
+ elseif expect_sections == true then
+ if not uci:get_first(config) then
+ return false
+ end
+ end
+ end
+ end
+
+ return true
+end
+
function node_visible(node)
if node then
return not (
+ (not dependencies_satisfied(node)) or
(not node.title or #node.title == 0) or
(not node.target or node.hidden == true) or
(type(node.target) == "table" and node.target.type == "firstchild" and
function node_childs(node)
local rv = { }
if node then
- local k, v
- for k, v in util.spairs(node.nodes,
- function(a, b)
- return (node.nodes[a].order or 100)
- < (node.nodes[b].order or 100)
- end)
- do
- if node_visible(v) then
- rv[#rv+1] = k
+ local _, child
+ for _, child in ipairs(_ordered_children(node)) do
+ if node_visible(child.node) then
+ rv[#rv+1] = child.name
end
end
end
--context._disable_memtrace()
end
-local function require_post_security(target)
+local function require_post_security(target, args)
+ if type(target) == "table" and target.type == "arcombine" and type(target.targets) == "table" then
+ return require_post_security((type(args) == "table" and #args > 0) and target.targets[2] or target.targets[1], args)
+ end
+
if type(target) == "table" then
if type(target.post) == "table" then
local param_name, required_val, request_val
assert(media, "No valid theme found")
end
- local function _ifattr(cond, key, val)
+ local function _ifattr(cond, key, val, noescape)
if cond then
local env = getfenv(3)
local scope = (type(env.self) == "table") and env.self
val = util.serialize_json(val)
end
end
- return string.format(
- ' %s="%s"', tostring(key),
- util.pcdata(tostring( val
- or (type(env[key]) ~= "function" and env[key])
- or (scope and type(scope[key]) ~= "function" and scope[key])
- or "" ))
- )
+
+ val = tostring(val or
+ (type(env[key]) ~= "function" and env[key]) or
+ (scope and type(scope[key]) ~= "function" and scope[key]) or "")
+
+ if noescape ~= true then
+ val = util.pcdata(val)
+ end
+
+ return string.format(' %s="%s"', tostring(key), val)
else
return ''
end
return
end
- if c and require_post_security(c.target) then
+ if c and require_post_security(c.target, args) then
if not test_post_security(c) then
return
end
-- Subdispatchers --
function _find_eligible_node(root, prefix, deep, types, descend)
- local _, cur_name, cur_node
- local childs = { }
-
- for cur_name, cur_node in pairs(root.nodes) do
- childs[#childs+1] = {
- node = cur_node,
- name = cur_name,
- order = cur_node.order or 100
- }
- end
-
- table.sort(childs, function(a, b)
- if a.order == b.order then
- return a.name < b.name
- else
- return a.order < b.order
- end
- end)
+ local children = _ordered_children(root)
if not root.leaf and deep ~= nil then
local sub_path = { unpack(prefix) }
deep = nil
end
- for _, cur_node in ipairs(childs) do
- sub_path[#prefix+1] = cur_node.name
+ local _, child
+ for _, child in ipairs(children) do
+ sub_path[#prefix+1] = child.name
- local res_path = _find_eligible_node(cur_node.node, sub_path,
+ local res_path = _find_eligible_node(child.node, sub_path,
deep, types, true)
if res_path then
end
+local _view = function(self, ...)
+ require "luci.template".render("view", { view = self.view })
+end
+
+function view(name)
+ return {type = "view", view = name, target = _view}
+end
+
+
local function _cbi(self, ...)
local cbi = require "luci.cbi"
local tpl = require "luci.template"