From b136b9b09ed3a953fd593cdbf47bd5efbb9825af Mon Sep 17 00:00:00 2001 From: shaoying Date: Sat, 5 Jan 2019 12:29:03 +0800 Subject: [PATCH] opt ctx Change-Id: Id4c930b9b338922a3f926d5166ad2e348277ff3c --- src/contexts/ctx/ctx.go | 634 +++++++++++++++++++++++++--------------- src/contexts/mdb/mdb.go | 134 +++++++++ src/contexts/web/web.go | 17 +- 3 files changed, 551 insertions(+), 234 deletions(-) diff --git a/src/contexts/ctx/ctx.go b/src/contexts/ctx/ctx.go index bf345d2b..db7ef447 100644 --- a/src/contexts/ctx/ctx.go +++ b/src/contexts/ctx/ctx.go @@ -1,39 +1,99 @@ package ctx import ( + "crypto/md5" + "encoding/hex" "encoding/json" - "errors" "fmt" "html/template" + "regexp" + "strconv" + "strings" + + "errors" "io" "math/rand" "os" - "regexp" "runtime/debug" "sort" - "strconv" - "strings" "time" ) -type LOGGER interface { - LOG(*Message, string, string) -} - -func Right(arg interface{}) bool { - switch str := arg.(type) { - case nil: - return false - case bool: - return str - case string: - switch str { - case "", "0", "false", "off", "no", "error: ": - return false +func Int(arg ...interface{}) int { + result := 0 + for _, v := range arg { + switch val := v.(type) { + case int: + result += val + case bool: + if val { + result += 1 + } + case string: + if i, e := strconv.Atoi(val); e == nil { + result += i + } + default: } - return true } - return false + return result +} +func Right(arg ...interface{}) bool { + result := false + for _, v := range arg { + switch val := v.(type) { + case int: + result = result || val != 0 + case bool: + result = result || val + case string: + switch val { + case "", "0", "false", "off", "no", "error: ": + result = result || false + break + } + result = result || true + case error: + result = result || false + default: + result = result || val != nil + } + } + return result +} +func Format(arg ...interface{}) string { + result := []string{} + for _, v := range arg { + switch val := v.(type) { + case nil: + result = result[:0] + case uint, uint8, uint16, uint32, uint64: + result = append(result, fmt.Sprintf("%d", val)) + case int, int8, int16, int32, int64: + result = append(result, fmt.Sprintf("%d", val)) + case bool: + result = append(result, fmt.Sprintf("%t", val)) + case string: + result = append(result, val) + case float64: + result = append(result, fmt.Sprintf("%d", int(val))) + case time.Time: + result = append(result, fmt.Sprintf("%d", val.Unix())) + default: + if b, e := json.Marshal(val); e == nil { + result = append(result, string(b)) + } + } + } + + if len(result) > 1 { + if n := strings.Count(result[0], "%") - strings.Count(result[0], "%%"); len(result) > n+1 { + return fmt.Sprintf(result[0], result[1:n+1]) + strings.Join(result[n+1:], "") + } else if len(result) == n+1 { + return fmt.Sprintf(result[0], result[1:]) + } + } + return strings.Join(result, "") } func Trans(arg ...interface{}) []string { ls := []string{} @@ -45,191 +105,231 @@ func Trans(arg ...interface{}) []string { } else { ls = append(ls, val.Meta["detail"]...) } - case string: - ls = append(ls, val) - case bool: - ls = append(ls, fmt.Sprintf("%t", val)) - case int, int8, int16, int32, int64: - ls = append(ls, fmt.Sprintf("%d", val)) - case float64: - ls = append(ls, fmt.Sprintf("%d", int(val))) - case []interface{}: + case []float64: for _, v := range val { - switch val := v.(type) { - case string: - ls = append(ls, val) - case bool: - ls = append(ls, fmt.Sprintf("%t", val)) - case int, int8, int16, int32, int64: - ls = append(ls, fmt.Sprintf("%d", val)) - } - } - case []string: - ls = append(ls, val...) - case []bool: - for _, v := range val { - ls = append(ls, fmt.Sprintf("%t", v)) + ls = append(ls, fmt.Sprintf("%d", int(v))) } case []int: for _, v := range val { ls = append(ls, fmt.Sprintf("%d", v)) } - case nil: + case []bool: + for _, v := range val { + ls = append(ls, fmt.Sprintf("%t", v)) + } + case []string: + ls = append(ls, val...) + case map[string]string: + for k, v := range val { + ls = append(ls, k, v) + } + case map[string]interface{}: + for k, v := range val { + ls = append(ls, k, Format(v)) + } + case []interface{}: + ls = append(ls, Format(val...)) default: - ls = append(ls, fmt.Sprintf("%v", val)) + ls = append(ls, Format(val)) } } return ls } -func Chain(m *Message, data interface{}, args ...interface{}) interface{} { - // if len(args) == 1 { - // if arg, ok := args[0].([]string); ok { - // args = args[:0] - // for _, v := range arg { - // args = append(args, v) - // } - // } - // } - // - root := data +func Chain(m *Message, root interface{}, args ...interface{}) interface{} { for i := 0; i < len(args); i += 2 { - var parent interface{} - parent_key, parent_index := "", 0 - data, root = root, nil - - keys := []string{} - switch arg := args[i].(type) { - case map[string]interface{}: - args = args[:0] + if arg, ok := args[i].(map[string]interface{}); ok { + argn := []interface{}{} for k, v := range arg { - args = append(args, k, v) + argn = append(argn, k, v) } - i = -2 + argn = append(argn, args[i+1:]) + args, i = argn, -2 continue - case []interface{}: - keys = []string{} - for _, v := range arg { - keys = append(keys, fmt.Sprintf("%v", v)) - } - case []string: - keys = arg - keys = strings.Split(strings.Join(arg, "."), ".") - case string: - keys = strings.Split(arg, ".") - case nil: - continue - default: - keys = append(keys, fmt.Sprintf("%v", arg)) } - for j, k := range keys { + var parent interface{} + parent_key, parent_index := "", 0 + + keys := []string{} + for _, v := range Trans(args[i]) { + keys = append(keys, strings.Split(v, ".")...) + } + + data := root + for j, key := range keys { + index, e := strconv.Atoi(key) + + var next interface{} switch value := data.(type) { case nil: + if j == len(keys)-1 { + next = args[i+1] + } + if i == len(args)-1 { return nil } - if _, e := strconv.Atoi(k); e == nil { - node := []interface{}{nil} - switch p := parent.(type) { - case map[string]interface{}: - p[parent_key] = node - case []interface{}: - p[parent_index] = node - } - if data, parent_index = node, 0; j == len(keys)-1 { - node[0] = args[i+1] - } + if e == nil { + data, index = []interface{}{next}, 0 } else { - node := map[string]interface{}{} - switch p := parent.(type) { - case map[string]interface{}: - p[parent_key] = node - case []interface{}: - p[parent_index] = node - } - if data, parent_key = node, k; j == len(keys)-1 { - node[k] = args[i+1] - } + data = map[string]interface{}{key: next} } - - parent, data = data, nil case []string: - if index, e := strconv.Atoi(k); e == nil { - index = (index+2+len(value)+2)%(len(value)+2) - 2 + index = (index+2+len(value)+2)%(len(value)+2) - 2 + + if j == len(keys)-1 { if i == len(args)-1 { if index < 0 { return "" } return value[index] } - switch index { - case -1: - return append([]string{args[i+1].(string)}, value...) - case -2: - return append(value, args[i+1].(string)) - default: - value[index] = args[i+1].(string) - } + next = args[i+1] } - case map[string]string: - if i == len(args)-1 { - return value[k] + if index == -1 { + data, index = append([]string{Format(next)}, value...), 0 + } else { + data, index = append(value, Format(next)), len(value) } - value[k] = args[i+1].(string) + next = value[index] + case map[string]string: + if j == len(keys)-1 { + if i == len(args)-1 { + return value[key] // 读取数据 + } + value[key] = Format(next) // 修改数据 + } + next = value[key] case map[string]interface{}: if j == len(keys)-1 { if i == len(args)-1 { - return value[k] + return value[key] // 读取数据 } - value[k] = args[i+1] + value[key] = args[i+1] // 修改数据 } - parent, data, parent_key = data, value[k], k + next = value[key] case []interface{}: - index, e := strconv.Atoi(k) - if e != nil { - return nil - } index = (index+2+len(value)+2)%(len(value)+2) - 2 - if i == len(args)-1 { - if index < 0 { - return nil - } - if j == len(keys)-1 { - return value[index] - } - } else { - if index == -1 { - value = append([]interface{}{nil}, value...) - index = 0 - } else if index == -2 { - value = append(value, nil) - index = len(value) - 1 + if j == len(keys)-1 { + if i == len(args)-1 { + if index < 0 { + return nil + } + return value[index] // 读取数据 } + next = args[i+1] // 修改数据 + } - if j == len(keys)-1 { - value[index] = args[i+1] - } + if index == -1 { + data, index = append([]interface{}{next}, value...), 0 + } else if index == -2 { + data, index = append(value, next), len(value) + } else if j == len(keys)-1 { + value[index] = next } - switch p := parent.(type) { - case map[string]interface{}: - p[parent_key] = value - case []interface{}: - p[parent_index] = value - } - parent, data, parent_index = value, value[index], index + next = value[index] } - if root == nil { - root = parent + switch p := parent.(type) { + case map[string]interface{}: + p[parent_key] = data + case []interface{}: + p[parent_index] = data + case nil: + root = data } + + parent, data = data, next + parent_key, parent_index = key, index } } return root } + +func Action(cmd string, arg ...interface{}) string { + switch cmd { + case "time": + return Format(time.Now()) + case "rand": + return Format(rand.Int()) + case "uniq": + return Format(time.Now(), rand.Int()) + default: + if len(arg) > 0 { + return Format(arg...) + } + } + return cmd +} +func Hash(arg ...interface{}) (string, []string) { + meta := Trans(arg...) + for i, v := range meta { + meta[i] = Action(v) + } + + h := md5.Sum([]byte(strings.Join(meta, ""))) + return hex.EncodeToString(h[:]), meta +} + +func Array(list []string, index int, arg ...interface{}) []string { + if len(arg) == 0 { + if -1 < index && index < len(list) { + return []string{list[index]} + } + return []string{""} + } + + str := Trans(arg...) + + index = (index+2)%(len(list)+2) - 2 + if index == -1 { + list = append(str, list...) + } else if index == -2 { + list = append(list, str...) + } else { + if index < -2 { + index += len(list) + 2 + } + if index < 0 { + index = 0 + } + + for i := len(list); i < index+len(str); i++ { + list = append(list, "") + } + for i := 0; i < len(str); i++ { + list[index+i] = str[i] + } + } + + return list +} +func Slice(arg []string, args ...interface{}) ([]string, string) { + if len(arg) == 0 { + return arg, "" + } + if len(args) == 0 { + return arg[1:], arg[0] + } + + result := "" + switch v := args[0].(type) { + case int: + case string: + if arg[0] == v && len(arg) > 1 { + return arg[2:], arg[1] + } + if len(args) > 1 { + return arg, Format(args[1]) + } + } + + return arg, result +} func Elect(last interface{}, args ...interface{}) string { if len(args) > 0 { switch arg := args[0].(type) { @@ -264,39 +364,8 @@ func Elect(last interface{}, args ...interface{}) string { return "" } -func Array(m *Message, list []string, index int, arg ...interface{}) []string { - if len(arg) == 0 { - if -1 < index && index < len(list) { - return []string{list[index]} - } - return []string{""} - } - - index = (index+2)%(len(list)+2) - 2 - - str := Trans(arg...) - - if index == -1 { - index, list = 0, append(str, list...) - } else if index == -2 { - index, list = len(list), append(list, str...) - } else { - if index < -2 { - index += len(list) + 2 - } - if index < 0 { - index = 0 - } - - for i := len(list); i < index+len(str); i++ { - list = append(list, "") - } - for i := 0; i < len(str); i++ { - list[index+i] = str[i] - } - } - - return list +type LOGGER interface { + LOG(*Message, string, string) } type Cache struct { @@ -540,13 +609,22 @@ func (m *Message) Code() int { return m.code } func (m *Message) Time(arg ...interface{}) string { + t := m.time + + if len(arg) > 0 { + if d, e := time.ParseDuration(arg[0].(string)); e == nil { + arg = arg[1:] + t.Add(d) + } + } + str := m.Conf("time_format") if len(arg) > 1 { str = fmt.Sprintf(arg[0].(string), arg[1:]...) } else if len(arg) > 0 { str = fmt.Sprintf("%v", arg[0]) } - return m.time.Format(str) + return t.Format(str) } func (m *Message) Message() *Message { return m.message @@ -1368,7 +1446,15 @@ func (m *Message) Options(key string, arg ...interface{}) bool { } func (m *Message) Optionv(key string, arg ...interface{}) interface{} { if len(arg) > 0 { - m.Put("option", key, arg[0]) + switch arg[0].(type) { + case nil: + // case []string: + // m.Option(key, v...) + // case string: + // m.Option(key, v) + default: + m.Put("option", key, arg[0]) + } } for msg := m; msg != nil; msg = msg.message { @@ -1420,7 +1506,7 @@ func (m *Message) Appendi(key string, arg ...interface{}) int { return i } func (m *Message) Appends(key string, arg ...interface{}) bool { - return len(m.Meta["append"]) > 0 && Right(m.Append(key, arg...)) + return Right(m.Append(key, arg...)) } func (m *Message) Appendv(key string, arg ...interface{}) interface{} { if len(arg) > 0 { @@ -1553,6 +1639,17 @@ func (m *Message) Cmd(args ...interface{}) *Message { if args := []string{}; x.Form != nil { for i := 0; i < len(arg); i++ { n, ok := x.Form[arg[i]] + if n == -1 { + j := i + 1 + for ; j < len(arg); j++ { + if _, ok := x.Form[arg[j]]; ok { + break + } + m.Add("option", arg[i], arg[j]) + } + i = j - 1 + continue + } if !ok { args = append(args, arg[i]) continue @@ -2462,7 +2559,7 @@ var Index = &Context{Name: "ctx", Help: "模块中心", "table_row_sep": &Config{Name: "table_row_sep", Value: "\n", Help: "命令列表帮助"}, "page_offset": &Config{Name: "page_offset", Value: "0", Help: "列表偏移"}, - "page_limit": &Config{Name: "page_limit", Value: "100", Help: "列表大小"}, + "page_limit": &Config{Name: "page_limit", Value: "10", Help: "列表大小"}, "time_format": &Config{Name: "time_format", Value: "2006-01-02 15:04:05", Help: "时间格式"}, }, @@ -2553,7 +2650,15 @@ var Index = &Context{Name: "ctx", Help: "模块中心", continue } if len(arg) > 1 && k == arg[1] { - m.Echo("%s: %s\n%s\n", k, v.Name, v.Help) + switch help := v.Help.(type) { + case []string: + m.Echo("%s: %s\n", k, v.Name) + for _, v := range help { + m.Echo(" %s\n", v) + } + case string: + m.Echo("%s: %s\n%s\n", k, v.Name, v.Help) + } for k, v := range v.Form { m.Echo(" option: %s(%d)\n", k, v) } @@ -2722,13 +2827,13 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } if len(arg) > 1 { - msg.Meta[k] = Array(m, msg.Meta[k], index, arg[1:]) + msg.Meta[k] = Array(msg.Meta[k], index, arg[1:]) m.Echo("%v", msg.Meta[k]) return } if index != -100 { - m.Echo(Array(m, msg.Meta[k], index)[0]) + m.Echo(Array(msg.Meta[k], index)[0]) return } @@ -2794,13 +2899,13 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } if len(arg) > 1 { - msg.Meta[k] = Array(m, msg.Meta[k], index, arg[1:]) + msg.Meta[k] = Array(msg.Meta[k], index, arg[1:]) m.Echo("%v", msg.Meta[k]) return } if index != -100 { - m.Echo(Array(m, msg.Meta[k], index)[0]) + m.Echo(Array(msg.Meta[k], index)[0]) return } @@ -3293,10 +3398,55 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } }}, - "trans": &Command{Name: "trans key [index]", Help: "数据转换", Hand: func(m *Message, c *Context, key string, arg ...string) { - value := m.Optionv(arg[0]) - if len(arg) > 1 && arg[1] != "" { - value = Chain(m, value, arg[1]) + "trans": &Command{Name: "trans option [type|data|json] limit 10 [index...]", Help: "数据转换", Hand: func(m *Message, c *Context, key string, arg ...string) { + value, arg := m.Optionv(arg[0]), arg[1:] + + view := "data" + if len(arg) > 0 { + switch arg[0] { + case "type", "data", "json": + view, arg = arg[0], arg[1:] + } + } + + limit := m.Confi("page_limit") + if len(arg) > 0 && arg[0] == "limit" { + limit, arg = Int(arg[1]), arg[2:] + } + + chain := strings.Join(arg, ".") + if chain != "" { + value = Chain(m, value, chain) + } + + switch view { + case "type": // 查看数据类型 + switch value := value.(type) { + case map[string]interface{}: + for k, v := range value { + m.Add("append", "key", k) + m.Add("append", "type", fmt.Sprintf("%T", v)) + } + m.Sort("key", "str").Table() + case []interface{}: + for k, v := range value { + m.Add("append", "key", k) + m.Add("append", "type", fmt.Sprintf("%T", v)) + } + m.Sort("key", "int").Table() + case nil: + default: + m.Add("append", "key", chain) + m.Add("append", "type", fmt.Sprintf("%T", value)) + m.Sort("key", "str").Table() + } + return + case "data": + case "json": // 查看文本数据 + b, e := json.MarshalIndent(value, "", " ") + m.Assert(e) + m.Echo(string(b)) + return } switch val := value.(type) { @@ -3323,33 +3473,58 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } m.Sort("key", "str").Table() case []interface{}: + fields := map[string]int{} for i, v := range val { + if i >= limit { + break + } switch val := v.(type) { case map[string]interface{}: - for k, v := range val { - switch value := v.(type) { - case string: - m.Add("append", k, value) - case float64: - m.Add("append", k, fmt.Sprintf("%d", int(value))) - default: - b, _ := json.Marshal(value) - m.Add("append", k, fmt.Sprintf("%v", string(b))) + for k, _ := range val { + fields[k]++ + } + } + } + + if len(fields) > 0 { + for i, v := range val { + if i >= limit { + break + } + switch val := v.(type) { + case map[string]interface{}: + for k, _ := range fields { + switch value := val[k].(type) { + case nil: + m.Add("append", k, "") + case string: + m.Add("append", k, value) + case float64: + m.Add("append", k, fmt.Sprintf("%d", int(value))) + default: + b, _ := json.Marshal(value) + m.Add("append", k, fmt.Sprintf("%v", string(b))) + } } } - case string: - m.Add("append", "index", i) - m.Add("append", "value", val) - case float64: - m.Add("append", "index", i) - m.Add("append", "value", fmt.Sprintf("%v", int(val))) - case nil: - m.Add("append", "index", i) - m.Add("append", "value", "") - default: - m.Add("append", "index", i) - b, _ := json.Marshal(val) - m.Add("append", "value", fmt.Sprintf("%v", string(b))) + } + } else { + for i, v := range val { + switch val := v.(type) { + case nil: + m.Add("append", "index", i) + m.Add("append", "value", "") + case string: + m.Add("append", "index", i) + m.Add("append", "value", val) + case float64: + m.Add("append", "index", i) + m.Add("append", "value", fmt.Sprintf("%v", int(val))) + default: + m.Add("append", "index", i) + b, _ := json.Marshal(val) + m.Add("append", "value", fmt.Sprintf("%v", string(b))) + } } } m.Table() @@ -3370,10 +3545,9 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } }}, "select": &Command{Name: "select key value field", - Form: map[string]int{"parse": 2, "group": 1, "order": 2, "limit": 1, "offset": 1, "fields": 1, "format": 2, "trans_map": 3, "vertical": 0, "hide": 1}, + Form: map[string]int{"parse": 2, "hide": 1, "fields": -1, "group": 1, "order": 2, "limit": 1, "offset": 1, "format": -1, "trans_map": -1, "vertical": 0}, Help: "选取数据", Hand: func(m *Message, c *Context, key string, arg ...string) { - msg := m.Spawn() - m.Set("result") + msg := m.Set("result").Spawn() // 解析 if len(m.Meta["append"]) == 0 { @@ -3436,7 +3610,7 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } } - // 筛选 + // 隐藏列 hides := map[string]bool{} for _, k := range m.Meta["hide"] { hides[k] = true @@ -3452,6 +3626,13 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } } + // 选择列 + if m.Option("fields") != "" { + msg = m.Spawn() + msg.Copy(m, "append", strings.Split(strings.Join(m.Meta["fields"], " "), " ")...) + m.Set("append").Copy(msg, "append") + } + // 聚合 if m.Set("append"); m.Has("group") { group := m.Option("group") @@ -3540,13 +3721,6 @@ var Index = &Context{Name: "ctx", Help: "模块中心", } } - // 选择列 - if m.Option("fields") != "" { - msg = m.Spawn() - msg.Copy(m, "append", strings.Split(m.Option("fields"), " ")...) - m.Set("append").Copy(msg, "append") - } - // 格式化 for i := 0; i < len(m.Meta["format"])-1; i += 2 { format := m.Meta["format"] diff --git a/src/contexts/mdb/mdb.go b/src/contexts/mdb/mdb.go index 9769e3e7..2d6e8c94 100644 --- a/src/contexts/mdb/mdb.go +++ b/src/contexts/mdb/mdb.go @@ -73,8 +73,142 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心", "csv_col_sep": &ctx.Config{Name: "字段分隔符", Value: "\t", Help: "字段分隔符"}, "csv_row_sep": &ctx.Config{Name: "记录分隔符", Value: "\n", Help: "记录分隔符"}, + + "temp": &ctx.Config{Name: "temp", Value: map[string]interface{}{}, Help: "缓存数据"}, + "temp_view": &ctx.Config{Name: "temp_view", Value: map[string]interface{}{}, Help: "缓存数据"}, }, Commands: map[string]*ctx.Command{ + "temp": &ctx.Command{Name: "temp [type [meta [data]]] [tid [node|ship|data] [chain... [select ...]]]", Form: map[string]int{"select": -1}, Help: "缓存数据", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) { + if len(arg) > 2 { // 添加数据 + if temp := m.Confm("temp", arg[0]); temp == nil { + h := m.Cmdx("aaa.hash", arg[0], arg[1]) + m.Confv("temp", h, map[string]interface{}{ + "create_time": m.Time(), "expire_time": m.Time("60s"), + "type": arg[0], "meta": arg[1], "data": m.Optionv(arg[2]), + }) + arg[2], arg = h, arg[2:] + } + } + + if len(arg) > 1 { + if temp, msg := m.Confm("temp", arg[0]), m; temp != nil { + hash, arg := arg[0], arg[1:] + switch arg[0] { + case "node": // 查看节点 + m.Put("option", "temp", temp).Cmdy("ctx.trans", "temp") + return + case "ship": //查看链接 + for k, v := range temp { + val := v.(map[string]interface{}) + m.Add("append", "key", k) + m.Add("append", "create_time", val["create_time"]) + m.Add("append", "type", val["type"]) + m.Add("append", "meta", val["meta"]) + } + m.Sort("create_time", "time_r").Table() + return + case "data": // 查看数据 + arg = arg[1:] + } + + trans := strings.Join(append([]string{hash, "data"}, arg...), ".") + h := m.Cmdx("aaa.hash", "trans", trans) + + if len(arg) == 0 || temp["type"].(string) == "trans" { + h = hash + } else { // 转换数据 + if view := m.Confm("temp", h); view != nil && false { // 加载缓存 + msg = m.Spawn() + switch data := view["data"].(type) { + case map[string][]string: + msg.Meta = data + case map[string]interface{}: + for k, v := range data { + switch val := v.(type) { + case []interface{}: + msg.Add("append", k, val) + } + } + m.Confv("temp", []string{h, "data"}, msg.Meta) + } + temp = view + } else { // 添加缓存 + msg = m.Put("option", "temp", temp["data"]).Cmd("ctx.trans", "temp", arg) + + m.Confv("temp", h, map[string]interface{}{ + "create_time": m.Time(), "expire_time": m.Time("60s"), + "type": "trans", "meta": trans, "data": msg.Meta, + "ship": map[string]interface{}{ + hash: map[string]interface{}{"create_time": m.Time(), "ship": "0", "type": temp["type"], "meta": temp["meta"]}, + }, + }) + m.Confv("temp", []string{hash, "ship", h}, map[string]interface{}{ + "create_time": m.Time(), "ship": "1", "type": "trans", "meta": trans, + }) + temp = m.Confm("temp", h) + } + } + + if m.Options("select") { // 过滤数据 + chain := strings.Join(m.Optionv("select").([]string), " ") + hh := m.Cmdx("aaa.hash", "select", chain, h) + + if view := m.Confm("temp", hh); view != nil { // 加载缓存 + msg = msg.Spawn() + switch data := view["data"].(type) { + case map[string][]string: + msg.Meta = data + case map[string]interface{}: + for k, v := range data { + switch val := v.(type) { + case []interface{}: + msg.Add("append", k, val) + } + } + m.Confv("temp", []string{h, "data"}, msg.Meta) + } + } else { // 添加缓存 + msg = msg.Spawn().Copy(msg, "append").Cmd("select", m.Optionv("select")) + + m.Confv("temp", hh, map[string]interface{}{ + "create_time": m.Time(), "expire_time": m.Time("60s"), + "type": "select", "meta": chain, "data": msg.Meta, + "ship": map[string]interface{}{ + h: map[string]interface{}{"create_time": m.Time(), "ship": "0", "type": temp["type"], "meta": temp["meta"]}, + }, + }) + + m.Confv("temp", []string{h, "ship", hh}, map[string]interface{}{ + "create_time": m.Time(), "ship": "1", "type": "select", "meta": chain, + }) + } + } + + msg.CopyTo(m) + return + } + } + + arg, h := ctx.Slice(arg) + if h != "" { + if temp := m.Confm("temp", h); temp != nil { + m.Echo(h) + return + } + } + + // 缓存列表 + m.Confm("temp", func(key string, temp map[string]interface{}) { + if len(arg) == 0 || strings.HasPrefix(key, arg[0]) || strings.HasSuffix(key, arg[0]) || (temp["type"].(string) == arg[0] && (len(arg) == 1 || strings.Contains(temp["meta"].(string), arg[1]))) { + m.Add("append", "key", key) + m.Add("append", "create_time", temp["create_time"]) + m.Add("append", "type", temp["type"]) + m.Add("append", "meta", temp["meta"]) + } + }) + m.Sort("create_time", "time_r").Table().Cmd("select", m.Optionv("select")) + }}, + "open": &ctx.Command{Name: "open [database [username [password [address [protocol [driver]]]]]]", Help: "open打开数据库, database: 数据库名, username: 用户名, password: 密码, address: 服务地址, protocol: 服务协议, driver: 数据库类型", Form: map[string]int{"dbname": 1, "dbhelp": 1}, diff --git a/src/contexts/web/web.go b/src/contexts/web/web.go index 1330dc60..e64e3f71 100644 --- a/src/contexts/web/web.go +++ b/src/contexts/web/web.go @@ -568,10 +568,6 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心", } var result interface{} - defer func() { - m.Target().Configs[m.Confx("body_response")] = &ctx.Config{Value: result} - m.Log("info", "cache %s", m.Confx("body_response")) - }() if m.Has("save") { p := m.Option("save") @@ -594,6 +590,8 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心", switch { case strings.HasPrefix(ct, "application/json"): json.NewDecoder(res.Body).Decode(&result) + m.Put("option", "data", result).Cmd("mdb.temp", "url", req.URL.String(), "data") + if m.Has("parse") { msg := m.Spawn().Put("option", "data", result).Cmd("trans", "data", m.Option("parse")) m.Copy(msg, "append").Copy(msg, "result") @@ -1106,11 +1104,18 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心", // 会话检查 if m.Options("right", !m.Confs("login_right") || !m.Confs("componet", "login")) { + m.Log("info", "no limit") // 禁用权限 } else if username := m.Option("username", m.Cmd("web.session").Append("username")); username == "" { // 用户登录 + m.Log("info", "no user") group, order = m.Option("componet_group", "login"), m.Option("componet_name", "") m.Option("right", "true") + if m.Options("bench") && !m.Cmds("aaa.work", m.Option("bench")) { + m.Append("redirect", merge(m, m.Option("index_url"), "bench", "")) + return + } } else if group == "login" { // 登录成功 + m.Log("info", "no login") return } else if !m.Options("bench") || !m.Cmds("aaa.work", m.Option("bench")) { // 创建空间 m.Append("redirect", merge(m, m.Option("index_url"), "bench", m.Cmdx("aaa.work", m.Option("sessid"), "create", "web"))) @@ -1197,14 +1202,18 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心", "action_time": msg.Time(), "order": m.Option("componet_name_order"), "cmd": args, }).Cmd("aaa.auth", m.Option("bench"), "data", "option", name_alias, "modify_time", msg.Time()) } + m.Log("what", "------%vv", msg.Append("directory")) } } else { msg = m } + m.Log("what", "------%vv", msg.Append("directory")) // 添加响应 if msg.Appends("directory") { + m.Log("what", "------%vv", msg.Append("directory")) m.Append("download_file", fmt.Sprintf("/download/%s", msg.Append("directory"))) + m.Log("what", "------%vv", msg.Append("directory")) return } else if accept_json { list = append(list, msg.Meta)