liubin/icebergs
1
0
Fork 0
forked from x/icebergs
Code Pull Requests Activity

opt team

Browse Source
This commit is contained in:
shylinux 2020-09-16 09:42:25 +08:00
parent 362bc64f4a
commit b82e311789
6 changed files with 421 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/chat/chat.go
View File

@ -274,4 +274,8 @@ var Index = &ice.Context{Name: "chat", Help: "聊天中心",
},
}
func init() { web.Index.Register(Index, &web.Frame{}, RIVER, STORM) }
func init() {
web.Index.Register(Index, &web.Frame{},
HEADER, RIVER, STORM, ACTION, FOOTER,
)
}

12
core/team/miss.go Normal file
View File

@ -0,0 +1,12 @@
package team
const MISS = "miss"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
MISS: {Name: "miss", Help: "miss", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
},
Commands: map[string]*ice.Command{},
}, nil)
}

64
core/team/plan.go Normal file
View File

@ -0,0 +1,64 @@
package team
const PLAN = "plan"
func init() {
Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{
PLAN: {Name: "plan scale=day,week,month,year,long begin_time@date auto 添加 导出 导入", Help: "计划", Meta: kit.Dict(
"display", "/plugin/local/team/plan.js", "style", "plan",
), Action: 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) {
_task_create(m, arg[1])
_task_insert(m, arg[1], arg[2:]...)
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
}},
mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
}},
mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv")))
}},
mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv")))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
}},
gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
}},
gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
}},
"command": {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 1 {
m.Cmdy(ctx.COMMAND, arg[0])
return
}
m.Cmdy(arg[0], arg[1:])
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
begin_time, end_time := _task_scope(m, arg...)
m.Set(ice.MSG_OPTION, "end_time")
m.Set(ice.MSG_OPTION, "begin_time")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, m.Option(kit.MDB_ZONE)), func(key string, val map[string]interface{}) {
zone := kit.Format(kit.Value(val, "meta.zone"))
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
begin, _ := time.ParseInLocation(ice.MOD_TIME, kit.Format(value[BEGIN_TIME]), time.Local)
if begin_time.Before(begin) && begin.Before(end_time) {
m.Push(zone, value)
m.Push(kit.MDB_ZONE, zone)
m.PushAction(_task_action(m, value[STATUS], "插件"))
}
})
})
}},
},
}, nil)
}

331
core/team/task.go Normal file
View File

@ -0,0 +1,331 @@
package team
import (
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/gdb"
"github.com/shylinux/icebergs/base/mdb"
kit "github.com/shylinux/toolkits"
"encoding/csv"
"os"
"path"
"strings"
"time"
)
func _task_list(m *ice.Message, zone string, id string, field ...interface{}) {
fields := strings.Split(kit.Select("begin_time,zone,id,status,level,type,name,text", m.Option("fields")), ",")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
if zone = kit.Format(kit.Value(val, "meta.zone")); id == "" {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Push(zone, value, fields)
})
return
}
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
})
}
func _task_create(m *ice.Message, zone string) {
if m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, nil) == nil {
m.Conf(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_META, kit.MDB_SHORT), kit.MDB_ZONE)
m.Rich(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Data(kit.MDB_ZONE, zone))
m.Log_CREATE(kit.MDB_ZONE, zone)
}
}
func _task_insert(m *ice.Message, zone string, arg ...string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.Dict(
BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time("30m"), kit.MDB_EXTRA, kit.Dict(),
STATUS, StatusPrepare, LEVEL, 3, SCORE, 3, arg,
))
m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id, arg[0], arg[1])
m.Echo("%d", id)
})
}
func _task_modify(m *ice.Message, zone, id, pro, set string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
switch pro {
case kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME:
m.Info("not allow %v", key)
case STATUS:
if value[STATUS] == set {
break
}
switch value[STATUS] {
case StatusCancel, StatusFinish:
m.Info("not allow %v", key)
return
}
switch set {
case StatusProcess:
kit.Value(value, BEGIN_TIME, m.Time())
case StatusCancel, StatusFinish:
kit.Value(value, CLOSE_TIME, m.Time())
}
fallthrough
default:
m.Log_MODIFY(kit.MDB_ZONE, zone, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
kit.Value(value, pro, set)
}
})
})
}
func _task_delete(m *ice.Message, zone, id string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Log_DELETE(kit.MDB_ZONE, zone, kit.MDB_ID, id)
kit.Value(value, STATUS, StatusCancel)
})
})
}
func _task_export(m *ice.Message, file string) {
f, p, e := kit.Create(file)
m.Assert(e)
defer f.Close()
w := csv.NewWriter(f)
defer w.Flush()
m.Assert(w.Write([]string{
kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME,
kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT,
LEVEL, STATUS, SCORE,
BEGIN_TIME, CLOSE_TIME,
kit.MDB_EXTRA,
}))
count := 0
m.Option("cache.limit", -2)
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Assert(w.Write(kit.Simple(
kit.Format(kit.Value(val, "meta.zone")),
kit.Format(value[kit.MDB_ID]),
kit.Format(value[kit.MDB_TIME]),
kit.Format(value[kit.MDB_TYPE]),
kit.Format(value[kit.MDB_NAME]),
kit.Format(value[kit.MDB_TEXT]),
kit.Format(value[LEVEL]),
kit.Format(value[STATUS]),
kit.Format(value[SCORE]),
kit.Format(value[BEGIN_TIME]),
kit.Format(value[CLOSE_TIME]),
kit.Format(value[kit.MDB_EXTRA]),
)))
count++
})
})
m.Log_EXPORT("file", p, "count", count)
m.Echo(p)
}
func _task_import(m *ice.Message, file string) {
f, e := os.Open(file)
m.Assert(e)
defer f.Close()
r := csv.NewReader(f)
heads, _ := r.Read()
count := 0
for {
lines, e := r.Read()
if e != nil {
break
}
zone := ""
data := kit.Dict()
for i, k := range heads {
switch k {
case kit.MDB_ZONE:
zone = lines[i]
case kit.MDB_ID:
continue
case kit.MDB_EXTRA:
kit.Value(data, k, kit.UnMarshal(lines[i]))
default:
kit.Value(data, k, lines[i])
}
}
_task_create(m, zone)
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), data)
m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id)
count++
})
}
m.Log_IMPORT("file", file, "count", count)
m.Echo(file)
}
func _task_search(m *ice.Message, kind, name, text string, arg ...string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
if value[kit.MDB_NAME] == name || strings.Contains(kit.Format(value[kit.MDB_TEXT]), name) {
m.Push("pod", m.Option(ice.MSG_USERPOD))
m.Push("ctx", m.Prefix())
m.Push("cmd", TASK)
m.Push("time", value[kit.MDB_TIME])
m.Push("size", 1)
m.Push("type", TASK)
m.Push("name", value[kit.MDB_NAME])
m.Push("text", kit.Format("%s:%d", kit.Value(val, "meta.zone"), kit.Int(value[kit.MDB_ID])))
}
})
})
}
func _task_render(m *ice.Message, kind, name, text string, arg ...string) {
ls := strings.Split(text, ":")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), ls[0], func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
})
}
func _task_action(m *ice.Message, status interface{}, action ...string) []string {
switch status {
case StatusPrepare:
action = append(action, "开始")
case StatusProcess:
action = append(action, "完成")
case StatusCancel, StatusFinish:
}
return action
}
func _task_input(m *ice.Message, field, value string) {
switch field {
case "zone":
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Push("zone", kit.Value(val, "meta.zone"))
m.Push("count", kit.Select("0", kit.Format(kit.Value(val, "meta.count"))))
})
m.Sort("count", "int_r")
case "name", "text":
list := map[string]int{}
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
list[kit.Format(value[field])]++
})
})
for k, i := range list {
m.Push("key", k)
m.Push("count", i)
}
m.Sort("count", "int_r")
}
}
func _task_scope(m *ice.Message, 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)
}
end_time := begin_time
switch begin_time = begin_time.Add(-time.Duration(begin_time.UnixNano()) % (24 * time.Hour)); arg[0] {
case ScaleDay:
end_time = begin_time.AddDate(0, 0, 1)
case ScaleWeek:
begin_time = begin_time.AddDate(0, 0, -int(begin_time.Weekday()))
end_time = begin_time.AddDate(0, 0, 7)
case ScaleMonth:
begin_time = begin_time.AddDate(0, 0, -begin_time.Day()+1)
end_time = begin_time.AddDate(0, 1, 0)
case ScaleYear:
begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
end_time = begin_time.AddDate(1, 0, 0)
case ScaleLong:
begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
begin_time = begin_time.AddDate(-begin_time.Year()%5, 0, 0)
end_time = begin_time.AddDate(5, 0, 0)
}
begin_time = begin_time.Add(-8 * time.Hour)
end_time = end_time.Add(-8 * time.Hour)
return begin_time, end_time
}
const (
LEVEL = "level"
STATUS = "status"
SCORE = "score"
BEGIN_TIME = "begin_time"
CLOSE_TIME = "close_time"
EXPORT = "usr/export/web.team.task/"
)
const (
ScaleDay = "day"
ScaleWeek = "week"
ScaleMonth = "month"
ScaleYear = "year"
ScaleLong = "long"
)
const (
StatusPrepare = "prepare"
StatusProcess = "process"
StatusCancel = "cancel"
StatusFinish = "finish"
)
const TASK = "task"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
TASK: {Name: "task", Help: "task", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
},
Commands: map[string]*ice.Command{
TASK: {Name: "task zone=auto id=auto auto 添加:button 导出:button 导入:button", Help: "任务", Action: 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) {
_task_create(m, arg[1])
_task_insert(m, arg[1], arg[2:]...)
}},
mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
}},
mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
}},
mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
_task_search(m, arg[0], arg[1], arg[2], arg[3:]...)
}},
mdb.RENDER: {Name: "render type name text", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
_task_render(m, arg[0], arg[1], arg[2], arg[3:]...)
}},
gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
}},
gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
}},
"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if _task_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1)); len(arg) < 2 {
m.Table(func(index int, value map[string]string, head []string) {
m.PushAction(_task_action(m, value[STATUS]))
})
} else {
m.Table(func(index int, value map[string]string, head []string) {
if value["key"] == "status" {
m.Push("key", "action")
}
})
}
}},
},
}, nil)
}

385
core/team/team.go
View File

@ -8,392 +8,17 @@ import (
"github.com/shylinux/icebergs/base/web"
kit "github.com/shylinux/toolkits"
"encoding/csv"
"os"
"path"
"strings"
"time"
)
func _task_list(m *ice.Message, zone string, id string, field ...interface{}) {
fields := strings.Split(kit.Select("begin_time,zone,id,status,level,type,name,text", m.Option("fields")), ",")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
if zone = kit.Format(kit.Value(val, "meta.zone")); id == "" {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Push(zone, value, fields)
})
return
}
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
})
}
func _task_create(m *ice.Message, zone string) {
if m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, nil) == nil {
m.Conf(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_META, kit.MDB_SHORT), kit.MDB_ZONE)
m.Rich(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Data(kit.MDB_ZONE, zone))
m.Log_CREATE(kit.MDB_ZONE, zone)
}
}
func _task_insert(m *ice.Message, zone string, arg ...string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.Dict(
BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time("30m"), kit.MDB_EXTRA, kit.Dict(),
STATUS, StatusPrepare, LEVEL, 3, SCORE, 3, arg,
))
m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id, arg[0], arg[1])
m.Echo("%d", id)
})
}
func _task_modify(m *ice.Message, zone, id, pro, set string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
switch pro {
case kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME:
m.Info("not allow %v", key)
case STATUS:
if value[STATUS] == set {
break
}
switch value[STATUS] {
case StatusCancel, StatusFinish:
m.Info("not allow %v", key)
return
}
switch set {
case StatusProcess:
kit.Value(value, BEGIN_TIME, m.Time())
case StatusCancel, StatusFinish:
kit.Value(value, CLOSE_TIME, m.Time())
}
fallthrough
default:
m.Log_MODIFY(kit.MDB_ZONE, zone, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
kit.Value(value, pro, set)
}
})
})
}
func _task_delete(m *ice.Message, zone, id string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Log_DELETE(kit.MDB_ZONE, zone, kit.MDB_ID, id)
kit.Value(value, STATUS, StatusCancel)
})
})
}
func _task_export(m *ice.Message, file string) {
f, p, e := kit.Create(file)
m.Assert(e)
defer f.Close()
const TEAM = "team"
w := csv.NewWriter(f)
defer w.Flush()
m.Assert(w.Write([]string{
kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME,
kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT,
LEVEL, STATUS, SCORE,
BEGIN_TIME, CLOSE_TIME,
kit.MDB_EXTRA,
}))
count := 0
m.Option("cache.limit", -2)
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Assert(w.Write(kit.Simple(
kit.Format(kit.Value(val, "meta.zone")),
kit.Format(value[kit.MDB_ID]),
kit.Format(value[kit.MDB_TIME]),
kit.Format(value[kit.MDB_TYPE]),
kit.Format(value[kit.MDB_NAME]),
kit.Format(value[kit.MDB_TEXT]),
kit.Format(value[LEVEL]),
kit.Format(value[STATUS]),
kit.Format(value[SCORE]),
kit.Format(value[BEGIN_TIME]),
kit.Format(value[CLOSE_TIME]),
kit.Format(value[kit.MDB_EXTRA]),
)))
count++
})
})
m.Log_EXPORT("file", p, "count", count)
m.Echo(p)
}
func _task_import(m *ice.Message, file string) {
f, e := os.Open(file)
m.Assert(e)
defer f.Close()
r := csv.NewReader(f)
heads, _ := r.Read()
count := 0
for {
lines, e := r.Read()
if e != nil {
break
}
zone := ""
data := kit.Dict()
for i, k := range heads {
switch k {
case kit.MDB_ZONE:
zone = lines[i]
case kit.MDB_ID:
continue
case kit.MDB_EXTRA:
kit.Value(data, k, kit.UnMarshal(lines[i]))
default:
kit.Value(data, k, lines[i])
}
}
_task_create(m, zone)
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), data)
m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id)
count++
})
}
m.Log_IMPORT("file", file, "count", count)
m.Echo(file)
}
func _task_search(m *ice.Message, kind, name, text string, arg ...string) {
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
if value[kit.MDB_NAME] == name || strings.Contains(kit.Format(value[kit.MDB_TEXT]), name) {
m.Push("pod", m.Option(ice.MSG_USERPOD))
m.Push("ctx", m.Prefix())
m.Push("cmd", TASK)
m.Push("time", value[kit.MDB_TIME])
m.Push("size", 1)
m.Push("type", TASK)
m.Push("name", value[kit.MDB_NAME])
m.Push("text", kit.Format("%s:%d", kit.Value(val, "meta.zone"), kit.Int(value[kit.MDB_ID])))
}
})
})
}
func _task_render(m *ice.Message, kind, name, text string, arg ...string) {
ls := strings.Split(text, ":")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), ls[0], func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
})
}
func _task_action(m *ice.Message, status interface{}, action ...string) []string {
switch status {
case StatusPrepare:
action = append(action, "开始")
case StatusProcess:
action = append(action, "完成")
case StatusCancel, StatusFinish:
}
return action
}
func _task_input(m *ice.Message, field, value string) {
switch field {
case "zone":
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Push("zone", kit.Value(val, "meta.zone"))
m.Push("count", kit.Select("0", kit.Format(kit.Value(val, "meta.count"))))
})
m.Sort("count", "int_r")
case "name", "text":
list := map[string]int{}
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
list[kit.Format(value[field])]++
})
})
for k, i := range list {
m.Push("key", k)
m.Push("count", i)
}
m.Sort("count", "int_r")
}
}
func _task_scope(m *ice.Message, 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)
}
end_time := begin_time
switch begin_time = begin_time.Add(-time.Duration(begin_time.UnixNano()) % (24 * time.Hour)); arg[0] {
case ScaleDay:
end_time = begin_time.AddDate(0, 0, 1)
case ScaleWeek:
begin_time = begin_time.AddDate(0, 0, -int(begin_time.Weekday()))
end_time = begin_time.AddDate(0, 0, 7)
case ScaleMonth:
begin_time = begin_time.AddDate(0, 0, -begin_time.Day()+1)
end_time = begin_time.AddDate(0, 1, 0)
case ScaleYear:
begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
end_time = begin_time.AddDate(1, 0, 0)
case ScaleLong:
begin_time = begin_time.AddDate(0, 0, -begin_time.YearDay()+1)
begin_time = begin_time.AddDate(-begin_time.Year()%5, 0, 0)
end_time = begin_time.AddDate(5, 0, 0)
}
begin_time = begin_time.Add(-8 * time.Hour)
end_time = end_time.Add(-8 * time.Hour)
return begin_time, end_time
}
const (
TASK = "task"
PLAN = "plan"
MISS = "miss"
)
const (
LEVEL = "level"
STATUS = "status"
SCORE = "score"
BEGIN_TIME = "begin_time"
CLOSE_TIME = "close_time"
EXPORT = "usr/export/web.team.task/"
)
const (
ScaleDay = "day"
ScaleWeek = "week"
ScaleMonth = "month"
ScaleYear = "year"
ScaleLong = "long"
)
const (
StatusPrepare = "prepare"
StatusProcess = "process"
StatusCancel = "cancel"
StatusFinish = "finish"
)
var Index = &ice.Context{Name: "team", Help: "团队中心",
Configs: map[string]*ice.Config{
TASK: {Name: "task", Help: "task", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
MISS: {Name: "miss", Help: "miss", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
},
var Index = &ice.Context{Name: TEAM, Help: "团队中心",
Configs: map[string]*ice.Config{},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Load()
m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, TASK, m.Prefix())
m.Cmd(mdb.RENDER, mdb.CREATE, TASK, TASK, m.Prefix())
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save(TASK) }},
TASK: {Name: "task zone=auto id=auto auto 添加:button 导出:button 导入:button", Help: "任务", Action: 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) {
_task_create(m, arg[1])
_task_insert(m, arg[1], arg[2:]...)
}},
mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
}},
mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
}},
mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
_task_search(m, arg[0], arg[1], arg[2], arg[3:]...)
}},
mdb.RENDER: {Name: "render type name text", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
_task_render(m, arg[0], arg[1], arg[2], arg[3:]...)
}},
gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
}},
gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
}},
"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if _task_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1)); len(arg) < 2 {
m.Table(func(index int, value map[string]string, head []string) {
m.PushAction(_task_action(m, value[STATUS]))
})
} else {
m.Table(func(index int, value map[string]string, head []string) {
if value["key"] == "status" {
m.Push("key", "action")
}
})
}
}},
PLAN: {Name: "plan scale=day,week,month,year,long begin_time@date auto 添加 导出 导入", Help: "计划", Meta: kit.Dict(
"display", "/plugin/local/team/plan.js", "style", "plan",
), Action: 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) {
_task_create(m, arg[1])
_task_insert(m, arg[1], arg[2:]...)
}},
mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
}},
mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
}},
mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv")))
}},
mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv")))
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
}},
gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
}},
gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
}},
"command": {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 1 {
m.Cmdy(ctx.COMMAND, arg[0])
return
}
m.Cmdy(arg[0], arg[1:])
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
begin_time, end_time := _task_scope(m, arg...)
m.Set(ice.MSG_OPTION, "end_time")
m.Set(ice.MSG_OPTION, "begin_time")
m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, m.Option(kit.MDB_ZONE)), func(key string, val map[string]interface{}) {
zone := kit.Format(kit.Value(val, "meta.zone"))
m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
begin, _ := time.ParseInLocation(ice.MOD_TIME, kit.Format(value[BEGIN_TIME]), time.Local)
if begin_time.Before(begin) && begin.Before(end_time) {
m.Push(zone, value)
m.Push(kit.MDB_ZONE, zone)
m.PushAction(_task_action(m, value[STATUS], "插件"))
}
})
})
}},
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() }},
},
}

6
misc/zsh/trash.go
View File

@ -6,6 +6,8 @@ import (
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/nfs"
kit "github.com/shylinux/toolkits"
"path"
)
const TRASH = "trash"
@ -18,7 +20,7 @@ func init() {
)},
},
Commands: map[string]*ice.Command{
TRASH: {Name: "TRASH hash auto 清理", Help: "收藏夹", Action: map[string]*ice.Action{
TRASH: {Name: "TRASH hash path auto 清理", Help: "收藏夹", Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert from= to=", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, m.Prefix(TRASH), "", mdb.HASH, "from", m.Option("from"), "to", m.Option("to"))
}},
@ -35,7 +37,7 @@ func init() {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 0 {
m.Cmd(mdb.SELECT, m.Prefix(TRASH), "", mdb.HASH, kit.MDB_HASH, arg).Table(func(index int, value map[string]string, head []string) {
m.Cmdy(nfs.DIR, value["to"])
m.Cmdy(nfs.DIR, path.Join(value["to"], kit.Select("", arg, 1)))
})
return
}