public async Task <ActionResult> RegisterAdmin(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var admin = new Admin()
{
UserId = user.Id, Name = model.Name
};
_db.Admin.Add(admin);
_db.SaveChanges();
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public IActionResult Register(RegisterAdminViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Böyle bir rol ekleyemedik");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login"));
}
}
return(View(registerViewModel));
}
public async Task <ActionResult> RegisterAdmin(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, name = model.name
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "Admin");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://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 async Task <IActionResult> Register(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = model.Email, Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//2n param is session cookie = lost after we close the browser window
//or permannet cookie = permanetly on user machine
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
foreach (var error in result.Errors)
{
//what is the model state object why we add here??
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public IActionResult RegisterAdmin(RegisterAdminViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
return(View("RegisterSuccessful"));
}
public IActionResult RegisterAdmin(RegisterAdminViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ViewData["AsWho"] = "Admin";
return(View("RegisterSuccessful"));
}
public async Task <ActionResult> Create(RegisterAdminViewModel model, FormCollection collection)
{
try
{
// TODO: Add insert logic here
AlphaNumGen alp = new AlphaNumGen();
var pwd = alp.GetPassword();
string username = string.Concat(model.FirstName.Substring(0, 1), "_", model.LastName);
var user = new ApplicationUser
{
UserName = username,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.Phone,
RegDate = DateTime.UtcNow,
NotifyStatus = 1,
UserType = "AD",
// EmailConfirmed = true
};
//this method add Newly registering Subcriber to AspNetUsers Tb which house is primary info and login permission
var result = await UserManager.CreateAsync(user, pwd);
if (result.Succeeded)
{
var UserRole = UserManager.GetRoles(user.Id);
if (!UserRole.Contains("Admin"))
{
var addToRole = UserManager.AddToRole(user.Id, "Admin");
}
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
//TODO: newly created admin get an email notification containing is registrations status
// eg. username and password
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "superadm",
new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", em.Notification_Email_Body_Creator(user.FullName, "This is to notify you that an account has been created " +
"for you on iHealth Nigeria GSFM Portal using this email address " + user.Email + " and the following information: <br/><br/> Username: "******"" +
"<br/> Password: "******" <br/><br/>Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>. <br/> Welcome on board. <br/><br/>" +
"Best Regards, <br/><br/> iHealth Nigeria Management"));
TempData["success"] = "Registration Succeeded";
return(RedirectToAction("create", "superadm"));
}
AddErrors(result);
}
catch
{
return(View());
}
return(View());
}
public async Task <ActionResult> Register(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
int flength = model.NameExtension.IndexOf("_");
string firstname = null;
if (flength > 0)
{
firstname = model.NameExtension.Substring(0, flength);
}
int index = model.NameExtension.IndexOf("_");
string lastname = model.NameExtension.Substring(index + 1);
var user = new ApplicationUser
{
NameExtension = model.NameExtension,
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
FirstName = firstname,
LastName = lastname,
CountryId = model.CountryId,
IsInterestedInLawyer = model.IsInterestedInLawyer,
DateRegistered = DateTime.UtcNow,
Career = "Admin",
EmailConfirmed = true,
DisableRP = false
};
var result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
// AddErrors(result);
}
await UserManager.SetTwoFactorEnabledAsync(user.Id, false);
if (result.Succeeded)
{
string iD = Guid.NewGuid().ToString();
return(RedirectToAction("UserRole", new { Controller = "Admin", action = "UserRole", page = user.Id, id = iD }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> RegisterAdmin(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
var createResult = await CreateAdminUser(model);
if (createResult.Success)
{
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(createResult.Result);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> RegisterAdminPanel(RegisterAdminViewModel registerDto)
{
IValidationContext validationContext = new ValidationContext <RegisterDto>(registerDto);
if (!ModelState.IsValid || !_registerValidator.Validate(validationContext).IsValid)
{
return(View());
}
var registerResponse = await _accountClientService.RegisterResponse(registerDto);
if (registerResponse.IsSuccessful)
{
ViewBag.Result = "Account created successfully!";
return(View());
}
ModelState.AddModelError(nameof(RegisterAdminViewModel.Username), registerResponse.Content.Trim('"'));
return(View());
}
public async Task <ActionResult> Register(RegisterAdminViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Name, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = UserManager.AddToRole(user.Id, "Administrator");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(model));
}
public ActionResult RegisterAdmin(RegisterAdminViewModel model)
{
if (model.BootstrapAdministratorSecret != ConfigReader.GetConfigValue("BootstrapAdministratorSecret"))
{
this.ModelState.AddModelError("BootstrapAdministratorSecret", "The provided Bootstrap Administrator Secret is invalid.");
}
if (!this.ModelState.IsValid)
{
return(View(model));
}
if (this.userService.GetUsers().Count() > 0)
{
// If a user exists, then this action should not occur.
return(RedirectToAction("Index", "Home"));
}
var identity = this.HttpContext.User.Identity as IClaimsIdentity;
var nameIdentifierClaim = identity.Claims.Where(c => c.ClaimType.Equals(ClaimTypes.NameIdentifier, StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
var identityProviderClaim = identity.Claims.Where(c => c.ClaimType.Equals(IdentityProviderClaimType, StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
var user = new User()
{
Name = model.AdministratorEmail,
Email = model.AdministratorEmail,
NameIdentifier = nameIdentifierClaim.Value,
IdentityProvider = identityProviderClaim.Value,
};
this.userService.CreateUser(user);
var role = this.roleService.GetRoleByName("Administrator");
this.roleService.AddUserToRole(role, user);
this.ExecuteLogOff();
return(RedirectToAction("RegistrationSuccess"));
}
public async Task <IActionResult> RegisterAdmin([FromBody] RegisterAdminViewModel Credentials)
{
if (ModelState.IsValid)
{
var admin = new User
{
UserName = Credentials.Email,
Email = Credentials.Email,
};
var result = await _userManager.CreateAsync(admin, Credentials.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(admin, "admin");
await _signInManager.SignInAsync(admin, isPersistent : false);
return(Ok("User successfully registered"));
}
return(Errors(result));
}
return(Error("Unexpected error"));
}
public async Task<ActionResult> AddAdmin(RegisterAdminViewModel model)
{
School school = schoolRepository.GetById(model.SchoolId);
if (ModelState.IsValid)
{
if (!RoleManager.RoleExists(WebRoles.Admin))
{
RoleManager.Create(new IdentityRole(WebRoles.Admin));
}
var user = new User() { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// Add user in Admin role
UserManager.AddToRole(user.Id, WebRoles.Admin);
// Add user id to school
school.AdminId = user.Id;
schoolRepository.Update(school);
saveContext.Commit();
return RedirectToAction("Index/" + model.SchoolId, new { area = "Admin"});
}
AddErrors(result);
}
ViewBag.Breadcrumb = new List<Breadcrumb>()
{
new Breadcrumb(Breadcrumb.HomeName, Breadcrumb.AdminHomeUrl),
new Breadcrumb(school.Name, Breadcrumb.AdminSchoolUrl + "/index/" + model.SchoolId),
new Breadcrumb(Breadcrumb.ActionAdd)
};
return View(model);
}
private async Task <AdminUserResult> CreateAdminUser(RegisterAdminViewModel model)
{
bool success = false;
var user = new ApplicationUser {
UserName = model.Nick, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var usuario = await _db.Usuarios.FirstOrDefaultAsync(u => u.Nick == model.Nick);
if (usuario == null)
{
_db.Usuarios.Add(new Usuarios
{
Contraseña = model.Password,
DNI = model.DNI,
Nick = model.Nick,
Nombre = model.Name,
Rol = "A"
});
_db.Administradores.Add(new Administradores
{
Nombre = model.Name,
Apellidos = model.Surname,
DNI_Admin = model.DNI,
Email = model.Email,
Nick = model.Nick,
Foto = "koala.png"
});
try
{
await _db.SaveChangesAsync();
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
string msg = Helpers.Util.ValidationErrors(e);
throw;
}
}
var manager = new IdentityManager();
await manager.CreateRoleAsync(KoalaRoles.UserAdmin);
await manager.AddUserToRoleAsync(user.Id, KoalaRoles.UserAdmin);
// 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>");
success = true;
}
return(new AdminUserResult
{
Success = success,
Result = result
});
}
public RegisterAdminPage(AccountType userAccountType, Action complete = null)
{
InitializeComponent();
BindingContext = new RegisterAdminViewModel(userAccountType, complete);
}
