public async Task <IActionResult> Create(UserCreateVM vm)
{
if (ModelState.IsValid)
{
IdentityUser user = new IdentityUser {
UserName = vm.Username, Email = vm.Email
};
IdentityResult result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
_logger.LogInformation($"Created new account for {user.UserName} with id {user.Id}");
// check if role string is valid
bool isValidRole = SecurityConstants.GetRoles().Contains(vm.UserRole);
if (isValidRole)
{
await _userManager.AddToRoleAsync(user, vm.UserRole);
_logger.LogInformation($"{vm.UserRole} role assigned to new user {user.UserName} with id {user.Id}");
}
return(RedirectToAction(nameof(Index)).WithSuccess($"Created new user {user.UserName} {(isValidRole ? $"with role {vm.UserRole}" : "")}"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
ViewData["UserRole"] = new SelectList(SecurityConstants.GetRoles());
return(View(vm));
}
public ActionResult Create(UserCreateVM model)
{
ViewBag.Breadcrumb = new Breadcrumb("user", "create", null);
try
{
if (ModelState.IsValid)
{
var user = userDm.Save(model);
if (user == null)
{
ModelState.AddModelError("", "Ошибка при сохранении");
return(View());
}
else
{
return(RedirectToAction("Index"));
}
}
else
{
return(View());
}
}
catch (Exception ex)
{
ModelState.AddModelError("", $"{ex.Message}");
return(View());
}
}
public ActionResult Registration(UserCreateVM model)
{
if (ModelState.IsValid)
{
}
return(View());
}
public async Task <IActionResult> Login(UserCreateVM user)
{
var response = await _signInManager.PasswordSignInAsync(user.UserName, user.Password, false, false);
if (!response.Succeeded)
{
return(BadRequest("invalid login"));
}
return(Ok(_service.BuildToken(user.UserName)));
}
public async Task <IActionResult> Create(UserCreateVM vm)
{
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser {
UserName = vm.Username, Email = vm.Email, TwoFactorEnabled = vm.IsTwoFactorEnabled
};
IdentityResult result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
_logger.LogInformation($"Created new account for {user.UserName} with id {user.Id}");
// check if role string is valid
bool isValidRole = SecurityConstants.GetRoles().Contains(vm.UserRole);
if (isValidRole)
{
await _userManager.AddToRoleAsync(user, vm.UserRole);
_logger.LogInformation($"{vm.UserRole} role assigned to new user {user.UserName} with id {user.Id}");
}
// verify user email
string emailToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
IdentityResult emaiVerifiedResult = await _userManager.ConfirmEmailAsync(user, emailToken);
if (emaiVerifiedResult.Succeeded)
{
_logger.LogInformation($"Email verified for new user {user.UserName} with id {user.Id} and email {vm.Email}");
}
else
{
_logger.LogInformation($"Email verify failed for {user.UserName} with id {user.Id} and email {vm.Email} due to errors {emaiVerifiedResult.Errors}");
}
if (!string.IsNullOrWhiteSpace(vm.PhoneNumber))
{
// verify phone number
string phoneVerifyToken = await _userManager.GenerateChangePhoneNumberTokenAsync(user, vm.PhoneNumber);
IdentityResult phoneVeifyResult = await _userManager.ChangePhoneNumberAsync(user, vm.PhoneNumber, phoneVerifyToken);
_logger.LogInformation($"Phone verified new user {user.UserName} with id {user.Id} and phone {vm.PhoneNumber} = {phoneVeifyResult.Succeeded}");
}
return(RedirectToAction(nameof(Index)).WithSuccess($"Created new user {user.UserName} {(isValidRole ? $"with role {vm.UserRole}" : "")}"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
ViewData["UserRole"] = new SelectList(SecurityConstants.GetRoles());
return(View(vm));
}
public IActionResult CreateUser(UserCreateVM VM)
{
if (!User.Identity.IsAuthenticated)// если неавторизован то редирект на авторизацию
{
Uri location = new Uri($"{Request.Scheme}://{Request.Host}/Account/Login");
return(Redirect(location.AbsoluteUri));
}
VM.user.Save();
Uri locat = new Uri($"{Request.Scheme}://{Request.Host}/Home/Users");
return(Redirect(locat.AbsoluteUri));
}
public async Task <IActionResult> Register(UserCreateVM user)
{
var model = new ApplicationUser {
Email = user.UserName, UserName = user.UserName
};
var response = await _userManager.CreateAsync(model, user.Password);
if (!response.Succeeded)
{
return(BadRequest("invalid register. Retry"));
}
return(Ok(_service.BuildToken(user.UserName)));
}
public JsonResult CreateUser(UserCreateVM A)
{
bool status = false;
string mes = "";
int v = A.UserID;
if (ModelState.IsValid)
{
try
{
using (PEPSIEntities dc = new PEPSIEntities())
{
UserLogin ulog = new UserLogin();
{
ulog.UserID = A.UserID;
ulog.UserName = A.UserName;
ulog.Password = A.Password;
ulog.MobileNo = A.MobileNo;
ulog.WorkStationID = A.WorkStationID;
ulog.RoleId = A.RoleId;
ulog.MachineIP = A.MachineIP;
ulog.Email = A.Email;
ulog.Status = "A";
ulog.CreateBy = User.Identity.Name;
ulog.CreateDate = System.DateTime.Now;
}
dc.UserLogins.Add(ulog);
dc.SaveChanges();
status = true;
dc.Dispose();
}
}
catch (Exception ex)
{
return(new JsonResult {
Data = new { status = false, mes = mes, v = v }
});
//throw ex;
}
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status, mes = mes, v = v }
});
}
internal User Save(UserCreateVM model)
{
var user = Mapper.Map <User>(model);
if (model.Photo != null)
{
//TODO: webimage
WebImage img = new WebImage(model.Photo.InputStream);
img.Resize(imageWidth, imageHeight);
user.Photo = new PictureData();
user.Photo.Data = img.GetBytes();
user.Photo.ContentType = "image/" + img.ImageFormat;
}
return(userLogic.Save(user));
}
public ActionResult Edit(UserCreateVM student)
{
try
{
if (ModelState.IsValid)
{
this._userLogic.Update(Mapper.Map <User>(student));
}
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, ex);
}
return(View(student));
}
public ActionResult Create(UserCreateVM user)
{
try
{
if (ModelState.IsValid)
{
_userLogic.AddUser(Mapper.Map <UserCreateVM, User>(user));
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, ex);
}
return(View(user));
}
public async Task <bool> Create(UserCreateVM viewModel)
{
//if (!ModelState.IsValid)
// return false;
await _identityContext.Database.EnsureCreatedAsync();
var user = new IdentityUser()
{
UserName = viewModel.Username,
Email = viewModel.Email
};
var result = await _userManager.CreateAsync(user, viewModel.Password);
await _signinManager.PasswordSignInAsync(viewModel.Username, viewModel.Password, false, false);
return(result.Succeeded);
}
public RedirectToRouteResult Edit(UserCreateVM user)
{
try
{
var userCurrent = _userLogic.GetUserByEMail(System.Web.HttpContext.Current.User.Identity.Name.ToString()) ?? new Common.User();
if (ModelState.IsValid)
{
var userUp = Mapper.Map <User>(user);
userUp.IDUser = userCurrent.IDUser;
this._userLogic.Update(userUp);
}
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, ex);
}
return(RedirectToAction("Details"));
}
public async Task <IActionResult> Register(UserCreateVM user)
{
var userToCreate = mapper.Map <User>(user);
var userForRepo = await manager.CreateAsync(userToCreate, user.Password);
if (!userForRepo.Succeeded)
{
return(StatusCode(500));
}
var userFromRepo = await manager.FindByNameAsync(userToCreate.UserName);
var addRole = await manager.AddToRoleAsync(userFromRepo, user.Role);
if (!addRole.Succeeded)
{
return(StatusCode(500));
}
return(Ok("Created Successful"));
}
public async Task <IActionResult> Create(UserCreateVM vm)
{
if (ModelState.IsValid)
{
Utility user = new Utility {
UserName = vm.Username, Email = vm.Email
};
IdentityResult result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
return(RedirectToAction(nameof(Index)));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(vm));
}
public ActionResult Register(UserCreateVM model)
{
if (model == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
try
{
if (this.logic.Add(model.Login, role: "User", password: model.Password))
{
logger.Info("New user was created", "Presentation layer, class UserController, method ActionResult Register(UserCreateVM)");
return(RedirectToAction("Index", "Common"));
}
else
{
return(View("Register", model));
}
}
catch (System.Exception e)
{
if (e is DalException)
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
else
{
logger.Warning("BL", e);
return(RedirectToAction("Index", "Common"));
}
}
}
else
{
return(View("Register", model));
}
}
public async Task <IActionResult> Create(UserCreateVM model)
{
if (!ModelState.IsValid)
{
ViewData["Roles"] = CreateRolesDropDownList();
ViewData["Employees"] = CreateEmployeesWithoutAccountDropDownList();
return(View(model));
}
User user = new User
{
Login = model.Login,
Password = model.Password,
RoleId = model.Role,
EmployeeId = model.Employee
};
context.Add(user);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public IHttpActionResult Post([FromBody] UserCreateVM user)
{
if (user == null)
{
return(BadRequest("User should be defined in request body"));
}
if (!ModelState.IsValid)
{
return(BadRequest("User not valid"));
}
else
{
var userWithID = userDm.Save(user);
if (userWithID != null)
{
return(Created($"api/user/{userWithID.ID}", userWithID));
}
else
{
return(BadRequest());
}
}
}
public async Task <ActionResult> UserCreate(UserCreateVM model)
{
ndb = new NanjilContext();
db = new ApplicationDbContext();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, EmployeeId = model.EmployeeId
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
await this.UserManager.AddToRoleAsync(user.Id, model.RoleId);
// 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>");
return(Json(new { success = true }));
}
AddErrors(result);
}
var emp = ndb.employees
.Where(x => x.IsActive == true)
.ToList()
.Select(x => new { EmployeeId = x.EmployeeId, EmployeeName = string.Format("{0} {1}", x.EmployeeCode, x.EmployeeName) });
ViewBag.Employees = new SelectList(emp, "EmployeeId", "EmployeeName");
ViewBag.Roles = new SelectList(db.Roles.ToList(), "Name", "Name");
return(PartialView("_UserCreate", model));
}
public ActionResult AddUser([FromBody] UserCreateVM model)
{
_logger.LogInformation("AddUser");
return(Ok($"User was added!"));
}
public User(UserCreateVM src) : base()
{
Email = src.Email;
UserName = src.Email; //idserver needs username filled
}
