public IActionResult AddMatch(MatchFormViewModel model)
{
bool allowedToEdit = this.roundService
.IsUserAllowedToEdit(model.RoundId, User.Identity.Name);
if (!allowedToEdit)
{
TempData.AddErrorMessage(MessageResources.msgNotAllowedToAddMatchForThisRound);
return(RedirectToAction(nameof(All), new { roundId = model.RoundId }));
}
if (!ModelState.IsValid)
{
model.Teams = GetSelectListItemTeams(model.LeagueId);
return(View(model));
}
this.matchService.Create(model.HomeTeam,
model.AwayTeam,
model.HomeWinPoints,
model.DrawPoints,
model.AwayWinPoints,
model.MatchStart,
model.RoundId,
model.LeagueId);
this.TempData.AddSuccessMessage(MessageResources.msgSuccessfullyAdded);
return(RedirectToAction(nameof(All), new { roundId = model.RoundId }));
}
// GET: Matches/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var match = await _context.Matchs
.Include(m => m.Sides)
.Include(m => m.Rounds)
.ThenInclude(r => r.Sides)
.FirstOrDefaultAsync(m => m.MatchID == id);
if (match == null)
{
return(NotFound());
}
SortModel(match);
var vm = new MatchFormViewModel();
vm.Match = match;
await PrepareDrowdownLists(vm);
return(View(vm));
}
private async Task ConsolidateMatchForm(MatchFormViewModel vm)
{
var maps = await _context.Layouts.Where(m => m.Left != null && m.Right != null).ToListAsync();
for (var s = 0; s < 2; ++s)
{
var side = vm.Match.Sides[s];
side.Match = vm.Match;
side.Number = s + 1;
}
for (var r = 0; r < vm.Match.Rounds.Count; ++r)
{
var round = vm.Match.Rounds[r];
round.Number = r + 1;
round.Match = vm.Match;
var map = maps.FirstOrDefault(m => m.GameLayoutID == round.GameLayoutID);
for (var s = 0; s < 2; ++s)
{
var roundSide = round.Sides[s];
roundSide.Round = round;
roundSide.MatchSide = vm.Match.Sides[s];
roundSide.GameSide = GetSide(r, s);
if (map != null)
{
roundSide.Faction = roundSide.GameSide == GameSide.Left ? map.Left : map.Right;
}
}
}
}
public async Task <IActionResult> Create(MatchFormViewModel vm, string applyTemplate)
{
ApplyTemplate(vm);
if (ModelState.IsValid && string.IsNullOrEmpty(applyTemplate))
{
_context.Add(vm.Match);
foreach (var side in vm.Match.Sides)
{
_context.Add(side);
}
foreach (var round in vm.Match.Rounds)
{
_context.Add(round);
}
foreach (var roundSide in vm.Match.Rounds.SelectMany(r => r.Sides))
{
_context.Add(roundSide);
}
await _context.SaveChangesAsync();
if (!string.IsNullOrEmpty(vm.Match.WorldName))
{
await CreateTacMap(vm);
_context.Update(vm.Match);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
await PrepareDrowdownLists(vm);
return(View(vm));
}
public void Initialize()
{
this.businessLayer = new Mock <ILeagueService>();
this.regionManager = new Mock <IRegionManager>();
this.viewModel = new MatchFormViewModel(this.regionManager.Object, this.businessLayer.Object);
this.navigationContext = new NavigationContext(new Mock <IRegionNavigationService>().Object, new Uri("http://www.test.com"));
}
private async Task PrepareDrowdownLists(MatchFormViewModel vm)
{
vm.WorldNameDropdownList = (await _mapInfos.GetMapsInfos()).OrderBy(s => s.title)
.Select(m => new SelectListItem(m.title, m.worldName)).ToList();
vm.FactionsDropdownList = (await _context.Factions.OrderBy(m => m.Name).ToListAsync())
.Select(m => new SelectListItem(m.Name, m.FactionID.ToString())).ToList();
vm.FactionsData = await _context.Factions.ToListAsync();
}
private void ApplyTemplate(MatchFormViewModel vm)
{
int wantedRounds;
int wantedSides;
switch (vm.Match.Template)
{
default:
case MatchTemplate.SingleSideCooperative:
wantedRounds = 1;
wantedSides = 1;
break;
case MatchTemplate.TwoRoundsTwoSidesCompetitive:
wantedRounds = 2;
wantedSides = 2;
break;
case MatchTemplate.TwoRoundsThreeSidesCompetitive:
wantedRounds = 2;
wantedSides = 3;
break;
}
if (vm.Match.Rounds.Count > wantedRounds)
{
vm.Match.Rounds.RemoveRange(wantedRounds, vm.Match.Rounds.Count - wantedRounds);
}
else if (vm.Match.Rounds.Count < wantedRounds)
{
vm.Match.Rounds.AddRange(Enumerable.Range(vm.Match.Rounds.Count, wantedRounds - vm.Match.Rounds.Count).Select(i => new Round()
{
Number = i + 1, Sides = new List <RoundSide>()
}));
}
if (vm.Match.Sides.Count > wantedSides)
{
vm.Match.Sides.RemoveRange(wantedSides, vm.Match.Sides.Count - wantedSides);
foreach (var round in vm.Match.Rounds)
{
round.Sides.RemoveRange(wantedSides, round.Sides.Count - wantedSides);
}
}
else if (vm.Match.Sides.Count < wantedSides)
{
vm.Match.Sides.AddRange(Enumerable.Range(vm.Match.Sides.Count, wantedSides - vm.Match.Sides.Count).Select(i => new MatchSide()
{
Name = "Equipe " + ViewHelper.SideName(i), Number = i + 1, MaxUsersCount = 20
}));
foreach (var round in vm.Match.Rounds)
{
round.Sides.AddRange(Enumerable.Range(round.Sides.Count, wantedSides - round.Sides.Count).Select(i => new RoundSide()));
}
}
ConsolidateMatchForm(vm);
}
private async Task CreateTacMap(MatchFormViewModel vm)
{
vm.Match.TacMapId = (await _tacMaps.Create(new ApiTacMapCreate()
{
WorldName = vm.Match.WorldName,
Label = vm.Match.Name,
EventHref = new Uri(Url.Action(nameof(EventsController.Details), ControllersName.Events, new { id = vm.Match.MatchID }, Request.Scheme)),
})).Id;
}
// GET: Matches
public ActionResult Create()
{
var viewModel = new MatchFormViewModel
{
Clubs = _context.Clubs.OrderBy(c => c.Name).ToList()
};
return(View(viewModel));
}
private async Task PrepareDrowdownLists(MatchFormViewModel vm)
{
var maps = await _context.Layouts.Include(m => m.GameMap).Where(m => m.Left != null && m.Right != null).OrderBy(m => m.Name).ToListAsync();
vm.MapsDropdownList = maps.GroupBy(m => m.GameMap).SelectMany(g => {
var grp = new SelectListGroup()
{
Name = g.Key.Name
};
return(g.Select(m => new SelectListItem(m.Name, m.GameLayoutID.ToString())
{
Group = grp
}));
}).ToList();
vm.MapsDropdownList.Insert(0, new SelectListItem("(Autre / Non précisé)", ""));
vm.MapsData = maps;
}
public async Task <IActionResult> Create(MatchFormViewModel vm, string addmap, string removemap)
{
if (!string.IsNullOrEmpty(addmap))
{
vm.Match.Rounds.Add(
new Round()
{
Number = vm.Match.Rounds.Count() + 1,
Sides = new List <RoundSide>()
{
new RoundSide(),
new RoundSide()
}
}
);
}
else if (!string.IsNullOrEmpty(removemap))
{
vm.Match.Rounds.RemoveAt(vm.Match.Rounds.Count - 1);
}
else if (ModelState.IsValid)
{
await ConsolidateMatchForm(vm);
_context.Add(vm.Match);
foreach (var side in vm.Match.Sides)
{
_context.Add(side);
}
foreach (var round in vm.Match.Rounds)
{
_context.Add(round);
}
foreach (var roundSide in vm.Match.Rounds.SelectMany(r => r.Sides))
{
_context.Add(roundSide);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
await PrepareDrowdownLists(vm);
return(View(vm));
}
// GET: Matches/Create
public async Task <IActionResult> Create()
{
var vm = new MatchFormViewModel();
vm.Match = new Match()
{
Date = DateTime.Today,
StartTime = new DateTime(1, 1, 1, 21, 0, 0),
Sides = new List <MatchSide>(),
Template = MatchTemplate.SingleSideCooperative,
Rounds = new List <Round>(),
RulesLink = "/Events/Rules"
};
ApplyTemplate(vm);
await PrepareDrowdownLists(vm);
return(View(vm));
}
public ActionResult Create(MatchFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("Create", viewModel));
}
var match = new Match
{
UserId = User.Identity.GetUserId(),
DateTime = viewModel.GetDateTime(),
HomeTeamId = viewModel.HomeTeam,
OutTeamId = viewModel.OutTeam,
Stadium = viewModel.Stadium,
};
_context.Matches.Add(match);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
private void ConsolidateMatchForm(MatchFormViewModel vm)
{
for (var s = 0; s < vm.Match.Sides.Count; ++s)
{
var side = vm.Match.Sides[s];
side.Match = vm.Match;
side.Number = s + 1;
}
for (var r = 0; r < vm.Match.Rounds.Count; ++r)
{
var round = vm.Match.Rounds[r];
round.Number = r + 1;
round.Match = vm.Match;
for (var s = 0; s < round.Sides.Count; ++s)
{
var roundSide = round.Sides[s];
roundSide.Round = round;
roundSide.MatchSide = vm.Match.Sides[s];
//roundSide.GameSide = GetSide(r, s);
}
}
}
// GET: Matches/Create
public async Task <IActionResult> Create()
{
var vm = new MatchFormViewModel();
vm.Match = new Match()
{
Date = DateTime.Today,
StartTime = new DateTime(1, 1, 1, 21, 0, 0),
Sides = new List <MatchSide>()
{
new MatchSide()
{
Name = "Equipe A", Number = 1
},
new MatchSide()
{
Name = "Equipe B", Number = 2
}
},
Rounds = new List <Round>()
{
new Round()
{
Number = 1,
Sides = new List <RoundSide>()
{
new RoundSide(),
new RoundSide()
}
}
}
};
await PrepareDrowdownLists(vm);
return(View(vm));
}
public async Task <IActionResult> Edit(int id, MatchFormViewModel vm, string addmap, string removemap)
{
if (id != vm.Match.MatchID)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(addmap))
{
vm.Match.Rounds.Add(
new Round()
{
Number = vm.Match.Rounds.Count() + 1,
Sides = new List <RoundSide>()
{
new RoundSide(),
new RoundSide()
}
}
);
}
else if (!string.IsNullOrEmpty(removemap))
{
vm.Match.Rounds.RemoveAt(vm.Match.Rounds.Count - 1);
}
else if (ModelState.IsValid)
{
await ConsolidateMatchForm(vm);
try
{
_context.Update(vm.Match);
foreach (var side in vm.Match.Sides)
{
_context.Update(side);
}
foreach (var round in vm.Match.Rounds)
{
if (round.RoundID == 0)
{
_context.Add(round);
}
else
{
_context.Update(round);
}
}
foreach (var roundSide in vm.Match.Rounds.SelectMany(r => r.Sides))
{
if (roundSide.RoundSideID == 0)
{
_context.Add(roundSide);
}
else
{
_context.Update(roundSide);
}
}
var remains = vm.Match.Rounds.Where(r => r.RoundID != 0).Select(r => r.RoundID).ToList();
foreach (var removed in _context.Rounds.Where(r => r.MatchID == vm.Match.MatchID && !remains.Contains(r.RoundID)).ToList())
{
_context.Remove(removed);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MatchExists(vm.Match.MatchID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
await PrepareDrowdownLists(vm);
return(View(vm));
}
public async Task <IActionResult> Edit(int id, MatchFormViewModel vm, string applyTemplate)
{
if (id != vm.Match.MatchID)
{
return(NotFound());
}
ApplyTemplate(vm);
if (ModelState.IsValid && string.IsNullOrEmpty(applyTemplate))
{
ConsolidateMatchForm(vm);
try
{
await LoadTacMap(vm.Match);
if (!string.IsNullOrEmpty(vm.Match.WorldName))
{
if (vm.Match.TacMapId == null || vm.Match.TacMap.WorldName != vm.Match.WorldName)
{
await CreateTacMap(vm);
}
else if (vm.Match.TacMap.Label != vm.Match.Name)
{
await _tacMaps.Update(vm.Match.TacMap.Id, new ApiTacMapPatch()
{
Label = vm.Match.Name
});
}
}
_context.Update(vm.Match);
foreach (var side in vm.Match.Sides)
{
_context.Update(side);
if (side.SquadsPolicy == SquadsPolicy.SquadsAndSlotsRestricted)
{
var squadsToRestrict = await _context.RoundSquads.Where(s => s.Side.MatchSideID == side.MatchSideID && !s.RestrictTeamComposition).ToListAsync();
foreach (var squad in squadsToRestrict)
{
squad.RestrictTeamComposition = true;
_context.Update(squad);
}
}
}
foreach (var round in vm.Match.Rounds)
{
if (round.RoundID == 0)
{
_context.Add(round);
}
else
{
_context.Update(round);
}
}
foreach (var roundSide in vm.Match.Rounds.SelectMany(r => r.Sides))
{
if (roundSide.RoundSideID == 0)
{
_context.Add(roundSide);
}
else
{
_context.Update(roundSide);
}
}
var remains = vm.Match.Rounds.Where(r => r.RoundID != 0).Select(r => r.RoundID).ToList();
foreach (var removed in _context.Rounds.Where(r => r.MatchID == vm.Match.MatchID && !remains.Contains(r.RoundID)).ToList())
{
_context.Remove(removed);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MatchExists(vm.Match.MatchID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
await PrepareDrowdownLists(vm);
return(View(vm));
}
