public async Task <IActionResult> Register(RegisterModel registerModel)
{
if (ModelState.IsValid && registerModel != null)
{
var user = new SimUser {
UserName = registerModel.Username, Email = registerModel.Email, LastLogin = DateTime.Now
};
var result = await UserManager.CreateAsync(user, registerModel.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
_ = await UserManager.AddToRoleAsync(user, Constants.RoleGuest);
await _signInManager.SignInAsync(user, isPersistent : true);
return(RedirectToAction("Index", "Home", new { message = $"Registration was succesful.\nWelcome {registerModel.Username}!" }));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(View());
}
private static ClientContext InitializeSimulatedAPI(Uri url)
{
var context = SimClientContext.Initialize(url);
SimClientRuntimeContext.Initialize();
SimUser.Initialize();
SimWeb.Initialize();
SimListItemCollection.Initialize();
SimListCollection.Initialize();
return(context);
}
public async Task <IActionResult> AddTeamToUser(string userId)
{
SimUser user = await UserManager.FindByIdAsync(userId);
if (user is null)
{
return(NotFound());
}
AddTeamToUserModel viewModel = new AddTeamToUserModel(user, user.Teams, GetTeamsNotOwnedByUser(user));
return(View(viewModel));
}
private List <Team> GetTeamsNotOwnedByUser(SimUser user)
{
if (user is null)
{
return(null);
}
var teams = Context.Teams
.AsEnumerable()
.Where(t => !user.Teams.Contains(t))
.ToList();
return(teams);
}
private List <Driver> GetDriversNotOwnedbyUser(SimUser user)
{
if (user is null)
{
return(null);
}
var drivers = Context.Drivers
.AsEnumerable()
.Where(t => !user.Drivers.Contains(t))
.ToList();
return(drivers);
}
public async Task <IActionResult> RemoveDriverFromUser(string userId, int driverId)
{
SimUser user = await UserManager.FindByIdAsync(userId);
Driver driver = await Context.Drivers.FindAsync(driverId);
if (user is null || driver is null)
{
return(NotFound());
}
user.Drivers.Remove(driver);
_ = await UserManager.UpdateAsync(user);
return(RedirectToAction(nameof(AddDriverToUser), new { userId }));
}
public async Task <IActionResult> RemoveTeamFromUser(string userId, int teamId)
{
SimUser user = await UserManager.FindByIdAsync(userId);
Team team = user.Teams.FirstOrDefault(t => t.Id == teamId);
if (user is null || team is null)
{
return(NotFound());
}
user.Teams.Remove(team);
_ = await UserManager.UpdateAsync(user);
return(RedirectToAction(nameof(AddTeamToUser), new { userId }));
}
public async Task <IActionResult> AddTeamToUser(string userId, [Bind("teamId")] int teamId)
{
SimUser user = await UserManager.FindByIdAsync(userId);
Team team = await Context.Teams.FindAsync(teamId);
if (user is null || team is null)
{
return(NotFound());
}
user.Teams.Add(team);
_ = await UserManager.UpdateAsync(user);
return(RedirectToAction(nameof(AddTeamToUser), new { userId }));
}
public async Task <IActionResult> RaceWeekend(int raceId)
{
var race = await Context.Races
.Include(r => r.Season)
.Include(r => r.Stints)
.SingleOrDefaultAsync(r => r.RaceId == raceId);
var drivers = await Context.DriverResults
.IgnoreQueryFilters()
.Where(dr => dr.RaceId == raceId)
.Include(dr => dr.Strategy)
.ThenInclude(dr => dr.Tyres)
.ThenInclude(dr => dr.Tyre)
.Include(dr => dr.SeasonDriver)
.ThenInclude(sd => sd.Driver)
.ThenInclude(d => d.DriverTraits)
.ThenInclude(drt => drt.Trait)
.Include(dr => dr.SeasonDriver.SeasonTeam)
.ThenInclude(st => st.Team)
.ThenInclude(t => t.TeamTraits)
.ThenInclude(tet => tet.Trait)
.Include(dr => dr.SeasonDriver.SeasonTeam.Rubber)
.ToListAsync();
// Checks if the user is authenticated and sends the list of owned team id's if that's the case
// Other wise assigns an empty int list to prevent a nullreference in the view
if (User.Identity.IsAuthenticated)
{
SimUser simuser = await UserManager.GetUserAsync(User);
ViewBag.owneddrivers = simuser.Drivers;
}
else
{
ViewBag.owneddrivers = new List <Driver>();
}
RaceWeekendModel viewmodel = new RaceWeekendModel
{
Year = race.Season.SeasonNumber,
Race = race,
DriverResults = drivers
};
return(View(viewmodel));
}
public async Task <IActionResult> Modify(RoleModifyModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.AddIds ?? new string[] { })
{
SimUser user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
Errors(result);
}
}
}
foreach (string userId in model.DeleteIds ?? new string[] { })
{
SimUser user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
Errors(result);
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(await Modify(model.RoleId));
}
}
public AddTeamToUserModel(SimUser simUser, IList <Team> teams, List <Team> otherTeams)
{
SimUser = simUser;
if (teams != null)
{
foreach (var team in teams.OrderBy(od => od.Abbreviation))
{
OwnedTeams.Add(team);
}
}
if (otherTeams != null)
{
foreach (var otherTeam in otherTeams.OrderBy(od => od.Abbreviation))
{
OtherTeams.Add(otherTeam);
}
}
}
public AddDriverToUserModel(SimUser simUser, IList <Driver> drivers, List <Driver> otherDrivers)
{
SimUser = simUser;
if (drivers != null)
{
foreach (var driver in drivers.OrderBy(od => od.Name))
{
OwnedDrivers.Add(driver);
}
}
if (otherDrivers != null)
{
foreach (var otherDriver in otherDrivers.OrderBy(od => od.Name))
{
OtherDrivers.Add(otherDriver);
}
}
}
public async Task <IActionResult> Create(SimUser user)
{
if (ModelState.IsValid)
{
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(user));
}
public async Task <IActionResult> Login([Bind] LoginModel model)
{
if (ModelState.IsValid && model != null)
{
SimUser user = await UserManager.FindByNameAsync(model.Username);
if (user is null)
{
_logger.LogInformation("Unknown username attempted to log-in");
ModelState.AddModelError(string.Empty, "Username doesn't exist.");
return(View());
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(
user.UserName,
model.Password,
model.RememberMe,
lockoutOnFailure : false)
;
if (result.Succeeded)
{
_logger.LogInformation("User logged in.");
user.LastLogin = DateTime.Now;
await UserManager.UpdateAsync(user);
return(RedirectToAction("Index", "Home"));
}
else
{
_logger.LogInformation("User failed to log in.");
ModelState.AddModelError(string.Empty, "Password was incorrect.");
return(View());
}
}
// If we got this far, something failed, redisplay form
return(View());
}
public static async Task SeedIdentity(UserManager <SimUser> userManager, RoleManager <IdentityRole> roleManager)
{
// Create the default Identity roles
string[] defaultRoles = new string[] { "Admin", "Member", "Guest" };
foreach (var elem in defaultRoles)
{
await AddRoleToIdentity(elem, roleManager);
}
// Create a default admin user
if (!userManager.Users.Any())
{
var user = new SimUser {
UserName = "******"
};
var result = await userManager.CreateAsync(user, "password");
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, "Admin");
}
}
}
public async Task <IActionResult> Delete(string id)
{
SimUser user = await UserManager.FindByIdAsync(id);
if (user != null)
{
var result = await UserManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
Errors(result);
}
}
else
{
ModelState.AddModelError("", "User couldn't be found");
}
return(View("Index"));
}
public async Task <IActionResult> RaceStart(int id, int raceId)
{
var race = await Context.Races
.Include(r => r.Stints)
.Include(r => r.Season.Drivers)
.Include(r => r.DriverResults)
.ThenInclude(r => r.StintResults)
.Include(r => r.DriverResults)
.SingleOrDefaultAsync(r => r.RaceId == raceId);
if (race.DriverResults.Count == 0)
{
// Checks if the user activating the race is the admin
SimUser user = await UserManager.GetUserAsync(User);
if (User.Identity.IsAuthenticated && await UserManager.IsInRoleAsync(user, Constants.RoleAdmin))
{
race = _raceBuilder
.Use(race)
.AddAllDrivers()
.GetResult();
var driverTraits = await Context.DriverTraits
.Include(drt => drt.Trait)
.ToListAsync();
var teamTraits = await Context.TeamTraits
.Include(ttr => ttr.Trait)
.ToListAsync();
var trackTraits = await Context.TrackTraits
.Include(tet => tet.Trait)
.Where(trt => trt.TrackId == race.TrackId)
.ToListAsync();
var seasonTeams = await Context.SeasonTeams
.Where(st => st.SeasonId == race.SeasonId)
.Include(st => st.Rubber)
.ToListAsync();
// Get all the possible strategies for this race
var strategies = await Context.Strategies
.Where(s => s.RaceLen == race.Stints.Count)
.Include(s => s.Tyres)
.ThenInclude(t => t.Tyre)
.ToListAsync();
// If the length is zero then creates a list consisting of the single, default strategy
if (strategies.Count == 0)
{
strategies = await Context.Strategies
.Where(s => s.StrategyId == 1)
.Include(s => s.Tyres)
.ThenInclude(t => t.Tyre)
.ToListAsync();
}
foreach (var driverRes in race.DriverResults)
{
// Gets the traits from the driver in the loop and sets them
var thisDriverTraits = driverTraits.Where(drt => drt.DriverId == driverRes.SeasonDriver.DriverId);
RaceService.SetDriverTraitMods(driverRes, thisDriverTraits, race.Weather);
// Gets the seasonteam of the driver in the loop
var thisDriverTeam = seasonTeams.First(st => st.SeasonDrivers.Contains(driverRes.SeasonDriver));
// Gets the traits from the team of the driver in the loop and sets them
var thisTeamTraits = teamTraits.Where(ttr => ttr.TeamId == thisDriverTeam.TeamId);
RaceService.SetTeamTraitMods(driverRes, thisTeamTraits, race.Weather);
// Sets the traits from the track to the driver in the loop
RaceService.SetTrackTraitMods(driverRes, trackTraits, race.Weather);
// Set a random strategy
int stratIndex = rng.Next(0, strategies.Count);
RaceService.SetRandomStrategy(driverRes, strategies[stratIndex]);
// Applies the effect of the related tyre manufacturer
var rubber = thisDriverTeam.Rubber;
RaceService.SetRubberEffect(driverRes, rubber);
}
Context.DriverResults.AddRange(race.DriverResults);
await Context.SaveChangesAsync();
}
else
{
return(Forbid());
}
}
return(RedirectToAction("RaceWeekend", new { raceId }));
}
