public ActionResult RegisterAdmin(RegisterAdminModel data)
{
string guid = Guid.NewGuid().ToString("N");
AdminService admin = new AdminService();
Photo photo = new Photo
{
Photo1 = db.Photos.Find(1).Photo1,
CreateDate = DateTime.Now
};
db.Photos.Add(photo);
db.SaveChanges();
User user = new User()
{
UserName = data.UserName,
UserPassword = MemberMethod.HashPw(data.UserPassword, guid),
Email = data.Email,
GUID = guid,
Phone = data.Phone,
RegistrationDate = DateTime.Now,
Enabled = true,
PhotoID = photo.PhotoID,
Admin = true,
RegionID = data.Region,
VerificationCode = "",
Address = "",
OauthType = "N",
Gender = data.Gender.Equals("male"),
Destination = "."
};
string uid = admin.Register(user).ToString();
return(uid != "0" ? Json(uid) : Json("Fail"));
}
public async Task RegisterAdminAsync(RegisterAdminModel model)
{
try
{
if (!model.Password.ToLower().Equals(model.ConfirmPassword.ToLower()))
{
throw new Exception("Password and confirm password must be matched.");
}
if ((await _userManager.FindByNameAsync(model.Email)) != null)
{
throw new Exception("Username already exist.");
}
AppUser user = new AppUser();
user.UserName = model.Email;
user.Email = model.Email;
user.PhoneNumber = model.PhoneNumber;
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
throw new Exception(result.ErrorGathering());
}
await AssignRoleToUser(user.Id, PharmacyRoles.Admin);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ActionResult> RegisterAdmin(RegisterAdminModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.UserName, Email = model.UserName, IsActive = true, MaDonVi = model.MaDonVi, HoTen = model.FullName, UType = "AD"
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "AD");
return(Json(new ResultInfo()
{
error = 0
}));
}
AddErrors(result);
}
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.FirstOrDefault();
// If we got this far, something failed, redisplay form
return(Json(new ResultInfo()
{
error = 1,
msg = errors.Select(p => p.ErrorMessage).FirstOrDefault()
}));
}
public async Task <IActionResult> RegisterAdmin([FromBody] RegisterAdminModel model)
{
var userExists = await _userManager.FindByNameAsync(model.UserName);
if (userExists != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "Użytkownik już istnieje!"
}));
}
ApplicationUser user = new ApplicationUser()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.UserName,
Name = model.Name,
Forname = model.Forname
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "Nie udało się stworzyć użytkownika!"
}));
}
if (!await _roleManager.RoleExistsAsync(UserRoles.Admin))
{
await _roleManager.CreateAsync(new IdentityRole(UserRoles.Admin));
}
if (!await _roleManager.RoleExistsAsync(UserRoles.User))
{
await _roleManager.CreateAsync(new IdentityRole(UserRoles.User));
}
if (await _roleManager.RoleExistsAsync(UserRoles.Admin))
{
await _userManager.AddToRoleAsync(user, UserRoles.Admin);
}
Prison prison = new Prison();
prison.PrisonName = model.PrisonName;
_prisonService.CreatePrison(prison);
_userPermissionsService.AddUserPermissions(model.UserName, model.PrisonName);
return(Ok(new Response {
Status = "Success", Message = "Użytkownik został stworzony!"
}));
}
public IActionResult Register([FromBody] RegisterAdminModel model)
{
// map model to entity
var user = _mapper.Map <User>(model);
user.AccesLevel = "Admin";
try
{
// create user
_userService.AdminCreate(user, model.Password);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult> NewAdmin(RegisterAdminModel model)
{
if (ModelState.IsValid)
{
try
{
await _userService.RegisterAdminAsync(model);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View());
}
}
else
{
return(View());
}
}
public ActionResult registroAdmin(RegisterAdminModel model)
{
if (model.PASSWORD == model.CONFIRMAR_PASSWORD)
{
model.PASSWORD = Helper.Encrypt(model.PASSWORD);
using (MEDICFARMAEntities db = new MEDICFARMAEntities())
{
var existsAdmin = db.ADMINISTRADOR_FARMACIA.FirstOrDefault(x => x.USUARIO == model.USUARIO);
var existsFarmacia = db.FARMACIA.FirstOrDefault(x => x.ID_FARMACIA == model.ID_FARMACIA);
if (existsAdmin == null && existsFarmacia != null)
{
ADMINISTRADOR_FARMACIA ad = new ADMINISTRADOR_FARMACIA();
ad.CODIGO_ADMINISTRADOR = model.CODIGO_ADMINISTRADOR;
ad.ID_FARMACIA = model.ID_FARMACIA;
ad.NOMBRES = model.NOMBRES;
ad.APELLIDOS = model.APELLIDOS;
ad.USUARIO = model.USUARIO;
ad.PASSWORD = model.PASSWORD;
ad.DUI = model.DUI;
ad.NIT = model.NIT;
ad.TELEFONO = model.TELEFONO;
ad.DIRECCION = model.DIRECCION;
db.ADMINISTRADOR_FARMACIA.Add(ad);
db.SaveChanges();
return(RedirectToAction("Master", "AdminEmp"));
}
else
{
ViewBag.error = "El usuario ya existe o el id farmacia no existe";
}
}
}
else
{
ViewBag.error = "Las contraseñas no coinciden";
}
return(View());
}
public async Task <IActionResult> RegisterAdmin(RegisterAdminModel model)
{
if (!await _roleManager.RoleExistsAsync(model.Role))
{
await _roleManager.CreateAsync(new IdentityRole(model.Role));
}
var userToCreate = new IdentityUser
{
Email = model.Email,
UserName = model.Username
};
//Create Admin
var result = await _userManager.CreateAsync(userToCreate, model.Password);
if (result.Succeeded)
{
var userInDb = await _userManager.FindByNameAsync(userToCreate.UserName);
//Add Role To Admin
await _userManager.AddToRoleAsync(userInDb, model.Role);
//Add Claim to Admin
var claim = new Claim("JobTitle", model.JobTitle);
await _userManager.AddClaimAsync(userInDb, claim);
return(Ok(result.Succeeded));
}
return(BadRequest(result.Errors));
}
public ActionResult RegisterAdmin(RegisterAdminModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
WebSecurity.CreateUserAndAccount(model.UserName, model.Password);
//WebSecurity.Login(model.UserName, model.Password);
var roles = (SimpleRoleProvider)Roles.Provider;
if (!roles.RoleExists("admin"))
{
roles.CreateRole("admin");
}
if (!roles.RoleExists("student"))
{
roles.CreateRole("student");
}
roles.AddUsersToRoles(new string[] { model.UserName }, new string[] { "admin" });
return(RedirectToAction("RegisterAdmin", "Account"));
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
