public void CreateBud_CallsRepositoryMethod()
{
// Arrange
var mockRepo = new Mock <IAuktionRepository>();
var service = new AuktionService(mockRepo.Object, null);
BudModel obj = null;
var bud = new BiddingViewModel {
AuktionID = 1, Summa = 2
};
var user = new NauktionUser {
Id = "abcdef"
};
mockRepo.Setup(t => t.CreateBudAsync(It.IsAny <BudModel>()))
.Callback((BudModel o) => obj = o)
.Returns(Task.CompletedTask).Verifiable();
// Act
service.CreateBudAsync(bud, user).GetAwaiter().GetResult();
// Assert
Assert.IsNotNull(obj);
Assert.AreEqual(1, obj.AuktionID);
Assert.AreEqual(2, obj.Summa);
Assert.AreEqual(user.Id, obj.Budgivare);
mockRepo.Verify();
}
public async Task <IActionResult> ElevateUser(string id)
{
NauktionUser user = await _userManager.FindByIdAsync(id);
if (user is null)
{
TempData["Message"] = "Misslyckades med att befodra användare! Användaren finns inte.";
return(RedirectToAction("Users"));
}
if (await _userManager.IsInRoleAsync(user, NauktionRoles.Admin))
{
TempData["Message"] = $"Misslyckades med att befodra användare \"{user.UserName}\"! Användaren är redan Admin.";
return(RedirectToAction("Users"));
}
IdentityResult result = await _userManager.AddToRoleAsync(user, NauktionRoles.Admin);
if (!result.Succeeded)
{
TempData["Message"] = $"Misslyckades med att befodra användaren \"{user.UserName}\"! Okänt fel: \"{string.Join("\", \"", result.Errors.Select(e => e.Description))}\"";
return(RedirectToAction("Users"));
}
TempData["Message"] = $"Användare \"{user.UserName}\" har blivit befodrad till Admin!";
return(RedirectToAction("Users"));
}
public async Task <IActionResult> Bid(BiddingViewModel bid)
{
NauktionUser currentUser = await _userManager.GetUserAsync(User);
// Validate
if (ModelState.IsValid)
{
string error = await _service.ValidateBud(bid.AuktionID, bid.Summa, currentUser);
if (!(error is null))
{
ModelState.AddModelError(nameof(bid.Summa), error);
}
}
// Redirect if invalid
if (!ModelState.IsValid)
{
TempData["BidErrors"] = ModelState[nameof(bid.Summa)].Errors
.Select(e => e.ErrorMessage)
.ToArray();
return(RedirectToAction("View", new { id = bid.AuktionID }));
}
// Valid! Let's create that bid!
await _service.CreateBudAsync(bid, currentUser);
TempData["BidSuccess"] = true;
return(RedirectToAction("View", new { id = bid.AuktionID }));
}
public async Task <IActionResult> Alter(int id)
{
AuktionModel auktionModel = await _service.GetAuktionAsync(id);
if (auktionModel is null)
{
TempData["Message"] = "Misslyckades med att redigera auktionen! Auktionen finns inte i databasen.";
return(RedirectToAction("Index"));
}
NauktionUser currentUser = await _userManager.GetUserAsync(User);
if (auktionModel.SkapadAv != currentUser.Id)
{
TempData["Message"] = "Misslyckades med att redigera auktionen! Du kan inte redigera någon annans auktion.";
return(RedirectToAction("Index"));
}
var model = new AuktionViewModel
{
AuktionID = auktionModel.AuktionID,
Titel = auktionModel.Titel,
Beskrivning = auktionModel.Beskrivning,
SlutDatum = auktionModel.SlutDatum,
Utropspris = auktionModel.Utropspris ?? 0
};
return(View(model));
}
public async Task <IActionResult> Alter(AuktionViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
AuktionModel auktionModel = await _service.GetAuktionAsync(model.AuktionID);
if (auktionModel is null)
{
TempData["Message"] = "Misslyckades med att redigera auktionen! Auktionen finns inte i databasen.";
return(RedirectToAction("Index"));
}
NauktionUser currentUser = await _userManager.GetUserAsync(User);
if (auktionModel.SkapadAv != currentUser.Id)
{
TempData["Message"] = "Misslyckades med att redigera auktionen! Du kan inte redigera någon annans auktion.";
return(RedirectToAction("Index"));
}
await _service.AlterAuktionAsync(model);
TempData["Message"] = $"Dina ändringar till auktionen \"{model.Titel}\" har sparats!";
return(View(model));
}
public async Task CreateBudAsync(BiddingViewModel model, NauktionUser budgivare)
{
await _repository.CreateBudAsync(new BudModel
{
AuktionID = model.AuktionID,
Summa = model.Summa,
Budgivare = budgivare.Id
});
}
public static async Task <bool> IsInRoleAsync(this UserManager <NauktionUser> userManager, ClaimsPrincipal user, NauktionRoles role)
{
NauktionUser nauktionUser = await userManager.GetUserAsync(user);
if (nauktionUser == null)
{
return(false);
}
return(await userManager.IsInRoleAsync(nauktionUser, role.ToString()));
}
public async Task <IActionResult> VerifyBudSumma(int AuktionID, int Summa)
{
NauktionUser currentUser = await _userManager.GetUserAsync(User);
string error = await _service.ValidateBud(AuktionID, Summa, currentUser);
if (error is null)
{
return(new JsonResult(true));
}
return(new JsonResult(error));
}
public async Task CreateAuktionAsync(AuktionViewModel model, NauktionUser skapare)
{
await _repository.CreateAuktionAsync(new AuktionModel
{
Titel = model.Titel,
Beskrivning = model.Beskrivning,
StartDatum = DateTime.Now,
SlutDatum = model.SlutDatum,
Gruppkod = _repository.Gruppkod,
Utropspris = model.Utropspris,
SkapadAv = skapare.Id
});
}
public async Task <IActionResult> Create(AuktionViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
NauktionUser currentUser = await _userManager.GetUserAsync(User);
await _service.CreateAuktionAsync(model, currentUser);
TempData["Message"] = $"Din auktion \"{model.Titel}\" har skapats!";
return(RedirectToAction("Index"));
}
private async Task LoadSharedKeyAndQrCodeUriAsync(NauktionUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new NauktionUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, NauktionRoles.Regular);
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <string> ValidateBud(int auktionID, int summa, NauktionUser budgivare)
{
AuktionModel auktion = await GetAuktionAsync(auktionID);
if (auktion is null)
{
return("Auktionen finns inte.");
}
if (auktion.IsClosed())
{
return("Du kan inte buda på en stängd auktion.");
}
if (summa <= auktion.Utropspris)
{
return("Budet måste vara större än utropspriset.");
}
List <BudModel> budModels = await ListBudsAsync(auktionID);
BudModel highestBid = budModels.FirstOrDefault();
if (highestBid is null)
{
return(null);
}
if (summa <= highestBid.Summa)
{
return("Budet måste vara större än det högsta budet.");
}
NauktionUser highestBidder = await _userManager.FindByIdAsync(highestBid.Budgivare);
if (highestBidder?.Id == budgivare.Id)
{
return("Du kan inte buda när du har högsta budet.");
}
return(null);
}
public async Task <IActionResult> View(int id)
{
AuktionBudViewModel model = await _service.GetAuktionBudsAsync(id);
if (model == null)
{
return(RedirectToAction("Index"));
}
NauktionUser currentUser = await _userManager.GetUserAsync(User);
string error = await _service.ValidateBud(model.AuktionID, model.MaxedPrice + 1, currentUser);
if (!(error is null))
{
TempData["BidErrors"] = new[] { error }
}
;
return(View(model));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new NauktionUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, NauktionRoles.Regular);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> Delete(AuktionDeleteViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Alter", new { id = model.AuktionID }));
}
AuktionBudViewModel auktionModel = await _service.GetAuktionBudsAsync(model.AuktionID);
if (auktionModel is null)
{
TempData["Message"] = "Misslyckades med att ta bort auktionen! Auktionen finns inte i databasen.";
return(RedirectToAction("Index"));
}
NauktionUser currentUser = await _userManager.GetUserAsync(User);
if (auktionModel.SkapadAv != currentUser.Id)
{
TempData["Message"] = "Misslyckades med att ta bort auktionen! Du kan inte ta bort någon annans auktion.";
return(RedirectToAction("Index"));
}
if (auktionModel.Bids.Count > 0)
{
TempData["Message"] =
"Misslyckades med att ta bort auktionen! Du kan inte ta bort en auktion som har blivit budad.";
return(RedirectToAction("Index"));
}
await _service.DeleteAuktionAsync(model.AuktionID);
TempData["Message"] = $"Auktionen \"{auktionModel.Titel}\" har blivit borttagen!";
return(RedirectToAction("Index"));
}
public static async Task <bool> IsInRoleAsync(this UserManager <NauktionUser> userManager, NauktionUser user, NauktionRoles role)
{
return(await userManager.IsInRoleAsync(user, role.ToString()));
}
public static async Task <IdentityResult> AddToRoleAsync(this UserManager <NauktionUser> userManager, NauktionUser user, NauktionRoles role)
{
return(await userManager.AddToRoleAsync(user, role.ToString()));
}
public static async Task <IdentityResult> AddToRolesAsync(this UserManager <NauktionUser> userManager, NauktionUser user, IEnumerable <NauktionRoles> roles)
{
return(await userManager.AddToRolesAsync(user, roles.Select(role => role.ToString())));
}
public static async Task <IList <NauktionRoles> > GetNauktionRolesAsync(this UserManager <NauktionUser> userManager, NauktionUser user)
{
return((await userManager.GetRolesAsync(user)).Select(role => Enum.Parse <NauktionRoles>(role, true)).ToList());
}