opt team

base/ctx/command.go

@@ -80,6 +80,9 @@ func init() {
 				}
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			if len(arg) == 0 {
+				_command_list(m, "")
+			}
 			for _, key := range arg {
 				_command_list(m, key)
 			}

base/ctx/context.go

@@ -7,9 +7,6 @@ import (
 
 func _context_list(m *ice.Message, sub *ice.Context) {
 	m.Travel(func(p *ice.Context, s *ice.Context) {
-		if sub != nil && sub != p {
-			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))

base/mdb/hash.go

@@ -14,6 +14,7 @@ func _hash_fields(m *ice.Message) []string {
 }
 func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
 	list := map[string]int{}
+	m.Debug("what %v %v", prefix, chain)
 	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])

base/mdb/list.go

@@ -14,6 +14,7 @@ func _list_fields(m *ice.Message) []string {
 }
 func _list_inputs(m *ice.Message, prefix, chain string, field, value string) {
 	list := map[string]int{}
+	m.Debug("what %v %v", prefix, chain)
 	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])

base/mdb/mdb.go

@@ -26,6 +26,7 @@ const (
 	FIELDS = "fields"
 	DETAIL = "detail"
 	RANDOM = "random"
+	REPEAT = "repeat"
 
 	CREATE = "create"
 	REMOVE = "remove"
@@ -34,12 +35,11 @@ const (
 	MODIFY = "modify"
 	SELECT = "select"
 
+	INPUTS = "inputs"
+	PRUNES = "prunes"
 	EXPORT = "export"
 	IMPORT = "import"
-	PRUNES = "prunes"
-	INPUTS = "inputs"
 	UPLOAD = "upload"
-	REPEAT = "repeat"
 	REVERT = "revert"
 
 	NEXT = "next"
@@ -94,7 +94,7 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
 	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
 	INSERT: {Name: "insert key sub type arg...", Help: "添加", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 		switch arg[2] {
-		case ZONE:
+		case ZONE: // insert key sub type zone arg...
 			_list_insert(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
 		case HASH:
 			_hash_insert(m, arg[0], _domain_chain(m, arg[1]), arg[3:]...)
@@ -104,7 +104,7 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
 	}},
 	DELETE: {Name: "delete key sub type field value", Help: "删除", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 		switch arg[2] {
-		case ZONE:
+		case ZONE: // delete key sub type zone field value
 			_list_delete(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4], arg[5])
 		case HASH:
 			_hash_delete(m, arg[0], _domain_chain(m, arg[1]), arg[3], arg[4])
@@ -114,7 +114,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:
+		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:]...)
 		case HASH:
 			_hash_modify(m, arg[0], _domain_chain(m, arg[1]), arg[3], arg[4], arg[5:]...)
@@ -132,6 +132,26 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
 			_list_select(m, arg[0], _domain_chain(m, arg[1]), kit.Select("", arg, 3), kit.Select("", arg, 4))
 		}
 	}},
+	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))
+		case HASH:
+			_hash_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(kit.MDB_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))
+		}
+	}},
+	PRUNES: {Name: "prunes key sub type [field value]...", Help: "清理", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		switch arg[2] {
+		case ZONE: // prunes key sub type zone field value
+			_list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
+		case HASH:
+			_hash_prunes(m, arg[0], _domain_chain(m, arg[1]), arg[3:]...)
+		case LIST:
+			_list_prunes(m, arg[0], _domain_chain(m, arg[1]), arg[3:]...)
+		}
+	}},
 	EXPORT: {Name: "export key sub type file", Help: "导出", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 		switch file := _file_name(m, arg...); arg[2] {
 		case ZONE:
@@ -152,32 +172,12 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: map[string]*
 			_list_import(m, arg[0], _domain_chain(m, arg[1]), file)
 		}
 	}},
-	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:
-			_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))
-		case HASH:
-			_hash_inputs(m, arg[0], _domain_chain(m, arg[1]), kit.Select(kit.MDB_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))
-		}
-	}},
-	PRUNES: {Name: "prunes key sub type [field value]...", Help: "清理", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		switch arg[2] {
-		case ZONE:
-			_list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
-		case HASH:
-			_hash_prunes(m, arg[0], _domain_chain(m, arg[1]), arg[3:]...)
-		case LIST:
-			_list_prunes(m, arg[0], _domain_chain(m, arg[1]), arg[3:]...)
-		}
-	}},
 }}
 
 func init() {
 	ice.Index.Register(Index, nil,
 		INSERT, DELETE, MODIFY, SELECT,
-		EXPORT, IMPORT, PRUNES, INPUTS,
+		INPUTS, PRUNES, EXPORT, IMPORT,
-		PLUGIN, RENDER, ENGINE, SEARCH,
+		SEARCH, ENGINE, PLUGIN, RENDER,
 	)
 }

base/mdb/zone.go

@@ -4,6 +4,7 @@ import (
 	"encoding/csv"
 	"os"
 	"path"
+	"strings"
 
 	ice "shylinux.com/x/icebergs"
 	kit "shylinux.com/x/toolkits"
@@ -56,6 +57,7 @@ func _zone_export(m *ice.Message, prefix, chain, file string) {
 	defer w.Flush()
 
 	fields := _zone_fields(m)
+	fields = append(fields, kit.MDB_EXTRA)
 	w.Write(fields)
 
 	count := 0
@@ -129,8 +131,20 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
 
 	return ice.SelectAction(map[string]*ice.Action{
 		INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+			arg[0] = strings.TrimPrefix(arg[0], "extra.")
+			arg[0] = kit.Select(arg[0], m.Config(kit.Keys(kit.MDB_ALIAS, arg[0])))
+			m.Debug("what %v", arg[0])
 			switch arg[0] {
+			case ice.POD:
+				m.Cmdy("route")
+			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")
+			case ice.ARG:
+
 			case _zone(m):
+				m.Debug("what %v", arg[0])
 				m.Cmdy(INPUTS, m.PrefixKey(), "", HASH, arg)
 			default:
 				m.Cmdy(INPUTS, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), arg)
@@ -157,6 +171,9 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
 			m.OptionFields(_zone(m))
 			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)
+		}},
 		PREV: {Name: "prev", Help: "上一页", Hand: func(m *ice.Message, arg ...string) {
 			PrevPage(m, arg[0], arg[1:]...)
 		}},

base/ssh/scripts.go

@@ -164,6 +164,7 @@ func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
 			continue // 多行
 		}
 		if strings.HasPrefix(strings.TrimSpace(line), "#") {
+			line = ""
 			continue
 		}
 		// if line = strings.Split(line, " # ")[0]; len(line) == 0 {
@@ -188,7 +189,9 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
 	switch f.source = kit.Select(STDIO, arg, 0); f.source {
 	case STDIO: // 终端交互
 		m.Cap(ice.CTX_STREAM, f.source)
+		if f.target == nil {
 			f.target = m.Target()
+		}
 
 		r, w, _ := os.Pipe()
 		m.Go(func() { io.Copy(w, os.Stdin) })
@@ -269,7 +272,7 @@ func init() {
 			}
 		}},
 		TARGET: {Name: "target name run:button", Help: "当前模块", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			f := m.Optionv(FRAME).(*Frame)
+			f := c.Server().(*Frame)
 			m.Search(arg[0]+ice.PT, func(p *ice.Context, s *ice.Context, key string) { f.target = s })
 			f.prompt(m)
 		}},

base/web/space.go

@@ -42,8 +42,8 @@ func _space_dial(m *ice.Message, dev, name string, arg ...string) {
 
 		host := kit.Format(client[tcp.HOSTNAME])
 		proto := strings.Replace(kit.Format(client[tcp.PROTOCOL]), "http", "ws", 1)
-		uri := kit.MergeURL(proto+"://"+host+"/space/", kit.MDB_TYPE, ice.Info.NodeType,
+		uri := kit.MergeURL(proto+"://"+host+"/space/", kit.MDB_TYPE, ice.Info.NodeType, kit.MDB_NAME, name,
-			kit.MDB_NAME, name, SHARE, ice.Info.CtxShare, RIVER, kit.Select(ice.Info.CtxRiver, m.Option(RIVER)), arg)
+			SHARE, m.Conf(cli.RUNTIME, kit.Keys("conf.ctx_share")), RIVER, m.Conf(cli.RUNTIME, kit.Keys("conf.ctx_river")), arg)
 		u := kit.ParseURL(uri)
 
 		m.Go(func() {

core/chat/action.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	"path"
-	"strings"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
@@ -47,7 +46,7 @@ func _action_exec(m *ice.Message, river, storm, index string, arg ...string) {
 		_action_upload(m) // 上传文件
 	}
 
-	if !m.PodCmd(cmds, arg) {
+	if cmds[0] == "web.chat.node" || !m.PodCmd(cmds, arg) {
 		m.Cmdy(cmds, arg) // 执行命令
 	}
 }
@@ -158,7 +157,7 @@ func init() {
 			kit.MDB_PATH, ice.USR_LOCAL_RIVER,
 		)},
 	}, Commands: map[string]*ice.Command{
-		"/action": {Name: "/action river storm action arg...", Help: "工作台", Action: map[string]*ice.Action{
+		"/action": {Name: "/action river storm action arg...", Help: "工作台", Action: ice.MergeAction(map[string]*ice.Action{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
 				for _, cmd := range []string{
 					"web.chat.meet.miss",
@@ -181,18 +180,13 @@ 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)
 			}},
-			ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
-				for _, k := range arg {
-					m.Cmdy(ctx.COMMAND, strings.TrimPrefix(k, "."))
-				}
-			}},
 			SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
 				_header_share(m, arg...)
 			}},
 			"_share": {Name: "_share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {
 				_action_share(m, arg...)
 			}},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if m.Warn(m.Option(ice.MSG_USERNAME) == "", ice.ErrNotLogin, arg) {
 				return // 没有登录
 			}

core/chat/chat.shy

@@ -23,5 +23,5 @@ location.go
 
 info.go
 node.go
-meet.go
 room.go
+meet.go

core/chat/footer.go

@@ -18,16 +18,13 @@ func init() {
 			LEGAL, kit.List(`<a href="mailto:shylinuxc@gmail.com">shylinuxc@gmail.com</a>`),
 		)},
 	}, Commands: map[string]*ice.Command{
-		"/footer": {Name: "/footer", Help: "状态栏", Action: map[string]*ice.Action{
+		"/footer": {Name: "/footer", Help: "状态栏", Action: ice.MergeAction(map[string]*ice.Action{
-			ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(ctx.COMMAND, arg)
-			}},
 			ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 				if m.Cmdy(arg); m.Result(1) == ice.ErrNotFound {
 					m.Set(ice.MSG_RESULT).Cmdy(cli.SYSTEM, arg)
 				}
 			}},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Confm(FOOTER, LEGAL, func(index int, value string) { m.Echo(value) })
 		}},
 	}})

core/chat/meet.go

@@ -12,27 +12,19 @@ const (
 const MISS = "miss"
 
 func init() {
-	Index.Register(&ice.Context{Name: MEET, Help: "遇见",
+	Index.Register(&ice.Context{Name: MEET, Help: "遇见", Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		MISS: {Name: MISS, Help: "miss", Value: kit.Data(
 			kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,name,照片,性别,年龄,身高,体重,籍贯,户口,学历,学校,职业,公司,年薪,资产,家境",
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Load() }},
-			ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save() }},
-
 		MISS: {Name: "miss name auto create", Help: "资料", Meta: kit.Dict("_trans", kit.Dict("name", "姓名")), Action: ice.MergeAction(map[string]*ice.Action{
-				mdb.CREATE: {Name: "create name 照片 性别 年龄 身高 体重 籍贯 户口 学历 学校 职业 公司 年薪 资产 家境", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+			mdb.CREATE: {Name: "create name 照片 性别 年龄 身高 体重 籍贯 户口 学历 学校 职业 公司 年薪 资产 家境", Help: "添加"},
-					m.Cmdy(mdb.INSERT, m.Prefix(MISS), "", mdb.HASH, arg)
-				}},
 		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), m.Conf(MISS, kit.META_FIELD))
+			msg := m.Spawn()
-				m.Cmd(mdb.SELECT, m.Prefix(MISS), "", mdb.HASH, kit.MDB_NAME, arg).Table(func(index int, value map[string]string, head []string) {
+			mdb.HashSelect(msg, arg...).Table(func(index int, value map[string]string, head []string) {
-					value["照片"] = kit.Format(`<img src="%s" height=%s>`, value["照片"], kit.Select("100", "400", m.Option(mdb.FIELDS) == mdb.DETAIL))
+				value["照片"] = ice.Render(m, ice.RENDER_IMAGES, value["照片"], kit.Select("100", "400", msg.FieldsIsDetail()))
-					m.Push("", value, kit.Split(m.Option(ice.MSG_FIELDS)))
+				m.Push(m.OptionFields(), value, kit.Split(msg.OptionFields()))
 			})
 		}},
-		},
+	}}, nil, MISS)
-	}, nil, MISS)
 }

core/chat/node.go

@@ -12,44 +12,45 @@ import (
 const NODE = "node"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Watch(web.DREAM_START, m.Prefix(NODE))
-				m.Watch(web.SPACE_START, m.Prefix(NODE))
-			}},
 		NODE: {Name: "node pod ctx cmd auto insert invite", Help: "设备", Action: map[string]*ice.Action{
-				web.DREAM_START: {Name: "start type name share river", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
+			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
-					if m.Option(ice.MSG_RIVER, m.Option(RIVER)) == "" {
+				m.Watch(web.DREAM_START, m.PrefixKey())
-						return
+				m.Watch(web.SPACE_START, m.PrefixKey())
-					}
-					m.Cmdy(mdb.INSERT, RIVER, _river_key(m, NODE), mdb.HASH, arg)
 			}},
 			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(web.SHARE, m.Option(web.SHARE)); msg.Append(kit.MDB_TYPE) == RIVER {
-						m.Cmdy(mdb.INSERT, RIVER, _river_key(m, NODE), mdb.HASH, arg)
+					m.Cmdy(NODE, mdb.INSERT, arg)
+				} else {
+					msg.Debug(msg.FormatMeta())
 				}
 			}},
+			web.DREAM_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
+				}
+				m.Cmdy(NODE, mdb.INSERT, arg)
+			}},
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				m.Cmdy(web.SPACE)
+			}},
+			mdb.INSERT: {Name: "insert type name share river", 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, kit.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.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.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], kit.MergeURL2(m.Option(ice.MSG_USERWEB),
 						"/chat/pod/"+kit.Keys(m.Option(ice.POD), value[kit.MDB_NAME])))
@@ -60,6 +61,5 @@ func init() {
 			}
 			m.Cmdy(web.ROUTE, arg)
 		}},
-		},
+	}})
-	})
 }

core/chat/river.go

@@ -63,8 +63,8 @@ func init() {
 					"base", kit.Dict(
 						"info", kit.List(
 							"web.chat.info",
-							"web.chat.user",
+							"web.chat.ocean",
-							"web.chat.tool",
+							"web.chat.storm",
 							"web.chat.node",
 						),
 						"scan", kit.List(
@@ -110,7 +110,7 @@ func init() {
 			}
 
 			switch kit.Select("", arg, 1) {
-			case OCEAN, NODE:
+			case STORM, OCEAN, NODE:
 				m.Option(ice.MSG_RIVER, arg[0])
 				m.Cmdy(arg[1], arg[2:])
 

core/chat/room.go

@@ -9,40 +9,57 @@ import (
 )
 
 const ROOM = "room"
-const JOIN = "join"
 
 func init() {
+	const (
+		JOIN = "join"
+		QUIT = "quit"
+	)
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
 		ROOM: {Name: "room", Help: "room", Value: kit.Data(
-			kit.MDB_SHORT, "zone",
+			kit.MDB_SHORT, "zone", kit.MDB_FIELD, "time,id,type,name,text",
-			kit.MDB_FIELD, "time,id,type,name,text",
 		)},
 		JOIN: {Name: "join", Help: "join", Value: kit.Data(
-			kit.MDB_SHORT, "zone",
+			kit.MDB_SHORT, "space", kit.MDB_FIELD, "time,hash,username,socket",
-			kit.MDB_FIELD, "time,hash,username,socket",
 		)},
 	}, Commands: map[string]*ice.Command{
-		ROOM: {Name: "room zone id auto create insert join", Help: "room", Action: ice.MergeAction(map[string]*ice.Action{
+		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(JOIN), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
 			}},
-			mdb.INSERT: {Name: "insert zone type name text", Help: "发送", Hand: func(m *ice.Message, arg ...string) {
+			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(JOIN, m.Option(kit.MDB_ZONE)).Table(func(index int, value map[string]string, head []string) {
+				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.Option(ice.MSG_DAEMON, value[web.SOCKET])
+					m.Debug("what %v", value)
-					m.Toast(m.Option("text"), m.Option("name"))
+					m.Cmdy(web.SPACE, value[web.SPACE], "toast", m.Option("text"), m.Option("name"))
 				})
 			}},
 
-			"join": {Name: "join", Help: "加入", Hand: func(m *ice.Message, arg ...string) {
+			JOIN: {Name: "join zone", Help: "加入", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(JOIN, mdb.INSERT, arg)
+				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))
+			}},
+			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))
 			}},
-			"exit": {Name: "exit", Help: "退出"},
 		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			mdb.ZoneSelect(m, arg...)
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
+				m.Action(mdb.CREATE)
+				m.PushAction(mdb.INSERT, JOIN)
+			} else if len(arg) == 1 {
+				m.Action(mdb.INSERT, JOIN)
+			}
+		}},
+		JOIN: {Name: "join space zone auto", Help: "join", Action: ice.MergeAction(map[string]*ice.Action{
+			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
+				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))
 			}},
-		JOIN: {Name: "join zone hash auto", Help: "join", 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(JOIN), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
@@ -56,8 +73,9 @@ func init() {
 			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))
 			}},
-		}), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
+			m.Fields(len(arg), "time,space", "time,zone")
+			if len(arg) == 0 {
 				m.Cmdy(mdb.SELECT, m.Prefix(JOIN), "", mdb.HASH)
 			} else {
 				m.Cmdy(mdb.SELECT, m.Prefix(JOIN), kit.KeyHash(arg[0]), mdb.HASH, arg[1:])

core/chat/storm.go

@@ -81,15 +81,14 @@ func init() {
 				return
 			}
 
-			if m.Copy(msg); len(arg) == 1 { // 命令列表
+			if m.Copy(msg); len(arg) > 1 { // 命令插件
-				m.PushAction(mdb.EXPORT, mdb.IMPORT)
-			}
-
-			// 命令插件
 				m.ProcessField(arg[0], arg[1], ice.RUN)
 				m.Table(func(index int, value map[string]string, head []string) {
 					m.Cmdy(m.Space(value[ice.POD]), ctx.CONTEXT, value[ice.CTX], ctx.COMMAND, value[ice.CMD])
 				})
+			} else {
+				m.PushAction(mdb.EXPORT, mdb.IMPORT)
+			}
 		}},
 	}})
 }

core/code/inner.go

@@ -68,7 +68,7 @@ func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		INNER: {Name: "inner path=src/ file=main.go line=1 auto", Help: "源代码", Meta: kit.Dict(
 			ice.Display("/plugin/local/code/inner.js", "editor"),
-		), Action: map[string]*ice.Action{
+		), Action: ice.MergeAction(map[string]*ice.Action{
 			mdb.PLUGIN: {Name: "plugin", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
 				if m.Cmdy(mdb.PLUGIN, arg); m.Result() == "" {
 					m.Echo(kit.Select("{}", m.Conf(INNER, kit.Keym(PLUG, arg[0]))))
@@ -88,9 +88,8 @@ func init() {
 				m.Cmdy(mdb.SEARCH, arg[:2], "cmd,file,line,text")
 			}},
 			mdb.INPUTS: {Name: "favor inputs", Help: "补全"},
-			ctx.COMMAND: {Name: "command", Help: "命令"},
 			FAVOR:      {Name: "favor", Help: "收藏"},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) < 2 {
 				nfs.Dir(m, kit.MDB_PATH)
 				return

core/code/publish.go

@@ -176,6 +176,6 @@ export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -
 `,
 	"tool", `# 群组环境
 mkdir contexts; cd contexts
-export ctx_log=/dev/stdout ctx_dev={{.Option "httphost"}} ctx_river={{.Option "sess.river"}} ctx_share={{.Option "share"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp ice
+export ctx_dev={{.Option "httphost"}} ctx_share={{.Option "share"}} ctx_river={{.Option "sess.river"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
 `,
 )

core/mall/asset.go

@@ -1,10 +1,7 @@
 package mall
 
 import (
-	"strings"
-
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
@@ -33,34 +30,18 @@ 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.Conf(ASSET, kit.META_FIELD)))
+	m.Cmd(mdb.SELECT, m.Prefix(ASSET), "", mdb.ZONE, account, ice.OptionFields(m.Config(kit.MDB_FIELD)))
 
 	m.Cmdy(mdb.MODIFY, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account, AMOUNT, amount)
 }
-func _asset_create(m *ice.Message, account string) {
-	m.Cmdy(mdb.INSERT, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account)
-}
 func _asset_insert(m *ice.Message, account string, arg ...string) {
-	_asset_create(m, account)
+	m.Cmdy(mdb.INSERT, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account)
 	m.Cmdy(mdb.INSERT, m.Prefix(ASSET), "", mdb.ZONE, account, arg)
 
-	m.OptionFields("time,account,amount,count")
+	amount := kit.Int(m.Cmd(mdb.SELECT, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account, ice.Option{mdb.FIELDS, "time,account,amount,count"}).Append(AMOUNT))
-	amount := kit.Int(m.Cmd(mdb.SELECT, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, account).Append(AMOUNT))
 	amount += kit.Int(_sub_value(m, AMOUNT, arg...))
 	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) {
-		return
-	}
-
-	switch strings.TrimPrefix(field, "extra.") {
-	case ACCOUNT, FROM, TO:
-		m.Cmdy(mdb.INPUTS, m.Prefix(ASSET), "", mdb.HASH, ACCOUNT, value)
-	default:
-		m.Cmdy(mdb.INPUTS, m.Prefix(ASSET), "", mdb.ZONE, m.Option(ACCOUNT), field, value)
-	}
-}
 
 const (
 	ACCOUNT = "account"
@@ -78,16 +59,15 @@ const (
 const ASSET = "asset"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		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",
+			kit.MDB_ALIAS, kit.Dict(FROM, ACCOUNT, TO, ACCOUNT),
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ASSET: {Name: "asset account id auto spend trans bonus", Help: "资产", Meta: kit.Dict(
-			ASSET: {Name: "asset account id auto spend trans bonus check", Help: "资产", Meta: kit.Dict(
 			"_trans", kit.Dict(ACCOUNT, "账户", AMOUNT, "金额", FROM, "转出", TO, "转入", "time", "时间", "name", "商家", "text", "备注"),
-			), Action: map[string]*ice.Action{
+		), 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:])...)
@@ -111,36 +91,10 @@ func init() {
 				}
 				m.Toast("核算成功")
 			}},
-
+		}, mdb.ZoneAction(), ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
+			m.Fields(len(arg), "time,account,amount,count", m.Config(kit.MDB_FIELD))
-					m.Cmdy(mdb.MODIFY, m.Prefix(ASSET), "", mdb.ZONE, m.Option(ACCOUNT), m.Option(kit.MDB_ID), arg)
-				}},
-				mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
-					m.OptionFields(ACCOUNT, m.Conf(ASSET, kit.META_FIELD), kit.MDB_EXTRA)
-					m.Cmdy(mdb.EXPORT, m.Prefix(ASSET), "", mdb.ZONE)
-				}},
-				mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
-					m.OptionFields(ACCOUNT)
-					m.Cmdy(mdb.IMPORT, m.Prefix(ASSET), "", mdb.ZONE)
-					m.Cmdy(ASSET, CHECK)
-				}},
-				mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-					_asset_inputs(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
-				}},
-
-				mdb.PLUGIN: {Name: "plugin extra.pod extra.ctx extra.cmd extra.arg", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, m.Prefix(ASSET), "", mdb.ZONE, m.Option(ACCOUNT), m.Option(kit.MDB_ID), arg)
-				}},
-				ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(ctx.COMMAND, arg)
-				}},
-				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(arg)
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			amount, count := 0, 0
-				m.Fields(len(arg), "time,account,amount,count", m.Conf(ASSET, kit.META_FIELD))
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
-				if m.Cmdy(mdb.SELECT, m.Prefix(ASSET), "", mdb.ZONE, arg); len(arg) == 0 {
 				m.PushAction(CHECK)
 				m.SortIntR(AMOUNT)
 
@@ -157,8 +111,7 @@ func init() {
 					count++
 				})
 			}
-				m.StatusTime(AMOUNT, amount, COUNT, count)
+			m.StatusTime(COUNT, count, AMOUNT, amount)
 		}},
-		},
+	}})
-	})
 }

core/mall/mall.go

@@ -7,13 +7,6 @@ import (
 
 const MALL = "mall"
 
-var Index = &ice.Context{Name: MALL, Help: "贸易中心", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: MALL, Help: "贸易中心"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Save()
-	}},
-}}
 
 func init() { web.Index.Register(Index, nil, ASSET, SALARY) }

core/mall/salary.go

@@ -14,29 +14,15 @@ const (
 const SALARY = "salary"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		SALARY: {Name: SALARY, Help: "工资", Value: kit.Data(
-				kit.MDB_SHORT, MONTH, kit.MDB_FIELD, "time,month,company,amount,income,tax",
+			kit.MDB_SHORT, MONTH, kit.MDB_FIELD, "month,company,amount,income,tax",
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		SALARY: {Name: "salary month auto create", Help: "工资", Action: ice.MergeAction(map[string]*ice.Action{
-			SALARY: {Name: "salary month auto create", Help: "工资", Action: map[string]*ice.Action{
+			mdb.CREATE: {Name: "create month company amount income tax 公积金 养老保险 医疗保险 生育保险 工伤保险 失业保险 企业公积金 企业养老保险 企业医疗保险 企业生育保险 企业工伤保险 企业失业保险", Help: "添加"},
-				mdb.CREATE: {Name: "create company month amount income tax 公积金 养老保险 医疗保险 生育保险 工伤保险 失业保险 企业公积金 企业养老保险 企业医疗保险 企业生育保险 企业工伤保险 企业失业保险", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-					m.Cmdy(mdb.INSERT, m.Prefix(SALARY), "", mdb.HASH, arg)
+			mdb.HashSelect(m, arg...)
-				}},
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, m.Prefix(SALARY), "", mdb.HASH, m.OptionSimple(MONTH), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, m.Prefix(SALARY), "", mdb.HASH, m.OptionSimple(MONTH))
-				}},
-				mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.INPUTS, m.Prefix(SALARY), "", mdb.HASH, arg)
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), m.Conf(SALARY, kit.META_FIELD))
-				m.Cmdy(mdb.SELECT, m.Prefix(SALARY), "", mdb.HASH, MONTH, arg)
 			amount, income, tax := 0, 0, 0
 			m.Table(func(index int, value map[string]string, head []string) {
 				amount += kit.Int(value[AMOUNT])
@@ -45,6 +31,5 @@ func init() {
 			})
 			m.StatusTime(AMOUNT, amount, INCOME, income, TAX, tax)
 		}},
-		},
+	}})
-	})
 }

core/team/count.go

@@ -13,14 +13,15 @@ const COUNT = "count"
 
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
-		COUNT: {Name: "count begin_time@date end_time@date auto insert", Help: "倒计时", Meta: kit.Dict(ice.Display(COUNT)), Action: map[string]*ice.Action{
+		COUNT: {Name: "count begin_time@date end_time@date auto insert", Help: "倒计时", Meta: kit.Dict(
+			ice.Display(""),
+		), 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(TASK, mdb.INSERT, arg)
 			}},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, TASK), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			begin_time, end_time := _task_scope(m, 8, append([]string{LONG}, arg...)...)
 			msg := _plan_list(m.Spawn(), begin_time, end_time)
-			// m.PushPodCmd(COUNT, arg...)
 			msg.SortTime(BEGIN_TIME)
 
 			tz := int64(8)

core/team/count.js

@@ -1,20 +1,19 @@
 Volcanos("onimport", {help: "导入数据", list: [], _init: function(can, msg, list, cb, target) {
         can.onmotion.clear(can)
         can.onappend.table(can, msg)
-        can.onappend.board(can, msg.Result())
+        can.onappend.board(can, msg)
         can.base.isFunc(cb) && cb(msg)
-        can.onappend.style(can)
     },
-})
+}, [""])
-Volcanos("onaction", {help: "控件交互", list: ["播放"],
+Volcanos("onaction", {help: "控件交互", list: ["play"],
-    "播放": function(event, can) {
+    play: function(event, can) {
         can.page.Select(can, can._output, "div.item", function(item) {
             can.onmotion.hidden(can, item)
         })
         can.core.Next(can.page.Select(can, can._output, "div.item"), function(item, next) {
             can.onmotion.show(can, 300, next, item)
         }, function() {
-            can.user.toast(can, "播放结束", can.Option("zone"))
+            can.user.toast(can, "播放结束")
         })
     },
 })

core/team/plan.css

@@ -0,0 +1,30 @@
+fieldset.plan>div.output div.prepare {
+    background-color:blue;
+    color:white;
+}
+fieldset.plan>div.output div.process {
+    background-color:green;
+    color:white;
+}
+fieldset.plan>div.output div.cancel {
+    background-color:yellow;
+    color:white;
+}
+fieldset.plan>div.output div.finish {
+    background-color:red;
+    color:white;
+}
+
+fieldset.plan>div.output td {
+    vertical-align:top;
+}
+fieldset.plan>div.output td.over {
+    border:solid 2px red;
+}
+fieldset.plan>div.output td div.date {
+    color:gray;
+}
+fieldset.plan>div.output div.project {
+    max-height:400px;
+    overflow:auto;
+}

core/team/plan.go

@@ -9,11 +9,43 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
+func _task_scope(m *ice.Message, tz int, arg ...string) (time.Time, time.Time) {
+	begin_time := time.Now()
+	if len(arg) > 1 {
+		begin_time, _ = time.ParseInLocation(ice.MOD_TIME, arg[1], time.Local)
+	}
+
+	begin_time = begin_time.Add(time.Duration(tz) * time.Hour)
+	begin_time = begin_time.Add(-time.Duration(begin_time.UnixNano()) % (24 * time.Hour))
+	begin_time = begin_time.Add(-time.Duration(tz) * time.Hour)
+
+	end_time := begin_time
+	switch kit.Select(WEEK, arg, 0) {
+	case DAY:
+		end_time = begin_time.AddDate(0, 0, 1)
+	case WEEK:
+		begin_time = begin_time.AddDate(0, 0, -int(begin_time.Weekday()))
+		end_time = begin_time.AddDate(0, 0, 7)
+	case MONTH:
+		begin_time = begin_time.AddDate(0, 0, -begin_time.Day()+1)
+		end_time = begin_time.AddDate(0, 1, 0)
+	case YEAR:
+		begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
+		end_time = begin_time.AddDate(1, 0, 0)
+	case LONG:
+		begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
+		begin_time = begin_time.AddDate(-30, 0, 0)
+		end_time = begin_time.AddDate(60, 0, 0)
+	}
+
+	return begin_time, end_time
+}
 func _plan_list(m *ice.Message, begin_time, end_time time.Time) *ice.Message {
 	m.Option(ice.CACHE_LIMIT, "100")
 	m.Fields(0, "begin_time,close_time,zone,id,level,status,score,type,name,text,extra")
 	m.Option(kit.Keycb(mdb.SELECT), func(key string, fields []string, value, val map[string]interface{}) {
 		begin, _ := time.ParseInLocation(ice.MOD_TIME, kit.Format(value[BEGIN_TIME]), time.Local)
+		m.Debug("what %v %v", begin_time, begin)
 		if begin_time.After(begin) || begin.After(end_time) {
 			return
 		}
@@ -25,43 +57,34 @@ func _plan_list(m *ice.Message, begin_time, end_time time.Time) *ice.Message {
 }
 
 const (
-	BEGIN = "begin"
+	DAY   = "day"
-	END   = "end"
+	WEEK  = "week"
+	MONTH = "month"
+	YEAR  = "year"
+	LONG  = "long"
 )
 
 const PLAN = "plan"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
 		PLAN: {Name: "plan scale=week,day,week,month,year,long begin_time@date place@province auto insert export import", Help: "计划", Meta: kit.Dict(
-				ice.Display("/plugin/local/team/plan.js", PLAN),
+			ice.Display(""),
-			), Action: map[string]*ice.Action{
+		), 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(TASK, mdb.INSERT, arg)
-					m.ProcessRefresh30ms()
-				}},
-				mdb.MODIFY: {Name: "task modify", Help: "编辑"},
-				mdb.EXPORT: {Name: "task export", Help: "导出"},
-				mdb.IMPORT: {Name: "task import", Help: "导入"},
-				mdb.INPUTS: {Name: "task inputs", Help: "补全"},
-
 			mdb.PLUGIN: {Name: "plugin extra.ctx extra.cmd extra.arg", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
 				_task_modify(m, arg[0], arg[1], arg[2:]...)
-					m.ProcessRefresh30ms()
 			}},
-				ctx.COMMAND: {Name: "command", Help: "命令"},
 			ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(arg)
+				msg := m.Cmd(TASK, arg[0], arg[1])
+				args := kit.Simple(kit.Keys(msg.Append("extra.pod"), msg.Append("extra.cmd")), arg[2:])
+				if !m.PodCmd(args) {
+					m.Cmdy(args)
+				}
 			}},
-
+		}, TASK, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				BEGIN: {Name: "task begin", Help: "开始"},
-				END:   {Name: "task end", Help: "结束"},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			begin_time, end_time := _task_scope(m, 8, arg...)
 			_plan_list(m, begin_time, end_time)
 			m.PushPodCmd(PLAN, arg...)
 		}},
-		},
+	}})
-	})
 }

core/team/plan.js

@@ -0,0 +1,208 @@
+Volcanos("onimport", {help: "导入数据", list: [], _init: function(can, msg, list, cb, target) {
+        can.onmotion.clear(can, target)
+        can.ui = can.onlayout.profile(can)
+        can.onmotion.hidden(can, can._action)
+        can.onimport[can.Option("scale")||"week"](can, msg)
+        can.page.Modify(can, can.ui.project, {style: {"max-height": can.ui.content.offsetHeight}})
+        can.page.Modify(can, can.ui.profile, {style: {"max-height": can.ui.content.offsetHeight}})
+        can.page.Modify(can, can.ui.profile, {style: {display: "block"}})
+        can.base.isFunc(cb) && cb(msg)
+    },
+    _content: function(can, msg, head, list, key, get, set) {
+        var hash = {}; msg.Table(function(value, index) {
+            var k = key(can.base.Date(value.begin_time)); hash[k] = (hash[k]||[]).concat([value])
+        })
+
+        can.sup.task && (can.sup.task._target = null)
+        var begin_time = can.base.Date(can.Option("begin_time"))
+        can.page.Append(can, can.ui.content, [{view: [chat.CONTENT, html.TABLE], list: can.core.List(list, function(hour, row) {
+            return {type: html.TR, list: can.core.List(head, function(week, col) {
+                if (row == 0) { return {text: [week, html.TH]} }
+                if (col == 0) { return {text: [hour, html.TD]} }
+                return can.onimport._task(can, msg, get(begin_time, col, row, hash), set(begin_time, col, row))
+            })}
+        }) }])
+        can.core.Timer(10, function() {
+            var target = can.sup.task._target||can.sup.task._target
+            can.sup.task = null, target.click()
+            can.Status("count", msg.Length())
+        })
+    },
+    _task: function(can, msg, list, time) { return {text: ["", html.TD],
+        ondblclick: function(event) {
+            can.onaction.insertTask(event, can, time+can.base.Time(null, "%y-%m-%d %H:%M:%S").slice(time.length))
+        },
+        ondrop: function(event) { event.preventDefault()
+            can.drop(event, event.target, time)
+        },
+        ondragover: function(event) { event.preventDefault()
+            can.page.Select(can, can.ui.content, html.TD, function(item) {
+                can.page.ClassList[event.target == item? "add": "del"](can, item, "over")
+            })
+        },
+        list: can.core.List(list, function(task) { return can.base.isString(task)? {text: [task, html.DIV, "date"]}:
+            {text: [can.onexport[can.Action("view")||"text"](can, task), html.DIV, can.onexport.style(can, task)],
+                ondragstart: function(event) { var target = event.target; can.drop = function(event, td, time) { td.append(target)
+                    can.onaction.modifyTask(event, can, task, "begin_time", time+task.begin_time.slice(time.length), task.begin_time)
+                } }, draggable: time != undefined,
+
+                title: can.onexport.title(can, task), _init: function(target) {
+                    var item = can.onappend.item(can, html.ITEM, {nick: task.name+":"+task.text}, function() {
+                        can.core.Timer(10, function() { can.onmotion.select(can, can.ui.content, html.TD, target.parentNode) })
+                        can.onimport._profile(can, task)
+                    }, function() {
+
+                    }, can.ui.project); task._target = target, can.task = can.task||task, can.sup.task = can.sup.task||task
+                    can.sup.task.zone == task.zone && can.sup.task.id == task.id && (can.sup.task._target = target)
+                    target.onclick = function(event) { item.click() }
+                },
+            }
+        }),
+    } },
+    _profile: function(can, task) {
+        function keys(task, key) { return [task.pod, task.zone, task.id, key].join(".") }
+
+        if (can.sup.task) { if (can.sup.task.id == task.id) { return }
+            can.page.Cache(keys(can.sup.task, chat.PROFILE), can.ui.profile, can.sup.task.id)
+            can.page.Cache(keys(can.sup.task, chat.DISPLAY), can.ui.display, can.sup.task.id)
+        }
+
+        can.sup.task = task, can.Status(task)
+        var profile = can.page.Cache(keys(task, "profile"), can.ui.profile)
+        var display = can.page.Cache(keys(task, "display"), can.ui.display)
+        if (profile || display) { return }
+
+        task.extra && can.core.Item(can.base.Obj(task.extra), function(key, value) { task["extra."+key] = value }), delete(task.extra)
+        var table = can.page.Appends(can, can.ui.profile, [{view: [chat.CONTENT, html.TABLE], list: [{th: ["key", "value"]}]}]).first
+        can.core.Item(task, function(key, value) { key != "_target" && can.page.Append(can, table, [{
+            td: [key, key == "pod" && value != ""? can.page.Format("a", can.user.MergeURL(can, {pod: value}), value): value],
+            onclick: function(event) { if (event.target.type == "button") { var msg = can.request(event, can.sup.task)
+                can.run(event, [ctx.ACTION, event.target.name], function(msg) { can.Update() }, true)
+            } },
+            ondblclick: function(event) { can.onmotion.modify(can, event.target, function(ev, value, old) {
+                can.onaction.modifyTask(event, can, task, key, value)
+            }) },
+        }]) }), can.onimport._display(can, task)
+    },
+    _display: function(can, task) { if (!task["extra.cmd"]) { return }
+        can.onappend.plugin(can, {type: "story", ctx: task["extra.ctx"], cmd: task["extra.cmd"], arg: task["extra.arg"]}, function(sub, meta) {
+            sub.run = function(event, cmds, cb) { var msg = can.request(event, {"task.zone": task.zone, "task.id": task.id})
+                can.run(event, can.misc.Concat([ctx.ACTION, cli.RUN, task["zone"], task["id"]], cmds), cb, true)
+            }
+        }, can.ui.display)
+        can.page.Modify(can, can.ui.display, {style: {display: "block"}})
+    },
+
+    day: function(can, msg) {
+        var head = ["hour", "task"]
+        var list = [0]; for (var i = 7; i < 24; i++) { list.push(can.base.Number(i, 2)) }
+
+        function key(time) { return can.base.Number(time.getHours(), 2) }
+        function get(begin_time, col, row, hash) { return hash[list[row]] }
+        function set(begin_time, col, row) { return can.base.Time(begin_time, "%y-%m-%d ")+list[row] }
+
+        can.onimport._content(can, msg, head, list, key, get, set)
+    },
+    week: function(can, msg) {
+        var head = ["hour"].concat(["周日", "周一", "周二", "周三", "周四", "周五", "周六"])
+        var list = [0]; for (var i = 7; i < 24; i++) { list.push(can.base.Number(i, 2)) }
+
+        function key(time) { return time.getDay()+" "+can.base.Number(time.getHours(), 2) }
+        function get(begin_time, col, row, hash) { return hash[col-1+" "+list[row]] }
+        function set(begin_time, col, row) { return can.base.Time(can.base.TimeAdd(begin_time, -begin_time.getDay()+col-1), "%y-%m-%d ")+list[row] }
+
+        can.onimport._content(can, msg, head, list, key, get, set)
+    },
+    month: function(can, msg) {
+        var head = ["order"].concat(["周日", "周一", "周二", "周三", "周四", "周五", "周六"])
+        var list = [0]; for (var i = 1; i < 6; i++) { list.push(i) }
+
+        function key(time) { return can.base.Time(time, "%y-%m-%d") }
+        function get(begin_time, col, row, hash) {
+            var begin = can.base.TimeAdd(begin_time, -(begin_time.getDate()-1))
+            var last = can.base.TimeAdd(begin_time, -(begin_time.getDate()-1)-begin.getDay())
+            var day = can.base.TimeAdd(last, (row-1)*7+col)
+            return [day.getDate()+""].concat(hash[key(day)]||[])
+        }
+        function set(begin_time, col, row) {
+            var begin = can.base.TimeAdd(begin_time, -(begin_time.getDate()-1))
+            var last = can.base.TimeAdd(begin_time, -(begin_time.getDate()-1)-begin.getDay())
+            var day = can.base.TimeAdd(last, (row-1)*7+col)
+            return key(day)
+        }
+
+        can.onimport._content(can, msg, head, list, key, get, set)
+    },
+    year: function(can, msg) {
+        var head = ["month"].concat(["周日", "周一", "周二", "周三", "周四", "周五", "周六"]);
+        var list = [0]; for (var i = 1; i < 13; i++) { list.push(i) }
+
+        function key(time) { return can.base.Time(time, "%y-%m ")+time.getDay() }
+        function get(begin_time, col, row, hash) { return hash[begin_time.getFullYear()+"-"+can.base.Number(row, 2)+" "+(col-1)] }
+        function set(begin_time, col, row) { return begin_time.getFullYear()+"-"+can.base.Number(list[row], 2) }
+
+        can.onimport._content(can, msg, head, list, key, get, set)
+    },
+    long: function(can, msg) {
+        var begin_time = can.base.Date(can.base.Time(can.Option("begin_time"), "%y-%m-%d %H:%M:%S"))
+        var begin = begin_time.getFullYear() - 5
+
+        var head = ["month"]; for (var i = 0; i < 10; i++) { head.push(begin+i) }
+        var list = [0]; for (var i = 1; i < 13; i++) { list.push(i) }
+
+        function key(time) { return can.base.Time(time, "%y-%m") }
+        function get(begin_time, col, row, hash) { return hash[begin+col-1+"-"+can.base.Number(row, 2)] }
+        function set(begin_time, col, row) { return begin+col-1+"-"+can.base.Number(row, 2) }
+
+        can.onimport._content(can, msg, head, list, key, get, set)
+    },
+}, [""])
+Volcanos("onaction", {help: "组件交互", list: [
+        ["level", "all", "l1", "l2", "l3", "l4", "l5"],
+        ["status", "all", "prepare", "process", "cancel", "finish"],
+        ["score", "all", "s1", "s2", "s3", "s4", "s5"],
+        ["view", "", "name", "text", "level", "score"],
+    ],
+    insertTask: function(event, can, time) { var msg = can.sup.request(event, {begin_time: time})
+        can.user.input(event, can, can.Conf("feature.insert"), function(event, button, data, list) {
+            can.run(event, can.base.Simple(ctx.ACTION, mdb.INSERT, "begin_time", time, data))
+        })
+    },
+    modifyTask: function(event, can, task, key, value) { var msg = can.request(event, task)
+        can.run(event, [ctx.ACTION, mdb.MODIFY, key, value, task[key]])
+    },
+
+    _filter: function(event, can, key, value) { var count = 0
+        if (value == "all") {
+            can.page.Select(can, can.ui.content, "div.item", function(item) {
+                can.page.ClassList.del(can, item, "hidden"), count++
+            })
+        } else {
+            can.page.Select(can, can.ui.content, "div.item", function(item) {
+                can.page.ClassList.add(can, item, "hidden")
+            })
+            can.page.Select(can, can.ui.content, "div."+value, function(item) {
+                can.page.ClassList.del(can, item, "hidden"), count++
+            })
+        }
+        can.Action(key, value), can.Status("count", count)
+    },
+    level: function(event, can, key, value) { can.onaction._filter(event, can, key, value) },
+    status: function(event, can, key, value) { can.onaction._filter(event, can, key, value) },
+    score: function(event, can, key, value) { can.onaction._filter(event, can, key, value) },
+    view: function(event, can, key, value) {
+        can.Action(key, value)
+        can.onmotion.clear(can, can.ui.project)
+        can.onmotion.clear(can, can.ui.content)
+        can.onimport[can.Option("scale")](can, can._msg)
+    },
+})
+Volcanos("onexport", {help: "导出数据", list: ["count", "begin_time", "zone", "id", "type", "name", "text"],
+    name: function(can, task) { return task.name },
+    text: function(can, task) { return task.name+": "+(task.text||"") },
+    level: function(can, task) { return "l-"+(task.level||3)+": "+(task.name||"") },
+    score: function(can, task) { return "s-"+(task.level||3)+": "+(task.name||"") },
+    title: function(can, task) { return task.zone+": "+(task.type||"") },
+    style: function(can, task) { return ["item", task.status, "id"+task.id, "l"+(task.level||""), "s"+(task.score||"")].join(" ") },
+})
+

core/team/task.go

@@ -2,7 +2,6 @@ package team
 
 import (
 	"strings"
-	"time"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
@@ -10,56 +9,15 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _task_scope(m *ice.Message, tz int, arg ...string) (time.Time, time.Time) {
-	begin_time := time.Now()
-	if len(arg) > 1 {
-		begin_time, _ = time.ParseInLocation(ice.MOD_TIME, arg[1], time.Local)
-	}
-
-	begin_time = begin_time.Add(time.Duration(tz) * time.Hour)
-	begin_time = begin_time.Add(-time.Duration(begin_time.UnixNano()) % (24 * time.Hour))
-	begin_time = begin_time.Add(-time.Duration(tz) * time.Hour)
-
-	end_time := begin_time
-	switch kit.Select(WEEK, arg, 0) {
-	case DAY:
-		end_time = begin_time.AddDate(0, 0, 1)
-	case WEEK:
-		begin_time = begin_time.AddDate(0, 0, -int(begin_time.Weekday()))
-		end_time = begin_time.AddDate(0, 0, 7)
-	case MONTH:
-		begin_time = begin_time.AddDate(0, 0, -begin_time.Day()+1)
-		end_time = begin_time.AddDate(0, 1, 0)
-	case YEAR:
-		begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
-		end_time = begin_time.AddDate(1, 0, 0)
-	case LONG:
-		begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
-		begin_time = begin_time.AddDate(-5, 0, 0)
-		end_time = begin_time.AddDate(10, 0, 0)
-	}
-
-	return begin_time, end_time
-}
 func _task_action(m *ice.Message, status interface{}, action ...string) string {
 	switch status {
 	case PREPARE:
 		action = append(action, BEGIN)
 	case PROCESS:
 		action = append(action, END)
-	case CANCEL:
+	case CANCEL, FINISH:
-	case FINISH:
 	}
-	return strings.Join(action, ",")
+	return kit.Join(action)
-}
-
-func _task_create(m *ice.Message, zone string) {
-	m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.HASH, kit.MDB_ZONE, zone)
-}
-func _task_insert(m *ice.Message, zone string, arg ...string) {
-	m.Cmdy(mdb.INSERT, m.Prefix(TASK), kit.KeyHash(zone), mdb.LIST,
-		BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time("30m"),
-		STATUS, PREPARE, LEVEL, 3, SCORE, 3, arg)
 }
 func _task_modify(m *ice.Message, field, value string, arg ...string) {
 	if field == STATUS {
@@ -72,46 +30,11 @@ 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) {
-		return
-	}
-
-	switch strings.TrimPrefix(field, "extra.") {
-	case kit.MDB_ZONE:
-		m.Cmdy(mdb.INPUTS, m.Prefix(TASK), "", mdb.HASH, field, value)
-	default:
-		m.Cmdy(mdb.INPUTS, m.Prefix(TASK), kit.KeyHash(m.Option(kit.MDB_ZONE)), mdb.LIST, field, value)
-	}
-}
-func _task_search(m *ice.Message, kind, name, text string) {
-	m.Cmd(mdb.SELECT, m.Prefix(TASK), "", mdb.ZONE, kit.MDB_FOREACH, func(key string, value map[string]interface{}, val map[string]interface{}) {
-		if name != "" && !kit.Contains(value[kit.MDB_NAME], name) {
-			return
-		}
-		if kind == TASK {
-			m.PushSearch(ice.CMD, TASK,
-				kit.MDB_ZONE, val[kit.MDB_ZONE], kit.MDB_ID, kit.Format(value[kit.MDB_ID]),
-				value)
-		} else {
-			m.PushSearch(ice.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)
-		}
-	})
-}
 
 const ( // type
 	ONCE = "once"
 	STEP = "step"
-)
+	// WEEK = "week"
-const ( // scale
-	DAY   = "day"
-	WEEK  = "week"
-	MONTH = "month"
-	YEAR  = "year"
-	LONG  = "long"
 )
 const ( // status
 	PREPARE = "prepare"
@@ -120,35 +43,46 @@ const ( // status
 	FINISH  = "finish"
 )
 const ( // key
-	SCALE  = "scale"
-	LEVEL  = "level"
-	STATUS = "status"
-	SCORE  = "score"
-
 	BEGIN_TIME = "begin_time"
 	CLOSE_TIME = "close_time"
+
+	STATUS = "status"
+	LEVEL  = "level"
+	SCORE  = "score"
+)
+const (
+	BEGIN = "begin"
+	END   = "end"
 )
 
 const TASK = "task"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		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",
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				// m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, m.Prefix(TASK))
-			}},
 		TASK: {Name: "task zone id auto insert export import", Help: "任务", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				if cli.Inputs(m, arg[0]) {
+					return
+				}
+				if arg[0] == m.Conf(TASK, kit.Keym(kit.MDB_SHORT)) {
+					m.Cmdy(mdb.INPUTS, m.Prefix(TASK), "", mdb.HASH, arg[0], arg[1:])
+					return
+				}
+				m.Cmdy(mdb.INPUTS, m.Prefix(TASK), "", mdb.ZONE, m.Option(kit.MDB_ZONE), strings.TrimPrefix(arg[0], "extra."), arg[1:])
+			}},
 			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) {
-					_task_create(m, arg[1])
+				m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
-					_task_insert(m, arg[1], arg[2:]...)
+				m.Cmdy(mdb.INSERT, m.Prefix(TASK), "", mdb.ZONE, m.Option(kit.MDB_ZONE),
+					BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time("30m"),
+					STATUS, PREPARE, LEVEL, 3, SCORE, 3, arg)
 			}},
 			mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
 				_task_modify(m, arg[0], arg[1])
+				m.ProcessRefresh30ms()
 			}},
 			mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
 				_task_modify(m, STATUS, CANCEL)
@@ -159,21 +93,13 @@ func init() {
 			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,extra")
 				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.Cmdy(mdb.IMPORT, m.Prefix(TASK), "", mdb.ZONE)
 				m.ProcessRefresh30ms()
 			}},
-				mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-					_task_inputs(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
-				}},
-				mdb.SEARCH: {Name: "search", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == TASK || arg[0] == kit.MDB_FOREACH {
-						_task_search(m, arg[0], arg[1], arg[2])
-						m.PushPodCmd(TASK, kit.Simple(mdb.SEARCH, arg)...)
-					}
-				}},
 
 			BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
 				_task_modify(m, STATUS, PROCESS)
@@ -182,8 +108,7 @@ func init() {
 				_task_modify(m, STATUS, FINISH)
 			}},
 		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,zone,count", m.Conf(TASK, kit.META_FIELD))
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
-				if m.Cmdy(mdb.SELECT, m.Prefix(TASK), "", mdb.ZONE, arg); len(arg) == 0 {
 				m.PushAction(mdb.REMOVE)
 			} else {
 				status := map[string]int{}
@@ -194,6 +119,5 @@ func init() {
 				m.Status(status)
 			}
 		}},
-		},
+	}})
-	})
 }

core/team/team.go

@@ -7,13 +7,6 @@ import (
 
 const TEAM = "team"
 
-var Index = &ice.Context{Name: TEAM, Help: "团队中心", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: TEAM, Help: "团队中心"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Save()
-	}},
-}}
 
 func init() { web.Index.Register(Index, nil, TASK, PLAN) }

misc.go

@@ -212,13 +212,6 @@ func (c *Context) cmd(m *Message, cmd *Command, key string, arg ...string) *Mess
 	return m
 }
 func (c *Context) _cmd(m *Message, cmd *Command, key string, k string, h *Action, arg ...string) *Message {
-	if k == "command" && h.Hand == nil {
-		for _, cmd := range arg {
-			m.Cmdy("command", cmd)
-		}
-		return m
-	}
-
 	if k == RUN && !m.Right(arg) {
 		return m
 	}
@@ -319,20 +312,31 @@ func Display(file string, arg ...string) map[string]string {
 	}
 	return map[string]string{"display": file, kit.MDB_STYLE: kit.Join(arg, " ")}
 }
-func MergeAction(list ...map[string]*Action) map[string]*Action {
+func MergeAction(list ...interface{}) map[string]*Action {
 	if len(list) == 0 {
 		return nil
 	}
+	base := list[0].(map[string]*Action)
 	for _, item := range list[1:] {
+		switch item := item.(type) {
+		case map[string]*Action:
 			for k, v := range item {
-			if h, ok := list[0][k]; !ok {
+				if h, ok := base[k]; !ok {
-				list[0][k] = v
+					base[k] = v
 				} else if h.Hand == nil {
 					h.Hand = v.Hand
 				}
 			}
+		case string:
+			base[CTX_INIT] = &Action{Hand: func(m *Message, arg ...string) {
+				m.Search(item, func(p *Context, s *Context, key string, cmd *Command) {
+					MergeAction(base, cmd.Action)
+					m.target.Merge(m.target)
+				})
+			}}
 		}
-	return list[0]
+	}
+	return base
 }
 func SelectAction(list map[string]*Action, fields ...string) map[string]*Action {
 	if len(fields) == 0 {