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 team

Browse Source
This commit is contained in:
shaoying 2020-08-02 01:56:26 +08:00
parent dc398e9044
commit 359c086cbb
7 changed files with 614 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
conf.go
View File

@ -26,6 +26,7 @@ const ( // MSG
MSG_CMDS = "cmds"
MSG_SESSID = "sessid"
MSG_DOMAIN = "domain"
MSG_USERIP = "user.ip"
MSG_USERUA = "user.ua"
MSG_USERURL = "user.url"

12
core/chat/chat.go
View File

@ -100,14 +100,24 @@ var Index = &ice.Context{Name: "chat", Help: "聊天中心",
default:
// 群组检查
m.Richs(RIVER, nil, arg[0], func(key string, value map[string]interface{}) {
m.Debug("%v", kit.Value(value, "meta.type"))
if kit.Value(value, "meta.type") != "public" {
m.Option(ice.MSG_DOMAIN, "R"+arg[0])
}
m.Richs(RIVER, kit.Keys(kit.MDB_HASH, arg[0], USER), m.Option(ice.MSG_USERNAME), func(key string, value map[string]interface{}) {
if m.Option(ice.MSG_RIVER, arg[0]); len(arg) > 1 {
// 应用检查
m.Richs(RIVER, kit.Keys(kit.MDB_HASH, arg[0], TOOL), arg[1], func(key string, value map[string]interface{}) {
m.Debug("%v", kit.Value(value, "meta.type"))
if kit.Value(value, "meta.type") != "public" {
m.Option(ice.MSG_DOMAIN, kit.Keys(m.Option(ice.MSG_DOMAIN), "S"+arg[1]))
}
m.Option(ice.MSG_STORM, arg[1])
})
}
m.Log_AUTH(RIVER, m.Option(ice.MSG_RIVER), STORM, m.Option(ice.MSG_STORM))
m.Log_AUTH(RIVER, m.Option(ice.MSG_RIVER), STORM, m.Option(ice.MSG_STORM), "domain", m.Option(ice.MSG_DOMAIN))
})
})
switch m.Option(ice.MSG_USERURL) {

650
core/mall/mall.go
View File

@ -2,56 +2,442 @@ package mall
import (
"github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/toolkits"
"encoding/csv"
"os"
"path"
"strconv"
"strings"
)
func input(m *ice.Message, arg ...string) bool {
if len(arg) > 0 && arg[0] == "action" {
switch arg[1] {
case "input":
switch arg[2] {
case "account", "to":
m.Richs("asset", nil, "*", func(key string, value map[string]interface{}) {
m.Push(arg[2], kit.Value(value, "meta.account"))
m.Push("count", kit.Value(value, "meta.count"))
})
m.Sort("count", "int_r")
return true
case "type", "name", "text", "value":
m.Confm("asset", kit.Keys("meta.word", arg[2]), func(key string, value string) {
m.Push(arg[2], key)
m.Push("count", value)
})
m.Sort("count", "int_r")
return true
func _asset_list(m *ice.Message, account string, id string, field ...interface{}) {
fields := strings.Split(kit.Select("time,account,id,type,amount,name,text", m.Option("fields")), ",")
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, account), func(key string, val map[string]interface{}) {
if account == "" {
m.Push(key, val["meta"], []string{kit.MDB_TIME, kit.MDB_COUNT, ACCOUNT, AMOUNT})
return
}
if account = kit.Format(kit.Value(val, "meta.account")); id == "" {
m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
m.Push(account, value, fields, val["meta"])
})
m.Sort("id", "int_r")
return
}
m.Grows(ASSET, 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 _asset_create(m *ice.Message, account string) {
if m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, nil) == nil {
m.Conf(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_META, kit.MDB_SHORT), ACCOUNT)
m.Rich(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Data(ACCOUNT, account, AMOUNT, 0))
m.Log_CREATE(ACCOUNT, account)
}
}
func _asset_insert(m *ice.Message, account string, arg ...string) {
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, func(key string, value map[string]interface{}) {
for i := 0; i < len(arg)-1; i += 2 {
if arg[i] == "amount" {
kit.Value(value, "meta.amount", kit.Int(kit.Value(value, "meta.amount"))+kit.Int(arg[i+1]))
}
}
}
return false
id := m.Grow(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.Dict(
kit.MDB_EXTRA, kit.Dict(),
arg,
))
m.Log_INSERT(ACCOUNT, account, kit.MDB_ID, id, arg[0], arg[1])
m.Echo("%d", id)
})
}
func _asset_modify(m *ice.Message, account, id, pro, set string) {
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, account), func(key string, val map[string]interface{}) {
m.Grows(ASSET, 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 ACCOUNT, kit.MDB_ID, kit.MDB_TIME:
m.Info("not allow %v", key)
default:
m.Log_MODIFY(ACCOUNT, account, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
kit.Value(value, pro, set)
}
})
})
}
func _asset_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{
ACCOUNT, kit.MDB_ID, kit.MDB_TIME,
kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT,
AMOUNT, kit.MDB_EXTRA,
}))
count := 0
m.Option("cache.limit", -2)
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(ASSET, 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.account")),
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[AMOUNT]),
kit.Format(value[kit.MDB_EXTRA]),
)))
count++
})
})
m.Log_EXPORT("file", p, "count", count)
m.Echo(p)
}
func _asset_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
}
account := ""
data := kit.Dict()
for i, k := range heads {
switch k {
case ACCOUNT:
account = 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])
}
}
_asset_create(m, account)
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, func(key string, value map[string]interface{}) {
kit.Value(value, "meta.amount", kit.Int(kit.Value(value, "meta.amount"))+kit.Int(data[AMOUNT]))
id := m.Grow(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), data)
m.Log_INSERT(ACCOUNT, account, kit.MDB_ID, id)
count++
})
}
m.Log_IMPORT("file", file, "count", count)
m.Echo(file)
}
func _asset_search(m *ice.Message, kind, name, text string, arg ...string) {
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(ASSET, 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", ASSET)
m.Push("time", value[kit.MDB_TIME])
m.Push("size", 1)
m.Push("type", ASSET)
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 _asset_render(m *ice.Message, kind, name, text string, arg ...string) {
ls := strings.Split(text, ":")
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), ls[0], func(key string, val map[string]interface{}) {
m.Grows(ASSET, 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 _asset_action(m *ice.Message, status interface{}, action ...string) string {
return strings.Join(action, "")
}
func _asset_input(m *ice.Message, key, value string) {
switch key {
case ACCOUNT:
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Push("account", kit.Value(val, "meta.account"))
m.Push("count", kit.Select("0", kit.Format(kit.Value(val, "meta.count"))))
})
case "name", "text":
list := map[string]int{}
m.Option("cache.limit", 10)
m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(k string, val map[string]interface{}) {
m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, k), "", "", func(index int, value map[string]interface{}) {
list[kit.Format(value[key])]++
})
})
for k, i := range list {
m.Push("key", k)
m.Push("count", i)
}
}
m.Sort("count", "int_r")
}
var _asset_inputs = kit.List(
"_input", "text", "name", "account", "value", "@key",
"_input", "select", "name", "type", "values", []interface{}{
"支出", "收入",
},
"_input", "text", "name", "amount",
"_input", "text", "name", "name", "value", "@key",
"_input", "text", "name", "text", "value", "@key",
)
const (
ASSET = "asset"
BONUS = "bonus"
SPEND = "spend"
)
const (
AMOUNT = "amount"
ACCOUNT = "account"
EXPORT = "usr/export/web.mall.asset/"
)
var Index = &ice.Context{Name: "mall", Help: "贸易中心",
Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{
"asset": {Name: "asset", Help: "资产", Value: kit.Data(kit.MDB_SHORT, "account", "site", kit.Dict(
"公积金", "https://grwsyw.gjj.beijing.gov.cn/ish/flow/menu/PPLGRZH0102?_r=0.6644871172745264",
"社保", "http://fuwu.rsj.beijing.gov.cn/csibiz/indinfo/index.jsp",
"个税", "https://its.beijing.chinatax.gov.cn:8443/zmsqjl.html",
), "word", kit.Dict(
"type", kit.Dict("流水", 0), "name", kit.Dict("晚餐", 0), "text", kit.Dict("泡面", 0), "value", kit.Dict("4500", 0),
))},
ASSET: {Name: ASSET, Help: "资产", Value: kit.Data(kit.MDB_SHORT, ACCOUNT)},
},
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, ASSET, ASSET, m.Prefix())
m.Cmd(mdb.RENDER, mdb.CREATE, ASSET, ASSET, m.Prefix())
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Save("asset")
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save(ASSET) }},
ASSET: {Name: "asset account=auto id=auto auto 添加:button 导出:button 导入:button", Help: "资产", Meta: kit.Dict(
mdb.INSERT, _asset_inputs,
), Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert [key value]...", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_asset_create(m, arg[1])
_asset_insert(m, arg[1], arg[2:]...)
}},
mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
_asset_modify(m, m.Option(ACCOUNT), m.Option(kit.MDB_ID), arg[0], arg[1])
}},
mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_asset_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) {
_asset_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_asset_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if _asset_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1)); len(arg) < 2 {
m.Table(func(index int, value map[string]string, head []string) {
})
} else {
m.Table(func(index int, value map[string]string, head []string) {
if value["key"] == "status" {
m.Push("key", "action")
m.Push("value", _asset_action(m, value["value"]))
}
})
}
return
if m.Option("_action") == "保存" {
arg = []string{"action", "save"}
}
if len(arg) > 0 && arg[0] == "action" {
switch arg[1] {
case "modify":
// 修改数据
m.Richs(cmd, nil, m.Option("account"), func(key string, account map[string]interface{}) {
m.Grows(cmd, kit.Keys("hash", key), "id", arg[5], func(index int, current map[string]interface{}) {
m.Log(ice.LOG_MODIFY, "%s: %d %s: %s->%s", key, index, kit.Value(current, arg[2]), arg[2], arg[3])
kit.Value(current, arg[2], arg[3])
})
})
case "save":
// 保存数据
m.Option("cache.limit", -2)
if f, p, e := kit.Create(kit.Select("usr/local/asset.csv", arg, 2)); m.Assert(e) {
defer f.Close()
w := csv.NewWriter(f)
defer w.Flush()
w.Write([]string{"时间", "收支类型", "账目分类", "备注", "金额", "账户"})
m.Richs(cmd, nil, kit.Select("*", arg, 3), func(key string, account map[string]interface{}) {
if kit.Format(kit.Value(account, "meta.account")) == "流水" {
return
}
m.Grows(cmd, kit.Keys("hash", key), kit.Select("", arg, 4), kit.Select("", arg, 5), func(index int, current map[string]interface{}) {
w.Write([]string{
kit.Format(current["time"]),
kit.Format(current["type"]),
kit.Format(current["name"]),
kit.Format(current["text"]),
kit.Format(current["value"]),
kit.Format(kit.Value(account, "meta.account")),
})
})
})
m.Log(ice.LOG_EXPORT, "%s", p)
m.Cmdy(web.STORY, "catch", "csv", p)
}
case "load":
// 加载数据
m.CSV(m.Cmdx("nfs.cat", arg[2])).Table(func(index int, data map[string]string, head []string) {
v, _ := strconv.ParseFloat(data["金额"], 64)
for _, account := range []string{kit.Select(data["账户"], arg, 3), "流水"} {
// amount := kit.Int(v * 100)
item := kit.Dict(
"type", data["收支类型"], "name", data["账目分类"], "text", data["备注"], "value", kit.Int(v),
"time", data["时间"], "extra", kit.UnMarshal(data["extra"]),
)
if m.Richs(cmd, nil, account, nil) == nil {
// 添加账户
m.Log(ice.LOG_CREATE, "account: %s", account)
m.Rich(cmd, nil, kit.Data("account", account, "amount", "0", "bonus", "0", "spend", "0"))
}
m.Richs(cmd, nil, account, func(key string, value map[string]interface{}) {
// 账户流水
m.Grow(cmd, kit.Keys("hash", key), item)
// 账户结余
amount := kit.Int(kit.Value(value, "meta.amount")) + kit.Int(v)
m.Log(ice.LOG_INSERT, "%s: %v", key, amount)
kit.Value(value, "meta.amount", amount)
switch data["收支类型"] {
case "收入":
bonus := kit.Int(kit.Value(value, "meta.bonus")) + kit.Int(v)
kit.Value(value, "meta.bonus", bonus)
case "支出":
spend := kit.Int(kit.Value(value, "meta.spend")) + kit.Int(v)
kit.Value(value, "meta.spend", spend)
}
})
}
})
}
return
}
if len(arg) == 0 {
// 账户列表
m.Richs(cmd, nil, "*", func(key string, value map[string]interface{}) {
m.Push(key, value["meta"], []string{"account", "count", "amount", "bonus", "spend"})
})
m.Sort("amount", "int_r")
return
}
if len(arg) > 5 && m.Richs(cmd, nil, arg[0], nil) == nil {
// 添加账户
m.Rich(cmd, nil, kit.Data("account", arg[0], "amount", "0", "bonus", "0", "spend", "0"))
m.Log(ice.LOG_CREATE, "account: %s", arg[0])
}
field := []string{"time", "id", "value", "type", "name", "text"}
m.Richs(cmd, nil, arg[0], func(key string, value map[string]interface{}) {
if len(arg) == 1 {
// 消费流水
m.Grows(cmd, kit.Keys("hash", key), "", "", func(index int, value map[string]interface{}) {
m.Push("", value, field)
})
m.Sort("id", "int_r")
return
}
if len(arg) == 2 {
// 消费详情
m.Grows(cmd, kit.Keys("hash", key), "id", arg[1], func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
return
}
if len(arg) < 6 {
// 消费查询
name, value := "type", arg[2]
switch len(arg) {
case 3:
// 消费分类
name, value = "type", arg[2]
case 4:
// 消费对象
name, value = "name", arg[3]
case 5:
// 消费备注
name, value = "text", arg[4]
}
m.Grows(cmd, kit.Keys("hash", key), name, value, func(index int, value map[string]interface{}) {
m.Push("", value, field)
})
m.Sort("id", "int_r")
return
}
// 词汇统计
web.Count(m, cmd, "meta.word.type", arg[2])
web.Count(m, cmd, "meta.word.name", arg[3])
web.Count(m, cmd, "meta.word.text", arg[4])
web.Count(m, cmd, "meta.word.value", strings.TrimPrefix(arg[5], "-"))
// 数据结构
amount := kit.Int(arg[5])
extra := kit.Dict()
data := kit.Dict(
kit.MDB_TYPE, arg[2], kit.MDB_NAME, arg[3], kit.MDB_TEXT, arg[4],
"value", amount, "extra", extra,
)
for i := 6; i < len(arg)-1; i += 2 {
switch arg[i] {
case kit.MDB_TIME:
kit.Value(data, arg[i], arg[i+1])
default:
kit.Value(extra, arg[i], arg[i+1])
}
}
// 添加流水
n := m.Grow(cmd, kit.Keys(kit.MDB_HASH, key), data)
// 账户结余
total := kit.Int(kit.Value(value, "meta.amount")) + amount
m.Log(ice.LOG_INSERT, "account: %s total: %v", arg[0], total)
kit.Value(value, "meta.amount", total)
m.Echo("%s: %d %d\n", arg[0], n, total)
// 收支统计
switch data["type"] {
case "收入":
bonus := kit.Int(kit.Value(value, "meta.bonus")) + amount
kit.Value(value, "meta.bonus", bonus)
case "支出":
spend := kit.Int(kit.Value(value, "meta.spend")) + amount
kit.Value(value, "meta.spend", spend)
}
})
}},
"spend": {Name: "spend account=@key to=@key name=@key 记录:button text:textarea value=@key time=@date",
@ -253,187 +639,31 @@ var Index = &ice.Context{Name: "mall", Help: "贸易中心",
m.Cmd("trans", "工资", "个税", tax, arg[0])
}
}},
"asset": {Name: "asset account=auto id=auto auto",
Help: "资产", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if m.Option("_action") == "保存" {
arg = []string{"action", "save"}
}
if len(arg) > 0 && arg[0] == "action" {
switch arg[1] {
case "modify":
// 修改数据
m.Richs(cmd, nil, m.Option("account"), func(key string, account map[string]interface{}) {
m.Grows(cmd, kit.Keys("hash", key), "id", arg[5], func(index int, current map[string]interface{}) {
m.Log(ice.LOG_MODIFY, "%s: %d %s: %s->%s", key, index, kit.Value(current, arg[2]), arg[2], arg[3])
kit.Value(current, arg[2], arg[3])
})
})
case "save":
// 保存数据
m.Option("cache.limit", -2)
if f, p, e := kit.Create(kit.Select("usr/local/asset.csv", arg, 2)); m.Assert(e) {
defer f.Close()
w := csv.NewWriter(f)
defer w.Flush()
w.Write([]string{"时间", "收支类型", "账目分类", "备注", "金额", "账户"})
m.Richs(cmd, nil, kit.Select("*", arg, 3), func(key string, account map[string]interface{}) {
if kit.Format(kit.Value(account, "meta.account")) == "流水" {
return
}
m.Grows(cmd, kit.Keys("hash", key), kit.Select("", arg, 4), kit.Select("", arg, 5), func(index int, current map[string]interface{}) {
w.Write([]string{
kit.Format(current["time"]),
kit.Format(current["type"]),
kit.Format(current["name"]),
kit.Format(current["text"]),
kit.Format(current["value"]),
kit.Format(kit.Value(account, "meta.account")),
})
})
})
m.Log(ice.LOG_EXPORT, "%s", p)
m.Cmdy(web.STORY, "catch", "csv", p)
}
case "load":
// 加载数据
m.CSV(m.Cmdx("nfs.cat", arg[2])).Table(func(index int, data map[string]string, head []string) {
v, _ := strconv.ParseFloat(data["金额"], 64)
for _, account := range []string{kit.Select(data["账户"], arg, 3), "流水"} {
// amount := kit.Int(v * 100)
item := kit.Dict(
"type", data["收支类型"], "name", data["账目分类"], "text", data["备注"], "value", kit.Int(v),
"time", data["时间"], "extra", kit.UnMarshal(data["extra"]),
)
if m.Richs(cmd, nil, account, nil) == nil {
// 添加账户
m.Log(ice.LOG_CREATE, "account: %s", account)
m.Rich(cmd, nil, kit.Data("account", account, "amount", "0", "bonus", "0", "spend", "0"))
}
m.Richs(cmd, nil, account, func(key string, value map[string]interface{}) {
// 账户流水
m.Grow(cmd, kit.Keys("hash", key), item)
// 账户结余
amount := kit.Int(kit.Value(value, "meta.amount")) + kit.Int(v)
m.Log(ice.LOG_INSERT, "%s: %v", key, amount)
kit.Value(value, "meta.amount", amount)
switch data["收支类型"] {
case "收入":
bonus := kit.Int(kit.Value(value, "meta.bonus")) + kit.Int(v)
kit.Value(value, "meta.bonus", bonus)
case "支出":
spend := kit.Int(kit.Value(value, "meta.spend")) + kit.Int(v)
kit.Value(value, "meta.spend", spend)
}
})
}
})
}
return
}
if len(arg) == 0 {
// 账户列表
m.Richs(cmd, nil, "*", func(key string, value map[string]interface{}) {
m.Push(key, value["meta"], []string{"account", "count", "amount", "bonus", "spend"})
})
m.Sort("amount", "int_r")
return
}
if len(arg) > 5 && m.Richs(cmd, nil, arg[0], nil) == nil {
// 添加账户
m.Rich(cmd, nil, kit.Data("account", arg[0], "amount", "0", "bonus", "0", "spend", "0"))
m.Log(ice.LOG_CREATE, "account: %s", arg[0])
}
field := []string{"time", "id", "value", "type", "name", "text"}
m.Richs(cmd, nil, arg[0], func(key string, value map[string]interface{}) {
if len(arg) == 1 {
// 消费流水
m.Grows(cmd, kit.Keys("hash", key), "", "", func(index int, value map[string]interface{}) {
m.Push("", value, field)
})
m.Sort("id", "int_r")
return
}
if len(arg) == 2 {
// 消费详情
m.Grows(cmd, kit.Keys("hash", key), "id", arg[1], func(index int, value map[string]interface{}) {
m.Push("detail", value)
})
return
}
if len(arg) < 6 {
// 消费查询
name, value := "type", arg[2]
switch len(arg) {
case 3:
// 消费分类
name, value = "type", arg[2]
case 4:
// 消费对象
name, value = "name", arg[3]
case 5:
// 消费备注
name, value = "text", arg[4]
}
m.Grows(cmd, kit.Keys("hash", key), name, value, func(index int, value map[string]interface{}) {
m.Push("", value, field)
})
m.Sort("id", "int_r")
return
}
// 词汇统计
web.Count(m, cmd, "meta.word.type", arg[2])
web.Count(m, cmd, "meta.word.name", arg[3])
web.Count(m, cmd, "meta.word.text", arg[4])
web.Count(m, cmd, "meta.word.value", strings.TrimPrefix(arg[5], "-"))
// 数据结构
amount := kit.Int(arg[5])
extra := kit.Dict()
data := kit.Dict(
kit.MDB_TYPE, arg[2], kit.MDB_NAME, arg[3], kit.MDB_TEXT, arg[4],
"value", amount, "extra", extra,
)
for i := 6; i < len(arg)-1; i += 2 {
switch arg[i] {
case kit.MDB_TIME:
kit.Value(data, arg[i], arg[i+1])
default:
kit.Value(extra, arg[i], arg[i+1])
}
}
// 添加流水
n := m.Grow(cmd, kit.Keys(kit.MDB_HASH, key), data)
// 账户结余
total := kit.Int(kit.Value(value, "meta.amount")) + amount
m.Log(ice.LOG_INSERT, "account: %s total: %v", arg[0], total)
kit.Value(value, "meta.amount", total)
m.Echo("%s: %d %d\n", arg[0], n, total)
// 收支统计
switch data["type"] {
case "收入":
bonus := kit.Int(kit.Value(value, "meta.bonus")) + amount
kit.Value(value, "meta.bonus", bonus)
case "支出":
spend := kit.Int(kit.Value(value, "meta.spend")) + amount
kit.Value(value, "meta.spend", spend)
}
})
}},
},
}
func init() { web.Index.Register(Index, &web.Frame{}) }
func input(m *ice.Message, arg ...string) bool {
if len(arg) > 0 && arg[0] == "action" {
switch arg[1] {
case "input":
switch arg[2] {
case "account", "to":
m.Richs("asset", nil, "*", func(key string, value map[string]interface{}) {
m.Push(arg[2], kit.Value(value, "meta.account"))
m.Push("count", kit.Value(value, "meta.count"))
})
m.Sort("count", "int_r")
return true
case "type", "name", "text", "value":
m.Confm("asset", kit.Keys("meta.word", arg[2]), func(key string, value string) {
m.Push(arg[2], key)
m.Push("count", value)
})
m.Sort("count", "int_r")
return true
}
}
}
return false
}

6
core/mall/mall.shy Normal file
View File

@ -0,0 +1,6 @@
title "asset"
refer `
公积金 https://grwsyw.gjj.beijing.gov.cn/ish/flow/menu/PPLGRZH0102?_r=0.6644871172745264
社保 http://fuwu.rsj.beijing.gov.cn/csibiz/indinfo/index.jsp
个税 https://its.beijing.chinatax.gov.cn:8443/zmsqjl.html
`

271
core/team/team.go
View File

@ -1,9 +1,8 @@
package team
import (
"strings"
ice "github.com/shylinux/icebergs"
"github.com/shylinux/icebergs/base/ctx"
"github.com/shylinux/icebergs/base/gdb"
"github.com/shylinux/icebergs/base/mdb"
"github.com/shylinux/icebergs/base/web"
@ -11,76 +10,47 @@ import (
"encoding/csv"
"os"
"path"
"strings"
"time"
)
const (
PLAN = "plan"
TASK = "task"
MISS = "miss"
)
const (
ZONE = "zone"
LEVEL = "level"
STATUS = "status"
SCORE = "score"
BEGIN_TIME = "begin_time"
CLOSE_TIME = "close_time"
EXPORT = "usr/export/web.team.task/list.csv"
)
const (
ScaleDay = "day"
ScaleWeek = "week"
ScaleMonth = "month"
ScaleYear = "year"
ScaleLong = "long"
)
const (
StatusPrepare = "prepare"
StatusProcess = "process"
StatusCancel = "cancel"
StatusFinish = "finish"
)
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, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
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, key), "", "", func(index int, value 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.Push(zone, value, fields)
})
return
}
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value 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.Push("detail", value)
})
})
}
func _task_create(m *ice.Message, zone string) {
if m.Richs(TASK, nil, zone, nil) == nil {
m.Rich(TASK, nil, kit.Data(ZONE, zone))
m.Log_CREATE(ZONE, zone)
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, kind, name, text, begin_time, close_time string, arg ...string) {
m.Richs(TASK, nil, zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, key), kit.Dict(
kit.MDB_TYPE, kind, kit.MDB_NAME, name, kit.MDB_TEXT, text,
BEGIN_TIME, begin_time, CLOSE_TIME, begin_time,
STATUS, StatusPrepare, LEVEL, 3, SCORE, 3,
kit.MDB_EXTRA, kit.Dict(arg),
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(), kit.MDB_EXTRA, kit.Dict(),
STATUS, StatusPrepare, LEVEL, 3, SCORE, 3, arg,
))
m.Log_INSERT(ZONE, zone, kit.MDB_ID, id, kit.MDB_TYPE, kind, kit.MDB_NAME, name)
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, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
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 ZONE, kit.MDB_ID, kit.MDB_TIME:
case kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME:
m.Info("not allow %v", key)
case STATUS:
if value[STATUS] == set {
@ -99,16 +69,16 @@ func _task_modify(m *ice.Message, zone, id, pro, set string) {
}
fallthrough
default:
m.Log_MODIFY(ZONE, zone, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
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, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
m.Log_DELETE(ZONE, zone, kit.MDB_ID, id)
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)
})
})
@ -122,7 +92,7 @@ func _task_export(m *ice.Message, file string) {
defer w.Flush()
m.Assert(w.Write([]string{
ZONE, kit.MDB_ID, kit.MDB_TIME,
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,
@ -130,8 +100,8 @@ func _task_export(m *ice.Message, file string) {
}))
count := 0
m.Option("cache.limit", -2)
m.Richs(TASK, nil, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
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]),
@ -170,7 +140,7 @@ func _task_import(m *ice.Message, file string) {
data := kit.Dict()
for i, k := range heads {
switch k {
case ZONE:
case kit.MDB_ZONE:
zone = lines[i]
case kit.MDB_ID:
continue
@ -182,18 +152,19 @@ func _task_import(m *ice.Message, file string) {
}
_task_create(m, zone)
m.Richs(TASK, nil, zone, func(key string, value map[string]interface{}) {
id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, key), data)
m.Log_INSERT(ZONE, zone, kit.MDB_ID, id)
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, nil, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
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())
@ -210,27 +181,36 @@ func _task_search(m *ice.Message, kind, name, text string, arg ...string) {
}
func _task_render(m *ice.Message, kind, name, text string, arg ...string) {
ls := strings.Split(text, ":")
m.Richs(TASK, nil, ls[0], func(key string, val map[string]interface{}) {
m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
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_plugin(m *ice.Message, arg ...string) {
if len(arg) == 0 {
kit.Fetch(m.Confv(MISS, "meta.plug"), func(key string, value map[string]interface{}) {
for k := range value {
m.Push(key, k)
}
})
return
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:
}
m.Cmdy(kit.Keys(arg[0], arg[1]), arg[2:])
for i, v := range action {
action[i] = m.Cmdx(mdb.RENDER, web.RENDER.Button, v)
}
return strings.Join(action, "")
}
func _task_input(m *ice.Message, key, value string) {
m.Cmdy(kit.Keys(m.Option("zone"), m.Option("type")), "action", "input", key, value)
switch key {
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":
case "text":
}
}
func _task_scope(m *ice.Message, arg ...string) (time.Time, time.Time) {
begin_time := time.Now()
@ -262,19 +242,55 @@ func _task_scope(m *ice.Message, arg ...string) (time.Time, time.Time) {
return begin_time, end_time
}
var _task_inputs = kit.List(
"_input", "text", "name", "zone", "value", "@key",
"_input", "select", "name", "type", "values", []interface{}{
"once", "step", "week",
},
"_input", "text", "name", "name", "value", "@key",
"_input", "text", "name", "text", "value", "@key",
"_input", "text", "name", "extra.cmds",
"_input", "text", "name", "extra.args",
"_input", "text", "name", "begin_time", "value", "@date",
"_input", "text", "name", "close_time", "value", "@date",
)
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, ZONE)},
MISS: {Name: "miss", Help: "miss", Value: kit.Data(kit.MDB_SHORT, ZONE)},
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)},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Travel(func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
if s == c {
return
}
m.Conf(MISS, kit.Keys("meta.plug", s.Name, key), cmd.Name)
})
m.Load()
m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, TASK, m.Prefix())
@ -283,32 +299,23 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
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: "任务", Meta: kit.Dict(
mdb.INSERT, kit.List(
"_input", "text", "name", "zone",
"_input", "text", "name", "type",
"_input", "text", "name", "name",
"_input", "text", "name", "text",
"_input", "text", "name", "begin_time",
"_input", "text", "name", "close_time",
"_input", "text", "name", "cmds",
"_input", "text", "name", "args",
),
mdb.INSERT, _task_inputs,
), Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert [key value]...", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_task_create(m, arg[1])
_task_insert(m, arg[1], arg[3], arg[5], arg[7], arg[9], arg[11], arg[12:]...)
_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(ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
_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(ZONE), m.Option(kit.MDB_ID))
_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(EXPORT, arg, 0))
_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(EXPORT, arg, 0))
_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) {
@ -319,41 +326,66 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
}},
gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
_task_modify(m, m.Option(ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
_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(ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
_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) {
_task_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
if len(arg) < 2 {
m.PushAction("开始", "完成")
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.Push("action", _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")
m.Push("value", _task_action(m, value["value"]))
}
})
}
}},
PLAN: {Name: "plan scale:select=day|week|month|year|long begin_time=@date end_time=@date auto", Help: "计划", Meta: kit.Dict(
PLAN: {Name: "plan scale:select=day|week|month|year|long begin_time=@date auto 添加:button", Help: "计划", Meta: kit.Dict(
mdb.INSERT, _task_inputs,
"display", "/plugin/local/team/plan.js", "detail", []string{StatusPrepare, StatusProcess, StatusCancel, StatusFinish},
), Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone type name text begin_time end_time", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_task_create(m, arg[0])
_task_insert(m, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5])
mdb.INSERT: {Name: "insert [key value]...", 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(ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
_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(ZONE), m.Option(kit.MDB_ID))
_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(EXPORT, arg, 0))
_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(EXPORT, arg, 0))
_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
}},
mdb.PLUGIN: {Name: "plugin", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
_task_plugin(m, arg...)
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)
}},
"input": {Name: "input", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
_task_input(m, arg[0], arg[1])
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:])
}},
"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) {
begin_time, end_time := _task_scope(m, arg...)
@ -361,13 +393,14 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
m.Set(ice.MSG_OPTION, "end_time")
m.Set(ice.MSG_OPTION, "begin_time")
m.Richs(TASK, nil, kit.Select(kit.MDB_FOREACH, m.Option(ZONE)), func(key string, val map[string]interface{}) {
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, key), "", "", func(index int, value 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{}) {
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(ZONE, zone)
m.Push(kit.MDB_ZONE, zone)
m.Push("action", _task_action(m, value[STATUS], "插件"))
}
})
})

2
misc.go
View File

@ -63,7 +63,7 @@ func (m *Message) PushAction(list ...interface{}) {
for _, k := range kit.Simple(list...) {
action = append(action, m.Cmdx("render", "button", k))
}
m.Push("操作", strings.Join(action, ""))
m.Push("action", strings.Join(action, ""))
})
}
func (m *Message) PushDetail(value interface{}, arg ...interface{}) *Message {

4
misc/wx/wx.shy
View File

@ -10,8 +10,10 @@ image qrcode `https://weixin.qq.com`
chapter "应用"
field "task" web.team.task args `[ ]`
field "plan" web.team.plan args `[ ]`
field "task" web.team.task args `[ ]`
field "asset" web.mall.asset args `[ ]`
chapter "项目"
section "icebergs"