From 00e860df266de4dd4c901f426439a5bd80e0a871 Mon Sep 17 00:00:00 2001
From: c9s <yoanlin93@gmail.com>
Date: Thu, 8 Aug 2024 17:18:17 +0800
Subject: [PATCH] core: add dynamic converter

---
 pkg/core/converter.go      | 33 +++++++++++++++++++++++++++------
 pkg/core/tradecollector.go | 20 ++++++++++++++------
 2 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/pkg/core/converter.go b/pkg/core/converter.go
index 2a2f24d62..c29ccff8b 100644
--- a/pkg/core/converter.go
+++ b/pkg/core/converter.go
@@ -17,26 +17,47 @@ type TradeConverter interface {
 	ConvertTrade(trade types.Trade) (types.Trade, error)
 }
 
+type OrderConvertFunc func(order types.Order) (types.Order, error)
+type TradeConvertFunc func(trade types.Trade) (types.Trade, error)
+
+type DynamicConverter struct {
+	orderConverter OrderConvertFunc
+	tradeConverter TradeConvertFunc
+}
+
+func NewDynamicConverter(orderConverter OrderConvertFunc, tradeConverter TradeConvertFunc) *DynamicConverter {
+	return &DynamicConverter{orderConverter: orderConverter, tradeConverter: tradeConverter}
+}
+
+func (c *DynamicConverter) ConvertOrder(order types.Order) (types.Order, error) {
+	return c.orderConverter(order)
+}
+
+func (c *DynamicConverter) ConvertTrade(trade types.Trade) (types.Trade, error) {
+	return c.tradeConverter(trade)
+}
+
 // SymbolConverter converts the symbol to another symbol
 type SymbolConverter struct {
-	fromSymbol, toSymbol string
+	FromSymbol string `json:"from"`
+	ToSymbol   string `json:"to"`
 }
 
 func NewSymbolConverter(fromSymbol, toSymbol string) *SymbolConverter {
-	return &SymbolConverter{fromSymbol: fromSymbol, toSymbol: toSymbol}
+	return &SymbolConverter{FromSymbol: fromSymbol, ToSymbol: toSymbol}
 }
 
 func (c *SymbolConverter) ConvertOrder(order types.Order) (types.Order, error) {
-	if order.Symbol == c.fromSymbol {
-		order.Symbol = c.toSymbol
+	if order.Symbol == c.FromSymbol {
+		order.Symbol = c.ToSymbol
 	}
 
 	return order, nil
 }
 
 func (c *SymbolConverter) ConvertTrade(trade types.Trade) (types.Trade, error) {
-	if trade.Symbol == c.fromSymbol {
-		trade.Symbol = c.toSymbol
+	if trade.Symbol == c.FromSymbol {
+		trade.Symbol = c.ToSymbol
 	}
 
 	return trade, nil
diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go
index e9245b49b..d961890af 100644
--- a/pkg/core/tradecollector.go
+++ b/pkg/core/tradecollector.go
@@ -13,19 +13,27 @@ import (
 )
 
 type ConverterManager struct {
-	converters []Converter
+	Converters []Converter `json:"converters,omitempty" yaml:"converters,omitempty"`
+}
+
+func (c *ConverterManager) Initialize() error {
+	for _, converter := range c.Converters {
+		_ = converter
+	}
+
+	return nil
 }
 
 func (c *ConverterManager) AddConverter(converter Converter) {
-	c.converters = append(c.converters, converter)
+	c.Converters = append(c.Converters, converter)
 }
 
 func (c *ConverterManager) ConvertOrder(order types.Order) types.Order {
-	if len(c.converters) == 0 {
+	if len(c.Converters) == 0 {
 		return order
 	}
 
-	for _, converter := range c.converters {
+	for _, converter := range c.Converters {
 		convOrder, err := converter.ConvertOrder(order)
 		if err != nil {
 			logrus.WithError(err).Errorf("converter %+v error, order: %s", converter, order.String())
@@ -39,11 +47,11 @@ func (c *ConverterManager) ConvertOrder(order types.Order) types.Order {
 }
 
 func (c *ConverterManager) ConvertTrade(trade types.Trade) types.Trade {
-	if len(c.converters) == 0 {
+	if len(c.Converters) == 0 {
 		return trade
 	}
 
-	for _, converter := range c.converters {
+	for _, converter := range c.Converters {
 		convTrade, err := converter.ConvertTrade(trade)
 		if err != nil {
 			logrus.WithError(err).Errorf("converter %+v error, trade: %s", converter, trade.String())