public IActionResult Login([FromBody] LogInModel logInModel)
{
try
{
LoggedInUserViewModel loggedInUser = service.LoginUser(logInModel.UserId, logInModel.Password);
if (!ReferenceEquals(loggedInUser, null))
{
//calling the function for the JWT token for respecting user
if (!ReferenceEquals(tokenGenerator, null))
{
string value = tokenGenerator.GetJWTToken(logInModel.UserId);
//returning the token to the consumer app
loggedInUser.Token = value;
return(Ok(loggedInUser));
}
else
{
return(Ok(loggedInUser));
}
}
else
{
return(StatusCode(204, "User not found"));
}
}
//catch (UserNotFoundException ex)
//{
// return NotFound();
//}
catch (Exception ex)
{
return(NotFound());
}
}
public LoggedInUserViewModel GetLoggedInUser()
{
var loggedInUser = new LoggedInUserViewModel();
try
{
client.BaseUrl = new Uri(endPoint);
var request = new RestRequest("api/user/me/", Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("Authorization", String.Format("Token {0}", _token));
request.RequestFormat = DataFormat.Json;
IRestResponse response = client.Execute(request);
if (response.StatusCode == HttpStatusCode.OK)
{
loggedInUser = JsonConvert.DeserializeObject <LoggedInUserViewModel>(response.Content);
}
}
catch (Exception ex)
{
throw ex;
}
return(loggedInUser);
}
public IActionResult SignIn(LoggedInUserViewModel user)
{
if (ModelState.IsValid)
{
bool result = _accountManager.ValidateAccount(user.Email, user.Password);
if (result)
{
ConfigureCookie(user);
}
else if (user.Email.ToLower() == "unassigned")
{
TempData["CredentialsIncorrect"] = "Invalid credentials!";
return(RedirectToAction("SignIn"));
}
else
{
TempData["CredentialsIncorrect"] = "Your username and/or password is incorrect.";
return(RedirectToAction("SignIn"));
}
string[] urlValues = RedirectHelper.AssignCorrectUserRedirect(user.Role);
return(RedirectToAction(urlValues[0], urlValues[1]));
}
return(RedirectToAction("Login"));
}
private static void MapUserToLoggedInViewModel(LoggedInUserViewModel loggedInUser, User userbyEmail)
{
loggedInUser.Email = userbyEmail.Email;
loggedInUser.FirstName = userbyEmail.FirstName;
loggedInUser.LastName = userbyEmail.LastName;
loggedInUser.MobilePhone = userbyEmail.MobilePhone;
loggedInUser.Role = userbyEmail.Role;
loggedInUser.UserName = userbyEmail.UserName;
}
public HttpResponse Index()
{
if (this.IsUserSignedIn())
{
var viewModel = new LoggedInUserViewModel();
var userId = this.GetUserId();
var username = this.usersService.GetUsername(userId);
viewModel.Name = username;
return(this.View(viewModel, "Home"));
}
return(this.View());
}
public IActionResult <LoggedInUserViewModel> Index(HttpSession session)
{
var loginModel = new LoggedInUserViewModel();
if (this.singInManager.IsAuthenticated(session))
{
var user = this.service.FindUserBySession(session);
var userName = this.service.GetUserNameByUserId(user.Id);
loginModel.Username = userName;
}
return(this.View(loginModel));
}
public JsonResult Login([FromBody] UserViewModel user)
{
ResponseViewModel response = new ResponseViewModel();
Response responseValidate = ValidateUserViewModel(user);
if (responseValidate.State.GetDescription() == BasicEnums.State.Error.GetDescription())
{
response.Code = BasicEnums.State.Error.GetHashCode().ToString();
response.Message = responseValidate.Message;
return(Json(response));
}
Task <ResponseEntity <User> > responseUserService = userServices.GetUserByUsername(user.Username);
if (responseUserService.Result.State.GetDescription() == BasicEnums.State.Error.GetDescription())
{
response.Code = BasicEnums.State.Error.GetHashCode().ToString();
response.Message = "Username or password incorrect.";
return(Json(response));
}
Task <ResponseEntity <PasswordByUser> > responsePasswordByUserService = passwordByUserServices.GetPassworByUserByUserId(responseUserService.Result.Entity.Id);
if (responsePasswordByUserService.Result.State.GetDescription() == BasicEnums.State.Error.GetDescription())
{
response.Code = BasicEnums.State.Error.GetHashCode().ToString();
response.Message = "password hasn't been assigned.";
return(Json(response));
}
Response responseValidateService = passwordByUserServices.ValidatePassword(responsePasswordByUserService.Result.Entity, user.Password);
if (responseValidateService.State.GetDescription() == BasicEnums.State.Error.GetDescription())
{
response.Code = BasicEnums.State.Error.GetHashCode().ToString();
response.Message = "Username or password incorrect.";
return(Json(response));
}
LoggedInUserViewModel loggedInUserViewModel = MappersFactory.LoggedInUserViewModel().Map(responseUserService.Result.Entity);
HttpContext.Session.Set(BasicConst.LOGGED_IN_USER_KEY, loggedInUserViewModel);
response.Code = BasicEnums.State.Ok.GetHashCode().ToString();
response.Message = "Welcome " + user.Username;
return(Json(response));
}
public LoggedInUserViewModel GetLoggedInUser()
{
var context = _httpContextAccessor.HttpContext;
if (context != null &&
context.User != null &&
context.User.Identity != null)
{
var loggedInUser = new LoggedInUserViewModel();
loggedInUser.UserName = context.User.Identity.Name;
return(loggedInUser);
}
return(null);
}
public LoggedInUserViewModel CheckedForLoggedInUser(HttpSession session)
{
var login = this.data.Logins.FindByPredicate(l => l.SessionId == session.Id && l.IsActive);
if (login != null)
{
LoggedInUserViewModel liuvm = new LoggedInUserViewModel()
{
Username = login.User.UserName
};
return(liuvm);
}
else
{
return(new LoggedInUserViewModel());
}
}
private void ConfigureCookie(LoggedInUserViewModel user)
{
if (ModelState.IsValid)
{
_user = _userCollection.GetUserByEmail(user.Email);
user.UserId = _user.Id;
user.Role = _user.Role;
user.FirstName = _user.FirstName;
user.LastName = _user.LastName;
List <object> newCookie = CookieManager.SetCookie(user);
HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme, (ClaimsPrincipal)newCookie[0],
(AuthenticationProperties)newCookie[1]
).Wait();
CookieManager.IsSignedIn = true;
ViewData["SignedIn"] = CookieManager.IsSignedIn;
}
}
public static List <object> SetCookie(LoggedInUserViewModel user)
{
Claims = new List <Claim>
{
new Claim(ClaimTypes.Email, user.Email),
new Claim("Name", user.FirstName + " " + user.LastName),
new Claim("UserID", user.UserId.ToString()),
new Claim(ClaimTypes.Role, user.Role.ToString())
};
Identity = new ClaimsIdentity(Claims, CookieAuthenticationDefaults.AuthenticationScheme);
Principal = new ClaimsPrincipal(Identity);
Properties = new AuthenticationProperties();
return(new List <object>()
{
Principal,
Properties
});
}
public ActionResult Index()
{
var orders = userService.GetUserReceipt(User.Username)
.Select(o => new OrderViewModel
{
Id = o.Id,
Product = o.Product.Name,
Quantity = o.Quantity,
Price = o.Product.Price
})
.ToList();;
var loggedInUser = new LoggedInUserViewModel
{
OrderViewModels = orders
};
return(this.View(loggedInUser, "/../Home/LoggedInUser"));
}
public IHttpResponse Index()
{
var orders = Db.Orders.Where(o => o.Status == Status.Active && o.Cashier.Username.Equals(User.Username))
.Select(o => new OrderViewModel
{
Id = o.Id,
Product = o.Product.Name,
Quantity = o.Quantity,
Price = o.Product.Price
})
.ToList();
var loggedInUser = new LoggedInUserViewModel
{
OrderViewModels = orders
};
return(View("/home/loggedInUser", loggedInUser));
}
public LoggedInUserViewModel LoginUser(string UserNameOrPhoneNumber, string Password)
{
LoggedInUserViewModel loggedInUser = new LoggedInUserViewModel();
User userbyEmail = GetUserByEmail(UserNameOrPhoneNumber);
User userbyphone = GetUserByphone(UserNameOrPhoneNumber);
if (!ReferenceEquals(userbyEmail, null))
{
if (userbyEmail.Password == Password)
{
MapUserToLoggedInViewModel(loggedInUser, userbyEmail);
}
}
else if (!ReferenceEquals(userbyphone, null))
{
if (userbyphone.Password == Password)
{
MapUserToLoggedInViewModel(loggedInUser, userbyphone);
}
}
return(loggedInUser);
}
