/// <summary>
/// Возвращает рассчитанные к-ты с питон api для события
/// </summary>
/// <param name="oddEvent"></param>
/// <returns></returns>
private Dictionary <string, decimal> GetCoefsFromApi(OddEvent oddEvent)
{
var paramsToPythonApi = MathClass.GetCoefsToPythonApi(oddEvent);
Dictionary <string, decimal> dict = _pythonClient.GetDataFromPythonApi(paramsToPythonApi.k1, paramsToPythonApi.to, paramsToPythonApi.tu, paramsToPythonApi.k2, paramsToPythonApi.hdp1, paramsToPythonApi.hdp2);
return(dict);
}
/// <summary>
/// Метод устанавливает вычисленные на api к-ты для пинакл события
/// Устанавливает расхождения между вычисленными к-ми и очищенными к-ми для пинакл события
/// </summary>
/// <param name="prices">Вычисленные на python api значения к-ов на исходы в виде ключ значение</param>
/// <param name="oddEvent">Пинакл событие</param>
public void ConvertPrices(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
SetTotalComputedPrices(prices, oddEvent);
SetMoneyLineComputedPrices(prices, oddEvent);
SetTotalComputedPricesFirstTeam(prices, oddEvent);
SetTotalComputedPricesSecondTeam(prices, oddEvent);
SetComputedHandicapPrices(prices, oddEvent);
SetComputedDoubleChancePrices(prices, oddEvent);
}
private Dictionary <string, decimal> GetCoefsFromApi2(OddEvent oddEvent)
{
var paramsToPythonApi = MathClass.GetCoefsToPythonApi(oddEvent);
var task = this._pythonClient.GetDataFromPythonApiAsync2(paramsToPythonApi.k1, paramsToPythonApi.to, paramsToPythonApi.tu, paramsToPythonApi.k2, paramsToPythonApi.hdp1, paramsToPythonApi.hdp2);
task.Wait();
Dictionary <string, decimal> dict = task.Result;
return(dict);
}
private bool IsEventstartTimeIntresting(double minutes, OddEvent oddEvent)
{
double disc = this.DiscStartTime(oddEvent);
if (disc <= minutes && disc > 0)
{
return(true);
}
else
{
return(false);
}
}
private PinData ConvertOddEventToPinData(OddEvent oddEvent)
{
OddPeriod oddPeriod = oddEvent.Periods[0];
PinData data = new PinData();
data.DateAdded = DateTime.Now.AddHours(2);
data.HomeScore = oddEvent.HomeScore;
data.AwayScore = oddEvent.AwayScore;
data.Totals = new List <PinTotal>();
data.HandiCaps = new List <PinHdp>();
data.EventId = oddEvent.EventId;
data.StartTime = oddEvent.StartTime;
data.HomeTeam = oddEvent.HomeTeam;
data.AwayTeam = oddEvent.AwayTeam;
if (oddPeriod.MoneyLine != null)
{
data.Home = oddPeriod.MoneyLine.Home.ToString();
data.Away = oddPeriod.MoneyLine.Away.ToString();
data.Draw = oddPeriod.MoneyLine.Draw.ToString();
}
if (oddPeriod.Totals != null && oddPeriod.Totals.Count > 0)
{
foreach (Total total in oddPeriod.Totals)
{
data.Totals.Add(new PinTotal()
{
Points = total.Points.ToString(), Over = total.Over.ToString(), Under = total.Under.ToString()
});
}
}
if (oddPeriod.Spreads != null && oddPeriod.Spreads.Count > 0)
{
foreach (OddsSpread spread in oddPeriod.Spreads)
{
data.HandiCaps.Add(new PinHdp()
{
Hdp = spread.Hdp.ToString(), Home = spread.Home.ToString(), Away = spread.Away.ToString()
});
}
}
return(data);
}
/// <summary>
/// Устанавливает для события hometeam,awayteam,starttime,islive
/// </summary>
/// <param name="oddEvent"></param>
public void SetOddEventParams(OddEvent oddEvent)
{
foreach (PinnacleEvent pinnacleEvent in this._events)
{
if (oddEvent.EventId == pinnacleEvent.Id)
{
oddEvent.StartTime = pinnacleEvent.Starts.AddHours(2);
oddEvent.HomeTeam = pinnacleEvent.Home;
oddEvent.AwayTeam = pinnacleEvent.Away;
oddEvent.DateAdded = DateTime.Now;
if (pinnacleEvent.LiveStatus == FixtureEventLiveStatus.LiveBettingEvent)
{
oddEvent.IsLive = true;
}
else
{
oddEvent.IsLive = false;
}
}
}
}
/// <summary>
/// Инициализирует имеющиеся гандикапы для события
/// </summary>
/// <param name="oddEvent"></param>
private void SetHandicapsForEvent(OddEvent oddEvent)
{
OddPeriod oddPeriod = oddEvent.Periods[0];
List <OddsSpread> spreads = oddPeriod.Spreads;
oddPeriod.Handicaps = new List <Handicap>();
foreach (OddsSpread spread in spreads)
{
if (spread.Hdp <= 3.5M && spread.Hdp >= -3.5M)
{
Handicap handicap = new Handicap()
{
HDPHOME = spread.Hdp, HDPAWAY = spread.Hdp * (-1), HOME = spread.Home, AWAY = spread.Away
};
oddPeriod.Handicaps.Add(handicap);
}
}
}
/// <summary>
/// Метод определяющий имеет ли пинакл событие хотя-бы один половинчатый тотал и гандикап для fulltime
/// </summary>
/// <param name="oddEvent">пинакл событие</param>
/// <returns></returns>
private bool IsEventIntresting2(OddEvent oddEvent)
{
bool consistTotal = false;
bool consistHandicap = false;
OddPeriod oddPeriod = oddEvent.Periods[0];
List <Total> totals = oddPeriod.Totals;
List <OddsSpread> spreads = oddPeriod.Spreads;
if (totals == null || spreads == null || totals.Count == 0 || spreads.Count == 0)
{
return(false);
}
foreach (Total total in totals)
{
if (total.Points % 1 == 0.5M && total.Points <= 6.5M && total.Points >= 0.5M)
{
consistTotal = true;
}
}
foreach (OddsSpread spread in spreads)
{
if (Math.Abs(spread.Hdp % 1) == 0.5M && spread.Hdp <= 3.5M && spread.Hdp >= -3.5M)
{
consistHandicap = true;
}
}
if (consistTotal == true && consistHandicap == true)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Устанавливает вычисленные к-ты и расхождения для события на исходы:Total
/// </summary>
/// <param name="prices"></param>
/// <param name="oddEvent"></param>
private static void SetTotalComputedPrices(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
List <Total> _pinnacleTotals = oddEvent.Periods[0].Totals;
for (int i = 0; i < _pinnacleTotals.Count; i++)
{
decimal points = _pinnacleTotals[i].Points;
decimal?margin = MathClass.GetMargin2(_pinnacleTotals[i].Over, _pinnacleTotals[i].Under);
_pinnacleTotals[i].FairOver = _pinnacleTotals[i].Over / (1 - margin);
_pinnacleTotals[i].FairUnder = _pinnacleTotals[i].Under / (1 - margin);
foreach (KeyValuePair <string, decimal> keyValuePair in prices)
{
if (keyValuePair.Key.StartsWith("T O") == true)
{
decimal resultOver = 0.0M;
decimal resultUnder = 0.0M;
string name = keyValuePair.Key.Replace("T O ", "");
resultOver = Decimal.Parse(name, CultureInfo.InvariantCulture);
foreach (KeyValuePair <string, decimal> keyValuePair2 in prices)
{
if (keyValuePair2.Key.StartsWith("T U") == true)
{
string name2 = keyValuePair2.Key.Replace("T U ", "");
resultUnder = Decimal.Parse(name2, CultureInfo.InvariantCulture);
if (resultOver == resultUnder && resultOver == points)
{
_pinnacleTotals[i].OverComputed = keyValuePair.Value;
_pinnacleTotals[i].UnderComputed = keyValuePair2.Value;
_pinnacleTotals[i].OverDisc = GetDiscByCoefs(_pinnacleTotals[i].FairOver, _pinnacleTotals[i].OverComputed);
_pinnacleTotals[i].UnderDisc = GetDiscByCoefs(_pinnacleTotals[i].FairUnder, _pinnacleTotals[i].UnderComputed);
}
}
}
}
}
}
}
/// <summary>
/// Устанавливает вычисленные к-ты и расхождения для события на исходы:Handicap
/// </summary>
/// <param name="prices"></param>
/// <param name="oddEvent"></param>
private static void SetComputedHandicapPrices(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
List <Handicap> _pinnacleHandicaps = oddEvent.Periods[0].Handicaps;
for (int i = 0; i < _pinnacleHandicaps.Count; i++)
{
decimal?margin = MathClass.GetMargin2(_pinnacleHandicaps[i].HOME, _pinnacleHandicaps[i].AWAY);
_pinnacleHandicaps[i].FairHome = _pinnacleHandicaps[i].HOME / (1 - margin);
_pinnacleHandicaps[i].FairAway = _pinnacleHandicaps[i].AWAY / (1 - margin);
foreach (KeyValuePair <string, decimal> keyValuePair in prices)
{
decimal resultHome = 0.0M;
decimal resultAway = 0.0M;
if (keyValuePair.Key.Contains("HDP1 ") == true)
{
string name = keyValuePair.Key.Replace("HDP1 ", "");
resultHome = Decimal.Parse(name, CultureInfo.InvariantCulture);
foreach (KeyValuePair <string, decimal> keyValuePair2 in prices)
{
if (keyValuePair2.Key.Contains("HDP2 ") == true)
{
string name2 = keyValuePair2.Key.Replace("HDP2 ", "");
resultAway = Decimal.Parse(name2, CultureInfo.InvariantCulture);
if (resultHome == resultAway * (-1) && _pinnacleHandicaps[i].HDPHOME == resultHome && _pinnacleHandicaps[i].HDPAWAY == resultAway)
{
_pinnacleHandicaps[i].HOMECOMPUTED = keyValuePair.Value;
_pinnacleHandicaps[i].AWAYCOMPUTED = keyValuePair2.Value;
_pinnacleHandicaps[i].HOMEDISC = GetDiscByCoefs(_pinnacleHandicaps[i].FairHome, _pinnacleHandicaps[i].HOMECOMPUTED);
_pinnacleHandicaps[i].AWAYDISC = GetDiscByCoefs(_pinnacleHandicaps[i].FairAway, _pinnacleHandicaps[i].AWAYCOMPUTED);
}
}
}
}
}
}
}
/// <summary>
/// Устанавливает вычисленные к-ты для события на исходы:DoubleChance
/// </summary>
/// <param name="prices"></param>
/// <param name="oddEvent"></param>
private static void SetComputedDoubleChancePrices(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
oddEvent.Periods[0].DoubleChance = new DoubleChance();
foreach (KeyValuePair <string, decimal> keyValuePair in prices)
{
decimal price;
if (keyValuePair.Key.Equals("DC 1X") == true)
{
price = keyValuePair.Value;
oddEvent.Periods[0].DoubleChance.HomeDrawComputed = price;
}
if (keyValuePair.Key.Equals("DC X2") == true)
{
price = keyValuePair.Value;
oddEvent.Periods[0].DoubleChance.AwayDrawComputed = price;
}
if (keyValuePair.Key.Equals("DC 12") == true)
{
price = keyValuePair.Value;
oddEvent.Periods[0].DoubleChance.HomeAwayComputed = price;
}
}
}
public void AddEvent(OddEvent oddEvent)
{
PinData pinData = this.ConvertOddEventToPinData(oddEvent);
this.Add(pinData);
}
private double DiscStartTimeLive(OddEvent oddEvent)
{
TimeSpan timeSpan = (DateTime)DateTime.Now - (DateTime)oddEvent.StartTime;
return(timeSpan.TotalMinutes);
}
/// <summary>
/// Устанавливает вычисленные к-ты и расхождения для события на исходы:TeamTotalTwo
/// </summary>
/// <param name="prices"></param>
/// <param name="oddEvent"></param>
private static void SetTotalComputedPricesSecondTeam(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
if (oddEvent.Periods[0].TeamTotal != null && oddEvent.Periods[0].TeamTotal.Away != null)
{
Total _pinnacleSecondTeamTotal = oddEvent.Periods[0].TeamTotal.Away;
decimal points = _pinnacleSecondTeamTotal.Points;
decimal?margin = MathClass.GetMargin2(_pinnacleSecondTeamTotal.Over, _pinnacleSecondTeamTotal.Under);
_pinnacleSecondTeamTotal.FairOver = _pinnacleSecondTeamTotal.Over / (1 - margin);
_pinnacleSecondTeamTotal.FairUnder = _pinnacleSecondTeamTotal.Under / (1 - margin);
foreach (KeyValuePair <string, decimal> keyValuePair in prices)
{
decimal resultPointsOver = 0.0M;
decimal resultPointsUnder = 0.0M;
if (keyValuePair.Key.StartsWith("T2 O") == true)
{
string name = keyValuePair.Key.Replace("T2 O ", "");
resultPointsOver = Decimal.Parse(name, CultureInfo.InvariantCulture);
foreach (KeyValuePair <string, decimal> keyValuePair2 in prices)
{
if (keyValuePair2.Key.Contains("T2 U") == true)
{
string name2 = keyValuePair2.Key.Replace("T2 U ", "");
resultPointsUnder = Decimal.Parse(name2, CultureInfo.InvariantCulture);
if (resultPointsOver == resultPointsUnder && resultPointsOver == points)
{
_pinnacleSecondTeamTotal.OverComputed = keyValuePair.Value;
_pinnacleSecondTeamTotal.UnderComputed = keyValuePair2.Value;
_pinnacleSecondTeamTotal.OverDisc = GetDiscByCoefs(_pinnacleSecondTeamTotal.FairOver, _pinnacleSecondTeamTotal.OverComputed);
_pinnacleSecondTeamTotal.UnderDisc = GetDiscByCoefs(_pinnacleSecondTeamTotal.FairUnder, _pinnacleSecondTeamTotal.UnderComputed);
}
}
}
}
}
}
}
{/// <summary>
/// Вычисление по событию пинакл к-ов для api
/// </summary>
/// <param name="oddEvent"></param>
/// <returns></returns>
public static (decimal k1, decimal to, decimal tu, decimal k2, decimal hdp1, decimal hdp2) GetCoefsToPythonApi(OddEvent oddEvent)
{
decimal k1 = 0.0M;
decimal to = 0.0M;
decimal tu = 0.0M;
decimal k2 = 0.0M;
decimal hdp1 = 0.0M;
decimal hdp2 = 0.0M;
foreach (Total total in oddEvent.Periods[0].Totals)
{
if (total.Points % 1 == 0.5M && total.Points >= 0.5M && total.Points <= 6.5M)
{
k1 = total.Points;
to = total.Over;
tu = total.Under;
}
}
foreach (OddsSpread spread in oddEvent.Periods[0].Spreads)
{
if (Math.Abs(spread.Hdp % 1) == 0.5M && spread.Hdp <= 3.5M && spread.Hdp >= -3.5M)
{
k2 = spread.Hdp;
hdp1 = spread.Home;
hdp2 = spread.Away;
}
}
return(k1, to, tu, k2, hdp1, hdp2);
}
/// <summary>
/// Устанавливает вычисленные к-ты и расхождения для события на исходы:1X2
/// </summary>
/// <param name="prices"></param>
/// <param name="oddEvent"></param>
private static void SetMoneyLineComputedPrices(Dictionary <string, decimal> prices, OddEvent oddEvent)
{
MoneyLine moneyLine = oddEvent.Periods[0].MoneyLine;
if (moneyLine != null)
{
decimal?margin = MathClass.GetMargin3(moneyLine.Home, moneyLine.Draw, moneyLine.Away);
moneyLine.FairHome = (moneyLine.Home / (1 - margin));
moneyLine.FairDraw = (moneyLine.Draw / (1 - margin));
moneyLine.FairAway = (moneyLine.Away / (1 - margin));
if (moneyLine != null)
{
foreach (KeyValuePair <string, decimal> keyValuePair in prices)
{
decimal?price;
if (keyValuePair.Key.Equals("ML 1") == true)
{
price = keyValuePair.Value;
moneyLine.HomeComputed = price;
moneyLine.HomeDisc = GetDiscByCoefs(moneyLine.FairHome, moneyLine.HomeComputed);
}
if (keyValuePair.Key.Equals("ML X") == true)
{
price = keyValuePair.Value;
moneyLine.DrawCompute = price;
moneyLine.DrawDisc = GetDiscByCoefs(moneyLine.FairDraw, moneyLine.DrawCompute);
}
if (keyValuePair.Key.Equals("ML 2") == true)
{
price = keyValuePair.Value;
moneyLine.AwayComputed = price;
moneyLine.AwayDisc = GetDiscByCoefs(moneyLine.FairAway, moneyLine.AwayComputed);
}
}
}
}
}
public PinacclePrices ConvertPinnacleEventToDatabasePrices(OddEvent oddEvent)
{
eventDiscs.Clear();
this.pinaccle = new PinacclePrices();
this.pinaccle.IsLive = oddEvent.IsLive;
this.pinaccle.DateAdded = oddEvent.DateAdded;
this.pinaccle.EventId = oddEvent.EventId.ToString();
this.properties = this.pinaccle.GetType().GetProperties();
this.pinaccle.HomeTeam = oddEvent.HomeTeam;
this.pinaccle.AwayTeam = oddEvent.AwayTeam;
this.pinaccle.StartTime = oddEvent.StartTime;
OddPeriod oddPeriod = oddEvent.Periods[0];
MoneyLine moneyLine = oddPeriod.MoneyLine;
List <Handicap> handicaps = oddPeriod.Handicaps;
List <Total> totals = oddPeriod.Totals;
DoubleChance doubleChance = oddPeriod.DoubleChance;
if (oddPeriod.TeamTotal != null)
{
Total homeTotal = oddPeriod.TeamTotal.Home;
Total awayTeamTotal = oddPeriod.TeamTotal.Away;
if (homeTotal != null)
{
this.SetHomeTeamTotalPricesTodatabase(homeTotal);
}
if (awayTeamTotal != null)
{
this.SetAwayTeamTotalPricesToDatabase(awayTeamTotal);
}
}
this.SetMoneyLinePricesToDatabase(moneyLine);
//this.SetDoubleChanceToDatabasePrices(doubleChance);
this.SetTotalPricesToDatabase(totals);
//this.SetHomeTeamTotalPricesTodatabase(homeTotal);
//this.SetAwayTeamTotalPricesToDatabase(awayTeamTotal);
this.SetHandicapPricesToDatabase(handicaps);
//var result = MathClass.GetStatsForMarket(this.eventDiscs);
//this.pinaccle.EventDiscMax = result.maxDisc;
//this.pinaccle.EventDiscAverage = result.averageDisc;
//this.pinaccle.EventMediana = MathClass.GetMedForMarket(this.eventDiscs);
return(this.pinaccle);
}
