public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUserIdentity {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Add(AddUserVM newUser)
{
IEnumerable <IdentityRole> roles = roleAppService.GetALL();
newUser.AllRoles = roles;
if (ModelState.IsValid == false)
{
return(View(newUser));
}
string roleName = Request["Role"];
IdentityResult result = userAppService.AddUser(newUser);
if (result.Succeeded)
{
ApplicationUserIdentity identityUser = userAppService.Find(newUser.UserName, newUser.PasswordHash);
userAppService.AssignToRole(identityUser.Id, roleName);
TempData["Msg"] = "New User Added Successfully";
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", result.Errors.FirstOrDefault());
return(View(newUser));
}
}
public async Task <ActionResult <ApplicationUser> > Register(ApplicationUserCreate applicationUserCreate)
{
var applicationUserIdentity = new ApplicationUserIdentity
{
Username = applicationUserCreate.Username,
Email = applicationUserCreate.Email,
Fullname = applicationUserCreate.Fullname
};
var result = await _userManager.CreateAsync(applicationUserIdentity, applicationUserCreate.Password);
if (result.Succeeded)
{
applicationUserIdentity = await _userManager.FindByNameAsync(applicationUserCreate.Username);
ApplicationUser applicationUser = new ApplicationUser()
{
ApplicationUserId = applicationUserIdentity.ApplicationUserId,
Username = applicationUserIdentity.Username,
Email = applicationUserIdentity.Email,
Fullname = applicationUserIdentity.Fullname,
Token = _tokenService.CreateToken(applicationUserIdentity)
};
return(Ok(applicationUser));
}
return(BadRequest(result.Errors));
}
public ActionResult Edit(ApplicationUserIdentity employee)
{
try
{
if (ModelState.IsValid)
{
if (employeeAppService.UpdateEmployee(employee))
{
return(RedirectToAction("Index"));
}
else
{
return(View(employee));
}
}
else
{
return(View(employee));
}
}
catch (Exception)
{
return(View(employee));
}
}
//public Task<string> Handle(CreateNewUserCommand request, CancellationToken cancellationToken)
//{
// throw new System.NotImplementedException();
//}
public async Task <string> Handle(CreateNewUserCommand request, CancellationToken cancellationToken)
{
// Kiểm tra tồn tại
var check = await CheckExistence(request.UserName, request.Email);
if (!check.Equals(""))
{
return(check);
}
ApplicationUserIdentity newUser = new ApplicationUserIdentity()
{
UserName = request.UserName,
Email = request.Email,
FullName = request.FullName,
NormalizedFullName = request.FullName.ToLower(),
PhoneNumber = request.PhoneNumber,
IsDeactivated = false,
IsDeleted = false,
CreatedDate = SystemClock.Now,
};
var result = await _userManager.CreateAsync(newUser, request.Password);
if (result.Succeeded)
{
return("Thành công");
}
return(default);
public ActionResult Register(RegisterViewModel newAccount)
{
if (ModelState.IsValid == false)
{
return(View(newAccount));
}
IdentityResult result = userAppService.Register(newAccount);
if (result.Succeeded)
{
IAuthenticationManager owinManager = HttpContext.GetOwinContext().Authentication;
//SignIn
SignInManager <ApplicationUserIdentity, string> signInManager =
new SignInManager <ApplicationUserIdentity, string>(
new ApplicationUserManager(), owinManager
);
ApplicationUserIdentity identityUser = userAppService.Find(newAccount.UserName, newAccount.PasswordHash);
signInManager.SignIn(identityUser, true, true);
TempData["Msg"] = "Register complete successfully";
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", result.Errors.FirstOrDefault());
return(View(newAccount));
}
}
public ActionResult Register(RegisterViewModel user)
{
if (ModelState.IsValid == false)
{
return(View(user));
}
IdentityResult result = accountAppService.Register(user);
if (result.Succeeded)
{
CartAppService cartAppService = new CartAppService();
IAuthenticationManager owinMAnager = HttpContext.GetOwinContext().Authentication;
//SignIn
SignInManager <ApplicationUserIdentity, string> signinmanager =
new SignInManager <ApplicationUserIdentity, string>(
new ApplicationUserManager(), owinMAnager
);
ApplicationUserIdentity identityUser = accountAppService.Find(user.UserName, user.PasswordHash);
signinmanager.SignIn(identityUser, true, true);
/*
* var userSignIn = User.Identity.GetUserId();
* cartAppService.InsertCart(userSignIn);
*/
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", result.Errors.FirstOrDefault());
return(View(user));
}
}
public UserViewModel GetVMByID(string id)
{
ApplicationUserIdentity user = TheUnitOfWork.User.FindByID(id);
UserViewModel userViewModel = Mapper.Map <UserViewModel>(user);
return(userViewModel);
}
public IdentityResult Register(RegisterViewModel user)
{
ApplicationUserIdentity identityUser =
mapper.Map <RegisterViewModel, ApplicationUserIdentity>(user);
return(TheUnitOfWork.Account.Register(identityUser));
}
public IdentityResult Register(ApplicationUserIdentity user)
{
try
{
IdentityResult result = manager.Create(user, user.PasswordHash);
return(result);
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
}
public async Task <IdentityResult> CreateAsync(ApplicationUserIdentity user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var dataTable = new DataTable();
dataTable.Columns.Add("Username", typeof(string));
dataTable.Columns.Add("NormalizedUsername", typeof(string));
dataTable.Columns.Add("Email", typeof(string));
dataTable.Columns.Add("NormalizedEmail", typeof(string));
dataTable.Columns.Add("FullName", typeof(string));
dataTable.Columns.Add("PasswordHas", typeof(string));
dataTable.Rows.Add(
user.Username,
user.NormalizedUsername,
user.Email,
user.NormalizedEmail,
user.FullName,
user.PasswordHas
);
using (var connection = new SqlConnection(_config.GetConnectionString("DefaultConnection")))
{
await connection.OpenAsync(cancellationToken);
await connection.ExecuteAsync("Account_insert", new { account = dataTable.AsTableValuedParameter("dbo.AccountType") },
commandType : CommandType.StoredProcedure);
}
return(IdentityResult.Success);
}
//public void GetAllReservationToDoctor(string doctorId)
//{
// TheUnitOfWork.ReservationRepo.GetWhere(i => i.userId == doctorId);
//}
public List <GetAllReservationToPatientDTO> GetAllReservationToPationt(string userId)
{
List <GetAllReservationToPatientDTO> dto = new List <GetAllReservationToPatientDTO>();
List <Reservation> reservation = TheUnitOfWork.ReservationRepo.GetWhere(i => i.userId == userId).OrderByDescending(i => i.Date).ToList();
reservation.ForEach(reserve =>
{
string doctorId = reserve.doctorId;
var dayShift = TheUnitOfWork.DayShiftRepo.GetById(reserve.dayShiftId);
ApplicationUserIdentity user = TheUnitOfWork.AccountRepo.GetAccountById(doctorId);
Clinic clinic = TheUnitOfWork.ClinicRepo.GetByIdWithArea(doctorId);
GetAllReservationToPatientDTO insertDto = new GetAllReservationToPatientDTO();
insertDto.reservetionId = reserve.Id;
insertDto.DoctorName = user.FullName;
insertDto.Date = reserve.Date;
insertDto.ClinicStreeet = clinic.Street;
insertDto.ClinicArea = clinic.Area.Name;
insertDto.State = reserve.State;
insertDto.IsRated = reserve.IsRated;
insertDto.DayShiftFrom = dayShift.From;
insertDto.DayShiftTo = dayShift.To;
dto.Add(insertDto);
});
return(dto);
}
public ActionResult Login(LoginViewModel user)
{
if (ModelState.IsValid == false)
{
return(View(user));
}
ApplicationUserIdentity identityUser = accountAppService.Find(user.UserName, user.PasswordHash);
if (identityUser != null)
{
IAuthenticationManager owinMAnager = HttpContext.GetOwinContext().Authentication;
//SignIn
SignInManager <ApplicationUserIdentity, string> signinmanager =
new SignInManager <ApplicationUserIdentity, string>(
new ApplicationUserManager(), owinMAnager
);
signinmanager.SignIn(identityUser, true, true);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Not Valid Username & Password");
return(View(user));
}
}
public async Task <IActionResult> GetCurrentUser()
{
var userId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
ApplicationUserIdentity user = await _accountAppService.GetUserById(userId);
return(Ok(user));
}
public EditlMyProfileVM GetEditMyProfileVM(string id)
{
ApplicationUserIdentity user = TheUnitOfWork.User.FindByID(id);
EditlMyProfileVM editlMyProfileVM = Mapper.Map <EditlMyProfileVM>(user);
return(editlMyProfileVM);
}
public IdentityResult SoftDeleteUser(string userId)
{
ApplicationUserIdentity user = TheUnitOfWork.User.FindByID(userId);
user.IsDeleted = true;
return(TheUnitOfWork.User.Update(user));
}
public ActionResult EmployeeRegister(RegisterVM user)
{
if (ModelState.IsValid == false)
{
return(View(user));
}
IdentityResult result = accountAppService.Register(user);
if (result.Succeeded)
{
ApplicationUserIdentity identityUser = accountAppService.Find(user.UserName, user.PasswordHash);
accountAppService.AssignToRole(identityUser.Id, "Employee"); //-------------
employeeAppService.SaveNewEmployee(new Employee {
Id = identityUser.Id, DealerId = User.Identity.GetUserId()
}); //To add UserId to Dealer table, like make the relatin manwal
return(RedirectToAction("Index", "Employee", new { area = "Dealer" })); //Dealer area
}
else
{
ModelState.AddModelError("", result.Errors.FirstOrDefault());
return(View(user));
}
}
public bool UpdateEmployee(ApplicationUserIdentity employee)
{
TheUnitOfWork.Account.Update(employee);
TheUnitOfWork.Commit();
return(true);
}
public void UpdateUser(string userId, UserViewModel userViewModel)
{
ApplicationUserIdentity user = TheUnitOfWork.User.FindByID(userId);
Mapper.Map(userViewModel, user);
TheUnitOfWork.User.Update(user);
}
public IdentityResult AddUser(AddUserVM newUser)
{
ApplicationUserIdentity identityUser = Mapper.Map <ApplicationUserIdentity>(newUser);
identityUser.Cart = new Cart();
identityUser.WishList = new Wishlist();
return(TheUnitOfWork.User.Register(identityUser));
}
public async Task <ApplicationUserIdentity> Register(RegisterAccountDTO registerAccountDTO)
{
ApplicationUserIdentity registerUser = Mapper.Map <ApplicationUserIdentity>(registerAccountDTO);
await TheUnitOfWork.AccountRepo.Register(registerUser);
TheUnitOfWork.SaveChanges();
return(registerUser);
}
public async Task <ApplicationUserIdentity> Find(string name, string password)
{
ApplicationUserIdentity user = await TheUnitOfWork.AccountRepo.Find(name, password);
if (user != null)
{
return(user);
}
return(null);
}
public bool IsExisted(string name, string password)
{
ApplicationUserIdentity user = TheUnitOfWork.Account.Find(name, password);
if (user != null)
{
return(true);
}
return(false);
}
public IdentityResult Update(ApplicationUserIdentity employee)
{
var user = manager.FindById(employee.Id);
user.UserName = employee.UserName;
user.Email = employee.Email;
user.PhoneNumber = employee.PhoneNumber;
IdentityResult result = manager.Update(user);
return(result);
}
public IdentityResult DeleteUser(string userId)
{
ApplicationUserIdentity user = TheUnitOfWork.User.FindByID(userId);
TheUnitOfWork.Cart.Delete(user.Cart);
TheUnitOfWork.Wishlist.Delete(user.WishList);
TheUnitOfWork.OrderHeader.DeleteList(user.OrderHeaders);
var result = TheUnitOfWork.User.Delete(user);
TheUnitOfWork.Commit();
return(result);
}
public bool AssignToRole(RegisterVM uservm)
{
try
{
ApplicationUserIdentity user = TheUnitOfWork.Account.FindByName(uservm.UserName);
if (uservm.userType == UserType.Teacher)
{
TheUnitOfWork.Account.AssignToRole(user.Id, "Teacher");
Teacher teacher = new Teacher()
{
user = user,
ID = user.Id,
firstName = uservm.firstName,
lastName = uservm.lastName,
gender = uservm.gender.ToString(),
age = uservm.age,
image = "defaultProfile.jpg"
};
user.teacher = teacher;
TheUnitOfWork.Teacher.InsertTeacher(teacher);
TheUnitOfWork.Commit();
}
else if (uservm.userType == UserType.Student)
{
TheUnitOfWork.Account.AssignToRole(user.Id, "Student");
Student student = new Student()
{
user = user,
ID = user.Id,
firstName = uservm.firstName,
lastName = uservm.lastName,
gender = uservm.gender.ToString(),
age = uservm.age,
image = "defaultProfile.jpg"
};
user.student = student;
TheUnitOfWork.Student.InsertStudent(student);
TheUnitOfWork.Commit();
}
return(true);
}
catch
{
return(false);
}
}
public ActionResult AddToCart(int productId)
{
string userId = User.Identity.GetUserId();
ApplicationUserIdentity user = userAppService.FindByID(userId);
CartProduct cartProduct = new CartProduct()
{
CartID = user.Id,
ProductID = productId,
Quantity = 1
};
cartAppService.addProduct(cartProduct);
TempData["Msg_Cart"] = "New Item Added Successfully To Cart";
return(RedirectToAction("index"));
}
public bool SignIn(LoginVM user, IAuthenticationManager owinManager)
{
try
{
SignInManager <ApplicationUserIdentity, string> signinmanager =
new SignInManager <ApplicationUserIdentity, string>(
new ApplicationUserManager(), owinManager
);
ApplicationUserIdentity identityUser = Find(user.UserName, user.PasswordHash);
signinmanager.SignIn(identityUser, true, true);
return(true);
}
catch
{
return(false);
}
}
public string CreateToken(ApplicationUserIdentity user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.NameId, user.ApplicationUserID.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Username)
};
var creds = new SigningCredentials(_key, SecurityAlgorithms.HmacSha256Signature);
var token = new JwtSecurityToken(
_issuer,
_issuer,
claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <IActionResult> RegisterDoctor(CreateDoctorDTO registerDoctorDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool isUsernameExist = await _accountAppService.checkUsernameExist(registerDoctorDTO.UserName);
if (isUsernameExist)
{
return(BadRequest(new Response {
Message = "Username already exist"
}));
}
bool isEmailExist = await _accountAppService.checkEmailExist(registerDoctorDTO.Email);
if (isEmailExist)
{
return(BadRequest(new Response {
Message = "Email already exist"
}));
}
try
{
registerDoctorDTO.IsDoctor = true;
ApplicationUserIdentity registerUser = await _accountAppService.Register(registerDoctorDTO);
await _accountAppService.AssignToRole(registerUser.Id, UserRoles.Doctor);
_doctorAppService.Create(registerUser.Id, registerDoctorDTO);
_generalAppService.CommitTransaction();
return(Ok(new Response {
Message = "Doctor created successfully"
}));
}
catch (Exception ex)
{
_generalAppService.RollbackTransaction();
return(BadRequest(new Response {
Message = ex.Message
}));
}
}
