x/icebergs
1
0
Fork 1
mirror of https://shylinux.com/x/icebergs synced 2025-06-26 10:27:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

opt chrome

Browse Source
This commit is contained in:
IT 老营长 @云轩领航-创始人 2022-01-02 22:02:27 +08:00
parent ea23534857
commit c43212865a
167 changed files with 1216 additions and 2269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/aaa/user.go
View File

@ -109,7 +109,7 @@ func init() {
}, Commands: map[string]*ice.Command{
USER: {Name: "user username auto create", Help: "用户", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, USER, m.PrefixKey())
m.Cmd(mdb.SEARCH, mdb.CREATE, m.CommandKey(), m.PrefixKey())
UserRoot(ice.Pulse)
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {

4
base/cli/daemon.go
View File

@ -5,6 +5,7 @@ import (
"os/exec"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
@ -37,7 +38,7 @@ func _daemon_exec(m *ice.Message, cmd *exec.Cmd) {
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, mdb.HASH, h, STATUS, ERROR, ERROR, e)
}
} else {
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), ctx.ARGS, cmd.Args)
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, mdb.HASH, h, STATUS, STOP)
}
@ -77,6 +78,7 @@ const (
BENCH = "bench"
PPROF = "pprof"
TIMEOUT = "timeout"
STATUS = "status"
ERROR = "error"
START = "start"

1
base/cli/qrcode.go
View File

@ -112,6 +112,7 @@ const (
LIGHT = 127
)
const (
COLOR = "color"
BLACK = "black"
RED = "red"
GREEN = "green"

4
base/cli/runtime.go
View File

@ -53,8 +53,8 @@ func _runtime_init(m *ice.Message) {
ice.Info.UserName = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
// 启动次数
count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT))) + 1
m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT), count)
count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT))) + 1
m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT), count)
// 节点信息
m.Conf(RUNTIME, kit.Keys(NODE, mdb.TIME), m.Time())

3
base/cli/system.go
View File

@ -7,6 +7,7 @@ import (
"os/exec"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
@ -69,7 +70,7 @@ func _system_exec(m *ice.Message, cmd *exec.Cmd) {
// 执行命令
if e := cmd.Run(); !m.Warn(e, ice.ErrNotFound, cmd.Args) {
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), ctx.ARGS, cmd.Args)
}
m.Push(mdb.TIME, m.Time())

22
base/ctx/command.go
View File

@ -15,21 +15,21 @@ func _command_list(m *ice.Message, name string) {
continue // 内部命令
}
m.Push(kit.MDB_KEY, k)
m.Push(kit.MDB_NAME, v.Name)
m.Push(kit.MDB_HELP, v.Help)
m.Push(mdb.KEY, k)
m.Push(mdb.NAME, v.Name)
m.Push(mdb.HELP, v.Help)
}
m.Sort(kit.MDB_KEY)
m.Sort(mdb.KEY)
return
}
// 命令详情
m.Spawn(m.Source()).Search(name, func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
m.Push(kit.MDB_INDEX, kit.Keys(s.Cap(ice.CTX_FOLLOW), key))
m.Push(kit.MDB_NAME, kit.Format(cmd.Name))
m.Push(kit.MDB_HELP, kit.Format(cmd.Help))
m.Push(kit.MDB_META, kit.Format(cmd.Meta))
m.Push(kit.MDB_LIST, kit.Format(cmd.List))
m.Push(mdb.INDEX, kit.Keys(s.Cap(ice.CTX_FOLLOW), key))
m.Push(mdb.NAME, kit.Format(cmd.Name))
m.Push(mdb.HELP, kit.Format(cmd.Help))
m.Push(mdb.META, kit.Format(cmd.Meta))
m.Push(mdb.LIST, kit.Format(cmd.List))
})
}
func _command_search(m *ice.Message, kind, name, text string) {
@ -65,6 +65,8 @@ func CmdAction(fields ...string) map[string]*ice.Action {
const (
ACTION = "action"
INDEX = "index"
ARGS = "args"
)
const COMMAND = "command"
@ -72,7 +74,7 @@ func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
COMMAND: {Name: "command key auto", Help: "命令", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, COMMAND, m.PrefixKey())
m.Cmd(mdb.SEARCH, mdb.CREATE, m.CommandKey(), m.PrefixKey())
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == COMMAND || arg[1] != "" {

11
base/ctx/context.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
@ -12,10 +13,10 @@ func _context_list(m *ice.Message, sub *ice.Context, name string) {
if name != "" && name != ice.ICE && !strings.HasPrefix(s.Cap(ice.CTX_FOLLOW), name+ice.PT) {
return
}
m.Push(kit.MDB_NAME, s.Cap(ice.CTX_FOLLOW))
m.Push(kit.MDB_STATUS, s.Cap(ice.CTX_STATUS))
m.Push(kit.MDB_STREAM, s.Cap(ice.CTX_STREAM))
m.Push(kit.MDB_HELP, s.Help)
m.Push(mdb.NAME, s.Cap(ice.CTX_FOLLOW))
m.Push(mdb.STATUS, s.Cap(ice.CTX_STATUS))
m.Push(mdb.STREAM, s.Cap(ice.CTX_STREAM))
m.Push(mdb.HELP, s.Help)
})
}
func Inputs(m *ice.Message, field string) bool {
@ -25,7 +26,7 @@ func Inputs(m *ice.Message, field string) bool {
case ice.CTX:
m.Cmdy(CONTEXT)
case ice.CMD:
m.Cmdy(CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(kit.MDB_EXTRA, ice.CTX))), COMMAND)
m.Cmdy(CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(mdb.EXTRA, ice.CTX))), COMMAND)
case ice.ARG:
default:

2
base/gdb/event.go
View File

@ -21,7 +21,7 @@ const EVENT = "event"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
EVENT: {Name: EVENT, Help: "事件流", Value: kit.Data(
kit.MDB_SHORT, EVENT, kit.MDB_FIELD, "time,id,cmd",
mdb.SHORT, EVENT, mdb.FIELD, "time,id,cmd",
)},
}, Commands: map[string]*ice.Command{
EVENT: {Name: "event event id auto listen", Help: "事件流", Action: ice.MergeAction(map[string]*ice.Action{

8
base/gdb/routine.go
View File

@ -14,15 +14,15 @@ const ROUTINE = "routine"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
ROUTINE: {Name: ROUTINE, Help: "协程池", Value: kit.Data(
kit.MDB_SHORT, "time,hash,status,fileline",
mdb.SHORT, "time,hash,status,fileline",
)},
}, Commands: map[string]*ice.Command{
ROUTINE: {Name: "routine hash auto prunes", Help: "协程池", Action: ice.MergeAction(map[string]*ice.Action{
mdb.CREATE: {Name: "create fileline status", Help: "创建"},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_SHORT))
m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, kit.MDB_STATUS, cli.STOP)
m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, kit.MDB_STATUS, cli.ERROR)
m.OptionFields(m.Config(mdb.SHORT))
m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, cli.STATUS, cli.STOP)
m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, cli.STATUS, cli.ERROR)
}},
"inner": {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
ls := kit.Split(m.Option("fileline"), ":")

6
base/gdb/signal.go
View File

@ -47,7 +47,7 @@ const SIGNAL = "signal"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SIGNAL: {Name: SIGNAL, Help: "信号器", Value: kit.Data(
kit.MDB_SHORT, SIGNAL, kit.MDB_FIELD, "time,signal,name,cmd",
mdb.SHORT, SIGNAL, mdb.FIELD, "time,signal,name,cmd",
nfs.PATH, path.Join(ice.VAR_RUN, "ice.pid"),
)},
}, Commands: map[string]*ice.Command{
@ -58,8 +58,8 @@ func init() {
m.Cmd(nfs.SAVE, kit.Select(m.Conf(SIGNAL, kit.META_PATH), m.Conf(cli.RUNTIME, kit.Keys(cli.CONF, cli.CTX_PID))),
m.Conf(cli.RUNTIME, kit.Keys(cli.HOST, cli.PID)))
m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", ice.CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", ice.CMD, "exit 1")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", mdb.NAME, "退出", ice.CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", mdb.NAME, "重启", ice.CMD, "exit 1")
}},
SIGNAL: {Name: "signal signal auto listen", Help: "信号器", Action: ice.MergeAction(map[string]*ice.Action{
LISTEN: {Name: "listen signal name cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {

16
base/gdb/timer.go
View File

@ -11,19 +11,19 @@ import (
func _timer_action(m *ice.Message, arg ...string) {
now := time.Now().UnixNano()
m.OptionFields(m.Config(kit.MDB_FIELD))
m.OptionFields(m.Config(mdb.FIELD))
m.Richs(TIMER, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); value[kit.MDB_STATUS] == cli.STOP {
m.Richs(TIMER, "", mdb.FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); value[cli.STATUS] == cli.STOP {
return
}
order := kit.Int(value[ORDER])
if n := kit.Time(kit.Format(value[NEXT])); now > n && order > 0 {
m.Logs(TIMER, kit.MDB_KEY, key, ORDER, order)
m.Logs(TIMER, mdb.KEY, key, ORDER, order)
msg := m.Cmd(value[ice.CMD])
m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(ice.RES, msg.Result()))
m.Grow(TIMER, kit.Keys(mdb.HASH, key), kit.Dict(ice.RES, msg.Result()))
if value[ORDER] = kit.Format(order - 1); order > 1 {
value[NEXT] = msg.Time(value[INTERVAL])
}
@ -43,7 +43,7 @@ const TIMER = "timer"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
TIMER: {Name: TIMER, Help: "定时器", Value: kit.Data(
kit.MDB_FIELD, "time,hash,delay,interval,order,next,cmd", TICK, "1s",
mdb.FIELD, "time,hash,delay,interval,order,next,cmd", TICK, "1s",
)},
}, Commands: map[string]*ice.Command{
TIMER: {Name: "timer hash id auto create action prunes", Help: "定时器", Action: ice.MergeAction(map[string]*ice.Action{
@ -51,14 +51,14 @@ func init() {
m.Cmdy(mdb.INSERT, TIMER, "", mdb.HASH, DELAY, "10ms", INTERVAL, "10m", ORDER, 1, NEXT, m.Time(m.Option(DELAY)), arg)
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.OptionFields(m.Config(mdb.FIELD))
m.Cmdy(mdb.PRUNES, TIMER, "", mdb.HASH, ORDER, 0)
}},
ACTION: {Name: "action", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
_timer_action(m, arg...)
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), m.Config(kit.MDB_FIELD), "time,id,res")
m.Fields(len(arg), m.Config(mdb.FIELD), "time,id,res")
mdb.ZoneSelect(m, arg...)
}},
}})

4
base/lex/lex.go
View File

@ -1,8 +1,6 @@
package lex
import (
ice "shylinux.com/x/icebergs"
)
import ice "shylinux.com/x/icebergs"
const LEX = "lex"

2
base/lex/lex.shy
View File

@ -1,2 +1,4 @@
chapter "lex"
field "分词" lex.split

30
base/lex/matrix.go
View File

@ -359,12 +359,12 @@ func (mat *Matrix) show(m *ice.Message) {
m.Status(NLANG, mat.nlang, NCELL, mat.ncell, NPAGE, len(mat.page), NHASH, len(mat.hash))
}
func _lex_load(m *ice.Message) {
m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", mdb.FOREACH, func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("256", value[NCELL])))
m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
mat.Train(m, kit.Format(value[NPAGE]), kit.Format(value[NHASH]), kit.Format(value[kit.MDB_TEXT]))
m.Grows(m.Prefix(MATRIX), kit.Keys(mdb.HASH, key), "", "", func(index int, value map[string]interface{}) {
mat.Train(m, kit.Format(value[NPAGE]), kit.Format(value[NHASH]), kit.Format(value[mdb.TEXT]))
})
value[MATRIX] = mat
})
@ -394,7 +394,7 @@ func init() {
MATRIX: {Name: "matrix hash npage text auto", Help: "魔方矩阵", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create nlang=32 ncell=128", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
mat := NewMatrix(m, kit.Int(kit.Select("32", m.Option(NLANG))), kit.Int(kit.Select("128", m.Option(NCELL))))
h := m.Rich(m.Prefix(MATRIX), "", kit.Data(kit.MDB_TIME, m.Time(), MATRIX, mat, NLANG, mat.nlang, NCELL, mat.ncell))
h := m.Rich(m.Prefix(MATRIX), "", kit.Data(mdb.TIME, m.Time(), MATRIX, mat, NLANG, mat.nlang, NCELL, mat.ncell))
switch cb := m.Optionv(kit.Keycb(MATRIX)).(type) {
case func(string, *Matrix):
cb(h, mat)
@ -402,13 +402,13 @@ func init() {
m.Echo(h)
}},
mdb.INSERT: {Name: "insert hash npage=num nhash=num text=123", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", m.Option(mdb.HASH), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat, _ := value[MATRIX].(*Matrix)
m.Echo("%d", mat.Train(m, m.Option(NPAGE), m.Option(NHASH), m.Option(kit.MDB_TEXT)))
m.Grow(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), kit.Dict(
kit.MDB_TIME, m.Time(), NPAGE, m.Option(NPAGE), NHASH, m.Option(NHASH), kit.MDB_TEXT, m.Option(kit.MDB_TEXT),
m.Echo("%d", mat.Train(m, m.Option(NPAGE), m.Option(NHASH), m.Option(mdb.TEXT)))
m.Grow(m.Prefix(MATRIX), kit.Keys(mdb.HASH, key), kit.Dict(
mdb.TIME, m.Time(), NPAGE, m.Option(NPAGE), NHASH, m.Option(NHASH), mdb.TEXT, m.Option(mdb.TEXT),
))
value[NPAGE] = len(mat.page)
@ -416,14 +416,14 @@ func init() {
})
}},
mdb.REMOVE: {Name: "create", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(MATRIX), "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
m.Cmdy(mdb.DELETE, m.Prefix(MATRIX), "", mdb.HASH, mdb.HASH, m.Option(mdb.HASH))
}},
PARSE: {Name: "parse hash npage text=123", Help: "解析", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", m.Option(mdb.HASH), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat, _ := value[MATRIX].(*Matrix)
stream := NewStream(bytes.NewBufferString(m.Option(kit.MDB_TEXT)))
stream := NewStream(bytes.NewBufferString(m.Option(mdb.TEXT)))
hash, word := mat.Parse(m, m.Option(NPAGE), stream)
m.Push(NHASH, kit.Select(kit.Format("%d", hash), mat.word[hash]))
m.Push("word", string(word))
@ -432,7 +432,7 @@ func init() {
m.ProcessInner()
}},
"show": {Name: "show", Help: "矩阵", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", kit.Select(m.Option(kit.MDB_HASH), arg, 0), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", kit.Select(m.Option(mdb.HASH), arg, 0), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
value[MATRIX].(*Matrix).show(m)
})
@ -448,7 +448,7 @@ func init() {
if m.Action(mdb.INSERT, "show"); len(arg) == 1 { // 词法列表
m.Fields(len(arg[1:]), "time,npage,nhash,text")
m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, arg[0]), mdb.LIST)
m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), kit.Keys(mdb.HASH, arg[0]), mdb.LIST)
m.PushAction(PARSE)
return
}
@ -463,8 +463,8 @@ func init() {
}
hash, word := mat.Parse(m, arg[1], NewStream(bytes.NewBufferString(arg[2])))
m.Push(kit.MDB_TIME, m.Time())
m.Push(kit.MDB_HASH, mat.word[hash])
m.Push(mdb.TIME, m.Time())
m.Push(mdb.HASH, mat.word[hash])
m.Push("word", string(word))
})
}},

16
base/lex/split.go
View File

@ -37,33 +37,37 @@ func _split_list(m *ice.Message, file string, arg ...string) map[string]interfac
list := kit.List(kit.Data(DEEP, -1))
m.Cmd(nfs.CAT, file, func(text string) {
if strings.HasPrefix(strings.TrimSpace(text), "# ") {
return
return // 注释
}
if strings.TrimSpace(text) == "" {
return
return // 空行
}
stack, deep = _split_deep(stack, text)
data := kit.Data(DEEP, deep)
// 回调函数
ls := kit.Split(text, m.Option(SPLIT_SPACE), m.Option(SPLIT_BLOCK), m.Option(SPLIT_QUOTE))
switch cb := m.OptionCB(SPLIT).(type) {
case func([]string, map[string]interface{}) []string:
ls = cb(ls, data)
case func(int, []string, map[string]interface{}) []string:
ls = cb(deep, ls, data)
case func([]string, map[string]interface{}) []string:
ls = cb(ls, data)
}
// 参数字段
for _, k := range arg {
if kit.Value(data, kit.Keym(k), kit.Select("", ls, 0)); len(ls) > 0 {
ls = ls[1:]
}
}
// 属性字段
for i := 0; i < len(ls)-1; i += 2 {
kit.Value(data, kit.Keym(ls[i]), ls[i+1])
}
// 查找节点
for i := len(list) - 1; i >= 0; i-- {
if deep > kit.Int(kit.Value(list[i], kit.Keym(DEEP))) {
kit.Value(list[i], "list.-2", data)
@ -96,8 +100,8 @@ func init() {
return
}
m.Echo(kit.Format(_split_list(m, arg[0], arg[1:]...)))
m.ProcessDisplay("/plugin/local/wiki/json.js")
m.Echo(kit.Format(_split_list(m, arg[0], kit.Split(kit.Join(arg[1:]))...)))
m.DisplayStory("json.js")
}},
}})
}

19
base/log/log.go
View File

@ -5,6 +5,7 @@ import (
"path"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
log "shylinux.com/x/toolkits/logs"
@ -90,28 +91,28 @@ const (
var Index = &ice.Context{Name: "log", Help: "日志模块", Configs: map[string]*ice.Config{
FILE: {Name: FILE, Help: "日志文件", Value: kit.Dict(
BENCH, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "bench.log"), kit.MDB_LIST, []string{}),
WATCH, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "watch.log"), kit.MDB_LIST, []string{
BENCH, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "bench.log"), mdb.LIST, []string{}),
WATCH, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "watch.log"), mdb.LIST, []string{
ice.LOG_CREATE, ice.LOG_REMOVE,
ice.LOG_INSERT, ice.LOG_DELETE,
ice.LOG_MODIFY, ice.LOG_SELECT,
ice.LOG_EXPORT, ice.LOG_IMPORT,
}),
ERROR, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "error.log"), kit.MDB_LIST, []string{
ERROR, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "error.log"), mdb.LIST, []string{
ice.LOG_WARN, ice.LOG_ERROR,
}),
TRACE, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "trace.log"), kit.MDB_LIST, []string{
TRACE, kit.Dict(nfs.PATH, path.Join(ice.VAR_LOG, "trace.log"), mdb.LIST, []string{
ice.LOG_DEBUG,
}),
)},
VIEW: {Name: VIEW, Help: "日志格式", Value: kit.Dict(
GREEN, kit.Dict(PREFIX, "\033[32m", SUFFIX, "\033[0m", kit.MDB_LIST, []string{
GREEN, kit.Dict(PREFIX, "\033[32m", SUFFIX, "\033[0m", mdb.LIST, []string{
ice.LOG_START, ice.LOG_SERVE, ice.LOG_CMDS,
}),
YELLOW, kit.Dict(PREFIX, "\033[33m", SUFFIX, "\033[0m", kit.MDB_LIST, []string{
YELLOW, kit.Dict(PREFIX, "\033[33m", SUFFIX, "\033[0m", mdb.LIST, []string{
ice.LOG_AUTH, ice.LOG_COST,
}),
RED, kit.Dict(PREFIX, "\033[31m", SUFFIX, "\033[0m", kit.MDB_LIST, []string{
RED, kit.Dict(PREFIX, "\033[31m", SUFFIX, "\033[0m", mdb.LIST, []string{
ice.LOG_CLOSE, ice.LOG_WARN,
}),
)},
@ -122,12 +123,12 @@ var Index = &ice.Context{Name: "log", Help: "日志模块", Configs: map[string]
return // 禁用日志
}
m.Confm(VIEW, nil, func(key string, value map[string]interface{}) {
kit.Fetch(value[kit.MDB_LIST], func(index int, k string) {
kit.Fetch(value[mdb.LIST], func(index int, k string) {
m.Conf(SHOW, kit.Keys(k, VIEW), key)
})
})
m.Confm(FILE, nil, func(key string, value map[string]interface{}) {
kit.Fetch(value[kit.MDB_LIST], func(index int, k string) {
kit.Fetch(value[mdb.LIST], func(index int, k string) {
m.Conf(SHOW, kit.Keys(k, FILE), key)
})
// 日志文件

6
base/mdb/engine.go
View File

@ -10,7 +10,7 @@ const ENGINE = "engine"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
ENGINE: {Name: ENGINE, Help: "引擎", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
SHORT, TYPE, FIELD, "time,type,name,text",
)},
}, Commands: map[string]*ice.Command{
ENGINE: {Name: "engine type name text auto", Help: "引擎", Action: ice.MergeAction(map[string]*ice.Action{
@ -20,12 +20,12 @@ func init() {
}, HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 1 {
m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
m.Cmdy(kit.Keys(value[TEXT], value[NAME]),
m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
})
}
if HashSelect(m, arg...); len(arg) == 0 {
m.Sort(kit.MDB_TYPE)
m.Sort(TYPE)
}
}},
}})

74
base/mdb/hash.go
View File

@ -14,39 +14,39 @@ func _hash_fields(m *ice.Message) []string {
}
func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
list := map[string]int{}
m.Richs(prefix, chain, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
if val = kit.GetMeta(val); kit.Format(val[kit.MDB_COUNT]) != "" {
list[kit.Format(val[field])] = kit.Int(val[kit.MDB_COUNT])
m.Richs(prefix, chain, FOREACH, func(key string, val map[string]interface{}) {
if val = kit.GetMeta(val); kit.Format(val[COUNT]) != "" {
list[kit.Format(val[field])] = kit.Int(val[COUNT])
} else {
list[kit.Format(val[field])]++
}
})
for k, i := range list {
m.Push(field, k)
m.Push(kit.MDB_COUNT, i)
m.Push(COUNT, i)
}
m.SortIntR(kit.MDB_COUNT)
m.SortIntR(COUNT)
}
func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) {
if m.Option(ice.MSG_DOMAIN) != "" {
m.Conf(prefix, kit.Keys(chain, kit.Keym(kit.MDB_SHORT)), m.Conf(prefix, kit.Keym(kit.MDB_SHORT)))
m.Conf(prefix, kit.Keys(chain, kit.Keym(SHORT)), m.Conf(prefix, kit.Keym(SHORT)))
}
m.Log_INSERT(kit.MDB_KEY, path.Join(prefix, chain), arg[0], arg[1])
m.Log_INSERT(KEY, path.Join(prefix, chain), arg[0], arg[1])
m.Echo(m.Rich(prefix, chain, kit.Data(arg)))
}
func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
if field != kit.MDB_HASH {
field, value = kit.MDB_HASH, kit.Select(kit.Hashs(value), m.Option(kit.MDB_HASH))
if field != HASH {
field, value = HASH, kit.Select(kit.Hashs(value), m.Option(HASH))
}
m.Richs(prefix, chain, value, func(key string, val map[string]interface{}) {
m.Log_DELETE(kit.MDB_KEY, path.Join(prefix, chain), field, value, kit.MDB_VALUE, kit.Format(val))
m.Conf(prefix, kit.Keys(chain, kit.MDB_HASH, key), "")
m.Log_DELETE(KEY, path.Join(prefix, chain), field, value, VALUE, kit.Format(val))
m.Conf(prefix, kit.Keys(chain, HASH, key), "")
})
}
func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg ...string) {
m.Richs(prefix, chain, value, func(key string, val map[string]interface{}) {
val = kit.GetMeta(val)
m.Log_MODIFY(kit.MDB_KEY, path.Join(prefix, chain), field, value, arg)
m.Log_MODIFY(KEY, path.Join(prefix, chain), field, value, arg)
for i := 0; i < len(arg); i += 2 {
if arg[i] == field {
continue
@ -56,8 +56,8 @@ func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg
})
}
func _hash_select(m *ice.Message, prefix, chain, field, value string) {
if field == kit.MDB_HASH && value == RANDOM {
value = kit.MDB_RANDOMS
if field == HASH && value == RANDOM {
value = RANDOMS
}
fields := _hash_fields(m)
m.Richs(prefix, chain, value, func(key string, val map[string]interface{}) {
@ -73,7 +73,7 @@ func _hash_select(m *ice.Message, prefix, chain, field, value string) {
}
})
if m.Option(FIELDS) != DETAIL {
m.SortTimeR(kit.MDB_TIME)
m.SortTimeR(TIME)
}
}
func _hash_export(m *ice.Message, prefix, chain, file string) {
@ -85,8 +85,8 @@ func _hash_export(m *ice.Message, prefix, chain, file string) {
en.SetIndent("", " ")
m.Assert(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))))
m.Log_EXPORT(kit.MDB_KEY, path.Join(prefix, chain), kit.MDB_FILE, p)
m.Conf(prefix, kit.Keys(chain, kit.MDB_HASH), "")
m.Log_EXPORT(KEY, path.Join(prefix, chain), FILE, p)
m.Conf(prefix, kit.Keys(chain, HASH), "")
m.Echo(p)
}
func _hash_import(m *ice.Message, prefix, chain, file string) {
@ -98,9 +98,9 @@ func _hash_import(m *ice.Message, prefix, chain, file string) {
m.Assert(json.NewDecoder(f).Decode(&list))
count := 0
if m.Conf(prefix, kit.Keys(chain, kit.MDB_META, kit.MDB_SHORT)) == "" {
if m.Conf(prefix, kit.Keys(chain, META, SHORT)) == "" {
for k, data := range list {
m.Conf(prefix, kit.Keys(chain, kit.MDB_HASH, k), data)
m.Conf(prefix, kit.Keys(chain, HASH, k), data)
count++
}
} else {
@ -110,12 +110,12 @@ func _hash_import(m *ice.Message, prefix, chain, file string) {
}
}
m.Log_IMPORT(kit.MDB_KEY, path.Join(prefix, chain), kit.MDB_COUNT, count)
m.Log_IMPORT(KEY, path.Join(prefix, chain), COUNT, count)
m.Echo("%d", count)
}
func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
fields := _hash_fields(m)
m.Richs(prefix, chain, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Richs(prefix, chain, FOREACH, func(key string, val map[string]interface{}) {
switch val = kit.GetMeta(val); cb := m.Optionv(kit.Keycb(PRUNES)).(type) {
case func(string, map[string]interface{}) bool:
if !cb(key, val) {
@ -131,7 +131,7 @@ func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
m.Push(key, val, fields)
})
m.Table(func(index int, value map[string]string, head []string) {
_hash_delete(m, prefix, chain, kit.MDB_HASH, value[kit.MDB_HASH])
_hash_delete(m, prefix, chain, HASH, value[HASH])
})
}
@ -139,13 +139,13 @@ const HASH = "hash"
func HashAction(fields ...string) map[string]*ice.Action {
_key := func(m *ice.Message) string {
if m.Config(kit.MDB_HASH) == "uniq" {
return kit.MDB_HASH
if m.Config(HASH) == "uniq" {
return HASH
}
if m.Config(kit.MDB_SHORT) == "uniq" {
return kit.MDB_HASH
if m.Config(SHORT) == "uniq" {
return HASH
}
return kit.Select(kit.MDB_HASH, m.Config(kit.MDB_SHORT))
return kit.Select(HASH, m.Config(SHORT))
}
return ice.SelectAction(map[string]*ice.Action{
INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
@ -177,35 +177,35 @@ func HashAction(fields ...string) map[string]*ice.Action {
func HashActionStatus(fields ...string) map[string]*ice.Action {
list := HashAction(fields...)
list[PRUNES] = &ice.Action{Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "close")
m.OptionFields(m.Config(FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "close")
}}
return list
}
func HashSelect(m *ice.Message, arg ...string) *ice.Message {
m.Fields(len(arg), m.Config(kit.MDB_FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", HASH, m.Config(kit.MDB_SHORT), arg)
m.Fields(len(arg), m.Config(FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", HASH, m.Config(SHORT), arg)
m.PushAction(REMOVE)
m.StatusTimeCount()
return m
}
func HashPrunes(m *ice.Message, cb func(map[string]string) bool) *ice.Message {
_key := func(m *ice.Message) string {
if m.Config(kit.MDB_HASH) == "uniq" {
return kit.MDB_HASH
if m.Config(HASH) == "uniq" {
return HASH
}
return kit.Select(kit.MDB_HASH, m.Config(kit.MDB_SHORT))
return kit.Select(HASH, m.Config(SHORT))
}
before := kit.Time(kit.Select(m.Time("-72h"), m.Option(kit.MDB_BEFORE)))
m.Cmd(m.CommandKey()).Table(func(index int, value map[string]string, head []string) {
if kit.Time(value[kit.MDB_TIME]) > before {
if kit.Time(value[TIME]) > before {
return
}
if cb != nil && cb(value) {
return
}
m.OptionFields(m.Config(kit.MDB_FIELD))
m.OptionFields(m.Config(FIELD))
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, _key(m), value[_key(m)])
})
return m

42
base/mdb/list.go
View File

@ -15,20 +15,20 @@ func _list_fields(m *ice.Message) []string {
func _list_inputs(m *ice.Message, prefix, chain string, field, value string) {
list := map[string]int{}
m.Grows(prefix, chain, "", "", func(index int, val map[string]interface{}) {
if val = kit.GetMeta(val); kit.Format(val[kit.MDB_COUNT]) != "" {
list[kit.Format(val[field])] = kit.Int(val[kit.MDB_COUNT])
if val = kit.GetMeta(val); kit.Format(val[COUNT]) != "" {
list[kit.Format(val[field])] = kit.Int(val[COUNT])
} else {
list[kit.Format(val[field])]++
}
})
for k, i := range list {
m.Push(field, k)
m.Push(kit.MDB_COUNT, i)
m.Push(COUNT, i)
}
m.SortIntR(kit.MDB_COUNT)
m.SortIntR(COUNT)
}
func _list_insert(m *ice.Message, prefix, chain string, arg ...string) {
m.Log_INSERT(kit.MDB_KEY, path.Join(prefix, chain), arg[0], arg[1])
m.Log_INSERT(KEY, path.Join(prefix, chain), arg[0], arg[1])
m.Echo("%d", m.Grow(prefix, chain, kit.Dict(arg)))
}
func _list_delete(m *ice.Message, prefix, chain, field, value string) {
@ -36,7 +36,7 @@ func _list_delete(m *ice.Message, prefix, chain, field, value string) {
func _list_modify(m *ice.Message, prefix, chain string, field, value string, arg ...string) {
m.Grows(prefix, chain, field, value, func(index int, val map[string]interface{}) {
val = kit.GetMeta(val)
m.Log_MODIFY(kit.MDB_KEY, path.Join(prefix, chain), field, value, arg)
m.Log_MODIFY(KEY, path.Join(prefix, chain), field, value, arg)
for i := 0; i < len(arg); i += 2 {
if arg[i] == field {
continue
@ -92,9 +92,9 @@ func _list_export(m *ice.Message, prefix, chain, file string) {
count++
})
m.Log_EXPORT(kit.MDB_KEY, path.Join(prefix, chain), kit.MDB_FILE, p, kit.MDB_COUNT, count)
m.Conf(prefix, kit.Keys(chain, kit.Keym(kit.MDB_COUNT)), 0)
m.Conf(prefix, kit.Keys(chain, kit.MDB_LIST), "")
m.Log_EXPORT(KEY, path.Join(prefix, chain), FILE, p, COUNT, count)
m.Conf(prefix, kit.Keys(chain, kit.Keym(COUNT)), 0)
m.Conf(prefix, kit.Keys(chain, LIST), "")
m.Echo(p)
}
func _list_import(m *ice.Message, prefix, chain, file string) {
@ -114,7 +114,7 @@ func _list_import(m *ice.Message, prefix, chain, file string) {
data := kit.Dict()
for i, k := range head {
if k == kit.MDB_EXTRA {
if k == EXTRA {
kit.Value(data, k, kit.UnMarshal(line[i]))
} else {
kit.Value(data, k, line[i])
@ -125,7 +125,7 @@ func _list_import(m *ice.Message, prefix, chain, file string) {
count++
}
m.Log_IMPORT(kit.MDB_KEY, kit.Keys(prefix, chain), kit.MDB_COUNT, count)
m.Log_IMPORT(KEY, kit.Keys(prefix, chain), COUNT, count)
m.Echo("%d", count)
}
func _list_prunes(m *ice.Message, prefix, chain string, arg ...string) {
@ -142,17 +142,17 @@ func ListAction(fields ...string) map[string]*ice.Action {
m.Cmdy(INSERT, m.PrefixKey(), "", LIST, arg)
}},
DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(DELETE, m.PrefixKey(), "", LIST, m.OptionSimple(kit.MDB_ID), arg)
m.Cmdy(DELETE, m.PrefixKey(), "", LIST, m.OptionSimple(ID), arg)
}},
MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(MODIFY, m.PrefixKey(), "", LIST, m.OptionSimple(kit.MDB_ID), arg)
m.Cmdy(MODIFY, m.PrefixKey(), "", LIST, m.OptionSimple(ID), arg)
}},
EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Option(ice.CACHE_LIMIT, "-1")
m.OptionFields(m.Config(kit.MDB_FIELD))
m.OptionFields(m.Config(FIELD))
m.Cmdy(EXPORT, m.PrefixKey(), "", LIST)
m.Conf(m.PrefixKey(), kit.MDB_LIST, "")
m.Config(kit.MDB_COUNT, 0)
m.Conf(m.PrefixKey(), LIST, "")
m.Config(COUNT, 0)
}},
IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(IMPORT, m.PrefixKey(), "", LIST, arg)
@ -161,19 +161,19 @@ func ListAction(fields ...string) map[string]*ice.Action {
m.Cmdy(PRUNES, m.PrefixKey(), "", LIST, arg)
}},
PREV: {Name: "prev", Help: "上一页", Hand: func(m *ice.Message, arg ...string) {
PrevPage(m, m.Config(kit.MDB_COUNT), kit.Slice(arg, 1)...)
PrevPage(m, m.Config(COUNT), kit.Slice(arg, 1)...)
}},
NEXT: {Name: "next", Help: "下一页", Hand: func(m *ice.Message, arg ...string) {
NextPage(m, m.Config(kit.MDB_COUNT), kit.Slice(arg, 1)...)
NextPage(m, m.Config(COUNT), kit.Slice(arg, 1)...)
}},
}, fields...)
}
func ListSelect(m *ice.Message, arg ...string) *ice.Message {
m.OptionPage(kit.Slice(arg, 1)...)
m.Fields(len(kit.Slice(arg, 0, 1)), m.Config(kit.MDB_FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", LIST, kit.MDB_ID, arg)
m.Fields(len(kit.Slice(arg, 0, 1)), m.Config(FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", LIST, ID, arg)
if !m.FieldsIsDetail() {
m.StatusTimeCountTotal(m.Config(kit.MDB_COUNT))
m.StatusTimeCountTotal(m.Config(COUNT))
}
return m
}

25
base/mdb/mdb.go
View File

@ -32,19 +32,24 @@ const (
NAME = "name"
TEXT = "text"
INDEX = "index"
VALUE = "value"
LINK = "link"
SCAN = "scan"
HELP = "help"
SHOW = "show"
HELP = "help"
FILE = "file"
DATA = "data"
SHORT = "short"
FIELD = "field"
TOTAL = "total"
COUNT = "count"
LIMIT = "limit"
INDEX = "index"
VALUE = "value"
EXTRA = "extra"
EXPIRE = "expire"
STATUS = "status"
STREAM = "stream"
FOREACH = "*"
RANDOMS = "%"
@ -118,7 +123,7 @@ const MDB = "mdb"
var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
ice.Pulse.Option(CACHE_LIMIT, "10")
ice.Pulse.Option(ice.CACHE_LIMIT, "10")
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}},
@ -145,7 +150,7 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
MODIFY: {Name: "modify key sub type field value arg...", Help: "编辑", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
switch arg[2] {
case ZONE: // modify key sub type zone id field value
_list_modify(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), kit.MDB_ID, arg[4], arg[5:]...)
_list_modify(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), ID, arg[4], arg[5:]...)
case HASH:
_hash_modify(m, arg[0], _domain_chain(m, arg[1]), arg[3], arg[4], arg[5:]...)
case LIST:
@ -157,7 +162,7 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
case ZONE:
_zone_select(m, arg[0], _domain_chain(m, arg[1]), kit.Select("", arg, 3), kit.Select("", arg, 4))
case HASH:
_hash_select(m, arg[0], _domain_chain(m, arg[1]), kit.Select("", arg, 3), kit.Select(kit.MDB_FOREACH, arg, 4))
_hash_select(m, arg[0], _domain_chain(m, arg[1]), kit.Select("", arg, 3), kit.Select(FOREACH, arg, 4))
case LIST:
_list_select(m, arg[0], _domain_chain(m, arg[1]), kit.Select("", arg, 3), kit.Select("", arg, 4))
}
@ -165,11 +170,11 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
INPUTS: {Name: "inputs key sub type field value", Help: "补全", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
switch arg[2] {
case ZONE: // inputs key sub type zone field value
_list_inputs(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), kit.Select(kit.MDB_NAME, arg, 4), kit.Select("", arg, 5))
_list_inputs(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), kit.Select(NAME, arg, 4), kit.Select("", arg, 5))
case HASH:
_hash_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(kit.MDB_NAME, arg, 3), kit.Select("", arg, 4))
_hash_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
case LIST:
_list_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(kit.MDB_NAME, arg, 3), kit.Select("", arg, 4))
_list_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
}
}},
PRUNES: {Name: "prunes key sub type [field value]...", Help: "清理", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

6
base/mdb/plugin.go
View File

@ -10,7 +10,7 @@ const PLUGIN = "plugin"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
PLUGIN: {Name: "plugin", Help: "插件", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
SHORT, TYPE, FIELD, "time,type,name,text",
)},
}, Commands: map[string]*ice.Command{
PLUGIN: {Name: "plugin type name text auto", Help: "插件", Action: map[string]*ice.Action{
@ -20,12 +20,12 @@ func init() {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 1 {
m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
m.Cmdy(kit.Keys(value[TEXT], value[NAME]),
m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
})
}
if HashSelect(m, arg...); len(arg) == 0 {
m.Sort(kit.MDB_TYPE)
m.Sort(TYPE)
}
}},
}})

6
base/mdb/render.go
View File

@ -10,7 +10,7 @@ const RENDER = "render"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
RENDER: {Name: "render", Help: "渲染", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
SHORT, TYPE, FIELD, "time,type,name,text",
)},
}, Commands: map[string]*ice.Command{
RENDER: {Name: "render type name text auto", Help: "渲染", Action: map[string]*ice.Action{
@ -20,12 +20,12 @@ func init() {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 1 {
m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
m.Cmdy(kit.Keys(value[TEXT], value[NAME]),
m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
})
}
if HashSelect(m, arg...); len(arg) == 0 {
m.Sort(kit.MDB_TYPE)
m.Sort(TYPE)
}
}},
}})

6
base/mdb/search.go
View File

@ -10,7 +10,7 @@ const SEARCH = "search"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SEARCH: {Name: "search", Help: "搜索", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
SHORT, TYPE, FIELD, "time,type,name,text",
)},
}, Commands: map[string]*ice.Command{
SEARCH: {Name: "search type word text auto", Help: "搜索", Action: map[string]*ice.Action{
@ -22,12 +22,12 @@ func init() {
if len(arg) > 1 {
msg.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
m.OptionFields(kit.Select("ctx,cmd,type,name,text", kit.Select(m.OptionFields(), arg, 2)))
m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2))
m.Cmdy(kit.Keys(value[TEXT], value[NAME]), m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2))
})
}
if HashSelect(msg, arg...); len(arg) == 0 {
m.Copy(msg)
m.Sort(kit.MDB_TYPE)
m.Sort(TYPE)
} else if len(arg) == 1 {
m.Copy(msg)
}

40
base/mdb/zone.go
View File

@ -15,12 +15,12 @@ func _zone_fields(m *ice.Message) []string {
}
func _zone_select(m *ice.Message, prefix, chain, zone string, id string) {
if zone == RANDOM {
zone = kit.MDB_RANDOMS
zone = RANDOMS
}
fields := _zone_fields(m)
cb := m.Optionv(kit.Keycb(SELECT))
m.Richs(prefix, chain, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Richs(prefix, chain, kit.Select(FOREACH, zone), func(key string, val map[string]interface{}) {
if val = kit.GetMeta(val); zone == "" {
if m.OptionFields() == DETAIL {
m.Push(DETAIL, val)
@ -30,7 +30,7 @@ func _zone_select(m *ice.Message, prefix, chain, zone string, id string) {
return
}
m.Grows(prefix, kit.Keys(chain, kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Grows(prefix, kit.Keys(chain, HASH, key), ID, id, func(index int, value map[string]interface{}) {
switch value = kit.GetMeta(value); cb := cb.(type) {
case func(string, []string, map[string]interface{}, map[string]interface{}):
cb(key, fields, value, val)
@ -57,14 +57,14 @@ func _zone_export(m *ice.Message, prefix, chain, file string) {
defer w.Flush()
fields := _zone_fields(m)
fields = append(fields, kit.MDB_EXTRA)
fields = append(fields, EXTRA)
w.Write(fields)
count := 0
m.Richs(prefix, chain, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Richs(prefix, chain, FOREACH, func(key string, val map[string]interface{}) {
val = kit.GetMeta(val)
m.Grows(prefix, kit.Keys(chain, kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Grows(prefix, kit.Keys(chain, HASH, key), "", "", func(index int, value map[string]interface{}) {
value = kit.GetMeta(value)
list := []string{}
@ -76,8 +76,8 @@ func _zone_export(m *ice.Message, prefix, chain, file string) {
})
})
m.Log_EXPORT(kit.MDB_KEY, path.Join(prefix, chain), kit.MDB_FILE, p, kit.MDB_COUNT, count)
m.Conf(prefix, kit.Keys(chain, kit.MDB_HASH), "")
m.Log_EXPORT(KEY, path.Join(prefix, chain), FILE, p, COUNT, count)
m.Conf(prefix, kit.Keys(chain, HASH), "")
m.Echo(p)
}
func _zone_import(m *ice.Message, prefix, chain, file string) {
@ -104,9 +104,9 @@ func _zone_import(m *ice.Message, prefix, chain, file string) {
switch k {
case zkey:
zone = line[i]
case kit.MDB_ID:
case ID:
continue
case kit.MDB_EXTRA:
case EXTRA:
kit.Value(data, k, kit.UnMarshal(line[i]))
default:
kit.Value(data, k, line[i])
@ -116,18 +116,18 @@ func _zone_import(m *ice.Message, prefix, chain, file string) {
list[zone] = m.Rich(prefix, chain, kit.Data(zkey, zone))
}
m.Grow(prefix, kit.Keys(chain, kit.MDB_HASH, list[zone]), data)
m.Grow(prefix, kit.Keys(chain, HASH, list[zone]), data)
count++
}
m.Log_IMPORT(kit.MDB_KEY, path.Join(prefix, chain), kit.MDB_COUNT, count)
m.Log_IMPORT(KEY, path.Join(prefix, chain), COUNT, count)
m.Echo("%d", count)
}
const ZONE = "zone"
func ZoneAction(fields ...string) map[string]*ice.Action {
_zone := func(m *ice.Message) string { return kit.Select(kit.MDB_ZONE, m.Config(kit.MDB_SHORT)) }
_zone := func(m *ice.Message) string { return kit.Select(ZONE, m.Config(SHORT)) }
return ice.SelectAction(map[string]*ice.Action{
INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
@ -139,7 +139,7 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
case ice.CTX:
m.Cmdy("context")
case ice.CMD:
m.Cmdy("context", kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(kit.MDB_EXTRA, ice.CTX))), "command")
m.Cmdy("context", kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(EXTRA, ice.CTX))), "command")
case ice.ARG:
case _zone(m):
@ -156,17 +156,17 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
}},
INSERT: {Name: "insert zone type=go name=hi text=hello", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 {
arg = m.OptionSimple(_zone(m), m.Config(kit.MDB_FIELD))
arg = m.OptionSimple(_zone(m), m.Config(FIELD))
}
m.Cmdy(INSERT, m.PrefixKey(), "", HASH, _zone(m), arg[1])
m.Cmdy(INSERT, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), arg[2:])
}},
MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(MODIFY, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), m.Option(kit.MDB_ID), arg)
m.Cmdy(MODIFY, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), m.Option(ID), arg)
}},
EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Option(ice.CACHE_LIMIT, "-1")
m.OptionFields(_zone(m), m.Config(kit.MDB_FIELD))
m.OptionFields(_zone(m), m.Config(FIELD))
m.Cmdy(EXPORT, m.PrefixKey(), "", ZONE)
}},
IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
@ -174,7 +174,7 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
m.Cmdy(IMPORT, m.PrefixKey(), "", ZONE)
}},
PLUGIN: {Name: "plugin extra.pod extra.ctx extra.cmd extra.arg", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(MODIFY, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), m.Option(kit.MDB_ID), arg)
m.Cmdy(MODIFY, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), m.Option(ID), arg)
}},
PREV: {Name: "prev", Help: "上一页", Hand: func(m *ice.Message, arg ...string) {
PrevPage(m, arg[0], arg[1:]...)
@ -185,9 +185,9 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
}, fields...)
}
func ZoneSelect(m *ice.Message, arg ...string) *ice.Message {
m.Fields(len(arg), kit.Fields(kit.MDB_TIME, m.Config(kit.MDB_SHORT), kit.MDB_COUNT), m.Config(kit.MDB_FIELD))
m.Fields(len(arg), kit.Fields(TIME, m.Config(SHORT), COUNT), m.Config(FIELD))
if m.Cmdy(SELECT, m.PrefixKey(), "", ZONE, arg); kit.Select("", arg, 0) == "" {
m.Sort(m.Config(kit.MDB_SHORT))
m.Sort(m.Config(SHORT))
m.PushAction(REMOVE)
}
return m

2
base/nfs/cat.go
View File

@ -145,7 +145,7 @@ func init() {
}, Commands: map[string]*ice.Command{
CAT: {Name: "cat path auto", Help: "文件", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.RENDER, mdb.CREATE, CAT, m.PrefixKey())
m.Cmd(mdb.RENDER, mdb.CREATE, m.CommandKey(), m.PrefixKey())
}},
mdb.RENDER: {Name: "render type name text", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
_cat_list(m, path.Join(arg[2], arg[1]))

4
base/nfs/dir.go
View File

@ -196,8 +196,8 @@ func init() {
}, Commands: map[string]*ice.Command{
DIR: {Name: "dir path field... auto upload", Help: "目录", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, DIR, m.PrefixKey())
m.Cmd(mdb.RENDER, mdb.CREATE, DIR, m.PrefixKey())
m.Cmd(mdb.SEARCH, mdb.CREATE, m.CommandKey(), m.PrefixKey())
m.Cmd(mdb.RENDER, mdb.CREATE, m.CommandKey(), m.PrefixKey())
}},
mdb.SEARCH: {Name: "search type name", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == mdb.FOREACH {

51
base/ssh/scripts.go
View File

@ -11,7 +11,6 @@ import (
"time"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
@ -64,9 +63,9 @@ func (f *Frame) prompt(m *ice.Message, list ...string) *Frame {
fmt.Fprintf(f.stdout, "\r")
for _, v := range list {
switch v {
case kit.MDB_COUNT:
case mdb.COUNT:
fmt.Fprintf(f.stdout, "%d", f.count)
case kit.MDB_TIME:
case mdb.TIME:
fmt.Fprintf(f.stdout, time.Now().Format("15:04:05"))
case TARGET:
fmt.Fprintf(f.stdout, f.target.Name)
@ -76,12 +75,8 @@ func (f *Frame) prompt(m *ice.Message, list ...string) *Frame {
}
return f
}
func (f *Frame) printf(m *ice.Message, res string, arg ...interface{}) *Frame {
if len(arg) > 0 {
fmt.Fprintf(f.stdout, res, arg...)
} else {
fmt.Fprint(f.stdout, res)
}
func (f *Frame) printf(m *ice.Message, str string, arg ...interface{}) *Frame {
fmt.Fprint(f.stdout, kit.Format(str, arg...))
return f
}
func (f *Frame) change(m *ice.Message, ls []string) []string {
@ -104,30 +99,28 @@ func (f *Frame) change(m *ice.Message, ls []string) []string {
return ls
}
func (f *Frame) alias(m *ice.Message, ls []string) []string {
if alias, ok := m.Optionv(ice.MSG_ALIAS).(map[string]interface{}); ok {
if len(ls) > 0 {
if a := kit.Simple(alias[ls[0]]); len(a) > 0 {
ls = append(append([]string{}, a...), ls[1:]...)
}
}
if len(ls) == 0 {
return ls
}
if alias := kit.Simple(kit.Value(m.Optionv(ice.MSG_ALIAS), ls[0])); len(alias) > 0 {
ls = append(alias, ls[1:]...)
}
return ls
}
func (f *Frame) parse(m *ice.Message, line string) string {
for _, one := range kit.Split(line, ";", ";", ";") {
msg := m.Spawn(f.target)
ls := f.change(msg, f.alias(msg, kit.Split(strings.TrimSpace(one))))
if len(ls) == 0 {
continue
}
if msg.Cmdy(ls[0], ls[1:]); msg.Result(1) == ice.ErrNotFound {
msg.Set(ice.MSG_RESULT).Cmdy(cli.SYSTEM, ls)
msg.Render("", kit.List())
if msg.Cmdy(ls[0], ls[1:]); m.IsErrNotFound() {
msg.SetResult().Cmdy(cli.SYSTEM, ls)
}
_args, _ := msg.Optionv(ice.MSG_ARGS).([]interface{})
f.res = Render(msg, msg.Option(ice.MSG_OUTPUT), _args...)
f.res = Render(msg, msg.Option(ice.MSG_OUTPUT), msg.Optionv(ice.MSG_ARGS).([]interface{})...)
}
return ""
}
@ -144,7 +137,7 @@ func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
continue // 空行
}
m.Cmdx(mdb.INSERT, SOURCE, kit.Keys(kit.MDB_HASH, h), mdb.LIST, kit.MDB_TEXT, bio.Text())
m.Cmdx(mdb.INSERT, SOURCE, kit.Keys(mdb.HASH, h), mdb.LIST, mdb.TEXT, bio.Text())
f.count++
if len(bio.Text()) == 0 {
@ -198,13 +191,12 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
f.stdin, f.stdout = r, os.Stdout
f.pipe = w
aaa.UserRoot(m)
m.Option(ice.MSG_OPTS, ice.MSG_USERNAME)
m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_NAME)), STDIO)
m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_TIME)), m.Time())
m.Conf(SOURCE, kit.Keys(mdb.HASH, STDIO, kit.Keym(mdb.NAME)), STDIO)
m.Conf(SOURCE, kit.Keys(mdb.HASH, STDIO, kit.Keym(mdb.TIME)), m.Time())
f.count = kit.Int(m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_COUNT)))) + 1
f.count = kit.Int(m.Conf(SOURCE, kit.Keys(mdb.HASH, STDIO, kit.Keym(mdb.COUNT)))) + 1
f.scan(m, STDIO, "")
default: // 脚本文件
@ -224,7 +216,7 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
}
f.count = 1
f.scan(m, m.Cmdx(mdb.INSERT, SOURCE, "", mdb.HASH, kit.MDB_NAME, f.source), "")
f.scan(m, m.Cmdx(mdb.INSERT, SOURCE, "", mdb.HASH, mdb.NAME, f.source), "")
}
return true
}
@ -256,13 +248,14 @@ func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SOURCE: {Name: SOURCE, Help: "加载脚本", Value: kit.Data()},
PROMPT: {Name: PROMPT, Help: "命令提示", Value: kit.Data(
PS1, []interface{}{"\033[33;44m", kit.MDB_COUNT, "[", kit.MDB_TIME, "]", "\033[5m", TARGET, "\033[0m", "\033[44m", ">", "\033[0m ", "\033[?25h", "\033[32m"},
PS2, []interface{}{kit.MDB_COUNT, " ", TARGET, "> "},
PS1, []interface{}{"\033[33;44m", mdb.COUNT, "[", mdb.TIME, "]", "\033[5m", TARGET, "\033[0m", "\033[44m", ">", "\033[0m ", "\033[?25h", "\033[32m"},
PS2, []interface{}{mdb.COUNT, " ", TARGET, "> "},
)},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
SOURCE: {Name: "source file", Help: "脚本解析", Action: ice.MergeAction(map[string]*ice.Action{
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SCREEN, m.Option(kit.MDB_TEXT))
m.Cmdy(SCREEN, m.Option(mdb.TEXT))
m.ProcessInner()
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

40
base/web/cache.go
View File

@ -29,23 +29,23 @@ func _cache_save(m *ice.Message, kind, name, text string, arg ...string) { // fi
file := kit.Select("", arg, 0)
text = kit.Select(file, text)
h := m.Cmdx(mdb.INSERT, CACHE, "", mdb.HASH,
kit.MDB_TYPE, kind, kit.MDB_NAME, name, kit.MDB_TEXT, text,
nfs.FILE, file, kit.MDB_SIZE, size)
mdb.TYPE, kind, mdb.NAME, name, mdb.TEXT, text,
nfs.FILE, file, nfs.SIZE, size)
// 返回结果
m.Push(kit.MDB_TIME, m.Time())
m.Push(kit.MDB_TYPE, kind)
m.Push(kit.MDB_NAME, name)
m.Push(kit.MDB_TEXT, text)
m.Push(kit.MDB_SIZE, size)
m.Push(mdb.TIME, m.Time())
m.Push(mdb.TYPE, kind)
m.Push(mdb.NAME, name)
m.Push(mdb.TEXT, text)
m.Push(nfs.SIZE, size)
m.Push(nfs.FILE, file)
m.Push(kit.MDB_HASH, h)
m.Push(mdb.HASH, h)
m.Push(DATA, h)
}
func _cache_watch(m *ice.Message, key, file string) {
mdb.HashSelect(m.Spawn(), key).Table(func(index int, value map[string]string, head []string) {
if value[nfs.FILE] == "" {
m.Cmdy(nfs.SAVE, file, value[kit.MDB_TEXT])
m.Cmdy(nfs.SAVE, file, value[mdb.TEXT])
} else {
m.Cmdy(nfs.LINK, file, value[nfs.FILE])
}
@ -72,7 +72,7 @@ func _cache_upload(m *ice.Message, r *http.Request) (kind, name, file, size stri
// 导入数据
buf.Seek(0, os.SEEK_SET)
if n, e := io.Copy(f, buf); m.Assert(e) {
m.Log_IMPORT(nfs.FILE, p, kit.MDB_SIZE, kit.FmtSize(int64(n)))
m.Log_IMPORT(nfs.FILE, p, nfs.SIZE, kit.FmtSize(int64(n)))
return h.Header.Get(ContentType), h.Filename, p, kit.Format(n)
}
}
@ -93,17 +93,19 @@ func _cache_download(m *ice.Message, r *http.Response) (file, size string) {
s := size * 100 / total
switch cb := m.OptionCB(SPIDE).(type) {
case func(int, int, int):
cb(size, total, s)
case func(int, int):
cb(size, total)
case []string:
m.Richs(cb[0], cb[1], cb[2], func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
value[kit.MDB_STEP], value[kit.MDB_SIZE], value[kit.MDB_TOTAL] = kit.Format(s), size, total
value[mdb.VALUE], value[mdb.COUNT], value[mdb.TOTAL] = kit.Format(s), size, total
})
default:
if s != step && s%10 == 0 {
m.Log_IMPORT(nfs.FILE, p, kit.MDB_STEP, s,
kit.MDB_SIZE, kit.FmtSize(int64(size)), kit.MDB_TOTAL, kit.FmtSize(int64(total)))
m.Log_IMPORT(nfs.FILE, p, mdb.VALUE, s,
mdb.COUNT, kit.FmtSize(int64(size)), mdb.TOTAL, kit.FmtSize(int64(total)))
}
}
step = s
@ -117,7 +119,7 @@ func _cache_download(m *ice.Message, r *http.Response) (file, size string) {
if f, e := os.Open(p); m.Assert(e) {
defer f.Close()
m.Log_IMPORT(nfs.FILE, p, kit.MDB_SIZE, kit.FmtSize(int64(size)))
m.Log_IMPORT(nfs.FILE, p, nfs.SIZE, kit.FmtSize(int64(size)))
c := _cache_name(m, kit.Hashs(f))
m.Cmd(nfs.LINK, c, p)
return c, kit.Format(size)
@ -138,15 +140,15 @@ const CACHE = "cache"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CACHE: {Name: CACHE, Help: "缓存池", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_FIELD, "time,hash,size,type,name,text",
mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,hash,size,type,name,text",
kit.MDB_STORE, ice.VAR_DATA, nfs.PATH, ice.VAR_FILE, kit.MDB_FSIZE, "200000",
kit.MDB_LIMIT, "50", kit.MDB_LEAST, "30",
mdb.LIMIT, "50", kit.MDB_LEAST, "30",
)},
}, Commands: map[string]*ice.Command{
"/cache/": {Name: "/cache/", Help: "缓存池", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Richs(CACHE, nil, arg[0], func(key string, value map[string]interface{}) {
if kit.Format(value[nfs.FILE]) == "" {
m.RenderResult(value[kit.MDB_TEXT])
m.RenderResult(value[mdb.TEXT])
} else {
m.RenderDownload(value[nfs.FILE])
}
@ -179,9 +181,9 @@ func init() {
}
if m.Append(nfs.FILE) == "" {
m.PushScript("inner", m.Append(kit.MDB_TEXT))
m.PushScript("inner", m.Append(mdb.TEXT))
} else {
m.PushDownload(m.Append(kit.MDB_NAME), m.MergeURL2("/share/cache/"+arg[0]))
m.PushDownload(m.Append(mdb.NAME), m.MergeURL2("/share/cache/"+arg[0]))
}
}},
}})

48
base/web/share.go
View File

@ -32,7 +32,7 @@ func _share_repos(m *ice.Message, repos string, arg ...string) {
func _share_proxy(m *ice.Message) {
switch p := path.Join(ice.VAR_PROXY, m.Option(ice.POD), m.Option(nfs.PATH)); m.R.Method {
case http.MethodGet: // 下发文件
m.RenderDownload(path.Join(p, m.Option(kit.MDB_NAME)))
m.RenderDownload(path.Join(p, m.Option(mdb.NAME)))
case http.MethodPost: // 上传文件
m.Cmdy(CACHE, UPLOAD)
@ -43,7 +43,7 @@ func _share_proxy(m *ice.Message) {
func _share_cache(m *ice.Message, arg ...string) {
if pod := m.Option(ice.POD); m.PodCmd(CACHE, arg[0]) {
if m.Append(nfs.FILE) == "" {
m.RenderResult(m.Append(kit.MDB_TEXT))
m.RenderResult(m.Append(mdb.TEXT))
} else {
m.Option(ice.POD, pod)
_share_local(m, m.Append(nfs.FILE))
@ -51,7 +51,7 @@ func _share_cache(m *ice.Message, arg ...string) {
return
}
msg := m.Cmd(CACHE, arg[0])
m.RenderDownload(msg.Append(nfs.FILE), msg.Append(kit.MDB_TYPE), msg.Append(kit.MDB_NAME))
m.RenderDownload(msg.Append(nfs.FILE), msg.Append(mdb.TYPE), msg.Append(mdb.NAME))
}
func _share_local(m *ice.Message, arg ...string) {
p := path.Join(arg...)
@ -103,34 +103,34 @@ const SHARE = "share"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SHARE: {Name: SHARE, Help: "共享链", Value: kit.Data(
kit.MDB_EXPIRE, "72h", kit.MDB_FIELD, "time,hash,userrole,username,river,storm,type,name,text",
mdb.EXPIRE, "72h", mdb.FIELD, "time,hash,userrole,username,river,storm,type,name,text",
)},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
ice.AddRender(ice.RENDER_DOWNLOAD, func(msg *ice.Message, cmd string, args ...interface{}) string {
list := []string{}
if msg.Option(ice.MSG_USERPOD) != "" {
list = append(list, ice.POD, msg.Option(ice.MSG_USERPOD))
}
arg := kit.Simple(args...)
if len(arg) > 1 {
list = append(list, "filename", arg[0])
}
return fmt.Sprintf(`<a href="%s" download="%s">%s</a>`,
_share_link(msg, kit.Select(arg[0], arg, 1), list), path.Base(arg[0]), arg[0])
})
}},
SHARE: {Name: "share hash auto prunes", Help: "共享链", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
ice.AddRender(ice.RENDER_DOWNLOAD, func(msg *ice.Message, cmd string, args ...interface{}) string {
list := []string{}
if msg.Option(ice.MSG_USERPOD) != "" {
list = append(list, ice.POD, msg.Option(ice.MSG_USERPOD))
}
arg := kit.Simple(args...)
if len(arg) > 1 {
list = append(list, "filename", arg[0])
}
return fmt.Sprintf(`<a href="%s" download="%s">%s</a>`,
_share_link(msg, kit.Select(arg[0], arg, 1), list), path.Base(arg[0]), arg[0])
})
}},
mdb.CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.PrefixKey(), "", mdb.HASH, kit.MDB_TIME, m.Time(m.Config(kit.MDB_EXPIRE)),
m.Cmdy(mdb.INSERT, m.PrefixKey(), "", mdb.HASH, mdb.TIME, m.Time(m.Config(mdb.EXPIRE)),
aaa.USERROLE, m.Option(ice.MSG_USERROLE), aaa.USERNAME, m.Option(ice.MSG_USERNAME), aaa.USERNICK, m.Option(ice.MSG_USERNICK),
RIVER, m.Option(ice.MSG_RIVER), STORM, m.Option(ice.MSG_STORM), arg)
m.Option(kit.MDB_LINK, _share_link(m, "/share/"+m.Result()))
m.Option(mdb.LINK, _share_link(m, "/share/"+m.Result()))
}},
LOGIN: {Name: "login userrole=void,tech username", Help: "登录", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(SHARE, mdb.CREATE, kit.MDB_TYPE, LOGIN, m.OptionSimple(aaa.USERROLE, aaa.USERNAME))
m.EchoQRCode(msg.Option(kit.MDB_LINK))
msg := m.Cmd(SHARE, mdb.CREATE, mdb.TYPE, LOGIN, m.OptionSimple(aaa.USERROLE, aaa.USERNAME))
m.EchoQRCode(msg.Option(mdb.LINK))
m.ProcessInner()
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -152,7 +152,7 @@ func init() {
}},
"/share/": {Name: "/share/", Help: "共享链", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(SHARE, kit.Select(m.Option(SHARE), arg, 0))
if msg := m.Cmd(SHARE, m.Option(SHARE)); kit.Int(msg.Append(kit.MDB_TIME)) < kit.Int(msg.FormatTime()) {
if msg := m.Cmd(SHARE, m.Option(SHARE)); kit.Int(msg.Append(mdb.TIME)) < kit.Int(msg.FormatTime()) {
m.RenderResult("共享超时")
return
}

2
base/web/space.go
View File

@ -236,7 +236,7 @@ func init() {
}, Commands: map[string]*ice.Command{
SPACE: {Name: "space name cmd auto invite", Help: "空间站", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, SPACE, m.PrefixKey())
m.Cmd(mdb.SEARCH, mdb.CREATE, m.CommandKey(), m.PrefixKey())
m.Conf(SPACE, mdb.HASH, "")
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {

25
base/web/spide.go
View File

@ -30,10 +30,10 @@ func _spide_create(m *ice.Message, name, address string) {
dir, file := path.Split(uri.EscapedPath())
m.Echo(m.Rich(SPIDE, nil, kit.Dict(
SPIDE_COOKIE, kit.Dict(), SPIDE_HEADER, kit.Dict(), SPIDE_CLIENT, kit.Dict(
kit.MDB_NAME, name, SPIDE_METHOD, SPIDE_POST, "url", address,
mdb.NAME, name, SPIDE_METHOD, SPIDE_POST, "url", address,
tcp.PROTOCOL, uri.Scheme, tcp.HOSTNAME, uri.Host,
nfs.PATH, dir, nfs.FILE, file, "query", uri.RawQuery,
kit.MDB_TIMEOUT, "600s", LOGHEADERS, ice.FALSE,
cli.TIMEOUT, "600s", LOGHEADERS, ice.FALSE,
),
)))
}
@ -85,7 +85,7 @@ func _spide_list(m *ice.Message, arg ...string) {
_spide_head(m, req, head, value)
// 发送请求
res, e := _spide_send(m, req, kit.Format(client[kit.MDB_TIMEOUT]))
res, e := _spide_send(m, req, kit.Format(client[cli.TIMEOUT]))
if m.Warn(e, ice.ErrNotFound, uri) {
return
}
@ -98,7 +98,7 @@ func _spide_list(m *ice.Message, arg ...string) {
// 检查结果
defer res.Body.Close()
m.Cost(kit.MDB_STATUS, res.Status, kit.MDB_SIZE, res.Header.Get(ContentLength), kit.MDB_TYPE, res.Header.Get(ContentType))
m.Cost(cli.STATUS, res.Status, nfs.SIZE, res.Header.Get(ContentLength), mdb.TYPE, res.Header.Get(ContentType))
// 缓存配置
for _, v := range res.Cookies() {
@ -260,7 +260,7 @@ func _spide_save(m *ice.Message, cache, save, uri string, res *http.Response) {
defer f.Close()
if n, e := io.Copy(f, res.Body); m.Assert(e) {
m.Log_EXPORT(kit.MDB_SIZE, n, nfs.FILE, p)
m.Log_EXPORT(nfs.SIZE, n, nfs.FILE, p)
m.Echo(p)
}
}
@ -331,18 +331,19 @@ const SPIDE = "spide"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SPIDE: {Name: SPIDE, Help: "蜘蛛侠", Value: kit.Data(
kit.MDB_SHORT, CLIENT_NAME, kit.MDB_FIELD, "time,client.name,client.url",
mdb.SHORT, CLIENT_NAME, mdb.FIELD, "time,client.name,client.url",
LOGHEADERS, ice.FALSE,
)},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(SPIDE, mdb.CREATE, ice.OPS, kit.Select("http://:9020", m.Conf(cli.RUNTIME, "conf.ctx_ops")))
m.Cmd(SPIDE, mdb.CREATE, ice.DEV, kit.Select("http://:9020", m.Conf(cli.RUNTIME, "conf.ctx_dev")))
m.Cmd(SPIDE, mdb.CREATE, ice.SHY, kit.Select("https://shylinux.com:443", m.Conf(cli.RUNTIME, "conf.ctx_shy")))
}},
SPIDE: {Name: "spide client.name action=raw,msg,save,cache method=GET,PUT,POST,DELETE url format=form,part,json,data,file arg run:button create", Help: "蜘蛛侠", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
conf := m.Confm(cli.RUNTIME, "conf")
m.Cmd(SPIDE, mdb.CREATE, ice.OPS, kit.Select("http://:9020", conf["ctx_ops"]))
m.Cmd(SPIDE, mdb.CREATE, ice.DEV, kit.Select("http://:9020", conf["ctx_dev"]))
m.Cmd(SPIDE, mdb.CREATE, ice.SHY, kit.Select("https://shylinux.com:443", conf["ctx_shy"]))
}},
mdb.CREATE: {Name: "create name address", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_spide_create(m, m.Option(kit.MDB_NAME), m.Option(ADDRESS))
_spide_create(m, m.Option(mdb.NAME), m.Option(ADDRESS))
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) < 2 || arg[0] == "" || (len(arg) > 3 && arg[3] == "") {

48
base/web/story.go
View File

@ -12,10 +12,10 @@ import (
func _story_list(m *ice.Message, name string, key string) {
if name == "" {
m.Richs(STORY, HEAD, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
m.Push(key, value, []string{kit.MDB_TIME, kit.MDB_COUNT, STORY})
m.Richs(STORY, HEAD, mdb.FOREACH, func(key string, value map[string]interface{}) {
m.Push(key, value, []string{mdb.TIME, mdb.COUNT, STORY})
})
m.SortTimeR(kit.MDB_TIME)
m.SortTimeR(mdb.TIME)
return
}
if key == "" {
@ -45,10 +45,10 @@ func _story_index(m *ice.Message, name string, withdata bool) {
m.Richs(CACHE, nil, name, func(key string, value map[string]interface{}) {
// 查询数据
m.Push(DATA, key)
m.Push(key, value, []string{kit.MDB_TEXT, nfs.FILE, kit.MDB_SIZE, kit.MDB_TIME, kit.MDB_NAME, kit.MDB_TYPE})
m.Push(key, value, []string{mdb.TEXT, nfs.FILE, nfs.SIZE, mdb.TIME, mdb.NAME, mdb.TYPE})
if withdata {
if value[nfs.FILE] == "" {
m.Echo("%s", kit.Format(value[kit.MDB_TEXT]))
m.Echo("%s", kit.Format(value[mdb.TEXT]))
} else {
m.Echo("%s", m.Cmdx(nfs.CAT, value[nfs.FILE]))
}
@ -61,18 +61,18 @@ func _story_history(m *ice.Message, name string) {
for i := 0; i < kit.Int(kit.Select("30", m.Option(ice.CACHE_LIMIT))) && list != ""; i++ {
m.Richs(STORY, nil, list, func(key string, value map[string]interface{}) {
// 直连节点
m.Push(key, value, []string{kit.MDB_TIME, kit.MDB_KEY, kit.MDB_COUNT, SCENE, STORY})
m.Push(key, value, []string{mdb.TIME, mdb.KEY, mdb.COUNT, SCENE, STORY})
m.Richs(CACHE, nil, value[DATA], func(key string, value map[string]interface{}) {
m.Push(DRAMA, value[kit.MDB_TEXT])
m.Push(DRAMA, value[mdb.TEXT])
m.Push(DATA, key)
})
kit.Fetch(value[LIST], func(key string, val string) {
m.Richs(STORY, nil, val, func(key string, value map[string]interface{}) {
// 复合节点
m.Push(key, value, []string{kit.MDB_TIME, kit.MDB_KEY, kit.MDB_COUNT, SCENE, STORY})
m.Push(key, value, []string{mdb.TIME, mdb.KEY, mdb.COUNT, SCENE, STORY})
m.Richs(CACHE, nil, value[DATA], func(key string, value map[string]interface{}) {
m.Push(DRAMA, value[kit.MDB_TEXT])
m.Push(DRAMA, value[mdb.TEXT])
m.Push(DATA, key)
})
})
@ -87,19 +87,19 @@ func _story_write(m *ice.Message, scene, name, text string, arg ...string) {
if len(arg) < 1 || text == "" || m.Richs(CACHE, nil, text, func(key string, value map[string]interface{}) { text = key }) == nil {
// 添加缓存
m.Cmdy(CACHE, CATCH, scene, name, text, arg)
scene, name, text = m.Append(kit.MDB_TYPE), m.Append(kit.MDB_NAME), m.Append(DATA)
scene, name, text = m.Append(mdb.TYPE), m.Append(mdb.NAME), m.Append(DATA)
}
// 查询索引
head, prev, value, count := "", "", kit.Dict(), 0
m.Richs(STORY, HEAD, name, func(key string, val map[string]interface{}) {
head, prev, value, count = key, kit.Format(val[LIST]), val, kit.Int(val[kit.MDB_COUNT])
m.Logs("info", HEAD, head, PREV, prev, kit.MDB_COUNT, count)
head, prev, value, count = key, kit.Format(val[LIST]), val, kit.Int(val[mdb.COUNT])
m.Logs("info", HEAD, head, PREV, prev, mdb.COUNT, count)
})
if last := m.Richs(STORY, nil, prev, nil); prev != "" && last != nil && last[DATA] == text {
// 重复提交
m.Push(prev, last, []string{kit.MDB_TIME, kit.MDB_COUNT, kit.MDB_KEY})
m.Push(prev, last, []string{mdb.TIME, mdb.COUNT, mdb.KEY})
m.Logs("info", "file", "exists")
m.Echo(prev)
return
@ -107,28 +107,28 @@ func _story_write(m *ice.Message, scene, name, text string, arg ...string) {
// 添加节点
list := m.Rich(STORY, nil, kit.Dict(
SCENE, scene, STORY, name, kit.MDB_COUNT, count+1, DATA, text, PREV, prev,
SCENE, scene, STORY, name, mdb.COUNT, count+1, DATA, text, PREV, prev,
))
m.Log_CREATE(STORY, list, kit.MDB_TYPE, scene, kit.MDB_NAME, name)
m.Push(kit.MDB_COUNT, count+1)
m.Push(kit.MDB_KEY, list)
m.Log_CREATE(STORY, list, mdb.TYPE, scene, mdb.NAME, name)
m.Push(mdb.COUNT, count+1)
m.Push(mdb.KEY, list)
if head == "" {
// 添加索引
m.Rich(STORY, HEAD, kit.Dict(SCENE, scene, STORY, name, kit.MDB_COUNT, count+1, LIST, list))
m.Rich(STORY, HEAD, kit.Dict(SCENE, scene, STORY, name, mdb.COUNT, count+1, LIST, list))
} else {
// 更新索引
value[kit.MDB_COUNT] = count + 1
value[kit.MDB_TIME] = m.Time()
value[mdb.COUNT] = count + 1
value[mdb.TIME] = m.Time()
value[LIST] = list
}
m.Echo(list)
}
func _story_catch(m *ice.Message, scene, name string, arg ...string) {
if last := m.Richs(STORY, HEAD, name, nil); last != nil {
if t, e := time.ParseInLocation(ice.MOD_TIME, kit.Format(last[kit.MDB_TIME]), time.Local); e == nil {
if t, e := time.ParseInLocation(ice.MOD_TIME, kit.Format(last[mdb.TIME]), time.Local); e == nil {
if s, e := os.Stat(name); e == nil && s.ModTime().Before(t) {
m.Push(name, last, []string{kit.MDB_TIME, kit.MDB_COUNT, kit.MDB_KEY})
m.Push(name, last, []string{mdb.TIME, mdb.COUNT, mdb.KEY})
m.Logs("info", "file", "exists")
m.Echo("%s", last[LIST])
// 重复提交
@ -165,8 +165,8 @@ func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
STORY: {Name: "story", Help: "故事会", Value: kit.Dict(
kit.MDB_META, kit.Dict(kit.MDB_SHORT, DATA),
HEAD, kit.Data(kit.MDB_SHORT, STORY),
mdb.META, kit.Dict(mdb.SHORT, DATA),
HEAD, kit.Data(mdb.SHORT, STORY),
)},
},
Commands: map[string]*ice.Command{

14
base/web/web.go
View File

@ -42,20 +42,20 @@ func (web *Frame) Start(m *ice.Message, arg ...string) bool {
}
frame.ServeMux = http.NewServeMux()
// 静态路由
msg := m.Spawn(s)
m.Confm(SERVE, kit.Keym(nfs.PATH), func(key string, value string) {
m.Log(ROUTE, "%s <- %s <- %s", s.Name, key, value)
frame.Handle(key, http.StripPrefix(key, http.FileServer(http.Dir(value))))
})
// 级联路由
msg := m.Spawn(s)
if pframe, ok := p.Server().(*Frame); ok && pframe.ServeMux != nil {
route := ice.PS + s.Name + ice.PS
msg.Log(ROUTE, "%s <= %s", p.Name, route)
pframe.Handle(route, http.StripPrefix(path.Dir(route), frame))
}
// 静态路由
m.Confm(SERVE, kit.Keym(nfs.PATH), func(key string, value string) {
m.Log(ROUTE, "%s <- %s <- %s", s.Name, key, value)
frame.Handle(key, http.StripPrefix(key, http.FileServer(http.Dir(value))))
})
// 命令路由
m.Travel(func(p *ice.Context, sub *ice.Context, k string, x *ice.Command) {
if s != sub || k[0] != '/' {

30
base/yac/matrix.go
View File

@ -310,18 +310,18 @@ func (mat *Matrix) show(m *ice.Message) {
}
func _yac_load(m *ice.Message) {
m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", mdb.FOREACH, func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("32", value[NCELL])))
m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Grows(m.Prefix(MATRIX), kit.Keys(mdb.HASH, key), "", "", func(index int, value map[string]interface{}) {
page := mat.index(m, NPAGE, kit.Format(value[NPAGE]))
hash := mat.index(m, NHASH, kit.Format(value[NHASH]))
if mat.mat[page] == nil {
mat.mat[page] = make([]*State, mat.ncell)
}
mat.train(m, page, hash, kit.Simple(value[kit.MDB_TEXT]), 1)
mat.train(m, page, hash, kit.Simple(value[mdb.TEXT]), 1)
})
value[MATRIX] = mat
})
@ -345,7 +345,7 @@ const MATRIX = "matrix"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
MATRIX: {Name: MATRIX, Help: "魔方矩阵", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
MATRIX: {Name: MATRIX, Help: "魔方矩阵", Value: kit.Data(mdb.SHORT, mdb.NAME)},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
_yac_load(m)
@ -354,7 +354,7 @@ func init() {
mdb.CREATE: {Name: "create name=shy nlang=32 ncell=32", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
mat := NewMatrix(m, kit.Int(kit.Select("32", m.Option(NLANG))), kit.Int(kit.Select("32", m.Option(NCELL))))
h := m.Rich(m.Prefix(MATRIX), "", kit.Data(
kit.MDB_TIME, m.Time(), kit.MDB_NAME, m.Option(kit.MDB_NAME),
mdb.TIME, m.Time(), mdb.NAME, m.Option(mdb.NAME),
MATRIX, mat, NLANG, mat.nlang, NCELL, mat.ncell,
))
switch cb := m.Optionv(kit.Keycb(MATRIX)).(type) {
@ -364,7 +364,7 @@ func init() {
m.Echo(h)
}},
mdb.INSERT: {Name: "insert name=shy npage=num nhash=num text=123", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_NAME), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", m.Option(mdb.NAME), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat, _ := value[MATRIX].(*Matrix)
@ -375,11 +375,11 @@ func init() {
mat.mat[page] = make([]*State, mat.ncell)
}
m.Option(kit.MDB_TEXT, strings.ReplaceAll(m.Option(kit.MDB_TEXT), "\\", "\\\\"))
text := kit.Split(m.Option(kit.MDB_TEXT), " ", " ", " ")
m.Option(mdb.TEXT, strings.ReplaceAll(m.Option(mdb.TEXT), "\\", "\\\\"))
text := kit.Split(m.Option(mdb.TEXT), " ", " ", " ")
mat.train(m, page, hash, text, 1)
m.Grow(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), kit.Dict(
kit.MDB_TIME, m.Time(), NPAGE, m.Option(NPAGE), NHASH, m.Option(NHASH), kit.MDB_TEXT, text,
m.Grow(m.Prefix(MATRIX), kit.Keys(mdb.HASH, key), kit.Dict(
mdb.TIME, m.Time(), NPAGE, m.Option(NPAGE), NHASH, m.Option(NHASH), mdb.TEXT, text,
))
value[NPAGE] = len(mat.page)
@ -387,14 +387,14 @@ func init() {
})
}},
mdb.REMOVE: {Name: "create", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(MATRIX), "", mdb.HASH, kit.MDB_NAME, m.Option(kit.MDB_NAME))
m.Cmdy(mdb.DELETE, m.Prefix(MATRIX), "", mdb.HASH, mdb.NAME, m.Option(mdb.NAME))
}},
PARSE: {Name: "parse name npage text=123", Help: "解析", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_NAME), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", m.Option(mdb.NAME), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
mat, _ := value[MATRIX].(*Matrix)
for stream := lex.NewStream(bytes.NewBufferString(m.Option(kit.MDB_TEXT))); stream.Scan(); {
for stream := lex.NewStream(bytes.NewBufferString(m.Option(mdb.TEXT))); stream.Scan(); {
hash, _ := mat.Parse(m, func(m *ice.Message, nhash string, hash int, word []string, begin int, stream *lex.Stream) (int, []string) {
switch cb := m.Optionv(kit.Keycb(MATRIX)).(type) {
case func(string, int, []string, int, *lex.Stream) (int, []string):
@ -411,7 +411,7 @@ func init() {
m.ProcessInner()
}},
"show": {Name: "show", Help: "矩阵", Hand: func(m *ice.Message, arg ...string) {
m.Richs(m.Prefix(MATRIX), "", kit.Select(m.Option(kit.MDB_NAME), arg, 0), func(key string, value map[string]interface{}) {
m.Richs(m.Prefix(MATRIX), "", kit.Select(m.Option(mdb.NAME), arg, 0), func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
value[MATRIX].(*Matrix).show(m)
})
@ -428,7 +428,7 @@ func init() {
if m.Action(mdb.INSERT, "show"); len(arg) == 1 { // 词法列表
m.Fields(len(arg[1:]), "time,npage,nhash,text")
m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, kit.Hashs(arg[0])), mdb.LIST)
m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), kit.Keys(mdb.HASH, kit.Hashs(arg[0])), mdb.LIST)
m.PushAction(PARSE)
return
}

12
base/yac/script.go
View File

@ -98,19 +98,19 @@ func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
SCRIPT: {Name: "script name npage text auto create", Help: "脚本解析", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create name=shy text=etc/yac.txt", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(MATRIX, mdb.CREATE, m.Option(kit.MDB_NAME))
if buf, err := ioutil.ReadFile(m.Option(kit.MDB_TEXT)); err == nil {
m.Option(kit.MDB_TEXT, string(buf))
m.Cmd(MATRIX, mdb.CREATE, m.Option(mdb.NAME))
if buf, err := ioutil.ReadFile(m.Option(mdb.TEXT)); err == nil {
m.Option(mdb.TEXT, string(buf))
}
m.Option(kit.MDB_TEXT, strings.ReplaceAll(m.Option(kit.MDB_TEXT), "\\", "\\\\"))
for _, line := range kit.Split(m.Option(kit.MDB_TEXT), "\n", "\n", "\n") {
m.Option(mdb.TEXT, strings.ReplaceAll(m.Option(mdb.TEXT), "\\", "\\\\"))
for _, line := range kit.Split(m.Option(mdb.TEXT), "\n", "\n", "\n") {
if strings.HasPrefix(strings.TrimSpace(line), "#") {
continue
}
line = strings.ReplaceAll(line, "\\", "\\\\")
if list := kit.Split(line, " ", " ", " "); len(list) > 2 {
m.Cmdx(MATRIX, mdb.INSERT, m.Option(kit.MDB_NAME), list[0], list[1], strings.Join(list[2:], " "))
m.Cmdx(MATRIX, mdb.INSERT, m.Option(mdb.NAME), list[0], list[1], strings.Join(list[2:], " "))
}
}
}},

11
conf.go
View File

@ -12,6 +12,10 @@ const (
PWD = "./"
JS = "js"
GO = "go"
SH = "sh"
OK = "ok"
TRUE = "true"
FALSE = "false"
@ -23,6 +27,7 @@ const (
LOAD = "load"
AUTO = "auto"
HELP = "help"
HTTP = "http"
SAVE = "save"
EXIT = "exit"
@ -65,8 +70,9 @@ const ( // REPOS
INTSHELL = "intshell"
CONTEXTS = "contexts"
REQUIRE = "require"
INSTALL = "install"
REQUIRE = "require"
DISPLAY = "display"
PUBLISH = "publish"
RELEASE = "release"
)
@ -86,6 +92,9 @@ const ( // DIR
USR_INSTALL = "usr/install"
USR_PUBLISH = "usr/publish"
PLUGIN_STORY = "/plugin/story"
PLUGIN_LOCAL = "/plugin/local"
FAVICON = "favicon.ico"
PROTO_JS = "proto.js"
FRAME_JS = "frame.js"

28
core/chat/action.go
View File

@ -15,7 +15,7 @@ import (
func _action_right(m *ice.Message, river string, storm string) (ok bool) {
if ok = true; m.Option(ice.MSG_USERROLE) == aaa.VOID {
m.Richs(RIVER, "", river, func(key string, value map[string]interface{}) {
if ok = m.Richs(RIVER, kit.Keys(kit.MDB_HASH, key, OCEAN), m.Option(ice.MSG_USERNAME), nil) != nil; ok {
if ok = m.Richs(RIVER, kit.Keys(mdb.HASH, key, OCEAN), m.Option(ice.MSG_USERNAME), nil) != nil; ok {
m.Log_AUTH(RIVER, river, STORM, storm)
}
})
@ -23,7 +23,7 @@ func _action_right(m *ice.Message, river string, storm string) (ok bool) {
return ok
}
func _action_key(m *ice.Message, arg ...string) string {
return kit.Keys(kit.MDB_HASH, kit.Select(m.Option(RIVER), arg, 0), STORM, kit.MDB_HASH, kit.Select(m.Option(STORM), arg, 1))
return kit.Keys(mdb.HASH, kit.Select(m.Option(RIVER), arg, 0), STORM, mdb.HASH, kit.Select(m.Option(STORM), arg, 1))
}
func _action_list(m *ice.Message, river, storm string) {
m.Cmdy(STORM, storm, ice.Option{ice.MSG_RIVER, river}).Table(func(index int, value map[string]string, head []string) {
@ -35,7 +35,7 @@ func _action_exec(m *ice.Message, river, storm, index string, arg ...string) {
m.Option(ice.MSG_STORM, storm)
cmds := []string{index}
if m.Grows(RIVER, _action_key(m, river, storm), kit.MDB_ID, index, func(index int, value map[string]interface{}) {
if m.Grows(RIVER, _action_key(m, river, storm), mdb.ID, index, func(index int, value map[string]interface{}) {
if cmds = kit.Simple(kit.Keys(value[ice.CTX], value[ice.CMD])); kit.Format(value[ice.POD]) != "" {
m.Option(ice.POD, value[ice.POD]) // 远程节点
}
@ -52,9 +52,9 @@ func _action_exec(m *ice.Message, river, storm, index string, arg ...string) {
}
}
func _action_share(m *ice.Message, arg ...string) {
switch msg := m.Cmd(web.SHARE, arg[0]); msg.Append(kit.MDB_TYPE) {
switch msg := m.Cmd(web.SHARE, arg[0]); msg.Append(mdb.TYPE) {
case web.STORM:
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire, arg) {
if m.Warn(kit.Time() > kit.Time(msg.Append(mdb.TIME)), ice.ErrExpire, arg) {
break // 分享超时
}
if len(arg) == 1 {
@ -77,13 +77,13 @@ func _action_share(m *ice.Message, arg ...string) {
_action_exec(m, msg.Append(web.RIVER), msg.Append(web.STORM), arg[1], arg[2:]...)
case web.FIELD:
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire, arg) {
if m.Warn(kit.Time() > kit.Time(msg.Append(mdb.TIME)), ice.ErrExpire, arg) {
break // 分享超时
}
if arg[0] = msg.Append(kit.MDB_NAME); len(arg) == 1 {
if arg[0] = msg.Append(mdb.NAME); len(arg) == 1 {
m.Push("title", msg.Append(kit.MDB_TITLE))
m.Push("index", msg.Append(kit.MDB_NAME))
m.Push("args", msg.Append(kit.MDB_TEXT))
m.Push("index", msg.Append(mdb.NAME))
m.Push("args", msg.Append(mdb.TEXT))
break // 命令列表
}
@ -115,12 +115,12 @@ func _action_domain(m *ice.Message, cmd string, arg ...string) (domain string) {
river := kit.Select(m.Option(ice.MSG_RIVER), arg, 0)
storm := kit.Select(m.Option(ice.MSG_STORM), arg, 1)
m.Richs(RIVER, "", river, func(key string, value map[string]interface{}) {
switch kit.Value(kit.GetMeta(value), kit.MDB_TYPE) {
switch kit.Value(kit.GetMeta(value), mdb.TYPE) {
case PUBLIC: // 公有群
return
case PROTECTED: // 共有群
m.Richs(RIVER, kit.Keys(kit.MDB_HASH, river, STORM), storm, func(key string, value map[string]interface{}) {
switch r := "R" + river; kit.Value(kit.GetMeta(value), kit.MDB_TYPE) {
m.Richs(RIVER, kit.Keys(mdb.HASH, river, STORM), storm, func(key string, value map[string]interface{}) {
switch r := "R" + river; kit.Value(kit.GetMeta(value), mdb.TYPE) {
case PUBLIC: // 公有组
domain = m.Option(ice.MSG_DOMAIN, kit.Keys(r))
case PROTECTED: // 共有组
@ -139,7 +139,7 @@ func _action_domain(m *ice.Message, cmd string, arg ...string) (domain string) {
}
func _action_upload(m *ice.Message) {
msg := m.Cmd(web.CACHE, web.UPLOAD)
m.Option(ice.MSG_UPLOAD, msg.Append(kit.MDB_HASH), msg.Append(kit.MDB_NAME), msg.Append(kit.MDB_SIZE))
m.Option(ice.MSG_UPLOAD, msg.Append(mdb.HASH), msg.Append(mdb.NAME), msg.Append(nfs.SIZE))
}
const (
@ -179,7 +179,7 @@ func init() {
}
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, _action_key(m), mdb.LIST, m.OptionSimple(kit.MDB_ID), arg)
m.Cmdy(mdb.MODIFY, RIVER, _action_key(m), mdb.LIST, m.OptionSimple(mdb.ID), arg)
}},
SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
_header_share(m, arg...)

14
core/chat/cmd.go
View File

@ -16,17 +16,17 @@ const CMD = "cmd"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CMD: {Name: CMD, Help: "命令", Value: kit.Data(kit.MDB_SHORT, "type", nfs.PATH, ice.PWD)},
CMD: {Name: CMD, Help: "命令", Value: kit.Data(mdb.SHORT, "type", nfs.PATH, ice.PWD)},
}, Commands: map[string]*ice.Command{
"/cmd/": {Name: "/cmd/", Help: "命令", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Name: "_init", Help: "初始化", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(CMD, mdb.CREATE, kit.MDB_TYPE, "shy", kit.MDB_NAME, "web.wiki.word")
m.Cmdy(CMD, mdb.CREATE, kit.MDB_TYPE, "svg", kit.MDB_NAME, "web.wiki.draw")
m.Cmdy(CMD, mdb.CREATE, kit.MDB_TYPE, "csv", kit.MDB_NAME, "web.wiki.data")
m.Cmdy(CMD, mdb.CREATE, kit.MDB_TYPE, "json", kit.MDB_NAME, "web.wiki.json")
m.Cmdy(CMD, mdb.CREATE, mdb.TYPE, "shy", mdb.NAME, "web.wiki.word")
m.Cmdy(CMD, mdb.CREATE, mdb.TYPE, "svg", mdb.NAME, "web.wiki.draw")
m.Cmdy(CMD, mdb.CREATE, mdb.TYPE, "csv", mdb.NAME, "web.wiki.data")
m.Cmdy(CMD, mdb.CREATE, mdb.TYPE, "json", mdb.NAME, "web.wiki.json")
for _, k := range []string{"sh", "go", "js", "mod", "sum"} {
m.Cmdy(CMD, mdb.CREATE, kit.MDB_TYPE, k, kit.MDB_NAME, "web.code.inner")
m.Cmdy(CMD, mdb.CREATE, mdb.TYPE, k, mdb.NAME, "web.code.inner")
}
}},
}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -37,7 +37,7 @@ func init() {
p := path.Join(m.Config(nfs.PATH), path.Join(arg...))
if mdb.HashSelect(m.Spawn(), kit.Ext(m.R.URL.Path)).Table(func(index int, value map[string]string, head []string) {
m.RenderCmd(value[kit.MDB_NAME], p)
m.RenderCmd(value[mdb.NAME], p)
}).Length() > 0 {
return // 插件
}

12
core/chat/div.go
View File

@ -27,8 +27,8 @@ const DIV = "div"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
DIV: {Name: "div", Help: "定制", Value: kit.Data(
kit.MDB_FIELD, "time,hash,type,name,text", nfs.PATH, ice.USR_PUBLISH,
kit.MDB_TEMPLATE, _div_template,
mdb.FIELD, "time,hash,type,name,text", nfs.PATH, ice.USR_PUBLISH,
nfs.TEMPLATE, _div_template,
)},
}, Commands: map[string]*ice.Command{
"/div/": {Name: "/div/", Help: "定制", Action: ice.MergeAction(ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -47,8 +47,8 @@ func init() {
}},
DIV: {Name: "div hash auto import", Help: "定制", Action: ice.MergeAction(map[string]*ice.Action{
lex.SPLIT: {Name: "split name=hi text", Help: "生成", Hand: func(m *ice.Message, arg ...string) {
h := m.Cmdx(DIV, mdb.CREATE, m.OptionSimple(kit.MDB_NAME), kit.MDB_TEXT, _div_parse(m, m.Option(kit.MDB_TEXT)))
m.ProcessRewrite(kit.MDB_HASH, h)
h := m.Cmdx(DIV, mdb.CREATE, m.OptionSimple(mdb.NAME), mdb.TEXT, _div_parse(m, m.Option(mdb.TEXT)))
m.ProcessRewrite(mdb.HASH, h)
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
@ -61,7 +61,7 @@ func init() {
m.Cmd(nfs.DIR, kit.Dict(nfs.DIR_ROOT, m.Option(nfs.PATH)), func(p string) {
switch kit.Ext(p) {
case "shy":
m.Cmd(m.PrefixKey(), lex.SPLIT, kit.MDB_NAME, p, kit.MDB_TEXT, m.Cmdx(nfs.CAT, p))
m.Cmd(m.PrefixKey(), lex.SPLIT, mdb.NAME, p, mdb.TEXT, m.Cmdx(nfs.CAT, p))
}
})
}},
@ -69,7 +69,7 @@ func init() {
switch kit.Ext(kit.Select("", arg, 0)) {
case "shy":
m.Fields(0)
m.Push(kit.MDB_TEXT, _div_parse(m, m.Cmdx(nfs.CAT, arg[0])))
m.Push(mdb.TEXT, _div_parse(m, m.Cmdx(nfs.CAT, arg[0])))
m.DisplayLocal("")
default:
if mdb.HashSelect(m, arg...); len(arg) > 0 {

11
core/chat/files.go
View File

@ -3,6 +3,7 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
)
@ -12,7 +13,7 @@ const FILES = "files"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
FILES: {Name: FILES, Help: "文件夹", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_DATA, kit.MDB_FIELD, "time,hash,type,name,size,data",
mdb.SHORT, mdb.DATA, mdb.FIELD, "time,hash,type,name,size,data",
)},
}, Commands: map[string]*ice.Command{
FILES: {Name: "files hash auto upload", Help: "文件夹", Action: ice.MergeAction(map[string]*ice.Action{
@ -20,15 +21,15 @@ func init() {
up := kit.Simple(m.Optionv(ice.MSG_UPLOAD))
if len(up) < 2 {
msg := m.Cmdy(web.CACHE, web.UPLOAD)
up = kit.Simple(msg.Append(kit.MDB_HASH), msg.Append(kit.MDB_NAME), msg.Append(kit.MDB_SIZE))
up = kit.Simple(msg.Append(mdb.HASH), msg.Append(mdb.NAME), msg.Append(nfs.SIZE))
}
m.Cmdy(mdb.INSERT, m.Prefix(FILES), "", mdb.HASH, kit.MDB_TYPE, kit.Ext(up[1]), kit.MDB_NAME, up[1], kit.MDB_SIZE, up[2], kit.MDB_DATA, up[0])
m.Cmdy(mdb.INSERT, m.Prefix(FILES), "", mdb.HASH, mdb.TYPE, kit.Ext(up[1]), mdb.NAME, up[1], nfs.SIZE, up[2], mdb.DATA, up[0])
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.HashSelect(m, arg...)
m.Table(func(index int, value map[string]string, head []string) {
link := "/share/cache/" + value[kit.MDB_DATA]
if m.PushDownload(kit.MDB_LINK, value[kit.MDB_NAME], link); len(arg) > 0 && kit.ExtIsImage(value[kit.MDB_NAME]) {
link := "/share/cache/" + value[mdb.DATA]
if m.PushDownload(mdb.LINK, value[mdb.NAME], link); len(arg) > 0 && kit.ExtIsImage(value[mdb.NAME]) {
m.PushImages(kit.MDB_IMAGE, link)
}
})

16
core/chat/header.go
View File

@ -22,7 +22,7 @@ func _header_agent(m *ice.Message, arg ...string) {
}
func _header_check(m *ice.Message, arg ...string) {
if m.Option(web.SHARE) != "" {
switch msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) {
switch msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(mdb.TYPE) {
case web.LOGIN:
if m.Option(ice.MSG_USERNAME) != msg.Append(aaa.USERNAME) {
web.RenderCookie(m, aaa.SessCreate(m, m.Option(ice.MSG_USERNAME, msg.Append(aaa.USERNAME))))
@ -49,15 +49,15 @@ func _header_grant(m *ice.Message, arg ...string) {
m.Cmd(web.SPACE, m.Option(web.SPACE), ice.MSG_SESSID, aaa.SessCreate(m, m.Option(ice.MSG_USERNAME)))
}
func _header_share(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_LINK) == "" {
m.Cmdy(web.SHARE, mdb.CREATE, kit.MDB_TYPE, web.LOGIN, arg)
if m.Option(mdb.LINK) == "" {
m.Cmdy(web.SHARE, mdb.CREATE, mdb.TYPE, web.LOGIN, arg)
} else {
m.Option(kit.MDB_LINK, tcp.ReplaceLocalhost(m, m.Option(kit.MDB_LINK)))
m.Option(mdb.LINK, tcp.ReplaceLocalhost(m, m.Option(mdb.LINK)))
}
m.Option(kit.MDB_LINK, kit.MergeURL(m.Option(kit.MDB_LINK), RIVER, "", STORM, ""))
m.PushQRCode(kit.MDB_TEXT, m.Option(kit.MDB_LINK))
m.Push(kit.MDB_NAME, m.Option(kit.MDB_LINK))
m.Option(mdb.LINK, kit.MergeURL(m.Option(mdb.LINK), RIVER, "", STORM, ""))
m.PushQRCode(mdb.TEXT, m.Option(mdb.LINK))
m.Push(mdb.NAME, m.Option(mdb.LINK))
}
func _header_users(m *ice.Message, key string, arg ...string) {
m.Option(aaa.USERNAME, m.Option(ice.MSG_USERNAME))
@ -132,7 +132,7 @@ func init() {
code.WEBPACK: {Name: "webpack", Help: "打包页面", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(nfs.COPY, ice.GO_MOD, path.Join(ice.SRC_RELEASE, ice.GO_MOD))
m.Cmdy(code.WEBPACK, mdb.CREATE, m.OptionSimple(kit.MDB_NAME))
m.Cmdy(code.WEBPACK, mdb.CREATE, m.OptionSimple(mdb.NAME))
}},
code.DEVPACK: {Name: "devpack", Help: "开发模式", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(nfs.COPY, ice.GO_MOD, path.Join(ice.SRC_DEBUG, ice.GO_MOD))

5
core/chat/info.go
View File

@ -3,7 +3,6 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
const INFO = "info"
@ -12,11 +11,11 @@ func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
INFO: {Name: "info auto", Help: "信息", Action: map[string]*ice.Action{
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, "", mdb.HASH, kit.MDB_HASH, m.Option(ice.MSG_RIVER), arg)
m.Cmdy(mdb.MODIFY, RIVER, "", mdb.HASH, mdb.HASH, m.Option(ice.MSG_RIVER), arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.OptionFields(mdb.DETAIL)
m.Cmdy(mdb.SELECT, RIVER, "", mdb.HASH, kit.MDB_HASH, m.Option(ice.MSG_RIVER))
m.Cmdy(mdb.SELECT, RIVER, "", mdb.HASH, mdb.HASH, m.Option(ice.MSG_RIVER))
}},
}})
}

2
core/chat/location.go
View File

@ -34,7 +34,7 @@ const LOCATION = "location"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
LOCATION: {Name: LOCATION, Help: "地理位置", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_FIELD, "time,hash,type,name,text,longitude,latitude",
mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,hash,type,name,text,longitude,latitude",
)},
}, Commands: map[string]*ice.Command{
LOCATION: {Name: "location hash auto getLocation", Help: "地理位置", Action: ice.MergeAction(map[string]*ice.Action{

2
core/chat/meet.go
View File

@ -14,7 +14,7 @@ const MISS = "miss"
func init() {
Index.Register(&ice.Context{Name: MEET, Help: "遇见", Configs: map[string]*ice.Config{
MISS: {Name: MISS, Help: "miss", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,name,照片,性别,年龄,身高,体重,籍贯,户口,学历,学校,职业,公司,年薪,资产,家境",
mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,照片,性别,年龄,身高,体重,籍贯,户口,学历,学校,职业,公司,年薪,资产,家境",
)},
}, Commands: map[string]*ice.Command{
MISS: {Name: "miss name auto create", Help: "资料", Meta: kit.Dict("_trans", kit.Dict("name", "姓名")), Action: ice.MergeAction(map[string]*ice.Action{

8
core/chat/node.go
View File

@ -22,7 +22,7 @@ func init() {
if m.Option(ice.MSG_RIVER, m.Option(RIVER)) == "" {
return
}
if msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) == RIVER {
if msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(mdb.TYPE) == RIVER {
m.Cmdy(NODE, mdb.INSERT, arg)
} else {
msg.Debug(msg.FormatMeta())
@ -41,10 +41,10 @@ func init() {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, NODE), mdb.HASH, arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, NODE), mdb.HASH, kit.MDB_NAME, m.Option(ice.POD))
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, NODE), mdb.HASH, mdb.NAME, m.Option(ice.POD))
}},
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
m.Option(web.SHARE, m.Cmdx(web.SHARE, mdb.CREATE, kit.MDB_TYPE, RIVER))
m.Option(web.SHARE, m.Cmdx(web.SHARE, mdb.CREATE, mdb.TYPE, RIVER))
m.Cmdy(code.PUBLISH, ice.CONTEXTS, "tool")
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -52,7 +52,7 @@ func init() {
m.Option(mdb.FIELDS, "time,type,name,share")
m.Cmdy(mdb.SELECT, RIVER, _river_key(m, NODE), mdb.HASH)
m.Table(func(index int, value map[string]string, head []string) {
m.PushAnchor(value[kit.MDB_NAME], m.MergeURL2("/chat/pod/"+kit.Keys(m.Option(ice.POD), value[kit.MDB_NAME])))
m.PushAnchor(value[mdb.NAME], m.MergeURL2("/chat/pod/"+kit.Keys(m.Option(ice.POD), value[mdb.NAME])))
})
m.RenameAppend("name", "pod")
m.PushAction(mdb.REMOVE)

6
core/chat/paste.go
View File

@ -13,7 +13,7 @@ const PASTE = "paste"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
PASTE: {Name: PASTE, Help: "粘贴", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_FIELD, "time,hash,type,name,text",
mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,hash,type,name,text",
)},
}, Commands: map[string]*ice.Command{
PASTE: {Name: "paste hash auto getClipboardData", Help: "粘贴", Action: ice.MergeAction(map[string]*ice.Action{
@ -23,8 +23,8 @@ func init() {
mdb.CREATE: {Name: "create type=text name=hi text:textarea=hi", Help: "添加"},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if mdb.HashSelect(m, arg...); len(arg) > 0 {
m.PushScript(ssh.SCRIPT, m.Append(kit.MDB_TEXT))
m.PushQRCode(cli.QRCODE, m.Append(kit.MDB_TEXT))
m.PushScript(ssh.SCRIPT, m.Append(mdb.TEXT))
m.PushQRCode(cli.QRCODE, m.Append(mdb.TEXT))
}
}},
}})

34
core/chat/river.go
View File

@ -13,13 +13,13 @@ import (
)
func _river_key(m *ice.Message, key ...interface{}) string {
return kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), kit.Simple(key))
return kit.Keys(mdb.HASH, m.Option(ice.MSG_RIVER), kit.Simple(key))
}
func _river_list(m *ice.Message) {
if m.Option(web.SHARE) != "" {
switch msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) {
switch msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(mdb.TYPE) {
case web.RIVER: // 共享群组
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_TITLE, msg.Append(mdb.NAME))
m.Option(ice.MSG_RIVER, msg.Append(RIVER))
m.Option(ice.MSG_STORM, msg.Append(STORM))
@ -31,21 +31,21 @@ func _river_list(m *ice.Message) {
}
case web.STORM: // 共享应用
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_TITLE, msg.Append(mdb.NAME))
m.Option(ice.MSG_STORM, msg.Append(STORM))
m.Option(ice.MSG_RIVER, "_share")
return
case web.FIELD: // 共享命令
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_TITLE, msg.Append(mdb.NAME))
m.Option(ice.MSG_RIVER, "_share")
return
}
}
m.Richs(RIVER, nil, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
m.Richs(RIVER, kit.Keys(kit.MDB_HASH, key, OCEAN), m.Option(ice.MSG_USERNAME), func(k string, val map[string]interface{}) {
m.Push(key, kit.GetMeta(value), []string{kit.MDB_HASH, kit.MDB_NAME}, kit.GetMeta(val))
m.Richs(RIVER, nil, mdb.FOREACH, func(key string, value map[string]interface{}) {
m.Richs(RIVER, kit.Keys(mdb.HASH, key, OCEAN), m.Option(ice.MSG_USERNAME), func(k string, val map[string]interface{}) {
m.Push(key, kit.GetMeta(value), []string{mdb.HASH, mdb.NAME}, kit.GetMeta(val))
})
})
}
@ -55,13 +55,13 @@ const RIVER = "river"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
RIVER: {Name: RIVER, Help: "群组", Value: kit.Data(
kit.MDB_FIELD, "time,hash,type,name,text,template",
mdb.FIELD, "time,hash,type,name,text,template",
MENUS, kit.List(RIVER, kit.List("create", "创建群组", "添加应用", "添加工具", "添加设备", "创建空间"), kit.List("share", "共享群组", "共享应用", "共享工具", "共享主机", "访问空间")),
)},
}, Commands: map[string]*ice.Command{
"/river": {Name: "/river", Help: "小河流", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Config(kit.MDB_TEMPLATE, kit.Dict(
m.Config(nfs.TEMPLATE, kit.Dict(
"base", kit.Dict(
"info", kit.List(
"web.chat.info",
@ -136,8 +136,8 @@ func init() {
}
switch arg[0] {
case kit.MDB_TEMPLATE:
m.Push(kit.MDB_TEMPLATE, ice.BASE)
case nfs.TEMPLATE:
m.Push(nfs.TEMPLATE, ice.BASE)
case aaa.USERROLE:
m.Push(aaa.USERROLE, aaa.VOID, aaa.TECH, aaa.ROOT)
case aaa.USERNAME:
@ -151,16 +151,16 @@ func init() {
m.Option(ice.MSG_RIVER, h)
m.Echo(h)
m.Conf(RIVER, kit.Keys(kit.MDB_HASH, h, NODE, kit.Keym(kit.MDB_SHORT)), kit.MDB_NAME)
m.Conf(RIVER, kit.Keys(kit.MDB_HASH, h, OCEAN, kit.Keym(kit.MDB_SHORT)), aaa.USERNAME)
m.Conf(RIVER, kit.Keys(mdb.HASH, h, NODE, kit.Keym(mdb.SHORT)), mdb.NAME)
m.Conf(RIVER, kit.Keys(mdb.HASH, h, OCEAN, kit.Keym(mdb.SHORT)), aaa.USERNAME)
m.Cmd(OCEAN, mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME))
kit.Fetch(m.Confv(RIVER, kit.Keym(kit.MDB_TEMPLATE, kit.Select("base", m.Option(kit.MDB_TEMPLATE)))), func(storm string, value interface{}) {
h := m.Cmdx(STORM, mdb.CREATE, kit.MDB_TYPE, PUBLIC, kit.MDB_NAME, storm, kit.MDB_TEXT, storm)
kit.Fetch(m.Confv(RIVER, kit.Keym(nfs.TEMPLATE, kit.Select("base", m.Option(nfs.TEMPLATE)))), func(storm string, value interface{}) {
h := m.Cmdx(STORM, mdb.CREATE, mdb.TYPE, PUBLIC, mdb.NAME, storm, mdb.TEXT, storm)
kit.Fetch(value, func(index int, value string) {
m.Search(value, func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
m.Cmd(STORM, mdb.INSERT, kit.MDB_HASH, h, ice.CTX, s.Cap(ice.CTX_FOLLOW), ice.CMD, key, kit.MDB_HELP, cmd.Help)
m.Cmd(STORM, mdb.INSERT, mdb.HASH, h, ice.CTX, s.Cap(ice.CTX_FOLLOW), ice.CMD, key, mdb.HELP, cmd.Help)
})
})
})

34
core/chat/room.go
View File

@ -17,31 +17,31 @@ func init() {
)
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
ROOM: {Name: "room", Help: "room", Value: kit.Data(
kit.MDB_SHORT, "zone", kit.MDB_FIELD, "time,id,type,name,text",
mdb.SHORT, "zone", mdb.FIELD, "time,id,type,name,text",
)},
JOIN: {Name: "join", Help: "join", Value: kit.Data(
kit.MDB_SHORT, "space", kit.MDB_FIELD, "time,hash,username,socket",
mdb.SHORT, "space", mdb.FIELD, "time,hash,username,socket",
)},
}, Commands: map[string]*ice.Command{
ROOM: {Name: "room zone id auto", Help: "room", Action: ice.MergeAction(map[string]*ice.Action{
mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
}},
mdb.INSERT: {Name: "insert zone type=hi name=hello text=world", Help: "发送", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
m.Cmdy(mdb.SELECT, m.Prefix(ROOM), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.HASH, ice.Option{mdb.FIELDS, "time,space"}).Table(func(index int, value map[string]string, head []string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.ZONE, m.Option(mdb.ZONE), arg[2:])
m.Cmdy(mdb.SELECT, m.Prefix(ROOM), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, ice.Option{mdb.FIELDS, "time,space"}).Table(func(index int, value map[string]string, head []string) {
m.Cmdy(web.SPACE, value[web.SPACE], "toast", m.Option("text"), m.Option("name"))
})
}},
JOIN: {Name: "join zone", Help: "加入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.HASH, web.SPACE, m.Option("_daemon"))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, web.SPACE, m.Option("_daemon"), kit.MDB_SHORT, kit.MDB_ZONE)
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), kit.KeyHash(m.Option("_daemon")), mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, web.SPACE, m.Option("_daemon"))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, web.SPACE, m.Option("_daemon"), mdb.SHORT, mdb.ZONE)
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), kit.KeyHash(m.Option("_daemon")), mdb.HASH, m.OptionSimple(mdb.ZONE))
}},
QUIT: {Name: "quit", Help: "退出", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(ROOM), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.HASH, m.OptionSimple(web.SPACE))
m.Cmdy(mdb.DELETE, m.Prefix(JOIN), kit.KeyHash(m.Option(web.SPACE)), mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.DELETE, m.Prefix(ROOM), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, m.OptionSimple(web.SPACE))
m.Cmdy(mdb.DELETE, m.Prefix(JOIN), kit.KeyHash(m.Option(web.SPACE)), mdb.HASH, m.OptionSimple(mdb.ZONE))
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
@ -56,21 +56,21 @@ func init() {
// m.Watch(web.SPACE_START, m.PrefixKey())
}},
web.SPACE_START: {Name: "space_start", Help: "下线", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
}},
mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(ROOM), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
}},
mdb.INSERT: {Name: "insert zone username daemon", Hand: func(m *ice.Message, arg ...string) {
m.Conf(m.Prefix(JOIN), kit.Keys(kit.KeyHash(m.Option(kit.MDB_ZONE)), kit.Keym(kit.MDB_SHORT)), web.SOCKET)
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.HASH,
m.Conf(m.Prefix(JOIN), kit.Keys(kit.KeyHash(m.Option(mdb.ZONE)), kit.Keym(mdb.SHORT)), web.SOCKET)
m.Cmdy(mdb.INSERT, m.Prefix(JOIN), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH,
aaa.USERNAME, m.Option(ice.MSG_USERNAME), web.SOCKET, m.Option(ice.MSG_DAEMON),
)
}},
mdb.DELETE: {Name: "delete zone socket", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, m.Prefix(JOIN), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.HASH, m.OptionSimple(web.SOCKET))
m.Cmdy(mdb.DELETE, m.Prefix(JOIN), kit.KeyHash(m.Option(mdb.ZONE)), mdb.HASH, m.OptionSimple(web.SOCKET))
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,space", "time,zone")

10
core/chat/scan.go
View File

@ -13,7 +13,7 @@ const SCAN = "scan"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SCAN: {Name: SCAN, Help: "扫码", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_FIELD, "time,hash,type,name,text",
mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,hash,type,name,text",
)},
}, Commands: map[string]*ice.Command{
SCAN: {Name: "scan hash auto scanQRCode scanQRCode0", Help: "扫码", Meta: kit.Dict(
@ -24,11 +24,11 @@ func init() {
mdb.CREATE: {Name: "create type=text name=hi text:textarea=hi", Help: "添加"},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if mdb.HashSelect(m, arg...); len(arg) > 0 {
if m.Append(kit.MDB_TYPE) == "image" {
m.PushImages("image", m.Append(kit.MDB_TEXT))
if m.Append(mdb.TYPE) == "image" {
m.PushImages("image", m.Append(mdb.TEXT))
}
m.PushScript(ssh.SCRIPT, m.Append(kit.MDB_TEXT))
m.PushQRCode(cli.QRCODE, m.Append(kit.MDB_TEXT))
m.PushScript(ssh.SCRIPT, m.Append(mdb.TEXT))
m.PushQRCode(cli.QRCODE, m.Append(mdb.TEXT))
}
}},
}})

8
core/chat/search.go
View File

@ -9,12 +9,12 @@ import (
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
"search": {Name: "search", Help: "搜索", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
"search": {Name: "search", Help: "搜索", Value: kit.Data(mdb.SHORT, mdb.NAME)},
}, Commands: map[string]*ice.Command{
"/search": {Name: "/search", Help: "搜索引擎", Action: ice.MergeAction(map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
m.Richs("/search", "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); arg[1] != "" && !kit.Contains(value[kit.MDB_NAME], arg[1]) {
m.Richs("/search", "", mdb.FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); arg[1] != "" && !kit.Contains(value[mdb.NAME], arg[1]) {
return
}
m.PushSearch(ice.CMD, "/search", value)
@ -32,7 +32,7 @@ func init() {
return
}
m.Cmd(mdb.INSERT, m.PrefixKey(), "", mdb.HASH,
kit.MDB_NAME, arg[1], kit.MDB_TYPE, arg[0], kit.MDB_TEXT, kit.Select("", arg, 2))
mdb.NAME, arg[1], mdb.TYPE, arg[0], mdb.TEXT, kit.Select("", arg, 2))
}},
}})
}

30
core/chat/storm.go
View File

@ -8,7 +8,7 @@ import (
)
func _storm_key(m *ice.Message, key ...interface{}) string {
return _river_key(m, STORM, kit.MDB_HASH, kit.Keys(key))
return _river_key(m, STORM, mdb.HASH, kit.Keys(key))
}
const STORM = "storm"
@ -21,7 +21,7 @@ func init() {
return
}
switch arg[0] {
case kit.MDB_HASH:
case mdb.HASH:
m.Cmdy(STORM, ice.OptionFields("hash,name"))
}
}},
@ -29,34 +29,34 @@ func init() {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, STORM), mdb.HASH, arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, STORM), mdb.HASH, m.OptionSimple(kit.MDB_HASH))
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, STORM), mdb.HASH, m.OptionSimple(mdb.HASH))
}},
mdb.INSERT: {Name: "insert hash pod ctx cmd help", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, _storm_key(m, m.Option(kit.MDB_HASH)), mdb.LIST, arg[2:])
m.Cmdy(mdb.INSERT, RIVER, _storm_key(m, m.Option(mdb.HASH)), mdb.LIST, arg[2:])
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) == "" {
m.Cmdy(mdb.MODIFY, RIVER, _river_key(m, STORM), mdb.HASH, m.OptionSimple(kit.MDB_HASH), arg)
if m.Option(mdb.ID) == "" {
m.Cmdy(mdb.MODIFY, RIVER, _river_key(m, STORM), mdb.HASH, m.OptionSimple(mdb.HASH), arg)
} else {
m.Cmdy(mdb.MODIFY, RIVER, _storm_key(m, m.Option(kit.MDB_HASH)), mdb.LIST, m.OptionSimple(kit.MDB_ID), arg)
m.Cmdy(mdb.MODIFY, RIVER, _storm_key(m, m.Option(mdb.HASH)), mdb.LIST, m.OptionSimple(mdb.ID), arg)
}
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) == "" {
if m.Option(mdb.ID) == "" {
return
}
msg := m.Cmd(STORM, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
msg := m.Cmd(STORM, m.Option(mdb.HASH), m.Option(mdb.ID))
cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
_action_domain(m, cmd, m.Option(mdb.HASH))
m.Cmdy(cmd, mdb.EXPORT)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) == "" {
if m.Option(mdb.ID) == "" {
return
}
msg := m.Cmd(STORM, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
msg := m.Cmd(STORM, m.Option(mdb.HASH), m.Option(mdb.ID))
cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
_action_domain(m, cmd, m.Option(mdb.HASH))
m.Cmdy(cmd, mdb.IMPORT)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -64,12 +64,12 @@ func init() {
m.OptionFields("time,hash,type,name,count")
m.Cmdy(mdb.SELECT, RIVER, _river_key(m, STORM), mdb.HASH)
m.PushAction(mdb.REMOVE)
m.Sort(kit.MDB_NAME)
m.Sort(mdb.NAME)
return
}
m.OptionFields("time,id,pod,ctx,cmd,arg,display,style")
msg := m.Cmd(mdb.SELECT, RIVER, _storm_key(m, arg[0]), mdb.LIST, kit.MDB_ID, kit.Select("", arg, 1))
msg := m.Cmd(mdb.SELECT, RIVER, _storm_key(m, arg[0]), mdb.LIST, mdb.ID, kit.Select("", arg, 1))
if msg.Length() == 0 && len(arg) > 1 { // 虚拟群组
msg.Push(ice.CMD, arg[1])
}

2
core/chat/trans.go
View File

@ -23,7 +23,7 @@ func init() {
SEND: {Name: "send", Help: "发送", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.SPACE, m.Option(TO), web.SPIDE, ice.DEV, web.SPIDE_SAVE, kit.Select(ice.PWD, m.Option("to_path")),
m.MergeURL2(path.Join("/share/local/", m.Option("from_path")), ice.POD, m.Option(FROM),
web.SHARE, m.Cmdx(web.SHARE, mdb.CREATE, kit.MDB_TYPE, web.LOGIN),
web.SHARE, m.Cmdx(web.SHARE, mdb.CREATE, mdb.TYPE, web.LOGIN),
),
)
m.Toast(ice.SUCCESS, SEND)

24
core/chat/website.go
View File

@ -16,14 +16,14 @@ import (
func _website_parse(m *ice.Message, text string) map[string]interface{} {
m.Option(nfs.CAT_CONTENT, text)
river, storm, last := kit.Dict(), kit.Dict(), kit.Dict()
m.Cmd(lex.SPLIT, "", kit.MDB_KEY, kit.MDB_NAME, func(deep int, ls []string, meta map[string]interface{}) []string {
m.Cmd(lex.SPLIT, "", mdb.KEY, mdb.NAME, func(deep int, ls []string, meta map[string]interface{}) []string {
if len(ls) == 1 {
ls = append(ls, ls[0])
}
data := kit.Dict()
for i := 2; i < len(ls); i += 2 {
switch ls[i] {
case kit.MDB_ARGS:
case ctx.ARGS:
data[ls[i]] = kit.UnMarshal(ls[i+1])
default:
data[ls[i]] = ls[i+1]
@ -32,13 +32,13 @@ func _website_parse(m *ice.Message, text string) map[string]interface{} {
switch deep {
case 1:
storm = kit.Dict()
river[ls[0]] = kit.Dict(kit.MDB_NAME, ls[1], "storm", storm, data)
river[ls[0]] = kit.Dict(mdb.NAME, ls[1], "storm", storm, data)
case 2:
last = kit.Dict(kit.MDB_NAME, ls[1], kit.MDB_LIST, kit.List(), data)
last = kit.Dict(mdb.NAME, ls[1], mdb.LIST, kit.List(), data)
storm[ls[0]] = last
default:
last[kit.MDB_LIST] = append(last[kit.MDB_LIST].([]interface{}),
kit.Dict(kit.MDB_NAME, ls[0], kit.MDB_HELP, ls[1], kit.MDB_INDEX, ls[0], data))
last[mdb.LIST] = append(last[mdb.LIST].([]interface{}),
kit.Dict(mdb.NAME, ls[0], mdb.HELP, ls[1], mdb.INDEX, ls[0], data))
}
return ls
})
@ -50,7 +50,7 @@ const WEBSITE = "website"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
WEBSITE: {Name: "website", Help: "网站", Value: kit.Data(
kit.MDB_SHORT, nfs.PATH, kit.MDB_FIELD, "time,path,type,name,text",
mdb.SHORT, nfs.PATH, mdb.FIELD, "time,path,type,name,text",
)},
}, Commands: map[string]*ice.Command{
WEBSITE: {Name: "website path auto create import", Help: "网站", Action: ice.MergeAction(map[string]*ice.Action{
@ -58,7 +58,7 @@ func init() {
web.AddRewrite(func(w http.ResponseWriter, r *http.Request) bool {
if ok := true; m.Richs(WEBSITE, nil, r.URL.Path, func(key string, value map[string]interface{}) {
msg, value := m.Spawn(w, r), kit.GetMeta(value)
switch text := kit.Format(value[kit.MDB_TEXT]); value[kit.MDB_TYPE] {
switch text := kit.Format(value[mdb.TEXT]); value[mdb.TYPE] {
case "svg":
msg.RenderResult(`<body style="background-color:cadetblue">%s</body>`, m.Cmdx(nfs.CAT, text))
case "shy":
@ -69,7 +69,7 @@ func init() {
return
}
case "txt":
res := _website_parse(msg, kit.Format(value[kit.MDB_TEXT]))
res := _website_parse(msg, kit.Format(value[mdb.TEXT]))
msg.RenderResult(_website_template2, kit.Format(res))
case "json":
msg.RenderResult(_website_template2, kit.Format(kit.UnMarshal(text)))
@ -104,10 +104,10 @@ func init() {
switch name := strings.TrimPrefix(p, m.Option(nfs.PATH)); kit.Ext(p) {
case "html", "js", "json", "txt":
m.Cmd(m.PrefixKey(), mdb.CREATE, nfs.PATH, ice.PS+name,
kit.MDB_TYPE, kit.Ext(p), kit.MDB_NAME, name, kit.MDB_TEXT, m.Cmdx(nfs.CAT, p))
mdb.TYPE, kit.Ext(p), mdb.NAME, name, mdb.TEXT, m.Cmdx(nfs.CAT, p))
default:
m.Cmd(m.PrefixKey(), mdb.CREATE, nfs.PATH, ice.PS+name,
kit.MDB_TYPE, kit.Ext(p), kit.MDB_NAME, name, kit.MDB_TEXT, p)
mdb.TYPE, kit.Ext(p), mdb.NAME, name, mdb.TEXT, p)
}
})
}},
@ -116,7 +116,7 @@ func init() {
m.PushAnchor(m.MergeURL2(value[nfs.PATH]))
})
if m.Sort(nfs.PATH); m.FieldsIsDetail() {
m.PushQRCode(kit.MDB_SCAN, m.MergeURL2(m.Append(nfs.PATH)))
m.PushQRCode(mdb.SCAN, m.MergeURL2(m.Append(nfs.PATH)))
m.EchoIFrame(m.Append(nfs.PATH))
}
}},

22
core/code/autogen.go
View File

@ -147,32 +147,32 @@ func init() {
AUTOGEN: {Name: "autogen path auto create binpack script", Help: "生成", Action: map[string]*ice.Action{
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case kit.MDB_MAIN:
case MAIN:
m.Cmdy(nfs.DIR, ice.SRC, "path,size,time", ice.Option{nfs.DIR_REG, `.*\.go`})
m.RenameAppend(nfs.PATH, arg[0])
}
}},
mdb.CREATE: {Name: "create main=src/main.go@key key zone type=Zone,Hash,Data name=hi list help", Help: "模块", Hand: func(m *ice.Message, arg ...string) {
_defs(m, kit.MDB_ZONE, m.Option(kit.MDB_NAME), kit.MDB_HELP, m.Option(kit.MDB_NAME))
_defs(m, kit.MDB_KEY, kit.Keys("web.code", m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME)))
switch m.Option(kit.MDB_TYPE) {
_defs(m, mdb.ZONE, m.Option(mdb.NAME), mdb.HELP, m.Option(mdb.NAME))
_defs(m, mdb.KEY, kit.Keys("web.code", m.Option(mdb.ZONE), m.Option(mdb.NAME)))
switch m.Option(mdb.TYPE) {
case "Zone":
_defs(m, "list", m.Option(kit.MDB_NAME)+" zone id auto insert")
_defs(m, "list", m.Option(mdb.NAME)+" zone id auto insert")
case "Hash":
_defs(m, "list", m.Option(kit.MDB_NAME)+" hash auto create")
_defs(m, "list", m.Option(mdb.NAME)+" hash auto create")
case "Data":
_defs(m, "list", m.Option(kit.MDB_NAME)+" path auto upload")
_defs(m, "list", m.Option(mdb.NAME)+" path auto upload")
}
m.Option("tags", kit.Format("`name:\"%s\" help:\"%s\"`", m.Option("list"), m.Option("help")))
if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), GO)); !kit.FileExists(p) {
if p := path.Join(ice.SRC, m.Option(mdb.ZONE), kit.Keys(m.Option(mdb.NAME), GO)); !kit.FileExists(p) {
_autogen_module(m, p)
_autogen_import(m, m.Option(kit.MDB_MAIN), m.Option(kit.MDB_ZONE), _autogen_mod(m, ice.GO_MOD))
_autogen_import(m, m.Option(MAIN), m.Option(mdb.ZONE), _autogen_mod(m, ice.GO_MOD))
}
if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), SHY)); !kit.FileExists(p) {
if p := path.Join(ice.SRC, m.Option(mdb.ZONE), kit.Keys(m.Option(mdb.NAME), SHY)); !kit.FileExists(p) {
_autogen_script(m, p)
_autogen_source(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME))
_autogen_source(m, m.Option(mdb.ZONE), m.Option(mdb.NAME))
}
}},
ssh.SCRIPT: {Name: "script", Help: "脚本：生成 etc/miss.sh", Hand: func(m *ice.Message, arg ...string) {

8
core/code/bench.go
View File

@ -64,17 +64,17 @@ const BENCH = "bench"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,nconn,nreqs",
mdb.SHORT, mdb.ZONE, mdb.FIELD, "time,id,type,name,text,nconn,nreqs",
)},
}, Commands: map[string]*ice.Command{
BENCH: {Name: "bench zone id auto insert", Help: "性能压测", Action: ice.MergeAction(map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone=some type=http,redis name=demo text='http://localhost:9020' nconn=3 nreqs=10", Help: "添加"},
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_TYPE) {
switch m.Option(mdb.TYPE) {
case HTTP:
_bench_http(m, m.Option(kit.MDB_TEXT))
_bench_http(m, m.Option(mdb.TEXT))
case REDIS:
_bench_redis(m, m.Option(kit.MDB_TEXT))
_bench_redis(m, m.Option(mdb.TEXT))
}
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

6
core/code/binpack.go
View File

@ -132,10 +132,10 @@ func init() {
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for k, v := range ice.Info.Pack {
m.Push(kit.MDB_NAME, k)
m.Push(kit.MDB_SIZE, len(v))
m.Push(mdb.NAME, k)
m.Push(nfs.SIZE, len(v))
}
m.Sort(kit.MDB_NAME)
m.Sort(mdb.NAME)
}},
}})
}

14
core/code/c.go
View File

@ -75,15 +75,15 @@ func init() {
m.Cmdy(cli.SYSTEM, ice.PWD+name)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
_c_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
_c_tags(m, kit.Select(MAIN, arg, 1))
_go_find(m, kit.Select(MAIN, arg, 1))
_go_grep(m, kit.Select(MAIN, arg, 1))
}},
}, PlugAction())},
MAN: {Name: MAN, Help: "手册", Action: ice.MergeAction(map[string]*ice.Action{
@ -91,12 +91,12 @@ func init() {
m.Echo(_c_help(m, strings.TrimPrefix(arg[0], MAN), strings.TrimSuffix(arg[1], ice.PT+arg[0])))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
for _, i := range []string{"1", "2", "3", "8"} {
if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
m.PushSearch(ice.CMD, MAN, nfs.FILE, kit.Keys(arg[1], MAN+i), nfs.LINE, 1, kit.MDB_TEXT, text)
if text := _c_help(m, i, kit.Select(MAIN, arg, 1)); text != "" {
m.PushSearch(ice.CMD, MAN, nfs.FILE, kit.Keys(arg[1], MAN+i), nfs.LINE, 1, mdb.TEXT, text)
}
}
}},

6
core/code/case.go
View File

@ -17,7 +17,7 @@ const CASE = "case"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CASE: {Name: CASE, Help: "用例", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,name,cmd,api,arg,res",
mdb.SHORT, mdb.ZONE, mdb.FIELD, "time,id,name,cmd,api,arg,res",
)},
}, Commands: map[string]*ice.Command{
CASE: {Name: "case dev zone id auto", Help: "用例", Action: ice.MergeAction(map[string]*ice.Action{
@ -30,8 +30,8 @@ func init() {
if m.ProcessInner(); len(arg) > 0 {
success := 0
m.Cmd(m.PrefixKey(), arg[0]).Table(func(index int, value map[string]string, head []string) {
m.Push(kit.MDB_TIME, m.Time())
m.Push(kit.MDB_ID, value[kit.MDB_ID])
m.Push(mdb.TIME, m.Time())
m.Push(mdb.ID, value[mdb.ID])
if err := m.Cmdx(m.PrefixKey(), cli.CHECK, value); err == ice.OK {
m.Push(ice.ERR, cli.Color(m, cli.GREEN, err))
success++

2
core/code/favor.go
View File

@ -11,7 +11,7 @@ const FAVOR = "favor"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
FAVOR: {Name: FAVOR, Help: "收藏夹", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,path,file,line",
mdb.SHORT, mdb.ZONE, mdb.FIELD, "time,id,type,name,text,path,file,line",
)},
}, Commands: map[string]*ice.Command{
FAVOR: {Name: "favor zone id auto insert", Help: "收藏夹", Action: ice.MergeAction(map[string]*ice.Action{

17
core/code/go.go
View File

@ -41,7 +41,7 @@ func _go_tags(m *ice.Message, key string) {
bio := bufio.NewScanner(f)
for i := 1; bio.Scan(); i++ {
if i == line || bio.Text() == text {
m.PushSearch(ice.CMD, "tags", nfs.FILE, strings.TrimPrefix(file, ice.PWD), nfs.LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
m.PushSearch(ice.CMD, "tags", nfs.FILE, strings.TrimPrefix(file, ice.PWD), nfs.LINE, kit.Format(i), mdb.TEXT, bio.Text())
}
}
}
@ -51,14 +51,14 @@ func _go_help(m *ice.Message, key string) {
if p == "" {
return
}
m.PushSearch(ice.CMD, "help", nfs.FILE, key+".godoc", nfs.LINE, 1, kit.MDB_TEXT, p)
m.PushSearch(ice.CMD, "help", nfs.FILE, key+".godoc", nfs.LINE, 1, mdb.TEXT, p)
}
func _go_find(m *ice.Message, key string) {
for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, FIND, ".", "-name", key), ice.NL) {
if p == "" {
continue
}
m.PushSearch(ice.CMD, FIND, nfs.FILE, strings.TrimPrefix(p, ice.PWD), nfs.LINE, 1, kit.MDB_TEXT, "")
m.PushSearch(ice.CMD, FIND, nfs.FILE, strings.TrimPrefix(p, ice.PWD), nfs.LINE, 1, mdb.TEXT, "")
}
}
func _go_grep(m *ice.Message, key string) {
@ -71,6 +71,7 @@ const (
_TAGS = ".tags"
FIND = "find"
GREP = "grep"
MAIN = "main"
)
const GO = "go"
const MOD = "mod"
@ -111,13 +112,13 @@ func init() {
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
_go_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_help(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_tags(m, kit.Select(MAIN, arg, 1))
_go_help(m, kit.Select(MAIN, arg, 1))
_go_find(m, kit.Select(MAIN, arg, 1))
_go_grep(m, kit.Select(MAIN, arg, 1))
}},
}, PlugAction())},
}, Configs: map[string]*ice.Config{

16
core/code/install.go
View File

@ -16,7 +16,7 @@ import (
)
func _install_download(m *ice.Message) {
link := m.Option(kit.MDB_LINK)
link := m.Option(mdb.LINK)
name := path.Base(link)
file := path.Join(kit.Select(m.Config(nfs.PATH), m.Option(nfs.PATH)), name)
@ -30,14 +30,14 @@ func _install_download(m *ice.Message) {
m.GoToast(web.DOWNLOAD, func(toast func(string, int, int)) {
// 进度
m.Cmd(mdb.INSERT, INSTALL, "", mdb.HASH, kit.MDB_NAME, name, kit.MDB_LINK, link)
m.Cmd(mdb.INSERT, INSTALL, "", mdb.HASH, mdb.NAME, name, mdb.LINK, link)
m.Richs(INSTALL, "", name, func(key string, value map[string]interface{}) {
value = kit.GetMeta(value)
p := 0
m.OptionCB(web.SPIDE, func(size int, total int) {
if n := size * 100 / total; p != n {
value[kit.MDB_STEP], value[kit.MDB_SIZE], value[kit.MDB_TOTAL] = n, size, total
value[mdb.VALUE], value[mdb.COUNT], value[mdb.TOTAL] = n, size, total
toast(name, size, total)
p = n
}
@ -54,7 +54,7 @@ func _install_download(m *ice.Message) {
})
}
func _install_build(m *ice.Message, arg ...string) {
p := m.Option(cli.CMD_DIR, path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(kit.MDB_LINK))))
p := m.Option(cli.CMD_DIR, path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(mdb.LINK))))
pp := kit.Path(path.Join(p, "_install"))
// 推流
@ -90,7 +90,7 @@ func _install_build(m *ice.Message, arg ...string) {
m.Toast(ice.SUCCESS, cli.BUILD)
}
func _install_order(m *ice.Message, arg ...string) {
p := path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(nfs.PATH)+ice.NL)
p := path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(mdb.LINK)), m.Option(nfs.PATH)+ice.NL)
if !strings.Contains(m.Cmdx(nfs.CAT, ice.ETC_PATH), p) {
m.Cmd(nfs.PUSH, ice.ETC_PATH, p)
}
@ -108,7 +108,7 @@ func _install_spawn(m *ice.Message, arg ...string) {
}
target := path.Join(m.Conf(cli.DAEMON, kit.META_PATH), m.Option(tcp.PORT))
source := path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(kit.MDB_LINK)))
source := path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(mdb.LINK)))
m.Cmd(nfs.DIR, path.Join(source, kit.Select("_install", m.Option("install")))).Table(func(index int, value map[string]string, head []string) {
m.Cmd(cli.SYSTEM, "cp", "-r", strings.TrimSuffix(value[nfs.PATH], ice.PS), target)
@ -154,7 +154,7 @@ const INSTALL = "install"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
INSTALL: {Name: INSTALL, Help: "安装", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_NAME, nfs.PATH, ice.USR_INSTALL,
mdb.SHORT, mdb.NAME, nfs.PATH, ice.USR_INSTALL,
)},
}, Commands: map[string]*ice.Command{
INSTALL: {Name: "install name port path auto download", Help: "安装", Meta: kit.Dict(), Action: map[string]*ice.Action{
@ -174,7 +174,7 @@ func init() {
_install_start(m, arg...)
}},
nfs.SOURCE: {Name: "source link path", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
m.Option(nfs.DIR_ROOT, path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), "_install"))
m.Option(nfs.DIR_ROOT, path.Join(m.Config(nfs.PATH), kit.TrimExt(m.Option(mdb.LINK)), "_install"))
defer m.StatusTime(nfs.PATH, m.Option(nfs.DIR_ROOT))
m.Cmdy(nfs.DIR, m.Option(nfs.PATH))
}},

6
core/code/js.go
View File

@ -33,11 +33,11 @@ func init() {
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(MAIN, arg, 1))
_go_grep(m, kit.Select(MAIN, arg, 1))
}},
}, PlugAction())},
NODE: {Name: "node auto download", Help: "前端", Action: map[string]*ice.Action{

10
core/code/pprof.go
View File

@ -26,7 +26,7 @@ const PPROF = "pprof"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,text,file",
mdb.SHORT, mdb.ZONE, mdb.FIELD, "time,id,text,file",
PPROF, kit.List(GO, "tool", PPROF),
)},
}, Commands: map[string]*ice.Command{
@ -63,8 +63,8 @@ func init() {
cmd := kit.Simple(m.Configv(PPROF), "-text", m.Option(BINNARY), msg.Append(nfs.FILE))
res := kit.Slice(strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL), 0, 20)
m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE),
kit.MDB_TEXT, strings.Join(res, ice.NL), nfs.FILE, msg.Append(nfs.FILE))
m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(mdb.ZONE),
mdb.TEXT, strings.Join(res, ice.NL), nfs.FILE, msg.Append(nfs.FILE))
m.Echo(strings.Join(res, ice.NL))
m.ProcessInner()
}},
@ -77,7 +77,7 @@ func init() {
m.ProcessInner()
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count,binnary,service,seconds", m.Config(kit.MDB_FIELD))
m.Fields(len(arg), "time,zone,count,binnary,service,seconds", m.Config(mdb.FIELD))
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
m.PushAction(ice.RUN, mdb.REMOVE)
m.Action(mdb.CREATE)
@ -85,7 +85,7 @@ func init() {
}
m.Table(func(index int, value map[string]string, head []string) {
m.PushDownload(kit.MDB_LINK, "pprof.pd.gz", value[nfs.FILE])
m.PushDownload(mdb.LINK, "pprof.pd.gz", value[nfs.FILE])
m.PushButton(web.SERVE)
})
}},

8
core/code/publish.go
View File

@ -22,14 +22,14 @@ func _bin_list(m *ice.Message, dir string) {
for _, ls := range strings.Split(strings.TrimSpace(m.Cmd(cli.SYSTEM, "bash", "-c", "ls |xargs file |grep executable").Append(cli.CMD_OUT)), ice.NL) {
if file := strings.TrimSpace(strings.Split(ls, ":")[0]); file != "" {
if s, e := os.Stat(path.Join(p, file)); e == nil {
m.Push(kit.MDB_TIME, s.ModTime())
m.Push(kit.MDB_SIZE, kit.FmtSize(s.Size()))
m.Push(mdb.TIME, s.ModTime())
m.Push(nfs.SIZE, kit.FmtSize(s.Size()))
m.Push(nfs.FILE, file)
m.PushDownload(kit.MDB_LINK, file, path.Join(p, file))
m.PushDownload(mdb.LINK, file, path.Join(p, file))
}
}
}
m.SortTimeR(kit.MDB_TIME)
m.SortTimeR(mdb.TIME)
}
func _publish_file(m *ice.Message, file string, arg ...string) string {

6
core/code/sh.go
View File

@ -24,14 +24,14 @@ func init() {
m.Set(ice.MSG_APPEND)
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(MAIN, arg, 1))
_go_grep(m, kit.Select(MAIN, arg, 1))
}},
MAN: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_c_help(m, arg[0], arg[1]))

6
core/code/shy.go
View File

@ -23,11 +23,11 @@ func init() {
m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
}},
mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_FOREACH {
if arg[0] == mdb.FOREACH {
return
}
_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
_go_find(m, kit.Select(MAIN, arg, 1))
_go_grep(m, kit.Select(MAIN, arg, 1))
}},
}, PlugAction())},
}, Configs: map[string]*ice.Config{

19
core/code/upgrade.go
View File

@ -6,6 +6,7 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
@ -15,20 +16,20 @@ const UPGRADE = "upgrade"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
cli.SYSTEM, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "bin", nfs.FILE, "ice.sh", nfs.PATH, ice.BIN_ICE_SH,
kit.MDB_TYPE, "bin", nfs.FILE, "ice.bin", nfs.PATH, ice.BIN_ICE_BIN,
UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(mdb.HASH, kit.Dict(
cli.SYSTEM, kit.Dict(mdb.LIST, kit.List(
mdb.TYPE, "bin", nfs.FILE, "ice.sh", nfs.PATH, ice.BIN_ICE_SH,
mdb.TYPE, "bin", nfs.FILE, "ice.bin", nfs.PATH, ice.BIN_ICE_BIN,
)),
nfs.SOURCE, kit.Dict(kit.MDB_LIST, kit.List(
kit.MDB_TYPE, "txt", nfs.FILE, "main.go", nfs.PATH, ice.SRC_MAIN_GO,
kit.MDB_TYPE, "txt", nfs.FILE, "miss.sh", nfs.PATH, ice.ETC_MISS_SH,
kit.MDB_TYPE, "txt", nfs.FILE, "go.mod", nfs.PATH, ice.GO_MOD,
nfs.SOURCE, kit.Dict(mdb.LIST, kit.List(
mdb.TYPE, "txt", nfs.FILE, "main.go", nfs.PATH, ice.SRC_MAIN_GO,
mdb.TYPE, "txt", nfs.FILE, "miss.sh", nfs.PATH, ice.ETC_MISS_SH,
mdb.TYPE, "txt", nfs.FILE, "go.mod", nfs.PATH, ice.GO_MOD,
)),
))},
}, Commands: map[string]*ice.Command{
UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
m.Grows(cmd, kit.Keys(mdb.HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
if value[nfs.PATH] == ice.BIN_ICE_BIN { // 程序文件
value[nfs.FILE] = kit.Keys(ice.ICE, runtime.GOOS, runtime.GOARCH)
m.Option(ice.EXIT, ice.TRUE)

6
core/code/webpack.go
View File

@ -71,7 +71,7 @@ func init() {
js.WriteString(m.Cmdx(nfs.CAT, k))
}
if f, _, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS))); m.Assert(e) {
if f, _, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(mdb.NAME), JS))); m.Assert(e) {
defer f.Close()
f.WriteString(ice.NL)
@ -81,7 +81,7 @@ func init() {
}
m.Option(nfs.DIR_ROOT, "")
if f, p, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), HTML))); m.Assert(e) {
if f, p, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(mdb.NAME), HTML))); m.Assert(e) {
defer f.Close()
f.WriteString(fmt.Sprintf(_pack,
@ -89,7 +89,7 @@ func init() {
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_CSS)),
m.Cmdx(nfs.CAT, _volcanos(m, ice.PROTO_JS)),
m.Cmdx(nfs.CAT, _publish(m, path.Join(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS)))),
m.Cmdx(nfs.CAT, _publish(m, path.Join(WEBPACK, kit.Keys(m.Option(mdb.NAME), JS)))),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_CACHE_JS)),
m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_JS)),

14
core/mall/asset.go
View File

@ -30,7 +30,7 @@ func _asset_check(m *ice.Message, account string) {
m.Option(kit.Keycb(mdb.SELECT), func(key string, value map[string]interface{}) {
amount += kit.Int(kit.Value(value, AMOUNT))
})
m.Cmd(mdb.SELECT, m.Prefix(ASSET), "", mdb.ZONE, account, ice.OptionFields(m.Config(kit.MDB_FIELD)))
m.Cmd(mdb.SELECT, m.Prefix(ASSET), "", mdb.ZONE, account, ice.OptionFields(m.Config(mdb.FIELD)))
m.Cmdy(mdb.MODIFY, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account, AMOUNT, amount)
}
@ -61,7 +61,7 @@ const ASSET = "asset"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
ASSET: {Name: ASSET, Help: "资产", Value: kit.Data(
kit.MDB_SHORT, ACCOUNT, kit.MDB_FIELD, "time,id,type,amount,name,text",
mdb.SHORT, ACCOUNT, mdb.FIELD, "time,id,type,amount,name,text",
kit.MDB_ALIAS, kit.Dict(FROM, ACCOUNT, TO, ACCOUNT),
)},
}, Commands: map[string]*ice.Command{
@ -70,15 +70,15 @@ func init() {
), Action: ice.MergeAction(map[string]*ice.Action{
SPEND: {Name: "spend account name amount time@date text", Help: "支出", Hand: func(m *ice.Message, arg ...string) {
_sub_amount(m, arg)
_asset_insert(m, arg[1], kit.Simple(kit.MDB_TYPE, "支出", arg[2:])...)
_asset_insert(m, arg[1], kit.Simple(mdb.TYPE, "支出", arg[2:])...)
}},
TRANS: {Name: "trans from to amount time@date text", Help: "转账", Hand: func(m *ice.Message, arg ...string) {
_asset_insert(m, arg[3], kit.Simple(kit.MDB_TYPE, "转入", kit.MDB_NAME, arg[1], arg[4:])...)
_asset_insert(m, arg[3], kit.Simple(mdb.TYPE, "转入", mdb.NAME, arg[1], arg[4:])...)
_sub_amount(m, arg)
_asset_insert(m, arg[1], kit.Simple(kit.MDB_TYPE, "转出", kit.MDB_NAME, arg[3], arg[4:])...)
_asset_insert(m, arg[1], kit.Simple(mdb.TYPE, "转出", mdb.NAME, arg[3], arg[4:])...)
}},
BONUS: {Name: "bonus account name amount time@date text", Help: "收入", Hand: func(m *ice.Message, arg ...string) {
_asset_insert(m, arg[1], kit.Simple(kit.MDB_TYPE, "收入", arg[2:])...)
_asset_insert(m, arg[1], kit.Simple(mdb.TYPE, "收入", arg[2:])...)
}},
CHECK: {Name: "check", Help: "核算", Hand: func(m *ice.Message, arg ...string) {
if m.Option(ACCOUNT) == "" {
@ -92,7 +92,7 @@ func init() {
m.Toast("核算成功")
}},
}, mdb.ZoneAction(), ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,account,amount,count", m.Config(kit.MDB_FIELD))
m.Fields(len(arg), "time,account,amount,count", m.Config(mdb.FIELD))
amount, count := 0, 0
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
m.PushAction(CHECK)

2
core/mall/salary.go
View File

@ -16,7 +16,7 @@ const SALARY = "salary"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SALARY: {Name: SALARY, Help: "工资", Value: kit.Data(
kit.MDB_SHORT, MONTH, kit.MDB_FIELD, "month,company,amount,income,tax",
mdb.SHORT, MONTH, mdb.FIELD, "month,company,amount,income,tax",
)},
}, Commands: map[string]*ice.Command{
SALARY: {Name: "salary month auto create", Help: "工资", Action: ice.MergeAction(map[string]*ice.Action{

6
core/team/count.go
View File

@ -26,18 +26,18 @@ func init() {
tz := int64(8)
msg.Table(func(index int, value map[string]string, head []string) {
if value[kit.MDB_STATUS] == CANCEL {
if value[mdb.STATUS] == CANCEL {
return
}
show := []string{}
for _, k := range []string{kit.MDB_NAME, kit.MDB_TEXT} {
for _, k := range []string{mdb.NAME, mdb.TEXT} {
show = append(show, kit.Format(`<div class="%v">%v</div>`, k, value[k]))
}
t := (kit.Time(value[BEGIN_TIME])+int64(time.Hour)*tz)/int64(time.Second)/3600/24 - (time.Now().Unix()+3600*tz)/3600/24
m.Echo(`<div class="item %s" title="%s">距离 %v%v%v<span class="day"> %v </span>天</div>`,
kit.Select("gone", "come", t > 0), value[kit.MDB_TEXT],
kit.Select("gone", "come", t > 0), value[mdb.TEXT],
strings.Split(value[BEGIN_TIME], " ")[0],
strings.Join(show, ""),
kit.Select("已经", "还有", t > 0), t,

2
core/team/plan.go
View File

@ -50,7 +50,7 @@ func _plan_list(m *ice.Message, begin_time, end_time time.Time) *ice.Message {
m.Push(key, value, fields, val)
m.PushButton(_task_action(m, value[STATUS], mdb.PLUGIN))
})
m.Cmd(mdb.SELECT, m.Prefix(TASK), "", mdb.ZONE, kit.MDB_FOREACH)
m.Cmd(mdb.SELECT, m.Prefix(TASK), "", mdb.ZONE, mdb.FOREACH)
return m
}

14
core/team/task.go
View File

@ -26,7 +26,7 @@ func _task_modify(m *ice.Message, field, value string, arg ...string) {
arg = append(arg, CLOSE_TIME, m.Time())
}
}
m.Cmdy(mdb.MODIFY, m.Prefix(TASK), "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), field, value, arg)
m.Cmdy(mdb.MODIFY, m.Prefix(TASK), "", mdb.ZONE, m.Option(mdb.ZONE), m.Option(mdb.ID), field, value, arg)
}
const ( // type
@ -58,13 +58,13 @@ const TASK = "task"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
TASK: {Name: TASK, Help: "任务", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "begin_time,id,status,level,score,type,name,text",
mdb.SHORT, mdb.ZONE, mdb.FIELD, "begin_time,id,status,level,score,type,name,text",
)},
}, Commands: map[string]*ice.Command{
TASK: {Name: "task zone id auto insert export import", Help: "任务", Action: ice.MergeAction(map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone type=once,step,week name text begin_time@date close_time@date", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.ZONE, m.Option(kit.MDB_ZONE),
m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.HASH, m.OptionSimple(mdb.ZONE))
m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.ZONE, m.Option(mdb.ZONE),
BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time("30m"),
STATUS, PREPARE, LEVEL, 3, SCORE, 3, arg)
m.ProcessRefresh30ms()
@ -77,12 +77,12 @@ func init() {
_task_modify(m, STATUS, CANCEL)
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(kit.MDB_ZONE, "time,id,type,name,text,level,status,score,begin_time,close_time")
m.OptionFields(mdb.ZONE, "time,id,type,name,text,level,status,score,begin_time,close_time")
m.Cmdy(mdb.EXPORT, m.Prefix(TASK), "", mdb.ZONE)
m.ProcessRefresh30ms()
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(kit.MDB_ZONE)
m.OptionFields(mdb.ZONE)
m.Cmdy(mdb.IMPORT, m.Prefix(TASK), "", mdb.ZONE)
m.ProcessRefresh30ms()
}},
@ -98,7 +98,7 @@ func init() {
status := map[string]int{}
m.Table(func(index int, value map[string]string, head []string) {
m.PushButton(_task_action(m, value[STATUS]))
status[value[kit.MDB_STATUS]]++
status[value[mdb.STATUS]]++
})
m.Status(status)
}

3
core/wiki/brief.go
View File

@ -2,6 +2,7 @@ package wiki
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -14,7 +15,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
BRIEF: {Name: BRIEF, Help: "摘要", Value: kit.Data(
kit.MDB_TEMPLATE, `<p {{.OptionTemplate}}>{{.Option "text"}}</p>`,
nfs.TEMPLATE, `<p {{.OptionTemplate}}>{{.Option "text"}}</p>`,
)},
}})
}

3
core/wiki/chart.go
View File

@ -5,6 +5,7 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -165,7 +166,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
CHART: {Name: CHART, Help: "图表", Value: kit.Data(
kit.MDB_TEMPLATE, `<svg {{.OptionTemplate}}
nfs.TEMPLATE, `<svg {{.OptionTemplate}}
vertion="1.1" xmlns="http://www.w3.org/2000/svg" height="{{.Option "height"}}" width="{{.Option "width"}}"
stroke-width="{{.Option "stroke-width"}}" stroke="{{.Option "stroke"}}" fill="{{.Option "fill"}}"
font-size="{{.Option "font-size"}}" font-family="{{.Option "font-family"}}" text-anchor="middle" dominant-baseline="middle">`,

3
core/wiki/chart/block.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/core/wiki"
kit "shylinux.com/x/toolkits"
)
@ -38,7 +39,7 @@ func (b *Block) Init(m *ice.Message, arg ...string) wiki.Chart {
return b
}
func (b *Block) Data(m *ice.Message, meta interface{}) wiki.Chart {
b.Text = kit.Select(b.Text, kit.Value(meta, kit.MDB_TEXT))
b.Text = kit.Select(b.Text, kit.Value(meta, mdb.TEXT))
kit.Fetch(meta, func(key string, value string) {
switch key {
case wiki.FG:

11
core/wiki/chart/chain.go
View File

@ -4,6 +4,7 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/core/wiki"
kit "shylinux.com/x/toolkits"
@ -22,7 +23,7 @@ func (c *Chain) Init(m *ice.Message, arg ...string) wiki.Chart {
m.Option(nfs.CAT_CONTENT, arg[0])
m.Option(lex.SPLIT_SPACE, "\t \n")
m.Option(lex.SPLIT_BLOCK, "\t \n")
c.data = lex.Split(m, "", kit.MDB_TEXT)
c.data = lex.Split(m, "", mdb.TEXT)
// 计算尺寸
c.Height = c.size(m, c.data) * c.GetHeights()
@ -39,8 +40,8 @@ func (c *Chain) Draw(m *ice.Message, x, y int) wiki.Chart {
}
func (c *Chain) size(m *ice.Message, root map[string]interface{}) (height int) {
meta := kit.GetMeta(root)
if list, ok := root[kit.MDB_LIST].([]interface{}); ok && len(list) > 0 {
kit.Fetch(root[kit.MDB_LIST], func(index int, value map[string]interface{}) {
if list, ok := root[mdb.LIST].([]interface{}); ok && len(list) > 0 {
kit.Fetch(root[mdb.LIST], func(index int, value map[string]interface{}) {
height += c.size(m, value)
})
} else {
@ -69,7 +70,7 @@ func (c *Chain) draw(m *ice.Message, root map[string]interface{}, x, y int, p *B
MarginY: p.MarginY,
}
item.x, item.y = x, y+(kit.Int(meta[wiki.HEIGHT])-1)*c.GetHeights()/2
item.Init(m, kit.Format(meta[kit.MDB_TEXT])).Data(m, meta)
item.Init(m, kit.Format(meta[mdb.TEXT])).Data(m, meta)
item.Draw(m, item.x, item.y)
// 画面尺寸
@ -90,7 +91,7 @@ func (c *Chain) draw(m *ice.Message, root map[string]interface{}, x, y int, p *B
// 递归节点
h, x := 0, x+item.GetWidths()
if kit.Fetch(root[kit.MDB_LIST], func(index int, value map[string]interface{}) {
if kit.Fetch(root[mdb.LIST], func(index int, value map[string]interface{}) {
h += c.draw(m, value, x, y+h, item)
}); h == 0 {
return item.GetHeights()

5
core/wiki/chart/label.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/core/wiki"
kit "shylinux.com/x/toolkits"
)
@ -26,7 +27,7 @@ func (l *Label) Init(m *ice.Message, arg ...string) wiki.Chart {
for i, v := range ls {
switch data := kit.Parse(nil, "", kit.Split(v)...).(type) {
case map[string]interface{}:
v = kit.Select("", data[kit.MDB_TEXT])
v = kit.Select("", data[mdb.TEXT])
}
if w := l.GetWidth(v); w > l.max[i] {
l.max[i] = w
@ -52,7 +53,7 @@ func (l *Label) Draw(m *ice.Message, x, y int) wiki.Chart {
item = &Block{FontSize: l.FontSize, Padding: l.Padding, MarginX: l.MarginX, MarginY: l.MarginY}
switch data := kit.Parse(nil, "", kit.Split(text)...).(type) {
case map[string]interface{}:
item.Init(m, kit.Select(text, data[kit.MDB_TEXT])).Data(m, data)
item.Init(m, kit.Select(text, data[mdb.TEXT])).Data(m, data)
default:
item.Init(m, text)
}

28
core/wiki/chart/sequence.go
View File

@ -4,6 +4,7 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/core/wiki"
kit "shylinux.com/x/toolkits"
@ -20,7 +21,7 @@ func (s *Sequence) push(m *ice.Message, list string, arg ...interface{}) map[str
node, node_list := kit.Dict(arg...), kit.Int(list)
s.List[node_list] = append(s.List[node_list], node)
_max := kit.Max(len(s.List[node_list])-1, s.pos[node_list])
node[kit.MDB_ORDER], s.pos[node_list] = _max, _max+1
node[ORDER], s.pos[node_list] = _max, _max+1
return node
}
func (s *Sequence) Init(m *ice.Message, arg ...string) wiki.Chart {
@ -44,12 +45,12 @@ func (s *Sequence) Init(m *ice.Message, arg ...string) wiki.Chart {
to_node = s.push(m, ls[i+1])
list[ls[i+1]] = to_node
_max := kit.Max(kit.Int(from_node[kit.MDB_ORDER]), kit.Int(to_node[kit.MDB_ORDER]))
_max := kit.Max(kit.Int(from_node[ORDER]), kit.Int(to_node[ORDER]))
s.pos[kit.Int(ls[i-1])], s.pos[kit.Int(ls[i+1])] = _max+1, _max+1
from_node[kit.MDB_ORDER], to_node[kit.MDB_ORDER] = _max, _max
from_node[kit.MDB_TEXT], from_node[kit.MDB_NEXT] = ls[i], ls[i+1]
from_node[ORDER], to_node[ORDER] = _max, _max
from_node[mdb.TEXT], from_node[mdb.NEXT] = ls[i], ls[i+1]
} else {
from_node[kit.MDB_ECHO], from_node[kit.MDB_PREV] = ls[i], ls[i+1]
from_node[ECHO], from_node[PREV] = ls[i], ls[i+1]
}
from_node = to_node
}
@ -89,29 +90,29 @@ func (s *Sequence) Draw(m *ice.Message, x, y int) wiki.Chart {
for i, x := range line_pos {
for _, v := range s.List[i] {
pos := kit.Int(v[kit.MDB_ORDER])
pos := kit.Int(v[ORDER])
g.EchoRect(RECT, rect_height, rect_width, x-rect_width/2, y+pos*(rect_height+s.MarginY)+s.MarginY, "2", "2")
yy := y + pos*(rect_height+s.MarginY) + s.MarginY + rect_height/4
if kit.Format(v[kit.MDB_NEXT]) != "" {
xx := line_pos[kit.Int(v[kit.MDB_NEXT])]
if kit.Format(v[mdb.NEXT]) != "" {
xx := line_pos[kit.Int(v[mdb.NEXT])]
if x < xx {
g.EchoArrowLine(NEXT, x+rect_width/2, yy, xx-rect_width/2-arrow_width, yy)
} else {
g.EchoArrowLine(NEXT, x-rect_width/2, yy, xx+rect_width/2+arrow_width, yy)
}
g.EchoText(TEXT, (x+xx)/2, yy, kit.Format(v[kit.MDB_TEXT]))
g.EchoText(TEXT, (x+xx)/2, yy, kit.Format(v[mdb.TEXT]))
}
yy += rect_height / 2
if kit.Format(v[kit.MDB_PREV]) != "" {
xx := line_pos[kit.Int(v[kit.MDB_PREV])]
if kit.Format(v[PREV]) != "" {
xx := line_pos[kit.Int(v[PREV])]
if x < xx {
g.EchoArrowLine(PREV, x+rect_width/2, yy, xx-rect_width/2-arrow_width, yy)
} else {
g.EchoArrowLine(PREV, x-rect_width/2, yy, xx+rect_width/2+arrow_width, yy)
}
g.EchoText(ECHO, (x+xx)/2, yy, kit.Format(v[kit.MDB_ECHO]))
g.EchoText(ECHO, (x+xx)/2, yy, kit.Format(v[ECHO]))
}
}
}
@ -122,6 +123,9 @@ func (s *Sequence) Draw(m *ice.Message, x, y int) wiki.Chart {
return s
}
const (
ORDER = "order"
)
const (
ARROW = "arrow"

2
core/wiki/data.go
View File

@ -11,7 +11,7 @@ const DATA = "data"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
DATA: {Name: DATA, Help: "数据表格", Value: kit.Data(
nfs.PATH, ice.USR_LOCAL_EXPORT, kit.MDB_REGEXP, ".*\\.csv",
nfs.PATH, ice.USR_LOCAL_EXPORT, REGEXP, ".*\\.csv",
)},
}, Commands: map[string]*ice.Command{
DATA: {Name: "data path auto", Help: "数据表格", Meta: kit.Dict(

2
core/wiki/draw.go
View File

@ -11,7 +11,7 @@ const DRAW = "draw"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
DRAW: {Name: DRAW, Help: "思维导图", Value: kit.Data(kit.MDB_REGEXP, ".*\\.svg")},
DRAW: {Name: DRAW, Help: "思维导图", Value: kit.Data(REGEXP, ".*\\.svg")},
}, Commands: map[string]*ice.Command{
DRAW: {Name: "draw path=src/main.svg pid refresh:button=auto edit save actions", Help: "思维导图", Meta: kit.Dict(
ice.DisplayLocal(""),

2
core/wiki/feel.go
View File

@ -16,7 +16,7 @@ const FEEL = "feel"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
FEEL: {Name: FEEL, Help: "影音媒体", Value: kit.Data(
nfs.PATH, ice.USR_LOCAL_IMAGE, kit.MDB_REGEXP, ".*.(png|PNG|jpg|JPG|jpeg|mp4|m4v|MOV)",
nfs.PATH, ice.USR_LOCAL_IMAGE, REGEXP, ".*.(png|PNG|jpg|JPG|jpeg|mp4|m4v|MOV)",
)},
}, Commands: map[string]*ice.Command{
FEEL: {Name: "feel path auto upload 上一页 下一页 actions", Help: "影音媒体", Meta: kit.Dict(

14
core/wiki/field.go
View File

@ -5,6 +5,8 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -39,8 +41,8 @@ func _field_show(m *ice.Message, name, text string, arg ...string) {
})
name = strings.ReplaceAll(name, ice.SP, "_")
meta[kit.MDB_NAME] = name
meta[kit.MDB_INDEX] = text
meta[mdb.NAME] = name
meta[mdb.INDEX] = text
// 扩展参数
for i := 0; i < len(arg)-1; i += 2 {
@ -67,7 +69,7 @@ func _field_show(m *ice.Message, name, text string, arg ...string) {
count := 0
kit.Fetch(meta[INPUTS], func(index int, value map[string]interface{}) {
if value[kit.MDB_TYPE] != kit.MDB_BUTTON {
if value[mdb.TYPE] != kit.MDB_BUTTON {
count++
}
})
@ -76,14 +78,14 @@ func _field_show(m *ice.Message, name, text string, arg ...string) {
list := meta[INPUTS].([]interface{})
for i := count; i < len(args); i++ {
list = append(list, kit.Dict(
kit.MDB_TYPE, "text", kit.MDB_NAME, "args", kit.MDB_VALUE, args[i],
mdb.TYPE, "text", mdb.NAME, "args", mdb.VALUE, args[i],
))
}
meta[INPUTS] = list
}
}
}
m.Option(kit.MDB_META, meta)
m.Option(mdb.META, meta)
// 渲染引擎
_wiki_template(m, FIELD, name, text)
@ -108,7 +110,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
FIELD: {Name: FIELD, Help: "插件", Value: kit.Data(
kit.MDB_TEMPLATE, `<fieldset {{.OptionTemplate}}" data-meta='{{.Optionv "meta"|Format}}'>
nfs.TEMPLATE, `<fieldset {{.OptionTemplate}}" data-meta='{{.Optionv "meta"|Format}}'>
<legend>{{.Option "name"}}</legend>
<form class="option"></form>
<div class="action"></div>

3
core/wiki/image.go
View File

@ -14,6 +14,7 @@ func _image_show(m *ice.Message, text string, arg ...string) {
}
const (
IMG = "img"
PNG = "png"
JPG = "jpg"
JPEG = "jpeg"
@ -34,7 +35,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
IMAGE: {Name: IMAGE, Help: "图片", Value: kit.Data(
kit.MDB_TEMPLATE, `<img {{.OptionTemplate}} title="{{.Option "text"}}" src="{{.Option "text"}}">`,
nfs.TEMPLATE, `<img {{.OptionTemplate}} title="{{.Option "text"}}" src="{{.Option "text"}}">`,
nfs.PATH, ice.USR_LOCAL_IMAGE,
)},
}})

2
core/wiki/json.go
View File

@ -52,7 +52,7 @@ const JSON = "json"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
JSON: {Name: JSON, Help: "数据结构", Value: kit.Data(
nfs.PATH, ice.USR_LOCAL_EXPORT, kit.MDB_REGEXP, ".*\\.json",
nfs.PATH, ice.USR_LOCAL_EXPORT, REGEXP, ".*\\.json",
)},
}, Commands: map[string]*ice.Command{
JSON: {Name: "json path auto", Help: "数据结构", Meta: kit.Dict(

2
core/wiki/local.go
View File

@ -21,7 +21,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
LOCAL: {Name: LOCAL, Help: "文件", Value: kit.Data(
kit.MDB_TEMPLATE, `<code {{.OptionTemplate}}>{{range $index, $value := .Optionv "input"}}{{$value}}{{end}}</code>`,
nfs.TEMPLATE, `<code {{.OptionTemplate}}>{{range $index, $value := .Optionv "input"}}{{$value}}{{end}}</code>`,
)},
}})
}

6
core/wiki/order.go
View File

@ -4,11 +4,13 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
func _order_show(m *ice.Message, text string, arg ...string) {
m.Optionv(kit.MDB_LIST, kit.Split(strings.TrimSpace(text), ice.NL))
m.Optionv(mdb.LIST, kit.Split(strings.TrimSpace(text), ice.NL))
_wiki_template(m, ORDER, "", text, arg...)
}
@ -21,7 +23,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
ORDER: {Name: ORDER, Help: "列表", Value: kit.Data(
kit.MDB_TEMPLATE, `<ul {{.OptionTemplate}}>{{range $index, $value := .Optionv "list"}}<li>{{$value}}</li>{{end}}</ul>`,
nfs.TEMPLATE, `<ul {{.OptionTemplate}}>{{range $index, $value := .Optionv "list"}}<li>{{$value}}</li>{{end}}</ul>`,
)},
}})
}

4
core/wiki/poems.go
View File

@ -15,13 +15,13 @@ const poems = "poems"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
poems: {Name: "poems", Help: "诗词", Value: kit.Data(
kit.MDB_SHORT, AUTHOR,
mdb.SHORT, AUTHOR,
)},
}, Commands: map[string]*ice.Command{
poems: {Name: "poems author title auto insert", Help: "诗词", Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert author title content:textarea", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.INSERT, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(AUTHOR))
m.Conf(poems, kit.KeyHash(m.Option(AUTHOR), kit.MDB_META, kit.MDB_SHORT), TITLE)
m.Conf(poems, kit.KeyHash(m.Option(AUTHOR), mdb.META, mdb.SHORT), TITLE)
m.Cmd(mdb.INSERT, m.PrefixKey(), kit.KeyHash(m.Option(AUTHOR)), mdb.HASH, arg[2:])
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

6
core/wiki/refer.go
View File

@ -5,6 +5,8 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -17,7 +19,7 @@ func _refer_show(m *ice.Message, text string, arg ...string) {
list = append(list, ls)
}
}
m.Optionv(kit.MDB_LIST, list)
m.Optionv(mdb.LIST, list)
_wiki_template(m, REFER, "", text, arg...)
}
@ -30,7 +32,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
REFER: {Name: REFER, Help: "参考", Value: kit.Data(
kit.MDB_TEMPLATE, `<ul {{.OptionTemplate}}>{{range $index, $value := .Optionv "list"}}<li>{{index $value 0}}: <a href="{{index $value 1}}" target="_blank">{{index $value 1}}</a></li>{{end}}</ul>`,
nfs.TEMPLATE, `<ul {{.OptionTemplate}}>{{range $index, $value := .Optionv "list"}}<li>{{index $value 0}}: <a href="{{index $value 1}}" target="_blank">{{index $value 1}}</a></li>{{end}}</ul>`,
)},
}})
}

3
core/wiki/shell.go
View File

@ -3,6 +3,7 @@ package wiki
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -25,7 +26,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
SHELL: {Name: SHELL, Help: "命令", Value: kit.Data(
kit.MDB_TEMPLATE, `<code {{.OptionTemplate}}>$ {{.Option "input"}} # {{.Option "name"}}
nfs.TEMPLATE, `<code {{.OptionTemplate}}>$ {{.Option "input"}} # {{.Option "name"}}
{{.Option "output"}}</code>`,
)},
}})

3
core/wiki/spark.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/ssh"
kit "shylinux.com/x/toolkits"
)
@ -82,7 +83,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
SPARK: {Name: SPARK, Help: "段落", Value: kit.Data(
kit.MDB_TEMPLATE, `<p {{.OptionTemplate}}>{{.Option "text"}}</p>`,
nfs.TEMPLATE, `<p {{.OptionTemplate}}>{{.Option "text"}}</p>`,
ssh.PROMPT, kit.Dict(SHELL, "$ "),
)},
}})

3
core/wiki/table.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -70,7 +71,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
TABLE: {Name: TABLE, Help: "表格", Value: kit.Data(
kit.MDB_TEMPLATE, `<table {{.OptionTemplate}}>
nfs.TEMPLATE, `<table {{.OptionTemplate}}>
<tr>{{range $i, $v := .Optionv "head"}}<th>{{$v}}</th>{{end}}</tr>
{{range $index, $value := .Optionv "list"}}
<tr>{{range $i, $v := $value}}<td>{{$v}}</td>{{end}}</tr>

28
core/wiki/title.go
View File

@ -5,6 +5,8 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -36,7 +38,7 @@ func _title_parse(m *ice.Message, dir string, root map[string]interface{}, list
ls[1] = path.Join(dir, ls[1])
}
meta := kit.Dict(kit.MDB_NAME, kit.Select("", ls, 0), kit.MDB_LINK, kit.Select("", ls, 1))
meta := kit.Dict(mdb.NAME, kit.Select("", ls, 0), mdb.LINK, kit.Select("", ls, 1))
for i := 2; i < len(ls); i += 2 {
meta[ls[i]] = ls[i+1]
}
@ -67,26 +69,26 @@ func _title_show(m *ice.Message, kind, text string, arg ...string) {
case SECTION: // 分节标题
title[SECTION]++
m.Option(kit.MDB_LEVEL, "h3")
m.Option(kit.MDB_PREFIX, kit.Format("%d.%d ", title[CHAPTER], title[SECTION]))
m.Option(LEVEL, "h3")
m.Option(PREFIX, kit.Format("%d.%d ", title[CHAPTER], title[SECTION]))
case CHAPTER: // 章节标题
title[CHAPTER]++
title[SECTION] = 0
m.Option(kit.MDB_LEVEL, "h2")
m.Option(kit.MDB_PREFIX, kit.Format("%d ", title[CHAPTER]))
m.Option(LEVEL, "h2")
m.Option(PREFIX, kit.Format("%d ", title[CHAPTER]))
default: // 文章标题
m.Option(kit.MDB_LEVEL, "h1")
m.Option(kit.MDB_PREFIX, "")
m.Option(LEVEL, "h1")
m.Option(PREFIX, "")
}
// 渲染引擎
_wiki_template(m, TITLE, "", text, arg...)
// 添加目录
menu, _ := m.Optionv(kit.MDB_MENU).(map[string]interface{})
menu[kit.MDB_LIST] = append(menu[kit.MDB_LIST].([]interface{}), kit.Dict(m.OptionSimple("level,prefix,text")))
menu, _ := m.Optionv(MENU).(map[string]interface{})
menu[mdb.LIST] = append(menu[mdb.LIST].([]interface{}), kit.Dict(m.OptionSimple("level,prefix,text")))
}
const (
@ -97,6 +99,12 @@ const (
ENDMENU = "endmenu"
)
const (
REGEXP = "regexp"
PREFIX = "prefix"
LEVEL = "level"
MENU = "menu"
)
const TITLE = "title"
func init() {
@ -119,7 +127,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
TITLE: {Name: TITLE, Help: "标题", Value: kit.Data(
kit.MDB_TEMPLATE, `<{{.Option "level"}} {{.OptionTemplate}}>{{.Option "prefix"}} {{.Option "text"}}</{{.Option "level"}}>`,
nfs.TEMPLATE, `<{{.Option "level"}} {{.OptionTemplate}}>{{.Option "prefix"}} {{.Option "text"}}</{{.Option "level"}}>`,
PREMENU, `<ul {{.OptionTemplate}}></ul>`,
ENDMENU, `<ul {{.OptionTemplate}}>{{$menu := .Optionv "menu"}}
{{range $index, $value := Value $menu "list"}}<li>{{Value $value "prefix"}} {{Value $value "text"}}</li>{{end}}

2
core/wiki/video.go
View File

@ -32,7 +32,7 @@ func init() {
}},
}, Configs: map[string]*ice.Config{
VIDEO: {Name: "video", Help: "视频", Value: kit.Data(
kit.MDB_TEMPLATE, `<video {{.OptionTemplate}} title="{{.Option "text"}}" src="{{.Option "text"}}" controls></video>`,
nfs.TEMPLATE, `<video {{.OptionTemplate}} title="{{.Option "text"}}" src="{{.Option "text"}}" controls></video>`,
nfs.PATH, ice.USR_LOCAL_IMAGE,
)},
}})

11
core/wiki/wiki.go
View File

@ -5,6 +5,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
@ -17,12 +18,12 @@ func _name(m *ice.Message, arg []string) []string {
return arg
}
func _option(m *ice.Message, kind, name, text string, arg ...string) {
m.Option(kit.MDB_TYPE, kind)
m.Option(kit.MDB_NAME, name)
m.Option(kit.MDB_TEXT, text)
m.Option(mdb.TYPE, kind)
m.Option(mdb.NAME, name)
m.Option(mdb.TEXT, text)
extra := kit.Dict()
m.Optionv(kit.MDB_EXTRA, extra)
m.Optionv(mdb.EXTRA, extra)
for i := 0; i < len(arg); i += 2 {
extra[arg[i]] = kit.Format(kit.Parse(nil, "", kit.Split(arg[i+1])...))
}
@ -65,7 +66,7 @@ func _wiki_upload(m *ice.Message, cmd string, dir string) {
}
func _wiki_template(m *ice.Message, cmd string, name, text string, arg ...string) {
_option(m, cmd, name, strings.TrimSpace(text), arg...)
m.RenderTemplate(m.Conf(cmd, kit.Keym(kit.MDB_TEMPLATE)))
m.RenderTemplate(m.Conf(cmd, kit.Keym(nfs.TEMPLATE)))
}
const WIKI = "wiki"

6
core/wiki/word.go
View File

@ -13,7 +13,7 @@ import (
func _word_show(m *ice.Message, name string, arg ...string) {
m.Set(ice.MSG_RESULT)
m.Option(TITLE, map[string]int{})
m.Option(kit.MDB_MENU, kit.Dict(kit.MDB_LIST, []interface{}{}))
m.Option(MENU, kit.Dict(mdb.LIST, []interface{}{}))
m.Option(ice.MSG_ALIAS, m.Confv(WORD, kit.Keym(kit.MDB_ALIAS)))
m.Option(nfs.DIR_ROOT, _wiki_path(m, WORD))
@ -25,7 +25,7 @@ const WORD = "word"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
WORD: {Name: WORD, Help: "语言文字", Value: kit.Data(
nfs.PATH, "", kit.MDB_REGEXP, ".*\\.shy", kit.MDB_ALIAS, kit.Dict(
nfs.PATH, "", REGEXP, ".*\\.shy", kit.MDB_ALIAS, kit.Dict(
NAVMENU, kit.List(TITLE, NAVMENU),
PREMENU, kit.List(TITLE, PREMENU),
CHAPTER, kit.List(TITLE, CHAPTER),
@ -47,7 +47,7 @@ func init() {
}},
"play": {Name: "play", Help: "演示"},
}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_REG, m.Config(kit.MDB_REGEXP))
m.Option(nfs.DIR_REG, m.Config(REGEXP))
if m.Option(nfs.DIR_DEEP, ice.TRUE); !_wiki_list(m, cmd, arg...) {
_word_show(m, arg[0])
}

1
go.mod
View File

@ -4,6 +4,7 @@ go 1.11
require (
shylinux.com/x/go-qrcode v0.0.1
shylinux.com/x/ice v0.4.7
shylinux.com/x/toolkits v0.4.3
shylinux.com/x/websocket v0.0.1
)

3
go.sum
View File

@ -1,5 +1,8 @@
shylinux.com/x/go-qrcode v0.0.1 h1:/eOGqMj1qtgs9Ymd12zTUa1gcJZs9S92kj2lb0QzKsE=
shylinux.com/x/go-qrcode v0.0.1/go.mod h1:KAbtU+KwiiABMZ/CJ0zh9PI2AX82Uf9rRYcQ4ODm4po=
shylinux.com/x/ice v0.4.7 h1:Ed7FVPMoBufLJrNfRfaLkYM1YyGfQcsguKZWjaQkiRI=
shylinux.com/x/ice v0.4.7/go.mod h1:nQaisRsVHtTZT2FWr97VE984xhfEDpcBpYJUbx8qX94=
shylinux.com/x/icebergs v0.7.8/go.mod h1:frbUQPPU+TaMODwp701HIATVaApfQPtA2Q3MtO1El5A=
shylinux.com/x/toolkits v0.4.3 h1:eDCYnfsU5JCRU3qG9e3n15K+37TNCtje8/tyfRWauV4=
shylinux.com/x/toolkits v0.4.3/go.mod h1:8LbYHe7oxBIqb6s4MSOD+4d28QvPdvkyCVtwB/JW7AA=
shylinux.com/x/websocket v0.0.1 h1:OBc21DxqsGlQ2+Pz76xqLyDNo1LV+PUUqfWi+1PZPDE=

43
misc.go
View File

@ -4,7 +4,6 @@ import (
"bytes"
"encoding/csv"
"net/url"
"path"
"reflect"
"strings"
@ -85,20 +84,6 @@ func (m *Message) Split(str string, arg ...string) *Message {
return m
}
func (m *Message) Display(file string, arg ...interface{}) *Message {
m.Option(MSG_DISPLAY, kit.MergeURL(Display0(2, file)["display"], arg...))
return m
}
func (m *Message) DisplayLocal(file string) *Message {
if file == "" {
file = path.Join(kit.PathName(2), kit.Keys(kit.FileName(2), "js"))
}
if !strings.HasPrefix(file, PS) {
file = path.Join("/plugin/local", file)
}
m.Option(MSG_DISPLAY, Display0(2, file)["display"])
return m
}
func (m *Message) FieldsIsDetail() bool {
if m.OptionFields() == "detail" {
return true
@ -108,6 +93,9 @@ func (m *Message) FieldsIsDetail() bool {
}
return false
}
func (m *Message) IsErr(str string) bool { return m.Result(1) == str }
func (m *Message) IsErrNotFound() bool { return m.Result(1) == ErrNotFound }
func (m *Message) OptionCB(key string, cb ...interface{}) interface{} {
if len(cb) > 0 {
return m.Optionv(kit.Keycb(key), cb...)
@ -220,7 +208,9 @@ func (m *Message) cmd(arg ...interface{}) *Message {
}
// 查找命令
if cmd, ok := m.target.Commands[strings.TrimPrefix(list[0], m.target.Cap(CTX_FOLLOW)+PT)]; ok {
if list[0] == "" {
run(m.Spawn(), m.target, m._cmd, list[0], list[1:]...)
} else if cmd, ok := m.target.Commands[strings.TrimPrefix(list[0], m.target.Cap(CTX_FOLLOW)+PT)]; ok {
run(m.Spawn(), m.target, cmd, list[0], list[1:]...)
} else if cmd, ok := m.source.Commands[strings.TrimPrefix(list[0], m.source.Cap(CTX_FOLLOW)+PT)]; ok {
run(m.Spawn(m.source), m.source, cmd, list[0], list[1:]...)
@ -349,27 +339,6 @@ func (c *Context) split(name string) (list []interface{}) {
return list
}
func Display(file string, arg ...string) map[string]string {
return Display0(2, file, arg...)
}
func DisplayLocal(file string, arg ...string) map[string]string {
if file == "" {
file = path.Join(kit.PathName(2), kit.FileName(2)+".js")
}
if !strings.HasPrefix(file, "/") {
file = path.Join("/plugin/local", file)
}
return Display0(2, file, arg...)
}
func Display0(n int, file string, arg ...string) map[string]string {
if file == "" {
file = kit.FileName(n+1) + ".js"
}
if !strings.HasPrefix(file, "/") {
file = path.Join("/require", kit.ModPath(n+1, file))
}
return map[string]string{"display": file, kit.MDB_STYLE: kit.Join(arg, SP)}
}
func MergeAction(list ...interface{}) map[string]*Action {
if len(list) == 0 {
return nil

26
misc/alpha/alpha.go
View File

@ -27,27 +27,27 @@ func _alpha_find(m *ice.Message, method, word string) {
// 搜索词汇
msg := m.Cmd(cli.SYSTEM, "grep", "-rih", word, m.Config(kit.MDB_STORE))
msg.CSV(msg.Result(), kit.Split(m.Config(kit.MDB_FIELD))...).Table(func(index int, value map[string]string, head []string) {
msg.CSV(msg.Result(), kit.Split(m.Config(mdb.FIELD))...).Table(func(index int, value map[string]string, head []string) {
if m.FieldsIsDetail() {
m.Push(mdb.DETAIL, value, kit.Split(m.Config(kit.MDB_FIELD)))
m.Push(kit.MDB_TIME, m.Time())
m.Push(mdb.DETAIL, value, kit.Split(m.Config(mdb.FIELD)))
m.Push(mdb.TIME, m.Time())
return
}
m.PushSearch(ice.CMD, ALPHA, kit.MDB_TYPE, method, kit.MDB_NAME, value[WORD], kit.MDB_TEXT, value["translation"], value)
m.PushSearch(ice.CMD, ALPHA, mdb.TYPE, method, mdb.NAME, value[WORD], mdb.TEXT, value["translation"], value)
})
}
func _alpha_load(m *ice.Message, file, name string) {
// 清空数据
meta := m.Confm(ALPHA, kit.MDB_META)
meta := m.Confm(ALPHA, mdb.META)
m.Assert(os.RemoveAll(path.Join(kit.Format(meta[kit.MDB_STORE]), name)))
m.Conf(ALPHA, name, "")
// 缓存配置
m.Conf(ALPHA, kit.Keys(name, kit.MDB_META), kit.Dict(meta))
m.Cmd(mdb.IMPORT, ALPHA, name, kit.MDB_LIST, file)
m.Conf(ALPHA, kit.Keys(name, mdb.META), kit.Dict(meta))
m.Cmd(mdb.IMPORT, ALPHA, name, mdb.LIST, file)
// 保存词库
m.Conf(ALPHA, kit.Keys(name, kit.Keym(kit.MDB_LIMIT)), 0)
m.Conf(ALPHA, kit.Keys(name, kit.Keym(mdb.LIMIT)), 0)
m.Conf(ALPHA, kit.Keys(name, kit.Keym(kit.MDB_LEAST)), 0)
m.Echo("%s: %d", name, m.Grow(ALPHA, name, kit.Dict(WORD, ice.SP)))
}
@ -61,14 +61,14 @@ const ALPHA = "alpha"
var Index = &ice.Context{Name: ALPHA, Help: "英汉词典", Configs: map[string]*ice.Config{
ALPHA: {Name: ALPHA, Help: "英汉词典", Value: kit.Data(
nfs.REPOS, "word-dict", kit.MDB_FIELD, "word,translation,definition",
nfs.REPOS, "word-dict", mdb.FIELD, "word,translation,definition",
kit.MDB_STORE, path.Join(ice.USR_LOCAL_EXPORT, ALPHA), kit.MDB_FSIZE, "300000",
kit.MDB_LIMIT, "50000", kit.MDB_LEAST, "1000",
mdb.LIMIT, "50000", kit.MDB_LEAST, "1000",
)},
}, Commands: map[string]*ice.Command{
ALPHA: {Name: "alpha method=word,line word auto", Help: "英汉", Action: map[string]*ice.Action{
mdb.IMPORT: {Name: "import file=usr/word-dict/ecdict name=ecdict", Help: "加载词库", Hand: func(m *ice.Message, arg ...string) {
_alpha_load(m, m.Option(nfs.FILE), kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(kit.MDB_NAME)))
_alpha_load(m, m.Option(nfs.FILE), kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.NAME)))
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == ALPHA {
@ -83,7 +83,7 @@ var Index = &ice.Context{Name: ALPHA, Help: "英汉词典", Configs: map[string]
m.Cmdy(CACHE, kit.Select("", arg, 1))
return
}
defer m.StatusTimeCountTotal(m.Config(kit.MDB_COUNT))
defer m.StatusTimeCountTotal(m.Config(mdb.COUNT))
if arg[0] == WORD {
if msg := m.Cmd(CACHE, arg[1]); msg.Length() > 0 {
m.Copy(msg)
@ -91,7 +91,7 @@ var Index = &ice.Context{Name: ALPHA, Help: "英汉词典", Configs: map[string]
}
m.OptionFields(mdb.DETAIL)
} else {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.OptionFields(m.Config(mdb.FIELD))
}
if _alpha_find(m, arg[0], arg[1]); arg[0] == WORD && m.Length() > 0 {
m.Cmd(CACHE, mdb.CREATE, m.AppendSimple())

Some files were not shown because too many files have changed in this diff Show More