public async Task <IActionResult> Register([FromBody] RegisterUserVm model)
{
var user = new AppUser
{
UserName = model.Username,
Email = model.Email,
PSK = TimeSensitivePassCode.GeneratePresharedKey()
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var retVal = new
{
user,
token = GenerateJwtToken(model.Username, user, false)
};
// NOTE: Return the PSK to be able to register via Google/Microsoft Authenticator
return(Ok(retVal));
}
throw new ApplicationException("UNKNOWN_ERROR");
}
public async Task <IActionResult> CreateUser(RegisterUserVm model)
{
if (ModelState.IsValid)
{
var user = new Users
{
Email = model.Email,
UserName = model.Username,
TEST = model.Test,
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Bruger");
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public ActionResult Index()
{
CurrentPage = PageTypes.NewUser;
var viewModel = new RegisterUserVm {
Role = UserRoleType.Alumni
};
PopulateCourses(viewModel.CourseId, viewModel.BranchId);
return(View(viewModel));
}
private User RegisterNewUser(RegisterUserVm userDetails)
{
var user = ValidateAndUpdateCommonInfo(userDetails);
if (userDetails.Role == UserRoleType.Alumni || userDetails.Role == UserRoleType.Student)
{
UpdateCourseDetails(userDetails.Batch, userDetails.BranchId, user);
}
_db.Users.Add(user);
_db.SaveChanges();
AddUserLog(user.UserId, "User Register");
return(user);
}
public bool Register(RegisterUserVm vm)
{
User user = Mapper.Instance.Map <RegisterUserVm, User>(vm);
if (this.Context.Users.Any(name => name.Username == user.Username))
{
return(false);
}
else
{
this.Context.Users.Add(user);
this.Context.SaveChanges();
return(true);
}
}
public ActionResult Register(RegisterUserVm vm)
{
if (this.userRepository.Register(vm))
{
if (ModelState.IsValid && vm.ConfirmPassword == vm.Password)
{
return(RedirectToAction("Login"));
}
return(View());
}
else
{
ModelState.AddModelError("", "Username taken");
return(View());
}
}
public ActionResult Register()
{
var httpCookie = this.Request.Cookies.Get("sessionId");
if (httpCookie != null && AuthenticationManager.IsAuthenticated(httpCookie.Value))
{
var user = AuthenticationManager.GetUser(httpCookie.Value);
ViewBag.Username = user.Username;
return(this.RedirectToAction("All", "Cameras"));
}
var model = new RegisterUserVm();
return(View(model));
}
private User ValidateAndUpdateCommonInfo(RegisterUserVm userDetails)
{
_userService.ValidateEmailUnique(userDetails.Email);
var user = userDetails.GetUserEntity();
var password = userDetails.Password;
user.AccountStatus = UserRegisterStatus.Approved;
user.MobileNumber = userDetails.MobileNumber;
user.HashedPassword = _hashService.CreateHash(password);
//TODO
//var role = _db.Roles.Single(r => r.RoleId == (byte)userDetails.Role);
user.UserRoles.Add(new UserRole
{
RoleType = userDetails.Role
});
return(user);
}
public PartialViewResult RegisterUser(RegisterUserVm model)
{
if (ModelState.IsValid)
{
try
{
var user = _regService.RegisterUser(model);
_regService.SendEmailValidationToken(user);
return(PartialView("ThankYou", model));
}
catch (SimpleException ex)
{
ModelState.AddModelError("", ex.Message);
}
}
PopulateCourses(model.CourseId, model.BranchId);
return(PartialView("RegisterUser", model));
}
public User RegisterUser(RegisterUserVm userDetails)
{
lock (_regSync)
{
var user = _db.Users.ToList()
.FirstOrDefault(u => u.FullName == userDetails.FirstName &&
u.UserCourses.Any(c => c.Batch == userDetails.Batch &&
userDetails.BranchId == c.BranchId) &&
(u.CreateType == UserCreateTypes.Auto || u.CreateType == UserCreateTypes.Admin));
if (user == null)
{
return(RegisterNewUser(userDetails));
}
else
{
return(UpgradeAutoToManual(userDetails, user));
}
}
}
public async Task <IActionResult> CreateAsync(RegisterUserVm register)
{
var identity = new IdentityUser
{
Email = register.Email,
EmailConfirmed = true,
UserName = register.Email,
};
IdentityResult identityResult = await userManager.CreateAsync(identity, register.Password);
if (identityResult.Succeeded)
{
SmnUser user = new SmnUser
{
DataELindjes = register.DataELindjes,
Emri = register.Emri,
EmriPrindit = register.EmriPrindit,
Foto = register.Foto,
Mbiemri = register.Mbiemri,
Identity = identity,
};
IdentityResult result = await userManager.AddToRoleAsync(identity, register.Roli);
context.SmnUser.Add(user);
await context.SaveChangesAsync();
return(Ok("New User Created"));
}
else
{
return(Ok("some error"));
}
return(View());
}
private User UpgradeAutoToManual(RegisterUserVm userDetails, User user)
{
if (userDetails.Email.ToLower() != user.Email.ToLower())
{
_userService.ValidateEmailUnique(userDetails.Email);
}
user.Email = userDetails.Email;
user.MobileNumber = string.IsNullOrEmpty(userDetails.MobileNumber) ? user.MobileNumber : userDetails.MobileNumber;
user.CreateType = UserCreateTypes.AutoManual;
user.JoinedOn = DateTime.UtcNow;
user.AccountStatus = UserRegisterStatus.Approved;
user.EmailConfirmedOn = null;
user.MobileNumber = userDetails.MobileNumber;
user.HashedPassword = _hashService.CreateHash(userDetails.Password);
_db.Entry(user).State = System.Data.EntityState.Modified;
_db.SaveChanges();
AddUserLog(user.UserId, "User converted from auto to manual");
return(user);
}
