public async Task <IActionResult> Login([FromBody] AppUserLoginModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
_logger.LogInformation("User is not found.");
return(NotFound());
}
var result = await _signInManager.PasswordSignInAsync(
userName : user.UserName,
password : model.Password,
isPersistent : model.RememberMe,
lockoutOnFailure : false);
if (!result.Succeeded)
{
return(BadRequest("Some shit happens here"));
}
var userToReturn = _mapper.Map <AppUserModel>(user);
return(Ok(userToReturn));
}
public InfrastructureModel <AppUserInformationModel> GetById(AppUserLoginModel loginModel)
{
InfrastructureModel <AppUserInformationModel> infrastructureModel = new InfrastructureModel <AppUserInformationModel>();
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", loginModel.TokenKey);
client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json charset=utf-8");
client.DefaultRequestHeaders.Accept.Clear();
var serializePostModel = JsonConvert.SerializeObject(loginModel);
StringContent contentPost = new StringContent(serializePostModel, Encoding.UTF8, "application/json");
HttpResponseMessage httpResponceMessage = client.PostAsync(ConnectionHelper.GetConnectionUrl() + "AppUser/GetById/", contentPost).Result;
httpResponceMessage.EnsureSuccessStatusCode();
string stringResponce = httpResponceMessage.Content.ReadAsStringAsync().Result;
infrastructureModel = JsonConvert.DeserializeObject <InfrastructureModel <AppUserInformationModel> >(stringResponce);
if (infrastructureModel.ResultModel != null)
{
infrastructureModel.ResultStatus = true;
}
return(infrastructureModel);
}
}
public IActionResult UpdatePassword([FromBody] AppUserLoginModel appUserLoginModel)
{
InfrastructureModel <bool> infrastructureModel = new InfrastructureModel <bool>();
var appUser = appUserOperation.GetById(appUserLoginModel.AppUserId);
if (appUser != null)
{
if (appUser.Password == appUserLoginModel.NowPassword)
{
if (appUserLoginModel.Password == appUserLoginModel.RePassword)
{
appUser.Password = appUserLoginModel.Password;
infrastructureModel.Message = "Şifre Değiştirildi";
appUserOperation.Update(appUser);
}
else
{
infrastructureModel.Message = "Şifreler Eşleşmiyor Veya Eski Şifreniz Yanlış";
}
}
else
{
infrastructureModel.Message = "Şuanki Şifreniz Yanlış";
}
infrastructureModel.ResultModel = true;
infrastructureModel.ResultStatus = true;
}
return(Json(infrastructureModel));
}
public JsonResult ChangePassword(AppUserLoginModel appUserLoginModel)
{
Response <bool> response = new Response <bool>();
appUserProvider = new AppUserProvider();
AppUserModel appUserModel = SessionExtension.GetSessionUser(HttpContext.Session);
if (appUserModel != null)
{
AppUserModel appUserTokenModel = SessionExtension.GetSessionUser(HttpContext.Session);
appUserLoginModel.TokenKey = appUserModel.TokenKey;
appUserLoginModel.AppUserId = appUserModel.AppUser.AppUserId;
InfrastructureModel <bool> infrastructureModel = appUserProvider.ChangePassword(appUserLoginModel);
response = new Response <bool>()
{
Data = infrastructureModel.ResultModel,
Message = infrastructureModel.Message,
Status = true,
Refresh = true
};
}
return(Json(response));
}
public JsonResult Login(AppUserLoginModel appUserLoginModel)
{
Response response = new Response();
tokenProvider = new TokenProvider();
try
{
appUserProvider = new AppUserProvider();
AppUserModel appuserModel = appUserProvider.GetLoginUser(appUserLoginModel).ResultModel;
if (appuserModel != null)
{
SessionExtension.Set <AppUserModel>(HttpContext.Session, "Login", appuserModel);
response = new Response()
{
Message = "success",
Status = true,
RedirectUrl = Url.Action("Index", "Home")
};
}
}
catch (Exception ex)
{
response = new Response()
{
Message = "Fail",
Status = false,
};
}
return(Json(response));
}
public async Task <IActionResult> LogIn(AppUserLoginModel model)
{
if (ModelState.IsValid)
{
string message = await _authService.SignIn(model);
if (message == "")
{
var activeUser = _contextAccessor.HttpContext.Session.GetObject <AppUserViewModel>("activeUser");
if (activeUser.Roles.Contains("Admin"))
{
return(RedirectToAction("Index", "Home", new { @area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "Home", new { @area = "Member" }));
}
}
else
{
ModelState.AddModelError("", message);
return(View(model));
}
}
return(View(model));
}
public async Task <string> SignIn(AppUserLoginModel loginModel)
{
var json = JsonConvert.SerializeObject(loginModel);
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
var responseMessage = await _httpClient.PostAsync("SignIn", content);
string ErrorMessage = await responseMessage.Content.ReadAsStringAsync();
if (responseMessage.IsSuccessStatusCode)
{
var token = JsonConvert.DeserializeObject <AccessToken>(await responseMessage.Content.ReadAsStringAsync());
_accessor.HttpContext.Session.SetString("token", token.Token);
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);
var activeUser = await _httpClient.GetAsync("GetActiveUser");
var userContent = JsonConvert.DeserializeObject <AppUserViewModel>(await activeUser.Content.ReadAsStringAsync());
_accessor.HttpContext.Session.SetObject("activeUser", userContent);
_accessor.HttpContext.Session.SetString("userName", userContent.FullName);
_accessor.HttpContext.Session.SetString("eMail", loginModel.Email);
return("");
}
else
{
return(ErrorMessage);
}
}
public async Task <IActionResult> Login(AppUserLoginModel model)
{
if (ModelState.IsValid)
{
if (appUserService.CheckUser(model.UserName, model.Password))
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, model.UserName),
new Claim(ClaimTypes.Role, "Admin"),
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
IsPersistent = model.RememberMe
};
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), authProperties);
return(RedirectToAction("Index", "Home", new { @area = "Admin" }));
}
ModelState.AddModelError("", "Kullanıcı adı veya parola hatalı");
}
return(View(model));
}
public async Task <IActionResult> SignIn(AppUserLoginModel appUserLoginModel)
{
if (await _authApiService.SignIn(appUserLoginModel))
{
return(RedirectToAction("Index", "Home", new { @area = "Admin" }));
}
return(View(appUserLoginModel));
}
public async Task <bool> SignIn(AppUserLoginModel model)
{
var jsonData = JsonConvert.SerializeObject(model);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await _httpClient.PostAsync("SignIn", content);
if (responseMessage.IsSuccessStatusCode)
{
var accessToken = JsonConvert.DeserializeObject <AccessToken>(await responseMessage.Content.ReadAsStringAsync());
_httpContextAccessor.HttpContext.Session.SetString("token", accessToken.Token);
return(true);
}
return(false);
}
public IActionResult GetUserToken([FromBody] AppUserLoginModel user)
{
var appUser = appUserOperation.GetLoginUser(user.UserName, user.Password);
if (appUser != null)
{
AppUserModel appUserModel = new AppUserModel();
string tokenKey = GenerateToken(user.UserName);
appUserModel.TokenKey = tokenKey;
appUserModel.AppUser = appUser;
return(Json(appUserModel));
}
return(Unauthorized());
}
public async Task <bool> SignIn(AppUserLoginModel appUserLoginModel) //kullanıcı bilgileri doğru ise true değilse false
{ //string content gönderiyoruz
var jsonData = JsonConvert.SerializeObject(appUserLoginModel);
var stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await _httpClient.PostAsync("SignIn", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
var accessToken = JsonConvert.DeserializeObject <AccessToken>
(await responseMessage.Content.ReadAsStringAsync());
_httpContextAccessor.HttpContext.Session.SetString("token", accessToken.Token);
return(true);
}
return(false);
}
public async Task <IActionResult> Login(AppUserLoginModel model)
{
if (ModelState.IsValid)
{
if (_appUserService.CheckUser(model.Username, model.Password))
{
await CookieConfiguration(model.Username, model.Password, model.RememberMe);
//giriş başarılı
return(RedirectToAction("Index", "Home", new { @area = "Admin" }));
}
//giriş başarısız
ModelState.AddModelError("", "Kullanıcı adı yada parola hatalı.");
}
return(View(model));
}
public async Task <IActionResult> SignIn(AppUserLoginModel model)
{
if (await _authService.SignIn(model))
{
return(RedirectToAction("Index", "Home", new { @area = "Admin" }));
}
else if (string.IsNullOrWhiteSpace(model.UserName) || string.IsNullOrWhiteSpace(model.Password))
{
return(View(model));
}
else
{
ModelState.AddModelError("", "Kullanıcı adi veya şifre hatalı");
return(View(model));
}
}
public async Task <IActionResult> Login([FromForm] AppUserLoginModel loginModel)
{
var authenticationResponse = await _identityService.LoginAsync(loginModel.Email, loginModel.Password);
if (!authenticationResponse.Success)
{
return(BadRequest(new LoginResult
{
Errors = authenticationResponse.Errors
}));
}
return(Ok(new LoginResult
{
Token = authenticationResponse.Token,
Success = true
}));
}
public string GetLoginUserToken(AppUserLoginModel model)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json charset=utf-8");
client.DefaultRequestHeaders.Accept.Clear();
string modelString = JsonConvert.SerializeObject(model);
StringContent content = new StringContent(modelString, Encoding.UTF8, "application/json");
HttpResponseMessage httpResponceMessage = client.PostAsync(ConnectionHelper.GetConnectionUrl() + "Token/GetUserToken/", content).Result;
httpResponceMessage.EnsureSuccessStatusCode();
string stringResponce = httpResponceMessage.Content.ReadAsStringAsync().Result;
return(stringResponce);
}
}
public IActionResult GetById([FromBody] AppUserLoginModel appUserLoginModel)
{
InfrastructureModel <AppUserInformationModel> infrastructureModel = new InfrastructureModel <AppUserInformationModel>();
var appUser = appUserOperation.GetById(appUserLoginModel.AppUserId);
if (appUser != null)
{
AppUserInformationModel appUserInformationModel = new AppUserInformationModel()
{
AppUserId = appUser.AppUserId,
Name = appUser.Name,
Surname = appUser.Surname,
Email = appUser.Email,
Username = appUser.Username
};
infrastructureModel.ResultModel = appUserInformationModel;
infrastructureModel.ResultStatus = true;
}
return(Json(infrastructureModel));
}
private void BtnLogin_Clicked(object sender, EventArgs e)
{
AppUserLoginModel appUserLoginModel = new AppUserLoginModel()
{
UserName = ent_UserName.Text,
Password = ent_Password.Text,
};
AppUserModel appuserModel = appUserProvider.GetLoginUser(appUserLoginModel).ResultModel;
if (appuserModel != null)
{
Application.Current.Properties["appUserId"] = appuserModel.AppUser.AppUserId;
Application.Current.SavePropertiesAsync();
Navigation.PushModalAsync(new LeftMenu());
}
else
{
DisplayAlert("Hata", "Kullanıcı Adı Veya Şifre Doğru Değil", "Tekrar Dene");
}
}
public JsonResult GetAppUserInformation(AppUserLoginModel appUserLoginModel)
{
Response <AppUserInformationModel> response = new Response <AppUserInformationModel>();
appUserProvider = new AppUserProvider();
AppUserModel appUserModel = SessionExtension.GetSessionUser(HttpContext.Session);
if (appUserModel != null)
{
AppUserModel appUserTokenModel = SessionExtension.GetSessionUser(HttpContext.Session);
InfrastructureModel <AppUserInformationModel> appUserInformationModel = appUserProvider.GetById(new AppUserLoginModel()
{
AppUserId = appUserModel.AppUser.AppUserId, TokenKey = appUserModel.TokenKey
});
response = new Response <AppUserInformationModel>()
{
Data = appUserInformationModel.ResultModel,
Message = "succes",
Status = true
};
}
return(Json(response));
}
