Merge branch 'release/0.1.9'

Update Indicators

cmd/indicators/funcs.go

@@ -0,0 +1,98 @@
+package indicators
+
+import (
+	"fmt"
+
+	"github.com/yasseldg/go-simple/logs/sLog"
+	"github.com/yasseldg/go-simple/repositorys/rMongo"
+	"github.com/yasseldg/go-simple/trading/tCandle"
+	"github.com/yasseldg/go-simple/trading/tIndicator"
+	"github.com/yasseldg/go-simple/trading/tInterval"
+)
+
+func Run(mongo *rMongo.Manager) {
+	indicator := get("SuperTrend")
+
+	run(indicator, mongo, "BYBIT_WLDUSDT", tInterval.Interval_1h)
+}
+
+func get(indicator string) Indicator {
+	switch indicator {
+	case "RSI":
+		return tIndicator.NewRSIcandle(14)
+
+	case "BBands":
+		return tIndicator.NewBBcandle(30, 2)
+
+	case "AvgATR":
+		return tIndicator.NewAvgATR(14)
+
+	case "SmATR":
+		return tIndicator.NewSmATR(14)
+
+	case "ADX":
+		return tIndicator.NewADX(14)
+
+	case "SuperTrend":
+		return tIndicator.NewSuperTrend(15, 5, false)
+
+	default:
+		return nil
+	}
+}
+
+// private vars
+
+var (
+	_coll rMongo.Collection
+
+	_iter tCandle.InterIter
+)
+
+type Indicator interface {
+	Log()
+	Add(candle tCandle.Inter)
+}
+
+//  private methods
+
+func run(indicator Indicator, mongo *rMongo.Manager, symbol string, interval tInterval.Interval) {
+	if indicator == nil {
+		sLog.Info("Indicator is nil")
+		return
+	}
+
+	err := config(mongo, symbol, interval)
+	if err != nil {
+		sLog.Info("repos.Run(): config(): %s", err)
+		return
+	}
+
+	indicator.Log()
+
+	for _iter.Next() {
+		indicator.Add(_iter.Item())
+
+		indicator.Log()
+	}
+}
+
+func config(_mongo *rMongo.Manager, symbol string, interval tInterval.Interval) error {
+
+	coll_name := fmt.Sprintf("%s_%s", "historic_prices", interval.String())
+
+	var err error
+	_coll, err = _mongo.GetColl("", "PP_Historic_Trades_R", symbol, coll_name)
+	if err != nil {
+		return fmt.Errorf("GetColl(): %s", err)
+	}
+	_coll.Log()
+
+	_iter, err = tCandle.NewIter(rMongo.NewFilter(), _coll)
+	if err != nil {
+		return fmt.Errorf("tCandle.NewIter(): %s", err)
+	}
+	_iter.Log("Candles")
+
+	return nil
+}

cmd/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"github.com/yasseldg/go-simple/cmd/indicators"
+	"github.com/yasseldg/go-simple/cmd/repos"
+
+	"github.com/yasseldg/go-simple/logs/sLog"
+	"github.com/yasseldg/go-simple/repositorys/rMongo"
+	"github.com/yasseldg/go-simple/types/sTime"
+)
+
+var (
+	_mongo *rMongo.Manager
+)
+
+func Init() {
+	mongo := rMongo.NewManager()
+	_mongo = &mongo
+}
+
+func main() {
+
+	clean := sLog.SetByName(sLog.Zap, sLog.LevelInfo, "")
+	defer clean()
+
+	Init()
+
+	sLog.Info("Starting...")
+
+	sTime.TimeControl(testIndicators, "Indicators")
+}
+
+func testModel() {
+	repos.Run(_mongo)
+}
+
+func testIndicators() {
+	indicators.Run(_mongo)
+}

cmd/repos/funcs.go

@@ -0,0 +1,95 @@
+package repos
+
+import (
+	"fmt"
+
+	"github.com/yasseldg/go-simple/logs/sLog"
+	"github.com/yasseldg/go-simple/repositorys/rMongo"
+	"github.com/yasseldg/go-simple/trading/tSide"
+)
+
+var (
+	_coll rMongo.Collection
+)
+
+func Run(mongo *rMongo.Manager) {
+	err := config(mongo)
+	if err != nil {
+		sLog.Error("repos.Run(): config(): %s", err)
+		return
+	}
+
+	strategie := Model{
+		Uuid:   "uuid",
+		Name:   "name",
+		Code:   "code",
+		Symbol: "symbol",
+		Side:   tSide.Buy,
+	}
+
+	err = load(strategie)
+	if err != nil {
+		sLog.Error("load(): %s", err)
+	}
+}
+
+func config(_mongo *rMongo.Manager) error {
+	var err error
+	_coll, err = _mongo.GetColl("strategies", "WRITE", "bot", "strategies", Indexes()...)
+	if err != nil {
+		return fmt.Errorf("GetColl(): %s", err)
+	}
+	_coll.Log()
+
+	return nil
+}
+
+func load(strategie Model) error {
+
+	doc, err := find(strategie)
+	if err != nil {
+		sLog.Error("find(): %s", err)
+		return create(strategie)
+	}
+
+	sLog.Warn("strategie already exists: %s", doc.String())
+
+	return nil
+}
+
+func find(strategie Model) (*Model, error) {
+
+	filter := NewFilter().Code(strategie.Code).Symbol(strategie.Symbol).State("active").Side(strategie.Side)
+
+	sLog.Warn("find strategie: %s", filter.String())
+
+	var doc Model
+	err := _coll.Filters(filter.Filters).FindOne(&doc)
+	if err != nil {
+		return nil, fmt.Errorf("coll.FindOne(): %s", err)
+	}
+
+	sLog.Warn("found strategie: %s", doc.String())
+
+	return &doc, nil
+}
+
+func create(strategie Model) error {
+
+	sLog.Warn("create strategie: %s", strategie.String())
+
+	strategie.SetState("active")
+
+	strategie.Log()
+
+	_coll.Log()
+
+	err := _coll.Create(&strategie)
+	if err != nil {
+		return fmt.Errorf("coll.Create(): %s", err)
+	}
+
+	strategie.Log()
+
+	return nil
+}

cmd/repos/model.go

@@ -0,0 +1,87 @@
+package repos
+
+import (
+	"fmt"
+
+	"github.com/yasseldg/go-simple/logs/sLog"
+	"github.com/yasseldg/go-simple/repositorys/rFilter"
+	"github.com/yasseldg/go-simple/repositorys/rMongo"
+	"github.com/yasseldg/go-simple/repositorys/rSort"
+	"github.com/yasseldg/go-simple/trading/tSide"
+
+	"github.com/yasseldg/mgm/v4"
+
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type Model struct {
+	mgm.DefaultModelDateState `bson:",inline"`
+
+	Uuid   string     `bson:"uuid" json:"uuid"`
+	Name   string     `bson:"name" json:"name"`
+	Code   string     `bson:"code" json:"code"`
+	Symbol string     `bson:"symbol" json:"symbol"`
+	Side   tSide.Side `bson:"sd" json:"sd"`
+}
+type Models []Model
+
+// filters
+
+type Filters struct{ rFilter.Filters }
+
+func NewFilter() *Filters {
+	return &Filters{Filters: rMongo.NewFilter()}
+}
+
+func (f *Filters) Uuid(uuid string) *Filters { f.Append("uuid", uuid); return f }
+
+func (f *Filters) Code(code string) *Filters { f.Append("code", code); return f }
+
+func (f *Filters) Side(side tSide.Side) *Filters { f.Int("sd", int(side)); return f }
+
+func (f *Filters) State(state string) *Filters { f.Append("st", state); return f }
+
+func (f *Filters) Symbol(symbol string) *Filters { f.Append("symbol", symbol); return f }
+
+// sorts
+
+type Sorts struct{ rSort.Sorts }
+
+func NewSort() *Sorts {
+	return &Sorts{Sorts: rMongo.NewSort()}
+}
+
+func (s *Sorts) Fields() bson.D {
+	return rMongo.GetFields(NewSort().Indexes().Sorts)
+}
+
+func (s *Sorts) UuidAsc() *Sorts { s.Asc("uuid"); return s }
+
+func (s *Sorts) CodeAsc() *Sorts { s.Asc("code"); return s }
+
+func (s *Sorts) SymbolAsc() *Sorts { s.Asc("symbol"); return s }
+
+func (s *Sorts) SideAsc() *Sorts { s.Asc("sd"); return s }
+
+func (s *Sorts) Indexes() *Sorts {
+	s.CodeAsc().SymbolAsc().SideAsc().UuidAsc()
+	return s
+}
+
+// indexes
+
+func Indexes() rMongo.Indexes {
+	return rMongo.Indexes{rMongo.Index{Fields: NewSort().Indexes().Fields(), Unique: true}}
+}
+
+//  model methods
+
+// TODO
+
+func (m *Model) String() string {
+	return fmt.Sprintf("uuid: %s .. name: %s .. code: %s .. symbol: %s .. side: %s .. state: %s", m.Uuid, m.Name, m.Code, m.Symbol, m.Side, m.State)
+}
+
+func (m *Model) Log() {
+	sLog.Info("Model: %s", m.String())
+}

data/dAccu/base.go

@@ -0,0 +1,67 @@
+package dAccu
+
+import (
+	"fmt"
+
+	"github.com/yasseldg/go-simple/logs/sLog"
+)
+
+type Base struct {
+	limit int
+
+	count int
+
+	empty bool
+	err   error
+
+	save func() error
+}
+
+func New(limit int, save func() error) *Base {
+	return &Base{
+		limit: limit,
+		save:  save,
+	}
+}
+
+func (a *Base) String(name string) string {
+	return fmt.Sprintf("Accu ( %s ): count: %d  ..  limit: %d", name, a.count, a.limit)
+}
+
+func (a *Base) Log(name string) {
+	sLog.Info(a.String(name))
+}
+
+func (a *Base) SetError(e error) {
+	a.err = e
+}
+
+func (a Base) Error() error {
+	return a.err
+}
+
+func (a *Base) Empty() bool {
+	return a.empty
+}
+
+func (a *Base) Increase() {
+	a.count++
+}
+
+func (a *Base) Limit() int {
+	return a.limit
+}
+
+func (a *Base) Count() int {
+	return a.count
+}
+
+func (a *Base) Save() {
+	err := a.save()
+	if err != nil {
+		a.SetError(err)
+		return
+	}
+
+	a.empty = true
+}