public int RegisterUser(UserDtoModel userDto, DateTime cartDate)
{
if (userDto == null)
{
throw new ArgumentNullException("User info not supplied");
}
using (EF_Models.ESDatabaseContext context = new EF_Models.ESDatabaseContext())
{
UnitOfWork uow = new UnitOfWork(context);
User efUser = _mapper.Map <User>(userDto);
uow.Users.AddNewUser(efUser);
DateTime SetDateTime()
{
return(DateTime.Now);
}
Cart efCart = new Cart()
{
DateLastUpdated = cartDate
};
efUser.Cart.Add(efCart);
uow.Commit();
int userID = efUser.Id;
return(userID);
}
}
public IActionResult Get(int userId, [FromHeader(Name = "MyAuthentication")] string myAuth)
{
UserDtoModel user = _userManager.GetUser(userId);
if (user == null)
{
return(NotFound());
}
return(Ok(user));
}
private bool IsUserAuthorized(UserDtoModel user)
{
bool isValidUser = false;
if (allowedroles.Length == 0 || user == null)
{
return(isValidUser);
}
isValidUser = Array.IndexOf(allowedroles, Enum.GetName(typeof(StaffType), user.RoleID)) >= 0;
return(isValidUser);
}
protected override bool AuthorizeCore(HttpContextBase context)
{
UserDtoModel user = _userAccountResolver.GetCurrentUser();
bool result = false;
result = IsUserAuthorized(user);
if (result)
{
base.AuthorizeCore(context);
}
return(result);
}
public async Task <ApplicationUserEntity> EditUserAsync(UserDtoModel userForChange)
{
var userIdentity = await userManager.FindByIdAsync(userForChange.Id);
var changedUserIdentity = mapper.Map(userForChange, userIdentity);
await userManager.UpdateAsync(changedUserIdentity);
await applicationDbContext.SaveChangesAsync();
return(changedUserIdentity);
}
public IHttpActionResult ValidateAccount(LoginDtoModel account)
{
UserDtoModel user = _staffFacade.ValidateAccount(account);
if (user != null)
{
return(Ok(user));
}
else
{
return(Unauthorized());
}
}
public async Task <ActionResult <ApplicationUserEntity> > UpdateUser(UserDtoModel editedUser)
{
ValidationResult validationResult = userDtoValidator.Validate(editedUser);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var updatedUser = await userManageService.EditUserAsync(editedUser);
return(CreatedAtAction("Updated", editedUser));
}
public UserDtoModel GetCurrentUser()
{
UserDtoModel user = null;
HttpCookie cookie = HttpContext.Current.Request.Cookies["CookieA"];
if (cookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(cookie.Value);
if (authTicket != null)
{
user = JsonConvert.DeserializeObject <UserDtoModel>(authTicket.UserData);
}
}
return(user);
}
public UserDtoModel ValidateStaffAccount(LoginDtoModel account)
{
UserDtoModel result = null;
var queryResult = _uow.GetDB().usp_CheckStaffAccount(account.Email, account.Password);
if (queryResult != null)
{
var user = queryResult.FirstOrDefault();
result = new UserDtoModel()
{
StaffID = user.StaffID,
FirstName = user.FirstName,
RoleID = user.RoleID
};
}
return(result);
}
public UserDtoModel GetUser(int id)
{
using (EF_Models.ESDatabaseContext context = new EF_Models.ESDatabaseContext())
{
UnitOfWork uow = new UnitOfWork(context);
//EF.User efUser = uow.Users.GetAll().FirstOrDefault();
EF_Models.User efUser = uow.Users.GetById(id);
if (efUser is null)
{
return(null);
}
UserDtoModel user = _mapper.Map <UserDtoModel>(efUser);
return(user);
}
}
public UserDtoModel UserLogin(string username, string passwordHash)
{
using (EF_Models.ESDatabaseContext context = new EF_Models.ESDatabaseContext())
{
UnitOfWork uow = new UnitOfWork(context);
User efUser = uow.Users.GetByUsernameAndPassword(username, passwordHash);
if (efUser is null)
{
throw new Exception("Wrong username or password");
}
UserDtoModel user = _mapper.Map <UserDtoModel>(efUser);
return(user);
}
}
public async Task EditUserTask(string identityName, UserDtoModel userModel)
{
using (var context = _serviceProvider.GetService <DatabaseContext>())
{
var user = await context.Users.FirstOrDefaultAsync(x => x.Id == identityName);
if (user == null)
{
throw new UserNotFoundException();
}
user.Birthday = userModel.Birthday;
user.FirstName = userModel.FirstName;
user.MobileNumber = userModel.MobileNumber;
user.LastName = userModel.LastName;
await context.SaveChangesAsync();
}
}
public async Task <ActionResult> Login(LoginViewModel user)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_applicationUriResolver.GetBaseUrl());
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = await client.PostAsJsonAsync("api/StaffApi/ValidateAccount", user);
if (response.IsSuccessStatusCode)
{
var propertyResponse = response.Content.ReadAsStringAsync().Result;
UserDtoModel result = JsonConvert.DeserializeObject <UserDtoModel>(propertyResponse);
string userData = JsonConvert.SerializeObject(result);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1, result.FirstName, DateTime.Now, DateTime.Now.AddMinutes(15), false, userData
);
string enTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie enCookie = new HttpCookie("CookieA", enTicket);
Response.Cookies.Add(enCookie);
HttpCookie userCookie = new HttpCookie("Username");
userCookie.Value = result.FirstName;
userCookie.Expires = DateTime.Now.AddHours(1);
Response.Cookies.Add(userCookie);
return(RedirectToAction("Index", "Property"));
}
else
{
ModelState.AddModelError("", "Invalid credentials");
}
}
return(View(user));
}
public async Task <IActionResult> EditUserAsync([FromBody] UserDtoModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
await _accountService.EditUserTask(User.Identity.Name, userModel);
return(StatusCode(200));
}
catch (UserNotFoundException ex)
{
return(StatusCode(404, ex.Message));
}
catch (Exception ex)
{
_logger.Error(ex);
return(StatusCode(500, "Internal server error"));
}
}
public int GetCurrentUserRole()
{
UserDtoModel user = GetCurrentUser();
return(user != null ? user.RoleID : 0);
}
