Example #1
0
func RobotWorker() {
	fmt.Println("env", Config["env"])
	if Config["env"] == "dev" {
		fmt.Println("test working...")
		var tradeAPI common.TradeAPI
		tradeAPI = huobi.NewHuobi()
		tradeAPI.Get_account_info()
		symbol := "btc_cny"
		tradeAPI.GetOrderBook(symbol)

		//testHuobiAPI()
		//testOkcoinLTCAPI()
		return
	}

	ticker := time.NewTicker(2 * time.Second) //2s
	defer ticker.Stop()

	var tradeAPI common.TradeAPI
	tradeAPI = huobi.NewHuobi()
	tradeAPI.Get_account_info()

	tradeAPI = okcoin.NewOkcoin()
	tradeAPI.Get_account_info()

	if Option["tradecenter"] == "huobi" {
		tradeAPI = huobi.NewHuobi()
	} else if Option["tradecenter"] == "okcoin" {
		tradeAPI = okcoin.NewOkcoin()
	} else {
		logger.Fatalln("Please config the tradecenter firstly...")
		return
	}
	peroid, _ := strconv.Atoi(Option["tick_interval"])
	totalHour, _ := strconv.ParseInt(Option["totalHour"], 0, 64)
	if totalHour < 1 {
		totalHour = 1
	}

	fmt.Println("robot working...")

	go func() {
		for _ = range ticker.C {
			tradeAPI.AnalyzeKLine(peroid)
		}
	}()

	logger.Infof("程序将持续运行%d小时后停止", time.Duration(totalHour))

	time.Sleep(time.Duration(totalHour) * time.Hour)

	logger.Infof("程序到达设定时长%d小时,停止运行。", time.Duration(totalHour))
}
Example #2
0
func tradeAPI() (tradeAPI TradeAPI) {
	if Option["tradecenter"] == "huobi" {
		tradeAPI = huobi.NewHuobi()
	} else if Option["tradecenter"] == "okcoin" {
		tradeAPI = okcoin.NewOkcoin()
	} else {
		logger.Fatalln("Please config the tradecenter firstly...")

	}
	return
}
Example #3
0
func marketAPI() (marketAPI MarketAPI) {
	if Option["datacenter"] == "huobi" {
		marketAPI = huobi.NewHuobi()
	} else if Option["datacenter"] == "okcoin" {
		marketAPI = okcoin.NewOkcoin()
	} else {
		logger.Fatalln("Please config the datacenter firstly...")

	}
	return
}
Example #4
0
func RobotWorker() {
	fmt.Println("env", Config["env"])
	if DebugEnv || Config["env"] == "dev" {
		fmt.Println("test working...")

		var tradeAPI TradeAPI
		tradeAPI = okcoin.NewOkcoin()
		tradeAPI.GetAccount()
		tradeAPI.GetOrderBook()

		tradeAPI = huobi.NewHuobi()
		tradeAPI.GetAccount()
		ret, orderbook := tradeAPI.GetOrderBook()
		fmt.Println(ret, orderbook)

		//testHuobiAPI()
		//testOkcoinLTCAPI()
		return
	}

	ticker := time.NewTicker(1 * time.Second) //2s
	defer ticker.Stop()

	totalHour, _ := strconv.ParseInt(Option["totalHour"], 0, 64)
	if totalHour < 1 {
		totalHour = 1
	}

	fmt.Println("robot working...")

	go func() {
		for _ = range ticker.C {
			peroid, _ := strconv.Atoi(Option["tick_interval"])
			strategyName := Option["strategy"]
			ret := true
			var records []Record
			if strategyName != "OPENORDER" {
				ret, records = marketAPI().GetKLine(peroid)
			}

			if ret != false {
				strategy.Tick(tradeAPI(), records)
			}
		}
	}()

	logger.Infof("程序将持续运行%d小时后停止", time.Duration(totalHour))

	time.Sleep(time.Duration(totalHour) * time.Hour)

	logger.Infof("程序到达设定时长%d小时,停止运行。", time.Duration(totalHour))
}
Example #5
0
func marketAPI() (marketAPI MarketAPI) {
	if Option["datacenter"] == "huobi" {
		marketAPI = huobi.NewHuobi()
	} else if Option["datacenter"] == "okcoin" {
		marketAPI = okcoin.NewOkcoin()
	} else if Option["datacenter"] == "peatio" {
		marketAPI = peatio.NewPeatio()
	} else if Option["datacenter"] == "bittrex" {
		marketAPI = Bittrex.Manager()
	} else {
		logger.Fatalln("Please config the market center...")
	}
	return
}
Example #6
0
func tradeAPI() (tradeAPI TradeAPI) {
	if Option["tradecenter"] == "huobi" {
		tradeAPI = huobi.NewHuobi()
	} else if Option["tradecenter"] == "okcoin" {
		tradeAPI = okcoin.NewOkcoin()
	} else if Option["tradecenter"] == "bitvc" {
		tradeAPI = bitvc.NewBitvc()
	} else if Option["tradecenter"] == "peatio" {
		tradeAPI = peatio.NewPeatio()
	} else {
		logger.Fatalln("Please config the exchange center...")
	}
	return
}
Example #7
0
func tradeAPI() (tradeAPI TradeAPI) {
	if Option["tradecenter"] == "huobi" {
		tradeAPI = huobi.NewHuobi()
	} else if Option["tradecenter"] == "okcoin" {
		tradeAPI = okcoin.NewOkcoin()
	} else if Option["tradecenter"] == "bitvc" {
		tradeAPI = bitvc.NewBitvc()
	} else if Option["tradecenter"] == "peatio" {
		tradeAPI = peatio.NewPeatio()
	} else if Option["tradecenter"] == "bittrex" {
		tradeAPI = Bittrex.Manager()
	} else if Option["tradecenter"] == "simulate" {
		tradeAPI = simulate.NewSimulate()
	} else {
		logger.Fatalln("Please config the exchange center...")
		panic(0)
	}
	return
}
Example #8
0
File: api.go Project: 9cat/btcrobot
func (w Bitvc) GetOrderBook() (ret bool, orderBook OrderBook) {
	tradeAPI := huobi.NewHuobi()
	return tradeAPI.GetOrderBook()
}
Example #9
0
func webui() {
	m := martini.Classic()
	m.Get("/secret", func() string {
		// show something
		err := LoadSecretOption()
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "读取秘钥配置数据失败"}`
		}
		Option_json, err := json.Marshal(SecretOption)
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "解析秘钥配置数据失败"}`
		}

		return string(Option_json)
	})

	m.Post("/secret", func(res http.ResponseWriter, req *http.Request) { // res and req are injected by Martini
		SecretOption["username"] = req.FormValue("username")
		SecretOption["password"] = req.FormValue("password")

		SecretOption["bitvc_email"] = req.FormValue("bitvc_email")
		SecretOption["bitvc_password"] = req.FormValue("bitvc_password")

		SecretOption["huobi_access_key"] = req.FormValue("huobi_access_key")
		SecretOption["huobi_secret_key"] = req.FormValue("huobi_secret_key")

		SecretOption["smtp_username"] = req.FormValue("smtp_username")
		SecretOption["smtp_password"] = req.FormValue("smtp_password")
		SecretOption["smtp_host"] = req.FormValue("smtp_host")
		SecretOption["smtp_addr"] = req.FormValue("smtp_addr")

		SecretOption["OKCoinAPIkey"] = req.FormValue("OKCoinAPIkey")

		SecretOption["ok_partner"] = req.FormValue("ok_partner")
		SecretOption["ok_secret_key"] = req.FormValue("ok_secret_key")

		SecretOption["ok_partner1"] = req.FormValue("ok_partner1")
		SecretOption["ok_secret_key1"] = req.FormValue("ok_secret_key1")

		SecretOption["ok_partner2"] = req.FormValue("ok_partner2")
		SecretOption["ok_secret_key2"] = req.FormValue("ok_secret_key2")

		SecretOption["ok_partner3"] = req.FormValue("ok_partner3")
		SecretOption["ok_secret_key3"] = req.FormValue("ok_secret_key3")

		SecretOption["ok_partner4"] = req.FormValue("ok_partner4")
		SecretOption["ok_secret_key4"] = req.FormValue("ok_secret_key4")

		SecretOption["ok_partner5"] = req.FormValue("ok_partner5")
		SecretOption["ok_secret_key5"] = req.FormValue("ok_secret_key5")

		SecretOption["ok_partner6"] = req.FormValue("ok_partner6")
		SecretOption["ok_secret_key6"] = req.FormValue("ok_secret_key6")

		SecretOption["ok_partner7"] = req.FormValue("ok_partner7")
		SecretOption["ok_secret_key7"] = req.FormValue("ok_secret_key7")

		SecretOption["ok_partner8"] = req.FormValue("ok_partner8")
		SecretOption["ok_secret_key8"] = req.FormValue("ok_secret_key8")

		SecretOption["ok_partner9"] = req.FormValue("ok_partner9")
		SecretOption["ok_secret_key9"] = req.FormValue("ok_secret_key9")

		SecretOption["ok_partner10"] = req.FormValue("ok_partner10")
		SecretOption["ok_secret_key10"] = req.FormValue("ok_secret_key10")

		// 更新个人信息
		err := SaveSecretOption()
		if err != nil {
			fmt.Fprint(res, "写入秘钥配置数据失败")
			return
		}

		fmt.Fprint(res, "更新秘钥配置成功!")

		go email.TriggerTrender("btcrobot测试邮件,您能收到这封邮件说明您的SMTP配置成功,来自星星的机器人")

		return
	})

	m.Get("/engine", func() string {
		// show something
		err := LoadOption()
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "读取引擎配置数据失败"}`
		}
		Option_json, err := json.Marshal(Option)
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "解析引擎配置数据失败"}`
		}

		return string(Option_json)
	})

	m.Post("/engine", func(res http.ResponseWriter, req *http.Request) {
		if req.FormValue("enable_trading") == "on" {
			Option["enable_trading"] = "1"
		} else {
			Option["enable_trading"] = "0"
		}

		if req.FormValue("discipleMode") == "on" {
			Option["discipleMode"] = "1"
		} else {
			Option["discipleMode"] = "0"
		}

		Option["discipleValue"] = req.FormValue("discipleValue")

		// open传递过来的是“on”或没传递
		if req.FormValue("enable_email") == "on" {
			Option["enable_email"] = "1"
		} else {
			Option["enable_email"] = "0"
		}

		Option["to_email"] = req.FormValue("to_email")

		Option["tick_interval"] = req.FormValue("tick_interval")
		Option["datacenter"] = req.FormValue("datacenter")
		Option["tradecenter"] = req.FormValue("tradecenter")
		Option["symbol"] = req.FormValue("symbol")
		Option["strategy"] = req.FormValue("strategy")
		Option["shortEMA"] = req.FormValue("shortEMA")
		Option["longEMA"] = req.FormValue("longEMA")
		Option["signalPeriod"] = req.FormValue("signalPeriod")

		Option["tradeAmount"] = req.FormValue("tradeAmount")
		Option["slippage"] = req.FormValue("slippage")

		Option["totalHour"] = req.FormValue("totalHour")
		Option["buyThreshold"] = req.FormValue("buyThreshold")
		Option["sellThreshold"] = req.FormValue("sellThreshold")
		Option["MACDbuyThreshold"] = req.FormValue("MACDbuyThreshold")
		Option["MACDsellThreshold"] = req.FormValue("MACDsellThreshold")

		Option["basePrice"] = req.FormValue("basePrice")
		Option["fluctuation"] = req.FormValue("fluctuation")

		Option["stoploss"] = req.FormValue("stoploss")

		// 更新个人信息
		err := SaveOption()
		if err != nil {
			fmt.Fprint(res, "写入引擎配置数据失败")
			return
		}

		fmt.Fprint(res, "更新引擎配置成功!")
	})

	m.Get("/trade", func() string {
		// show something
		LoadTrade()

		err := LoadTrade()
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "读取Trade配置数据失败"}`
		}

		Option_json, err := json.Marshal(TradeOption)
		if err != nil {
			logger.Errorln(err)
			return `{"errno": 1, "msg":", "解析引擎配置数据失败"}`
		}

		return string(Option_json)
	})

	m.Post("/trade", func(res http.ResponseWriter, req *http.Request) {
		msgtype := req.FormValue("msgtype")
		var nbuyprice, nbuytotalamount, nbuyinterval, nmaxbuyamountratio float64
		var nbuytimes int
		var nsellprice, nselltotalamount, nsellinterval, nmaxsellamountratio float64
		var nselltimes int

		var err error
		if msgtype == "dobuy" {
			TradeOption["buyprice"] = req.FormValue("buyprice")
			TradeOption["buytotalamount"] = req.FormValue("buytotalamount")
			TradeOption["buyinterval"] = req.FormValue("buyinterval")
			TradeOption["buytimes"] = req.FormValue("buytimes")
			TradeOption["maxbuyamountratio"] = req.FormValue("maxbuyamountratio")
			nbuyprice, err = strconv.ParseFloat(Option["buyprice"], 64)
			if err != nil {
				logger.Errorln("config item buyprice is not float")
				return
			}
			nbuytotalamount, err = strconv.ParseFloat(Option["buytotalamount"], 64)
			if err != nil {
				logger.Errorln("config item numbuytotalamount is not float")
				return
			}
			nbuyinterval, err = strconv.ParseFloat(Option["buyinterval"], 64)
			if err != nil {
				logger.Errorln("config item buyinterval is not float")
				return
			}
			nbuytimes, err = strconv.Atoi(Option["buytimes"])
			if err != nil {
				logger.Errorln("config item numbuytimes is not float")
				return
			}

			nmaxbuyamountratio, err = strconv.ParseFloat(Option["maxbuyamountratio"], 64)
			if err != nil {
				logger.Errorln("config item numbuytotalamount is not float")
				return
			}
		} else if msgtype == "dosell" {
			TradeOption["sellprice"] = req.FormValue("sellprice")
			TradeOption["selltotalamount"] = req.FormValue("selltotalamount")
			TradeOption["sellinterval"] = req.FormValue("sellinterval")
			TradeOption["selltimes"] = req.FormValue("selltimes")
			TradeOption["maxsellamountratio"] = req.FormValue("maxsellamountratio")

			nsellprice, err = strconv.ParseFloat(Option["sellprice"], 64)
			if err != nil {
				logger.Errorln("config item sellprice is not float")
				return
			}
			nselltotalamount, err = strconv.ParseFloat(Option["selltotalamount"], 64)
			if err != nil {
				logger.Errorln("config item selltotalamount is not float")
				return
			}
			nsellinterval, err = strconv.ParseFloat(Option["v"], 64)
			if err != nil {
				logger.Errorln("config item sellinterval is not float")
				return
			}
			nselltimes, err = strconv.Atoi(Option["selltimes"])
			if err != nil {
				logger.Errorln("config item selltimes is not float")
				return
			}

			nmaxsellamountratio, err = strconv.ParseFloat(Option["maxsellamountratio"], 64)
			if err != nil {
				logger.Errorln("config item maxsellamountratio is not float")
				return
			}

		} else {
			fmt.Fprint(res, "无效的POST请求")
		}

		// 更新个人信息
		err = SaveTrade()
		if err != nil {
			fmt.Fprint(res, "写入Trade配置数据失败")
		}

		var tradeAPI TradeAPI
		if Option["tradecenter"] == "huobi" {
			tradeAPI = huobi.NewHuobi()
		} else if Option["tradecenter"] == "okcoin" {
			tradeAPI = okcoin.NewOkcoin()
		} else {
			fmt.Fprint(res, "没有选择交易所名称")
		}

		var ret string

		var arrbuyTradePrice []float64
		splitnbuyinterval := nbuyinterval / float64(nbuytimes)
		splitbuyTradeAmount := nbuytotalamount / float64(nbuytimes)
		if splitbuyTradeAmount/nbuytotalamount > nmaxbuyamountratio {
			return
		}

		if msgtype == "dobuy" {
			for i := 0; i < nbuytimes; i++ {
				warning := "oo, 买入buy In<----限价单"

				if i < nbuytimes/2 {
					arrbuyTradePrice[i] = nbuyprice - float64(i)*splitnbuyinterval
				} else {
					arrbuyTradePrice[i] = nbuyprice + float64((i-nbuytimes/2))*splitnbuyinterval
				}

				tradePrice := fmt.Sprintf("%f", arrbuyTradePrice[i])
				strsplitTradeAmount := fmt.Sprintf("%f", splitbuyTradeAmount)

				ret = tradeAPI.Buy(tradePrice, strsplitTradeAmount)

				if ret != "0" {
					fmt.Fprint(res, "交易委托成功")
				} else {
					fmt.Fprint(res, "交易委托失败")
				}
				logger.Infoln(warning)
			}
		}

		var arrsellTradePrice []float64
		splitnsellinterval := nsellinterval / float64(nselltimes)
		splitsellTradeAmount := nselltotalamount / float64(nselltimes)
		if splitsellTradeAmount/nselltotalamount > nmaxsellamountratio {
			return
		}
		if msgtype == "dosell" {
			for i := 0; i < nselltimes; i++ {
				warning := "oo, 卖出buy In<----限价单"

				if i < nselltimes/2 {
					arrsellTradePrice[i] = nsellprice - float64(i)*splitnsellinterval
				} else {
					arrsellTradePrice[i] = nsellprice + float64((i-nselltimes/2))*splitnsellinterval
				}

				tradePrice := fmt.Sprintf("%f", arrsellTradePrice[i])
				strsplitTradeAmount := fmt.Sprintf("%f", splitbuyTradeAmount)

				ret = tradeAPI.Sell(tradePrice, strsplitTradeAmount)

				if ret != "0" {
					fmt.Fprint(res, "交易委托成功")
				} else {
					fmt.Fprint(res, "交易委托失败")
				}
				logger.Infoln(warning)
			}
		}
	})

	m.Use(auth.Basic(SecretOption["username"], SecretOption["password"]))
	m.Use(martini.Static("./static"))
	m.Use(martini.Static("../static"))

	logger.Infoln(http.ListenAndServe(Config["host"], m))

	m.Run()

	fmt.Println("[ ---------------------------------------------------------->>> ")
	fmt.Printf("start web server failed, please check if %s is already used.", Config["host"])
	fmt.Println(" <<<----------------------------------------------------------] ")
}
Example #10
0
func TradeHandler(rw http.ResponseWriter, req *http.Request) {
	if !Basic(rw, req) {
		return
	}
	vars := mux.Vars(req)

	msgtype := vars["msgtype"]

	if req.Method != "POST" || msgtype == "" {
		// 获取用户信息
		err := config.LoadTrade()
		if err != nil {
			logger.Errorln(err)
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "读取Trade配置数据失败", `"}`)
			return
		}
		// 设置模板数据
		filter.SetData(req, map[string]interface{}{"trade": config.TradeOption})
		req.Form.Set(filter.CONTENT_TPL_KEY, "/template/trade/trade.html")
		return
	} else if req.Method == "POST" {
		if msgtype == "dobuy" {
			config.TradeOption["buyprice"] = req.FormValue("buyprice")
			config.TradeOption["buyamount"] = req.FormValue("buyamount")
		} else if msgtype == "dosell" {
			config.TradeOption["sellprice"] = req.FormValue("sellprice")
			config.TradeOption["sellamount"] = req.FormValue("sellamount")
		} else {
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "无效的POST请求", `"}`)
			return
		}

		// 更新个人信息
		err := config.SaveTrade()
		if err != nil {
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "写入Trade配置数据失败", `"}`)
			return
		}

		var tradeAPI TradeAPI
		if config.Option["tradecenter"] == "huobi" {
			tradeAPI = huobi.NewHuobi()
		} else if config.Option["tradecenter"] == "okcoin" {
			tradeAPI = okcoin.NewOkcoin()
		} else {
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "没有选择交易所名称", `"}`)
			return
		}

		var ret bool
		if msgtype == "dobuy" {
			ret = tradeAPI.Buy(config.TradeOption["buyprice"], config.TradeOption["buyamount"])
		} else if msgtype == "dosell" {
			ret = tradeAPI.Sell(config.TradeOption["sellprice"], config.TradeOption["sellamount"])
		}

		if ret != true {
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "交易委托失败", `"}`)
			return
		} else {
			fmt.Fprint(rw, `{"errno": 1, "msg":"`, "交易委托成功", `"}`)
			return
		}
	}
}