public ProfileStructure GetProfile(int id)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
ProfileStructure newProf = new ProfileStructure();
Account acc = context.Account.Where(x => x.UserId == id).FirstOrDefault();
newProf.UserID = acc.UserId;
newProf.UserName = acc.UserName;
newProf.ChampionImage = context.Champion.Where(x => x.ChampionId == acc.ChampionId).Select(y => y.ChampionImage).FirstOrDefault();
newProf.error = 0;
dbContextTransaction.Commit();
return(newProf);
}
catch (Exception)
{
dbContextTransaction.Rollback();
ProfileStructure data = new ProfileStructure();
data.error = 1;
data.message = "Database could not commit transaction.";
return(data);
}
}
}
}
public DataStructure AddAccount(Account account)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
DataStructure data = new DataStructure();
Account acc = context.Account.Where(i => i.UserName.Equals(account.UserName)).FirstOrDefault();
if (acc != null)
{
data.error = 1;
data.message = "That username is not available.";
return(data);
}
account.LevelAccess = 3;
account.ChampionId = 1;
context.Add(account);
context.SaveChanges();
dbContextTransaction.Commit();
data.error = 0;
return(data);
}
catch (Exception)
{
dbContextTransaction.Rollback();
DataStructure data = new DataStructure();
data.error = 1;
data.message = "Database could not commit transaction.";
return(data);
}
}
}
}
public DataStructure DeleteAccount(int id)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
DataStructure data = new DataStructure();
Account acc = context.Account.Where(i => i.UserId == id).FirstOrDefault();
if (acc == null)
{
data.error = 1;
data.message = "Account does not exist.";
return(data);
}
context.Remove(acc);
context.SaveChanges();
data.error = 0;
data.message = "Account successfully deleted.";
dbContextTransaction.Commit();
return(data);
}
catch (Exception e)
{
DataStructure data = new DataStructure();
data.error = 1;
data.message = e.ToString();
dbContextTransaction.Rollback();
return(data);
}
}
}
}
public LoginStructure GetAccount(String user, String password)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
LoginStructure login = new LoginStructure();
Account acc = context.Account.Where(i => i.UserName.Equals(user) && i.Password.Equals(password)).FirstOrDefault();
if (acc == null)
{
login.error = 1;
login.message = "Invalid username/password combination.";
return(login);
}
login.error = 0;
login.UserID = acc.UserId;
login.ChampionImage = context.Champion.Where(i => i.ChampionId == acc.ChampionId).Select(x => x.ChampionImage).FirstOrDefault();
return(login);
}
catch (Exception)
{
dbContextTransaction.Rollback();
LoginStructure data = new LoginStructure();
data.error = 1;
data.message = "Database could not commit transaction.";
return(data);
}
}
}
}
public TeamStructure GetTeam(int TeamId)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
TeamStructure data = new TeamStructure();
Coach coach = context.Coach.Where(i => i.CoachId == context.CompetitorTeamRef.Where(x => x.TeamId == TeamId).Select(m => m.CoachId).FirstOrDefault()).FirstOrDefault();
if (coach == null)
{
data.error = 1;
data.message = "There is no coach available for this team.";
return(data);
}
Person coachPerson = context.Person.Where(i => i.PersonId == coach.PersonId).FirstOrDefault();
Team team = context.Team.Where(i => i.TeamId == TeamId).FirstOrDefault();
data.TeamLogo = team.TeamLogo;
data.TeamName = team.TeamName;
data.TeamPicture = team.TeamPicture;
data.TeamId = TeamId;
data.CoachName = coachPerson.PersonName;
data.CoachIgn = coach.CoachIgn;
data.ids = new List <int>();
var t = context.CompetitorTeamRef.Where(i => i.TeamId == TeamId).Select(x => x.PlayerId).ToList();
t.ForEach(x =>
{
data.ids.Add(x);
});
dbContextTransaction.Commit();
data.error = 0;
return(data);
}
catch (Exception e)
{
dbContextTransaction.Rollback();
TeamStructure data = new TeamStructure();
data.error = 1;
data.message = e.ToString();
return(data);
}
}
}
}
public TournamentStructure GetTournament(int id)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
TournamentStructure tourney = new TournamentStructure();
Tournament t = context.Tournament.Where(i => i.TournamentId == id).FirstOrDefault();
if (t == null)
{
tourney.error = 1;
tourney.message = "Tournament does not exist in the database.";
return(tourney);
}
tourney.TournamentName = t.TournamentName;
tourney.StartDate = t.StartDate;
tourney.EndDate = t.EndDate;
tourney.Season = t.Season;
PlayerTransaction p = new PlayerTransaction();
tourney.MVP = p.GetPlayer(t.Mvpid);
Coach c = context.Coach.Where(i => i.CoachId == t.Mvcid).FirstOrDefault();
tourney.MVCName = context.Person.Where(i => i.PersonId == c.PersonId).Select(x => x.PersonName).FirstOrDefault();
tourney.MVCIgn = c.CoachIgn;
MatchTransaction mt = new MatchTransaction();
TeamTransaction tt = new TeamTransaction();
tourney.TournamentBanner = t.TournamentBanner;
tourney.Matches = new List <SimpleMatchStructure>();
tourney.Standings = new List <StandingsStructure>();
context.Team.ToList().ForEach((team) =>
{
StandingsStructure s = new StandingsStructure();
s.TeamName = team.TeamName;
s.TeamLogo = team.TeamPicture;
s.TeamId = team.TeamId;
tourney.Standings.Add(s);
});
context.Match.Where(i => (!i.IsFinals).GetValueOrDefault() && (!i.IsQuarters).GetValueOrDefault() && (!i.IsSemis).GetValueOrDefault() && i.TournamentId == t.TournamentId).OrderBy(o => o.DatePlayed)
.ToList().ForEach((match) =>
{
SimpleMatchStructure sms = new SimpleMatchStructure();
sms.MatchId = match.MatchId;
sms.DatePlayed = match.DatePlayed;
sms.WinningTeam = tt.GetTeam(match.WinningTeamId);
sms.LosingTeam = tt.GetTeam(match.LosingTeamId);
tourney.Matches.Add(sms);
tourney.Standings.Find(l => l.TeamName == sms.WinningTeam.TeamName).Wins++;
tourney.Standings.Find(l => l.TeamName == sms.LosingTeam.TeamName).Losses++;
});
tourney.Playsoffs = new List <SimpleMatchStructure>();
context.Match.Where(i => ((i.IsFinals).GetValueOrDefault() == true || (i.IsQuarters).GetValueOrDefault() == true || (i.IsSemis).GetValueOrDefault() == true) && i.TournamentId == t.TournamentId).OrderBy(o => o.DatePlayed)
.ToList().ForEach((match) =>
{
SimpleMatchStructure sms = new SimpleMatchStructure();
sms.MatchId = match.MatchId;
sms.DatePlayed = match.DatePlayed;
sms.WinningTeam = tt.GetTeam(match.WinningTeamId);
sms.LosingTeam = tt.GetTeam(match.LosingTeamId);
tourney.Playsoffs.Add(sms);
});
tourney.Standings = tourney.Standings.OrderByDescending(o => o.Wins).ThenBy(x => x.Losses).ToList();
dbContextTransaction.Commit();
return(tourney);
}
catch (Exception e)
{
TournamentStructure tourney = new TournamentStructure();
tourney.error = 1;
tourney.message = e.ToString();
dbContextTransaction.Rollback();
return(tourney);
}
}
}
}
public List <Tournament> GetTournaments()
{
LoLEsportsDbContext context = new LoLEsportsDbContext();
return(context.Tournament.ToList());
}
public List <Team> GetTeams()
{
LoLEsportsDbContext context = new LoLEsportsDbContext();
return(context.Team.ToList());
}
public List <Champion> GetChampions()
{
LoLEsportsDbContext context = new LoLEsportsDbContext();
return(context.Champion.ToList());
}
public MatchStructure GetMatch(int id)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
MatchStructure match = new MatchStructure();
Match m = context.Match.Where(i => i.MatchId == id).FirstOrDefault();
if (m == null)
{
match.error = 1;
match.message = "Match does not exist in the database.";
return(match);
}
match.DatePlayed = m.DatePlayed;
match.MatchLocation = m.MatchLocation;
match.Duration = m.Duration;
Team wt = context.Team.Where(i => i.TeamId == m.WinningTeamId).FirstOrDefault();
TeamTransaction tt = new TeamTransaction();
match.WinningTeam = tt.GetTeam(wt.TeamId);
Team lt = context.Team.Where(i => i.TeamId == m.LosingTeamId).FirstOrDefault();
match.LosingTeam = tt.GetTeam(lt.TeamId);
match.WinningTeamStats = context.PlayerMatchRef.Where(i => i.MatchId == m.MatchId && match.WinningTeam.ids.Contains(i.PlayerId)).OrderBy(o => o.PlayerId).ToList();
match.LosingTeamStats = context.PlayerMatchRef.Where(i => i.MatchId == m.MatchId && match.LosingTeam.ids.Contains(i.PlayerId)).OrderBy(o => o.PlayerId).ToList();
match.PlayerNames = new List <String>();
match.ChampionImages = new List <String>();
match.ChampionBans = new List <String>();
match.WinningTeamStats.ForEach((player) =>
{
match.PlayerNames.Add(context.Player.Where(x => player.PlayerId == x.PlayerId).Select(l => l.PlayerIgn).FirstOrDefault());
match.ChampionImages.Add(context.Champion.Where(x => player.ChampionPlayedId == x.ChampionId).Select(l => l.ChampionImage).FirstOrDefault());
match.ChampionBans.Add(context.Champion.Where(x => player.ChampionBannedId == x.ChampionId).Select(l => l.ChampionImage).FirstOrDefault());
});
match.PlayerNames2 = new List <String>();
match.ChampionImages2 = new List <String>();
match.ChampionBans2 = new List <String>();
match.LosingTeamStats.ForEach((player) =>
{
match.PlayerNames2.Add(context.Player.Where(x => player.PlayerId == x.PlayerId).Select(l => l.PlayerIgn).FirstOrDefault());
match.ChampionImages2.Add(context.Champion.Where(x => player.ChampionPlayedId == x.ChampionId).Select(l => l.ChampionImage).FirstOrDefault());
match.ChampionBans2.Add(context.Champion.Where(x => player.ChampionBannedId == x.ChampionId).Select(l => l.ChampionImage).FirstOrDefault());
});
Tournament t = context.Tournament.Where(x => x.TournamentId == m.TournamentId).FirstOrDefault();
match.TournamentID = t.TournamentId;
match.TournamentName = t.TournamentName;
dbContextTransaction.Commit();
return(match);
}
catch (Exception e)
{
MatchStructure match = new MatchStructure();
match.error = 1;
match.message = e.ToString();
dbContextTransaction.Rollback();
return(match);
}
}
}
}
public PlayerStructure GetPlayer(int PlayerId)
{
using (var context = new LoLEsportsDbContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
PlayerStructure data = new PlayerStructure();
Player player = context.Player.Where(i => i.PlayerId == PlayerId).FirstOrDefault();
if (player == null)
{
data.error = 1;
data.message = "Player does not exist in the current database.";
return(data);
}
Person person = context.Person.Where(i => i.PersonId == player.PersonId).FirstOrDefault();
if (person == null)
{
data.error = 1;
data.message = "Player does not have an existing PersonID.";
return(data);
}
data.error = 0;
data.Age = person.Age;
data.Biography = person.Biography;
data.Hometown = person.Hometown;
data.PersonName = person.PersonName;
data.PlayerID = player.PlayerId;
data.PlayerIGN = player.PlayerIgn;
data.PlayerRole = player.PlayerRole;
data.Quote = player.Quote;
data.Salary = person.Salary;
//Calculate scores
int TotalKills = context.PlayerMatchRef.Where(i => i.PlayerId == player.PlayerId).Sum(x => x.PlayerKills);
int TotalAssists = context.PlayerMatchRef.Where(i => i.PlayerId == player.PlayerId).Sum(x => x.PlayerAssists);
int TotalScore = context.PlayerMatchRef.Where(i => i.PlayerId == player.PlayerId).Sum(x => x.PlayerScore);
int TotalDeaths = context.PlayerMatchRef.Where(i => i.PlayerId == player.PlayerId).Sum(x => x.PlayerDeaths);
player.TotalKills = TotalKills;
player.TotalAssists = TotalAssists;
player.TotalScore = TotalScore;
player.TotalDeaths = TotalDeaths;
context.Update(player);
context.SaveChanges();
data.TotalAssists = TotalAssists;
data.TotalDeaths = TotalDeaths;
data.TotalKills = TotalKills;
data.TotalScore = TotalScore;
data.PlayerImage = player.PlayerImage;
int TeamId = context.CompetitorTeamRef.Where(i => i.PlayerId == PlayerId).Select(x => x.TeamId).FirstOrDefault();
data.TeamName = context.Team.Where(i => i.TeamId == TeamId).Select(x => x.TeamName).FirstOrDefault();
data.TeamImage = context.Team.Where(i => i.TeamId == TeamId).Select(x => x.TeamLogo).FirstOrDefault();
data.TeamID = TeamId;
dbContextTransaction.Commit();
return(data);
}
catch (Exception)
{
dbContextTransaction.Rollback();
PlayerStructure data = new PlayerStructure();
data.error = 1;
data.message = "Database could not commit the transaction.";
return(data);
}
}
}
}
