public ILeague GetGenericLeague()
{
ILeague league = null;
string leagueName = "Quick Play";
using (var context = new Data.DartballContext()) {
var item = context.Leagues.FirstOrDefault(x => x.Name == leagueName);
if (item == null)
{
LeagueDto dto = new LeagueDto()
{
Name = leagueName,
Password = "******"
};
AddNew(dto);
item = context.Leagues.FirstOrDefault(x => x.Name == leagueName);
league = Mapper.Map <LeagueDto>(item);
}
else
{
league = Mapper.Map <LeagueDto>(item);
}
}
return(league);
}
public void Execute(LeagueDto request)
{
if (Context.Leagues.Any(l => l.Name == request.Name))
{
throw new EntityAlreadyExistsException("league");
}
List <RefereeLeague> lista = new List <RefereeLeague>();
if (request.RefereesId != null)
{
foreach (var refereeId in request.RefereesId)
{
if (!Context.Referees.Any(l => l.Id == refereeId))
{
throw new EntityNotFoundException("Referee");
}
lista.Add(new RefereeLeague {
LeagueId = request.Id, RefereeId = refereeId
});
}
}
Context.Leagues.Add(new League {
LeagueReferees = lista,
Level = request.Level,
IsDeleted = false,
Name = request.Name
});
Context.SaveChanges();
}
public bool ExistsInDb(LeagueDto league)
{
Connection.BeginTransaction();
var rows = Connection.Query <int>(@"SELECT COUNT(1) as 'Count' FROM League WHERE LeagueId = @LeagueId", new { LeagueId = league.LeagueId });
Connection.Commit();
return(rows.First() > 0);
}
private LeagueDto GetLeague(int leagueId)
{
var leagueDto = db.Leagues.Select(a => LeagueDto.Create(a)).FirstOrDefault(a => a.Id == leagueId);
if (leagueDto == null)
{
throw new Exception("league doesn't exist");
}
return(leagueDto);
}
private void InsertLeague(LeagueDto league)
{
string insertQuery = @"INSERT INTO League
(LeagueId, Name, Password, DeleteDate)
values(@LeagueId, @Name, @Password, @DeleteDate)";
Connection.BeginTransaction();
Connection.Execute(insertQuery, league);
Connection.Commit();
}
public async Task <IActionResult> Save([FromBody] LeagueDto dto)
{
if (!this._service.HasAccess(dto))
{
return(Forbid());
}
await this._service.SaveAsync(dto);
return(Ok());
}
private async void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
{
string nameSummoner = NavigationContext.QueryString["name"];
SummonerDto summoner = new SummonerDto();
try
{
summoner = await summoner.SearchSummoner(nameSummoner);
textBlockNomeInv.Text = summoner.Nome;
}
catch
{
MessageBox.Show("Não existe um invocador com esse nome.");
NavigationService.GoBack();
return;
}
textBlockLevel.Text += summoner.SummonerLevel.ToString();
try
{
LeagueDto leagueSummoner = new LeagueDto();
leagueSummoner = await leagueSummoner.SearchLeague(summoner.Id);
textBlockElo.Text = leagueSummoner.Tier + " " + leagueSummoner.Entries[0].Division;
textBlockVit.Text = leagueSummoner.Entries[0].Wins > 1 ? leagueSummoner.Entries[0].Wins.ToString() + " vitórias" : leagueSummoner.Entries[0].Wins.ToString() + " vitória";
textBlockDer.Text = leagueSummoner.Entries[0].Losses > 1 ? leagueSummoner.Entries[0].Losses.ToString() + " derrotas" : leagueSummoner.Entries[0].Losses.ToString() + " derrota";
}
catch
{
MessageBox.Show("Informações de derrotas e vitórias são apenas para jogadores ranqueados.", "Informação", MessageBoxButton.OK);
textBlockElo.Text = "Unranked";
textBlockVit.Text = "0 vitória";
textBlockDer.Text = "0 derrota";
}
imageInvocador.Source = await summoner.GetProfileIcon();
RecentGamesDto gamesRecent = await new RecentGamesDto().GetLatestGamesById(summoner.Id);
List <int> lastChampionsPlayed = new List <int>();
foreach (GameDto game in gamesRecent.Games)
{
lastChampionsPlayed.Add(game.ChampionId);
LastMatches controlMatch = new LastMatches(game);
controlMatch.Margin = new Thickness(0, 0, 0, 10);
controlMatch.Load();
listboxPartidas.Items.Add(controlMatch);
}
int idChampPref = lastChampionsPlayed[new Random().Next(lastChampionsPlayed.Count - 1)];
ImageBrush imgBrush = new ImageBrush();
BitmapImage source = (await ChampionDto.SearchChampionAllData(idChampPref)).GetChampionSplash(0);
imgBrush.ImageSource = source;
imgBrush.Stretch = Stretch.UniformToFill;
LayoutRoot.Background = imgBrush;
}
/// <summary>
/// data layer will determine add vs update
/// </summary>
/// <param name="league"></param>
public void Save(LeagueDto league)
{
if (ExistsInDb(league))
{
Update(league);
}
else
{
AddNew(league);
}
}
private void UpdateLeague(LeagueDto league)
{
string updateQuery = @"update League
set DeleteDate = @DeleteDate,
Name = @Name,
Password = @Password
where LeagueId = @LeagueId";
Connection.BeginTransaction();
Connection.Execute(updateQuery, league);
Connection.Commit();
}
private LeagueDto Map(LeagueModel model)
{
if (model == null)
{
return(null);
}
LeagueDto dto = new LeagueDto();
dto.caption = model.caption;
dto.league = model.league;
dto.year = model.year;
return(dto);
}
private LeagueModel Map(LeagueDto dto)
{
if (dto == null)
{
return(null);
}
LeagueModel model = new LeagueModel();
model.caption = dto.caption;
model.league = dto.league;
model.year = dto.year;
return(model);
}
public void LeagueNameBlankTest()
{
LeagueDto dto = new LeagueDto
{
LeagueId = TEST_ALTERNATE_ID,
Name = string.Empty,
Password = TEST_LEAGUE_PASSWORD
};
var result = LeagueService.AddNew(dto);
Assert.IsFalse(result.IsSuccess);
}
public void LeagueNameLengthTest()
{
LeagueDto dto = new LeagueDto
{
LeagueId = TEST_ALTERNATE_ID,
Name = TEST_LEAGUE_NAME + "dfaodsfhoas;dhg;oahg;oahego;ha;ldgjh;sadjghadfasdfadfasdgfasdgsadasdgasdgasdgasdg;kasjdhg;kjsahdg;hasdg;jhasdg;jhas;dgkjh;sadkjh;asjhg;kajhgd",
Password = TEST_LEAGUE_PASSWORD
};
var result = LeagueService.AddNew(dto);
Assert.IsFalse(result.IsSuccess);
}
private LeagueDto CreateLeagueDtoWithLinks(League league)
{
LeagueDto leagueDto = new LeagueDto
{
Name = league.Name
};
leagueDto.Links.Add(new Link(
_urlHelper.Link(nameof(GetGames), new { sport = league.Sport.Name, league = league.Name }).ToLower(),
"games",
"GET"));
return(leagueDto);
}
public Guid SeedLeague()
{
Guid id = Guid.NewGuid();
LeagueDto dto = new LeagueDto()
{
LeagueId = id,
Name = "Seed League",
Password = "******"
};
League.AddNew(dto);
return(id);
}
public LeagueDto LoadByKey(Guid leagueId)
{
LeagueDto league = null;
Connection.BeginTransaction();
var result = Connection.Query <LeagueDto>(
SELECT_QUERY + " where LeagueId = @LeagueId",
new { LeagueId = leagueId.ToString() });
league = result.FirstOrDefault();
Connection.Commit();
return(league);
}
public async Task <IActionResult> GetLeague()
{
var league = await _repo.GetLeague();
var leagueState = await _repo.GetLeagueStateForId(league.StateId);
LeagueDto leagueDto = new LeagueDto
{
Id = league.Id,
StateId = league.StateId,
Day = league.Day,
State = leagueState.State,
Year = league.Year
};
return(Ok(leagueDto));
}
public async Task SaveAsync(LeagueDto leagueDto)
{
League league;
if (leagueDto.Id > 0)
{
league = await this.GetSingleLeagueAsync(leagueDto.Id);
}
else
{
league = new League();
_context.Leagues.Add(league);
}
leagueDto.WrapIn(league, _context);
await _context.SaveChangesAsync();
}
// POST tables/League
public async Task <IHttpActionResult> PostLeague(LeagueDto item)
{
var exists = _context.Leagues.Any(l => l.Name.Equals(item.Name, System.StringComparison.InvariantCultureIgnoreCase));
if (exists)
{
return(BadRequest("The name of that league is already in use."));
}
League league = await InsertAsync(item.ToLeague());
if (league.IsAcceptingMembers)
{
NotifyAboutNewLeagueOpenEnrollment(league);
}
return(CreatedAtRoute("Tables", new { id = league.Id }, league));
}
public IActionResult Post([FromBody] LeagueDto leagueDto)
{
try
{
_addLeagueCommand.Execute(leagueDto);
return(StatusCode(201));
}
catch (EntityNotFoundException e)
{
return(NotFound(e.Message));
}
catch (EntityAlreadyExistsException e)
{
return(Conflict(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public IActionResult Put(int id, [FromBody] LeagueDto leagueDto)
{
leagueDto.Id = id;
try
{
_editLeagueCommand.Execute(leagueDto);
return(NoContent());
}
catch (EntityNotFoundException e)
{
return(Conflict(e.Message));
}
catch (EntityAlreadyExistsException e)
{
return(Conflict(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public void AddRemoveLeagueTest()
{
LeagueDto dto = new LeagueDto
{
LeagueId = TEST_ALTERNATE_ID,
Name = TEST_LEAGUE_NAME,
Password = TEST_LEAGUE_PASSWORD
};
var result = LeagueService.AddNew(dto);
Assert.IsTrue(result.IsSuccess);
//make sure the league is actually in the db
var league = LeagueService.GetLeague(TEST_ALTERNATE_ID);
Assert.IsNotNull(league);
Assert.AreEqual(TEST_LEAGUE_NAME, league.Name);
Assert.AreEqual(TEST_LEAGUE_PASSWORD, league.Password);
//make sure an update works
dto.Name = TEST_LEAGUE_NAME_2;
var nameChangeResult = LeagueService.Update(dto);
Assert.IsTrue(nameChangeResult.IsSuccess);
league = LeagueService.GetLeague(TEST_ALTERNATE_ID);
Assert.AreEqual(TEST_LEAGUE_NAME_2, league.Name);
//cleanup by deleting the record
var deleteResult = LeagueService.RemoveLeague(TEST_ALTERNATE_ID);
Assert.IsTrue(deleteResult.IsSuccess);
//make sure the league is gone
var deletedLeague = LeagueService.GetLeague(TEST_ALTERNATE_ID);
Assert.IsNull(deletedLeague);
}
public void Execute(LeagueDto request)
{
var league = Context.Leagues.Include(l => l.Clubs).Include(l => l.LeagueReferees).Where(l => l.Id == request.Id && l.IsDeleted == false).FirstOrDefault();
if (request.Level != 0)
{
league.Level = request.Level;
}
if (request.Name != null)
{
if (league.Name.ToLower() == request.Name.ToLower())
{
throw new EntityAlreadyExistsException("league");
}
league.Name = request.Name;
}
List <RefereeLeague> lista = new List <RefereeLeague>();
if (request.RefereesId != null)
{
foreach (var refereeId in request.RefereesId)
{
if (!Context.Referees.Any(l => l.Id == refereeId))
{
throw new EntityNotFoundException("Referee");
}
lista.Add(new RefereeLeague {
LeagueId = request.Id, RefereeId = refereeId
});
}
league.LeagueReferees = lista;
}
Context.SaveChanges();
}
public static League ToLeague(this LeagueDto dto)
{
return(new League
{
Id = dto.Id,
Name = dto.Name,
Description = dto.Description,
Sport = dto.Sport,
IsEnabled = dto.IsEnabled,
StartDate = dto.StartDate,
EndDate = dto.EndDate,
UpdatedAt = dto.UpdatedAt,
Season = dto.Season,
RulesUrl = dto.RulesUrl,
MaxChallengeRange = dto.MaxChallengeRange,
MinHoursBetweenChallenge = dto.MinHoursBetweenChallenge,
MatchGameCount = dto.MatchGameCount,
HasStarted = dto.HasStarted,
ImageUrl = dto.ImageUrl,
CreatedByAthleteId = dto.CreatedByAthleteId,
IsAcceptingMembers = dto.IsAcceptingMembers
});
}
public StatTableDto GetCareerGoalieTable(StatParametersDto paramDto)
{
StatTableDto statTableDto = new StatTableDto();
StatParametersDto cleanParameters = CleanCareerParameters(paramDto);
cleanParameters.Col = cleanParameters.Col ?? 1;
using (db = new BojoBoxContext())
{
LeagueDto leagueDto = GetLeague(cleanParameters.League.Value);
TeamDto teamDto = GetTeam(cleanParameters.Team.Value);
List <int> teamIds = null;
if (teamDto != null)
{
teamIds = GetFranchiseTeamIds(teamDto.Id);
}
statTableDto.Teams = GetTeamParameters(leagueDto.Id);
statTableDto.HeaderText = leagueDto.Acronym + " - Career Stats";
var goalieCareerQuery = db.GoalieSeasons.Where(a => a.LeagueId == leagueDto.Id);
if (teamDto != null)
{
goalieCareerQuery = goalieCareerQuery.Where(a => a.TeamId.HasValue && teamIds.Contains(a.TeamId.Value));
}
else
{
goalieCareerQuery = goalieCareerQuery.Where(a => a.TeamId.HasValue);
}
bool isPlayoffs = CheckIfPlayoffs(cleanParameters.SeasonType.Value);
goalieCareerQuery = goalieCareerQuery.Where(a => a.isPlayoffs == isPlayoffs);
var idStatPairs = GetIdStatPairsCareer(cleanParameters.Col, goalieCareerQuery);
idStatPairs = idStatPairs.GroupBy(a => a.Id, b => b.Stat, (x, y) => new IdStatPair(x, y.Sum()));
idStatPairs = idStatPairs.OrderByDescending(a => a.Stat);
// TODO: Check if to sort ascending
int pageSize = 20;
statTableDto.PageCount = GetPageCount(cleanParameters, idStatPairs);
var selectedGoalieIds = idStatPairs.Select(b => b.Id).Skip(cleanParameters.Page.Value * pageSize).Take(pageSize).ToArray();
var goalieRows = db.GoalieSeasons
.Include(a => a.Goalie)
.Where(a => selectedGoalieIds.Contains(a.GoalieId))
.Where(a => a.TeamId.HasValue)
.Where(a => a.LeagueId == leagueDto.Id)
.Where(a => a.isPlayoffs == isPlayoffs);
if (teamDto != null)
{
goalieRows = goalieRows.Where(a => a.TeamId.HasValue && teamIds.Contains(a.TeamId.Value));
}
statTableDto.PlayerRows = goalieRows.GroupBy(a => a.Goalie, b => b, (skater, rows) => new PlayerTableRow()
{
Player = PlayerDto.Create(skater),
Season = null,
Team = null,
SeasonCount = rows.Select(a => a.Season).Distinct().Count(),
TeamCount = rows.Where(x => x.GoalieId == skater.Id).Select(x => x.TeamId).Distinct().Count(),
Stats = new int[]
{
rows.Sum(x => x.GamesPlayed),
rows.Sum(x => x.Wins),
rows.Sum(x => x.Losses),
rows.Sum(x => x.OvertimeLosses),
rows.Sum(x => x.Minutes),
rows.Sum(x => x.PenaltyMinutes),
rows.Sum(x => x.Shutouts),
rows.Sum(x => x.GoalsAgainst),
rows.Sum(x => x.ShotsAgainst),
rows.Sum(x => x.Assists),
rows.Sum(x => x.EmptyGoalAgainst),
rows.Sum(x => x.PenaltyShotSaves),
rows.Sum(x => x.PenaltyShotAttempts),
rows.Sum(x => x.Starts),
rows.Sum(x => x.Backups),
}
})
.ToList();
statTableDto.PlayerRows = statTableDto.PlayerRows.OrderByDescending(a => a.Stats.ElementAt(cleanParameters.Col.Value)).ThenByDescending(a => a.Stats.ElementAt(4));
AddRanks(statTableDto.PlayerRows, 1 + (cleanParameters.Page.Value * pageSize));
}
statTableDto.DisplayType = "career";
statTableDto.PlayerType = "goalie";
statTableDto.StatParameters = cleanParameters;
return(statTableDto);
}
public StatTableDto GetPlayerGoalieTable(int goalieId, StatParametersDto paramDto)
{
StatTableDto statTableDto = new StatTableDto();
StatParametersDto cleanParameters = CleanPlayerParameters(paramDto);
using (db = new BojoBoxContext())
{
LeagueDto leagueDto = GetLeague(cleanParameters.League.Value);
TeamDto teamDto = GetTeam(cleanParameters.Team.Value);
PlayerDto goalieDto = GetGoalie(goalieId);
statTableDto.HeaderText = goalieDto.Name;
var goalieSeasonsQuery = db.GoalieSeasons
.Include(a => a.Goalie)
.Include(a => a.Team)
.Include(a => a.League)
.Where(a => a.GoalieId == goalieDto.Id);
bool isPlayoffs = CheckIfPlayoffs(cleanParameters.SeasonType.Value);
goalieSeasonsQuery = goalieSeasonsQuery.Where(a => a.isPlayoffs == isPlayoffs);
if (cleanParameters.League > 0)
{
goalieSeasonsQuery = goalieSeasonsQuery.Where(a => a.LeagueId == leagueDto.Id);
}
int teamCount = goalieSeasonsQuery.Where(a => a.Team != null).Select(a => a.Team.Id).Distinct().Count();
statTableDto.Teams = goalieSeasonsQuery.Select(a => a.Team).Where(a => a != null).DistinctBy(a => a.Id).Select(a => TeamDto.Create(a)).ToList();
if (cleanParameters.Team > 0)
{
goalieSeasonsQuery = goalieSeasonsQuery.Where(a => a.TeamId == cleanParameters.Team);
}
else
{
goalieSeasonsQuery = goalieSeasonsQuery.Where(a => a.SubtotalForId == null);
}
List <GoalieSeasonFullDto> goalieSeasonDtos = goalieSeasonsQuery.Select(a => GoalieSeasonFullDto.Create(a)).ToList();
int i = 1;
List <PlayerTableRow> rows = new List <PlayerTableRow>();
foreach (var dto in goalieSeasonDtos)
{
PlayerTableRow row = new PlayerTableRow();
row.Player = dto.Goalie;
row.Rank = i++;
row.Season = dto.Season;
row.Team = dto.Team;
row.Stats = GetGoalieStats(dto);
rows.Add(row);
}
if (cleanParameters.Col == null)
{
rows = rows.OrderByDescending(a => a.Season).ToList();
}
else
{
rows = rows.OrderByDescending(a => a.Stats.ElementAt(cleanParameters.Col.Value)).ThenByDescending(a => a.Stats.ElementAt(13)).ToList();
}
statTableDto.PlayerRows = rows;
List <int> totals = new List <int>();
if (rows.Any())
{
totals = GetTotals(rows);
totals.Insert(0, teamCount);
totals.Insert(0, rows.Count());
}
statTableDto.Totals = totals;
}
statTableDto.DisplayType = "player";
statTableDto.PlayerType = "goalie";
statTableDto.StatParameters = cleanParameters;
return(statTableDto);
}
public void Update(LeagueDto league)
{
UpdateLeague(league);
}
public void AddNew(LeagueDto league)
{
InsertLeague(league);
}
public static void WrapIn(this LeagueDto dto, League league, HemaneContext context)
{
league.Name = dto.Name;
league.Sport = context.Sports.Single(s => s.Id == dto.SportId);
}
public bool HasAccess(LeagueDto leagueDto)
{
return(this._userService.CurrentUser().Group == Group.Administrator);
}
