public async Task RemoveFromWatchListAsyncRemovesTheFilm()
{
// Arrange
var film = new Film();
var user = new CinemaUser
{
WatchList = new List <Film> {
film
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).Returns(new ValueTask <CinemaUser>(user));
var filmBusiness = new FilmBusiness(mockContext.Object);
// Act
await filmBusiness.RemoveFromWatchListAsync(user.Id, film);
// Assert
Assert.AreEqual(0, mockSet.Object.First().WatchList.Count(), "Film not removed from watchlist");
mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CinemaUser {
UserName = model.Email,
Email = model.Email,
Name = model.Name,
Surname = model.Surname
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Potwierdź konto", "Potwierdź konto, klikając <a href=\"" + callbackUrl + "\">tutaj</a>");
return(View("RegisterSuccess"));
}
AddErrors(result);
}
// Dotarcie do tego miejsca wskazuje, że wystąpił błąd, wyświetl ponownie formularz
return(View(model));
}
public async Task SeedUser(UserManager <CinemaUser> userManager)
{
if (userManager.FindByNameAsync("*****@*****.**").Result == null)
{
CinemaUser user = new CinemaUser();
user.UserName = "******";
user.Email = "*****@*****.**";
IdentityResult result = userManager.CreateAsync(user, "Danny@1").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, "User").Wait();
}
}
if (userManager.FindByNameAsync("*****@*****.**").Result == null)
{
CinemaUser user = new CinemaUser();
user.UserName = "******";
user.Email = "*****@*****.**";
IdentityResult result = userManager.CreateAsync(user, "Docent@1").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, "Admin").Wait();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="Cuser"></param>
/// <returns></returns>
public bool AddCinemaUser(CinemaUser Cuser)
{
bool dbResult = false;
try
{
List <SqlParameter> param = new List <SqlParameter>();
param.Add(new SqlParameter()
{
ParameterName = "@Email", Value = Cuser.Email
});
param.Add(new SqlParameter()
{
ParameterName = "@Password", Value = Cuser.Password
});
param.Add(new SqlParameter()
{
ParameterName = "@ConfirmPassword", Value = Cuser.ConfirmPassword
});
param.Add(new SqlParameter()
{
ParameterName = "@FName", Value = Cuser.Fname
});
param.Add(new SqlParameter()
{
ParameterName = "@LName", Value = Cuser.Lname
});
param.Add(new SqlParameter()
{
ParameterName = "@Mobile", Value = Cuser.Mobile
});
param.Add(new SqlParameter()
{
ParameterName = "@CreatedBy", Value = Cuser.CreatedBy
});
param.Add(new SqlParameter()
{
ParameterName = "@RoleId", Value = Cuser.RoleId
});
param.Add(new SqlParameter()
{
ParameterName = "@MessageCode", Value = "", Direction = ParameterDirection.Output, Size = 10
});
param.Add(new SqlParameter()
{
ParameterName = "@MessageDescription", Value = "", Direction = ParameterDirection.Output, Size = 1000
});
List <SqlParameter> retParam = new List <SqlParameter>();
dbResult = Insert(StoredProcedureName.INSERT_USER, param);
}
catch (Exception ex)
{
if (ex.Message.Contains("Username is already Exists") == true)
{
dbResult = false;
}
}
return(dbResult);
}
public void DeleteUser(int id)
{
CinemaUser userFromDb = _cinemaDbContext.Users.FirstOrDefault(x => x.UserId == id);
if (userFromDb != null)
{
_cinemaDbContext.Remove(userFromDb);
_cinemaDbContext.SaveChanges();
}
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
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 CinemaUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
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);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId, code },
protocol: Request.Scheme);
await _emailSender.SendEmailConfirmationEmailAsync(Input.Email, callbackUrl);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
private async Task LoadAsync(CinemaUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = "",
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public async Task AddToWatchListAsyncAddsTheFilm()
{
// Arrange
var email = "*****@*****.**";
var username = "******";
var user = new CinemaUser
{
ConcurrencyStamp = Guid.NewGuid().ToString(),
Email = email,
NormalizedEmail = email.ToUpper(),
EmailConfirmed = true,
UserName = username,
NormalizedUserName = username.ToUpper(),
FirstName = username,
LastName = username,
Gender = GenderType.Male,
SecurityStamp = Guid.NewGuid().ToString(),
WatchList = new List <Film> {
new Film()
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).Returns(new ValueTask <CinemaUser>(user));
var filmBusiness = new FilmBusiness(mockContext.Object);
var film = new Film {
Rating = 2
};
// Act
await filmBusiness.AddToWatchListAsync(user.Id, film);
// Assert
Assert.AreEqual(2, mockSet.Object.First().WatchList.Count(), "Film not added to watchlist");
mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
public bool EditUser(CinemaUserDTO cinemaUserDTO)
{
CinemaUser oldUser = _cinemaDbContext.Users.FirstOrDefault(x => x.UserId == cinemaUserDTO.UserId);
if (oldUser != null)
{
oldUser.FirstName = cinemaUserDTO.FirstName;
oldUser.LastName = cinemaUserDTO.LastName;
oldUser.Email = cinemaUserDTO.Email;
oldUser.PhoneNumber = cinemaUserDTO.PhoneNumber;
_cinemaDbContext.SaveChanges();
return(true);
}
return(false);
}
private async Task LoadAsync(CinemaUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber,
FirstName = user.FirstName,
LastName = user.LastName
};
}
public int AddUser(CinemaUserDTO registerDTO)
{
CinemaUser newUser = new CinemaUser {
FirstName = registerDTO.FirstName,
LastName = registerDTO.LastName,
BirthDay = registerDTO.BirthDay,
Email = registerDTO.Email,
PhoneNumber = registerDTO.PhoneNumber,
Password = registerDTO.Password
};
_cinemaDbContext.Users.Add(newUser);
_cinemaDbContext.SaveChanges();
return(newUser.UserId);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
CinemaUser user = _userManager.FindByNameAsync(Input.UserName).GetAwaiter().GetResult();
returnUrl = returnUrl?.Replace("AddReview", "Detail");
returnUrl ??= Url.Content("~/");
if (ModelState.IsValid)
{
// 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(Input.UserName, Input.Password, Input.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
_logger.LogInformation("User logged in.");
return(LocalRedirect(returnUrl));
}
if (result.RequiresTwoFactor)
{
return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, Input.RememberMe }));
}
if (result.IsLockedOut)
{
_logger.LogWarning("User account locked out.");
return(RedirectToPage("./Lockout"));
}
else
{
if (user != null)
{
if (!_userManager.IsEmailConfirmedAsync(user).GetAwaiter().GetResult())
{
ModelState.AddModelError(string.Empty, "Email not confirmed.");
return(Page());
}
}
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(Page());
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public CinemaUserDTO GetUserById(int id)
{
CinemaUser userFromDb = _cinemaDbContext.Users.FirstOrDefault(x => x.UserId == id);
if (userFromDb == null)
{
return(null);
}
return(new CinemaUserDTO {
UserId = userFromDb.UserId,
FirstName = userFromDb.FirstName,
LastName = userFromDb.LastName,
BirthDay = userFromDb.BirthDay,
Email = userFromDb.Email,
PhoneNumber = userFromDb.PhoneNumber,
Password = userFromDb.Password
});
}
private async Task LoadSharedKeyAndQrCodeUriAsync(CinemaUser 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 SeedAsync(CinemaDbContext context)
{
if (context.Users.Any())
{
return;
}
var email = "*****@*****.**";
var username = "******";
var adminUser = new CinemaUser
{
ConcurrencyStamp = Guid.NewGuid().ToString(),
Email = email,
NormalizedEmail = email.ToUpper(),
EmailConfirmed = true,
UserName = username,
NormalizedUserName = username.ToUpper(),
FirstName = username,
LastName = username,
Gender = GenderType.Male,
SecurityStamp = Guid.NewGuid().ToString(),
};
var password = new PasswordHasher <CinemaUser>().HashPassword(adminUser, "Abcdef1.");
adminUser.PasswordHash = password;
await context.UserRoles.AddAsync(new IdentityUserRole <string>()
{
UserId = adminUser.Id,
RoleId = context.Roles.FirstOrDefault(x => x.Name == "Admin").Id
});
await context.Users.AddAsync(adminUser);
await context.SaveChangesAsync();
}
public async Task AddToWatchListAsyncDoesntAddAlredyAddedFilm()
{
// Arrange
var film = new Film {
Rating = 2
};
var user = new CinemaUser {
WatchList = new List <Film> {
film
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).Returns(new ValueTask <CinemaUser>(user));
var filmBusiness = new FilmBusiness(mockContext.Object);
// Act
await filmBusiness.AddToWatchListAsync(user.Id, film);
// Assert
Assert.AreEqual(1, mockSet.Object.First().WatchList.Count(), "Film added to watchlist when already exists");
mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Never());
}
public List <Reservation> GetReservationsForUser(CinemaUser user)
{
return(set.Where(r => r.CinemaUserID == user.Id).OrderByDescending(r => r.ReservationDate).ToList());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new CinemaUser {
UserName = Input.Username,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
CreatedOn = DateTime.UtcNow,
Gender = Input.Gender
};
if (_userManager.FindByEmailAsync(user.Email).GetAwaiter().GetResult() == null)
{
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
result = await _userManager.AddToRoleAsync(user, Input.UserType.ToString());
}
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code },
protocol: Request.Scheme);
await _emailSender.SendEmailConfirmationEmailAsync(Input.Email, callbackUrl);
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
else
{
ModelState.AddModelError(string.Empty, "This email is already registered");
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public List <Reservation> GetReservationsForUser(CinemaUser user)
{
throw new NotImplementedException();
}
public void GetWatchListReturnsAllElements()
{
// Arrange
var filmData1 = new FilmData
{
Title = "Title1",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster1",
FilmId = "Film1"
};
var filmData2 = new FilmData
{
Title = "Title2",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster2",
FilmId = "Film2"
};
var film1 = new Film
{
Rating = 2,
Id = "Film1",
FilmData = filmData1
};
var film2 = new Film
{
Rating = 3,
Id = "Film2",
FilmData = filmData2
};
filmData1.Film = film1;
filmData2.Film = film2;
var user = new CinemaUser {
WatchList = new List <Film> {
film1, film2
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).Returns(new ValueTask <CinemaUser>(user));
var filmBusiness = new FilmBusiness(mockContext.Object);
var mapper = new Mapper();
var expectedWatchList = user.WatchList.Select(x => mapper.MapToFilmCardViewModel(x.FilmData)).ToList();
// Act
var resultWatchList = filmBusiness.GetWatchList(user.Id, mapper.MapToFilmCardViewModel).ToList();
// Assert
Assert.AreEqual(expectedWatchList.Count, resultWatchList.Count, "Incorrect watchlist returned");
Assert.AreEqual(expectedWatchList[0].Id, resultWatchList[0].Id, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Poster, resultWatchList[0].Poster, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Rating, resultWatchList[0].Rating, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Title, resultWatchList[0].Title, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Genres, resultWatchList[0].Genres, "Incorect data returned");
Assert.AreEqual(expectedWatchList[1].Id, resultWatchList[1].Id, "Incorect data returned");
}
public void GetWatchListReturnsNoElementsForInvalidUser()
{
// Arrange
var filmData1 = new FilmData
{
Title = "Title1",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster1",
FilmId = "Film1"
};
var filmData2 = new FilmData
{
Title = "Title2",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster2",
FilmId = "Film2"
};
var film1 = new Film
{
Rating = 2,
Id = "Film1",
FilmData = filmData1
};
var film2 = new Film
{
Rating = 3,
Id = "Film2",
FilmData = filmData2
};
filmData1.Film = film1;
filmData2.Film = film2;
var user = new CinemaUser
{
WatchList = new List <Film> {
film1, film2
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).
Returns(new ValueTask <CinemaUser>(Task.FromResult((CinemaUser)null)));
var filmBusiness = new FilmBusiness(mockContext.Object);
var mapper = new Mapper();
var expectedWatchList = new List <FilmCardViewModel>();
// Act
var resultWatchList = filmBusiness.GetWatchList("UnexistingUserId", mapper.MapToFilmCardViewModel);
// Assert
Assert.AreEqual(null, resultWatchList, "Incorrect watchlist returned");
}
