dynamic: compareStruct and compareSimpleValue

pkg/dynamic/compare.go

@@ -14,62 +14,24 @@ type Diff struct {
 	After  string `json:"after"`
 }
 
-func isSimpleType(kind reflect.Kind) bool {
-	switch kind {
-	case reflect.Bool, reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint64, reflect.String, reflect.Float64:
-		return true
-	default:
-		return false
-	}
-}
-
-func compareSimpleValue(a, b reflect.Value) bool {
-	if a.Kind() != b.Kind() {
-		return false
-	}
-
-	switch a.Kind() {
-	case reflect.Bool:
-		if a.Bool() == b.Bool() {
-			return true
-		}
-
-	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint64:
-		if a.Int() == b.Int() {
-			return true
-		}
-
-	case reflect.String:
-		if a.String() == b.String() {
-			return true
-		}
-
-	case reflect.Float64:
-		if a.Float() == b.Float() {
-			return true
-		}
-
-	case reflect.Slice:
-		// TODO: compare slice
-
-	default:
-		// unhandled case
-
-	}
-
-	return false
-}
-
 // a (after)
 // b (before)
 func Compare(a, b interface{}) ([]Diff, error) {
 	var diffs []Diff
 
 	ra := reflect.ValueOf(a)
+	if ra.Kind() == reflect.Ptr {
+		ra = ra.Elem()
+	}
+
 	raType := ra.Type()
 	raKind := ra.Kind()
 
 	rb := reflect.ValueOf(b)
+	if rb.Kind() == reflect.Ptr {
+		rb = rb.Elem()
+	}
+
 	rbType := rb.Type()
 	rbKind := rb.Kind() // bool, int, slice, string, struct
 
@@ -96,15 +58,133 @@ func Compare(a, b interface{}) ([]Diff, error) {
 		}
 	}
 
+	if raKind == reflect.Struct {
+
+	}
+
 	return diffs, nil
 }
 
+func compareStruct(a, b reflect.Value) ([]Diff, error) {
+	if a.Kind() == reflect.Ptr {
+		a = a.Elem()
+	}
+
+	if b.Kind() == reflect.Ptr {
+		b = b.Elem()
+	}
+
+	if a.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("value is not a struct")
+	}
+
+	if b.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("value is not a struct")
+	}
+
+	if a.Type() != b.Type() {
+		return nil, fmt.Errorf("type is not the same")
+	}
+
+	var diffs []Diff
+
+	numFields := a.NumField()
+	for i := 0; i < numFields; i++ {
+		fieldValueA := a.Field(i)
+		fieldValueB := b.Field(i)
+
+		fieldName := a.Type().Field(i).Name
+
+		if isSimpleType(fieldValueA.Kind()) {
+			if compareSimpleValue(fieldValueA, fieldValueB) {
+				continue
+			} else {
+				diffs = append(diffs, Diff{
+					Field:  fieldName,
+					Before: convertToStr(fieldValueB),
+					After:  convertToStr(fieldValueA),
+				})
+			}
+		} else if fieldValueA.Kind() == reflect.Struct && fieldValueB.Kind() == reflect.Struct {
+			subDiffs, err := compareStruct(fieldValueA, fieldValueB)
+			if err != nil {
+				return diffs, err
+			}
+
+			for _, subDiff := range subDiffs {
+				diffs = append(diffs, Diff{
+					Field:  fieldName + "." + subDiff.Field,
+					Before: subDiff.Before,
+					After:  subDiff.After,
+				})
+			}
+		}
+	}
+
+	return diffs, nil
+}
+
+func isSimpleType(kind reflect.Kind) bool {
+	switch kind {
+	case reflect.Bool, reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint64, reflect.String, reflect.Float64:
+		return true
+	default:
+		return false
+	}
+}
+
+func compareSimpleValue(a, b reflect.Value) bool {
+	if a.Kind() != b.Kind() {
+		return false
+	}
+
+	switch a.Kind() {
+
+	case reflect.Bool:
+		if a.Bool() == b.Bool() {
+			return true
+		}
+
+	case reflect.Uint, reflect.Uint32, reflect.Uint64:
+		if a.Uint() == b.Uint() {
+			return true
+		}
+	case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64:
+		if a.Int() == b.Int() {
+			return true
+		}
+
+	case reflect.String:
+		if a.String() == b.String() {
+			return true
+		}
+
+	case reflect.Float64:
+		if a.Float() == b.Float() {
+			return true
+		}
+
+	case reflect.Slice:
+		// TODO: compare slice
+
+	default:
+		// unhandled case
+
+	}
+
+	return false
+}
+
 func convertToStr(val reflect.Value) string {
 	if val.Type() == reflect.TypeOf(fixedpoint.Zero) {
 		fp := val.Interface().(fixedpoint.Value)
 		return fp.String()
 	}
 
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+
 	switch val.Kind() {
 	case reflect.Float32, reflect.Float64:
 		return strconv.FormatFloat(val.Float(), 'f', -1, 64)
@@ -116,11 +196,7 @@ func convertToStr(val reflect.Value) string {
 		return strconv.FormatUint(val.Uint(), 10)
 
 	case reflect.Bool:
-		if val.Bool() {
-			return "true"
-		} else {
-			return "false"
-		}
+		return strconv.FormatBool(val.Bool())
 	default:
 		strType := reflect.TypeOf("")
 		if val.CanConvert(strType) {

pkg/dynamic/compare_test.go

@@ -1,12 +1,14 @@
 package dynamic
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 
 	"github.com/c9s/bbgo/pkg/fixedpoint"
+	"github.com/c9s/bbgo/pkg/types"
 )
 
 func Test_convertToStr(t *testing.T) {
@@ -40,9 +42,91 @@ func Test_convertToStr(t *testing.T) {
 		assert.Equal(t, "123", out)
 	})
 
+	t.Run("int-ptr-str", func(t *testing.T) {
+		a := int(123)
+		out := convertToStr(reflect.ValueOf(&a))
+		assert.Equal(t, "123", out)
+	})
+
 	t.Run("fixedpoint-str", func(t *testing.T) {
 		a := fixedpoint.NewFromInt(100)
 		out := convertToStr(reflect.ValueOf(a))
 		assert.Equal(t, "100", out)
 	})
 }
+
+func Test_compareStruct(t *testing.T) {
+	tests := []struct {
+		name    string
+		a, b    reflect.Value
+		want    []Diff
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:    "order ptrs",
+			wantErr: assert.NoError,
+			a: reflect.ValueOf(&types.Order{
+				SubmitOrder: types.SubmitOrder{
+					Symbol:   "BTCUSDT",
+					Quantity: fixedpoint.NewFromFloat(100.0),
+				},
+				ExecutedQuantity: fixedpoint.NewFromFloat(50.0),
+			}),
+			b: reflect.ValueOf(&types.Order{
+				SubmitOrder: types.SubmitOrder{
+					Symbol:   "BTCUSDT",
+					Quantity: fixedpoint.NewFromFloat(100.0),
+				},
+				ExecutedQuantity: fixedpoint.NewFromFloat(20.0),
+			}),
+			want: []Diff{
+				{
+					Field:  "ExecutedQuantity",
+					Before: "20",
+					After:  "50",
+				},
+			},
+		},
+		{
+			name:    "order ptr and value",
+			wantErr: assert.NoError,
+			a: reflect.ValueOf(types.Order{
+				SubmitOrder: types.SubmitOrder{
+					Symbol:   "BTCUSDT",
+					Quantity: fixedpoint.NewFromFloat(100.0),
+				},
+				Status:           types.OrderStatusFilled,
+				ExecutedQuantity: fixedpoint.NewFromFloat(100.0),
+			}),
+			b: reflect.ValueOf(&types.Order{
+				SubmitOrder: types.SubmitOrder{
+					Symbol:   "BTCUSDT",
+					Quantity: fixedpoint.NewFromFloat(100.0),
+				},
+				ExecutedQuantity: fixedpoint.NewFromFloat(50.0),
+				Status:           types.OrderStatusPartiallyFilled,
+			}),
+			want: []Diff{
+				{
+					Field:  "Status",
+					Before: "PARTIALLY_FILLED",
+					After:  "FILLED",
+				},
+				{
+					Field:  "ExecutedQuantity",
+					Before: "50",
+					After:  "100",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := compareStruct(tt.a, tt.b)
+			if !tt.wantErr(t, err, fmt.Sprintf("compareStruct(%v, %v)", tt.a, tt.b)) {
+				return
+			}
+			assert.Equalf(t, tt.want, got, "compareStruct(%v, %v)", tt.a, tt.b)
+		})
+	}
+}

pkg/notifier/slacknotifier/slack.go

@@ -71,7 +71,17 @@ func (n *Notifier) worker() {
 	}
 }
 
-func (n *Notifier) PostLiveNote(obj livenote.Object) error {
+type LiveNoteOption interface{}
+
+type Mention struct {
+	User string
+}
+
+type Comment struct {
+	Text string
+}
+
+func (n *Notifier) PostLiveNote(obj livenote.Object, opts ...LiveNoteOption) error {
 	note := n.liveNotePool.Update(obj)
 	ctx := context.Background()
 
@@ -87,18 +97,30 @@ func (n *Notifier) PostLiveNote(obj livenote.Object) error {
 		return fmt.Errorf("livenote object does not support types.SlackAttachmentCreator interface")
 	}
 
-	opts := slack.MsgOptionAttachments(attachment)
+	var slackOpts []slack.MsgOption
+	slackOpts = append(slackOpts, slack.MsgOptionAttachments(attachment))
+
+	var mentions []*Mention
+	var comments []*Comment
+	for _, opt := range opts {
+		switch val := opt.(type) {
+		case *Mention:
+			mentions = append(mentions, val)
+		case *Comment:
+			comments = append(comments, val)
+
+		}
+	}
 
 	if note.MessageID != "" {
 		// UpdateMessageContext returns channel, timestamp, text, err
-		_, _, _, err := n.client.UpdateMessageContext(ctx, channel, note.MessageID, opts)
+		_, _, _, err := n.client.UpdateMessageContext(ctx, channel, note.MessageID, slackOpts...)
 		if err != nil {
 			return err
 		}
 
 	} else {
-
-		respCh, respTs, err := n.client.PostMessageContext(ctx, channel, opts)
+		respCh, respTs, err := n.client.PostMessageContext(ctx, channel, slackOpts...)
 		if err != nil {
 			log.WithError(err).
 				WithField("channel", n.channel).