public async Task<IEnumerable<Model.GenericPrediction>> FetchPredictionsAsync(Model.IValueOptions valueOptions)
{
var daysMatches =
this.fixtureRepository
.GetDaysMatches(valueOptions.Tournament.TournamentName, valueOptions.CouponDate);
var predictionURLs = new List<Uri>();
var predictions = new List<Model.GenericPrediction>();
var webRepository =
this.webRepositoryProvider
.CreateWebRepository(valueOptions.CouponDate);
foreach (var match in daysMatches)
{
var predictionURL =
this.predictionRepository
.GetFootballAPIURL(int.Parse(match.TeamsPlayerA.ExternalID),
int.Parse(match.TeamsPlayerB.ExternalID));
predictionURLs.Add(predictionURL);
}
var apiModels = await webRepository.ParseJsons<APIFootballPrediction>(predictionURLs);
return apiModels.Zip(predictionURLs, (m, u) => new { model = m, url = u })
.ToList()
.Select(x => ConvertAPIToGeneric(x.model,
valueOptions.Tournament,
valueOptions.CouponDate,
x.url));
}
public async Task<IEnumerable<Model.GenericPrediction>> FetchPredictionsAsync(Model.IValueOptions valueOptions)
{
var predictions = new List<Model.GenericPrediction>();
var webRepository =
this.webRepositoryProvider
.CreateWebRepository(valueOptions.CouponDate);
var jsonTennisMatches =
await webRepository.ParseJsonEnumerable<APITennisMatch>(
this.predictionRepository.GetTodaysMatchesURL(),
string.Format("atp-{0}", valueOptions.CouponDate.ToShortDateString()));
foreach (var jsonTennisMatch in jsonTennisMatches)
{
var predictionURL = new Uri(jsonTennisMatch.ToString());
var jsonTennisPrediction = await
webRepository.ParseJson<APITennisPrediction>(predictionURL);
jsonTennisPrediction.StartTime = jsonTennisMatch.MatchDate;
predictions.Add(ConvertAPIToGeneric(jsonTennisPrediction, predictionURL));
}
return predictions;
}
public override IEnumerable<Model.GenericPrediction> FetchPredictions(Model.IValueOptions valueOptions)
{
var gameWeek = this.fixtureRepository.GetDaysMatches(valueOptions.Tournament.TournamentName, valueOptions.CouponDate);
var footballTeams = new List<TeamPlayer>();
var predictions = new List<Model.GenericPrediction>();
var webRepository = this.webRepositoryProvider.CreateWebRepository(valueOptions.CouponDate);
foreach (var game in gameWeek)
{
var homeTeam = game.TeamsPlayerA;
var awayTeam = game.TeamsPlayerB;
footballTeams.Add(homeTeam);
footballTeams.Add(awayTeam);
}
for (int i = 0; i < footballTeams.Count(); i += 2)
{
var homeTeamID = footballTeams[i].ExternalID == string.Empty ? 0 : int.Parse(footballTeams[i].ExternalID);
var awayTeamID = footballTeams[i + 1].ExternalID == string.Empty ? 0 : int.Parse(footballTeams[i + 1].ExternalID);
var predictionURL = this.predictionRepository.GetFootballAPIURL(homeTeamID, awayTeamID);
var jsonFootballPredicton = (APIFootballPrediction)webRepository.ParseJson<APIFootballPrediction>(
predictionURL, s => ProgressReporterProvider.Current.ReportProgress(s, Model.ReporterImportance.Low, Model.ReporterAudience.Admin), string.Format("{0}-{1}",
valueOptions.Tournament.TournamentName.Replace(" ", ""), valueOptions.CouponDate.ToShortDateString()));
predictions.Add(ConvertAPIToGeneric(jsonFootballPredicton, valueOptions.Tournament, valueOptions.CouponDate, predictionURL));
}
return predictions;
}
public async Task<Model.GenericPrediction> FetchSinglePredictionAsync(TeamPlayer teamPlayerA, TeamPlayer teamPlayerB, Tournament tournament, Model.IValueOptions valueOptions)
{
var webRepository =
this.webRepositoryProvider
.CreateWebRepository(valueOptions.CouponDate);
var predictionURL =
this.predictionRepository
.GetTennisPredictionURL(teamPlayerA, teamPlayerB, tournament, valueOptions.CouponDate);
var jsonTennisPrediction = await
webRepository.ParseJson<APITennisPrediction>(predictionURL);
jsonTennisPrediction.StartTime = valueOptions.CouponDate;
return ConvertAPIToGeneric(jsonTennisPrediction, predictionURL);
}
public async Task<IEnumerable<Model.GenericPrediction>> FetchPredictionsCouponAsync(Model.IValueOptions valueOptions)
{
var predictions = new List<Model.GenericPrediction>();
var webRepository =
this.webRepositoryProvider
.CreateWebRepository(valueOptions.CouponDate);
var jsonTennisMatches =
await webRepository.ParseJsonEnumerable<APITennisMatch>(
this.predictionRepository.GetTodaysMatchesURL(),
string.Format("atp-{0}", valueOptions.CouponDate.ToShortDateString()));
foreach (var jsonTennisMatch in jsonTennisMatches)
{
predictions.Add(new Model.TennisPrediction()
{
PlayerAFirstName = jsonTennisMatch.PlayerAFirstName,
TeamOrPlayerA = jsonTennisMatch.PlayerASurname,
PlayerBFirstName = jsonTennisMatch.PlayerBSurname,
TeamOrPlayerB = jsonTennisMatch.PlayerBSurname,
});
}
return predictions;
}
public IEnumerable<Model.GenericPrediction> FetchPredictionsCoupon(Model.IValueOptions valueOptions)
{
return this.spreadsheetData.GetPredictions(valueOptions);
}
public override IEnumerable<Model.GenericPrediction> FetchPredictionsCoupon(Model.IValueOptions valueOptions)
{
var predictions = new List<Model.GenericPrediction>();
var atp = "ATP";
var webRepository = this.webRepositoryProvider.CreateWebRepository(valueOptions.CouponDate);
var jsonTennisMatches = webRepository.GetJsonObjects<APITennisMatch>(this.predictionRepository.GetTodaysMatchesURL(),
s => ProgressReporterProvider.Current.ReportProgress(s, Model.ReporterImportance.Low, Model.ReporterAudience.Admin), string.Format("{0}-{1}", atp, valueOptions.CouponDate.ToShortDateString()));
foreach (var jsonTennisMatch in jsonTennisMatches)
{
predictions.Add(new Model.TennisPrediction()
{
PlayerAFirstName = jsonTennisMatch.PlayerAFirstName,
TeamOrPlayerA = jsonTennisMatch.PlayerASurname,
PlayerBFirstName = jsonTennisMatch.PlayerBSurname,
TeamOrPlayerB = jsonTennisMatch.PlayerBSurname,
});
}
return predictions;
}
public override Model.GenericPrediction FetchSinglePrediction(TeamPlayer teamPlayerA, TeamPlayer teamPlayerB, Tournament tournament, Model.IValueOptions valueOptions)
{
throw new NotImplementedException();
}
protected IEnumerable<Model.GenericMatchCoupon> FetchOddsForMatches(Model.IValueOptions valueOptions, IEnumerable<Match> matches)
{
var coupons = new List<Model.GenericMatchCoupon>();
var oddsStrategy = this.oddsProvider.CreateOddsStrategy(valueOptions);
var timeStamp = DateTime.Now;
var tournamentEventIDs = matches.Select(m => m.TournamentEventID)
.Distinct()
.ToDictionary(t => t, t => this.fixtureRepository.GetTournamentEventById(t).EventName);
foreach (var match in matches)
{
var teamOrPlayerA = this.fixtureRepository.GetTeamOrPlayerById(match.TeamAID);
var teamOrPlayerB = this.fixtureRepository.GetTeamOrPlayerById(match.TeamBID);
var matchCouponURLs = this.bookmakerRepository
.GetMatchCouponURLs(match.Id)
.First(m => m.ExternalSource.Source == valueOptions.OddsSource.Source)
.MatchCouponURLString;
var coupon = new Model.GenericMatchCoupon
{
TeamOrPlayerA = teamOrPlayerA.Name,
FirstNameA = teamOrPlayerA.FirstName,
TeamOrPlayerB = teamOrPlayerB.Name,
FirstNameB = teamOrPlayerB.FirstName,
TournamentEventName = tournamentEventIDs[match.TournamentEventID],
MatchURL = new Uri(match.MatchCouponURLs.First(m => m.ExternalSource.Source == valueOptions.OddsSource.Source).MatchCouponURLString),
InPlay = match.InPlay
};
coupon.ActualOdds = oddsStrategy.GetOdds(coupon, valueOptions.CouponDate, timeStamp);
coupons.Add(coupon);
}
var matchesReturn = PersistCoupons(coupons, valueOptions.CouponDate, valueOptions.Tournament.TournamentName);
return coupons;
}
public IDictionary<Model.Outcome, IEnumerable<Model.GenericOdd>> GetOdds(Model.GenericMatchCoupon matchCoupon, DateTime timeStamp)
{
var returnOdds = new Dictionary<Model.Outcome, IEnumerable<Model.GenericOdd>>();
var outcomes = Enum.GetNames(typeof(Model.Outcome)).Where(o => o != "NotAssigned");
string[] bookies = new string[] { "B365", "BS", "LB", "SB", "SJ", "WH", "BW", "GB", "IW", "VC" };
var footballData = this.bookmakerRepository.GetExternalSource("Football Data Odds");
var valueSamurai = this.bookmakerRepository.GetExternalSource("Value Samurai");
var bookiesDic = bookies.ToDictionary(b => b, b => this.bookmakerRepository.FindByName(this.bookmakerRepository.GetAlias(b, footballData, valueSamurai)));
var footballDataBest = this.bookmakerRepository.FindByName("Football Data Odds Best Available");
var oddsRow = FixturesCouponsOdds.Where(x => x.Field<string>("HomeTeam") == matchCoupon.TeamOrPlayerA &&
x.Field<string>("AwayTeam") == matchCoupon.TeamOrPlayerB)
.FirstOrDefault();
foreach (var outcome in outcomes)
{
var outcomeEnum = (Model.Outcome)Enum.Parse(typeof(Model.Outcome), outcome);
var oddsForOutcome = new List<Model.GenericOdd>();
returnOdds.Add(outcomeEnum, oddsForOutcome);
//already taken care of?
//var bestOdd = oddsRow.Field<double>("BbMx" + outcome.Substring(0, 1));
//oddsForOutcome.Add(CreateConcreateOdd(footballDataBest, bestOdd));
foreach (var bookieKey in bookiesDic.Keys)
{
var bookie = bookiesDic[bookieKey];
var lookup = bookieKey + outcome.Substring(0, 1);
var odd = oddsRow.Field<double>(lookup);
var genericOdd = CreateConcreateOdd(bookie, odd);
oddsForOutcome.Add(genericOdd);
}
}
return returnOdds;
}
public override IEnumerable<Model.GenericPrediction> FetchPredictionsCoupon(Model.IValueOptions valueOptions)
{
throw new NotImplementedException();
}
public abstract IEnumerable<Model.GenericPrediction> FetchPredictionsCoupon(Model.IValueOptions valueOptions);
public abstract Model.GenericPrediction FetchSinglePrediction(TeamPlayer teamPlayerA, TeamPlayer teamPlayerB, Tournament tournament, Model.IValueOptions valueOptions);
public Task<IEnumerable<Model.GenericPrediction>> FetchPredictionsCouponAsync(Model.IValueOptions valueOptions)
{
throw new NotImplementedException();
}
public IEnumerable<Model.IGenericTournamentCoupon> GetTournaments(Model.OddsDownloadStage stage = Model.OddsDownloadStage.Tournament)
{
var tournaments = new List<Model.IGenericTournamentCoupon>();
tournaments.Add(new Model.GenericTournamentCoupon()
{
TournamentName = "Premier League",
Matches = GetMatches()
});
return tournaments;
}
public override IEnumerable<Model.GenericPrediction> FetchPredictions(Model.IValueOptions valueOptions)
{
var predictions = new List<Model.GenericPrediction>();
var atp = "ATP";
var webRepository = this.webRepositoryProvider.CreateWebRepository(valueOptions.CouponDate);
var jsonTennisMatches = webRepository.GetJsonObjects<APITennisMatch>(this.predictionRepository.GetTodaysMatchesURL(),
s => ProgressReporterProvider.Current.ReportProgress(s, Model.ReporterImportance.Low, Model.ReporterAudience.Admin), string.Format("{0}-{1}", atp, valueOptions.CouponDate.ToShortDateString()));
foreach (var jsonTennisMatch in jsonTennisMatches)
{
var predictionURL = new Uri(jsonTennisMatch.ToString());
var jsonTennisPrediction = (APITennisPrediction)webRepository.ParseJson<APITennisPrediction>(
predictionURL, s => ProgressReporterProvider.Current.ReportProgress(s, Model.ReporterImportance.Low, Model.ReporterAudience.Admin));
jsonTennisPrediction.StartTime = jsonTennisMatch.MatchDate;
predictions.Add(ConvertAPIToGeneric(jsonTennisPrediction, predictionURL));
}
return predictions;
}
public IEnumerable<Model.GenericPrediction> GetPredictions(Model.IValueOptions valueOptions)
{
var predictionsReturn = new List<Model.GenericPrediction>();
var todaysRows = this.excelMatches.Where(x => x.Field<DateTime>("DateToTake").Date == valueOptions.CouponDate.Date);
foreach (var row in todaysRows)
{
predictionsReturn.Add(this.predictions[row.Field<string>("URL")]);
}
return predictionsReturn;
}
public IDictionary<Model.Outcome, IEnumerable<Model.GenericOdd>> GetOdds(Model.GenericMatchCoupon matchCoupon, DateTime timeStamp)
{
var returnOdds = new Dictionary<Model.Outcome, IEnumerable<Model.GenericOdd>>();
var outcomes = Enum.GetNames(typeof(Model.Outcome)).Where(o => o != "NotAssigned" && o != "Draw");
string[] bookies = new string[] { "B365", "EX", "LB", "PS", "SJ" };
var tennisData = this.bookmakerRepository.GetExternalSource("Tennis Data Odds");
var valueSamurai = this.bookmakerRepository.GetExternalSource("Value Samurai");
var bookiesDic = bookies.ToDictionary(b => b, b => this.bookmakerRepository.FindByName(this.bookmakerRepository.GetAlias(b, tennisData, valueSamurai)));
var tennisDataBest = this.bookmakerRepository.FindByName("Tennis Data Odds Best Available");
var oddsRow = this.excelMatches.FirstOrDefault(x => x.Field<string>("URL") == matchCoupon.MatchURL.ToString());
foreach (var outcome in outcomes)
{
var outcomeEnum = (Model.Outcome)Enum.Parse(typeof(Model.Outcome), outcome);
var oddsForOutcome = new List<Model.GenericOdd>();
returnOdds.Add(outcomeEnum, oddsForOutcome);
foreach (var bookieKey in bookiesDic.Keys)
{
var bookie = bookiesDic[bookieKey];
var lookup = bookieKey + (outcome == "HomeWin" ? "1" : "2");
var odd = oddsRow.Field<double?>(lookup);
if (odd != null)
{
var genericOdd = CreateConcreateOdd(bookie, odd ?? 0.0);
oddsForOutcome.Add(genericOdd);
}
}
}
return returnOdds;
}
public IEnumerable<Model.IGenericTournamentCoupon> GetTournaments(Model.OddsDownloadStage stage = Model.OddsDownloadStage.Tournament)
{
throw new NotImplementedException();
}
public IEnumerable<Model.GenericPrediction> GetPredictions(Model.IValueOptions valueOptions)
{
return genericPredictions.Where(p => p.MatchDate.Date == valueOptions.CouponDate.Date);
}
public Task<Model.GenericPrediction> FetchSinglePredictionAsync(TeamPlayer teamPlayerA, TeamPlayer teamPlayerB, Tournament tournament, Model.IValueOptions valueOptions)
{
throw new NotImplementedException();
}
public override Model.GenericPrediction FetchSinglePrediction(TeamPlayer teamPlayerA, TeamPlayer teamPlayerB, Tournament tournament, Model.IValueOptions valueOptions)
{
var webRepository = this.webRepositoryProvider.CreateWebRepository(valueOptions.CouponDate);
var predictionURL = this.predictionRepository.GetTennisPredictionURL(teamPlayerA, teamPlayerB, tournament, valueOptions.CouponDate);
var jsonTennisPrediction = (APITennisPrediction)webRepository.ParseJson<APITennisPrediction>(
predictionURL, s => ProgressReporterProvider.Current.ReportProgress(s, Model.ReporterImportance.Low, Model.ReporterAudience.Admin));
jsonTennisPrediction.StartTime = valueOptions.CouponDate;
return ConvertAPIToGeneric(jsonTennisPrediction, predictionURL);
}
