public IActionResult Registration()
{
HttpContext.Session.Remove("UserId");
AccountRegisterVM vm = new AccountRegisterVM();
return(View(vm));
}
public async Task <IActionResult> Register(AccountRegisterVM viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var user = new IdentityUser();
user.Email = viewModel.Email;
user.UserName = viewModel.Email;
var result = await userManager.CreateAsync(user, viewModel.Password);
if (!result.Succeeded)
{
if (result.ToString().Contains("DuplicateEmail"))
{
ModelState.AddModelError(nameof(AccountRegisterVM.Email), "E-posten är redan registrerad");
}
if (result.ToString().Contains("DuplicateUserName"))
{
ModelState.AddModelError(nameof(AccountRegisterVM.Email), "E-posten är redan registrerad");
}
return(View(viewModel));
}
mysticoContext.AddUser(user.Id, viewModel.FirstName, viewModel.LastName, viewModel.Email);
await signInManager.PasswordSignInAsync(user, viewModel.Password, false, false);
return(RedirectToAction(nameof(SplitController.Index), nameof(SplitController).Replace("Controller", "")));
}
public async Task <IActionResult> Registration(AccountRegisterVM userData)
{
if (ModelState.IsValid)
{
string uri = $"{baseuri}/users/username/{userData.UserName}";
User currentUser = await WebApiHelper.GetApiResult <User>(uri);
if (currentUser == null)//user bestaat nog niet
{
User newUser = new User()
{
FirstName = userData.FirstName,
LastName = userData.LastName,
UserName = userData.UserName,
PasswordHash = userData.Password
};
pH.HashPassword(newUser, newUser.PasswordHash);//het paswoord van de user wordt binnen deze functie vervangen
uri = $"{baseuri}/users";
User AddedUser = await WebApiHelper.PostCallAPI <User, User>(uri, newUser);
HttpContext.Session.SetString("UserId", AddedUser.Id.ToString());
return(new RedirectToActionResult("RegisterSuccess", "Account", null));
}
else
{
ModelState.AddModelError(string.Empty, "A trainer with that username already exists");
return(View(userData));
}
}
else
{
return(View(userData));
}
}
internal async Task <IdentityResult> TryCreateCompanyAsync(AccountRegisterVM vm)
{
var result = await userManager.CreateAsync(new CompanyUser
{
UserName = vm.UserName
}, vm.Password);
return(result);
}
public async Task <IdentityResult> TryRegisterAsync(AccountRegisterVM viewModel)
{
// Try to create a new user
return(await userManager.CreateAsync(
new MyIdentityUser { UserName = viewModel.Username,
FirstName = viewModel.FirstName,
Email = viewModel.Username },
viewModel.Password));
}
public async Task <IdentityResult> TryCreateUser(AccountRegisterVM vm)
{
var result = await userManager.CreateAsync(new MyIdentityUser
{
UserName = vm.UserName,
Email = vm.Email,
}, vm.Password);
return(result);
}
public bool IsUserExsits(AccountRegisterVM model)
{
User verifyUser = new UsersRepository().GetAll().FirstOrDefault((u => u.Username.ToLower() == model.Username.ToLower() || u.Email == model.Email));
if (verifyUser == null)
{
return(false);
}
return(true);
}
public async Task <bool> TryRegisterAsync(AccountRegisterVM viewModel)
{
// Todo: Try to create a new user
//Finns UserManager, RoleManager, SignInManager
//Identity vill att vi anv deras klasser (ovan) som i sin tur jobbar mot context
var result = await userManager.CreateAsync(
new MyIdentityUser { UserName = viewModel.Username }, viewModel.Password);
return(result.Succeeded);
}
public ActionResult Register(AccountRegisterVM model)
{
User user = new User();
if (ModelState.IsValid)
{
// Mapping ViewModel => entity
user.UserName = model.UserName;
user.UserPassword = model.UserPassword;
user.UserName = model.UserName;
user.UserEmail = model.UserEmail;
user.Birthday = model.Birthday;
user.UserLastName = model.UserLastName;
user.UserFirstName = model.UserFirstName;
user.UserAddress = model.UserAddress;
user.UserPost = model.UserPost;
user.UserGemeente = model.UserGemeente;
user.UserPhone = model.UserPhone;
// Aanmaak Hash-paswoord en Role als klant:
user.PasswordHash = FormsAuthentication.HashPasswordForStoringInConfigFile(user.UserPassword, "md5");
Role userRole = db.Roles.FirstOrDefault(r => r.RoleName == "Klant");
user.Roles.Add(userRole);
db.Users.Add(user);
db.SaveChanges();
// Aanmaak van de email
string body = "<p>Beste {0},</br></p><p>Bedankt voor uw registratieaanvraag! U kan meteen aan de slag.</p><p><u>Gegevens:</u></br></p><p>Naam: {0} {1}.</p><p>TEL / GSM: {2} </p><p>Email: {3}.</p><p>Adres: {4}</p><p></br>Met vriendelijke groeten,</br></p><p>Uw webmaster</p>";
var message = new MailMessage();
message.To.Add(new MailAddress("*****@*****.**"));
message.To.Add(new MailAddress("*****@*****.**"));
message.To.Add(new MailAddress("*****@*****.**"));
message.Subject = string.Format("Nieuwe registratie-aanvraag van website Ivo Bytes");
message.Body = string.Format(body, user.UserFirstName, user.UserLastName, user.UserPhone, user.UserEmail, user.UserAddress);
message.IsBodyHtml = true;
// Versturen van de mail via smtpClient => configuratie in web.config
SmtpClient smtp = new SmtpClient();
smtp.Send(message);
// Gebruik van Tempdata om Indexpagina te voorzien met een melding wanneer mail gestuurd werd.
TempData["Success"] = "Bedankt voor uw registratie! We nemen snel contact met u op.";
return(RedirectToAction("Index", "Home"));
}
// Modelstate not valid? See errors:
var errors = ModelState.Values.SelectMany(v => v.Errors);
return(View());
}
public async Task <IActionResult> Register(AccountRegisterVM model)
{
if (ModelState.IsValid)
{
string fileName = null;
if (_userManager.FindByEmailAsync(model.Email) != null)
{
ModelState.AddModelError("Email", "There is already an account with this email address.");
}
if (model.ProfileImage != null)
{
var uploadFolder = Path.Combine(_hostingEnvironment.WebRootPath, "img");
fileName = $"{Guid.NewGuid()}_{model.ProfileImage.FileName}";
var filePath = Path.Combine(uploadFolder, fileName);
await model.ProfileImage.CopyToAsync(new FileStream(filePath, FileMode.Create));
}
var account = new ApplicationUser {
FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email, ProfilePicturePath = fileName
};
var result = await _userManager.CreateAsync(account, model.Password);
if (result.Succeeded)
{
var user = await _userManager.FindByEmailAsync(account.Email);
await _userManager.AddToRoleAsync(user, "User");
await _signInManager.SignInAsync(account, isPersistent : false);
TempData["UserRegistered"] = $"You are now registered. Welcome {model.FirstName}!";
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public ActionResult Register(AccountRegisterVM model)
{
if (ModelState.IsValid)
{
UserRepository userRepo = new UserRepository();
User user = new User()
{
FirstName = model.FirstName,
LastName = model.LastName,
Password = model.Password
};
bool userDoesntExist = true;
User userUsername = userRepo.GetAll(us => us.Username == model.Username).FirstOrDefault();
if (userUsername != null)
{
ModelState.AddModelError("Username", "Username already exists");
userDoesntExist = false;
}
user.Username = model.Username;
User userEmail = userRepo.GetAll(us => us.Email == model.Email).FirstOrDefault();
if (userEmail != null)
{
ModelState.AddModelError("Email", "Email already exists");
userDoesntExist = false;
}
user.Email = model.Email;
if (userDoesntExist)
{
userRepo.Save(user);
return(RedirectToAction("Login"));
}
}
return(View(model));
}
public async Task <IActionResult> Register(AccountRegisterVM vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var result = await service.TryCreateUser(vm);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, result.Errors.First().Description);
return(View(vm));
}
return(RedirectToAction(nameof(Login)));
}
public async Task <IActionResult> Register([FromForm] AccountRegisterVM formdata)
{
// Hold Error List
List <string> errorList = new List <string>();
// Create User Object
var user = new User
{
Email = formdata.EmailAddress,
UserName = formdata.Username,
DateCreated = DateTimeOffset.UtcNow,
LastOnline = DateTimeOffset.UtcNow,
SecurityStamp = Guid.NewGuid().ToString()
};
// Add User To Database
var result = await _userManager.CreateAsync(user, formdata.Password);
// If Successfully Created
if (result.Succeeded)
{
// Add Role To User
await _userManager.AddToRoleAsync(user, "Customer");
// Return Ok Request
return(Ok(new
{
result = user,
message = "Registration Successful"
}));
}
else
{
// Add Error To ErrorList
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
errorList.Add(error.Description);
}
}
// Return Bad Request Status With ErrorList
return(BadRequest(new { message = errorList }));
}
public async Task <IActionResult> Register([FromBody] AccountRegisterVM viewModel)
{
if (!ModelState.IsValid)
{
return(Json(new { ModelState = false }));
}
// Try to register user
var result = await service.TryRegisterAsync(viewModel);
if (!result.Succeeded)
{
var x = result.Errors.First().Description;
// Show error
ModelState.AddModelError(string.Empty, result.Errors.First().Description);
return(Json(new { success = false, responseText = "Det gick inte att skapa användaren.", test = x } /*, JsonRequestBehavior.AllowGet*/));
}
return(Json(new { success = true, responseText = "Användaren tillagd i databasen" } /*, JsonRequestBehavior.AllowGet*/));
}
public async Task <IActionResult> RegisterAsync(AccountRegisterVM viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
// Try to register user
var success = await accountService.TryRegisterAsync(viewModel);
if (!success)
{
// Show error
ModelState.AddModelError(string.Empty, "Failed to create user");
return(View(viewModel));
}
// Redirect user
return(RedirectToAction(nameof(Login)));
}
public async Task <IActionResult> Register(AccountRegisterVM viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
// Try to register user
var result = await accountService.TryRegisterAsync(viewModel);
if (!result.Succeeded)
{
// Show error
ModelState.AddModelError(string.Empty, result.Errors.First().Description);
return(View(viewModel));
}
// Redirect user
return(RedirectToAction(nameof(Login)));
}
public IActionResult Register([FromForm] AccountRegisterVM userVM)
{
//мапим вьюмодель в сущность. далее подключу автомаппер
User user = new User()
{
FirstName = userVM.FirstName,
LastName = userVM.LastName,
Username = userVM.Username,
};
// создаём юзера
try
{
return(Ok(accountModel.AccountCreate(user, userVM.Password)));
}
catch (AppException ex)
{
//кидаем исключения из модельки
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Register(AccountRegisterVM model)
{
if (ModelState.IsValid)
{
var result = await userManager.CreateAsync(new IdentityUser(model.UserName), (model.PassWord));
if (!result.Succeeded)
{
ModelState.AddModelError("UserName", result.Errors.First().Description);
}
else
{
var res2 = await signInManager.PasswordSignInAsync(model.UserName, model.PassWord, false, false);
TempData["User"] = JsonConvert.SerializeObject(model);
return(RedirectToAction(nameof(AddUser)));
}
}
return(View(model));
}
public ActionResult Register()
{
UsersService usersService = new UsersService();
AccountRegisterVM model = new AccountRegisterVM();
TryUpdateModel(model);
if (usersService.IsUserExsits(model))
{
ModelState.AddModelError(String.Empty, "Username or Email is already taken.");
}
if (!ModelState.IsValid)
{
return(View(model));
}
User user;
if (model.ID == 0)
{
user = new User();
}
else
{
return(this.RedirectToAction(c => c.Login()));
}
Mapper.Map(model, user);
user.Password = Guid.NewGuid().ToString();
usersService.Save(user);
Task.Run(() => EmailService.SendEmail(user, ControllerContext));
return(View("WaitForConfirmation"));
}
public ActionResult Register(string redirectUrl)
{
AccountRegisterVM model = new AccountRegisterVM();
return(View(model));
}
public async Task <IdentityResult> TryRegisterAsync(AccountRegisterVM viewModel)
{
return(await userManager.CreateAsync(
new MyIdentityUser { UserName = viewModel.Username },
viewModel.Password));
}
public async Task <bool> TryRegisterAsync(AccountRegisterVM viewModel)
{
var result = await userManager.CreateAsync(new MyIdentityUser { UserName = viewModel.Username }, viewModel.Password);
return(result.Succeeded);
}
public async Task <IActionResult> Register(AccountRegisterVM viewModel)
{
if (!ModelState.IsValid)
{
string user = repository.GetUsername(HttpContext.User);
string id = repository.GetUserId(HttpContext.User);
var model = new HomeIndexVM
{
LoggedIn = User.Identity.IsAuthenticated,
DigiStudent = new HomeIndexFindClassroomVM {
Classrooms = await repository.GetAllClassrooms()
}, //classrooms = repository.FindAllClassrooms();
CreateClassroom = new HomeIndexCreateClassroomVM(),
DigiMaster = new HomeIndexLoginVM {
Username = user
},
Register = new AccountRegisterVM {
OldClassroomName = repository.GetClassroomNameByAspNetId(id), OldClassroomId = repository.GetClassroomId(id)
}
};
TempData["username"] = viewModel.RegUsername;
TempData["password"] = viewModel.RegPassword;
TempData["classroomname"] = viewModel.ClassroomName;
TempData["message"] = "Fyll i alla fält.";
return(RedirectToAction(nameof(Index), model));
}
if (!await repository.IsClassroomNameAvailable(viewModel.ClassroomName))
{
string user = repository.GetUsername(HttpContext.User);
string id = repository.GetUserId(HttpContext.User);
var model = new HomeIndexVM
{
LoggedIn = User.Identity.IsAuthenticated,
DigiStudent = new HomeIndexFindClassroomVM {
Classrooms = await repository.GetAllClassrooms()
}, //classrooms = repository.FindAllClassrooms();
CreateClassroom = new HomeIndexCreateClassroomVM(),
DigiMaster = new HomeIndexLoginVM {
Username = user
},
Register = new AccountRegisterVM {
OldClassroomName = repository.GetClassroomNameByAspNetId(id), OldClassroomId = repository.GetClassroomId(id)
}
};
TempData["username"] = viewModel.RegUsername;
TempData["password"] = viewModel.RegPassword;
TempData["classroomname"] = viewModel.ClassroomName;
TempData["message"] = "Klassrumsnamn är upptaget.";
return(RedirectToAction(nameof(Index), model));
}
var result = await repository.CreateUser(viewModel.RegUsername, viewModel.RegPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
if (error.Code.Contains("User"))
{
ModelState.AddModelError(nameof(AccountRegisterVM.RegUsername), error.Description);
}
else
{
ModelState.AddModelError(nameof(AccountRegisterVM.RegPassword), error.Description);
}
}
string user = repository.GetUsername(HttpContext.User);
string id = repository.GetUserId(HttpContext.User);
var model = new HomeIndexVM
{
LoggedIn = User.Identity.IsAuthenticated,
DigiStudent = new HomeIndexFindClassroomVM {
Classrooms = await repository.GetAllClassrooms()
}, //classrooms = repository.FindAllClassrooms();
CreateClassroom = new HomeIndexCreateClassroomVM(),
DigiMaster = new HomeIndexLoginVM {
Username = user
},
Register = new AccountRegisterVM {
OldClassroomName = repository.GetClassroomNameByAspNetId(id), OldClassroomId = repository.GetClassroomId(id)
}
};
TempData["username"] = viewModel.RegUsername;
TempData["password"] = viewModel.RegPassword;
TempData["classroomname"] = viewModel.ClassroomName;
TempData["message"] = "Användarnamn eller lösenord är inte tillgänglig.";
return(RedirectToAction(nameof(Index), model));
}
ClassroomDigiMasterVM modell = await repository.CreateClassroom(UtilClass.ParseHtml(viewModel.ClassroomName), await repository.GetUserAsync(viewModel.RegUsername));
return(RedirectToAction("DigiMaster", "Classroom", new { id = await repository.GetClassroomIdByName(viewModel.OldClassroomName) }));
}
