diff --git a/widgets/action/action.go b/widgets/action/action.go index 5878a6ba..86205344 100644 --- a/widgets/action/action.go +++ b/widgets/action/action.go @@ -1,148 +1,16 @@ package action -import ( - "fmt" - - "github.com/yaoapp/gou" - "github.com/yaoapp/kun/any" - "github.com/yaoapp/kun/exception" - "github.com/yaoapp/yao/widgets/hook" -) - -// Bind the process name -func (p *Process) Bind(name string) { - p.ProcessBind = name -} - // NewProcess create a new process -func NewProcess(name string, p *Process) *Process { +func NewProcess() *Process { + return &Process{ + Default: []interface{}{}, + } +} + +// ProcessOf create of get a process +func ProcessOf(p *Process) *Process { if p == nil { - p = &Process{} + p = NewProcess() } - p.Name = name return p } - -// SetHandler set the handler -func (p *Process) SetHandler(handler Handler) *Process { - p.Handler = handler - return p -} - -// SetDefault set the default value -func (p *Process) SetDefault(defaults map[string]*Process) *Process { - - if defaultProcess, has := defaults[p.Name]; has { - - p.Name = defaultProcess.Name - - if p.Process == "" { - p.Process = defaultProcess.Process - } - - if p.Guard == "" { - p.Guard = defaultProcess.Guard - } - - if p.Default == nil { - p.Default = defaultProcess.Default - } - - // format defaults - if len(p.Default) != len(defaultProcess.Default) { - defauts := defaultProcess.Default - nums := len(p.Default) - if nums > len(defaultProcess.Default) { - nums = len(defaultProcess.Default) - } - for i := 0; i < nums; i++ { - defauts[i] = p.Default[i] - } - p.Default = defauts - } - } - - return p -} - -// WithBefore bind before hook -func (p *Process) WithBefore(before *hook.Before) *Process { - p.Before = before - return p -} - -// WithAfter bind after hook -func (p *Process) WithAfter(after *hook.After) *Process { - p.After = after - return p -} - -// Args get the process args -func (p *Process) Args(process *gou.Process) []interface{} { - process.ValidateArgNums(1) - args := p.Default - nums := len(process.Args[1:]) - if nums > len(args) { - nums = len(args) - } - - for i := 0; i < nums; i++ { - args[i] = p.deepMergeDefault(process.Args[i+1], args[i]) - } - return args -} - -// Exec exec the process -func (p *Process) Exec(process *gou.Process) (interface{}, error) { - if p.Handler == nil { - return nil, fmt.Errorf("%s handler does not set", p.Name) - } - return p.Handler(p, process) -} - -// MustExec exec the process -func (p *Process) MustExec(process *gou.Process) interface{} { - res, err := p.Exec(process) - if err != nil { - exception.New(err.Error(), 500).Throw() - } - return res -} - -// deepMergeDefault deep merge args -func (p *Process) deepMergeDefault(value interface{}, defaults interface{}) interface{} { - - if value == nil { - return defaults - } - - switch defaults.(type) { - - case map[string]interface{}: - defaultMap := defaults.(map[string]interface{}) - valueMap := any.Of(value).MapStr() - for key, v := range defaultMap { - valueMap[key] = p.deepMergeDefault(valueMap[key], v) - } - return valueMap - - case []interface{}: - defaultArr := defaults.([]interface{}) - valueArr := any.Of(value).CArray() - - // pad - nums := len(defaultArr) - len(valueArr) - for i := 0; i < nums; i++ { - valueArr = append(valueArr, nil) - } - - // set default - for idx, v := range defaultArr { - valueArr[idx] = p.deepMergeDefault(valueArr[idx], v) - } - - return valueArr - } - - return value -} diff --git a/widgets/action/action_test.go b/widgets/action/action_test.go new file mode 100644 index 00000000..21dcfccd --- /dev/null +++ b/widgets/action/action_test.go @@ -0,0 +1,85 @@ +package action + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/yaoapp/gou" +) + +func TestNewProcess(t *testing.T) { + defaults := testDefaults() + test := NewProcess(). + Merge(defaults["yao.unit.Test1"]). + SetHandler(testHandler) + + assert.Equal(t, "yao.unit.Test1", test.Name) + assert.Equal(t, "bearer-jwt", test.Guard) + assert.Equal(t, "yao.unit.T1", test.Process) + assert.Equal(t, []interface{}{nil, nil, nil}, test.Default) +} + +func TestProcessOf(t *testing.T) { + defaults := testDefaults() + test := NewProcess() + new := ProcessOf(test).Merge(defaults["yao.unit.Test2"]).SetHandler(testHandler) + assert.Equal(t, "yao.unit.Test2", new.Name) + assert.Equal(t, "bearer-jwt", new.Guard) + assert.Equal(t, "yao.unit.T2", new.Process) + assert.Equal(t, []interface{}{nil, nil}, new.Default) + + new = ProcessOf(nil).Merge(defaults["yao.unit.Test3"]).SetHandler(testHandler) + assert.Equal(t, "yao.unit.Test3", new.Name) + assert.Equal(t, "bearer-jwt", new.Guard) + assert.Equal(t, "yao.unit.T3", new.Process) + assert.Equal(t, []interface{}{nil}, new.Default) +} + +func testData() map[string]*Process { + defaults := testDefaults() + return map[string]*Process{ + "T0": NewProcess().Merge(defaults["yao.unit.Test1"]).SetHandler(testHandler), + "T1": NewProcess().Merge(defaults["yao.unit.Test2"]).SetHandler(testHandler), + "T2": NewProcess().Merge(defaults["yao.unit.Test3"]).SetHandler(testHandler), + "T3": NewProcess().Merge(defaults["yao.unit.Test4"]).SetHandler(testHandler), + "T4": NewProcess().Merge(defaults["yao.unit.Test5"]).SetHandler(testHandler), + } +} + +func testHandler(p *Process, process *gou.Process) (interface{}, error) { + args := p.Args(process) + return args, nil +} + +func testDefaults() map[string]*Process { + return map[string]*Process{ + + "yao.unit.Test1": { + Name: "yao.unit.Test1", + Guard: "bearer-jwt", + Process: "yao.unit.T1", + Default: []interface{}{nil, nil, nil}, + }, + + "yao.unit.Test2": { + Name: "yao.unit.Test2", + Guard: "bearer-jwt", + Process: "yao.unit.T2", + Default: []interface{}{nil, nil}, + }, + + "yao.unit.Test3": { + Name: "yao.unit.Test3", + Guard: "bearer-jwt", + Process: "yao.unit.T3", + Default: []interface{}{nil}, + }, + + "yao.unit.Test4": { + Name: "yao.unit.Test4", + Guard: "bearer-jwt", + Process: "yao.unit.T4", + Default: []interface{}{}, + }, + } +} diff --git a/widgets/action/process.go b/widgets/action/process.go new file mode 100644 index 00000000..888bb447 --- /dev/null +++ b/widgets/action/process.go @@ -0,0 +1,278 @@ +package action + +import ( + "fmt" + "strings" + + "github.com/yaoapp/gou" + "github.com/yaoapp/gou/session" + "github.com/yaoapp/kun/any" + "github.com/yaoapp/kun/exception" + "github.com/yaoapp/kun/log" + "github.com/yaoapp/yao/widgets/hook" +) + +// Bind the process name +func (p *Process) Bind(processName string) { + p.ProcessBind = processName +} + +// SetName set the process name +func (p *Process) SetName(name string) { + p.Name = name +} + +// SetHandler set the handler +func (p *Process) SetHandler(handler Handler) *Process { + p.Handler = handler + return p +} + +// Merge a process +func (p *Process) Merge(newProcess *Process) *Process { + + if newProcess == nil { + return p + } + + if newProcess.Name != "" { + p.Name = newProcess.Name + } + + if p.Process == "" { + p.Process = newProcess.Process + } + + if p.Guard == "" { + p.Guard = newProcess.Guard + } + + p.DefaultMerge(newProcess.Default) + return p +} + +// DefaultMerge merge the default value. +// option[0] the default is false, if true overwrite by the default value; +// option[1] the default is true, if true deep merge map and slice; +func (p *Process) DefaultMerge(defaults []interface{}, option ...bool) { + + overwrite := false + if len(option) > 0 && option[0] { + overwrite = true + } + + deep := true + if len(option) > 1 && !option[1] { + deep = false + } + + if defaults == nil { + return + } + + if p.Default == nil { + p.Default = []interface{}{} + } + + length := len(p.Default) + for idx, value := range defaults { + if idx >= length { + p.Default = append(p.Default, value) + continue + } + if value != nil { + p.Default[idx] = p.mergeDefaultValue("", p.Default[idx], value, overwrite, deep) + } + } +} + +// WithBefore bind before hook +func (p *Process) WithBefore(before *hook.Before) *Process { + p.Before = before + return p +} + +// WithAfter bind after hook +func (p *Process) WithAfter(after *hook.After) *Process { + p.After = after + return p +} + +// Args get the process args +func (p *Process) Args(process *gou.Process) []interface{} { + process.ValidateArgNums(1) + args := []interface{}{} + args = append(args, p.Default...) + nums := len(process.Args[1:]) + if nums > len(args) { + nums = len(args) + } + + for i := 0; i < nums; i++ { + input := process.Args[i+1] + defaultValue := args[i] + args[i] = p.mergeDefaultValue(process.Sid, input, defaultValue, false, true) + // fmt.Printf("-Args--\n%#v\n===\n%#v\n-END Args--\n\n", input, args[i]) + } + return args +} + +// Exec exec the process +func (p *Process) Exec(process *gou.Process) (interface{}, error) { + if p.Handler == nil { + return nil, fmt.Errorf("%s handler does not set", p.Name) + } + return p.Handler(p, process) +} + +// MustExec exec the process +func (p *Process) MustExec(process *gou.Process) interface{} { + res, err := p.Exec(process) + if err != nil { + exception.New(err.Error(), 500).Throw() + } + return res +} + +// deepMergeDefault deep merge args +func (p *Process) mergeDefaultValue(sid string, value interface{}, defaultValue interface{}, overwrite bool, deep bool) interface{} { + + switch defaultValue.(type) { + + case map[string]interface{}: + return p.mergeDefaultMap(sid, value, defaultValue.(map[string]interface{}), overwrite, deep) + + case []interface{}: + return p.mergeDefaultSlice(sid, value, defaultValue.([]interface{}), overwrite, deep) + + case string: + return p.mergeDefaultString(sid, value, defaultValue.(string), overwrite) + } + + if value == nil || overwrite { + return defaultValue + } + + if vstr, ok := value.(string); ok && vstr == "" { + return defaultValue + } else if vint, ok := value.(int); ok && vint == 0 { + return defaultValue + } + + return value +} + +func (p *Process) mergeDefaultMap(sid string, value interface{}, defaultValues map[string]interface{}, overwrite bool, deep bool) interface{} { + if value == nil { + value = map[string]interface{}{} + // return defaultValues + } + + vmap := map[string]interface{}(any.Of(value).Map().MapStrAny) + // fmt.Printf("-vmap--\n%#v\n-end vmap--\n\n", vmap) + + for k, v := range defaultValues { + // fmt.Printf("-vmap k:v--\n%#v:%#v\n-end vmap k:v--\n\n", k, v) + + if _, has := vmap[k]; !has || overwrite || deep { + if deep { + vmap[k] = p.mergeDefaultValue(sid, vmap[k], v, overwrite, deep) + continue + } + vmap[k] = v + } + } + + // delete keys + if overwrite && !deep { + for k := range vmap { + if _, has := defaultValues[k]; !has { + delete(vmap, k) + } + } + } + + return vmap +} + +func (p *Process) mergeDefaultSlice(sid string, value interface{}, defaultValues []interface{}, overwrite bool, deep bool) interface{} { + if value == nil { + value = []interface{}{} + // return defaultValues + } + + varr := any.Of(value).CArray() + // fmt.Printf("-varr--\n%#v\n-end varr--\n\n", defaultValues) + + length := len(varr) + for i, v := range defaultValues { + if i >= length { + if deep { + varr = append(varr, p.mergeDefaultValue(sid, nil, v, overwrite, deep)) + // fmt.Printf("-varr-deep --\n%#v\n-end varr--\n\n", varr) + continue + } + + varr = append(varr, v) + continue + } + + if overwrite { + if deep { + varr[i] = p.mergeDefaultValue(sid, varr[i], v, overwrite, deep) + } else { + varr[i] = v + } + } + } + + // delete keys + if overwrite && !deep && length > len(defaultValues) { + varr = varr[:len(defaultValues)] + } + + return varr +} + +func (p *Process) mergeDefaultString(sid string, value interface{}, defaultValue string, overwrite bool) interface{} { + + if value == nil || overwrite { + value = defaultValue + } + + if valueStr, ok := value.(string); ok && sid != "" { + + if valueStr == "" { + return defaultValue + } + + // Session $.user.id $.user_id + v := strings.TrimSpace(valueStr) + if strings.HasPrefix(v, "$.") { + name := strings.TrimLeft(v, "$.") + namer := strings.Split(name, ".") + + val, err := session.Global().ID(sid).Get(namer[0]) + + if err != nil { + exception.New("Get %s %s", 500, v, err.Error()).Throw() + return nil + } + + // $.user_id + if len(namer) == 1 { + log.Trace("[Session] %s %v", v, val) + return val + } + + // $.user.id + mapping := any.Of(val).MapStr().Dot() + val = mapping.Get(strings.Join(namer[1:], ".")) + log.Trace("[Session] %s %v", v, val) + return val + } + + } + + return value +} diff --git a/widgets/action/process_test.go b/widgets/action/process_test.go new file mode 100644 index 00000000..cdac861e --- /dev/null +++ b/widgets/action/process_test.go @@ -0,0 +1,189 @@ +package action + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBind(t *testing.T) { + tests := testData() + tests["T0"].Bind("yao.unit.T0") + assert.Equal(t, "yao.unit.T0", tests["T0"].ProcessBind) +} + +func TestDefaultMerge(t *testing.T) { + tests := testData() + D := testProcessDefaults() + T0 := tests["T0"] + + T0.DefaultMerge(nil) + assert.Equal(t, []interface{}{nil, nil, nil}, T0.Default) + + T0.DefaultMerge([]interface{}{D["string"]}) + assert.Equal(t, []interface{}{"hello", nil, nil}, T0.Default) + + T0.DefaultMerge([]interface{}{nil, D["float"]}) + assert.Equal(t, []interface{}{"hello", 0.618, nil}, T0.Default) + + T0.DefaultMerge([]interface{}{nil, nil, D["int"]}) + assert.Equal(t, []interface{}{"hello", 0.618, 49}, T0.Default) + + T0.DefaultMerge([]interface{}{nil, nil, nil, D["int"]}) + assert.Equal(t, []interface{}{"hello", 0.618, 49, 49}, T0.Default) + + T0.DefaultMerge([]interface{}{nil, D["string"], nil}) + assert.Equal(t, []interface{}{"hello", 0.618, 49, 49}, T0.Default) + + T0.DefaultMerge([]interface{}{nil, D["string"], nil}, true) + assert.Equal(t, []interface{}{"hello", "hello", 49, 49}, T0.Default) + + // T1 + T1 := tests["T1"] + T1.DefaultMerge(nil) + assert.Equal(t, []interface{}{nil, nil}, T1.Default) + + T1.DefaultMerge([]interface{}{D["map"], D["slice"]}) + assert.Equal(t, 1.38065, T1.Default[0].(map[string]interface{})["float"]) + assert.Equal(t, 64, T1.Default[0].(map[string]interface{})["int"]) + assert.Equal(t, "foo", T1.Default[0].(map[string]interface{})["string"]) + assert.Equal(t, "world", T1.Default[1].([]interface{})[0]) + assert.Equal(t, 9.10939, T1.Default[1].([]interface{})[1]) + assert.Equal(t, 81, T1.Default[1].([]interface{})[2]) + + // overwrite false, deep true + T1.DefaultMerge([]interface{}{ + D["nest"].(map[string]interface{})["nest-map"], + D["nest"].(map[string]interface{})["nest-slice"], + }) + assert.Equal(t, 1.38065, T1.Default[0].(map[string]interface{})["float"]) + assert.Equal(t, 64, T1.Default[0].(map[string]interface{})["int"]) + assert.Equal(t, "foo", T1.Default[0].(map[string]interface{})["string"]) + assert.Contains(t, T1.Default[0], "map") + assert.Contains(t, T1.Default[0], "slice") + assert.Equal(t, "world", T1.Default[1].([]interface{})[0]) + assert.Equal(t, 9.10939, T1.Default[1].([]interface{})[1]) + assert.Equal(t, 81, T1.Default[1].([]interface{})[2]) + assert.Contains(t, T1.Default[1].([]interface{})[3], "float") + assert.Contains(t, T1.Default[1].([]interface{})[4], "bar") + + // T2 + // overwrite true, deep false + T1.DefaultMerge([]interface{}{D["map"], D["slice"]}, true, false) + assert.Equal(t, 1.38065, T1.Default[0].(map[string]interface{})["float"]) + assert.Equal(t, 64, T1.Default[0].(map[string]interface{})["int"]) + assert.Equal(t, "foo", T1.Default[0].(map[string]interface{})["string"]) + assert.Equal(t, "world", T1.Default[1].([]interface{})[0]) + assert.Equal(t, 9.10939, T1.Default[1].([]interface{})[1]) + assert.Equal(t, 81, T1.Default[1].([]interface{})[2]) + + // overwrite true, deep true + T1.DefaultMerge([]interface{}{ + D["nest"].(map[string]interface{})["nest-map"], + D["nest"].(map[string]interface{})["nest-slice"], + }, true, true) + assert.Equal(t, 3.1415926, T1.Default[0].(map[string]interface{})["float"]) + assert.Equal(t, 99, T1.Default[0].(map[string]interface{})["int"]) + assert.Equal(t, "bar", T1.Default[0].(map[string]interface{})["string"]) + assert.Contains(t, T1.Default[0], "map") + assert.Contains(t, T1.Default[0], "slice") + assert.Equal(t, "bar", T1.Default[1].([]interface{})[0]) + assert.Equal(t, 3.1415926, T1.Default[1].([]interface{})[1]) + assert.Equal(t, 99, T1.Default[1].([]interface{})[2]) + assert.Contains(t, T1.Default[1].([]interface{})[3], "float") + assert.Contains(t, T1.Default[1].([]interface{})[4], "bar") + + // overwrite false, deep false + T1.DefaultMerge([]interface{}{ + map[string]interface{}{"string": "foo", "hello": "world"}, + []interface{}{"foo", nil, nil, nil, nil, "world"}, + }, false, false) + assert.Equal(t, 3.1415926, T1.Default[0].(map[string]interface{})["float"]) + assert.Equal(t, 99, T1.Default[0].(map[string]interface{})["int"]) + assert.Equal(t, "bar", T1.Default[0].(map[string]interface{})["string"]) + assert.Equal(t, "world", T1.Default[0].(map[string]interface{})["hello"]) + assert.Contains(t, T1.Default[0], "map") + assert.Contains(t, T1.Default[0], "slice") + assert.Equal(t, "bar", T1.Default[1].([]interface{})[0]) + assert.Equal(t, 3.1415926, T1.Default[1].([]interface{})[1]) + assert.Equal(t, 99, T1.Default[1].([]interface{})[2]) + assert.Contains(t, T1.Default[1].([]interface{})[3], "float") + assert.Contains(t, T1.Default[1].([]interface{})[4], "bar") + assert.Contains(t, T1.Default[1].([]interface{})[5], "world") + +} + +func testProcessDefaults() map[string]interface{} { + + return map[string]interface{}{ + "string": "hello", + "float": 0.618, + "int": 49, + "map": map[string]interface{}{ + "string": "foo", + "float": 1.38065, + "int": 64, + }, + "slice": []interface{}{ + "world", + 9.10939, + 81, + }, + "nest": map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + "slice": []interface{}{ + "bar", + 3.1415926, + 99, + }, + "nest-slice": []interface{}{ + "bar", + 3.1415926, + 99, + map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + }, + + []interface{}{ + "bar", + 3.1415926, + 99, + map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + }, + }, + }, + "map": map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + }, + "nest-map": map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + "map": map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + }, + "slice": []interface{}{ + "bar", + 3.1415926, + 99, + map[string]interface{}{ + "string": "bar", + "float": 3.1415926, + "int": 99, + }, + }, + }, + }, + } +} diff --git a/widgets/chart/action.go b/widgets/chart/action.go index e29f79f0..838b160f 100644 --- a/widgets/chart/action.go +++ b/widgets/chart/action.go @@ -30,18 +30,17 @@ var processActionDefaults = map[string]*action.Process{ // SetDefaultProcess set the default value of action func (act *ActionDSL) SetDefaultProcess() { - act.Setting = action.NewProcess("Setting", act.Setting). - SetDefault(processActionDefaults). + act.Setting = action.ProcessOf(act.Setting). + Merge(processActionDefaults["Setting"]). SetHandler(processHandler) - act.Component = action.NewProcess("Component", act.Component). - SetDefault(processActionDefaults). + act.Component = action.ProcessOf(act.Component). + Merge(processActionDefaults["Component"]). SetHandler(processHandler) - act.Data = action.NewProcess("Data", act.Data). - WithBefore(act.BeforeData). - WithAfter(act.AfterData). - SetDefault(processActionDefaults). + act.Data = action.ProcessOf(act.Data). + WithBefore(act.BeforeData).WithAfter(act.AfterData). + Merge(processActionDefaults["Data"]). SetHandler(processHandler) } diff --git a/widgets/form/action.go b/widgets/form/action.go index be66cb7a..7136a534 100644 --- a/widgets/form/action.go +++ b/widgets/form/action.go @@ -46,38 +46,37 @@ var processActionDefaults = map[string]*action.Process{ // SetDefaultProcess set the default value of action func (act *ActionDSL) SetDefaultProcess() { - act.Setting = action.NewProcess("Setting", act.Setting). - SetDefault(processActionDefaults). + act.Setting = action.ProcessOf(act.Setting). + Merge(processActionDefaults["Setting"]). SetHandler(processHandler) - act.Component = action.NewProcess("Component", act.Component). - SetDefault(processActionDefaults). + act.Component = action.ProcessOf(act.Component). + Merge(processActionDefaults["Component"]). SetHandler(processHandler) - act.Find = action.NewProcess("Find", act.Find). - WithBefore(act.BeforeFind). - WithAfter(act.AfterFind). - SetDefault(processActionDefaults). + act.Find = action.ProcessOf(act.Find). + WithBefore(act.BeforeFind).WithAfter(act.AfterFind). + Merge(processActionDefaults["Find"]). SetHandler(processHandler) - act.Save = action.NewProcess("Save", act.Save). + act.Save = action.ProcessOf(act.Save). WithBefore(act.BeforeSave).WithAfter(act.AfterSave). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Save"]). SetHandler(processHandler) - act.Create = action.NewProcess("Create", act.Create). + act.Create = action.ProcessOf(act.Create). WithBefore(act.BeforeCreate).WithAfter(act.AfterCreate). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Create"]). SetHandler(processHandler) - act.Update = action.NewProcess("Update", act.Update). + act.Update = action.ProcessOf(act.Update). WithBefore(act.BeforeUpdate).WithAfter(act.AfterUpdate). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Update"]). SetHandler(processHandler) - act.Delete = action.NewProcess("Delete", act.Delete). + act.Delete = action.ProcessOf(act.Delete). WithBefore(act.BeforeDelete).WithAfter(act.AfterDelete). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Delete"]). SetHandler(processHandler) } diff --git a/widgets/login/process.go b/widgets/login/process.go index 035f7f1a..2641d658 100644 --- a/widgets/login/process.go +++ b/widgets/login/process.go @@ -66,7 +66,7 @@ func auth(field string, value string, password string) maps.Map { user := gou.Select("xiang.user") rows, err := user.Get(gou.QueryParam{ - Select: []interface{}{"id", "password", "name", "type", "email", "mobile", "extra"}, + Select: []interface{}{"id", "password", "name", "type", "email", "mobile", "extra", "status"}, Limit: 1, Wheres: []gou.QueryWhere{ {Column: column, Value: value}, diff --git a/widgets/table/action.go b/widgets/table/action.go index 0c3f983e..fafdbec7 100644 --- a/widgets/table/action.go +++ b/widgets/table/action.go @@ -88,73 +88,73 @@ var processActionDefaults = map[string]*action.Process{ // SetDefaultProcess set the default value of action func (act *ActionDSL) SetDefaultProcess() { - act.Setting = action.NewProcess("Setting", act.Setting). - SetDefault(processActionDefaults). + act.Setting = action.ProcessOf(act.Setting). + Merge(processActionDefaults["Setting"]). SetHandler(processHandler) - act.Component = action.NewProcess("Component", act.Component). - SetDefault(processActionDefaults). + act.Component = action.ProcessOf(act.Component). + Merge(processActionDefaults["Component"]). SetHandler(processHandler) - act.Search = action.NewProcess("Search", act.Search). + act.Search = action.ProcessOf(act.Search). WithBefore(act.BeforeSearch).WithAfter(act.AfterSearch). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Search"]). SetHandler(processHandler) - act.Get = action.NewProcess("Get", act.Get). + act.Get = action.ProcessOf(act.Get). WithBefore(act.BeforeGet).WithAfter(act.AfterGet). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Get"]). SetHandler(processHandler) - act.Find = action.NewProcess("Find", act.Find). + act.Find = action.ProcessOf(act.Find). WithBefore(act.BeforeFind). WithAfter(act.AfterFind). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Find"]). SetHandler(processHandler) - act.Save = action.NewProcess("Save", act.Save). + act.Save = action.ProcessOf(act.Save). WithBefore(act.BeforeSave).WithAfter(act.AfterSave). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Save"]). SetHandler(processHandler) - act.Create = action.NewProcess("Create", act.Create). + act.Create = action.ProcessOf(act.Create). WithBefore(act.BeforeCreate).WithAfter(act.AfterCreate). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Create"]). SetHandler(processHandler) - act.Insert = action.NewProcess("Insert", act.Insert). + act.Insert = action.ProcessOf(act.Insert). WithBefore(act.BeforeInsert).WithAfter(act.AfterInsert). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Insert"]). SetHandler(processHandler) - act.Update = action.NewProcess("Update", act.Update). + act.Update = action.ProcessOf(act.Update). WithBefore(act.BeforeUpdate).WithAfter(act.AfterUpdate). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Update"]). SetHandler(processHandler) - act.UpdateWhere = action.NewProcess("UpdateWhere", act.UpdateWhere). + act.UpdateWhere = action.ProcessOf(act.UpdateWhere). WithBefore(act.BeforeUpdateWhere).WithAfter(act.AfterUpdateWhere). - SetDefault(processActionDefaults). + Merge(processActionDefaults["UpdateWhere"]). SetHandler(processHandler) - act.UpdateIn = action.NewProcess("UpdateIn", act.UpdateIn). + act.UpdateIn = action.ProcessOf(act.UpdateIn). WithBefore(act.BeforeUpdateIn).WithAfter(act.AfterUpdateIn). - SetDefault(processActionDefaults). + Merge(processActionDefaults["UpdateIn"]). SetHandler(processHandler) - act.Delete = action.NewProcess("Delete", act.Delete). + act.Delete = action.ProcessOf(act.Delete). WithBefore(act.BeforeDelete).WithAfter(act.AfterDelete). - SetDefault(processActionDefaults). + Merge(processActionDefaults["Delete"]). SetHandler(processHandler) - act.DeleteWhere = action.NewProcess("DeleteWhere", act.DeleteWhere). + act.DeleteWhere = action.ProcessOf(act.DeleteWhere). WithBefore(act.BeforeDeleteWhere).WithAfter(act.AfterDeleteWhere). - SetDefault(processActionDefaults). + Merge(processActionDefaults["DeleteWhere"]). SetHandler(processHandler) - act.DeleteIn = action.NewProcess("DeleteIn", act.DeleteIn). + act.DeleteIn = action.ProcessOf(act.DeleteIn). WithBefore(act.BeforeDeleteIn).WithAfter(act.AfterDeleteIn). - SetDefault(processActionDefaults). + Merge(processActionDefaults["DeleteIn"]). SetHandler(processHandler) } @@ -177,9 +177,9 @@ func (act *ActionDSL) BindModel(m *gou.Model) { // bind options if act.Bind.Option != nil { - act.Search.Default[0] = act.Bind.Option - act.Get.Default[0] = act.Bind.Option - act.Find.Default[1] = act.Bind.Option + act.Search.DefaultMerge([]interface{}{act.Bind.Option}) + act.Get.DefaultMerge([]interface{}{act.Bind.Option}) + act.Find.DefaultMerge([]interface{}{nil, act.Bind.Option}) } } diff --git a/widgets/table/api_test.go b/widgets/table/api_test.go index 9fd44707..e3ab12ce 100644 --- a/widgets/table/api_test.go +++ b/widgets/table/api_test.go @@ -46,6 +46,40 @@ func TestAPISetting(t *testing.T) { assert.Equal(t, "/api/__yao/table/pet/component/fields.table.入院状态.edit.props.xProps/remote", data.Get("fields.table.入院状态.edit.props.xProps.remote.api")) } +func TestAPISearch(t *testing.T) { + port := start(t) + defer test.Stop(func() {}) + + req := test.NewRequest(port).Route("/api/__yao/table/session/search") + res, err := req.Get() + if err != nil { + t.Fatal(err) + } + assert.Equal(t, 403, res.Status()) + + req = test.NewRequest(port).Route("/api/__yao/table/session/search").Token(token(t)) + res, err = req.Get() + if err != nil { + t.Fatal(err) + } + assert.Equal(t, 200, res.Status()) + resp, err := res.Map() + if err != nil { + t.Fatal(err) + } + + data := any.Of(resp).MapStr().Dot() + assert.Equal(t, "20", fmt.Sprintf("%v", data.Get("pagesize"))) + assert.Equal(t, "3", fmt.Sprintf("%v", data.Get("total"))) + assert.Equal(t, "#FF0000", data.Get("data.0.status.color")) + assert.Equal(t, "status", data.Get("data.0.status.field")) + assert.Equal(t, "checked", data.Get("data.0.status.label")) + assert.Equal(t, "Cookie", data.Get("data.0.status.name")) + assert.Equal(t, "enabled", data.Get("data.0.mode")) + assert.Equal(t, "1", fmt.Sprintf("%v", data.Get("data.0.doctor_id"))) + +} + func TestAPISave(t *testing.T) { port := start(t) defer test.Stop(func() {}) diff --git a/widgets/table/table_test.go b/widgets/table/table_test.go index dbb343aa..6b6e57db 100644 --- a/widgets/table/table_test.go +++ b/widgets/table/table_test.go @@ -19,7 +19,7 @@ func TestLoad(t *testing.T) { if err != nil { t.Fatal(err) } - assert.Equal(t, 3, len(Tables)) + assert.Equal(t, 4, len(Tables)) } func prepare(t *testing.T, language ...string) { diff --git a/widgets/test/request.go b/widgets/test/request.go index 854cf809..fe413358 100644 --- a/widgets/test/request.go +++ b/widgets/test/request.go @@ -190,7 +190,7 @@ func (p *Response) To(v interface{}) error { func AutoLogin(id int) (map[string]interface{}, error) { user := gou.Select("xiang.user") - row, err := user.Find(id, gou.QueryParam{Select: []interface{}{"id", "password", "name", "type", "email", "mobile", "extra"}}) + row, err := user.Find(id, gou.QueryParam{Select: []interface{}{"id", "name", "type", "email", "mobile", "extra", "status"}}) if err != nil { return nil, err }