public List <UserSignUpDto> GetAllUserList() { List <UserSignUpDto> lstUserSignUpDto = new List <UserSignUpDto>(); SqlCommand cmd = new SqlCommand("GetAllUserList", connectionRepository.con); cmd.CommandType = CommandType.StoredProcedure; connectionRepository.con.Open(); SqlDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { UserSignUpDto userSignUpDto = new UserSignUpDto(); userSignUpDto.UserId = Convert.ToInt32(dr["UserId"]); userSignUpDto.Name = Convert.ToString(dr["Name"]); userSignUpDto.EmailId = Convert.ToString(dr["EmailId"]); userSignUpDto.Password = Convert.ToString(dr["Password"]); userSignUpDto.CreatedDate = Convert.ToString(dr["CreatedDate"]); userSignUpDto.MobileNo = Convert.ToString(dr["MobileNo"]); userSignUpDto.Gender = Convert.ToString(dr["Gender"]); userSignUpDto.IsActive = Convert.ToInt32(dr["IsActive"]); lstUserSignUpDto.Add(userSignUpDto); } connectionRepository.con.Close(); return(lstUserSignUpDto); }
public async Task <IActionResult> SignUp(UserSignUpDto userSignUpDto) { TempData["Active"] = "Kullanıcı"; if (ModelState.IsValid) { User user = new User { UserName = userSignUpDto.UserName, Email = userSignUpDto.Email, PhoneNumber = userSignUpDto.PhoneNumber, }; var result = await _userManager.CreateAsync(user, userSignUpDto.Password); if (result.Succeeded) { return(RedirectToAction("Index", "Home", new { area = "" })); } else { ModelState.AddModelError("", "Lütfen tüm alanları doldurun."); return(View("UserSignUp")); } } else { return(View("UserSignUp")); } }
public AuthenticationModelDto GenerateToken(UserSignUpDto userSignUpDto) { var jwtSettings = _configuration.GetSection("JwtSettings"); var secretKey = jwtSettings.GetValue <string>("SecretKey"); int minutes = jwtSettings.GetValue <int>("MinutestoExpiration"); var issuer = jwtSettings.GetValue <string>("Issuer"); var audience = jwtSettings.GetValue <string>("Audience"); var key = Encoding.ASCII.GetBytes(secretKey); var claims = GetClaims(userSignUpDto); var token = new JwtSecurityToken( issuer: issuer, audience: audience, claims: claims, notBefore: DateTime.UtcNow, expires: DateTime.UtcNow.AddMinutes(minutes), signingCredentials: new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256) ); return(new AuthenticationModelDto { Token = new JwtSecurityTokenHandler().WriteToken(token), MinutesToExpiration = minutes, TokenDate = DateTime.UtcNow, UserLogged = _mapper.Map <UserLoggedDto>(userSignUpDto) }); }
public IResponse <string> Validate(UserSignUpDto dto) { var response = new Response <string>(); if (string.IsNullOrWhiteSpace(dto.Email)) { response.Errors.Add("Email is required"); } else if (!Validation.IsValidEmail(dto.Email)) { response.Errors.Add("Email must be an email address."); } if (string.IsNullOrWhiteSpace(dto.Password)) { response.Errors.Add("Password is required"); } else if (dto.Password.Length < 8) { response.Errors.Add("Password must be at least 8 characters in length."); } if (dto.Password != dto.ConfirmPassword) { response.Errors.Add("Password and confirm password must match."); } return(response); }
public ActionResult MyProfile(UserSignUpModel userSignUpModel) { if (!ModelState.IsValid) { return(View(userSignUpModel)); } else { UserSignUpDto userSignUpDto = new UserSignUpDto(); userSignUpDto.UserId = userSignUpModel.UserId; userSignUpDto.Name = userSignUpModel.Name; userSignUpDto.EmailId = userSignUpModel.EmailId; userSignUpDto.Password = userSignUpModel.Password; userSignUpDto.MobileNo = userSignUpModel.MobileNo; userSignUpDto.Gender = userSignUpModel.Gender; int i = userSignUpDal.SaveUserDetails(userSignUpDto); if (i > 0) { ViewBag.successText = "Successfully Profile Updated."; } else { ViewBag.failureText = "Your Profile Has Not Updated. Please Try after Sometime "; } List <ItemGroupDto> lstItemGroupDto = itemGroupDal.GetAndEditItemGroup(0, 1); ViewBag.ItemGroups = lstItemGroupDto; return(View()); } }
public User Map(UserSignUpDto source) { var target = new User(); target.Email = source.Email; target.Password = source.Password; return(target); }
public List <Claim> GetClaims(UserSignUpDto userSignUpDto) { List <Claim> claims = new List <Claim>(); claims.Add(new Claim(ClaimTypes.Name, userSignUpDto.UserName)); claims.Add(new Claim(ClaimTypes.Email, userSignUpDto.Email)); return(claims); }
public async Task <IdentityResult> RegisterAsync(UserSignUpDto userDto) { try { var user = _mapper.Map <Blog.Core.Models.User>(userDto); return(await _userManager.CreateAsync(user)); } catch (Exception ex) { throw new Exception(ex.Message); } }
public async Task <IdentityResult> RegisterAsync(UserSignUpDto userDto) { try { userDto.PasswordHash = GetPasswordHash(userDto.Password); return(await _userAuthDalFacade.RegisterAsync(userDto)); } catch (Exception ex) { throw new Exception(ex.Message); } }
public async Task <IActionResult> SignUp([FromBody] UserSignUpDto userSignUpDto) { var user = _mapper.Map <User>(userSignUpDto); var userCreateResult = await _userManager.CreateAsync(user, userSignUpDto.Password); if (userCreateResult.Succeeded) { return(Created(string.Empty, string.Empty)); } return(Problem(userCreateResult.Errors.First().Description, null, 400)); }
public void SignUp_ReturnsOkResult() { var user = new UserSignUpDto() { FirstName = "Hello", LastName = "World", Email = "*****@*****.**", Password = "******" }; var response = _userController.SignUp(user); Assert.IsType <ObjectResult>(response.Result); }
public async Task <ActionResult <UserDto> > UserSignUp([FromBody] UserSignUpDto userData) { var user = _mapper.Map <UserSignUpDto, User>(userData); var userResult = await _userManager.CreateAsync(user, userData.Password); if (userResult.Succeeded) { await _userManager.AddToRoleAsync(user, "customer"); return(Created(string.Empty, string.Empty)); } return(Problem(userResult.Errors.First().Description, null, 500)); }
public ActionResult <IResponse <object> > SignUp(UserSignUpDto dto) { var validationResponse = UserValidator.Validate(dto); if (!validationResponse.IsValid) { return(BadRequest(validationResponse)); } var entity = UserMapper.Map(dto); UserLogic.Create(entity); return(Ok()); }
public void UserCheckOutPayment(FormCollection form) { var addressId = Convert.ToInt32(form[12]); dynamic userId = Session["UserId"]; UserAddressDal userAddressDal = new UserAddressDal(); UserAddressDto userAddressDto = userAddressDal.GetUserAddressByAddressId(addressId, userId, 1); UserSignUpDto userSignUpDto = userSignUpDal.GetUserDetailsByUserId(userId); string firstName = userAddressDto.Name; string amount = form["totalPrice"]; string productInfo = "Product"; string email = userSignUpDto.EmailId; string phone = userAddressDto.MobileNo; //string surl = "http://*****:*****@gmail.com|||||||||||mE2RxRwx"; string hash = Generatehash512(hashString); myremotepost.Add("hash", hash); myremotepost.Post(); }
private void Arrange() { _userValidator = new UserValidator(); _userSignUpDto = new UserSignUpDto { Email = "*****@*****.**", Password = "******", ConfirmPassword = "******", }; _userSignInDto = new UserSignInDto { Email = "*****@*****.**", Password = "******" }; }
public async Task <IActionResult> SignUp([FromBody] UserSignUpDto userSignUpDto) { var result = await _httpClient.PostAsync($"{_configuration["ApiResourceBaseUrls:AuthServer"]}/identity/users/create", JsonContent.Create(userSignUpDto)); var content = await result.Content.ReadAsStringAsync(); if (result.IsSuccessStatusCode) { var link = Url.Action("RequestEmailConfirmation", new { userSignUpDto.Email, userSignUpDto.UserName }); await _httpClient.GetAsync($"https://localhost:5002{link}"); return(Ok(JsonConvert.DeserializeObject <UserSignInDto>(content))); } else { return(BadRequest(new { errors = JsonConvert.DeserializeObject <IEnumerable <IdentityError> >(content) })); } }
public async Task <ApiResponse> SignUp(UserSignUpDto userSignUpDto) { try { var user = _mapper.Map <UserSignUpDto, User>(userSignUpDto); var userCreateResult = await _userManager.CreateAsync(user, userSignUpDto.Password); if (!userCreateResult.Succeeded) { throw new ApiException(userCreateResult.Errors.First().Description, 500); } return(new ApiResponse("Votre compte a bien été crée", Status201Created)); } catch (Exception ex) { throw ex; } }
public async Task <ActionResult <UserSignUpDto> > PostUser(UserSignUpDto userSignUpDto) { try { //var newUser = await _userRepository.AddAsync(_mapper.Map<Users>(userSignUpDto)); var newUser = _user.AddInsert1(_mapper.Map <Users>(userSignUpDto)); if (newUser == null) { return(BadRequest()); } var newUserDto = _mapper.Map <UserSignUpDto>(newUser); return(CreatedAtAction(nameof(PostUser), new { id = newUserDto.Id, newUserDto })); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> SignUp(UserSignUpDto model) { try { var user = _mapper.Map <User>(model); if (await _userRepository.VerifyEmailExists(user.Email)) { return(BadRequest(new { message = "Email Already Exists", errorCode = StatusCodes.Status400BadRequest })); } _userRepository.Add(user); await _userRepository.SaveChangesAsync(); return(Created("", "Success!")); } catch (System.Exception e) { return(this.StatusCode(StatusCodes.Status500InternalServerError, e.Message)); } }
public ActionResult MyProfile() { List <ItemGroupDto> lstItemGroupDto = itemGroupDal.GetAndEditItemGroup(0, 1); ViewBag.ItemGroups = lstItemGroupDto; dynamic userId = Session["UserId"]; UserSignUpDto userSignUpDto = userSignUpDal.GetUserDetailsByUserId(userId); AutoMapper.Mapper.CreateMap <UserSignUpDto, UserSignUpModel>() .ForMember(o => o.UserId, b => b.MapFrom(z => z.UserId)) .ForMember(o => o.Name, b => b.MapFrom(z => z.Name)) .ForMember(o => o.EmailId, b => b.MapFrom(z => z.EmailId)) .ForMember(o => o.MobileNo, b => b.MapFrom(z => z.MobileNo)) .ForMember(o => o.Password, b => b.MapFrom(z => z.Password)) .ForMember(o => o.ConfirmPassword, b => b.MapFrom(z => z.ConfirmPassword)) .ForMember(o => o.Gender, b => b.MapFrom(z => z.Gender)); UserSignUpModel userSignUpModel = Mapper.Map <UserSignUpDto, UserSignUpModel>(userSignUpDto); // UserSignUpModel userSignUpModel = userSignUpDto.userSignUpDto; return(View(userSignUpModel)); }
public async Task <IActionResult> SignUp(UserSignUpDto userSignUpDto) { var user = _mapper.Map <UserSignUpDto, AppUser>(userSignUpDto); if (!string.IsNullOrEmpty(userSignUpDto.Email)) { var message = new Message(new[] { userSignUpDto.Email }, "Test email", "this is test email"); await _emailSender.SendEmail(message); if (!ModelState.IsValid) { return(BadRequest()); } if (await _userManager.FindByEmailAsync(user.Email) != null) { var error = _userManager.ErrorDescriber.DuplicateEmail(user.Email); return(Problem($"{_convertErrorToCode.ConvertErrorToCode(error.Code).ToString()} : {error.Description}", null, 500)); } } var userCreateResult = await _userManager.CreateAsync(user, userSignUpDto.Password); if (userCreateResult.Succeeded) { var player = new Player { UserId = user.Id }; player.IsOnline = true; await _dbContext.Players.AddAsync(player); await _dbContext.SaveChangesAsync(); return(Ok()); } var code = _convertErrorToCode.ConvertErrorToCode(userCreateResult.Errors.First().Code); return(Problem($"{code.ToString()} : {userCreateResult.Errors.First().Description}", null, 500)); }
public async Task <IActionResult> SignUp([FromBody] UserSignUpDto userSignUpDto) { var user = new User { UserName = userSignUpDto.UserName, Email = userSignUpDto.Email, IsActive = true }; var result = await _userManager.CreateAsync(user, userSignUpDto.Password); if (result == IdentityResult.Success) { await _userManager.AddClaimAsync(user, new Claim("sub", user.Id.ToString())); await _userManager.AddToRoleAsync(user, "user"); return(Ok(new { user.UserName, userSignUpDto.Password })); } return(BadRequest(result.Errors)); }
public UserSignUpDto GetUserDetailsByUserId(int UserId) { UserSignUpDto userSignUpDto = new UserSignUpDto(); SqlCommand cmd = new SqlCommand("GetUserDetailsByUserId", connectionRepository.con); cmd.Parameters.AddWithValue("@UserId", UserId); cmd.CommandType = CommandType.StoredProcedure; connectionRepository.con.Open(); SqlDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { userSignUpDto.UserId = Convert.ToInt32(dr["UserId"]); userSignUpDto.Name = Convert.ToString(dr["Name"]); userSignUpDto.EmailId = Convert.ToString(dr["EmailId"]); userSignUpDto.Password = Convert.ToString(dr["Password"]); userSignUpDto.ConfirmPassword = Convert.ToString(dr["Password"]); userSignUpDto.MobileNo = Convert.ToString(dr["MobileNo"]); userSignUpDto.Gender = Convert.ToString(dr["Gender"]); } connectionRepository.con.Close(); return(userSignUpDto); }
public int SaveUserDetails(UserSignUpDto userSignUp) { try { SqlCommand cmd = new SqlCommand("SaveUserDetails", connectionRepository.con); cmd.Parameters.AddWithValue("@UserId", userSignUp.UserId); cmd.Parameters.AddWithValue("@Name", userSignUp.Name); cmd.Parameters.AddWithValue("@EmailId", userSignUp.EmailId); cmd.Parameters.AddWithValue("@Password", userSignUp.Password); cmd.Parameters.AddWithValue("@MobileNo", userSignUp.MobileNo); cmd.Parameters.AddWithValue("@Gender", userSignUp.Gender); cmd.Parameters.AddWithValue("@IsActive", userSignUp.IsActive); cmd.CommandType = CommandType.StoredProcedure; connectionRepository.con.Open(); int i = cmd.ExecuteNonQuery(); connectionRepository.con.Close(); return(i); } catch (Exception ex) { throw ex; } }
public ActionResult UserLogin(UserLoginModel userLoginModel) { if (!ModelState.IsValid) { return(View(userLoginModel)); } else { UserSignUpDto userSignUpDto = new UserSignUpDto() { EmailId = userLoginModel.EmailId, Password = userLoginModel.Password }; userSignUpDto = userSignUpDal.UserSignIn(userSignUpDto); if (userSignUpDto.UserId > 0) { Session["UserId"] = userSignUpDto.UserId; Session["UserName"] = userSignUpDto.Name; Session["Email"] = userSignUpDto.EmailId; dynamic returnUrl = Session["returnUrl"]; if (!String.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Index")); } //dynamic CurrentURL = System.Web.HttpContext.Current.Request.Url; //return RedirectToAction(CurrentURL); } else { ViewBag.LoginError = "Invalid Login Attempt"; return(View()); } } }
public ActionResult UserRegister(UserSignUpModel userSignUpModel) { if (!ModelState.IsValid) { return(View(userSignUpModel)); } else { UserSignUpDto userSignUpDto = new UserSignUpDto(); userSignUpDto.UserId = userSignUpModel.UserId; userSignUpDto.Name = userSignUpModel.Name; userSignUpDto.EmailId = userSignUpModel.EmailId; userSignUpDto.Password = userSignUpModel.Password; userSignUpDto.MobileNo = userSignUpModel.MobileNo; userSignUpDto.Gender = userSignUpModel.Gender; userSignUpDto.IsActive = 1; bool existUser = userSignUpDal.CheckValidEmailId(userSignUpModel.EmailId); if (existUser == false) { int i = userSignUpDal.SaveUserDetails(userSignUpDto); if (i > 0) { ViewBag.successText = "Successfully Registered.Please Login to Your Account"; } else { ViewBag.failureText = "You are not Registered. Please Try after Sometime "; } } else { ViewBag.failureText = "This MailId already Exist."; } return(View()); } }
public async Task <IActionResult> SignIn(UserSignUpDto userDto) { var user = _userManager.Users.SingleOrDefault(u => u.UserName == userDto.UserName); if (user is null) { return(NotFound("User not found!")); } var signInResult = await _userManager.CheckPasswordAsync(user, userDto.Password); if (signInResult) { var player = await _dbContext.Players.FirstOrDefaultAsync(p => p.UserId == user.Id); player.IsOnline = true; _dbContext.Players.Update(player); await _dbContext.SaveChangesAsync(); return(Ok(new { token = GenerateJwt(user) })); } return(BadRequest("User name or pass is incorrect!")); }
public async Task <IActionResult> RegisterUser([FromBody] UserSignUpDto userDto) { var result = await _userAuthService.RegisterAsync(userDto); return(Json(result)); }