local stat, err = util.copcall(dispatch, context.request)
if not stat then
+ luci.util.perror(err)
error500(err)
end
local track = {}
local args = {}
- context.args = args
+ ctx.args = args
+ ctx.requestargs = ctx.requestargs or args
local n
for i, s in ipairs(request) do
-- @param path Controller base directory
-- @param suffix Controller file suffix
function createindex_plain(path, suffix)
+ local controllers = util.combine(
+ luci.fs.glob(path .. "*" .. suffix) or {},
+ luci.fs.glob(path .. "*/*" .. suffix) or {}
+ )
+
if indexcache then
local cachedate = fs.mtime(indexcache)
- if cachedate and cachedate > fs.mtime(path) then
+ if cachedate then
+ local realdate = 0
+ for _, obj in ipairs(controllers) do
+ local omtime = fs.mtime(path .. "/" .. obj)
+ realdate = (omtime and omtime > realdate) and omtime or realdate
+ end
- assert(
- sys.process.info("uid") == fs.stat(indexcache, "uid")
- and fs.stat(indexcache, "mode") == "rw-------",
- "Fatal: Indexcache is not sane!"
- )
+ if cachedate > realdate then
+ assert(
+ sys.process.info("uid") == fs.stat(indexcache, "uid")
+ and fs.stat(indexcache, "mode") == "rw-------",
+ "Fatal: Indexcache is not sane!"
+ )
- index = loadfile(indexcache)()
- return index
+ index = loadfile(indexcache)()
+ return index
+ end
end
end
index = {}
- local controllers = util.combine(
- luci.fs.glob(path .. "*" .. suffix) or {},
- luci.fs.glob(path .. "*/*" .. suffix) or {}
- )
-
for i,c in ipairs(controllers) do
local module = "luci.controller." .. c:sub(#path+1, #c-#suffix):gsub("/", ".")
local mod = require(module)
local ctx = context
local tree = {nodes={}}
+ local modi = {}
ctx.treecache = setmetatable({}, {__mode="v"})
ctx.tree = tree
+ ctx.modifiers = modi
-- Load default translation
require "luci.i18n".loadc("default")
v()
end
+ local function modisort(a,b)
+ return modi[a].order < modi[b].order
+ end
+
+ for _, v in util.spairs(modi, modisort) do
+ scope._NAME = v.module
+ setfenv(v.func, scope)
+ v.func()
+ end
+
return tree
end
+--- Register a tree modifier.
+-- @param func Modifier function
+-- @param order Modifier order value (optional)
+function modifier(func, order)
+ context.modifiers[#context.modifiers+1] = {
+ func = func,
+ order = order or 0,
+ module = getfenv(2)._NAME
+ }
+end
+
--- Clone a node of the dispatching tree to another position.
-- @param path Virtual path destination
-- @param clone Virtual path source
--- Create a redirect to another dispatching node.
-- @param ... Virtual path destination
function alias(...)
- local req = arg
- return function()
+ local req = {...}
+ return function(...)
+ for _, r in ipairs({...}) do
+ req[#req+1] = r
+ end
+
dispatch(req)
end
end
-- @param n Number of path values to replace
-- @param ... Virtual path to replace removed path values with
function rewrite(n, ...)
- local req = arg
- return function()
+ local req = {...}
+ return function(...)
+ local dispatched = util.clone(context.dispatched)
+
for i=1,n do
- table.remove(context.path, 1)
+ table.remove(dispatched, 1)
+ end
+
+ for i, r in ipairs(req) do
+ table.insert(dispatched, i, r)
end
- for i,r in ipairs(req) do
- table.insert(context.path, i, r)
+ for _, r in ipairs({...}) do
+ dispatched[#dispatched+1] = r
end
- dispatch()
+ dispatch(dispatched)
end
end
-- @param ... Additional parameters passed to the function
function call(name, ...)
local argv = {...}
- return function() return getfenv()[name](unpack(argv)) end
+ return function(...)
+ if #argv > 0 then
+ return getfenv()[name](unpack(argv), ...)
+ else
+ return getfenv()[name](...)
+ end
+ end
end
--- Create a template render dispatching target.
end
--- Create a CBI model dispatching target.
--- @param model CBI model tpo be rendered
-function cbi(model)
+-- @param model CBI model to be rendered
+function cbi(model, config)
+ config = config or {}
return function(...)
require("luci.cbi")
require("luci.template")
local state = nil
for i, res in ipairs(maps) do
+ if config.autoapply then
+ res.autoapply = config.autoapply
+ end
local cstate = res:parse()
if not state or cstate < state then
state = cstate
end
end
+ if config.on_valid_to and state and state > 0 and state < 2 then
+ luci.http.redirect(config.on_valid_to)
+ return
+ end
+
+ if config.on_changed_to and state and state > 1 then
+ luci.http.redirect(config.on_changed_to)
+ return
+ end
+
+ if config.on_success_to and state and state > 0 then
+ luci.http.redirect(config.on_success_to)
+ return
+ end
+
+ if config.state_handler then
+ if not config.state_handler(state, maps) then
+ return
+ end
+ end
+
+ local pageaction = true
http.header("X-CBI-State", state or 0)
- luci.template.render("cbi/header")
+ luci.template.render("cbi/header", {state = state})
for i, res in ipairs(maps) do
res:render()
+ if res.pageaction == false then
+ pageaction = false
+ end
end
- luci.template.render("cbi/footer")
+ luci.template.render("cbi/footer", {pageaction=pageaction, state = state, autoapply = config.autoapply})
end
end
projects / project / luci.git / blobdiff