// POST api/users
public IHttpActionResult Post([FromBody] UserAddViewModel viewModel)
{
try
{
if (viewModel == null)
{
return(BadRequest(ModelState));
}
ValidateViewModel(viewModel, _repository, null);
if (ModelState.IsValid)
{
var user = viewModel.GetModel(null);
_repository.SaveUser(user);
var uriString = Url.Link("DefaultApi", new { controller = "Users", id = user.UserId });
return(Created(uriString, new UserMessage()
{
UserId = user.UserId, UserName = user.UserName
}));
}
else
{
return(Error(ModelState));
}
}
catch (Exception exc)
{
return(InternalServerError(exc));
}
}
public async Task <IActionResult> AddUser(UserAddViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = new ApplicationUser
{
UserName = model.UserName.Trim(),
Email = model.Email.Trim(),
IdCardNo = model.IdCardNo.Trim(),
BirthDate = model.BirthDate
};
var result = await _userManager.CreateAsync(user, model.Password.Trim());
if (result.Succeeded)
{
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
public void UsersController_Post_ValidModelStateSavesUser()
{
// Arrange
var repository = Substitute.For <IRepository>();
var usersController = new UsersController(repository);
usersController.Request = new HttpRequestMessage();
usersController.Configuration = new HttpConfiguration();
// Mock the UrlHelper in order for the controller
// to be able to successfully call the Url.Link() method.
var urlHelper = Substitute.For <UrlHelper>();
urlHelper.Link(Arg.Any <string>(), Arg.Any <object>()).Returns("http://localhost/api/users/0");
usersController.Url = urlHelper;
var viewModel = new UserAddViewModel()
{
UserName = "******",
Password = "******"
};
// Act
var actionResult = usersController.Post(viewModel) as CreatedNegotiatedContentResult <UserMessage>;
// Assert
Assert.IsNotNull(actionResult);
Assert.AreEqual(0, actionResult.Content.UserId);
Assert.AreEqual("johns", actionResult.Content.UserName);
repository.ReceivedWithAnyArgs().SaveUser(null);
}
public ActionResult AddUser(UserAddViewModel model)
{
if (ModelState.IsValid)
{
try
{
if (model.User.UserId != 0)
{
var user = new UserManager().Get(u => u.UserId == model.User.UserId);
user.Name = model.User.Name;
user.Lastname = model.User.Lastname;
user.Username = model.User.Username;
user.Email = model.User.Email;
user.Password = model.User.Password;
new UserManager().Update(user);
}
else
{
new UserManager().Add(model.User);
}
return(RedirectToAction("ListUser", "User"));
}
catch (Exception exception)
{
ViewBag.Message = exception.Message;
return(View());
}
}
else
{
return(RedirectToAction("Index", "Error", new { errorHeader = "İşlem yapılırken hata oluştu", errorMessage = "Kullanıcı kaydetme işlemi yapılırken hata oluştu lütfen sistem yöneticinize başvurun" }));
}
}
public ActionResult <UserAddResModel> Manage_User_add(UserAddViewModel userAddViewModel)
{
int User_Add_Count;
UserAddResModel userAddResModel = new UserAddResModel();
User_Add_Count = _userService.User_Add(userAddViewModel);
if (User_Add_Count > 0)
{
userAddResModel.IsSuccess = true;
userAddResModel.AddCount = User_Add_Count;
userAddResModel.baseViewModel.Message = "添加成功";
userAddResModel.baseViewModel.ResponseCode = 200;
_ILogger.Information("增添用户信息成功");
return(Ok(userAddResModel));
}
else
{
userAddResModel.IsSuccess = false;
userAddResModel.AddCount = 0;
userAddResModel.baseViewModel.Message = "添加失败";
userAddResModel.baseViewModel.ResponseCode = 200;
_ILogger.Information("增添用户信息失败");
return(Ok(userAddResModel));
}
}
public IActionResult Add(UserAddViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = viewModel.ApplicationUser.FirstName,
LastName = viewModel.ApplicationUser.LastName,
Email = viewModel.ApplicationUser.Email,
Role = viewModel.ApplicationUser.Role
};
var result = userRepository.AddUser(user);
if (result == true)
{
viewModel.StatusMessage = "New user added successfully!";
}
else
{
viewModel.StatusMessage = "This email has already been used!";
}
return(View(viewModel));
}
return(View(viewModel));
}
public ActionResult AddUser(UserAddViewModel userAdd)
{
try
{
if (ModelState.IsValid)
{
_userProvider.AddUserWithLoginAndPhone(userAdd.FirstName, userAdd.MiddleName, userAdd.LastName, userAdd.UserPostId, userAdd.BirthDate, userAdd.Workplace, userAdd.Email, userAdd.Phone, userAdd.Login, userAdd.Password, userAdd.UserRoleId);
return(Redirect("~/User/GetAllUsers"));
}
else
{
ViewBag.Roles = ListForRoles();
ViewBag.Posts = ListForPosts();
return(View(userAdd));
}
}
catch (SqlException ex)
{
_logger.LogError(ex.Message);
ViewBag.Message = ex.Message;
return(View("SqlError"));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(Redirect("/Error/ServerError"));
}
}
public async Task <IActionResult> AddUser(UserAddViewModel userAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(userAddViewModel));
}
var user = new ApplicationUser
{
UserName = userAddViewModel.UserName,
Email = userAddViewModel.Email,
IdCardNo = userAddViewModel.IdCardNo,
BirthDate = userAddViewModel.BirthDate
};
var result = await _userManager.CreateAsync(user, userAddViewModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(userAddViewModel));
}
public UserAddView(UserAddViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
viewModel.CloseAction = new Action(this.Close);
}
public async Task <IActionResult> Post([FromBody] UserAddViewModel model)
{
string id = null;
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var user = new DbUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"",
"resetpassword",
//pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Reset Password",
$"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
return(Ok(new { answer = "Check your email" }));
//return Ok("S***N");
}
//添加用户
public int User_Add(UserAddViewModel userAddViewModel)
{
var user_Info = _IMapper.Map <UserAddViewModel, User_Info>(userAddViewModel);
_IUserInfoRepository.Add(user_Info);
return(_IUserInfoRepository.SaveChanges());
}
public async Task <IActionResult> AddUser(UserAddViewModel userAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(userAddViewModel));
}
var user = new ApplicationUser
{
UserName = userAddViewModel.UserName,
Email = userAddViewModel.Email
};
var result = await _userManager.CreateAsync(user, userAddViewModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError(string.Empty, item.Description);
}
return(View(userAddViewModel));
}
}
public ActionResult Create(UserAddViewModel model)
{
try
{
AddUserDto dto = new AddUserDto();
dto.UserName = model.UserName;
dto.UserPassword = CommonTools.ToMd5(model.UserPassword);
dto.UserRoles = "45";
dto.UserStatus = true;
string userJsonString = JsonHelper.JsonSerializerBySingleData(dto);
Message msg = CMSService.Insert("User", userJsonString);
return(RedirectTo("/User/Index", msg.MessageInfo));
}
catch
{
Message msg = new Message();
msg.MessageStatus = "Error";
msg.MessageInfo = "操作出错了";
ViewBag.Status = msg.MessageStatus;
ViewBag.msg = msg.MessageInfo;
return(View());
}
}
public async Task <IActionResult> Add(UserAddViewModel model)
{
if (ModelState.IsValid)
{
//Set Properties for User Entity
User user = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
PositionTitle = model.PositionTitle,
PhoneNumber = model.Phone,
CampusId = model.CampusId,
Email = model.Email,
UserName = model.Username
};
//Create the User with the password.
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//Check to see if a Role was selected
if (model.RoleId != null)
{
//If a role was selected, find the selected role in the database.
IdentityRole role = await roleManager.FindByIdAsync(model.RoleId);
if (role != null)
{
//If the role was found, add the user to the role selected.
await userManager.AddToRoleAsync(user, role.Name);
//User and role where added, so redirect to User List page.
TempData["SucessMessage"] = "User with name " + user.FullName + ", was created successfully.";
return(RedirectToAction("List"));
}
else
{
//If adding the user to the role selected failed add model errors to display on page.
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
else
{
//User was added, so redirect to User List page.
TempData["SucessMessage"] = "User with name " + user.FullName + ", was created successfully.";
return(RedirectToAction("List"));
}
}
}
model.Campuses = data.Campuses.List();
model.Roles = roleManager.Roles;
return(View(model));
}
public async Task <IActionResult> Add(UserAddViewModel model)
{
var roleManager = serviceProvider.GetRequiredService <RoleManager <Role> >();
var userManager = serviceProvider.GetRequiredService <UserManager <User> >();
var roles = roleManager.Roles.Select(x => new SelectListItem {
Text = x.Name, Value = x.NormalizedName
}).ToList();
roles.Insert(0, new SelectListItem {
Text = "Select Role", Value = ""
});
model.Role = roles;
if (model.Email != null)
{
var userCheckWithEmail = await userManager.FindByEmailAsync(model.Email);
if (userCheckWithEmail != null && !userCheckWithEmail.DeletedDate.HasValue)
{
ModelState.AddModelError("Email", "Email already used please use different.");
}
}
var userCheckWithUsername = await userManager.FindByNameAsync(model.UserName);
if (userCheckWithUsername != null)
{
ModelState.AddModelError("Username", "Username already Used please use different.");
}
if (!ModelState.IsValid)
{
return(View(model));
}
var userEntity = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
PhoneNumber = model.Phone,
TwoFactorEnabled = model.TwoFactorAuthentication,
EmailConfirmed = true,
CreatedDate = DateTime.Now,
UserName = model.UserName
};
var result = await userManager.CreateAsync(userEntity, model.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(userEntity, model.RoleName);
}
return(Redirect("Index"));
}
public IActionResult Create()
{
var model = new UserAddViewModel
{
Roles = _roleManager.Roles.ToList()
};
return(View(model));
}
public IActionResult Create(string returnUrl)
{
UserAddViewModel vm = new UserAddViewModel(_userService.Ranks.GetRankSelectList());
ViewData["ActiveMenu"] = "Admin";
ViewData["ActiveLink"] = "UserCreate";
ViewData["Title"] = "Create User";
ViewBag.ReturnUrl = returnUrl;
return(View(vm));
}
public ActionResult Register()
{
var model = new UserAddViewModel
{
User = new User(),
City = _cityService.GetAll()
};
return(View(model));
}
public IActionResult Add()
{
UserAddViewModel model = new UserAddViewModel
{
//DropDowns
Campuses = data.Campuses.List(),
Roles = roleManager.Roles
};
return(View(model));
}
public ActionResult AddUser(int id=0)
{
UserAddViewModel model = new UserAddViewModel();
if (id!=0)
{
//update yapılmak istenyor id 0 değil
//UserManager userManager = new UserManager();
//var user= userManager.Get(um => um.UserId == id);
var user= new UserManager().Get(x => x.UserId == id);
model.User = user;
}
return View(model);
}
public ActionResult AddUser(UserAddViewModel vm)
{
if (ModelState.IsValid)
{
var context = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
vm.User = new ApplicationUser()
{
FirstName = vm.FirstName,
LastName = vm.LastName,
Email = vm.Email,
UserName = vm.FirstName + vm.LastName
};
userManager.PasswordValidator = new PasswordValidator()
{
RequiredLength = 5,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = true,
RequireNonLetterOrDigit = false
};
userManager.UserValidator = new UserValidator <ApplicationUser>(userManager)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true
};
var create = userManager.Create(vm.User, vm.Password);
if (!create.Succeeded)
{
ModelState.AddModelError("Email", "Email address is already in use.");
return(View(vm));
}
else
{
userManager.AddToRole(vm.User.Id, vm.Role);
return(RedirectToAction("Users"));
}
}
else
{
return(View(vm));
}
}
public void UsersController_Post_InvalidModelStateReturnsErrorRequest()
{
// Arrange
var usersController = new UsersController(null);
var viewModel = new UserAddViewModel();
// Add a model state error.
usersController.ModelState.AddModelError("UserName", "UserName is required.");
// Act
var actionResult = usersController.Post(viewModel);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(ErrorActionResult));
}
public ActionResult AddUser(int id = 0)
{
if (!IsLoggedOn())
{
return(RedirectToAction("Index", "Login"));
}
UserAddViewModel model = new UserAddViewModel();
if (id != 0)
{
var user = new UserManager().Get(x => x.UserId == id);
model.User = user;
}
return(View(model));
}
//[Authorize(Roles = "Admin")]
public ActionResult AddUser(UserAddViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = new ApplicationUser
{
Email = model.Email,
UserName = model.Email
};
string password = RandomPassword();
string regex = @"^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?!.*\s).{6,9}$";
var match = Regex.Match(password, regex, RegexOptions.IgnoreCase);
if (!match.Success)
{
//Console.WriteLine($"Поганий пароль - {str}");
}
var res = UserManager.CreateAsync(user, "Qwerty1-").Result;
if (res.Succeeded)
{
User newUser = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
DateBirth = Convert.ToDateTime(model.DateBirth),
DateAdd = DateTime.Now,
Email = model.Email,
Phone = model.Phone,
Status = 0,
};
_context.SiteUsers.Add(newUser);
_context.SaveChanges();
var client = new SmtpClient("smtp.gmail.com", 587)
{
Credentials = new NetworkCredential("*****@*****.**", "terranet"),
EnableSsl = true
};
client.Send("*****@*****.**", model.Email, "Новий пароль", $"Пароль: {password}");
}
return(RedirectToAction("users"));
}
public HttpResponseMessage AddUser([FromBody] UserAddViewModel model)
{
Usuario user = new Usuario();
var json = "";
try
{
user.id = Guid.NewGuid();
user.nombre = model.Name;
user.apellido1 = model.MidleName;
user.apellido2 = model.LastName;
user.telefono = model.Telefono;
user.email = model.Correo;
db.Usuario.Add(user);
db.SaveChanges();
json = Helper.toJson(true, "Usuario Agregado");
return(new HttpResponseMessage()
{
Content = new StringContent(json.ToString(), Encoding.UTF8, "application/json")
});
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
//Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",ve.PropertyName, ve.ErrorMessage);
EventLog eventLog = new EventLog("Application");
eventLog.Source = "BonaterraSite";
eventLog.WriteEntry("- Property: " + ve.PropertyName + ", Error: " + ve.ErrorMessage, EventLogEntryType.Information, 101, 1);
}
json = Helper.toJson(false, "No se pudo agregar usuario");
return(new HttpResponseMessage()
{
Content = new StringContent(json.ToString(), Encoding.UTF8, "application/json")
});
}
throw;
}
}
public ActionResult Add()
{
var cities = CityService.GetAll().ToList();
var citydto = new CityDTO()
{
Id = 0, Name = "总部"
};
cities.Insert(0, citydto);
var roles = RoleService.GetAll().ToList();
UserAddViewModel viewModel = new UserAddViewModel()
{
CityDTOs = cities, RoleDTOs = roles
};
return(View(viewModel));
}
public async Task <IActionResult> AddUser([FromBody] UserAddViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var currentUser = await _userManager.GetUserAsync(User);
var user = new User
{
UserName = model.Email, //
Email = model.Email, //
nombre_usu = model.nombre_usu, // Name
apellidos_usu = model.apellidos_usu, // Surname
tipo_usu = model.tipo_usu, // Role
pais_usu = model.pais_usu, // Country
activo_usu = 1, // Active
usuC_usu = currentUser.Id, // user who creates
usuM_usu = currentUser.Id, // user who modifes
fechaC_usu = datetime, // created datetime
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// Log
using (StreamWriter sw = System.IO.File.AppendText(Constants.Log.log_path))
{
sw.WriteLine("Datetime: " + datetime.ToString("dd/MM/yyyy HH:mm:ss") + " IP: " + ip + " Email: " + currentUser.Email + " Nombre: " + currentUser.nombre_usu + " Action: Usuario agregado.");
}
return(Json(new { success = true, message = "Usuario agregado con éxito." }));
}
else
{
return(Json(new { success = false, message = result.Errors }));
}
}
catch (Exception ex)
{
return(Json(new { success = false, message = ex.Message }));
}
}
// POST: api/Message
public IHttpActionResult Post(UserAddViewModel model)
{
MailMessage mail = new MailMessage("*****@*****.**", model.Email);
SmtpClient client = new SmtpClient();
client.Port = 587;
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
client.EnableSsl = true;
client.Credentials = new NetworkCredential("*****@*****.**", "?t1e2r3r4a5n6e7t?");
client.Host = "smtp.gmail.com";
mail.Subject = model.FirstName;// + " " + model.LastName;
mail.Body = "user added";
mail.IsBodyHtml = true;
client.Send(mail);
return(Ok());
}
public async Task <IActionResult> Post([FromBody] UserAddViewModel model)
{
string id = null;
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var userProfile = new UserProfile
{
FirstName = model.FirstName,
LastName = model.LastName,
Salary = model.Salary,
Age = model.Age
};
var user = new DbUser()
{
UserName = model.Email,
Email = model.Email,
UserProfile = userProfile
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var frontEndURL = _configuration.GetValue <string>("FrontEndURL");
var callbackUrl =
$"{frontEndURL}/confirmemail?userId={user.Id}&" +
$"code={WebUtility.UrlEncode(code)}";
await _emailSender.SendEmailAsync(model.Email, "Confirm Email",
$"Please confirm your email by clicking here: " +
$"<a href='{callbackUrl}'>link</a>");
return(Ok("S***N"));
}
public async Task <UserViewModel> CreateAsync(UserAddViewModel userVM)
{
User user = _mapper.Map <User>(userVM);
IdentityResult result = await _userManager.CreateAsync(user, userVM.Password);
if (result.Succeeded)
{
if (userVM.Roles.Count() > 0)
{
await _userManager.AddToRolesAsync(user, userVM.Roles.Select(x => x.Name));
}
UserViewModel data = _mapper.Map <UserViewModel>(user);
return(data);
}
return(null);
}
