// GET: Tournaments/Details/5
public async Task <ActionResult> CreateGroup(int?id)
{
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var tournament = await db.Tournaments.FindAsync(id);
if (tournament == null)
{
return(HttpNotFound());
}
var view = new TournamentGroup {
TournamentId = tournament.TournamentId,
};
return(View(view));
}
catch (Exception ex)
{
fileshelper.ErrorLogging(ex);
return(View());
}
}
private bool Equals(TournamentGroup tournamentGroup)
{
return(tournamentGroup != null && tournamentGroup.Buyinincents == Buyinincents &&
tournamentGroup.Tourneytagscsv == Tourneytagscsv &&
tournamentGroup.SpeedtypeId == SpeedtypeId &&
tournamentGroup.PokergametypeId == PokergametypeId);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TournamentGroup tournamentGroup = await db.TournamentGroups.FindAsync(id);
db.TournamentGroups.Remove(tournamentGroup);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private async Task MakeCountriesList(Sport sportID)
{
Sportccbetdata matches = await dataManager.GetAllLiveMatchesForTodayForOneSport(sportID);
foreach (Category cat in matches.Sports.Sport.Category)
{
if (Countries.Count == 0)
{
await GetCountries();
}
var country1 = Countries.FirstOrDefault(x => x.Id == cat.Id);
foreach (Tournament tour in cat.Tournaments)
{
var tournamentGroup = new TournamentGroup()
{
Name = tour.Name
};
foreach (Match match in tour.Match)
{
var matchIndex = 0;
Match obj = country1.Matches.FirstOrDefault(x => x.Id == match.Id);
if (obj == null)
{
country1.Matches.Add(match);
Matches.Add(match);
match.CountryID = country1.Id;
}
else
{
Matches.Add(match);
match.CountryID = country1.Id;
matchIndex = country1.Matches.IndexOf(obj);
country1.Matches[matchIndex].Result = match.Result;
country1.Matches[matchIndex].Minutes = match.Minutes;
}
foreach (Competitor com in match.Competitors.Competitor)
{
if (com.Type == "1")
{
match.HomeTeam = com;
}
if (com.Type == "2")
{
match.AwayTeam = com;
}
}
if (!Tournaments.Contains(tournamentGroup))
{
Tournaments.Add(tournamentGroup);
}
}
}
CategoriesWithLiveGames.Add(cat);
}
}
public async Task <ActionResult> EditGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.Entry(tournamentGroup).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = tournamentGroup.TournamentId }));
}
return(View(tournamentGroup));
}
public async Task <ActionResult> CreateGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.TournamentGroups.Add(tournamentGroup);
await db.SaveChangesAsync();
return(RedirectToAction(string.Format("Details/{0}", tournamentGroup.TournamentId)));
}
return(View(tournamentGroup));
}
public async Task <ActionResult> EditGroup(TournamentGroup view)
{
if (ModelState.IsValid)
{
db.Entry(view).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction($"Details/{view.TournamentId}"));
}
return(View(view));
}
public async Task <ActionResult> Edit([Bind(Include = "TournamentGroupId,Name,TournamentId")] TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.Entry(tournamentGroup).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.TournamentId = new SelectList(db.Tournaments, "TournamentId", "Name", tournamentGroup.TournamentId);
return(View(tournamentGroup));
}
public async Task <ActionResult> EditGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.Entry(tournamentGroup).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction(string.Format("Details/{0}", tournamentGroup.TournamentId)));
}
// ViewBag.TournamentId = new SelectList(db.Tournaments, "TournamentId", "Name", tournamentGroup.TournamentId);
return(View(tournamentGroup));
}
public async Task <ActionResult> CreateGroup(TournamentGroup view)
{
if (ModelState.IsValid)
{
db.TournamentGroups.Add(view);
await db.SaveChangesAsync();
return(RedirectToAction($"Details/{view.TournamentId}"));
}
return(View(view));
}
// GET: TournamentGroups/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TournamentGroup tournamentGroup = await db.TournamentGroups.FindAsync(id);
if (tournamentGroup == null)
{
return(HttpNotFound());
}
return(View(tournamentGroup));
}
// GET: TournamentGroups/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TournamentGroup tournamentGroup = await db.TournamentGroups.FindAsync(id);
if (tournamentGroup == null)
{
return(HttpNotFound());
}
ViewBag.TournamentId = new SelectList(db.Tournaments, "TournamentId", "Name", tournamentGroup.TournamentId);
return(View(tournamentGroup));
}
public ActionResult CreateGroup(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var tournament = db.Tournaments.Find(id);
var tournamentGroup = new TournamentGroup
{
TournamentId = tournament.TournamentId
};
return(View(tournamentGroup));
}
public async Task <ActionResult> EditTournamentGroup(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TournamentGroup tournamentGroup = await db.TournamentGroups.FindAsync(id);
ViewData["Tournamet"] = tournamentGroup.Tournament.Name;
if (tournamentGroup == null)
{
return(HttpNotFound());
}
return(View(tournamentGroup));
}
public async Task <ActionResult> EditGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.Entry(tournamentGroup).State = EntityState.Modified;
var response = await DBHelper.SaveChangesAsync(db);
if (response.Succeeded)
{
return(RedirectToAction(string.Format("Details/{0}", tournamentGroup.TournamentId)));
}
ModelState.AddModelError(string.Empty, response.Message);
}
return(View(tournamentGroup));
}
public async Task <ActionResult> CreateGroup(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var tournament = await db.Tournaments.FindAsync(id);
if (tournament == null)
{
return(HttpNotFound());
}
var view = new TournamentGroup {
TournamentId = tournament.TournamentId,
};
return(View(view));
}
public async Task <ActionResult> DeleteGroup(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TournamentGroup tournamentGroup = await db.TournamentGroups.FindAsync(id);
if (tournamentGroup == null)
{
return(HttpNotFound());
}
db.TournamentGroups.Remove(tournamentGroup);
await db.SaveChangesAsync();
return(RedirectToAction($"Details/{tournamentGroup.TournamentId}"));
}
public async Task <ActionResult> EditTournamentGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.Entry(tournamentGroup).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (Exception)
{
}
return(RedirectToAction($"Details/{tournamentGroup.TournamentId}"));
}
ViewBag.TournamentId = new SelectList(db.Tournaments, "TournamentId", "Name", tournamentGroup.TournamentId);
return(View(tournamentGroup));
}
public async Task <ActionResult> CreateTournamenGroup(TournamentGroup tournamentGroup)
{
if (ModelState.IsValid)
{
db.TournamentGroups.Add(tournamentGroup);
try
{
await db.SaveChangesAsync();
}
catch (Exception)
{
}
return(RedirectToAction($"Details/{tournamentGroup.TournamentId}"));
}
return(View(tournamentGroup));
}
private void groupSystem_CheckedChanged(object sender, EventArgs e)
{
TournamentGroup finalGroup = new TournamentGroup {
Group = new Dictionary <string, ITournamentParticipant>()
};
foreach (var group in Groups)
{
var element = group.Value.Group.OrderBy(m => m.Value.Score.Points).Last();
finalGroup.Group.Add(element.Key, element.Value);
}
int tempY = startY;
AddTournamentParticipantsLabels <ITournamentGroup, ITournamentParticipant>(new[] { finalGroup }, AddParticipantWithScoreLabel);
PrintMatches(new Dictionary <int, TournamentGroup> {
{ 1, finalGroup }
}, X, tempY);
}
public async Task <ActionResult> CreateTournamenGroup(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var tournament = await db.Tournaments.FindAsync(id);
if (tournament == null)
{
return(HttpNotFound());
}
ViewData["Tournamet"] = tournament.Name;
//aqui retorono all object have this id del tournametGrpup with your toournament;
var view = new TournamentGroup()
{
TournamentId = tournament.TournamentId,
};
return(View(view));
}
private async Task GetAllMatches(DateTime dt)
{
i++;
Sport spor = new Sport {
Id = "1"
};
SportMatches = await dataManager.GetAllMatchesForTodayForOneSport(spor, dt);
MatchesToday.Clear();
Tournaments.Clear();
foreach (Category cat in SportMatches.Sports.Sport.Category)
{
if (Countries.Count == 0)
{
await GetCountries();
}
var country3 = CountriesWithLiveGamesToday.FirstOrDefault(x => x.Id == cat.Id);
foreach (Tournament tour in cat.Tournaments)
{
var tournamentGroup = new TournamentGroup()
{
Name = tour.Name
};
foreach (Match match in tour.Match)
{
Match obj = country3.Matches.FirstOrDefault(x => x.Id == match.Id);
if (obj == null)
{
country3.Matches.Add(match);
MatchesToday.Add(match);
match.CountryID = country3.Id;
tournamentGroup.Add(match);
}
else
{
MatchesToday.Add(match);
match.CountryID = country3.Id;
tournamentGroup.Add(match);
}
foreach (Competitor com in match.Competitors.Competitor)
{
if (com.Type == "1")
{
match.HomeTeam = com;
}
if (com.Type == "2")
{
match.AwayTeam = com;
}
}
match.TournamentName = tour.Name;
match.TournamentId = tour.Id;
match.HasTable = tour.Hastable;
}
tournamentGroup.Date = dt.ToString("d" + ". " + "MMM");
tournamentGroup.LeaguePicture = SetLeaguePicture(tour, cat);
if (!Tournaments.Contains(tournamentGroup))
{
Tournaments.Add(tournamentGroup);
}
}
}
}
public static List <Tournament> ParseHLReport(string filepath, RTADatabaseContext context)
{
var tournaments = new List <Tournament>();
var data = File.ReadAllText(filepath).Split(new[] { "@tourn@" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var entry in data)
{
var tournEntry = entry.Split(new[] { "@group@" }, StringSplitOptions.RemoveEmptyEntries);
var tournamentGroups = new List <TournamentGroup>();
var tournamentPlayers = new List <TournamentPlayer>();
var tournData = tournEntry[0].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
var mapVersion = tournData[7];
var map = context.Maps.FirstOrDefault(m => m.Version == mapVersion);
if (map == null)
{
map = new Map {
Version = mapVersion
};
context.Maps.Add(map);
}
var tournament = new Tournament
{
IsFinished = true,
IsOfficial = true,
IsArchived = true,
NameRus = tournData[0],
NameEng = tournData[1],
Year = int.Parse(tournData[2]),
IsSeasonal = bool.Parse(tournData[3]),
Season = byte.Parse(tournData[4]),
IsPrivate = bool.Parse(tournData[5]),
DateCreated = DateTime.ParseExact(tournData[6], "yyyy.MM.dd", null),
Map = map,
Description = new TournamentDescription
{
//ContentRus =
//ContentEng =
}
};
for (int i = 1; i < tournEntry.Length; i++)
{
var groupEntry = tournEntry[i].Split('#');
var groupData = groupEntry[0].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
var group = new TournamentGroup
{
NameRus = groupData[0],
NameEng = groupData[1],
GroupFormatId = byte.Parse(groupData[2])
};
var matches = new List <Match>();
var tournamentGroupPlayers = new List <TournamentGroupPlayer>();
var matchData = groupEntry[1].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in matchData)
{
var matchEntry = line.Replace("[confirmed]", "").Replace("[/confirmed]", "").
Replace("[open]", "").Replace("[/open]", "").Replace("[denied]", "").Replace("[/denied]", "").Split(';');
var players = matchEntry[0].Split(' ');
var player1Name = players[0];
var player2Name = players[2];
var player1 = context.Players.FirstOrDefault(p => p.Name == player1Name);
if (player1 == null)
{
player1 = new Player
{
Name = player1Name,
GuidKey = Guid.NewGuid().ToString(),
Stats = new PlayerStats
{
RatingClass = "B",
RatingPointsCurrent = 1200,
RatingPointsMax = 1200
}
};
context.Players.Add(player1);
}
var player2 = context.Players.FirstOrDefault(p => p.Name == player2Name);
if (player2 == null)
{
player2 = new Player
{
Name = player2Name,
GuidKey = Guid.NewGuid().ToString(),
Stats = new PlayerStats
{
RatingClass = "B",
RatingPointsCurrent = 1200,
RatingPointsMax = 1200
}
};
context.Players.Add(player2);
}
var games = new List <Game>();
for (int j = 1; j < matchEntry.Length - 2; j++)
{
var items = matchEntry[j].Replace(",", "").
Replace("Lazlo", "Laszlo").Replace("Shadwyn", "Ylaya").Replace("Gilrean", "Gilraen").Replace("Vlad", "Vladimir").Replace("Timerkhan", "Temkhan").
Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (items[0] != "?" && items[4] != "?")
{
var faction1Id = factionDictEng[items[0]];
var hero1 = items[1];
if (hero1 == "?" && faction1Id == 1)
{
hero1 = "Temkhan";
}
else if (hero1 == "?" && faction1Id == 6)
{
hero1 = "Arthas";
}
var faction2Id = factionDictEng[items[3]];
var hero2 = items[4];
if (hero2 == "?" && faction1Id == 1)
{
hero2 = "Temkhan";
}
else if (hero2 == "?" && faction1Id == 6)
{
hero2 = "Arthas";
}
if (hero1 != "?" && hero2 != "?")
{
bool player1Won = items[2] == ">";
var game = new Game
{
IsConfirmed = true,
Faction1Id = faction1Id,
Hero1Id = context.Heroes.FirstOrDefault(h => h.NameEng == hero1).Id,
Player1Won = player1Won,
Faction2Id = faction2Id,
Hero2Id = context.Heroes.FirstOrDefault(h => h.NameEng == hero2).Id,
DateSubmitted = DateTime.ParseExact(matchEntry[matchEntry.Length - 1], "yyyy.MM.dd", null),
};
SeedStatsUpdater.UpdateStats(player1.Stats, player2.Stats, faction1Id, faction2Id, player1Won);
context.SaveChanges();
games.Add(game);
}
}
}
var tournamentPlayer = tournamentPlayers.FirstOrDefault(tp => tp.Player == player1);
if (tournamentPlayer == null)
{
tournamentPlayer = new TournamentPlayer
{
Player = player1
};
tournamentPlayers.Add(tournamentPlayer);
}
if (!tournamentGroupPlayers.Any(tgp => tgp.TournamentPlayer == tournamentPlayer))
{
tournamentGroupPlayers.Add(new TournamentGroupPlayer {
TournamentPlayer = tournamentPlayer
});
}
tournamentPlayer = tournamentPlayers.FirstOrDefault(tp => tp.Player == player2);
if (tournamentPlayer == null)
{
tournamentPlayer = new TournamentPlayer
{
Player = player2
};
tournamentPlayers.Add(tournamentPlayer);
}
if (!tournamentGroupPlayers.Any(tgp => tgp.TournamentPlayer == tournamentPlayer))
{
tournamentGroupPlayers.Add(new TournamentGroupPlayer {
TournamentPlayer = tournamentPlayer
});
}
var date = matchEntry[matchEntry.Length - 1];
var score = matchEntry[matchEntry.Length - 2].Split(' ');
var match = new Match
{
Player1 = player1,
Player2 = player2,
Games = games,
IsFinished = true,
DateFinished = DateTime.ParseExact(date, "yyyy.MM.dd", null),
Player1Score = int.Parse(score[0]),
Player2Score = int.Parse(score[2]),
};
matches.Add(match);
}
group.Matches = matches;
group.TournamentGroupPlayers = tournamentGroupPlayers;
tournamentGroups.Add(group);
}
tournament.TournamentPlayers = tournamentPlayers;
tournament.TournamentGroups = tournamentGroups;
tournaments.Add(tournament);
}
;
return(tournaments);
}