public async Task <IActionResult> Create(User user)
{
if (ModelState.IsValid)
{
_context.Add(user);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Create([Bind("VideoID,VideoLink,Title,Image,Date,MatchID")] Video video)
{
if (ModelState.IsValid)
{
video.Date = DateTime.Now;
if (string.IsNullOrEmpty(video.Title) || string.IsNullOrEmpty(video.Image))
{
var request = new HttpRequestMessage(HttpMethod.Get, video.VideoLink);
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var doc = new HtmlDocument();
doc.LoadHtml(await response.Content.ReadAsStringAsync());
video.Image = doc.DocumentNode.SelectSingleNode("//meta[@property='og:image']")?.GetAttributeValue("content", "");
video.Title = doc.DocumentNode.SelectSingleNode("//meta[@name='title']")?.GetAttributeValue("content", "");
}
}
_context.Add(video);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MatchID"] = new SelectList(_context.Matchs, "MatchID", "Name", video.MatchID);
return(View(video));
}
public async Task <IActionResult> Create(RoundSquadFormViewModel vm)
{
await PrepareViewModel(vm);
if (ModelState.IsValid)
{
for (int i = 0; i < vm.Squad.Slots.Count; ++i)
{
var slot = vm.Squad.Slots[i];
slot.Squad = vm.Squad;
}
using (var transac = await _context.Database.BeginTransactionAsync())
{
if (await CheckUserAvailibilty(vm))
{
await PrepareDrowndownList(vm);
return(View(vm));
}
await ComputeSquadNumber(vm.Squad);
vm.Squad.Slots = vm.Squad.Slots.Where(s => s.Role != null).ToList();
vm.Squad.SlotsCount = vm.Squad.Slots.Count();
NormalizeSlotsNumber(vm);
_context.Add(vm.Squad);
foreach (var slot in vm.Squad.Slots)
{
_context.Add(slot);
}
await _context.SaveChangesAsync();
await transac.CommitAsync();
}
return(RedirectToRound(vm.Squad));
}
await PrepareDrowndownList(vm);
return(View(vm));
}
public async Task <IActionResult> Create([Bind("ContentBlockID,Kind,Title,OrderNum,Content")] ContentBlock contentBlock)
{
if (ModelState.IsValid)
{
_context.Add(contentBlock);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(contentBlock));
}
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 async Task <IActionResult> Create([Bind("DocumentID,Type,Link,Title,Date,MatchID")] Document document)
{
if (ModelState.IsValid)
{
document.Date = DateTime.Now;
_context.Add(document);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MatchID"] = new SelectList(_context.Matchs, "MatchID", "Name", document.MatchID);
return(View(document));
}
public async Task <IActionResult> Create([Bind("NewsID,Title,Content,MatchID")] News news)
{
if (ModelState.IsValid)
{
news.Date = DateTime.Now;
news.LastUpdate = news.Date;
_context.Add(news);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MatchID"] = new SelectList(_context.Matchs, "MatchID", "Name", news.MatchID);
return(View(news));
}
public async Task <IActionResult> Create(MatchTechnicalInfos matchTechnicalInfos, IFormFile modpack)
{
if (ModelState.IsValid)
{
await ProcessModpack(matchTechnicalInfos, modpack);
_context.Add(matchTechnicalInfos);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(AdminMatchsController.Details), ControllersName.AdminMatchs, new { id = matchTechnicalInfos.MatchID }));
}
await LoadInformations(matchTechnicalInfos);
return(View(matchTechnicalInfos));
}
public async Task <IActionResult> Password([Bind("Login,OldPassword,Password,PasswordRepeat")] PasswordViewModel vm)
{
var user = await UserHelper.GetUser(_context, User);
if (user == null)
{
return(NotFound());
}
var userPwd = await _context.UserLogins.FirstOrDefaultAsync(u => u.UserID == user.UserID);
if (vm.Password != vm.PasswordRepeat)
{
ModelState.AddModelError("PasswordRepeat", "Les deux mots de passe ne correspondent pas.");
}
else if (await _context.UserLogins.AnyAsync(u => u.UserID != user.UserID && u.Login.ToLower() == vm.Login.ToLower()))
{
ModelState.AddModelError("Login", "Le nom d'utilisateur est déjà utilisé.");
}
else if (userPwd != null && !userPwd.IsValidPassword(vm.OldPassword))
{
ModelState.AddModelError("OldPassword", "L'ancien mot de passe ne corresponds pas.");
}
else if (ModelState.IsValid)
{
if (userPwd != null)
{
userPwd.Login = vm.Login;
userPwd.SetPassword(vm.Password);
_context.Update(userPwd);
}
else
{
userPwd = new UserLogin();
userPwd.UserID = user.UserID;
userPwd.Login = vm.Login;
userPwd.SetPassword(vm.Password);
_context.Add(userPwd);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
vm.OldPassword = string.Empty;
vm.Password = string.Empty;
vm.PasswordRepeat = string.Empty;
vm.NeedOldPassword = userPwd != null;
return(View(vm));
}
public async Task <IActionResult> Create(MatchUserCreateViewModel vm)
{
if (ModelState.IsValid)
{
_context.Add(vm.MatchUser);
await _context.SaveChangesAsync();
using (var transac = await _context.Database.BeginTransactionAsync())
{
await ApplyUserSlots(vm);
await _context.SaveChangesAsync();
await transac.CommitAsync();
}
return(RedirectToAction(nameof(Details), ControllersName.AdminMatchs, new { id = vm.MatchUser.MatchID }, "users"));
}
PrepareEditViewModel(vm);
return(View(vm));
}
public async Task <IActionResult> SubscriptionInitial(int id, SubscriptionInitialViewModel vm)
{
var match = await _context.Matchs.Include(m => m.Sides).FirstOrDefaultAsync(m => m.MatchID == id);
if (match == null)
{
return(NotFound());
}
if (match.State != MatchState.Open)
{
return(RedirectToAction(nameof(Details), new { id }));
}
if (!vm.AcceptMatchRules)
{
ModelState.AddModelError("AcceptMatchRules", "Vous devez accepter le réglement de l'opération");
}
if (!vm.AcceptSubscription)
{
ModelState.AddModelError("AcceptSubscription", "Vous devez accepter le traitement des données nécessaires à votre inscription");
}
if (!ModelState.IsValid)
{
vm.Match = match;
return(View("SubscriptionInitial", vm));
}
using (var transaction = await _context.Database.BeginTransactionAsync())
{
var user = await GetUser();
if (user == null)
{
vm.User.SteamId = UserHelper.GetSteamId(User);
vm.User.SteamName = User.Identity.Name;
vm.User.UserID = 0;
_context.Add(vm.User);
await _context.SaveChangesAsync();
user = vm.User;
}
var matchUser = await _context.MatchUsers.FirstOrDefaultAsync(u => u.MatchID == id && u.UserID == user.UserID);
if (matchUser == null)
{
if (vm.RoundSquadID != null)
{
// Vérifie que RoundSquadID appartient bien à MatchID
vm.RoundSquadID = await _context.RoundSquads.Where(s => s.RoundSquadID == vm.RoundSquadID && s.Side.MatchSide.MatchID == id).Select(s => s.RoundSquadID).FirstOrDefaultAsync();
// Calcule MatchSideID
vm.MatchSideID = await _context.RoundSquads.Where(s => s.RoundSquadID == vm.RoundSquadID && s.Side.MatchSide.MatchID == id).Select(s => s.Side.MatchSideID).FirstOrDefaultAsync();
}
else if (vm.MatchSideID != null)
{
// Vérifie que MatchSideID appartient bien à MatchID
vm.MatchSideID = await _context.MatchSides.Where(s => s.MatchSideID == vm.MatchSideID && s.MatchID == id).Select(s => s.MatchSideID).FirstOrDefaultAsync();
}
else
{
if (await _context.MatchSides.CountAsync(s => s.MatchID == id) == 1)
{
vm.MatchSideID = (await _context.MatchSides.FirstAsync(s => s.MatchID == id)).MatchSideID;
}
}
matchUser = new MatchUser()
{
MatchID = id, UserID = vm.User.UserID, MatchSideID = vm.MatchSideID
};
if (matchUser.MatchSideID == null || await CanJoin(matchUser))
{
_context.Add(matchUser);
await _context.SaveChangesAsync();
}
}
await transaction.CommitAsync();
}
return(RedirectToAction(nameof(Subscription), new { id }));
}
