4130 lines
273 KiB
C#
4130 lines
273 KiB
C#
using BitgetApi.Data;
|
|
using BitgetAPI.Data;
|
|
using BitgetAPI.IndicatorConditionSetup;
|
|
using BitgetAPI.WebService;
|
|
using DevExpress.Internal.WinApi.Windows.UI.Notifications;
|
|
using DevExpress.Utils.DirectXPaint;
|
|
using DevExpress.Utils.Filtering.Internal;
|
|
using DevExpress.Utils.IoC;
|
|
using DevExpress.Xpo.Logger;
|
|
using DevExpress.XtraPrinting.Native;
|
|
using Newtonsoft.Json;
|
|
using Serilog;
|
|
using Serilog.Debugging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static BitgetAPI.CommonProperty;
|
|
|
|
using static DevExpress.Utils.Drawing.Helpers.NativeMethods;
|
|
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;
|
|
|
|
namespace BitgetAPI.IndicatorConditionSetup
|
|
{
|
|
public class IndicatorProcess
|
|
{
|
|
GlobalOptions options = GlobalOptions.Instance;
|
|
CommonProperty commonProperty = CommonProperty.Instance;
|
|
|
|
//영호 Key
|
|
private string YHKIM_AccessKey
|
|
{
|
|
get
|
|
{
|
|
return options.SelectAPI.AccessKey;
|
|
}
|
|
}
|
|
// = "bg_f93aa530288b6ec9d62095994c51972a";
|
|
private string YHKIM_SecreteKey
|
|
{
|
|
get
|
|
{
|
|
return options.SelectAPI.SecretKey;
|
|
}
|
|
}// = "2fce18bcd12ca23a7920c48295a58da031443ea383af8114ed599c1b14ac678e";
|
|
private string YHKIM_PassphraseKey
|
|
{
|
|
get
|
|
{
|
|
return options.SelectAPI.PassphraseKey;
|
|
}
|
|
}// = "dudgh0505";
|
|
|
|
private double YHKIM_Leverage
|
|
{
|
|
get
|
|
{
|
|
return options.Leverage;
|
|
}
|
|
}
|
|
|
|
private double YHKIM_OrderAmount
|
|
{
|
|
get
|
|
{
|
|
return options.OrderAmount;
|
|
}
|
|
}
|
|
|
|
|
|
// 스레드 시작/종료 플래그
|
|
public bool Is_th_SignalInfo;
|
|
public Dictionary<string, Dictionary<string, double>> 전저고점 = new Dictionary<string, Dictionary<string, double>>();
|
|
|
|
public List<object> checkedMarkets;
|
|
public List<object> intervalList;
|
|
|
|
// 신호검색 리스트 작성
|
|
// 신호 Long 상승 (구매)
|
|
public List<SignalInfoData> signals_LU = null;
|
|
// 신호 Short 하락 (구매)
|
|
public List<SignalInfoData> signals_SD = null;
|
|
// 검색현황 Long 하락 (판매)
|
|
public List<SignalInfoData> signals_LD = null;
|
|
// 검색현황 Short 상승 (판매)
|
|
public List<SignalInfoData> signals_SU = null;
|
|
|
|
public TimeSpan sesstionTime;
|
|
|
|
// 조건식 설정 상태
|
|
public bool checked구름떼상향돌파 = false;
|
|
public bool checked구름떼하향돌파 = false;
|
|
public bool 영호조건식_상향돌파 = false;
|
|
public bool 영호조건식_하향돌파 = false;
|
|
|
|
//구매 리스트
|
|
public Dictionary<string, Dictionary<string, object>> UpBuyList = new Dictionary<string, Dictionary<string, object>>();
|
|
//결과 리스트
|
|
public List<Dictionary<string, object>> UpResultList = new List<Dictionary<string, object>>();
|
|
|
|
//구매 리스트
|
|
public Dictionary<string, Dictionary<string, object>> DownBuyList = new Dictionary<string, Dictionary<string, object>>();
|
|
//결과 리스트
|
|
public List<Dictionary<string, object>> DownResultList = new List<Dictionary<string, object>>();
|
|
|
|
public Dictionary<string, bool> UpList = new Dictionary<string, bool>();
|
|
public Dictionary<string, double> UpBuyValue = new Dictionary<string, double>();
|
|
|
|
public Dictionary<string, bool> DownList = new Dictionary<string, bool>();
|
|
public Dictionary<string, double> DownBuyValue = new Dictionary<string, double>();
|
|
|
|
public int LongCount = 0;
|
|
public int ShortCount = 0;
|
|
|
|
public List<Dictionary<string, object>> BuyLongList = new List<Dictionary<string, object>>();
|
|
public List<Dictionary<string, object>> BuyShortList = new List<Dictionary<string, object>>();
|
|
public List<Dictionary<string, object>> ResultList = new List<Dictionary<string, object>>();
|
|
|
|
public Dictionary<string, Dictionary<int, bool>> SellShortStep = new Dictionary<string, Dictionary<int, bool>>();
|
|
public Dictionary<string, Dictionary<int, bool>> SellLongStep = new Dictionary<string, Dictionary<int, bool>>();
|
|
|
|
public Dictionary<string, bool> BuyShortStep = new Dictionary<string, bool>();
|
|
public Dictionary<string, bool> BuyLongStep = new Dictionary<string, bool>();
|
|
|
|
|
|
public int 전가Flag = 1;
|
|
|
|
|
|
// 전봉이 구름떼 돌파후 시가가 구름떼 위에서 시작하는 것
|
|
// 전봉이 구름떼 하락후 시가가 구름떼 밑에서 시작하는 것
|
|
|
|
public void calProcess()
|
|
{
|
|
|
|
IchimokuConditionSetup ichimokuConditionSetup = new IchimokuConditionSetup();
|
|
MovingAverageConditionSetup movingAverageConditionSetup = new MovingAverageConditionSetup();
|
|
|
|
signals_LU.Clear();
|
|
signals_SD.Clear();
|
|
signals_LD.Clear();
|
|
signals_SU.Clear();
|
|
|
|
//시작시 한번만 하면됨(양방향)
|
|
ChangeFuturePositionMode(FuturePositionMode.hedge_mode);
|
|
//GetFutureAccountList();
|
|
//order 로직
|
|
//var orderDatas = FutureOrder("XRPUSDT", FutureMarginMode.isolated, 10, (double)0.549, FutureSide.BuyShort, OrderType.limit, 10);
|
|
|
|
//var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
//var orderValue = new Dictionary<string, object>();
|
|
//orderValue.Add("orderId", orderDic["orderId"]);
|
|
|
|
//var sellData = FutureOrder("XRPUSDT", FutureMarginMode.isolated, 10, 0, FutureSide.SellShort, OrderType.market, 10, orderDic["orderId"]);
|
|
|
|
|
|
|
|
// 추후 공통화 및 소스정리 필요
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
if (!Is_th_SignalInfo) break;
|
|
//Thread.Sleep(200);
|
|
var nowTime = DateTime.Now;
|
|
|
|
// 특정 시간 이후 삭제
|
|
foreach (var item in signals_LU.ToList())
|
|
{
|
|
// 시간 지나면 삭제
|
|
if (item.SignalStart + sesstionTime < nowTime)
|
|
{
|
|
signals_LU.Remove(item);
|
|
continue;
|
|
|
|
}
|
|
|
|
var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == item.MarketName);
|
|
var lastCandleData = findedMarket.candleDataList[item.MCandleTimeType].OrderBy(i => i.Argument).ToList().Last();
|
|
|
|
if (lastCandleData.IchimokData != null)
|
|
{
|
|
if (checked구름떼상향돌파 || 영호조건식_상향돌파)
|
|
{
|
|
item.Price = lastCandleData.Close;
|
|
item.Rate = (lastCandleData.Close / lastCandleData.Open) * 100 - 100;
|
|
item.IndicatorRate = (lastCandleData.Close / item.IndicatorPrice) * 100 - 100;
|
|
}
|
|
}
|
|
}
|
|
foreach (var item in signals_SD.ToList())
|
|
{
|
|
// 시간 지나면 삭제
|
|
if (item.SignalStart + sesstionTime < nowTime)
|
|
{
|
|
signals_SD.Remove(item);
|
|
continue;
|
|
|
|
}
|
|
|
|
var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == item.MarketName);
|
|
var candleDataList = findedMarket.candleDataList[item.MCandleTimeType].OrderBy(i => i.Argument).ToList();
|
|
if (candleDataList != null && candleDataList.Count > 0)
|
|
{
|
|
var lastCandleData = candleDataList.Last();
|
|
if (lastCandleData.IchimokData != null)
|
|
{
|
|
if (checked구름떼하향돌파 || 영호조건식_하향돌파)
|
|
{
|
|
item.Price = lastCandleData.Close;
|
|
item.Rate = (lastCandleData.Close / lastCandleData.Open) * 100 - 100;
|
|
item.IndicatorRate = (lastCandleData.Close / item.IndicatorPrice) * 100 - 100;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
foreach (var item in signals_LD.ToList())
|
|
if (item.SignalStart + sesstionTime < nowTime) signals_SU.Remove(item);
|
|
foreach (var item in signals_SU.ToList())
|
|
if (item.SignalStart + sesstionTime < nowTime) signals_SD.Remove(item);
|
|
|
|
// 체크된 마켓 정보
|
|
foreach (string market in checkedMarkets)
|
|
{
|
|
var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == market);
|
|
var enumList = Enum.GetValues(typeof(CommonProperty.MCandleTimeType));
|
|
Array.Reverse(enumList);
|
|
|
|
foreach (CommonProperty.MCandleTimeType interval in enumList)
|
|
{
|
|
// Description
|
|
var strInterval = Utils.Convertor.GetEnumDescription((Enum)interval);
|
|
if (!intervalList.Contains(strInterval)) continue;
|
|
|
|
if (!전저고점.ContainsKey(market + strInterval))
|
|
{
|
|
var dic = new Dictionary<string, double>();
|
|
dic.Add("전고가", 0);
|
|
dic.Add("전저가", 0);
|
|
dic.Add("전전고가", 0);
|
|
dic.Add("전전저가", 0);
|
|
dic.Add("전전전저가", 0);
|
|
dic.Add("전전전고가", 0);
|
|
dic.Add("전전전전저가", 0);
|
|
dic.Add("전전전전고가", 0);
|
|
dic.Add("tempHighVal", 0);
|
|
dic.Add("tempLowVal", 0);
|
|
dic.Add("tempHigh2Val", 0);
|
|
dic.Add("tempLow2Val", 0);
|
|
dic.Add("switchLowVal", 0);
|
|
dic.Add("switchHighVal", 0);
|
|
전저고점.Add(market + strInterval, dic);
|
|
}
|
|
if (!BuyShortStep.ContainsKey(market + strInterval)) {
|
|
BuyShortStep[market + strInterval] = false;
|
|
BuyLongStep[market + strInterval] = false;
|
|
}
|
|
#region Main 처리
|
|
// 시간별로 정렬하기 (임시 리스트)
|
|
var candleDatas = findedMarket.candleDataList[MCandleTimeType.M1];
|
|
var candleDatas_정렬 = candleDatas.OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
if (candleData == null) continue;
|
|
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData);
|
|
|
|
candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
|
|
var candleData_전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
if (candleData_전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData_전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전봉);
|
|
|
|
candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
|
|
var candleData_전전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
if (candleData_전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData_전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전전봉);
|
|
|
|
candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
|
|
var candleData_전전전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
if (candleData_전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData_전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전전전봉);
|
|
|
|
|
|
candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
|
|
var candleData_전전전전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
if (candleData_전전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData_전전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전전전전봉);
|
|
#endregion
|
|
|
|
#region 5분봉 처리
|
|
// 시간별로 정렬하기 (임시 리스트)
|
|
var candleDatas_5 = findedMarket.candleDataList[MCandleTimeType.M5];
|
|
var candleDatas_5_정렬 = candleDatas_5.OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData_5 = candleDatas_5.Find(i => i.Argument == candleDatas_5_정렬.Last().Argument);
|
|
|
|
if (candleData_5 == null) continue;
|
|
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_5_정렬, candleData_5);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_5_정렬, candleData_5);
|
|
|
|
candleDatas_5_정렬.RemoveAt(candleDatas_5_정렬.Count - 1);
|
|
var candleData_5_전봉 = candleDatas_5.Find(i => i.Argument == candleDatas_5_정렬.Last().Argument);
|
|
|
|
if (candleData_5_전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_5_정렬, candleData_5_전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_5_정렬, candleData_5_전봉);
|
|
|
|
candleDatas_5_정렬.RemoveAt(candleDatas_5_정렬.Count - 1);
|
|
var candleData_5_전전봉 = candleDatas_5.Find(i => i.Argument == candleDatas_5_정렬.Last().Argument);
|
|
|
|
if (candleData_5_전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_5_정렬, candleData_5_전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_5_정렬, candleData_5_전전봉);
|
|
|
|
candleDatas_5_정렬.RemoveAt(candleDatas_5_정렬.Count - 1);
|
|
var candleData_5_전전전봉 = candleDatas_5.Find(i => i.Argument == candleDatas_5_정렬.Last().Argument);
|
|
|
|
if (candleData_5_전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_5_정렬, candleData_5_전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_5_정렬, candleData_5_전전전봉);
|
|
|
|
|
|
candleDatas_5_정렬.RemoveAt(candleDatas_5_정렬.Count - 1);
|
|
var candleData_5_전전전전봉 = candleDatas_5.Find(i => i.Argument == candleDatas_5_정렬.Last().Argument);
|
|
|
|
if (candleData_5_전전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_5_정렬, candleData_5_전전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_5_정렬, candleData_5_전전전전봉);
|
|
#endregion
|
|
|
|
#region 30분봉 처리
|
|
// 시간별로 정렬하기 (임시 리스트)
|
|
var candleDatas_30 = findedMarket.candleDataList[MCandleTimeType.M30];
|
|
var candleDatas_30_정렬 = candleDatas_30.OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData_30 = candleDatas_30.Find(i => i.Argument == candleDatas_30_정렬.Last().Argument);
|
|
|
|
if (candleData_30 == null) continue;
|
|
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_30_정렬, candleData_30);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_30_정렬, candleData_30);
|
|
|
|
candleDatas_30_정렬.RemoveAt(candleDatas_30_정렬.Count - 1);
|
|
var candleData_30_전봉 = candleDatas_30.Find(i => i.Argument == candleDatas_30_정렬.Last().Argument);
|
|
|
|
if (candleData_30_전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_30_정렬, candleData_30_전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_30_정렬, candleData_30_전봉);
|
|
|
|
candleDatas_30_정렬.RemoveAt(candleDatas_30_정렬.Count - 1);
|
|
var candleData_30_전전봉 = candleDatas_30.Find(i => i.Argument == candleDatas_30_정렬.Last().Argument);
|
|
|
|
if (candleData_30_전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_30_정렬, candleData_30_전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_30_정렬, candleData_30_전전봉);
|
|
|
|
candleDatas_30_정렬.RemoveAt(candleDatas_30_정렬.Count - 1);
|
|
var candleData_30_전전전봉 = candleDatas_30.Find(i => i.Argument == candleDatas_30_정렬.Last().Argument);
|
|
|
|
if (candleData_30_전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_30_정렬, candleData_30_전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_30_정렬, candleData_30_전전전봉);
|
|
|
|
|
|
candleDatas_30_정렬.RemoveAt(candleDatas_30_정렬.Count - 1);
|
|
var candleData_30_전전전전봉 = candleDatas_30.Find(i => i.Argument == candleDatas_30_정렬.Last().Argument);
|
|
|
|
if (candleData_30_전전전전봉 == null) continue;
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas_30_정렬, candleData_30_전전전전봉);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_30_정렬, candleData_30_전전전전봉);
|
|
#endregion
|
|
|
|
if (checked구름떼상향돌파 && candleData_전봉.Open < candleData_전봉.IchimokData.상한선 && candleData.Open > candleData.IchimokData.상한선 && candleData.Low > candleData.IchimokData.상한선
|
|
&& candleData.Close > candleData.IchimokData.상한선)
|
|
{
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 구름떼 상승", strInterval);
|
|
var signalData = signals_LU.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_LU.Add(signalInfoData);
|
|
}
|
|
|
|
}
|
|
else if (checked구름떼상향돌파 && candleData_전봉.Open > candleData_전봉.IchimokData.하한선 && candleData.Open < candleData.IchimokData.하한선 && candleData.High < candleData.IchimokData.하한선
|
|
&& candleData.Close < candleData.IchimokData.하한선)
|
|
{
|
|
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 구름떼 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
|
|
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
}
|
|
|
|
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
|
|
{
|
|
|
|
#region Main 봉 계산
|
|
|
|
var 전전전봉3 = candleData_전전전봉.movingAverageDataList[3].Value;
|
|
var 전전전봉4 = candleData_전전전봉.movingAverageDataList[4].Value;
|
|
var 전전전봉8 = candleData_전전전봉.movingAverageDataList[8].Value;
|
|
var 전전전봉12 = candleData_전전전봉.movingAverageDataList[12].Value;
|
|
var 전전전봉24 = candleData_전전전봉.movingAverageDataList[24].Value;
|
|
var 전전전봉36 = candleData_전전전봉.movingAverageDataList[36].Value;
|
|
var 전전전봉72 = candleData_전전전봉.movingAverageDataList[72].Value;
|
|
var 전전전봉40 = candleData_전전전봉.movingAverageDataList[40].Value;
|
|
|
|
var 전전전전봉4 = candleData_전전전전봉.movingAverageDataList[4].Value;
|
|
|
|
var 전전봉3 = candleData_전전봉.movingAverageDataList[3].Value;
|
|
var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
|
|
var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
|
|
var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
|
|
var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
|
|
var 전전봉36 = candleData_전전봉.movingAverageDataList[36].Value;
|
|
var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;
|
|
|
|
var 전전봉144 = candleData_전전봉.movingAverageDataList[144].Value;
|
|
var 전전봉20 = candleData_전전봉.movingAverageDataList[20].Value;
|
|
var 전전봉40 = candleData_전전봉.movingAverageDataList[40].Value;
|
|
var 전전봉120 = candleData_전전봉.movingAverageDataList[120].Value;
|
|
var 전전봉160 = candleData_전전봉.movingAverageDataList[160].Value;
|
|
var 전전봉240 = candleData_전전봉.movingAverageDataList[240].Value;
|
|
var 전전봉80 = candleData_전전봉.movingAverageDataList[80].Value;
|
|
var 전전봉480 = candleData_전전봉.movingAverageDataList[480].Value;
|
|
|
|
|
|
var 전봉3 = candleData_전봉.movingAverageDataList[3].Value;
|
|
var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
|
|
var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
|
|
var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
|
|
var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
|
|
var 전봉36 = candleData_전봉.movingAverageDataList[36].Value;
|
|
var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
|
|
var 전봉144 = candleData_전봉.movingAverageDataList[144].Value;
|
|
|
|
var 전봉20 = candleData_전봉.movingAverageDataList[20].Value;
|
|
var 전봉40 = candleData_전봉.movingAverageDataList[40].Value;
|
|
var 전봉80 = candleData_전봉.movingAverageDataList[80].Value;
|
|
var 전봉120 = candleData_전봉.movingAverageDataList[120].Value;
|
|
var 전봉160 = candleData_전봉.movingAverageDataList[160].Value;
|
|
var 전봉240 = candleData_전봉.movingAverageDataList[240].Value;
|
|
var 전봉480 = candleData_전봉.movingAverageDataList[480].Value;
|
|
|
|
var 현재봉3 = candleData.movingAverageDataList[3].Value;
|
|
var 현재봉4 = candleData.movingAverageDataList[4].Value;
|
|
var 현재봉8 = candleData.movingAverageDataList[8].Value;
|
|
var 현재봉12 = candleData.movingAverageDataList[12].Value;
|
|
var 현재봉24 = candleData.movingAverageDataList[24].Value;
|
|
var 현재봉36 = candleData.movingAverageDataList[36].Value;
|
|
var 현재봉20 = candleData.movingAverageDataList[20].Value;
|
|
var 현재봉40 = candleData.movingAverageDataList[40].Value;
|
|
var 현재봉48 = candleData.movingAverageDataList[48].Value;
|
|
var 현재봉72 = candleData.movingAverageDataList[72].Value;
|
|
var 현재봉120 = candleData.movingAverageDataList[120].Value;
|
|
var 현재봉144 = candleData.movingAverageDataList[144].Value;
|
|
var 현재봉240 = candleData.movingAverageDataList[240].Value;
|
|
var 현재봉160 = candleData.movingAverageDataList[160].Value;
|
|
var 현재봉80 = candleData.movingAverageDataList[80].Value;
|
|
|
|
var 전봉Bol4_Down = candleData_전봉.movingAverageDataList[4].BolangerValue_Down;
|
|
var 전봉Bol12_Down = candleData_전봉.movingAverageDataList[12].BolangerValue_Down;
|
|
var 전봉Bol24_Down = candleData_전봉.movingAverageDataList[24].BolangerValue_Down;
|
|
var 전봉Bol72_Down = candleData_전봉.movingAverageDataList[72].BolangerValue_Down;
|
|
|
|
var 전전봉Bol4_Down = candleData_전전봉.movingAverageDataList[4].BolangerValue_Down;
|
|
var 전전봉Bol12_Down = candleData_전전봉.movingAverageDataList[12].BolangerValue_Down;
|
|
var 전전봉Bol24_Down = candleData_전전봉.movingAverageDataList[24].BolangerValue_Down;
|
|
var 전전봉Bol72_Down = candleData_전전봉.movingAverageDataList[72].BolangerValue_Down;
|
|
|
|
var Bol4_Down = candleData.movingAverageDataList[4].BolangerValue_Down;
|
|
var Bol12_Down = candleData.movingAverageDataList[12].BolangerValue_Down;
|
|
var Bol24_Down = candleData.movingAverageDataList[24].BolangerValue_Down;
|
|
var Bol72_Down = candleData.movingAverageDataList[72].BolangerValue_Down;
|
|
|
|
var 전봉Bol4_Up = candleData_전봉.movingAverageDataList[4].BolangerValue_Up;
|
|
var 전봉Bol12_Up = candleData_전봉.movingAverageDataList[12].BolangerValue_Up;
|
|
var 전봉Bol24_Up = candleData_전봉.movingAverageDataList[24].BolangerValue_Up;
|
|
var 전봉Bol72_Up = candleData_전봉.movingAverageDataList[72].BolangerValue_Up;
|
|
|
|
var 전전봉Bol4_Up = candleData_전전봉.movingAverageDataList[4].BolangerValue_Up;
|
|
var 전전봉Bol12_Up = candleData_전전봉.movingAverageDataList[12].BolangerValue_Up;
|
|
var 전전봉Bol24_Up = candleData_전전봉.movingAverageDataList[24].BolangerValue_Up;
|
|
var 전전봉Bol72_Up = candleData_전전봉.movingAverageDataList[72].BolangerValue_Up;
|
|
|
|
var Bol4_Up = candleData.movingAverageDataList[4].BolangerValue_Up;
|
|
var Bol12_Up = candleData.movingAverageDataList[12].BolangerValue_Up;
|
|
var Bol24_Up = candleData.movingAverageDataList[24].BolangerValue_Up;
|
|
var Bol72_Up = candleData.movingAverageDataList[72].BolangerValue_Up;
|
|
#endregion
|
|
|
|
var 현재봉3_5 = candleData_5.movingAverageDataList[3].Value;
|
|
var 전봉3_5 = candleData_5_전봉.movingAverageDataList[3].Value;
|
|
var 전전봉3_5 = candleData_5_전전봉.movingAverageDataList[3].Value;
|
|
var 전전전봉3_5 = candleData_5_전전전봉.movingAverageDataList[3].Value;
|
|
|
|
var 현재봉3_30 = candleData_5.movingAverageDataList[3].Value;
|
|
var 전봉3_30 = candleData_30_전봉.movingAverageDataList[3].Value;
|
|
var 전전봉3_30 = candleData_30_전전봉.movingAverageDataList[3].Value;
|
|
var 전전전봉3_30 = candleData_30_전전전봉.movingAverageDataList[3].Value;
|
|
|
|
if (!(전저고점.ContainsKey(market + "1m") && 전저고점.ContainsKey(market + "5m") && 전저고점.ContainsKey(market + "30m")))
|
|
continue;
|
|
|
|
var 저고점_1 = 전저고점[market + "1m"];
|
|
var 저고점_5 = 전저고점[market + "5m"];
|
|
var 저고점_30 = 전저고점[market + "30m"];
|
|
|
|
var returnVal = Calculate전고점(market, "1m", MCandleTimeType.M1, 전봉3, 전전봉3, 전전전봉3, candleData);
|
|
if (!returnVal) continue;
|
|
|
|
returnVal = Calculate전고점(market, "5m", MCandleTimeType.M5, 전봉3_5, 전전봉3_5, 전전전봉3_5, candleData_5);
|
|
if (!returnVal) continue;
|
|
returnVal = Calculate전고점(market, "30m", MCandleTimeType.M30, 전봉3_30, 전전봉3_30, 전전전봉3_30, candleData_30);
|
|
if (!returnVal) continue;
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
//전 저점 계산
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
if ((int)interval != 1)
|
|
{
|
|
continue;
|
|
}
|
|
var buyFlag = false;
|
|
|
|
// 30분봉
|
|
var flag_30 = (저고점_30["전전전저가"] > 저고점_30["전전저가"] && 저고점_30["전전저가"] < 저고점_30["전저가"] && 현재봉3_30 > 저고점_30["전저가"])
|
|
|| (저고점_30["전전저가"] > 저고점_30["전저가"] && candleData_30.High > 저고점_30["전고가"]);
|
|
|
|
var flag_5 = (저고점_5["전전전저가"] > 저고점_5["전전저가"] && 저고점_5["전전저가"] < 저고점_5["전저가"] && candleData_5.High > 저고점_5["전고가"])
|
|
|| (저고점_5["전전저가"] > 저고점_5["전저가"] && candleData_5.High > 저고점_5["전고가"]);
|
|
|
|
var flag_1 = 현재봉3 > 현재봉24 && 현재봉3 > 현재봉48 && 현재봉3 > 현재봉72 && 현재봉3 > 현재봉120;
|
|
|
|
if (flag_30 && flag_5 && flag_1) {
|
|
buyFlag = true;
|
|
}
|
|
|
|
|
|
if (buyFlag)
|
|
{
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellLongStep.Add(market + interval, dic);
|
|
if (LongCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
if ((int)interval != 30)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var buyItem = UpBuyList[market + interval];
|
|
var flag = (bool)buyItem["Flag"];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
var sellFlag = false;
|
|
if (저고점_30["전저가"] > 현재봉3)
|
|
sellFlag = true;
|
|
|
|
|
|
if (sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
BuyLongStep[market + interval] = false;
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
if ((int)interval != 1)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var buyFlag = false;
|
|
|
|
var flag_30 = (저고점_30["전전전고가"] < 저고점_30["전전고가"] && 저고점_30["전전고가"] > 저고점_30["전고가"] && 현재봉3_30 < 저고점_30["전고가"])
|
|
|| (저고점_30["전전고가"] < 저고점_30["전고가"] && candleData_30.Low < 저고점_30["전저가"]);
|
|
|
|
var flag_5 = (저고점_5["전전전고가"] < 저고점_5["전전고가"] && 저고점_5["전전고가"] > 저고점_5["전고가"] && candleData_5.Low < 저고점_5["전저가"])
|
|
|| (저고점_5["전전고가"] < 저고점_5["전고가"] && candleData_5.Low < 저고점_5["전저가"]);
|
|
|
|
var flag_1 = 현재봉3 < 현재봉24 && 현재봉3 < 현재봉48 && 현재봉3 < 현재봉72 && 현재봉3 < 현재봉120;
|
|
|
|
if (flag_30 && flag_5 && flag_1)
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
|
|
if (buyFlag)
|
|
{
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellShortStep.Add(market + interval, dic);
|
|
|
|
if (ShortCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
if ((int)interval != 30)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var sellFlag = false;
|
|
var buyItem = DownBuyList[market + interval];
|
|
var flag = (bool)buyItem["Flag"];
|
|
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
if (저고점_30["전고가"] < 현재봉3)
|
|
sellFlag = true;
|
|
|
|
if (sellFlag)
|
|
{
|
|
BuyShortStep[market + interval] = false;
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
SellShortStep.Remove(market + interval);
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool Calculate전고점(string market, string strInterval, MCandleTimeType type, double 전봉3, double 전전봉3, double 전전전봉3, CandleData candleData)
|
|
{
|
|
|
|
var 저고점 = 전저고점[market + strInterval];
|
|
|
|
//전저가
|
|
if (전봉3 > 전전봉3 && 전전봉3 < 전전전봉3 &&
|
|
저고점["tempLowVal"] != candleData.Argument.Hour * 60 + candleData.Argument.Minute &&
|
|
(candleData.Argument.Hour * 60 + candleData.Argument.Minute) - 저고점["tempHighVal"] > 2 * (int)type)
|
|
{
|
|
저고점["tempLow2Val"] = 저고점["tempLowVal"];
|
|
저고점["tempLowVal"] = candleData.Argument.Hour * 60 + candleData.Argument.Minute;
|
|
저고점["switchLowVal"] = 저고점["전전전전저가"];
|
|
저고점["전전전전저가"] = 저고점["전전저가"];
|
|
저고점["전전전저가"] = 저고점["전전저가"];
|
|
저고점["전전저가"] = 저고점["전저가"];
|
|
저고점["전저가"] = 전전봉3;
|
|
|
|
}
|
|
else if (전봉3 > 전전봉3 && 전전봉3 < 전전전봉3 &&
|
|
저고점["tempLowVal"] != candleData.Argument.Hour * 60 + candleData.Argument.Minute &&
|
|
(candleData.Argument.Hour * 60 + candleData.Argument.Minute) - 저고점["tempHighVal"] <= 2 * (int)type)
|
|
{
|
|
//이전으로 초기화 작업(High)
|
|
저고점["전고가"] = 저고점["전전고가"];
|
|
저고점["전전고가"] = 저고점["전전전고가"];
|
|
저고점["전전전고가"] = 저고점["전전전전고가"];
|
|
저고점["전전전전고가"] = 저고점["switchLowVal"];
|
|
저고점["tempHighVal"] = 저고점["tempHigh2Val"];
|
|
|
|
if (저고점["전저가"] > 전전봉3)
|
|
저고점["전저가"] = 전전봉3;
|
|
}
|
|
|
|
//전고가
|
|
if (전전봉3 > 전봉3 && 전전봉3 > 전전전봉3 &&
|
|
저고점["tempHighVal"] != candleData.Argument.Hour * 60 + candleData.Argument.Minute &&
|
|
(candleData.Argument.Hour * 60 + candleData.Argument.Minute) - 저고점["tempLowVal"] > 2 * (int)type)
|
|
{
|
|
저고점["tempHigh2Val"] = 저고점["tempHighVal"];
|
|
저고점["tempHighVal"] = candleData.Argument.Hour * 60 + candleData.Argument.Minute;
|
|
저고점["switchHighVal"] = 저고점["전전전전고가"];
|
|
저고점["전전전전고가"] = 저고점["전전전고가"];
|
|
저고점["전전전고가"] = 저고점["전전고가"];
|
|
저고점["전전고가"] = 저고점["전고가"];
|
|
저고점["전고가"] = 전전봉3;
|
|
}
|
|
else if (전전봉3 > 전봉3 && 전전봉3 > 전전전봉3 &&
|
|
저고점["tempHighVal"] != candleData.Argument.Hour * 60 + candleData.Argument.Minute &&
|
|
(candleData.Argument.Hour * 60 + candleData.Argument.Minute) - 저고점["tempLowVal"] < 2 * (int)type)
|
|
{
|
|
//이전으로 초기화 작업(Low)
|
|
저고점["전저가"] = 저고점["전전저가"];
|
|
저고점["전전저가"] = 저고점["전전전저가"];
|
|
저고점["전전전저가"] = 저고점["전전전전저가"];
|
|
저고점["전전전전저가"] = 저고점["switchHighVal"];
|
|
저고점["tempLowVal"] = 저고점["tempLow2Val"];
|
|
|
|
if (저고점["전고가"] < 전전봉3)
|
|
저고점["전고가"] = 전전봉3;
|
|
}
|
|
|
|
전저고점[market + strInterval] = 저고점;
|
|
|
|
if (저고점["전전전저가"] == 0 || 저고점["전전전고가"] == 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public Dictionary<string, object> GetPendingOrders()
|
|
{
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
var reqStr = "/api/v2/mix/order/orders-pending";
|
|
|
|
var nvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "GET", reqStr, "productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP",timestamp}
|
|
};
|
|
|
|
return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetPendingOrder_Future, BitgetURL_PendingOrders_Future, null, MCandleTimeType.M1, "", "", nvc);
|
|
}
|
|
|
|
public long GetTimeStamp()
|
|
{
|
|
|
|
var result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetGetTimeStamp, BitgetURL_GetTimestamp, null, MCandleTimeType.M1, "", "", null);
|
|
if (result == null)
|
|
{
|
|
return 0;
|
|
}
|
|
var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(JsonConvert.SerializeObject(result["data"]));
|
|
long.TryParse(data["serverTime"].ToString(), out var returnData);
|
|
return returnData;
|
|
}
|
|
|
|
|
|
public List<Dictionary<string, object>> GetFutureAccountList()
|
|
{
|
|
|
|
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
var reqStr = "/api/v2/mix/account/accounts";
|
|
|
|
var nvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "GET", reqStr, "productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP",timestamp}
|
|
};
|
|
|
|
return (List<Dictionary<string, object>>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetAccountList_Future, BitgetURL_AccountList_Future, null, MCandleTimeType.M1, "", "", nvc);
|
|
}
|
|
|
|
public Dictionary<string, object> CancelFutureOrder(string symbol, string orderId)
|
|
{
|
|
|
|
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
var reqStr = "/api/v2/mix/order/cancel-order";
|
|
var postStr = "{\"symbol\" : \"" + symbol + "\", \"orderId\" : \"" + orderId + "\", \"productType\" : \"usdt-futures\" , \"marginCoin\" : \"USDT\"}";
|
|
var nvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP", timestamp}
|
|
};
|
|
|
|
return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetCancelOrder_Future, BitgetURL_CancelOrder_Future, null, MCandleTimeType.M1, postStr, "", nvc);
|
|
}
|
|
|
|
public Dictionary<string, object> ChangeFuturePositionMode(FuturePositionMode mode)
|
|
{
|
|
|
|
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
var reqStr = "/api/v2/mix/account/set-position-mode";
|
|
var postStr = "{\"productType\" : \"USDT-FUTURES\", \"posMode\" : \"" + Utils.Convertor.GetEnumDescription((Enum)mode) + "\"}";
|
|
|
|
var nvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP", timestamp}
|
|
};
|
|
|
|
return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangePositionMode_Future, BitgetURL_ChangePositionMode_Future, null, MCandleTimeType.M1, postStr, "", nvc);
|
|
}
|
|
|
|
public Dictionary<string, object> GetFutureOrderDetail(string symbol, string orderId)
|
|
{
|
|
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
// sell은 ClientOID 가 필요
|
|
var orderDetailStr = "/api/v2/mix/order/detail";
|
|
timestamp = GetTimeStamp().ToString();
|
|
var orderDetailnvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "GET", orderDetailStr, "symbol="+symbol.ToString()+"&orderId="+orderId.ToString()+"&productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP",timestamp}
|
|
};
|
|
|
|
return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetOrderDetail_Future, BitgetURL_OrderDetail_Future + "?symbol=" + symbol.ToString() + "&orderId=" + orderId.ToString() + "&productType=USDT-FUTURES", null, MCandleTimeType.M1, "", "", orderDetailnvc);
|
|
|
|
}
|
|
|
|
|
|
public Dictionary<string, object> FutureOrder(string symbol, FutureMarginMode marginMode, double size, double price, FutureSide futureSide, OrderType orderType, double leverage, string id = "")
|
|
{
|
|
var side = "";
|
|
var tradeSide = "";
|
|
|
|
if (futureSide == FutureSide.BuyShort)
|
|
{
|
|
id = Guid.NewGuid().ToString();
|
|
side = "sell";
|
|
tradeSide = "open";
|
|
}
|
|
else if (futureSide == FutureSide.BuyLong)
|
|
{
|
|
id = Guid.NewGuid().ToString();
|
|
side = "buy";
|
|
tradeSide = "Open";
|
|
}
|
|
else if (futureSide == FutureSide.SellShort)
|
|
{
|
|
side = "sell";
|
|
tradeSide = "close";
|
|
}
|
|
else if (futureSide == FutureSide.SellLong)
|
|
{
|
|
side = "buy";
|
|
tradeSide = "close";
|
|
}
|
|
|
|
if (orderType == OrderType.market)
|
|
price = 0;
|
|
|
|
|
|
|
|
var timestamp = GetTimeStamp().ToString();
|
|
|
|
var reqStr = "/api/v2/mix/order/place-order";
|
|
|
|
if (futureSide == FutureSide.BuyShort || futureSide == FutureSide.BuyLong)
|
|
{
|
|
//change margin mode 이후 leverage 처리 해야 함
|
|
var changeMarginModeStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"usdt-futures\", \"marginCoin\": \"USDT\", \"marginMode\": \"" + Utils.Convertor.GetEnumDescription((Enum)marginMode) + "\"}";
|
|
|
|
var nvcMargin = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "POST", "/api/v2/mix/account/set-margin-mode", "", changeMarginModeStr, YHKIM_SecreteKey)},
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP", timestamp}
|
|
};
|
|
var result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangeMarginMode_Future, BitgetURL_ChangeMarginMode_Future, null, MCandleTimeType.M1, changeMarginModeStr, "", nvcMargin);
|
|
if (result == null || result["msg"]?.ToString() != "success")
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var leverageStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"USDT-FUTURES\", \"marginCoin\": \"USDT\", \"leverage\": \"" + leverage.ToString() + "\", \"holdSide\": \"" + (futureSide == FutureSide.BuyShort ? "short" : "long") + "\"}";
|
|
timestamp = GetTimeStamp().ToString();
|
|
var nvcLeverage = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "POST", "/api/v2/mix/account/set-leverage", "", leverageStr, YHKIM_SecreteKey)},
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP", timestamp}
|
|
};
|
|
result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangeLeverage_Future, BitgetURL_ChangeLeverage_Future, null, MCandleTimeType.M1, leverageStr, "", nvcLeverage);
|
|
if (result == null || result["msg"]?.ToString() != "success")
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var result = CancelFutureOrder(symbol, id);
|
|
if (result == null || result["msg"]?.ToString() != "success")
|
|
{
|
|
Log.Error("Sell에서 Cancel관련 Error");
|
|
}
|
|
}
|
|
|
|
var postStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"usdt-futures\", \"marginMode\": \"" + Utils.Convertor.GetEnumDescription((Enum)marginMode) + "\", \"marginCoin\": \"USDT\", \"size\": \""
|
|
+ size.ToString() + "\", \"price\": \"" + price.ToString() + "\", \"side\": \"" + side + "\", " + "\"tradeSide\": \"" + tradeSide + "\", \"orderType\": \"" + Utils.Convertor.GetEnumDescription((Enum)orderType)
|
|
+ "\", \"force\": \"gtc\", \"clientOid\": \"" + id + "\" }";
|
|
timestamp = GetTimeStamp().ToString();
|
|
var nvc = new NameValueCollection {
|
|
{"ACCESS-KEY", YHKIM_AccessKey},
|
|
{"ACCESS-SIGN", GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
|
|
{"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
|
|
{"ACCESS-TIMESTAMP", timestamp}
|
|
};
|
|
return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetOrder_Future, BitgetURL_BuySellOrder_Future, null, MCandleTimeType.M1, postStr, "", nvc);
|
|
}
|
|
|
|
public string GenerateSignString(string timestamp, string method, string requestPath, string queryString, string body, string secretKey)
|
|
{
|
|
method = method.ToUpper();
|
|
body = body == null ? "" : body;
|
|
queryString = string.IsNullOrWhiteSpace(queryString) ? "" : "?" + queryString;
|
|
string preHash = timestamp + method + requestPath + queryString + body;
|
|
|
|
var encSecretKey_byteData = System.Text.Encoding.UTF8.GetBytes(secretKey);
|
|
var encPreHash_byteData = System.Text.Encoding.UTF8.GetBytes(preHash);
|
|
|
|
return Convert.ToBase64String(new HMACSHA256(encSecretKey_byteData).ComputeHash(encPreHash_byteData));
|
|
}
|
|
|
|
public void calIchimokuProcess_Add()
|
|
{
|
|
|
|
|
|
}
|
|
|
|
public void calIchimokuProcess_Update()
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
|
|
{
|
|
var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
|
|
var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
|
|
var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
|
|
var 전봉48 = candleData_전봉.movingAverageDataList[48].Value;
|
|
var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
|
|
|
|
var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
|
|
var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
|
|
var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
|
|
var 전전봉48 = candleData_전전봉.movingAverageDataList[48].Value;
|
|
var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;
|
|
|
|
var 현재봉4 = candleData.movingAverageDataList[4].Value;
|
|
var 현재봉8 = candleData.movingAverageDataList[8].Value;
|
|
var 현재봉12 = candleData.movingAverageDataList[12].Value;
|
|
var 현재봉24 = candleData.movingAverageDataList[24].Value;
|
|
var 현재봉48 = candleData.movingAverageDataList[48].Value;
|
|
var 현재봉72 = candleData.movingAverageDataList[72].Value;
|
|
|
|
var 전봉Bol4 = candleData_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉Bol12 = candleData_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉Bol24 = candleData_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉Bol4 = candleData_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉Bol12 = candleData_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉Bol24 = candleData_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var Bol4 = candleData.movingAverageDataList[4].BolangerValue;
|
|
var Bol12 = candleData.movingAverageDataList[12].BolangerValue;
|
|
var Bol24 = candleData.movingAverageDataList[24].BolangerValue;
|
|
|
|
if ((int)interval != 1)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
#region 5분봉 처리
|
|
//15분봉이지만 60분봉으로 변경
|
|
//var candleDatas5 = findedMarket.candleDataList[MCandleTimeType.M5].ToList();
|
|
//var candleDatas5_정렬 = candleDatas5.OrderBy(i => i.Argument).ToList();
|
|
|
|
//var candleData5 = candleDatas5.FirstOrDefault(i => i.Argument == candleDatas5_정렬.Last().Argument);
|
|
//if (candleData5 == null) continue;
|
|
//movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas5_정렬, candleData5);
|
|
//ichimokuConditionSetup.calIchimokuData(candleDatas5_정렬, candleData5);
|
|
|
|
|
|
//candleDatas5_정렬.RemoveAt(candleDatas5_정렬.Count - 1);
|
|
//var candleData5_전봉 = candleDatas5.FirstOrDefault(i => i.Argument == candleDatas5_정렬.Last().Argument);
|
|
//movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas5_정렬, candleData5_전봉);
|
|
//ichimokuConditionSetup.calIchimokuData(candleDatas5_정렬, candleData5_전봉);
|
|
|
|
//var 현재봉5_4 = candleData5.movingAverageDataList[4].Value;
|
|
//var 전봉5_4 = candleData5_전봉.movingAverageDataList[4].Value;
|
|
|
|
#endregion
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
if (
|
|
candleData.IchimokData.하한선 > 현재봉4 &&
|
|
candleData_전봉.IchimokData.하한선 > candleData_전봉.Close &&
|
|
candleData_전봉.Open < candleData_전봉.Close &&
|
|
전봉4 > 전봉8 && 전전봉4 < 전전봉8 &&
|
|
전봉8 < 전봉24 && 전봉24 < 전봉48 && 전봉48 < 전봉72 &&
|
|
전전봉8 < 전전봉24 && 전전봉24 < 전전봉48 && 전전봉48 < 전전봉72 &&
|
|
전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4
|
|
) {
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
SellLongStep.Add(market + interval, 8);
|
|
|
|
if (LongCount < 2)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
|
|
if (orderData == null)
|
|
{
|
|
Log.Error("Buy 안됨 확인 필요");
|
|
continue;
|
|
}
|
|
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = UpBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
if ((nowTime.Hour == 0 ? 24 : nowTime.Hour) < ((DateTime)buyItem["BuyDate"]).Hour + ((int)interval / 60))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
var key = SellLongStep[market + interval];
|
|
var sellFlag = false;
|
|
switch (SellLongStep[market + interval])
|
|
{
|
|
case 8:
|
|
if (전봉8 > 전봉24)
|
|
{
|
|
SellLongStep[market + interval] = 24;
|
|
key = 24;
|
|
}
|
|
else
|
|
{
|
|
if (전봉4 < 전전봉4)
|
|
{
|
|
sellFlag = true;
|
|
}
|
|
|
|
else if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval * 2)
|
|
{
|
|
if (전봉4 > candleData_전봉.Close && 전봉4 < 전봉24)
|
|
{
|
|
sellFlag = true;
|
|
}
|
|
}
|
|
|
|
if (현재봉4 < 현재봉8 && candleData.Close < candleData.movingAverageDataList[key].Value) sellFlag = true;
|
|
}
|
|
break;
|
|
case 24:
|
|
if (전봉8 > 전봉48)
|
|
{
|
|
SellLongStep[market + interval] = 48;
|
|
key = 48;
|
|
}
|
|
break;
|
|
case 48:
|
|
key = 8;
|
|
break;
|
|
}
|
|
|
|
|
|
if (candleData.movingAverageDataList[key].Value > 현재봉4 || sellFlag)
|
|
{
|
|
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
if (
|
|
candleData.IchimokData.상한선 < 현재봉4 &&
|
|
candleData_전봉.IchimokData.상한선 < candleData_전봉.Close &&
|
|
candleData_전봉.Open > candleData_전봉.Close &&
|
|
전봉4 < 전봉8 && 전전봉4 > 전전봉8 &&
|
|
전봉8 > 전봉24 && 전봉24 > 전봉48 && 전봉48 > 전봉72 &&
|
|
전전봉8 > 전전봉24 && 전전봉24 > 전전봉48 && 전전봉48 > 전전봉72 &&
|
|
전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4
|
|
)
|
|
{
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
|
|
|
|
if(ShortCount < 2)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
|
|
if (orderData == null) {
|
|
Log.Error("Buy 안됨 확인 필요");
|
|
continue;
|
|
}
|
|
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
SellShortStep.Add(market + interval, 8);
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = DownBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
if ((nowTime.Hour == 0 ? 24 : nowTime.Hour) < ((DateTime)buyItem["BuyDate"]).Hour + ((int)interval / 60))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
var key = SellShortStep[market + interval];
|
|
var sellFlag = false;
|
|
switch (SellShortStep[market + interval])
|
|
{
|
|
case 8:
|
|
if (전봉8 < 전봉24)
|
|
{
|
|
SellShortStep[market + interval] = 24;
|
|
key = 24;
|
|
}
|
|
else
|
|
{
|
|
if (전봉4 > 전전봉4)
|
|
{
|
|
sellFlag = true;
|
|
}
|
|
else if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval * 2)
|
|
{
|
|
if (전봉4 < candleData_전봉.Close && 전봉4 > 전봉24)
|
|
{
|
|
sellFlag = true;
|
|
}
|
|
}
|
|
|
|
if (현재봉4 > 현재봉8 && candleData.Close > candleData.movingAverageDataList[key].Value) sellFlag = true;
|
|
}
|
|
|
|
break;
|
|
case 24:
|
|
if (전봉8 < 전봉48)
|
|
{
|
|
SellShortStep[market + interval] = 48;
|
|
key = 48;
|
|
}
|
|
break;
|
|
case 48:
|
|
key = 8;
|
|
break;
|
|
|
|
}
|
|
|
|
if (candleData.movingAverageDataList[key].Value < 현재봉4 || sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
SellShortStep.Remove(market + interval);
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
*/
|
|
/*
|
|
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
|
|
{
|
|
candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
|
|
var candleData_전전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);
|
|
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전전봉);
|
|
|
|
// 24,72 높은값
|
|
var 높은값_48_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_48_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
|
|
// 24,72 높은값
|
|
var 높은값_48_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_48_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
|
|
|
|
// 24,72 높은값
|
|
var 높은값_48_24 = Math.Max(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_48_24 = Math.Min(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);
|
|
|
|
var 높은값_12_낮은값72_24 = Math.Max(candleData.movingAverageDataList[12].Value, 낮은값_48_24);
|
|
var 낮은값_12_높은값72_24 = Math.Min(candleData.movingAverageDataList[12].Value, 높은값_48_24);
|
|
|
|
var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
|
|
var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
|
|
var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
|
|
var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;
|
|
|
|
var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
|
|
var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
|
|
var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
|
|
var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
|
|
|
|
var 현재봉4 = candleData.movingAverageDataList[4].Value;
|
|
var 현재봉12 = candleData.movingAverageDataList[12].Value;
|
|
var 현재봉24 = candleData.movingAverageDataList[24].Value;
|
|
var 현재봉72 = candleData.movingAverageDataList[72].Value;
|
|
|
|
|
|
var 전봉Bol4 = candleData_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉Bol12 = candleData_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉Bol24 = candleData_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉Bol4 = candleData_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉Bol12 = candleData_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉Bol24 = candleData_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var Bol4 = candleData.movingAverageDataList[4].BolangerValue;
|
|
var Bol12 = candleData.movingAverageDataList[12].BolangerValue;
|
|
var Bol24 = candleData.movingAverageDataList[24].BolangerValue;
|
|
|
|
//5분봉이 default이지만 15분봉으로 변경
|
|
if ((int)interval != 5)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
#region 15분봉 처리
|
|
//15분봉이지만 60분봉으로 변경
|
|
var candleDatas15 = findedMarket.candleDataList[MCandleTimeType.M15];
|
|
var candleDatas15_정렬 = candleDatas15.ToList().OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData15 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
|
|
if (candleData15 == null) continue;
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15);
|
|
|
|
|
|
candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
|
|
var candleData15_전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전봉);
|
|
|
|
candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
|
|
var candleData15_전전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전전봉);
|
|
|
|
candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
|
|
var candleData15_전전전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전전봉);
|
|
|
|
|
|
var 낮은값15_72_24 = Math.Min(candleData15.movingAverageDataList[72].Value, candleData15.movingAverageDataList[24].Value);
|
|
var 높은값15_72_24 = Math.Max(candleData15.movingAverageDataList[72].Value, candleData15.movingAverageDataList[24].Value);
|
|
|
|
var 전봉낮은값15_72_24 = Math.Min(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
|
|
var 전봉높은값15_72_24 = Math.Max(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
|
|
var 전전봉낮은값15_72_24 = Math.Min(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
|
|
var 전전봉높은값15_72_24 = Math.Max(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
|
|
|
|
var 현재봉15_12 = candleData15.movingAverageDataList[12].Value;
|
|
var 전봉15_12 = candleData15_전봉.movingAverageDataList[12].Value;
|
|
var 전전봉15_12 = candleData15_전전봉.movingAverageDataList[12].Value;
|
|
|
|
var 현재봉15_4 = candleData15.movingAverageDataList[4].Value;
|
|
var 전봉15_4 = candleData15_전봉.movingAverageDataList[4].Value;
|
|
var 전전봉15_4 = candleData15_전전봉.movingAverageDataList[4].Value;
|
|
|
|
var 전봉15Bol4 = candleData15_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉15Bol12 = candleData15_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉15Bol24 = candleData15_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉15Bol4 = candleData15_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉15Bol12 = candleData15_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉15Bol24 = candleData15_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var 현재봉15Bol4 = candleData15.movingAverageDataList[4].BolangerValue;
|
|
var 현재봉15Bol12 = candleData15.movingAverageDataList[12].BolangerValue;
|
|
var 현재봉15Bol24 = candleData15.movingAverageDataList[24].BolangerValue;
|
|
#endregion
|
|
|
|
#region 1분봉 처리
|
|
//1분봉이지만 3분봉으로 변경
|
|
var candleDatas1 = findedMarket.candleDataList[MCandleTimeType.M1];
|
|
var candleDatas1_정렬 = candleDatas1.ToList().OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData1 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
|
|
if (candleData1 == null) continue;
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1);
|
|
|
|
candleDatas1_정렬.RemoveAt(candleDatas1_정렬.Count - 1);
|
|
var candleData1_전봉 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1_전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1_전봉);
|
|
|
|
candleDatas1_정렬.RemoveAt(candleDatas1_정렬.Count - 1);
|
|
var candleData1_전전봉 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1_전전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1_전전봉);
|
|
|
|
|
|
var 높은값1_72_24 = Math.Max(candleData1.movingAverageDataList[72].Value, candleData1.movingAverageDataList[24].Value);
|
|
var 낮은값1_72_24 = Math.Min(candleData1.movingAverageDataList[72].Value, candleData1.movingAverageDataList[24].Value);
|
|
|
|
var 전봉낮은값1_72_24 = Math.Min(candleData1_전봉.movingAverageDataList[72].Value, candleData1_전봉.movingAverageDataList[24].Value);
|
|
var 전봉높은값1_72_24 = Math.Max(candleData1_전봉.movingAverageDataList[72].Value, candleData1_전봉.movingAverageDataList[24].Value);
|
|
var 전전봉낮은값1_72_24 = Math.Min(candleData1_전전봉.movingAverageDataList[72].Value, candleData1_전전봉.movingAverageDataList[24].Value);
|
|
var 전전봉높은값1_72_24 = Math.Max(candleData1_전전봉.movingAverageDataList[72].Value, candleData1_전전봉.movingAverageDataList[24].Value);
|
|
|
|
var 현재봉1_12 = candleData1.movingAverageDataList[12].Value;
|
|
var 전봉1_12 = candleData1_전봉.movingAverageDataList[12].Value;
|
|
var 전전봉1_12 = candleData1_전전봉.movingAverageDataList[12].Value;
|
|
|
|
var 현재봉1_4 = candleData1.movingAverageDataList[4].Value;
|
|
var 전봉1_4 = candleData1_전봉.movingAverageDataList[4].Value;
|
|
var 전전봉1_4 = candleData1_전전봉.movingAverageDataList[4].Value;
|
|
|
|
var 전봉1Bol4 = candleData1_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉1Bol12 = candleData1_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉1Bol24 = candleData1_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉1Bol4 = candleData1_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉1Bol12 = candleData1_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉1Bol24 = candleData1_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var 현재봉1Bol4 = candleData1.movingAverageDataList[4].BolangerValue;
|
|
var 현재봉1Bol12 = candleData1.movingAverageDataList[12].BolangerValue;
|
|
var 현재봉1Bol24 = candleData1.movingAverageDataList[24].BolangerValue;
|
|
#endregion
|
|
|
|
#region 60분봉 처리
|
|
//60분봉이지만 180분 처리
|
|
var candleDatas60 = findedMarket.candleDataList[MCandleTimeType.H1];
|
|
var candleDatas60_정렬 = candleDatas60.ToList().OrderBy(i => i.Argument).ToList();
|
|
|
|
var candleData60 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
|
|
if (candleData60 == null) continue;
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60);
|
|
|
|
|
|
candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
|
|
var candleData60_전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전봉);
|
|
|
|
candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
|
|
var candleData60_전전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전전봉);
|
|
|
|
candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
|
|
var candleData60_전전전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
|
|
movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전전전봉);
|
|
ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전전전봉);
|
|
|
|
|
|
var 낮은값60_72_24 = Math.Min(candleData60.movingAverageDataList[72].Value, candleData60.movingAverageDataList[24].Value);
|
|
var 높은값60_72_24 = Math.Max(candleData60.movingAverageDataList[72].Value, candleData60.movingAverageDataList[24].Value);
|
|
|
|
var 전봉낮은값60_72_24 = Math.Min(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
|
|
var 전봉높은값60_72_24 = Math.Max(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
|
|
var 전전봉낮은값60_72_24 = Math.Min(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
|
|
var 전전봉높은값60_72_24 = Math.Max(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
|
|
|
|
var 현재봉60_12 = candleData60.movingAverageDataList[12].Value;
|
|
var 전봉60_12 = candleData60_전봉.movingAverageDataList[12].Value;
|
|
var 전전봉60_12 = candleData60_전전봉.movingAverageDataList[12].Value;
|
|
|
|
var 현재봉60_4 = candleData60.movingAverageDataList[4].Value;
|
|
var 전봉60_4 = candleData60_전봉.movingAverageDataList[4].Value;
|
|
var 전전봉60_4 = candleData60_전전봉.movingAverageDataList[4].Value;
|
|
|
|
var 전봉60Bol4 = candleData60_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉60Bol12 = candleData60_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉60Bol24 = candleData60_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉60Bol4 = candleData60_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉60Bol12 = candleData60_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉60Bol24 = candleData60_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var 현재봉60Bol4 = candleData60.movingAverageDataList[4].BolangerValue;
|
|
var 현재봉60Bol12 = candleData60.movingAverageDataList[12].BolangerValue;
|
|
var 현재봉60Bol24 = candleData60.movingAverageDataList[24].BolangerValue;
|
|
#endregion
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
var candle15Flag = 현재봉15_4 > 현재봉15_12
|
|
&& candleData15.Open < candleData15.Close
|
|
&& 현재봉15_4 > 전봉15_4
|
|
&& 전봉15_4 > 전전봉15_4
|
|
&& 현재봉15_12 > 전봉15_12
|
|
&& 전봉15_12 > 전전봉15_12
|
|
&& 전봉15Bol12 - 전봉15Bol24 > 현재봉15Bol12 - 현재봉15Bol24;
|
|
|
|
var candle60Flag = 현재봉60_4 > 현재봉60_12
|
|
// && candleData60.Open < candleData60.Close
|
|
&& 현재봉60_4 > 전봉60_4
|
|
//&& 전봉60_4 > 전전봉60_4
|
|
&& 현재봉60_12 > 전봉60_12
|
|
// && 전봉60_12 > 전전봉60_12
|
|
&& 전봉60Bol12 - 전봉60Bol24 > 현재봉60Bol12 - 현재봉60Bol24;
|
|
|
|
|
|
var buyFlag = 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4;
|
|
var sellFlag = 현재봉1_4 < 높은값1_72_24;
|
|
|
|
var 전고점Data = 전고점[market + strInterval];
|
|
double.TryParse(전고점Data["val"].ToString(), out var val);
|
|
bool.TryParse(전고점Data["flag"].ToString(), out var flag);
|
|
bool.TryParse(전고점Data["firstFlag"].ToString(), out var firstFlag);
|
|
bool.TryParse(전고점Data["clearFlag"].ToString(), out var clearFlag);
|
|
bool.TryParse(전고점Data["breakFlag"].ToString(), out var breakFlag);
|
|
bool.TryParse(전고점Data["tempBuyFlag"].ToString(), out var tempBuyFlag);
|
|
|
|
if (현재봉4 < 낮은값_48_24 && candleData.IchimokData.하한선 > candleData.Close)
|
|
{
|
|
if (firstFlag)
|
|
전고점Data["firstFlag"] = false;
|
|
|
|
전고점Data["flag"] = true;
|
|
전고점Data["clearFlag"] = true;
|
|
전고점Data["val"] = 0;
|
|
전고점Data["breakFlag"] = false;
|
|
전고점Data["tempBuyFlag"] = true;
|
|
}
|
|
|
|
if (!flag || !breakFlag)
|
|
{
|
|
if (val == 0)
|
|
{
|
|
전고점Data["val"] = 전봉4;
|
|
val = 전봉4;
|
|
}
|
|
|
|
if (전봉4 < 전전봉4 && clearFlag)
|
|
{
|
|
전고점Data["clearFlag"] = false;
|
|
if (전전봉4 < val)
|
|
{
|
|
전고점Data["flag"] = false;
|
|
전고점Data["breakFlag"] = true;
|
|
}
|
|
else
|
|
{
|
|
전고점Data["flag"] = true;
|
|
}
|
|
}
|
|
|
|
else if (전봉4 > 전전봉4)
|
|
{
|
|
전고점Data["clearFlag"] = true;
|
|
if (val < 전봉4)
|
|
{
|
|
전고점Data["val"] = 전봉4;
|
|
}
|
|
}
|
|
}
|
|
if (전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전전봉4 < 높은값_48_24_전전봉
|
|
&& 전봉4 < 낮은값_48_24_전봉
|
|
&& 전봉12 > 낮은값_48_24_전봉)
|
|
{
|
|
if (UpList.ContainsKey(market + strInterval))
|
|
{
|
|
if (UpList[market + strInterval])
|
|
UpList[market + strInterval] = false;
|
|
}
|
|
else
|
|
{
|
|
UpList.Add(market + strInterval, false);
|
|
}
|
|
}
|
|
|
|
if ((
|
|
전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전전봉4 < 높은값_48_24_전전봉
|
|
&& 전봉4 < 낮은값_48_24_전봉
|
|
&& 전봉12 > 낮은값_48_24_전봉
|
|
&& 전봉24 < 전전봉24
|
|
&& 전봉12 < 전전봉12
|
|
&& 전봉4 < 전전봉4
|
|
&& (!UpBuyValue.ContainsKey(market + strInterval) || (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] == 0))
|
|
//&& 낮은값_48_24_전봉 < candleData_전봉.IchimokData.상한선
|
|
//&& candleData_전봉.Close < candleData_전봉.IchimokData.상한선
|
|
//&& candleData_전봉.Open > candleData_전봉.Close
|
|
))
|
|
{
|
|
if (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] == 0)
|
|
{
|
|
UpBuyValue[market + strInterval] = candleData.Open;
|
|
}
|
|
else
|
|
{
|
|
UpBuyValue.Add(market + strInterval, candleData.Open);
|
|
}
|
|
}
|
|
else if (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] != 0 && 현재봉1_4 > 높은값1_72_24 && UpList.ContainsKey(market + strInterval) && !UpList[market + strInterval])
|
|
{
|
|
if (UpBuyValue[market + strInterval] < candleData.Close)
|
|
{
|
|
if (UpList.ContainsKey(market + strInterval))
|
|
{
|
|
UpList[market + strInterval] = true;
|
|
}
|
|
else
|
|
{
|
|
UpList.Add(market + strInterval, true);
|
|
}
|
|
|
|
}
|
|
|
|
UpBuyValue[market + strInterval] = 0;
|
|
}
|
|
|
|
//사는 시점
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
if (
|
|
(
|
|
전전봉4 < 높은값_48_24_전전봉
|
|
&& 전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전봉4 > 높은값_48_24_전봉
|
|
&& 전봉12 < 높은값_48_24_전봉
|
|
&& 전봉24 > 전전봉24
|
|
&& 전봉12 > 전전봉12
|
|
&& 전봉4 > 전전봉4
|
|
&& 높은값_48_24_전봉 > candleData_전봉.IchimokData.하한선
|
|
&& candleData_전봉.Close > candleData_전봉.IchimokData.하한선
|
|
&& candleData_전봉.Open < candleData_전봉.Close
|
|
)
|
|
&& flag && !firstFlag && buyFlag && tempBuyFlag
|
|
&& UpList.ContainsKey(market + strInterval) && UpList[market + strInterval]
|
|
|
|
//4 < 높은값_72_24_전전봉 &&
|
|
//전봉4 > 높은값_72_24_전봉 &&
|
|
//전봉12 > 전전봉12 &&
|
|
//((전봉4 < candleData_전봉.IchimokData.하한선 && 높은값_72_24_전봉 < candleData_전봉.IchimokData.하한선)
|
|
//|| (전봉4 > candleData_전봉.IchimokData.하한선 && 높은값_72_24_전봉 > candleData_전봉.IchimokData.하한선)) &&
|
|
//전봉4 - 전전봉4 > 전봉12 - 전전봉12 &&
|
|
//전봉12 - 전전봉12 > 전봉24 - 전전봉24
|
|
//)
|
|
//&& flag && !firstFlag && buyFlag && candle15Flag
|
|
|
|
)
|
|
{
|
|
전고점Data["tempBuyFlag"] = false;
|
|
|
|
if (!(candle15Flag && candle60Flag))
|
|
continue;
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
|
|
if (val == 0)
|
|
전고점Data["val"] = 전봉4;
|
|
|
|
전고점Data["flag"] = false;
|
|
전고점Data["clearFlag"] = false;
|
|
|
|
|
|
if (LongCount < 3)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
}
|
|
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = UpBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
if (nowTime < ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
if (nowTime < ((DateTime)buyItem["BuyDate"]).AddHours(((int)interval) / 60))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (sellFlag)
|
|
{
|
|
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
var candle15Flag = 현재봉15_4 < 현재봉15_12
|
|
&& candleData15.Open > candleData15.Close
|
|
&& 현재봉15_4 < 전봉15_4
|
|
&& 전봉15_4 < 전전봉15_4
|
|
&& 현재봉15_12 < 전봉15_12
|
|
&& 전봉15_12 < 전전봉15_12
|
|
&& 전봉15Bol12 - 전봉15Bol24 > 현재봉15Bol12 - 현재봉15Bol24;
|
|
|
|
|
|
var candle60Flag = 현재봉60_4 < 현재봉12
|
|
// && candleData60.Open > candleData60.Close
|
|
&& 현재봉60_4 < 전봉60_4
|
|
// && 전봉60_4 < 전전봉60_4
|
|
&& 현재봉60_12 < 전봉60_12
|
|
//&& 전봉60_12 < 전전봉60_12
|
|
&& 전봉60Bol12 - 전봉60Bol24 > 현재봉60Bol12 - 현재봉60Bol24;
|
|
|
|
var buyFlag = 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4;
|
|
|
|
var sellFlag = 현재봉1_4 > 높은값1_72_24;
|
|
|
|
var 전저점Data = 전저점[market + strInterval];
|
|
double.TryParse(전저점Data["val"].ToString(), out var val);
|
|
bool.TryParse(전저점Data["flag"].ToString(), out var flag);
|
|
bool.TryParse(전저점Data["firstFlag"].ToString(), out var firstFlag);
|
|
bool.TryParse(전저점Data["clearFlag"].ToString(), out var clearFlag);
|
|
bool.TryParse(전저점Data["breakFlag"].ToString(), out var breakFlag);
|
|
bool.TryParse(전저점Data["tempBuyFlag"].ToString(), out var tempBuyFlag);
|
|
|
|
if (현재봉4 > 높은값_48_24 && candleData.IchimokData.상한선 < candleData.Close)
|
|
{
|
|
if (firstFlag)
|
|
전저점Data["firstFlag"] = false;
|
|
|
|
전저점Data["flag"] = true;
|
|
전저점Data["clearFlag"] = true;
|
|
전저점Data["val"] = 0;
|
|
전저점Data["breakFlag"] = false;
|
|
전저점Data["tempBuyFlag"] = true;
|
|
}
|
|
|
|
if (!flag || !breakFlag)
|
|
{
|
|
if (val == 0)
|
|
{
|
|
전저점Data["val"] = 전봉4;
|
|
val = 전봉4;
|
|
}
|
|
|
|
if (전봉4 > 전전봉4 && clearFlag)
|
|
{
|
|
전저점Data["clearFlag"] = false;
|
|
if (전전봉4 > val)
|
|
{
|
|
전저점Data["flag"] = false;
|
|
전저점Data["breakFlag"] = true;
|
|
}
|
|
else
|
|
{
|
|
전저점Data["flag"] = true;
|
|
}
|
|
}
|
|
|
|
else if (전봉4 < 전전봉4)
|
|
{
|
|
전저점Data["clearFlag"] = true;
|
|
if (val > 전봉4)
|
|
{
|
|
전저점Data["val"] = 전봉4;
|
|
}
|
|
}
|
|
}
|
|
if (전전봉4 < 높은값_48_24_전전봉
|
|
&& 전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전봉4 > 높은값_48_24_전봉
|
|
&& 전봉12 < 높은값_48_24_전봉)
|
|
{
|
|
|
|
if (DownList.ContainsKey(market + strInterval))
|
|
{
|
|
if (DownList[market + strInterval])
|
|
DownList[market + strInterval] = false;
|
|
}
|
|
else
|
|
{
|
|
DownList.Add(market + strInterval, false);
|
|
}
|
|
}
|
|
|
|
if ((
|
|
전전봉4 < 높은값_48_24_전전봉
|
|
&& 전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전봉4 > 높은값_48_24_전봉
|
|
&& 전봉12 < 높은값_48_24_전봉
|
|
&& 전봉24 > 전전봉24 && 전봉12 > 전전봉12
|
|
&& 전봉4 > 전전봉4
|
|
&& (!DownBuyValue.ContainsKey(market + strInterval) || (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] == 0))
|
|
//&& 높은값_48_24_전봉 > candleData_전봉.IchimokData.하한선
|
|
//&& candleData_전봉.Close > candleData_전봉.IchimokData.하한선
|
|
//&& candleData_전봉.Open < candleData_전봉.Close
|
|
))
|
|
{
|
|
if (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] == 0)
|
|
{
|
|
DownBuyValue[market + strInterval] = candleData.Open;
|
|
}
|
|
else
|
|
{
|
|
DownBuyValue.Add(market + strInterval, candleData.Open);
|
|
}
|
|
}
|
|
else if (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] != 0 && 현재봉1_4 < 낮은값1_72_24 && DownList.ContainsKey(market + strInterval) && !DownList[market + strInterval])
|
|
{
|
|
if (DownBuyValue[market + strInterval] > candleData.Close)
|
|
{
|
|
if (DownList.ContainsKey(market + strInterval))
|
|
{
|
|
DownList[market + strInterval] = true;
|
|
}
|
|
else
|
|
{
|
|
DownList.Add(market + strInterval, true);
|
|
}
|
|
|
|
}
|
|
|
|
DownBuyValue[market + strInterval] = 0;
|
|
}
|
|
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
if ((
|
|
전전봉4 > 낮은값_48_24_전전봉
|
|
&& 전전봉4 < 높은값_48_24_전전봉
|
|
&& 전봉4 < 낮은값_48_24_전봉
|
|
&& 전봉12 > 낮은값_48_24_전봉
|
|
&& 전봉24 < 전전봉24
|
|
&& 전봉12 < 전전봉12
|
|
&& 전봉4 < 전전봉4
|
|
&& 낮은값_48_24_전봉 < candleData_전봉.IchimokData.상한선
|
|
&& candleData_전봉.Close < candleData_전봉.IchimokData.상한선
|
|
&& candleData_전봉.Open > candleData_전봉.Close
|
|
)
|
|
&& flag && !firstFlag && buyFlag && tempBuyFlag
|
|
&& DownList.ContainsKey(market + strInterval) && DownList[market + strInterval]
|
|
)
|
|
{
|
|
전저점Data["tempBuyFlag"] = false;
|
|
if (!(candle15Flag && candle60Flag))
|
|
continue;
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
|
|
if (val == 0)
|
|
전저점Data["val"] = 전봉4;
|
|
|
|
전저점Data["flag"] = false;
|
|
전저점Data["clearFlag"] = false;
|
|
|
|
if(ShortCount < 2)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = DownBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
if (nowTime < ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
if (nowTime < ((DateTime)buyItem["BuyDate"]).AddHours(((int)interval) / 60))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
|
|
if (sellFlag)
|
|
{
|
|
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
/*
|
|
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
|
|
{
|
|
// 24,72 높은값
|
|
var 높은값_72_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_72_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
|
|
// 24,72 높은값
|
|
var 높은값_72_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_72_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
|
|
|
|
// 24,72 높은값
|
|
var 높은값_72_24 = Math.Max(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);
|
|
// 24,72 낮은값
|
|
var 낮은값_72_24 = Math.Min(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);
|
|
|
|
var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
|
|
var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
|
|
var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
|
|
var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
|
|
var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;
|
|
|
|
var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
|
|
var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
|
|
var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
|
|
var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
|
|
var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
|
|
|
|
var 현재봉4 = candleData.movingAverageDataList[4].Value;
|
|
var 현재봉8 = candleData.movingAverageDataList[8].Value;
|
|
var 현재봉12 = candleData.movingAverageDataList[12].Value;
|
|
var 현재봉24 = candleData.movingAverageDataList[24].Value;
|
|
var 현재봉72 = candleData.movingAverageDataList[72].Value;
|
|
|
|
|
|
var 전봉Bol4 = candleData_전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전봉Bol12 = candleData_전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전봉Bol24 = candleData_전봉.movingAverageDataList[24].BolangerValue;
|
|
|
|
var 전전봉Bol4 = candleData_전전봉.movingAverageDataList[4].BolangerValue;
|
|
var 전전봉Bol12 = candleData_전전봉.movingAverageDataList[12].BolangerValue;
|
|
var 전전봉Bol24 = candleData_전전봉.movingAverageDataList[24].BolangerValue;
|
|
var Bol4 = candleData.movingAverageDataList[4].BolangerValue;
|
|
var Bol12 = candleData.movingAverageDataList[12].BolangerValue;
|
|
var Bol24 = candleData.movingAverageDataList[24].BolangerValue;
|
|
|
|
if ((int)interval != 15)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
if (
|
|
(
|
|
전전봉4 < 높은값_72_24_전전봉 &&
|
|
전봉4 > 높은값_72_24_전봉
|
|
&& 전봉8 < 높은값_72_24_전봉
|
|
&& 전봉12 < 높은값_72_24_전봉
|
|
&& 전봉4 > 전전봉4
|
|
&& 전봉8 > 전전봉8
|
|
&& 전봉12 > 전전봉12
|
|
&& 전봉4 > candleData_전봉.IchimokData.하한선
|
|
)
|
|
)
|
|
{
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
SellLongStep.Add(market + interval, 0);
|
|
if (LongCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = UpBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
var compareVal = 높은값_72_24;
|
|
var val = SellLongStep[market + interval];
|
|
var sellFlag = false;
|
|
|
|
if (val != 101)
|
|
{
|
|
if (높은값_72_24 < 현재봉8)
|
|
{
|
|
SellLongStep[market + interval] = 101;
|
|
val = 101;
|
|
}
|
|
}
|
|
|
|
if (val == 101)
|
|
{
|
|
compareVal = 현재봉8;
|
|
}
|
|
|
|
if (candleData_전봉.Close < candleData_전봉.Open &&
|
|
candleData_전전봉.Close < candleData_전전봉.Open &&
|
|
candleData_전전전봉.Close < candleData_전전전봉.Open)
|
|
sellFlag = true;
|
|
|
|
if (현재봉4 < compareVal || sellFlag)
|
|
{
|
|
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
if (
|
|
전전봉4 > 낮은값_72_24_전전봉
|
|
&& 전봉4 < 낮은값_72_24_전봉
|
|
&& 전봉8 > 낮은값_72_24_전봉
|
|
&& 전봉12 > 낮은값_72_24_전봉
|
|
&& 전봉4 < 전전봉4
|
|
&& 전봉8 < 전전봉8
|
|
&& 전봉12 < 전전봉12
|
|
&& candleData_전봉.IchimokData.상한선 > 전봉4
|
|
)
|
|
{
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
SellShortStep.Add(market + interval, 0);
|
|
|
|
if (ShortCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = DownBuyList[market + interval];
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
var compareVal = 낮은값_72_24;
|
|
var val = SellShortStep[market + interval];
|
|
var sellFlag = false;
|
|
|
|
if (val != 101)
|
|
{
|
|
if (낮은값_72_24 > 현재봉8)
|
|
{
|
|
SellShortStep[market + interval] = 101;
|
|
val = 101;
|
|
}
|
|
}
|
|
|
|
if (val == 101)
|
|
{
|
|
compareVal = 현재봉8;
|
|
}
|
|
|
|
|
|
if (candleData_전봉.Close > candleData_전봉.Open &&
|
|
candleData_전전봉.Close > candleData_전전봉.Open &&
|
|
candleData_전전전봉.Close > candleData_전전전봉.Open)
|
|
sellFlag = true;
|
|
|
|
|
|
if (현재봉4 > compareVal || sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
/*
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
var buyFlag = false;
|
|
var buyTempFlag = false;
|
|
|
|
var buyType = 0;
|
|
|
|
if (BuyLongStep.ContainsKey(market + interval) && BuyLongStep[market + interval])
|
|
{
|
|
if (전봉72 < 전봉24 && 전봉12 < 전봉2 && 전봉24 < 전봉2 &&
|
|
candleData_전봉.IchimokData.상한선 < 전봉24 &&
|
|
(전전봉24 < 전봉24 && 전전봉12 < 전봉12))
|
|
{
|
|
buyTempFlag = true;
|
|
buyType = 2;
|
|
}
|
|
else if (전봉2 < 전봉24)
|
|
BuyLongStep[market + interval] = false;
|
|
}
|
|
else
|
|
{
|
|
if (
|
|
candleData_전봉.IchimokData.상한선 > 전봉2 && candleData_전전봉.IchimokData.상한선 > 전전봉2 &&
|
|
전봉72 > 전봉2 && 전전봉72 > 전전봉2 && 전전봉24 > 전전봉2 && 전봉24 < 전봉2 && (전전봉24 < 전봉24 || 전전봉12 < 전봉12)
|
|
)
|
|
{
|
|
buyTempFlag = true;
|
|
buyType = 1;
|
|
}
|
|
else if (
|
|
candleData_전봉.IchimokData.하한선 < 전봉2 && candleData_전전봉.IchimokData.하한선 < 전전봉2 &&
|
|
전봉24 < 전봉2 && 전전봉2 < 전전봉24 && 전전봉72 < 전전봉2 && 전봉72 < 전봉2 && (전전봉24 < 전봉24 || 전전봉12 < 전봉12)
|
|
)
|
|
{
|
|
BuyLongStep[market + interval] = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (buyTempFlag)
|
|
{
|
|
if (buyType == 1)
|
|
{
|
|
if (Bol12_Up < Bol24_Up && 전봉Bol12_Up < 전봉Bol24_Up && Math.Abs(전봉24 - 전봉Bol72_Down) < Math.Abs(전봉24 - 전봉72))
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
else if (buyType == 2)
|
|
{
|
|
if (Bol12_Up < Bol24_Up && 전봉Bol12_Up < 전봉Bol24_Up && Math.Abs(현재봉24 - Bol72_Up) < Math.Abs(현재봉24 - 현재봉72))
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (buyFlag)
|
|
{
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Type", buyType },
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "MovingRate4_8", 현재봉8 - 현재봉4 },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellLongStep.Add(market + interval, dic);
|
|
if (LongCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = UpBuyList[market + interval];
|
|
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
var sellFlag = false;
|
|
int.TryParse(buyItem["Type"].ToString(), out var type);
|
|
var val = SellLongStep[market + interval];
|
|
//switch (type)
|
|
//{
|
|
// case 1:
|
|
// if (전봉12 > 전봉24 && !val[2])
|
|
// val[2] = true;
|
|
// if (전봉2 > 전봉72 && !val[3])
|
|
// val[3] = true;
|
|
// if (전봉12 > 전봉72 && !val[4])
|
|
// val[4] = true;
|
|
// if (전봉24 > 전봉72 && !val[5])
|
|
// val[5] = true;
|
|
|
|
// if (val[1] && !val[2] && !val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉12 < 전봉24 && 전봉24 < 전봉2 && 전봉2 < 전봉72);
|
|
// }
|
|
// else if (val[1] && val[2] && !val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 < 전봉12 && 전봉12 < 전봉2 && 전봉2 < 전봉72);
|
|
// }
|
|
// else if (val[1] && !val[2] && val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉12 < 전봉24 && 전봉24 < 전봉72 && 전봉72 < 전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 < 전봉12 && 전봉12 < 전봉72 && 전봉72 < 전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 < 전봉72 && 전봉72 < 전봉12 && 전봉12 < 전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && val[4] && val[5])
|
|
// {
|
|
// sellFlag = !(전봉72 < 전봉24 && 전봉24 < 전봉12 && 전봉12 < 전봉2);
|
|
// }
|
|
|
|
// break;
|
|
// case 2:
|
|
// if ((전봉24 < 현재봉24 && 전봉12 < 현재봉12) || 현재봉2 > 현재봉24)
|
|
// {
|
|
// sellFlag = true;
|
|
// }
|
|
// break;
|
|
|
|
//}
|
|
if (type == 1)
|
|
{
|
|
if (Math.Abs(전봉4 - 전봉Bol72_Down) < Math.Abs(전봉4 - 전봉72))
|
|
{
|
|
if (전봉2 < 전봉4 && !(전봉24 > 전전봉24 && 전봉12 > 전전봉12))
|
|
{
|
|
sellFlag = true;
|
|
BuyLongStep[market + interval] = false;
|
|
}
|
|
else
|
|
{
|
|
if ((전전봉24 > 전봉24 && 전전봉12 > 전봉12) ||
|
|
(전봉2 < 전봉24))
|
|
{
|
|
sellFlag = true;
|
|
BuyLongStep[market + interval] = false;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if ((전전봉24 > 전봉24 && 전전봉12 > 전봉12) ||
|
|
(전봉2 < 전봉24))
|
|
{
|
|
sellFlag = true;
|
|
BuyLongStep[market + interval] = false;
|
|
}
|
|
}
|
|
}
|
|
else if (type == 2)
|
|
{
|
|
if ((전전봉24 > 전봉24 && 전전봉12 > 전봉12) ||
|
|
((전전봉24 > 전봉24 || 전전봉12 > 전봉12) && 현재봉2 < 현재봉72 && 전봉2 > 전봉72) ||
|
|
전봉24 > 전봉Bol72_Up && 전봉2 < 전봉Bol72_Up
|
|
)
|
|
{
|
|
sellFlag = true;
|
|
BuyLongStep[market + interval] = false;
|
|
}
|
|
}
|
|
if (sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
var buyFlag = false;
|
|
var buyTempFlag = false;
|
|
|
|
var buyType = 0;
|
|
|
|
if (BuyShortStep.ContainsKey(market + interval) && BuyShortStep[market + interval])
|
|
{
|
|
if (전봉72 > 전봉24 && 전봉12 > 전봉2 && 전봉24 > 전봉2 &&
|
|
candleData_전봉.IchimokData.하한선 > 전봉24 &&
|
|
(전전봉24 > 전봉24 && 전전봉12 > 전봉12))
|
|
{
|
|
buyTempFlag = true;
|
|
buyType = 2;
|
|
}
|
|
else if (전봉2 > 전봉24)
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
else
|
|
{
|
|
if (
|
|
candleData_전봉.IchimokData.하한선 < 전봉2 && candleData_전전봉.IchimokData.하한선 < 전전봉2 &&
|
|
전봉72 < 전봉2 && 전전봉72 < 전전봉2 && 전전봉24 < 전전봉2 && 전봉24 > 전봉2 && (전전봉24 > 전봉24 || 전전봉12 > 전봉12)
|
|
)
|
|
{
|
|
buyTempFlag = true;
|
|
buyType = 1;
|
|
}
|
|
else if (
|
|
candleData_전봉.IchimokData.상한선 > 전봉2 && candleData_전전봉.IchimokData.상한선 > 전전봉2 &&
|
|
전봉24 > 전봉2 && 전전봉2 > 전전봉24 && 전전봉72 > 전전봉2 && 전봉72 > 전봉2 && (전전봉24 > 전봉24 || 전전봉12 > 전봉12)
|
|
)
|
|
{
|
|
BuyShortStep[market + interval] = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (buyTempFlag)
|
|
{
|
|
if (buyType == 1)
|
|
{
|
|
if (Bol12_Down > Bol24_Down && 전봉Bol12_Down > 전봉Bol24_Down && Math.Abs(전봉24 - 전봉Bol72_Up) < Math.Abs(전봉24 - 전봉72))
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
else if (buyType == 2)
|
|
{
|
|
if (Bol12_Down > Bol24_Down && 전봉Bol12_Down > 전봉Bol24_Down && Math.Abs(현재봉24 - Bol72_Down) < Math.Abs(현재봉24 - 현재봉72))
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (buyFlag)
|
|
{
|
|
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Type", buyType },
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "MovingRate4_8", 현재봉4 - 현재봉8 },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellShortStep.Add(market + interval, dic);
|
|
if (buyType == 2)
|
|
{
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
if (ShortCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var sellFlag = false;
|
|
var buyItem = DownBuyList[market + interval];
|
|
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
int.TryParse(buyItem["Type"].ToString(), out var type);
|
|
|
|
//switch (type)
|
|
//{
|
|
// case 1:
|
|
// var val = SellShortStep[market + interval];
|
|
// if (전봉12 < 전봉24 && !val[2])
|
|
// val[2] = true;
|
|
// if (전봉2 < 전봉72 && !val[3])
|
|
// val[3] = true;
|
|
// if (전봉12 < 전봉72 && !val[4])
|
|
// val[4] = true;
|
|
// if (전봉24 < 전봉72 && !val[5])
|
|
// val[5] = true;
|
|
|
|
// if (val[1] && !val[2] && !val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉12 > 전봉24 && 전봉24 > 전봉2 && 전봉2 > 전봉72);
|
|
// }
|
|
// else if (val[1] && val[2] && !val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 > 전봉12 && 전봉12 > 전봉2 && 전봉2 > 전봉72);
|
|
// }
|
|
// else if (val[1] && !val[2] && val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉12 > 전봉24 && 전봉24 > 전봉72 && 전봉72 >전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && !val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 > 전봉12 && 전봉12 > 전봉72 && 전봉72 > 전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && val[4] && !val[5])
|
|
// {
|
|
// sellFlag = !(전봉24 > 전봉72 && 전봉72 > 전봉12 && 전봉12 > 전봉2);
|
|
// }
|
|
// else if (val[1] && val[2] && val[3] && val[4] && val[5])
|
|
// {
|
|
// sellFlag = !(전봉72 > 전봉24 && 전봉24 > 전봉12 && 전봉12 > 전봉2);
|
|
// }
|
|
// else
|
|
// sellFlag = true;
|
|
// break;
|
|
// case 2:
|
|
// if(전봉12 < 현재봉12 && 전봉24 < 현재봉24)
|
|
// {
|
|
// sellFlag = true;
|
|
// }
|
|
// break;
|
|
//}
|
|
|
|
if (type == 1)
|
|
{
|
|
if (Math.Abs(전봉4 - 전봉Bol72_Up) < Math.Abs(전봉4 - 전봉72))
|
|
{
|
|
if (전봉2 > 전봉4 && !(전봉24 < 전전봉24 && 전봉12 < 전전봉12))
|
|
{
|
|
sellFlag = true;
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
else
|
|
{
|
|
if ((전전봉24 < 전봉24 && 전전봉12 < 전봉12) ||
|
|
(전봉2 > 전봉24))
|
|
{
|
|
sellFlag = true;
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if ((전전봉24 < 전봉24 && 전전봉12 < 전봉12) ||
|
|
(전봉2 > 전봉24))
|
|
{
|
|
sellFlag = true;
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
}
|
|
}
|
|
else if (type == 2)
|
|
{
|
|
if ((전전봉24 < 전봉24 && 전전봉12 < 전봉12) ||
|
|
((전전봉24 < 전봉24 || 전전봉12 < 전봉12) && 현재봉2 > 현재봉72 && 전봉2 < 전봉72) ||
|
|
전봉24 < 전봉Bol72_Down && 전봉2 > 전봉Bol72_Down
|
|
)
|
|
{
|
|
sellFlag = true;
|
|
BuyShortStep[market + interval] = false;
|
|
}
|
|
}
|
|
|
|
if (sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
SellShortStep.Remove(market + interval);
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
if (영호조건식_상향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 상승", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!UpBuyList.ContainsKey(market + interval))
|
|
{
|
|
var buyFlag = false;
|
|
|
|
if(!BuyLongStep.ContainsKey(market + interval) || !BuyLongStep[market + interval])
|
|
{
|
|
if(전전봉2 < 전전봉Bol72_Down)
|
|
{
|
|
BuyLongStep[market + interval] = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(BuyLongStep.ContainsKey(market + interval) || BuyLongStep[market + interval])
|
|
{
|
|
if(전봉24 < 현재봉24 && 전봉24 < 전봉72 && 현재봉24 < 현재봉72 && 전봉72 > 전봉2 && 현재봉72 < 현재봉2 && 현재봉24 > Bol72_Down)
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
|
|
if (buyFlag)
|
|
{
|
|
BuyLongStep[market + interval] = false;
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "MovingRate4_8", 현재봉8 - 현재봉4 },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
UpBuyList.Add(market + interval, buyDic);
|
|
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellLongStep.Add(market + interval, dic);
|
|
if (LongCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyLongList.Add(orderDataDic);
|
|
LongCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var buyItem = UpBuyList[market + interval];
|
|
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
var sellFlag = false;
|
|
|
|
if(전봉24 < 전봉72)
|
|
{
|
|
if (전봉2 < 전봉72)
|
|
sellFlag = true;
|
|
if (전봉2 < 전봉Bol72_Up && 전전봉2 > 전전봉Bol72_Up)
|
|
sellFlag = true;
|
|
|
|
}
|
|
else
|
|
{
|
|
if (현재봉24 < 현재봉72)
|
|
sellFlag = true;
|
|
if (Bol72_Up < 현재봉24)
|
|
sellFlag = true;
|
|
if (전봉72 > 현재봉72 && 전봉24 > 현재봉24)
|
|
sellFlag = true;
|
|
}
|
|
|
|
if (sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "Type", "상향"},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
UpResultList.Add(result);
|
|
UpBuyList.Remove(market + interval);
|
|
SellLongStep.Remove(market + interval);
|
|
|
|
var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "상향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price},
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyLongList.Remove(orderDic);
|
|
LongCount--;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
if (영호조건식_하향돌파)
|
|
{
|
|
var price = candleData.Close;
|
|
var rate = (candleData.Close / candleData.Open) * 100 - 100;
|
|
var indicatorPrice = candleData.Open;
|
|
var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;
|
|
|
|
var description = string.Format("{0} 72,24,4 하락", strInterval);
|
|
var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));
|
|
|
|
try
|
|
{
|
|
//사는 시점
|
|
if (!DownBuyList.ContainsKey(market + interval))
|
|
{
|
|
var buyFlag = false;
|
|
|
|
if (!BuyShortStep.ContainsKey(market + interval) || !BuyShortStep[market + interval])
|
|
{
|
|
if (전전봉2 > 전전봉Bol72_Up)
|
|
{
|
|
BuyShortStep[market + interval] = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (BuyShortStep.ContainsKey(market + interval) || BuyShortStep[market + interval])
|
|
{
|
|
if (전봉24 > 현재봉24 && 전봉24 > 전봉72 && 현재봉24 > 현재봉72 && 전봉72 < 전봉2 && 현재봉72 > 현재봉2 && 현재봉24 < Bol72_Up)
|
|
{
|
|
buyFlag = true;
|
|
}
|
|
}
|
|
|
|
if (buyFlag)
|
|
{
|
|
BuyShortStep[market + interval] = false;
|
|
// 없으면 생성
|
|
if (signalData == null)
|
|
{
|
|
SignalInfoData signalInfoData = new SignalInfoData();
|
|
signalInfoData.SignalStart = nowTime;
|
|
signalInfoData.MarketName = market;
|
|
signalInfoData.Description = description;
|
|
signalInfoData.Rate = rate;
|
|
signalInfoData.Price = price;
|
|
signalInfoData.IndicatorPrice = indicatorPrice;
|
|
signalInfoData.IndicatorRate = indicatorRate;
|
|
signalInfoData.MCandleTimeType = interval;
|
|
|
|
signals_SD.Add(signalInfoData);
|
|
}
|
|
var buyDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
|
|
{ "CandleTime", candleData.Argument },
|
|
{ "MovingRate4_8", 현재봉4 - 현재봉8 },
|
|
{ "Candle", candleData }
|
|
};
|
|
|
|
DownBuyList.Add(market + interval, buyDic);
|
|
var dic = new Dictionary<int, bool>
|
|
{
|
|
[1] = true,
|
|
[2] = false,
|
|
[3] = false,
|
|
[4] = false,
|
|
[5] = false
|
|
};
|
|
SellShortStep.Add(market + interval, dic);
|
|
BuyShortStep[market + interval] = false;
|
|
if (ShortCount < 5)
|
|
{
|
|
double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
|
|
var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
|
|
if (orderData != null)
|
|
{
|
|
var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
|
|
|
|
var orderDataDic = new Dictionary<string, object>
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", nowTime },
|
|
{ "Price", price },
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "Candle", candleData },
|
|
{ "Size", size },
|
|
{ "orderId", orderDic["orderId"] }
|
|
};
|
|
BuyShortList.Add(orderDataDic);
|
|
ShortCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//파는 시점
|
|
else
|
|
{
|
|
var sellFlag = false;
|
|
var buyItem = DownBuyList[market + interval];
|
|
|
|
if (interval < MCandleTimeType.H1)
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
//임시로 처리
|
|
else
|
|
{
|
|
var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
|
|
if (nowTime < buyTime)
|
|
continue;
|
|
}
|
|
|
|
if (전봉24 > 전봉72)
|
|
{
|
|
if (전봉2 > 전봉72)
|
|
sellFlag = true;
|
|
if (전봉2 > 전봉Bol72_Down && 전전봉2 > 전전봉Bol72_Down)
|
|
sellFlag = true;
|
|
}
|
|
else
|
|
{
|
|
if (현재봉24 > 현재봉72)
|
|
sellFlag = true;
|
|
if (Bol72_Down > 현재봉24)
|
|
sellFlag = true;
|
|
if (전봉72 < 현재봉72 && 전봉24 < 현재봉24)
|
|
sellFlag = true;
|
|
}
|
|
if (sellFlag)
|
|
{
|
|
double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
|
|
var resultRate = ((price - buyPrice) / buyPrice) * 100;
|
|
|
|
var result = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", buyItem["BuyDate"]},
|
|
{ "BuyPrice", buyPrice },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRate }
|
|
};
|
|
|
|
DownResultList.Add(result);
|
|
DownBuyList.Remove(market + interval);
|
|
SellShortStep.Remove(market + interval);
|
|
var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);
|
|
|
|
if (orderDic != null)
|
|
{
|
|
double.TryParse(orderDic["Size"].ToString(), out var size);
|
|
var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());
|
|
|
|
if (sellOrder != null)
|
|
{
|
|
var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
|
|
}
|
|
else
|
|
{
|
|
Log.Error("Sell 안됨 확인 필요");
|
|
}
|
|
|
|
|
|
double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
|
|
//var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
|
|
//var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));
|
|
|
|
//double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);
|
|
|
|
var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;
|
|
|
|
var orderResult = new Dictionary<string, object>()
|
|
{
|
|
{ "MarketName", market },
|
|
{ "BuyDate", orderDic["BuyDate"]},
|
|
{ "BuyPrice", orderDic["Price"] },
|
|
{ "Type", "하향"},
|
|
{ "MCandleTimeType", (int)interval },
|
|
{ "BuyCandle", buyItem["Candle"] },
|
|
{ "SellDate", nowTime},
|
|
{ "SellPrice", price },
|
|
{ "SellCandle", candleData },
|
|
{ "Rate", resultRateData }
|
|
};
|
|
ResultList.Add(orderResult);
|
|
BuyShortList.Remove(orderDic);
|
|
ShortCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e.Message);
|
|
}
|
|
}
|
|
|
|
*/ |