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"); }