public async Task <IActionResult> Create(Guid?id, [Bind("Password,ConfirmPassword,FullName,UserName,Email,PhoneNumber")] RegisterViewmodel registerViewmodel, IFormFile image)
{
if (ModelState.IsValid)
{
if (id.HasValue)
{
var userN = _context.Users.Find(id);
userN.UserName = registerViewmodel.Email;
userN.NormalizedUserName = registerViewmodel.Email.ToUpper();
userN.Email = registerViewmodel.Email;
userN.NormalizedEmail = registerViewmodel.Email.ToUpper();
userN.FullName = registerViewmodel.FullName;
userN.PhoneNumber = registerViewmodel.PhoneNumber;
if (image != null)
{
if (checkPath(Path.GetExtension(image.FileName)))
{
var streamN = new MemoryStream();
image.CopyTo(streamN);
userN.Assignment = streamN.ToArray();
streamN.Close();
}
}
_context.Users.Update(userN);
await _context.SaveChangesAsync();
}
else
if (_userManager.FindByEmailAsync(registerViewmodel.Email).Result == null)
{
if (!checkPath(Path.GetExtension(image.FileName)))
{
return(PartialView("_OrderPartial", registerViewmodel));
}
var user = new ApplicationUser
{
Id = Guid.NewGuid(),
UserName = registerViewmodel.Email,
Email = registerViewmodel.Email,
FullName = registerViewmodel.FullName,
PhoneNumber = registerViewmodel.PhoneNumber
};
using (var stream = new MemoryStream())
{
await image.CopyToAsync(stream);
user.Assignment = stream.ToArray();
stream.Close();
}
var result = _userManager.CreateAsync(user, registerViewmodel.Password).Result;
if (result.Succeeded)
{
//_userManager.AddToRoleAsync(user, "Admin").Wait();
}
}
}
return(PartialView("_OrderPartial", registerViewmodel));
}
public IActionResult Registreer(string returnUrl = null)
{
var reqFields = tenantContext.Items[Tenant.Constants.REQUIREDFIELDS] as Field[];
var optFields = tenantContext.Items[Tenant.Constants.OPTIONALFIELDS] as Field[];
var vm = new RegisterViewmodel
{
ReturnUrl = returnUrl,
Required = reqFields.Select(x => new ValueField(x)).ToList(),
Optional = optFields.Select(x => new ValueField(x)).ToList()
};
return(View(vm));
}
public void RegisterUser(RegisterViewmodel registerViewmodel)
{
var customer = new Customer();
customer.UserName = registerViewmodel.UserName;
customer.Password = registerViewmodel.Password;
customer.NIC = registerViewmodel.NIC;
customer.PhoneNumber = registerViewmodel.PhoneNumber;
customer.Address = registerViewmodel.Address;
customer.BankType = registerViewmodel.BankType;
customer.PhoneType = registerViewmodel.PhoneType;
customer.BlockStatus = (int)RecordStatusEnum.Active;
customer.UserRole = (int)UserRoleEnum.ProfileUser;
_applicationContext.Customer.Add(customer);
_applicationContext.SaveChanges();
}
public async Task <IActionResult> Register(RegisterViewmodel model)
{
if (ModelState.IsValid)
{
// Copy data from RegisterViewModel to IdentityUser
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
City = model.City
};
// Store user data in AspNetUsers database table
var result = await userManager.CreateAsync(user, model.Password);
// If user is successfully created, sign-in the user using
// SignInManager and redirect to index action of HomeController
if (result.Succeeded)
{
// If the user is signed in and in the Admin role, then it is
// the Admin user that is creating a new user. So redirect the
// Admin user to ListRoles action
if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
{
return(RedirectToAction("ListUsers", "Administration"));
}
else
{
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
}
// If there are any errors, add them to the ModelState object
// which will be displayed by the validation summary tag helper
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public IActionResult Register(RegisterViewmodel model)
{
if (ModelState.IsValid)
{
UserModel user = new UserModel()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password,
Role = model.Role
};
_userCollection.Create(user);
TempData["Register"] = "Created account succesfully.";
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public async Task <IActionResult> Create(Guid?id)
{
var user = new RegisterViewmodel();
if (id.HasValue)
{
var userN = await _context.Users.FindAsync(id);
var userN2 = new RegisterViewmodel()
{
id = userN.Id,
Email = userN.Email,
FullName = userN.FullName,
PhoneNumber = userN.PhoneNumber,
Assignment = userN.Assignment
};
return(PartialView("_OrderPartial", userN2));
}
return(PartialView("_OrderPartial", user));
}
public async Task <IActionResult> Register(RegisterViewmodel registerModel)
{
var user = _mapper.Map <RegisterModel>(registerModel);
var result = await _identityService.Register(user, registerModel.Password);
var res = result.ToString();
if (!result.Succeeded)
{
return(BadRequest(res));
}
var token = await _identityService.GetEmailConfirmationToken(user.Email);
if (token.Succeeded)
{
return(Ok(token));
}
return(BadRequest());
}
public ActionResult Register(RegisterViewmodel registerViewmodel)
{
if (ModelState.IsValid)
{
try
{
_userManager.Register(registerViewmodel.Email, registerViewmodel.Password);
FormsAuthentication.SetAuthCookie(registerViewmodel.Email, false);
return(RedirectToAction("Index", "Home"));
}
catch (BusinessException be)
{
///TODO Log error.
}
}
return(View());
}
public ActionResult Register(RegisterViewmodel registerViewmodel)
{
if (!string.IsNullOrEmpty(registerViewmodel.PhoneNumber))
{
if (registerViewmodel.PhoneNumber.Length != 10 || registerViewmodel.PhoneNumber.Any(x => char.IsLetter(x)))
{
this.Flash(Toastr.ERROR, "Failed", "Enter numbers only for phone");
return(RedirectToAction("Login", registerViewmodel));
}
}
if (ModelState.IsValid)
{
registerViewmodel.Password = FormsAuthentication.HashPasswordForStoringInConfigFile(registerViewmodel.Password, "SHA1");
_securityService.RegisterUser(registerViewmodel);
this.Flash(Toastr.SUCCESS, "Success", "Registered Successfully");
return(RedirectToAction("Login"));
}
this.Flash(Toastr.ERROR, "Failed", "Fields cannot be blank");
return(RedirectToAction("Login", registerViewmodel));
}
public IActionResult Register(RegisterViewmodel viewmodel)
{
registerlogic.AddUser(new Models.Account(viewmodel.Name, viewmodel.Lastname, viewmodel.DateOfBirth, viewmodel.Gender, viewmodel.Username, viewmodel.Password, viewmodel.Saldo));
return(View("../Login/Index"));
//try
//{
//}
//catch (Exception e)
//{
// viewmodel.message = e.Message;
//}
//finally
//{
// viewmodel.Password = "";
//}
//return PartialView();
//return View("../Login/Index");
}
public async Task <IActionResult> Registreer(RegisterViewmodel model, string returnUrl = null)
{
if (ModelState.IsValid && model.Required.All(x => !string.IsNullOrEmpty(x.Value)))
{
var user = new ApplicationUser(Guid.NewGuid())
{
UserName = model.Username,
Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var claims = new List <Claim>();
foreach (var required in model.Required.Where(x => !string.IsNullOrEmpty(x.Value)))
{
claims.Add(new Claim(required.ClaimType, required.Value));
}
foreach (var optional in model.Optional.Where(x => !string.IsNullOrEmpty(x.Value)))
{
claims.Add(new Claim(optional.ClaimType, optional.Value));
}
await userManager.AddClaimsAsync(user, claims);
// Send an email with this link
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, protocol: HttpContext.Request.Scheme);
await emailSender.SendEmailAsync(model.Email, $"Welkom bij {tenantContext.Name}", $"Om gebruik te maken van uw {tenantContext.Name} account moet u uw email adres bevestigen. Gebruik daarvoor deze link: <a href='{callbackUrl}'>Activeer nu</a>");
return(View("Registered"));
}
AddErrors(result);
}
return(View(model));
}
