static void Main(string[] args)
{
if (_createTablesOnStartup)
{
try
{
TrackerDBContext db = new TrackerDBContext();
RelationalDatabaseCreator dbCreator = (RelationalDatabaseCreator)db.Database.GetService <IDatabaseCreator>();
dbCreator.CreateTables();
}
catch (Exception ex)
{
Console.WriteLine("Some of the tables already exist, consider changing CreateTablesOnStartup to false from App.config");
}
}
ResultsTask.Start();
ImagesTask.Start();
PreliveTask.Start();
TeamsTask.Start();
if (ConfigurationManager.AppSettings["TrackLive"] == "true")
{
LiveTask.Start();
}
while (true)
{
}
}
public static List <T> FilterAlreadySentEvents <T>(TrackerDBContext db, List <T> rows)
{
if (rows is List <Results> )
{
List <Results> results = new List <Results>();
rows.ForEach(ev => results.Add(ev as Results));
List <Results> filteredResults = new List <Results>();
var dbResults = db.Results.ToList();
foreach (var result in results)
{
bool eligableEvent = true;
foreach (var dbResult in dbResults)
{
if (result.LeagueName == dbResult.LeagueName &&
result.HomeTeam == dbResult.HomeTeam &&
result.AwayTeam == dbResult.AwayTeam &&
result.GameDate.ToString() == dbResult.GameDate.ToString())
{
eligableEvent = false;
break;
}
}
if (eligableEvent)
{
filteredResults.Add(result);
}
}
return(filteredResults as List <T>);
}
else if (rows is List <Prelive> )
{
List <Prelive> preliveEvents = new List <Prelive>();
rows.ForEach(ev => preliveEvents.Add(ev as Prelive));
List <Prelive> filteredPreliveEvents = new List <Prelive>();
var dbPreliveEvents = db.Prelive.ToList();
foreach (var prelive in preliveEvents)
{
bool eligableEvent = true;
foreach (var dbPrelive in dbPreliveEvents)
{
if (prelive.LeagueName == dbPrelive.LeagueName &&
prelive.HomeTeam == dbPrelive.HomeTeam &&
prelive.AwayTeam == dbPrelive.AwayTeam &&
prelive.GameDate.ToString() == dbPrelive.GameDate.ToString())
{
eligableEvent = false;
break;
}
}
if (eligableEvent)
{
filteredPreliveEvents.Add(prelive);
}
}
return(filteredPreliveEvents as List <T>);
}
return(rows);
}
public static void TeamsWorkerInit(TimeSpan TeamsSamplePeriodInMinutes)
{
while (true)
{
TrackerDBContext dbContext = new TrackerDBContext();
var teamsFromDb = dbContext.Team.ToList();
var playersFromDb = dbContext.Player.ToList();
GamesOfLegends lol = new GamesOfLegends();
List <Player> players = new List <Player>();
lol.GetLinks();
var teams = lol.GetTeams();
if (teams.Count > 0)
{
dbContext.Team.RemoveRange(teamsFromDb);
dbContext.Team.AddRange(teams);
var champsStatsFromDb = dbContext.ChampionStat.ToList();
dbContext.RemoveRange(champsStatsFromDb);
Console.WriteLine($"Finished Getting Teams at {DateTime.Now.ToShortTimeString()}." +
$" {teams.Count} teams added to Db.");
players = lol.GetPlayers(teams);
dbContext.Player.RemoveRange(playersFromDb);
dbContext.Player.AddRange(players);
dbContext.SaveChanges();
var champStats = lol.GetChampionStats();
List <ChampionStat> stats = new List <ChampionStat>();
dbContext.SaveChanges();
foreach (var champ in champStats)
{
foreach (var stat in champ.Value)
{
foreach (var player in players)
{
if (champ.Key == player.Nickname)
{
stat.PlayerId = player.PlayerId;
stats.Add(stat);
}
}
}
}
dbContext.AddRange(stats);
dbContext.SaveChanges();
Console.WriteLine($"Finished Getting Players and Champion stats at {DateTime.Now.ToShortTimeString()}." +
$" {players.Count} players added to Db.");
}
Console.WriteLine($"Sampling Teams and Players again in {TeamsSamplePeriodInMinutes.Hours} hours and {TeamsSamplePeriodInMinutes.Minutes} minutes");
Thread.Sleep(TeamsSamplePeriodInMinutes);
}
}
public static void ResultsWorkerInit(TimeSpan ResultsSamplePeriod)
{
while (true)
{
TrackerDBContext dbContext = new TrackerDBContext();
EsportsLiveScore.GetNewLinks();
var results = EsportsLiveScore.GetResultEvents();
var filteredResults = Utilities.FilterAlreadySentEvents(dbContext, results);
dbContext.Results.AddRange(filteredResults);
Utilities.RemoveUnwatedEventsFromDb(ref dbContext);
dbContext.SaveChanges();
Console.WriteLine($"Finished Getting Results at {DateTime.Now.ToShortTimeString()}. New Results Added to db: {filteredResults.Count}. Sampling Results again in {ResultsSamplePeriod.Hours} hours and {ResultsSamplePeriod.Minutes} minutes");
Thread.Sleep(ResultsSamplePeriod);
}
}
public static void PreliveWorkerInit(TimeSpan PreliveSamplePeriod)
{
while (true)
{
while (EsportsLiveScore.LinksForLeagues == null || EsportsLiveScore.LinksForLeagues.Count == 0)
{
Thread.Sleep(30000);
}
TrackerDBContext dbContext = new TrackerDBContext();
var preliveEvents = EsportsLiveScore.GetPreliveEvents();
var filteredEvents = Utilities.FilterAlreadySentEvents(dbContext, preliveEvents);
dbContext.Prelive.AddRange(filteredEvents);
dbContext.SaveChanges();
Console.WriteLine($"Finished Getting Prelive Events at {DateTime.Now.ToShortTimeString()}." +
$" {filteredEvents.Count} events added to Db. " +
$"Sampling Prelive again in {PreliveSamplePeriod.Hours} hours and {PreliveSamplePeriod.Minutes} minutes");
Thread.Sleep(PreliveSamplePeriod);
}
}
public static void RemoveUnwatedEventsFromDb(ref TrackerDBContext dbContext)
{
var resultsToRemove = new List <Results>();
foreach (var res in dbContext.Results)
{
if (res.GameDate < DateTime.UtcNow.AddDays(-30))
{
resultsToRemove.Add(res);
}
}
dbContext.RemoveRange(resultsToRemove);
var preliveEventsToRemove = new List <Prelive>();
foreach (var pre in dbContext.Prelive)
{
if (pre.GameDate < DateTime.UtcNow)
{
preliveEventsToRemove.Add(pre);
}
}
dbContext.RemoveRange(preliveEventsToRemove);
}
public Mapping(TrackerDBContext context)
{
Context = context;
}
public LeagueOfLegendsController(TrackerDBContext db, IConfiguration config, IMemoryCache memoryCache)
{
this.db = db;
Configuration = config;
_cache = memoryCache;
}
public TicketsController(TrackerDBContext db)
{
_db = db;
}
public CounterStrikeController(IMemoryCache memoryCache, TrackerDBContext db, IConfiguration config)
{
this.db = db;
Configuration = config;
_cache = memoryCache;
}
public UsersController(TrackerDBContext db)
{
_db = db;
}
public static Sport CreateSportCacheById(int sportId, TrackerDBContext db, IConfiguration Configuration)
{
MappingServiceUrl = Configuration.GetSection("MappingServiceUrl").Value;
Sport sport = new Sport();
ConcurrentDictionary <string, HashSet <Results> > ResultEvents = new ConcurrentDictionary <string, HashSet <Results> >();
ConcurrentDictionary <string, HashSet <Prelive> > PreliveEvents = new ConcurrentDictionary <string, HashSet <Prelive> >();
var results = db.Results.ToList();
Parallel.ForEach(results, (result) =>
{
if (result.SportId == sportId)
{
if (ResultEvents.ContainsKey(result.LeagueName))
{
lock (_lock)
{
ResultEvents[result.LeagueName].Add(result);
}
}
else
{
lock (_lock)
{
ResultEvents.TryAdd(result.LeagueName, new HashSet <Results>()
{
result
});
}
}
}
});
sport.ResultsEvents = ResultEvents;
var preliveEventsFromDb = db.Prelive.ToList();
Parallel.ForEach(preliveEventsFromDb, (preliveEvent) =>
{
if (preliveEvent.SportId == sportId)
{
if (PreliveEvents.ContainsKey(preliveEvent.LeagueName))
{
lock (_lock)
{
PreliveEvents[preliveEvent.LeagueName].Add(preliveEvent);
}
}
else
{
lock (_lock)
{
PreliveEvents.TryAdd(preliveEvent.LeagueName, new HashSet <Prelive>()
{
preliveEvent
});
}
}
}
});
sport.PreliveEvents = PreliveEvents;
sport.LastUpdate = DateTime.UtcNow;
var teamsFromDb = db.Team.ToList();
var players = db.Player.ToList();
var playersToAdd = new List <Player>();
foreach (var player in players)
{
if (player.SportId != sportId)
{
continue;
}
bool shouldAddPlayer = true;
foreach (var playerToAdd in playersToAdd)
{
if (player.Nickname == playerToAdd.Nickname)
{
shouldAddPlayer = false;
break;
}
}
if (shouldAddPlayer)
{
playersToAdd.Add(player);
}
}
sport.Players = playersToAdd;
ConcurrentDictionary <string, HashSet <Team> > teams = new ConcurrentDictionary <string, HashSet <Team> >();
Parallel.ForEach(teamsFromDb, (team) =>
{
if (team.SportId == sportId)
{
if (teams.ContainsKey(team.Region))
{
lock (_lock)
{
teams[team.Region].Add(team);
}
}
else
{
lock (_lock)
{
var masterLeague = GetMasterLeagueFromMappingService
($"{MappingServiceUrl}/Mapping/GetLeague", sportId, team.Name.ToLowerInvariant().Contains("academy") ?
$"{team.Region}Academy" : team.Region).Result;
if (masterLeague == null || masterLeague.Equals("Bad POST params") || masterLeague.Equals("Could Not Locate League"))
{
teams.TryAdd(team.Region, new HashSet <Team>()
{
team
});
}
else
{
team.Region = masterLeague;
if (teams.ContainsKey(masterLeague))
{
teams[team.Region].Add(team);
}
else
{
teams.TryAdd(team.Region, new HashSet <Team>()
{
team
});
}
}
}
}
}
});
sport.TeamsInLeague = teams;
ConcurrentDictionary <string, string> images = new ConcurrentDictionary <string, string>();
DirectoryInfo d = new DirectoryInfo(Configuration.GetSection("ImagePathReader").Value);
FileInfo[] files = d.GetFiles("*.png");
var defaultImageByteArray = System.IO.File.ReadAllBytes
(Configuration.GetSection("ImagePathReader").Value + DefaultImagesById[sportId] + ".png");
var defaultImageString = Convert.ToBase64String(defaultImageByteArray);
images.TryAdd("default", defaultImageString);
foreach (var image in files)
{
var byteArray = System.IO.File.ReadAllBytes
(image.FullName);
var imageString = Convert.ToBase64String(byteArray);
images.TryAdd(image.Name.Replace(image.Extension, "").ToLowerInvariant(), imageString);
sport.TeamLogos = images;
}
sport.TeamLogos = images;
if (sportId == 1)
{
sport.ChampionStats = db.ChampionStat.ToList();
}
return(sport);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IMemoryCache cache, TrackerDBContext db, IConfiguration config, IHubContext <LiveEventHub> hubContext)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseSignalR(routes =>
{
routes.MapHub <LiveEventHub>("/live");
});
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
"default",
"{controller}/{action=Index}/{id?}");
});
app.UseSpa(spa =>
{
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseReactDevelopmentServer(npmScript: "start");
}
});
//app.UseCors("CorsPolicy");
cache.Set("LeagueOfLegends", CacheCreator.CreateSportCacheById(1, db, Configuration));
cache.Set("CSGO", CacheCreator.CreateSportCacheById(2, db, Configuration));
cache.Set("Dota2", CacheCreator.CreateSportCacheById(3, db, Configuration));
cache.Set("Live", new Live());
RabbitMQMessageReceiver r = new RabbitMQMessageReceiver();
LiveEventHub hub = new LiveEventHub(hubContext, cache);
r.LiveEventReached += hub.SendEvent;
//clean up old live events from cache
LiveEvent dummy = new LiveEvent();
Task.Factory.StartNew(async delegate
{
while (true)
{
var live = cache.Get("Live") as Live;
foreach (var ev in live.LiveEvents)
{
if (DateTime.UtcNow > ev.Value.UpdateDate.AddSeconds(180))
{
live.LiveEvents.TryRemove(hub.CreateLiveGameKey(ev.Value), out dummy);
hub.RemoveLiveEvent(ev.Value);
}
}
cache.Set("Live", live);
await Task.Delay(5000);
}
});
}
public ProjectsController(TrackerDBContext db)
{
_db = db;
}
