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