x/icebergs
1
0
Fork 1
mirror of https://shylinux.com/x/icebergs synced 2025-04-25 17:18:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

opt chat

Browse Source
This commit is contained in:
harveyshao 2021-07-28 17:45:28 +08:00
parent b015003088
commit 56a48845a3
56 changed files with 592 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/aaa/user.go
View File

@ -36,7 +36,7 @@ func _user_search(m *ice.Message, kind, name, text string) {
if value = kit.GetMeta(value); name != "" && name != value[USERNAME] {
return
}
m.PushSearch(kit.SSH_CMD, USER, kit.MDB_TYPE, kit.Format(UserRole(m, value[USERNAME])),
m.PushSearch("cmd", USER, kit.MDB_TYPE, kit.Format(UserRole(m, value[USERNAME])),
kit.MDB_NAME, kit.Format(value[USERNICK]), kit.MDB_TEXT, kit.Format(value[USERNAME]), value)
})
}

15
base/cli/daemon.go
View File

@ -3,7 +3,6 @@ package cli
import (
"io"
"os/exec"
"path"
"strings"
ice "github.com/shylinux/icebergs"
@ -38,9 +37,9 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
m.Go(func() {
h := m.Cmdx(mdb.INSERT, DAEMON, "", mdb.HASH,
kit.MDB_STATUS, START, kit.SSH_PID, cmd.Process.Pid,
kit.SSH_CMD, strings.Join(cmd.Args, " "),
kit.SSH_DIR, cmd.Dir, kit.SSH_ENV, kit.Select("", cmd.Env),
kit.MDB_STATUS, START, PID, cmd.Process.Pid,
CMD, strings.Join(cmd.Args, " "),
DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
mdb.CACHE_CLEAR_ON_EXIT, m.Option(mdb.CACHE_CLEAR_ON_EXIT),
CMD_OUTPUT, out, CMD_ERRPUT, err,
)
@ -67,7 +66,7 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
})
}
func Inputs(m *ice.Message, field, value string) bool {
func Inputs(m *ice.Message, field string) bool {
switch strings.TrimPrefix(field, "extra.") {
case POD:
m.Cmdy("route")
@ -107,6 +106,8 @@ const (
BENCH = "bench"
PPROF = "pprof"
OPEN = "open"
CLOSE = "close"
START = "start"
RESTART = "restart"
RELOAD = "reload"
@ -118,7 +119,7 @@ const DAEMON = "daemon"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(kit.MDB_PATH, path.Join(ice.USR_LOCAL, DAEMON))},
DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_DAEMON)},
},
Commands: map[string]*ice.Command{
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -140,7 +141,7 @@ func init() {
m.Option(mdb.FIELDS, "time,hash,status,pid,cmd,dir,env")
m.Cmd(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH)).Table(func(index int, value map[string]string, head []string) {
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), kit.MDB_STATUS, STOP)
m.Cmdy(SYSTEM, "kill", "-9", value[kit.SSH_PID])
m.Cmdy(SYSTEM, "kill", "-9", value[PID])
})
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {

2
base/ctx/command.go
View File

@ -41,7 +41,7 @@ func _command_search(m *ice.Message, kind, name, text string) {
return
}
m.PushSearch(kit.SSH_CMD, COMMAND, CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key,
m.PushSearch("cmd", COMMAND, CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key,
kit.MDB_TYPE, kind, kit.MDB_NAME, key, kit.MDB_TEXT, s.Cap(ice.CTX_FOLLOW),
)
})

7
base/gdb/event.go
View File

@ -2,18 +2,19 @@ package gdb
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
func _event_listen(m *ice.Message, event string, cmd string) {
h := m.Cmdx(mdb.INSERT, EVENT, "", mdb.HASH, EVENT, event)
m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, kit.SSH_CMD, cmd)
m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, cli.CMD, cmd)
}
func _event_action(m *ice.Message, event string, arg ...string) {
m.Option(mdb.FIELDS, "time,id,cmd")
m.Cmd(mdb.SELECT, EVENT, kit.Keys(kit.MDB_HASH, kit.Hashs(event)), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
m.Cmd(kit.Split(value[kit.SSH_CMD]), event, arg).Cost(EVENT, event, kit.SSH_ARG, arg)
m.Cmd(kit.Split(value[cli.CMD]), event, arg).Cost(EVENT, event, cli.ARG, arg)
})
}
@ -27,7 +28,7 @@ func init() {
Commands: map[string]*ice.Command{
EVENT: {Name: "event event id auto listen", Help: "事件流", Action: map[string]*ice.Action{
LISTEN: {Name: "listen event cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
_event_listen(m, m.Option(EVENT), m.Option(kit.SSH_CMD))
_event_listen(m, m.Option(EVENT), m.Option(cli.CMD))
}},
ACTION: {Name: "action event arg", Help: "触发", Hand: func(m *ice.Message, arg ...string) {
_event_action(m, m.Option(EVENT), arg[2:]...)

4
base/gdb/gdb.go
View File

@ -52,8 +52,8 @@ var Index = &ice.Context{Name: GDB, Help: "事件模块",
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, "退出", kit.SSH_CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", kit.SSH_CMD, "exit 1")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", cli.CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", cli.CMD, "exit 1")
m.Load()
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

6
base/gdb/routine.go
View File

@ -42,12 +42,12 @@ func init() {
INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
switch kit.Select("", arg, 0) {
case kit.SSH_RUN:
case cli.RUN:
m.Cmdy(INNER, arg[1:])
default:
ls := kit.Split(m.Option("fileline"), ":")
m.ProcessField(INNER, kit.SSH_RUN)
m.Option(kit.SSH_ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
m.ProcessField(INNER, cli.RUN)
m.Option(cli.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
m.Cmdy(ctx.COMMAND, INNER)
}
}},

3
base/gdb/signal.go
View File

@ -7,6 +7,7 @@ import (
"syscall"
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
@ -21,7 +22,7 @@ func _signal_action(m *ice.Message, s int) {
m.Option(mdb.FIELDS, "time,signal,name,cmd")
msg := m.Cmd(mdb.SELECT, SIGNAL, "", mdb.HASH, SIGNAL, s)
msg.Table(func(index int, value map[string]string, head []string) {
m.Cmdy(kit.Split(value[kit.SSH_CMD]))
m.Cmdy(kit.Split(value[cli.CMD]))
})
}

4
base/gdb/timer.go
View File

@ -25,8 +25,8 @@ func _timer_action(m *ice.Message, arg ...string) {
if n := kit.Time(kit.Format(value[NEXT])); now > n && order > 0 {
m.Logs(TIMER, kit.MDB_KEY, key, ORDER, order)
msg := m.Cmd(value[kit.SSH_CMD])
m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(kit.SSH_RES, msg.Result()))
msg := m.Cmd(value[cli.CMD])
m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(cli.RES, msg.Result()))
if value[ORDER] = kit.Format(order - 1); order > 1 {
value[NEXT] = msg.Time(value[INTERVAL])
}

6
base/nfs/dir.go
View File

@ -14,6 +14,8 @@ import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
@ -115,7 +117,7 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
}
m.Push(kit.MDB_HASH, kit.Select(hex.EncodeToString(h[:6]), hex.EncodeToString(h[:]), field == kit.MDB_HASH))
case kit.MDB_ACTION:
case ctx.ACTION:
if !f.IsDir() && !aaa.SessIsCli(m) {
m.PushButton(TRASH)
} else {
@ -148,7 +150,7 @@ func _dir_search(m *ice.Message, kind, name string) {
value[kit.MDB_TYPE] = _cat_ext(value[kit.MDB_NAME])
}
m.PushSearch(kit.SSH_CMD, CAT, value)
m.PushSearch(cli.CMD, CAT, value)
})
}

2
base/ssh/channel.go
View File

@ -81,7 +81,7 @@ func init() {
m.Cmdy(mdb.PRUNES, CHANNEL, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(CHANNEL, kit.MDB_ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
m.Cmdy(CHANNEL, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
ctx.COMMAND: {Name: "command cmd=pwd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, CHANNEL, kit.Keys(kit.MDB_HASH, m.Option(kit.MDB_HASH)), mdb.LIST, kit.MDB_TYPE, CMD, kit.MDB_TEXT, m.Option(CMD))

3
base/ssh/scripts.go
View File

@ -154,7 +154,7 @@ func (f *Frame) option(m *ice.Message, ls []string) []string {
if i < j {
m.Option(ls[i][1:], ls[i+1:j+1])
} else {
m.Option(ls[i][1:], "true")
m.Option(ls[i][1:], ice.TRUE)
}
i = j
break
@ -354,6 +354,7 @@ const (
PS2 = "PS2"
)
const (
SCRIPT = "script"
SOURCE = "source"
TARGET = "target"
PROMPT = "prompt"

2
base/ssh/session.go
View File

@ -81,7 +81,7 @@ func init() {
m.ProcessRefresh("300ms")
}},
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SESSION, kit.MDB_ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
m.Cmdy(SESSION, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {

14
base/web/dream.go
View File

@ -63,7 +63,7 @@ func _dream_show(m *ice.Message, name string) {
m.Cmd(nfs.SAVE, miss, m.Conf(DREAM, kit.Keym("miss")))
}
if b, e := ioutil.ReadFile(path.Join(p, m.Conf(gdb.SIGNAL, kit.Keym(kit.SSH_PID)))); e == nil {
if b, e := ioutil.ReadFile(path.Join(p, m.Conf(gdb.SIGNAL, kit.Keym(cli.PID)))); e == nil {
if s, e := os.Stat("/proc/" + string(b)); e == nil && s.IsDir() {
m.Info("already exists %v", string(b))
return // 已经启动
@ -75,13 +75,13 @@ func _dream_show(m *ice.Message, name string) {
m.Optionv(cli.CMD_ENV, kit.Simple(
"ctx_dev", "http://:"+m.Cmd(SERVE).Append(tcp.PORT),
cli.PATH, kit.Path(path.Join(p, kit.SSH_BIN))+":"+kit.Path(kit.SSH_BIN)+":"+os.Getenv(cli.PATH),
"USER", ice.Info.UserName, m.Confv(DREAM, kit.Keym(kit.SSH_ENV)),
"USER", ice.Info.UserName, m.Confv(DREAM, kit.Keym(cli.ENV)),
))
// 启动任务
kit.Path(os.Args[0])
m.Optionv(cli.CMD_ERRPUT, path.Join(p, m.Conf(DREAM, kit.Keym(kit.SSH_ENV, "ctx_log"))))
m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(kit.SSH_CMD)), SPIDE_DEV, SPIDE_DEV, kit.MDB_NAME, name)
m.Optionv(cli.CMD_ERRPUT, path.Join(p, m.Conf(DREAM, kit.Keym(cli.ENV, "ctx_log"))))
m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(cli.CMD)), SPIDE_DEV, SPIDE_DEV, kit.MDB_NAME, name)
m.Event(DREAM_CREATE, kit.MDB_TYPE, m.Option(kit.MDB_TYPE), kit.MDB_NAME, name)
m.Sleep(ice.MOD_TICK)
}
@ -136,9 +136,9 @@ func init() {
}},
},
Configs: map[string]*ice.Config{
DREAM: {Name: DREAM, Help: "梦想家", Value: kit.Data(kit.MDB_PATH, "usr/local/work",
kit.SSH_CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
kit.SSH_ENV, kit.Dict(ice.CTX_LOG, ice.BIN_BOOTLOG),
DREAM: {Name: DREAM, Help: "梦想家", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_WORK,
cli.CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
cli.ENV, kit.Dict(ice.CTX_LOG, ice.BIN_BOOTLOG),
"miss", `#!/bin/bash
[ -f $PWD/.ish/plug.sh ] || [ -f $HOME/.ish/plug.sh ] || git clone ${ISH_CONF_HUB_PROXY:="https://"}github.com/shylinux/intshell $PWD/.ish
[ "$ISH_CONF_PRE" != "" ] || source $PWD/.ish/plug.sh || source $HOME/.ish/plug.sh

15
base/web/route.go
View File

@ -3,6 +3,7 @@ package web
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/nfs"
@ -34,7 +35,7 @@ func _route_list(m *ice.Message) {
// 链接操作
m.Table(func(index int, value map[string]string, field []string) {
m.PushAnchor(value[kit.SSH_ROUTE], kit.MergeURL(m.Option(ice.MSG_USERWEB),
kit.SSH_POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.SSH_ROUTE])))
cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.SSH_ROUTE])))
switch value[kit.MDB_TYPE] {
case WORKER:
@ -81,7 +82,7 @@ func init() {
}},
aaa.INVITE: {Name: "invite", Help: "脚本", Hand: func(m *ice.Message, arg ...string) {
for _, k := range []string{"tmux", "base", "miss"} {
m.Cmdy("web.code.publish", "contexts", k)
m.Cmdy("web.code.publish", ice.CONTEXTS, k)
}
m.EchoScript("shell", "# 共享环境", m.Option(ice.MSG_USERWEB))
@ -89,7 +90,7 @@ func init() {
m.EchoAnchor(m.Option(ice.MSG_USERWEB))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_ACTION) {
switch m.Option(ctx.ACTION) {
case mdb.CREATE:
m.Cmdy(SPACE, m.Option(ROUTE), "web.code.autogen", mdb.INPUTS, arg)
return
@ -116,7 +117,7 @@ func init() {
}},
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Debug(m.Option(ROUTE))
m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(kit.SSH_CTX), m.Option(kit.SSH_CMD)), arg)
m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(cli.CTX), m.Option(cli.CMD)), arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 || arg[0] == "" { // 路由列表
@ -125,17 +126,17 @@ func init() {
}
} else if len(arg) > 2 { // 加载插件
m.ShowPlugin(arg[0], arg[1], arg[2], kit.MDB_ACTION, ctx.COMMAND)
m.ShowPlugin(arg[0], arg[1], arg[2], ctx.ACTION, ctx.COMMAND)
} else if len(arg) > 1 { // 命令列表
m.Cmd(SPACE, arg[0], ctx.CONTEXT, arg[1], ctx.COMMAND).Table(func(index int, value map[string]string, head []string) {
m.Push(kit.SSH_CMD, value[kit.MDB_KEY])
m.Push(cli.CMD, value[kit.MDB_KEY])
m.Push("", value, []string{kit.MDB_NAME, kit.MDB_HELP})
})
} else if len(arg) > 0 { // 模块列表
m.Cmd(SPACE, arg[0], ctx.CONTEXT).Table(func(index int, value map[string]string, head []string) {
m.Push(kit.SSH_CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
m.Push(cli.CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
m.Push("", value, []string{ice.CTX_STATUS, ice.CTX_STREAM, kit.MDB_HELP})
})
}

10
base/web/serve.go
View File

@ -35,7 +35,7 @@ func _serve_main(m *ice.Message, w http.ResponseWriter, r *http.Request) bool {
m.Info("").Info("%s %s %s", r.Header.Get(ice.MSG_USERIP), r.Method, r.URL)
// 参数日志
if m.Conf(SERVE, kit.Keym(LOGHEADERS)) == "true" {
if m.Conf(SERVE, kit.Keym(LOGHEADERS)) == ice.TRUE {
for k, v := range r.Header {
m.Info("%s: %v", k, kit.Format(v))
}
@ -136,7 +136,7 @@ func _serve_handle(key string, cmd *ice.Command, msg *ice.Message, w http.Respon
}
// 请求命令
if msg.Option(ice.MSG_USERPOD, msg.Option(kit.SSH_POD)); msg.Optionv(ice.MSG_CMDS) == nil {
if msg.Option(ice.MSG_USERPOD, msg.Option(cli.POD)); msg.Optionv(ice.MSG_CMDS) == nil {
if p := strings.TrimPrefix(r.URL.Path, key); p != "" {
msg.Optionv(ice.MSG_CMDS, strings.Split(p, "/"))
}
@ -162,7 +162,7 @@ func _serve_login(msg *ice.Message, cmds []string, w http.ResponseWriter, r *htt
// 会话认证
}
if msg.Option(ice.MSG_USERNAME) == "" && tcp.IsLocalHost(msg, msg.Option(ice.MSG_USERIP)) && msg.Conf(SERVE, kit.Keym(tcp.LOCALHOST)) == "true" {
if msg.Option(ice.MSG_USERNAME) == "" && tcp.IsLocalHost(msg, msg.Option(ice.MSG_USERIP)) && msg.Conf(SERVE, kit.Keym(tcp.LOCALHOST)) == ice.TRUE {
aaa.UserRoot(msg)
// 主机认证
}
@ -173,9 +173,9 @@ func _serve_login(msg *ice.Message, cmds []string, w http.ResponseWriter, r *htt
return cmds, msg.Result(0) != ice.ErrWarn && msg.Result() != ice.FALSE
}
if ls := strings.Split(r.URL.Path, "/"); msg.Conf(SERVE, kit.Keym(aaa.BLACK, ls[1])) == "true" {
if ls := strings.Split(r.URL.Path, "/"); msg.Conf(SERVE, kit.Keym(aaa.BLACK, ls[1])) == ice.TRUE {
return cmds, false // 黑名单
} else if msg.Conf(SERVE, kit.Keym(aaa.WHITE, ls[1])) == "true" {
} else if msg.Conf(SERVE, kit.Keym(aaa.WHITE, ls[1])) == ice.TRUE {
if msg.Option(ice.MSG_USERNAME) == "" && msg.Option(SHARE) != "" {
share := msg.Cmd(SHARE, msg.Option(SHARE))
switch share.Append(kit.MDB_TYPE) {

23
base/web/share.go
View File

@ -9,6 +9,7 @@ import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/tcp"
kit "github.com/shylinux/toolkits"
@ -17,10 +18,10 @@ import (
func _share_domain(m *ice.Message) string {
link := m.Conf(SHARE, kit.Keym(kit.MDB_DOMAIN))
if link == "" {
link = m.Cmd(SPACE, SPIDE_DEV, kit.SSH_PWD).Append(kit.MDB_LINK)
link = m.Cmd(SPACE, SPIDE_DEV, cli.PWD).Append(kit.MDB_LINK)
}
if link == "" {
link = m.Cmd(SPACE, SPIDE_SHY, kit.SSH_PWD).Append(kit.MDB_LINK)
link = m.Cmd(SPACE, SPIDE_SHY, cli.PWD).Append(kit.MDB_LINK)
}
if link == "" {
link = kit.Format("http://%s:%s", m.Cmd(tcp.HOST).Append(tcp.IP), m.Cmd(SERVE).Append(tcp.PORT))
@ -28,13 +29,13 @@ func _share_domain(m *ice.Message) string {
return link
}
func _share_cache(m *ice.Message, arg ...string) {
if pod := m.Option(kit.SSH_POD); pod != "" {
m.Option(kit.SSH_POD, "")
if pod := m.Option(cli.POD); pod != "" {
m.Option(cli.POD, "")
msg := m.Cmd(SPACE, pod, CACHE, arg[0])
if msg.Append(kit.MDB_FILE) == "" {
m.Render(ice.RENDER_RESULT, msg.Append(kit.MDB_TEXT))
} else {
m.Option(kit.SSH_POD, pod)
m.Option(cli.POD, pod)
_share_local(m, msg.Append(kit.MDB_FILE))
}
return
@ -57,15 +58,15 @@ func _share_local(m *ice.Message, arg ...string) {
}
}
if m.Option(kit.SSH_POD) != "" { // 远程文件
pp := path.Join(ice.VAR_PROXY, m.Option(kit.SSH_POD), p)
if m.Option(cli.POD) != "" { // 远程文件
pp := path.Join(ice.VAR_PROXY, m.Option(cli.POD), p)
cache := time.Now().Add(-time.Hour * 240000)
if s, e := os.Stat(pp); e == nil {
cache = s.ModTime()
}
m.Cmdy(SPACE, m.Option(kit.SSH_POD), SPIDE, SPIDE_DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
SPIDE_PART, kit.SSH_POD, m.Option(kit.SSH_POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
m.Cmdy(SPACE, m.Option(cli.POD), SPIDE, SPIDE_DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
SPIDE_PART, cli.POD, m.Option(cli.POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
if s, e := os.Stat(pp); e == nil && !s.IsDir() {
p = pp
@ -83,11 +84,11 @@ func _share_local(m *ice.Message, arg ...string) {
func _share_proxy(m *ice.Message, arg ...string) {
switch m.R.Method {
case http.MethodGet: // 下发文件
m.Render(ice.RENDER_DOWNLOAD, path.Join(ice.VAR_PROXY, path.Join(m.Option(kit.SSH_POD), m.Option(kit.MDB_PATH), m.Option(kit.MDB_NAME))))
m.Render(ice.RENDER_DOWNLOAD, path.Join(ice.VAR_PROXY, path.Join(m.Option(cli.POD), m.Option(kit.MDB_PATH), m.Option(kit.MDB_NAME))))
case http.MethodPost: // 上传文件
m.Cmdy(CACHE, UPLOAD)
m.Cmdy(CACHE, WATCH, m.Option(kit.MDB_DATA), path.Join(ice.VAR_PROXY, m.Option(kit.SSH_POD), m.Option(kit.MDB_PATH)))
m.Cmdy(CACHE, WATCH, m.Option(kit.MDB_DATA), path.Join(ice.VAR_PROXY, m.Option(cli.POD), m.Option(kit.MDB_PATH)))
m.Render(ice.RENDER_RESULT, m.Option(kit.MDB_PATH))
}
}

18
base/web/space.go
View File

@ -25,7 +25,7 @@ func _space_list(m *ice.Message, space string) {
if space == "" {
m.Table(func(index int, value map[string]string, head []string) {
m.PushAnchor(value[kit.MDB_NAME], kit.MergeURL(strings.Split(m.Option(ice.MSG_USERWEB), "?")[0],
kit.SSH_POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])))
cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])))
})
m.SortStrR(kit.MDB_NAME)
}
@ -142,7 +142,7 @@ func _space_handle(m *ice.Message, safe bool, send map[string]*ice.Message, c *w
if len(target) == 0 { // 本地执行
msg.Log_AUTH(aaa.USERROLE, msg.Option(ice.MSG_USERROLE), aaa.USERNAME, msg.Option(ice.MSG_USERNAME))
if msg.Optionv(ice.MSG_HANDLE, "true"); safe {
if msg.Optionv(ice.MSG_HANDLE, ice.TRUE); safe {
msg.Go(func() { _space_exec(msg, source, target, c, name) })
} else {
msg.Push(kit.MDB_LINK, kit.MergePOD(_share_domain(msg), name))
@ -156,7 +156,7 @@ func _space_handle(m *ice.Message, safe bool, send map[string]*ice.Message, c *w
return // 转发报文
}
if msg.Warn(msg.Option(ice.MSG_HANDLE) == "true", ice.ErrNotFound) {
if msg.Warn(msg.Option(ice.MSG_HANDLE) == ice.TRUE, ice.ErrNotFound) {
// 回复失败
} else { // 下发失败
@ -166,7 +166,7 @@ func _space_handle(m *ice.Message, safe bool, send map[string]*ice.Message, c *w
}) != nil { // 转发成功
} else if res, ok := send[msg.Option(ice.MSG_TARGET)]; len(target) != 1 || !ok {
if msg.Warn(msg.Option(ice.MSG_HANDLE) == "true", ice.ErrNotFound) {
if msg.Warn(msg.Option(ice.MSG_HANDLE) == ice.TRUE, ice.ErrNotFound) {
// 回复失败
} else { // 下发失败
@ -190,12 +190,12 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
switch value[kit.MDB_TYPE] {
case MASTER:
m.PushSearch(kit.SSH_CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, m.Cmd(SPIDE, value[kit.MDB_NAME], ice.OptionFields("client.url")).Append("client.url"), value)
default:
m.PushSearch(kit.SSH_CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, kit.MergeURL(m.Option(ice.MSG_USERWEB), kit.SSH_POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])), value)
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, kit.MergeURL(m.Option(ice.MSG_USERWEB), cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])), value)
}
})
@ -205,8 +205,8 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
return
}
m.Cmd(tcp.HOST).Table(func(index int, value map[string]string, head []string) {
m.PushSearch(kit.SSH_CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, kit.Format("http://%s:%s", value[tcp.IP], port), kit.SSH_POD, kit.Keys(m.Option(ice.MSG_USERPOD), value))
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, kit.Format("http://%s:%s", value[tcp.IP], port), cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), value))
})
}
}

2
base/yac/script.go
View File

@ -80,7 +80,7 @@ func _pop_stack(m *ice.Message) *frame {
}
func _exp_true(m *ice.Message, arg string) bool {
if arg == "true" {
if arg == ice.TRUE {
return true
}
if arg == "false" {

6
conf.go
View File

@ -38,6 +38,12 @@ const ( // DIR
USR_PUBLISH = "usr/publish"
USR_LOCAL = "usr/local"
USR_LOCAL_WORK = "usr/local/work"
USR_LOCAL_RIVER = "usr/local/river"
USR_LOCAL_IMAGE = "usr/local/image"
USR_LOCAL_EXPORT = "usr/local/export"
USR_LOCAL_DAEMON = "usr/local/daemon"
FAVICON = "favicon.ico"
PROTO_JS = "proto.js"
FRAME_JS = "frame.js"

174
core/chat/action.go
View File

@ -16,28 +16,28 @@ import (
func _action_domain(m *ice.Message, cmd string, arg ...string) (domain string) {
m.Option(ice.MSG_LOCAL, "")
m.Option(ice.MSG_DOMAIN, "")
if m.Conf(ACTION, kit.Keys(kit.MDB_META, DOMAIN, cmd)) != "true" {
return ""
if m.Conf(ACTION, kit.Keym(DOMAIN, cmd)) != ice.TRUE {
return "" // 公有命令
}
storm := kit.Select(m.Option(ice.MSG_STORM), arg, 0)
river := kit.Select(m.Option(ice.MSG_RIVER), arg, 1)
m.Richs(RIVER, "", river, func(key string, value map[string]interface{}) {
switch kit.Value(kit.GetMeta(value), kit.MDB_TYPE) {
case PUBLIC:
case PUBLIC: // 公有群
return
case PROTECTED:
case PROTECTED: // 共有群
m.Richs(RIVER, kit.Keys(kit.MDB_HASH, river, TOOL), storm, func(key string, value map[string]interface{}) {
switch kit.Value(kit.GetMeta(value), kit.MDB_TYPE) {
case PUBLIC:
domain = m.Option(ice.MSG_DOMAIN, kit.Keys("R"+river))
case PROTECTED:
domain = m.Option(ice.MSG_DOMAIN, kit.Keys("R"+river, "S"+storm))
case PRIVATE:
domain = m.Option(ice.MSG_DOMAIN, kit.Keys("R"+river, "U"+m.Option(ice.MSG_USERNAME)))
switch r := "R" + river; kit.Value(kit.GetMeta(value), kit.MDB_TYPE) {
case PUBLIC: // 公有组
domain = m.Option(ice.MSG_DOMAIN, kit.Keys(r))
case PROTECTED: // 共有组
domain = m.Option(ice.MSG_DOMAIN, kit.Keys(r, "S"+storm))
case PRIVATE: // 私有组
domain = m.Option(ice.MSG_DOMAIN, kit.Keys(r, "U"+m.Option(ice.MSG_USERNAME)))
}
})
case PRIVATE:
case PRIVATE: // 私有群
domain = m.Option(ice.MSG_DOMAIN, kit.Keys("U"+m.Option(ice.MSG_USERNAME)))
}
m.Option(ice.MSG_LOCAL, path.Join(m.Conf(RIVER, kit.META_PATH), domain))
@ -55,50 +55,6 @@ func _action_right(m *ice.Message, river string, storm string) (ok bool) {
}
return ok
}
func _action_share(m *ice.Message, arg ...string) {
switch msg := m.Cmd(web.SHARE, arg[1]); msg.Append(kit.MDB_TYPE) {
case web.STORM:
if len(arg) == 2 {
_action_list(m, msg.Append(web.RIVER), msg.Append(web.STORM))
return
}
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire) {
break // 分享超时
}
m.Log_AUTH(
aaa.USERROLE, m.Option(ice.MSG_USERROLE, msg.Append(aaa.USERROLE)),
aaa.USERNAME, m.Option(ice.MSG_USERNAME, msg.Append(aaa.USERNAME)),
)
_action_show(m, msg.Append(web.RIVER), msg.Append(web.STORM), arg[2], arg[3:]...)
case web.FIELD:
if cmd := kit.Keys(msg.Append(web.RIVER), msg.Append(web.STORM)); len(arg) == 2 {
m.Push("index", cmd)
m.Push("title", msg.Append(kit.MDB_NAME))
m.Push("args", msg.Append(kit.MDB_TEXT))
break
}
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire) {
break // 分享超时
}
m.Log_AUTH(
aaa.USERROLE, m.Option(ice.MSG_USERROLE, msg.Append(aaa.USERROLE)),
aaa.USERNAME, m.Option(ice.MSG_USERNAME, msg.Append(aaa.USERNAME)),
)
if m.Warn(!m.Right(arg[2:]), ice.ErrNotRight) {
break // 没有授权
}
if m.Option(ice.MSG_UPLOAD) != "" {
_action_upload(m) // 上传文件
}
m.Cmdy(arg[2:])
}
}
func _action_list(m *ice.Message, river, storm string) {
m.Option(ice.MSG_RIVER, river)
@ -115,28 +71,72 @@ func _action_show(m *ice.Message, river, storm, index string, arg ...string) {
prefix := kit.Keys(kit.MDB_HASH, river, TOOL, kit.MDB_HASH, storm)
if m.Grows(RIVER, prefix, kit.MDB_ID, index, func(index int, value map[string]interface{}) {
if cmds = kit.Simple(kit.Keys(value[cli.CTX], value[cli.CMD])); kit.Format(value[cli.POD]) != "" {
m.Option(cli.POD, value[cli.POD])
m.Option(cli.POD, value[cli.POD]) // 远程节点
}
}) == nil && m.Warn(!m.Right(cmds), ice.ErrNotRight) {
return
return // 没有授权
}
if _action_domain(m, cmds[0]); m.Option(ice.MSG_UPLOAD) != "" {
_action_upload(m) // 上传文件
}
m.Cmdy(_action_proxy(m), cmds, arg)
}
func _action_proxy(m *ice.Message) (proxy []string) {
if p := m.Option(cli.POD); p != "" {
proxy = append(proxy, web.SPACE, p)
m.Option(cli.POD, "")
if !m.PodCmd(cmds, arg) {
m.Cmdy(cmds, arg) // 执行命令
}
return proxy
}
func _action_upload(m *ice.Message, arg ...string) {
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))
}
func _action_share(m *ice.Message, arg ...string) {
switch msg := m.Cmd(web.SHARE, arg[0]); msg.Append(kit.MDB_TYPE) {
case web.STORM:
if len(arg) == 1 {
_action_list(m, msg.Append(web.RIVER), msg.Append(web.STORM))
break // 命令列表
}
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire) {
break // 分享超时
}
m.Log_AUTH(
aaa.USERROLE, m.Option(ice.MSG_USERROLE, msg.Append(aaa.USERROLE)),
aaa.USERNAME, m.Option(ice.MSG_USERNAME, msg.Append(aaa.USERNAME)),
)
if !_action_right(m, msg.Append(web.RIVER), msg.Append(web.STORM)) {
break // 没有授权
}
// 执行命令
_action_show(m, msg.Append(web.RIVER), msg.Append(web.STORM), arg[1], arg[2:]...)
case web.FIELD:
if cmd := kit.Keys(msg.Append(web.RIVER), msg.Append(web.STORM)); len(arg) == 1 {
m.Push("index", cmd)
m.Push("title", msg.Append(kit.MDB_NAME))
m.Push("args", msg.Append(kit.MDB_TEXT))
break // 命令列表
}
if m.Warn(kit.Time() > kit.Time(msg.Append(kit.MDB_TIME)), ice.ErrExpire) {
break // 分享超时
}
m.Log_AUTH(
aaa.USERROLE, m.Option(ice.MSG_USERROLE, msg.Append(aaa.USERROLE)),
aaa.USERNAME, m.Option(ice.MSG_USERNAME, msg.Append(aaa.USERNAME)),
)
if m.Warn(!m.Right(arg[1:]), ice.ErrNotRight) {
break // 没有授权
}
if m.Option(ice.MSG_UPLOAD) != "" {
_action_upload(m) // 上传文件
}
m.Cmdy(arg[1:]) // 执行命令
}
}
const (
DOMAIN = "domain"
@ -145,7 +145,6 @@ const (
PRIVATE = "private"
)
const P_ACTION = "/action"
const ACTION = "action"
func init() {
@ -154,25 +153,42 @@ func init() {
ACTION: {Name: ACTION, Help: "应用", Value: kit.Data(DOMAIN, kit.Dict())},
},
Commands: map[string]*ice.Command{
P_ACTION: {Name: "/action river storm action arg...", Help: "工作台", Action: map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
for _, cmd := range []string{
"web.chat.meet.miss",
"web.chat.meet.mate",
"web.chat.location",
"web.chat.paste",
"web.chat.scan",
"web.wiki.feel",
"web.wiki.draw",
"web.wiki.data",
"web.wiki.word",
"web.team.task",
"web.team.plan",
"web.mall.asset",
"web.mall.salary",
} {
m.Conf(ACTION, kit.Keym(DOMAIN, cmd), ice.TRUE)
}
}},
"/action": {Name: "/action river storm action arg...", Help: "工作台", Action: map[string]*ice.Action{
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), TOOL, kit.MDB_HASH, m.Option(STORM)), mdb.LIST,
m.OptionSimple(kit.MDB_ID), arg)
}},
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
for _, k := range arg {
m.Cmdy(ctx.COMMAND, strings.TrimPrefix(k, "."))
}
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), TOOL, kit.MDB_HASH, m.Option(STORM)), mdb.LIST,
kit.MDB_ID, m.Option(kit.MDB_ID), arg)
}},
SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
_header_share(m, arg...)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if arg[0] == "_share" {
"_share": {Name: "_share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
_action_share(m, arg...)
return
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if m.Warn(m.Option(ice.MSG_USERNAME) == "", ice.ErrNotLogin) {
return // 没有登录
}
@ -185,8 +201,10 @@ func init() {
return //命令列表
}
// 执行命令
_action_show(m, arg[0], arg[1], arg[2], arg[3:]...)
}},
"/cmd/": {Name: "/cmd/", Help: "命令", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.RenderDownload(path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS, kit.MDB_PATH)), "page/cmd.html"))
}},
@ -194,11 +212,9 @@ func init() {
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(ctx.COMMAND, arg)
}},
cli.RUN: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
cli.RUN: {Name: "command", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Debug("waht %v %v", cmd, arg)
}},
}})
}

45
core/chat/auth.go Normal file
View File

@ -0,0 +1,45 @@
package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/ssh"
"github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits"
)
const AUTH = "auth"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
AUTH: {Name: "auth hash auto create", Help: "授权", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create type=node,user name text", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, AUTH), mdb.HASH,
aaa.USERROLE, m.Option(ice.MSG_USERROLE), aaa.USERNAME, m.Option(ice.MSG_USERNAME),
kit.MDB_TIME, m.Time("72h"), arg)
}},
mdb.INSERT: {Name: "insert river share", Help: "加入", Hand: func(m *ice.Message, arg ...string) {
switch msg := m.Cmd(AUTH, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) {
case USER:
m.Option(ice.MSG_RIVER, m.Option(RIVER))
m.Cmdy(USER, mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME))
}
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, _river_key(m, AUTH), mdb.HASH, m.OptionSimple(kit.MDB_HASH), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, AUTH), mdb.HASH, m.OptionSimple(kit.MDB_HASH))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,hash,userrole,username,type,name,text")
if m.Cmdy(mdb.SELECT, RIVER, _river_key(m, AUTH), mdb.HASH, kit.MDB_HASH, arg); len(arg) > 0 {
m.PushScript(ssh.SCRIPT, _river_url(m, web.SHARE, m.Option(web.SHARE)))
m.PushQRCode(cli.QRCODE, _river_url(m, web.SHARE, m.Option(web.SHARE)))
}
m.PushAction(mdb.REMOVE)
}},
}})
}

57
core/chat/chat.go
View File

@ -4,7 +4,6 @@ import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits"
)
const CHAT = "chat"
@ -13,61 +12,11 @@ var Index = &ice.Context{Name: CHAT, Help: "聊天中心",
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(web.SERVE, aaa.WHITE, HEADER, RIVER, ACTION, FOOTER)
m.Watch(web.SPACE_START, m.Prefix(NODE))
m.Watch(web.SPACE_STOP, m.Prefix(NODE))
m.Load()
for _, cmd := range []string{
"web.chat.meet.miss",
"web.chat.meet.mate",
"web.chat.location",
"web.chat.paste",
"web.chat.scan",
"web.wiki.feel",
"web.wiki.draw",
"web.wiki.data",
"web.wiki.word",
"web.team.task",
"web.team.plan",
"web.mall.asset",
"web.mall.salary",
} {
m.Conf(ACTION, kit.Keym("domain", cmd), "true")
}
m.Conf(RIVER, "meta.template", kit.Dict(
"base", kit.Dict(
"info", []interface{}{
"web.chat.info",
"web.chat.auth",
"web.chat.user",
"web.chat.tool",
"web.chat.node",
},
"scan", []interface{}{
"web.chat.scan",
"web.chat.paste",
"web.chat.files",
"web.chat.location",
"web.chat.meet.miss",
"web.wiki.feel",
},
"task", []interface{}{
"web.team.task",
"web.team.plan",
"web.mall.asset",
"web.mall.salary",
"web.wiki.word",
},
"draw", []interface{}{
"web.wiki.draw",
"web.wiki.data",
"web.wiki.word",
},
),
))
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save() }},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Save()
}},
},
}

22
core/chat/info.go Normal file
View File

@ -0,0 +1,22 @@
package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
const INFO = "info"
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)
}},
}, 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))
}},
}})
}

58
core/chat/node.go Normal file
View File

@ -0,0 +1,58 @@
package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/icebergs/core/code"
kit "github.com/shylinux/toolkits"
)
const NODE = "node"
func init() {
Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Watch(web.SPACE_START, m.Prefix(NODE))
}},
NODE: {Name: "node name ctx cmd auto insert invite", Help: "设备", Action: map[string]*ice.Action{
web.SPACE_START: {Name: "start type name share river", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
if m.Option(ice.MSG_RIVER, m.Option(RIVER)) == "" {
return
}
if msg := m.Cmd(AUTH, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) == NODE {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, NODE), mdb.HASH, arg)
}
}},
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
m.Option(web.SHARE, m.Cmdx(AUTH, mdb.CREATE, kit.MDB_TYPE, NODE))
m.Cmdy(code.PUBLISH, ice.CONTEXTS, "tool")
}},
mdb.INSERT: {Name: "insert type name share", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
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, m.OptionSimple(aaa.USERNAME))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.SPACE)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Option(mdb.FIELDS, "time,type,name,share")
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), NODE), mdb.HASH)
m.Table(func(index int, value map[string]string, head []string) {
m.PushAnchor(value[kit.MDB_NAME], kit.MergeURL(m.Option(ice.MSG_USERWEB),
cli.POD, kit.Keys(m.Option(cli.POD), value[kit.MDB_NAME])))
})
m.PushAction(mdb.REMOVE)
return
}
m.Cmdy(web.ROUTE, arg)
}},
},
})
}

6
core/chat/paste.go
View File

@ -2,7 +2,9 @@ package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/ssh"
kit "github.com/shylinux/toolkits"
)
@ -28,8 +30,8 @@ func init() {
}, mdb.HashAction(PASTE)), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), m.Conf(PASTE, kit.META_FIELD))
if m.Cmdy(mdb.SELECT, cmd, "", mdb.HASH, kit.MDB_HASH, arg); len(arg) > 0 {
m.PushScript("script", m.Append(kit.MDB_TEXT))
m.PushQRCode("qrcode", m.Append(kit.MDB_TEXT))
m.PushScript(ssh.SCRIPT, m.Append(kit.MDB_TEXT))
m.PushQRCode(cli.QRCODE, m.Append(kit.MDB_TEXT))
}
m.PushAction(mdb.REMOVE)
}},

346
core/chat/river.go
View File

@ -6,19 +6,24 @@ import (
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/tcp"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/icebergs/core/code"
kit "github.com/shylinux/toolkits"
)
func _river_key(m *ice.Message, key ...interface{}) string {
return kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), kit.Simple(key))
}
func _river_url(m *ice.Message, arg ...string) string {
return kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), arg)
}
func _river_list(m *ice.Message) {
m.Set(ice.MSG_OPTION, kit.MDB_HASH)
m.Set(ice.MSG_OPTION, kit.MDB_NAME)
if m.Option(web.SHARE) != "" {
switch msg := m.Cmd(web.SHARE, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) {
case web.RIVER: // 应用入口
case web.RIVER: // 共享群组
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_RIVER, msg.Append(RIVER))
m.Option(ice.MSG_STORM, msg.Append(STORM))
@ -26,16 +31,17 @@ func _river_list(m *ice.Message) {
if m.Conf(RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER))) == "" {
break
}
if msg.Cmd(m.Prefix(USER), m.Option(ice.MSG_USERNAME)).Append(aaa.USERNAME) == "" {
msg.Cmd(m.Prefix(USER), mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME))
// 加入群组
if msg.Cmd(USER, m.Option(ice.MSG_USERNAME)).Append(aaa.USERNAME) == "" {
msg.Cmd(USER, mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME)) // 加入群组
}
case web.STORM: // 应用入口
case web.STORM: // 共享应用
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_STORM, msg.Append(STORM))
m.Option(ice.MSG_RIVER, "_share")
return
case web.FIELD: // 应用入口
case web.FIELD: // 共享命令
m.Option(ice.MSG_TITLE, msg.Append(kit.MDB_NAME))
m.Option(ice.MSG_RIVER, "_share")
return
@ -48,229 +54,80 @@ func _river_list(m *ice.Message) {
})
})
}
func _river_proxy(m *ice.Message, pod string) (proxy []string) {
if p := kit.Select(m.Option(cli.POD), pod); p != "" {
proxy = append(proxy, web.SPACE, p)
m.Option(cli.POD, "")
}
return proxy
}
const (
INFO = "info"
AUTH = "auth"
NODE = "node"
TOOL = "tool"
USER = "user"
)
const STORM = "storm"
const RIVER = "river"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
RIVER: {Name: RIVER, Help: "群组", Value: kit.Data(kit.MDB_PATH, "usr/local/river")},
RIVER: {Name: RIVER, Help: "群组", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_RIVER)},
},
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)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(mdb.FIELDS, mdb.DETAIL)
m.Cmdy(mdb.SELECT, RIVER, "", mdb.HASH, kit.MDB_HASH, m.Option(ice.MSG_RIVER))
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf(RIVER, kit.Keym(kit.MDB_TEMPLATE), kit.Dict(
"base", kit.Dict(
"info", []interface{}{
"web.chat.info",
"web.chat.auth",
"web.chat.user",
"web.chat.tool",
"web.chat.node",
},
"scan", []interface{}{
"web.chat.scan",
"web.chat.paste",
"web.chat.files",
"web.chat.location",
"web.chat.meet.miss",
"web.wiki.feel",
},
"task", []interface{}{
"web.team.task",
"web.team.plan",
"web.mall.asset",
"web.mall.salary",
"web.wiki.word",
},
"draw", []interface{}{
"web.wiki.draw",
"web.wiki.data",
"web.wiki.word",
},
),
))
}},
AUTH: {Name: "auth hash auto create", Help: "授权", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create type=node,user name text", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), AUTH), mdb.HASH,
aaa.USERROLE, m.Option(ice.MSG_USERROLE), aaa.USERNAME, m.Option(ice.MSG_USERNAME),
kit.MDB_TIME, m.Time("72h"), arg)
}},
mdb.INSERT: {Name: "insert river share", Help: "加入", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,userrole,username,type,name,text")
msg := m.Cmd(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), AUTH), mdb.HASH, kit.MDB_HASH, m.Option(web.SHARE))
switch msg.Append(kit.MDB_TYPE) {
case USER:
m.Option(ice.MSG_RIVER, m.Option(RIVER))
m.Cmdy(m.Prefix(USER), mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME))
case NODE:
}
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), AUTH), mdb.HASH,
kit.MDB_HASH, m.Option(kit.MDB_HASH), arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), AUTH), mdb.HASH,
kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(mdb.FIELDS, kit.Select("time,hash,userrole,username,type,name,text", mdb.DETAIL, len(arg) > 0))
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), AUTH), mdb.HASH, kit.MDB_HASH, arg)
m.PushAction(mdb.REMOVE)
if len(arg) > 0 {
m.PushQRCode("qrcode", kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, m.Option("share")))
m.PushScript("script", kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, m.Option("share")))
"/river": {Name: "/river", Help: "小河流", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if m.Warn(m.Option(ice.MSG_USERNAME) == "", ice.ErrNotLogin) {
m.Render(web.STATUS, 401)
return // 没有登录
}
}},
NODE: {Name: "node name ctx cmd auto insert invite", Help: "设备", Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert type name share", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), NODE), mdb.HASH, arg)
}},
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
m.Option(web.SHARE, m.Cmdx(m.Prefix(AUTH), mdb.CREATE, kit.MDB_TYPE, NODE))
m.Cmdy(code.PUBLISH, "contexts", "tool")
}},
web.SPACE_START: {Name: "start type name share river", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
if m.Option(ice.MSG_RIVER, m.Option(RIVER)) == "" {
return
}
if msg := m.Cmd(m.Prefix(AUTH), m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) == NODE {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), NODE), mdb.HASH, arg)
}
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, kit.Keys(kit.MDB_HASH, m.Option(RIVER), NODE), mdb.HASH,
kit.MDB_NAME, m.Option(kit.MDB_NAME))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.SPACE)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Option(mdb.FIELDS, "time,type,name,share")
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), NODE), mdb.HASH)
m.Table(func(index int, value map[string]string, head []string) {
m.PushAnchor(value[kit.MDB_NAME], kit.MergeURL(m.Option(ice.MSG_USERWEB),
kit.SSH_POD, kit.Keys(m.Option(kit.SSH_POD), value[kit.MDB_NAME])))
})
m.PushAction(mdb.REMOVE)
return
_river_list(m)
return // 群组列表
}
m.Cmdy(web.ROUTE, arg)
}},
TOOL: {Name: "tool hash id auto insert create", Help: "工具", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create type=public,protected,private name=hi text=hello", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL), mdb.HASH, arg)
}},
mdb.INSERT: {Name: "insert hash pod ctx cmd help", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL, kit.MDB_HASH, m.Option(kit.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, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL, kit.MDB_HASH, m.Option(kit.MDB_HASH)), mdb.LIST,
kit.MDB_ID, m.Option(kit.MDB_ID), arg)
} else {
m.Cmdy(mdb.MODIFY, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL), mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), arg)
}
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL), mdb.HASH,
kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
m.Option(mdb.FIELDS, "time,id,pod,ctx,cmd,arg")
msg := m.Cmd(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL, kit.MDB_HASH, m.Option(kit.MDB_HASH)), mdb.LIST, kit.MDB_ID, m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(_river_proxy(msg, msg.Append(cli.POD)), cmd, mdb.EXPORT)
}
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
m.Option(mdb.FIELDS, "time,id,pod,ctx,cmd,arg")
msg := m.Cmd(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL, kit.MDB_HASH, m.Option(kit.MDB_HASH)), mdb.LIST, kit.MDB_ID, m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(_river_proxy(msg, msg.Append(cli.POD)), cmd, mdb.IMPORT)
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case kit.MDB_HASH:
m.Cmd(TOOL).Table(func(index int, value map[string]string, head []string) {
m.Push(kit.MDB_HASH, value[kit.MDB_HASH])
m.Push(kit.MDB_NAME, value[kit.MDB_NAME])
})
case cli.POD:
m.Cmdy(web.ROUTE)
case cli.CTX:
m.Cmd(ctx.CONTEXT, "web").Table(func(index int, value map[string]string, head []string) {
m.Push(cli.CTX, kit.Keys(kit.Select("", value["ups"], value["ups"] != "shy"), value[kit.MDB_NAME]))
m.Push(kit.MDB_HELP, value[kit.MDB_HELP])
})
case cli.CMD, kit.MDB_HELP:
m.Cmd(ctx.CONTEXT, m.Option(cli.CTX), ctx.COMMAND).Table(func(index int, value map[string]string, head []string) {
m.Push(cli.CMD, value[kit.MDB_KEY])
m.Push(kit.MDB_NAME, value[kit.MDB_NAME])
m.Push(kit.MDB_HELP, value[kit.MDB_HELP])
})
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Option(mdb.FIELDS, "time,hash,type,name,count")
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL), mdb.HASH)
m.PushAction(mdb.REMOVE)
m.Sort(kit.MDB_NAME)
if len(arg) == 2 && arg[1] == TOOL {
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(arg[1], arg[2:])
return // 应用列表
}
m.Option(mdb.FIELDS, "time,id,pod,ctx,cmd,arg,display,style")
msg := m.Cmd(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), TOOL, kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, kit.Select("", arg, 1))
if len(msg.Appendv(cli.CMD)) == 0 && len(arg) > 1 {
msg.Push(cli.CMD, arg[1])
if m.Warn(!m.Right(RIVER, arg), ice.ErrNotRight) {
return // 没有授权
}
if len(arg) > 2 && arg[2] == "run" {
m.Cmdy(_river_proxy(m, msg.Append(cli.POD)), kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD)), arg[3:])
return // 执行命令
}
if m.Copy(msg); len(arg) < 2 {
m.PushAction(mdb.EXPORT, mdb.IMPORT)
m.SortInt(kit.MDB_ID)
return // 命令列表
}
switch kit.Select("", arg, 1) {
case USER, TOOL, NODE:
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(arg[1], arg[2:])
// 命令插件
m.ProcessField(arg[0], arg[1], "run")
m.Table(func(index int, value map[string]string, head []string) {
m.Cmdy(web.SPACE, value[cli.POD], ctx.CONTEXT, value[cli.CTX], ctx.COMMAND, value[cli.CMD])
})
case ctx.ACTION, aaa.INVITE:
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(RIVER, arg[1:])
default:
m.Cmdy(RIVER, arg)
}
}},
USER: {Name: "user username auto insert invite", Help: "用户", Action: map[string]*ice.Action{
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
share := m.Option(web.SHARE, m.Cmdx(m.Prefix(AUTH), mdb.CREATE, kit.MDB_TYPE, USER))
m.EchoScript(kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, share))
m.EchoQRCode(kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, share))
m.Render("")
}},
mdb.INSERT: {Name: "insert username", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), USER), mdb.HASH, arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), USER), mdb.HASH, aaa.USERNAME, m.Option(aaa.USERNAME))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("aaa.user")
m.Appendv(ice.MSG_APPEND, aaa.USERNAME, aaa.USERZONE, aaa.USERNICK)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(mdb.FIELDS, kit.Select("time,username", mdb.DETAIL, len(arg) > 0))
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), USER), mdb.HASH, aaa.USERNAME, arg)
m.Table(func(index int, value map[string]string, head []string) {
m.Richs(USER, nil, value[aaa.USERNAME], func(key string, val map[string]interface{}) {
val = kit.GetMeta(val)
m.Push(aaa.USERNICK, val[aaa.USERNICK])
m.PushImages(aaa.AVATAR, kit.Format(val[aaa.AVATAR]), kit.Select("60", "240", m.Option(mdb.FIELDS) == mdb.DETAIL))
})
})
m.PushAction(mdb.REMOVE)
}},
RIVER: {Name: "river hash auto create", Help: "群组", Action: map[string]*ice.Action{
RIVER: {Name: "river hash auto create", Help: "群组", Action: ice.MergeAction(map[string]*ice.Action{
mdb.CREATE: {Name: "create type=public,protected,private name=hi text=hello template=base", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
h := m.Cmdx(mdb.INSERT, RIVER, "", mdb.HASH, arg)
m.Option(ice.MSG_RIVER, h)
@ -278,7 +135,7 @@ func init() {
m.Conf(RIVER, kit.Keys(kit.MDB_HASH, h, NODE, kit.MDB_META, kit.MDB_SHORT), kit.MDB_NAME)
m.Conf(RIVER, kit.Keys(kit.MDB_HASH, h, USER, kit.MDB_META, kit.MDB_SHORT), aaa.USERNAME)
m.Cmd(m.Prefix(USER), mdb.INSERT, aaa.USERNAME, m.Option(ice.MSG_USERNAME))
m.Cmd(USER, 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(TOOL, mdb.CREATE, kit.MDB_TYPE, PUBLIC, kit.MDB_NAME, storm, kit.MDB_TEXT, storm)
@ -290,27 +147,10 @@ func init() {
})
})
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.MODIFY, RIVER, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), arg)
}},
mdb.REMOVE: {Name: "remove hash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.EXPORT, RIVER, "", mdb.HASH)
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.IMPORT, RIVER, "", mdb.HASH)
}},
aaa.INVITE: {Name: "invite", Help: "脚本", Hand: func(m *ice.Message, arg ...string) {
for _, k := range []string{"tmux", "base", "miss", "binary", "source", "module"} {
m.Cmdy("web.code.publish", "contexts", k)
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_ACTION) {
case tcp.START:
m.Cmdy(web.DREAM, kit.MDB_ACTION, mdb.INPUTS, arg)
switch m.Option(ctx.ACTION) {
case cli.START:
m.Cmdy(web.DREAM, ctx.ACTION, mdb.INPUTS, arg)
return
}
@ -328,47 +168,21 @@ func init() {
m.Cmdy(mdb.INPUTS, RIVER, "", mdb.HASH, arg)
}
}},
tcp.START: {Name: "start name repos template", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(m.Space(m.Option(kit.SSH_POD)), web.DREAM, tcp.START, arg)
aaa.INVITE: {Name: "invite", Help: "脚本", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.PUBLISH, ice.CONTEXTS)
}},
cli.START: {Name: "start name repos template", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(m.Space(m.Option(cli.POD)), web.DREAM, cli.START, arg)
}},
SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
_header_share(m, arg...)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}, mdb.HashAction(RIVER)), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmdy(mdb.SELECT, RIVER, "", mdb.HASH, kit.MDB_HASH, arg)
m.PushAction(mdb.REMOVE)
}},
"/river": {Name: "/river", Help: "小河流", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if m.Warn(m.Option(ice.MSG_USERNAME) == "", ice.ErrNotLogin) {
m.Render(web.STATUS, 401)
return // 没有登录
}
if len(arg) == 0 {
_river_list(m)
return // 群组列表
}
if len(arg) == 2 && arg[1] == TOOL {
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(m.Prefix(arg[1]), arg[2:])
return // 应用列表
}
if m.Warn(!m.Right(RIVER, arg), ice.ErrNotRight) {
return // 没有授权
}
switch kit.Select("", arg, 1) {
case USER, TOOL, NODE:
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(m.Prefix(arg[1]), arg[2:])
case kit.MDB_ACTION, aaa.INVITE:
m.Option(ice.MSG_RIVER, arg[0])
m.Cmdy(RIVER, arg[1:])
default:
m.Cmdy(RIVER, arg)
}
}},
},
})
}

6
core/chat/scan.go
View File

@ -2,7 +2,9 @@ package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/ssh"
kit "github.com/shylinux/toolkits"
)
@ -27,8 +29,8 @@ func init() {
}, mdb.HashAction(SCAN)), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), m.Conf(SCAN, kit.META_FIELD))
if m.Cmdy(mdb.SELECT, m.Prefix(SCAN), "", mdb.HASH, kit.MDB_HASH, arg); len(arg) > 0 {
m.PushScript("script", m.Append(kit.MDB_TEXT))
m.PushQRCode("qrcode", m.Append(kit.MDB_TEXT))
m.PushScript(ssh.SCRIPT, m.Append(kit.MDB_TEXT))
m.PushQRCode(cli.QRCODE, m.Append(kit.MDB_TEXT))
}
m.PushAction(mdb.REMOVE)
}},

2
core/chat/search.go
View File

@ -25,7 +25,7 @@ func init() {
if value = kit.GetMeta(value); arg[1] != "" && !kit.Contains(value[kit.MDB_NAME], arg[1]) {
return
}
m.PushSearch(kit.SSH_CMD, P_SEARCH, value)
m.PushSearch(cli.CMD, P_SEARCH, value)
})
}},
mdb.RENDER: {Name: "render", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {

93
core/chat/tool.go Normal file
View File

@ -0,0 +1,93 @@
package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
const STORM = "storm"
const TOOL = "tool"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
TOOL: {Name: "tool hash id auto insert create", Help: "工具", Action: map[string]*ice.Action{
mdb.CREATE: {Name: "create type=public,protected,private name=hi text=hello", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, TOOL), mdb.HASH, arg)
}},
mdb.INSERT: {Name: "insert hash pod ctx cmd help", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, TOOL, m.OptionSimple(kit.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, TOOL), mdb.HASH, m.OptionSimple(kit.MDB_HASH), arg)
} else {
m.Cmdy(mdb.MODIFY, RIVER, _river_key(m, TOOL, m.OptionSimple(kit.MDB_HASH)), mdb.LIST, m.OptionSimple(kit.MDB_ID), arg)
}
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, TOOL), mdb.HASH, m.OptionSimple(kit.MDB_HASH))
}},
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.EXPORT)
}
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.IMPORT)
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
if cli.Inputs(m, arg[0]) {
return
}
switch arg[0] {
case kit.MDB_HASH:
m.Cmdy(TOOL, ice.OptionFields("hash,name"))
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.OptionFields("time,hash,type,name,count")
m.Cmdy(mdb.SELECT, RIVER, _river_key(m, TOOL), mdb.HASH)
m.PushAction(mdb.REMOVE)
m.Sort(kit.MDB_NAME)
return // 应用列表
}
m.OptionFields("time,id,pod,ctx,cmd,arg,display,style")
msg := m.Cmd(mdb.SELECT, RIVER, _river_key(m, TOOL, kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, kit.Select("", arg, 1))
if len(msg.Appendv(cli.CMD)) == 0 && len(arg) > 1 {
msg.Push(cli.CMD, arg[1])
}
if len(arg) > 2 && arg[2] == cli.RUN {
m.Cmdy(m.Space(msg.Append(cli.POD)), kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD)), arg[3:])
return // 执行命令
}
if m.Copy(msg); len(arg) < 2 {
m.PushAction(mdb.EXPORT, mdb.IMPORT)
return // 命令列表
}
// 命令插件
m.ProcessField(arg[0], arg[1], cli.RUN)
m.Table(func(index int, value map[string]string, head []string) {
m.Cmdy(m.Space(value[cli.POD]), ctx.CONTEXT, value[cli.CTX], ctx.COMMAND, value[cli.CMD])
})
}},
}})
}

44
core/chat/user.go Normal file
View File

@ -0,0 +1,44 @@
package chat
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/aaa"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits"
)
const USER = "user"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
USER: {Name: "user username auto insert invite", Help: "用户", Action: map[string]*ice.Action{
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
share := m.Option(web.SHARE, m.Cmdx(AUTH, mdb.CREATE, kit.MDB_TYPE, USER))
m.EchoScript(kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, share))
m.EchoQRCode(kit.MergeURL(m.Option(ice.MSG_USERWEB), RIVER, m.Option(ice.MSG_RIVER), web.SHARE, share))
m.Render("")
}},
mdb.INSERT: {Name: "insert username", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, RIVER, _river_key(m, USER), mdb.HASH, arg)
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, RIVER, _river_key(m, USER), mdb.HASH, m.OptionSimple(aaa.USERNAME))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("aaa.user", ice.OptionFields(aaa.USERNAME, aaa.USERZONE, aaa.USERNICK))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,username")
m.Cmdy(mdb.SELECT, RIVER, _river_key(m, USER), mdb.HASH, aaa.USERNAME, arg)
m.Table(func(index int, value map[string]string, head []string) {
m.Richs(USER, nil, value[aaa.USERNAME], func(key string, val map[string]interface{}) {
val = kit.GetMeta(val)
m.Push(aaa.USERNICK, val[aaa.USERNICK])
m.PushImages(aaa.AVATAR, kit.Format(val[aaa.AVATAR]), kit.Select("60", "240", m.Option(mdb.FIELDS) == mdb.DETAIL))
})
})
m.PushAction(mdb.REMOVE)
}},
}})
}

2
core/code/compile.go
View File

@ -18,7 +18,7 @@ func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
COMPILE: {Name: COMPILE, Help: "编译", Value: kit.Data(
kit.MDB_PATH, ice.USR_PUBLISH, kit.SSH_ENV, kit.Dict(
kit.MDB_PATH, ice.USR_PUBLISH, cli.ENV, kit.Dict(
"CGO_ENABLED", "0", "GOCACHE", os.Getenv("GOCACHE"),
cli.HOME, os.Getenv(cli.HOME), cli.PATH, os.Getenv(cli.PATH),
"GOPROXY", "https://goproxy.cn,direct", "GOPRIVATE", "github.com",

8
core/code/go.go
View File

@ -19,7 +19,7 @@ func _go_find(m *ice.Message, key string) {
if p == "" {
continue
}
m.PushSearch(kit.SSH_CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
m.PushSearch(cli.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
}
}
func _go_tags(m *ice.Message, key string) {
@ -49,7 +49,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(kit.SSH_CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
m.PushSearch(cli.CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
}
}
}
@ -57,14 +57,14 @@ func _go_tags(m *ice.Message, key string) {
func _go_grep(m *ice.Message, key string) {
msg := m.Spawn()
msg.Split(m.Cmd(cli.SYSTEM, "grep", "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(kit.SSH_CMD, "grep", value) })
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(cli.CMD, "grep", value) })
}
func _go_help(m *ice.Message, key string) {
p := m.Cmd(cli.SYSTEM, "go", "doc", key).Append(cli.CMD_OUT)
if p == "" {
return
}
m.PushSearch(kit.SSH_CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
m.PushSearch(cli.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
}
const GO = "go"

12
core/code/publish.go
View File

@ -109,7 +109,7 @@ func init() {
m.Option("hostpath", kit.Path("./.ish/pluged"))
if len(arg) == 0 {
arg = append(arg, "base")
arg = append(arg, "tmux", "base", "miss", "binary", "source", "module")
}
for _, k := range arg {
if buf, err := kit.Render(m.Conf(PUBLISH, kit.Keym(ice.CONTEXTS, k)), m); m.Assert(err) {
@ -127,7 +127,7 @@ func init() {
web.DREAM: {Name: "dream name=hi repos", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.DREAM, tcp.START, arg)
m.Process(ice.PROCESS_OPEN, kit.MergeURL(m.Option(ice.MSG_USERWEB),
kit.SSH_POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
@ -161,14 +161,14 @@ export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o
"binary", `# 应用安装
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp binary
`,
"tmux", `# 终端环境
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp
"miss", `# 开发环境
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
`,
"base", `# 生产环境
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
`,
"miss", `# 开发环境
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
"tmux", `# 终端环境
export ctx_dev={{.Option "httphost"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp
`,
"tool", `# 群组环境
mkdir contexts; cd contexts

2
core/mall/asset.go
View File

@ -50,7 +50,7 @@ func _asset_insert(m *ice.Message, account string, arg ...string) {
m.Cmdy(mdb.MODIFY, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account, AMOUNT, amount)
}
func _asset_inputs(m *ice.Message, field, value string) {
if cli.Inputs(m, field, value) {
if cli.Inputs(m, field) {
return
}

6
core/team/task.go
View File

@ -73,7 +73,7 @@ func _task_modify(m *ice.Message, field, value string, arg ...string) {
m.Cmdy(mdb.MODIFY, m.Prefix(TASK), "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), field, value, arg)
}
func _task_inputs(m *ice.Message, field, value string) {
if cli.Inputs(m, field, value) {
if cli.Inputs(m, field) {
return
}
@ -90,11 +90,11 @@ func _task_search(m *ice.Message, kind, name, text string) {
return
}
if kind == TASK {
m.PushSearch(kit.SSH_CMD, TASK,
m.PushSearch(cli.CMD, TASK,
kit.MDB_ZONE, val[kit.MDB_ZONE], kit.MDB_ID, kit.Format(value[kit.MDB_ID]),
value)
} else {
m.PushSearch(kit.SSH_CMD, TASK,
m.PushSearch(cli.CMD, TASK,
kit.MDB_TYPE, val[kit.MDB_ZONE], kit.MDB_NAME, kit.Format(value[kit.MDB_ID]),
kit.MDB_TEXT, kit.Format("%v:%v", value[kit.MDB_NAME], value[kit.MDB_TEXT]),
value)

4
core/wiki/chart.go
View File

@ -177,7 +177,7 @@ func (b *Label) Draw(m *ice.Message, x, y int) Chart {
switch m.Option("compact") {
case "max":
item.Width = b.Width/len(line) - b.MarginX
case "true":
case ice.TRUE:
default:
item.Width = b.max[i]
@ -299,7 +299,7 @@ func (b *Chain) draw(m *ice.Message, root map[string]interface{}, depth int, wid
MarginX: b.MarginX,
MarginY: b.MarginY,
}
if m.Option("compact") != "true" {
if m.Option("compact") != ice.TRUE {
item.Width = b.max[depth]
}
item.x = x

2
core/wiki/data.go
View File

@ -12,7 +12,7 @@ func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
DATA: {Name: DATA, Help: "数据表格", Value: kit.Data(
kit.MDB_PATH, "usr/local/export", kit.MDB_REGEXP, ".*\\.csv",
kit.MDB_PATH, ice.USR_LOCAL_EXPORT, kit.MDB_REGEXP, ".*\\.csv",
)},
},
Commands: map[string]*ice.Command{

2
core/wiki/feel.go
View File

@ -12,7 +12,7 @@ func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
FEEL: {Name: FEEL, Help: "影音媒体", Value: kit.Data(
kit.MDB_PATH, "usr/local/image", kit.MDB_REGEXP, ".*.(png|PNG|jpg|JPG|jpeg|mp4|m4v|MOV)",
kit.MDB_PATH, ice.USR_LOCAL_IMAGE, kit.MDB_REGEXP, ".*.(png|PNG|jpg|JPG|jpeg|mp4|m4v|MOV)",
)},
},
Commands: map[string]*ice.Command{

2
core/wiki/image.go
View File

@ -36,7 +36,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"}}">`,
kit.MDB_PATH, "usr/local/image",
kit.MDB_PATH, ice.USR_LOCAL_IMAGE,
)},
},
})

5
core/wiki/spark.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/ssh"
kit "github.com/shylinux/toolkits"
)
@ -13,7 +14,7 @@ func _spark_show(m *ice.Message, name, text string, arg ...string) {
return
}
prompt := kit.Select(name+"> ", m.Conf(SPARK, kit.Keym(kit.MDB_PROMPT, name)))
prompt := kit.Select(name+"> ", m.Conf(SPARK, kit.Keym(ssh.PROMPT, name)))
m.Echo(`<div class="story" data-type="spark" data-name="%s">`, name)
for _, l := range strings.Split(text, "\n") {
m.Echo("<div>")
@ -46,7 +47,7 @@ func init() {
Configs: map[string]*ice.Config{
SPARK: {Name: SPARK, Help: "段落", Value: kit.Data(
kit.MDB_TEMPLATE, `<p {{.OptionTemplate}}>{{.Option "text"}}</p>`,
kit.MDB_PROMPT, kit.Dict("shell", "$ "),
ssh.PROMPT, kit.Dict("shell", "$ "),
)},
},
})

2
core/wiki/video.go
View File

@ -34,7 +34,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>`,
kit.MDB_PATH, "usr/local/image",
kit.MDB_PATH, ice.USR_LOCAL_IMAGE,
)},
},
})

2
logs.go
View File

@ -28,7 +28,7 @@ func (m *Message) log(level string, str string, arg ...interface{}) *Message {
Log(m, m.Format("prefix"), level, str)
// 日志分流
}
if m.Option("_disable_log") == "true" {
if m.Option("_disable_log") == TRUE {
return m // 屏蔽日志
}

2
meta.go
View File

@ -299,7 +299,7 @@ func (m *Message) Table(cbs ...func(index int, value map[string]string, head []s
// 回调函数
rows := kit.Select("\n", m.Option("table.row_sep"))
cols := kit.Select(" ", m.Option("table.col_sep"))
compact := m.Option("table.compact") == "true"
compact := m.Option("table.compact") == TRUE
cb := func(value map[string]string, field []string, index int) bool {
for i, v := range field {
if k := m.meta[MSG_APPEND][i]; compact {

24
misc.go
View File

@ -46,7 +46,7 @@ func (m *Message) Watch(key string, arg ...string) *Message {
if len(arg) == 0 {
arg = append(arg, m.Prefix("auto"))
}
m.Cmd("gdb.event", "action", "listen", "event", key, kit.SSH_CMD, strings.Join(arg, " "))
m.Cmd("gdb.event", "action", "listen", "event", key, "cmd", strings.Join(arg, " "))
return m
}
func (m *Message) Event(key string, arg ...string) *Message {
@ -72,7 +72,7 @@ func (m *Message) ShowPlugin(pod, ctx, cmd string, arg ...string) {
}
func (m *Message) PushPodCmd(cmd string, arg ...string) {
m.Table(func(index int, value map[string]string, head []string) {
m.Push(kit.SSH_POD, m.Option(MSG_USERPOD))
m.Push("pod", m.Option(MSG_USERPOD))
})
m.Cmd("web.space").Table(func(index int, value map[string]string, head []string) {
@ -82,7 +82,7 @@ func (m *Message) PushPodCmd(cmd string, arg ...string) {
break
}
m.Cmd("web.space", value[kit.MDB_NAME], m.Prefix(cmd), arg).Table(func(index int, val map[string]string, head []string) {
val[kit.SSH_POD] = kit.Keys(value[kit.MDB_NAME], val[kit.SSH_POD])
val["pod"] = kit.Keys(value[kit.MDB_NAME], val["pod"])
m.Push("", val, head)
})
}
@ -92,12 +92,12 @@ func (m *Message) PushSearch(args ...interface{}) {
data := kit.Dict(args...)
for _, k := range kit.Split(m.Option(MSG_FIELDS)) {
switch k {
case kit.SSH_POD:
case "pod":
// m.Push(k, kit.Select(m.Option(MSG_USERPOD), data[kit.SSH_POD]))
case kit.SSH_CTX:
case "ctx":
m.Push(k, m.Prefix())
case kit.SSH_CMD:
m.Push(k, kit.Format(data[kit.SSH_CMD]))
case "cmd":
m.Push(k, kit.Format(data["cmd"]))
case kit.MDB_TIME:
m.Push(k, kit.Select(m.Time(), data[k]))
default:
@ -113,7 +113,7 @@ func (m *Message) PushSearchWeb(cmd string, name string) {
if value[kit.MDB_NAME] == "" {
text = kit.MergeURL(value[kit.MDB_TEXT] + url.QueryEscape(name))
}
m.PushSearch(kit.SSH_CMD, cmd, kit.MDB_TYPE, kit.Select("", value[kit.MDB_TYPE]), kit.MDB_NAME, name, kit.MDB_TEXT, text)
m.PushSearch("cmd", cmd, kit.MDB_TYPE, kit.Select("", value[kit.MDB_TYPE]), kit.MDB_NAME, name, kit.MDB_TEXT, text)
})
}
@ -133,7 +133,7 @@ func Render(m *Message, cmd string, args ...interface{}) string {
}
list := []string{}
if m.Option(MSG_USERPOD) != "" {
list = append(list, kit.SSH_POD, m.Option(MSG_USERPOD))
list = append(list, "pod", m.Option(MSG_USERPOD))
}
if len(arg) == 1 {
arg[0] = kit.MergeURL2(m.Option(MSG_USERWEB), path.Join(kit.Select("", "/share/local",
@ -205,7 +205,7 @@ func (m *Message) PushAnchor(arg ...interface{}) { // [name] link
}
func (m *Message) PushButton(arg ...string) {
if !m.IsCliUA() {
m.Push(kit.MDB_ACTION, Render(m, RENDER_BUTTON, strings.Join(arg, ",")))
m.Push("action", Render(m, RENDER_BUTTON, strings.Join(arg, ",")))
}
}
func (m *Message) PushScript(arg ...string) *Message { // [type] text...
@ -578,8 +578,8 @@ func (m *Message) OptionTemplate() string {
return strings.Join(res, " ")
}
func (m *Message) PodCmd(arg ...interface{}) bool {
if pod := m.Option(kit.SSH_POD); pod != "" {
m.Option(kit.SSH_POD, "")
if pod := m.Option("pod"); pod != "" {
m.Option("pod", "")
m.Cmd(append([]interface{}{"space", pod}, arg...))
return true
}

2
misc/alpha/alpha.go
View File

@ -68,7 +68,7 @@ var Index = &ice.Context{Name: ALPHA, Help: "英汉词典",
Configs: map[string]*ice.Config{
ALPHA: {Name: ALPHA, Help: "英汉词典", Value: kit.Data(
kit.MDB_LIMIT, "50000", kit.MDB_LEAST, "1000",
kit.MDB_STORE, "usr/local/export/alpha", kit.MDB_FSIZE, "2000000",
kit.MDB_STORE, path.Join(ice.USR_LOCAL_EXPORT, ALPHA), kit.MDB_FSIZE, "2000000",
kit.SSH_REPOS, "word-dict", kit.MDB_FIELD, []interface{}{
"audio", "bnc", "collins", "definition", "detail", "exchange", "frq", "id", "oxford", "phonetic", "pos", "tag", "time", "translation", "word",
},

2
misc/chrome/cache.go
View File

@ -17,7 +17,7 @@ func init() {
Configs: map[string]*ice.Config{
CACHE: {Name: CACHE, Help: "爬虫缓存", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_LINK, kit.MDB_FIELD, "time,hash,step,size,total,type,name,text,link",
kit.MDB_PATH, "usr/local/image",
kit.MDB_PATH, ice.USR_LOCAL_IMAGE,
)},
},
Commands: map[string]*ice.Command{

2
misc/git/spide.go
View File

@ -80,7 +80,7 @@ func init() {
}
if len(arg) == 1 { // 目录列表
m.Option(nfs.DIR_DEEP, "true")
m.Option(nfs.DIR_DEEP, ice.TRUE)
nfs.Dir(m, kit.MDB_PATH)
color := []string{"yellow", "blue", "cyan", "red"}

3
misc/git/status.go
View File

@ -6,6 +6,7 @@ import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
)
@ -133,7 +134,7 @@ func init() {
}}, OPT: {Name: "opt", Help: "优化"}, PRO: {Name: "pro", Help: "自举"},
COMMIT: {Name: "commit action=opt,add,pro comment=some@key", Help: "提交", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == kit.MDB_ACTION {
if arg[0] == ctx.ACTION {
m.Option(kit.MDB_TEXT, arg[1]+" "+arg[3])
} else {
m.Option(kit.MDB_TEXT, kit.Select("opt some", strings.Join(arg, " ")))

4
misc/git/total.go
View File

@ -17,7 +17,7 @@ func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
TOTAL: {Name: TOTAL, Help: "统计量", Value: kit.Data(
kit.MDB_SHORT, kit.MDB_NAME, "skip", kit.Dict("wubi-dict", "true", "word-dict", "true"),
kit.MDB_SHORT, kit.MDB_NAME, "skip", kit.Dict("wubi-dict", ice.TRUE, "word-dict", ice.TRUE),
)},
},
Commands: map[string]*ice.Command{
@ -33,7 +33,7 @@ func init() {
days, commit, adds, dels, rest := 0, 0, 0, 0, 0
m.Richs(REPOS, nil, kit.MDB_FOREACH, func(mu *sync.Mutex, key string, value map[string]interface{}) {
value = kit.GetMeta(value)
if m.Conf(TOTAL, kit.Keym("skip", value[kit.MDB_NAME])) == "true" {
if m.Conf(TOTAL, kit.Keym("skip", value[kit.MDB_NAME])) == ice.TRUE {
return
}

2
misc/input/input.go
View File

@ -154,7 +154,7 @@ const INPUT = "input"
var Index = &ice.Context{Name: INPUT, Help: "输入法",
Configs: map[string]*ice.Config{
INPUT: {Name: INPUT, Help: "输入法", Value: kit.Data(
kit.MDB_STORE, "usr/local/export/input", kit.MDB_FSIZE, "200000",
kit.MDB_STORE, path.Join(ice.USR_LOCAL_EXPORT, INPUT), kit.MDB_FSIZE, "200000",
kit.MDB_LIMIT, "5000", kit.MDB_LEAST, "1000",
kit.MDB_SHORT, "zone", kit.SSH_REPOS, "wubi-dict",
)},

2
misc/lark/company.go
View File

@ -22,7 +22,7 @@ func _company_list(m *ice.Message, appid string) {
}
func _company_members(m *ice.Message, appid string, ship_id string) {
_, data := _lark_get(m, appid, "/open-apis/contact/v1/department/user/list",
"department_id", ship_id, "page_size", "100", "fetch_child", "true")
"department_id", ship_id, "page_size", "100", "fetch_child", ice.TRUE)
kit.Fetch(kit.Value(data, "data.user_list"), func(index int, value map[string]interface{}) {
msg := m.Cmd(EMPLOYEE, appid, value[OPEN_ID])

5
misc/lark/home.go
View File

@ -2,6 +2,7 @@ package lark
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/icebergs/core/chat"
kit "github.com/shylinux/toolkits"
@ -23,7 +24,7 @@ func init() {
m.Cmd("web.chat./river").Table(func(index int, val map[string]string, head []string) {
m.Cmd("web.chat./river", val[kit.MDB_HASH], chat.TOOL).Table(func(index int, value map[string]string, head []string) {
list = append(list, kit.Keys(val[kit.MDB_NAME], value[kit.MDB_NAME]),
kit.SSH_CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
cli.CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
})
})
} else {
@ -31,7 +32,7 @@ func init() {
m.Option(ice.MSG_STORM, arg[1])
link = kit.MergeURL(link, chat.RIVER, arg[0], chat.STORM, arg[1])
m.Cmd("web.chat./river", arg[0], chat.TOOL, arg[1]).Table(func(index int, value map[string]string, head []string) {
list = append(list, value[kit.SSH_CMD], kit.SSH_CMD, kit.Keys(value[kit.SSH_CTX], value[kit.SSH_CMD]))
list = append(list, value[cli.CMD], cli.CMD, kit.Keys(value[cli.CTX], value[cli.CMD]))
})
}
m.Cmd(FORM, CHAT_ID, m.Option(OPEN_CHAT_ID), name, text, "打开网页", "url", link, list)

5
misc/lark/msg.go
View File

@ -6,6 +6,7 @@ import (
"strings"
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/cli"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/icebergs/core/wiki"
kit "github.com/shylinux/toolkits"
@ -88,9 +89,9 @@ func init() {
"card": {Name: "", Help: "", Hand: func(m *ice.Message, arg ...string) {
data := m.Optionv(ice.MSG_USERDATA)
kit.Fetch(kit.Value(data, "action.value"), func(key string, value string) { m.Option(key, value) })
m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(kit.SSH_CMD))...))
m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(cli.CMD))...))
m.Cmd(SEND, m.Option(APP_ID), CHAT_ID, m.Option(OPEN_CHAT_ID),
m.Option(wiki.TITLE)+" "+m.Option(kit.SSH_CMD), m.Result())
m.Option(wiki.TITLE)+" "+m.Option(cli.CMD), m.Result())
}},
}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
if m.Options(OPEN_CHAT_ID) {

12
misc/trash/web/_group.go
View File

@ -21,24 +21,24 @@ func init() {
case "label", "标签":
if m.Option(ice.EXPORT_LABEL) != "" && m.Option(cmd) != "" {
m.Cmdy(LABEL, m.Option(ice.EXPORT_LABEL), "add", m.Option(cmd), m.Option(kit.MDB_NAME))
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
}
case "add", "添加":
if m.Option(cmd) != "" && m.Option(kit.MDB_NAME) != "" {
m.Cmdy(cmd, m.Option(cmd), "add", m.Option(kit.MDB_NAME))
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
}
case "del", "退还":
if m.Option(cmd) != "" && m.Option(kit.MDB_NAME) != "" {
m.Cmdy(cmd, m.Option(cmd), "del", m.Option(kit.MDB_NAME))
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
}
case "prune", "清理":
m.Richs(cmd, nil, m.Option(cmd), func(key string, value map[string]interface{}) {
m.Richs(cmd, kit.Keys(kit.MDB_HASH, key), kit.MDB_FOREACH, func(sub string, value map[string]interface{}) {
if value[kit.MDB_STATUS] != "busy" {
m.Cmdy(cmd, m.Option(cmd), "del", value[kit.MDB_NAME])
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
}
})
})
@ -49,7 +49,7 @@ func init() {
last := m.Conf(cmd, kit.Keys(kit.MDB_HASH, key, kit.MDB_HASH, sub))
m.Logs(ice.LOG_DELETE, cmd, m.Option(cmd), kit.MDB_NAME, value[kit.MDB_NAME], kit.MDB_VALUE, last)
m.Conf(cmd, kit.Keys(kit.MDB_HASH, key, kit.MDB_HASH, sub), "")
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
m.Echo(last)
}
})
@ -59,7 +59,7 @@ func init() {
m.Echo(m.Conf(cmd, kit.Keys(kit.MDB_HASH, key)))
m.Logs(ice.LOG_REMOVE, cmd, m.Option(cmd), kit.MDB_VALUE, m.Conf(cmd, kit.Keys(kit.MDB_HASH, key)))
m.Conf(cmd, kit.Keys(kit.MDB_HASH, key), "")
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
})
}
return

6
misc/trash/web/_label.go
View File

@ -1,8 +1,8 @@
package web
import (
"github.com/shylinux/icebergs"
"github.com/shylinux/toolkits"
ice "github.com/shylinux/icebergs"
kit "github.com/shylinux/toolkits"
"sync"
)
@ -10,7 +10,7 @@ import (
func _label_add(m *ice.Message, cmd string) {
if m.Option(cmd) != "" && m.Option(kit.SSH_GROUP) != "" && m.Option(kit.MDB_NAME) != "" {
m.Cmdy(cmd, m.Option(cmd), "add", m.Option(kit.SSH_GROUP), m.Option(kit.MDB_NAME))
m.Option(ice.FIELD_RELOAD, "true")
m.Option(ice.FIELD_RELOAD, ice.TRUE)
}
}
func _label_del(m *ice.Message, cmd string) {

4
type.go
View File

@ -119,7 +119,7 @@ func (c *Context) cmd(m *Message, cmd *Command, key string, arg ...string) *Mess
}
m.meta[MSG_DETAIL] = kit.Simple(key, arg)
if m.Hand = true; len(arg) > 1 && arg[0] == kit.MDB_ACTION && cmd.Action != nil {
if m.Hand = true; len(arg) > 1 && arg[0] == "action" && cmd.Action != nil {
if h, ok := cmd.Action[arg[1]]; ok {
return c._cmd(m, cmd, key, arg[1], h, arg[2:]...)
}
@ -290,7 +290,7 @@ func (c *Context) split(key string, cmd *Command, name string) []interface{} {
case "@":
if len(ls) > i+1 {
if kit.Value(item, kit.MDB_INPUT) == BUTTON {
kit.Value(item, kit.MDB_ACTION, ls[i+1])
kit.Value(item, "action", ls[i+1])
} else {
kit.Value(item, kit.MDB_VALUE, "@"+ls[i+1]+"="+value)
}