public ActionResult Register(UserFormModel form)
{
if (ModelState.IsValid)
{
var command = Mapper.Map <UserFormModel, UserRegisterCommand>(form);
command.Activated = true;
command.RoleId = (Int32)UserRoles.User;
IEnumerable <ValidationResult> errors = commandBus.Validate(command);
ModelState.AddModelErrors(errors);
if (ModelState.IsValid)
{
var result = commandBus.Submit(command);
if (result.Success)
{
User user = userRepository.Get(u => u.Email == form.Email);
formAuthentication.SetAuthCookie(this.HttpContext,
UserAuthenticationTicketBuilder.CreateAuthenticationTicket(
user));
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "An unknown error occurred.");
}
}
// If we got this far, something failed, redisplay form
return(View(form));
}
// If we got this far, something failed
return(Json(new { errors = GetErrorsFromModelState() }));
}
public ActionResult Create(UserFormModel model)
{
var user = UserService.UserNew();
Csla.Data.DataMapper.Map(model, user, true);
user.SetPassword(model.Password);
try
{
user = UserService.UserSave(user);
if (user.IsValid)
{
return(new JsonResult {
Data = this.Url.Action("Edit", new { id = user.UserId, message = Resources.SaveSuccessfulMessage })
});
}
}
catch (Exception ex)
{
this.ModelState.AddModelError("", ex.Message);
}
this.Map(user, model, false);
return(this.View(model));
}
public void User_Register_Redirects_To_Home()
{
//Arrange
User user = new User()
{
Email = "*****@*****.**",
UserId = 1,
FirstName = "Shiju",
LastName = "Var",
DateCreated = DateTime.Now,
Password = "******",
RoleId = 2
};
commandBus.Setup(c => c.Submit(It.IsAny <UserRegisterCommand>())).Returns(new CommandResult(true));
userRepository.Setup(x => x.Get(It.IsAny <Expression <Func <User, bool> > >())).Returns(user);
Mapper.CreateMap <UserFormModel, UserRegisterCommand>();
UserFormModel userForm = new UserFormModel
{
Email = "*****@*****.**",
FirstName = "Shiju",
LastName = "Var",
Password = "******",
ConfirmPassword = "******"
};
AccountController controller = new AccountController(commandBus.Object, userRepository.Object, formsAuthentication.Object);
// Act
var result = controller.Register(userForm) as RedirectToRouteResult;
// Assert
Assert.AreEqual("Home", result.RouteValues["controller"]);
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public async Task<IActionResult> Update(long id, [FromBody]UserFormModel model)
{
if (!await Users.CheckIfExists(id)) return NotFound();
var newPassword = !string.IsNullOrEmpty(model.Password) ? model.Password : null;
await Users.Update(id, Mapper.Map<AddUserDTO>(model), newPassword);
return Ok();
}
public static int GetUserRole(this HtmlHelper html)
{
UserFormModel UFM = new UserFormModel();
int CurrentUserRole = UFM.UserRole;
return(CurrentUserRole);
}
public IActionResult Unban(UserFormModel model)
{
this.users.BannUser(model.UserId, null);
TempData[ApplicationConstants.TempDataSuccessMessageKey] =
$"You Unbanned {model.UserName}!";
return(RedirectToAction("Active"));
}
public UserControllerTest()
{
_tester = new ControllerTester <UserController>();
UserFormModel = new UserFormModel
{
FirstName = "First Name",
LastName = "Last Name"
};
}
public IActionResult MakeAdmin(UserFormModel model)
{
this.users.MakeAdmin(model.UserId);
TempData[ApplicationConstants.TempDataSuccessMessageKey] =
$"You made {model.UserName} an Admin!";
return(RedirectToAction("Active"));
}
public async Task <IActionResult> CreateUser(UserFormModel form)
{
if (_userManager.Validate(form.User.Email, form.User.UserName, form.Password, form.ConfirmPassword))
{
var supervisorId = _userManager.SupervisorId;
await _userService.RegisterUserWithPermission(form.User, form.Password, form.Roles, form.UserClaims, supervisorId);
}
return(RedirectToAction("Index"));
}
//----------------
private Users RegisterForm(UserFormModel user)
{
return(new Users()
{
firstname = user.firstname?.Trim(),
email = user.email.ToLower().Trim(),
lastname = user.lastname?.Trim(),
avatar = user.avatar?.Trim(),
alias_name = user.alias_name?.Trim()
});
}
public IActionResult Index(UserFormModel model)
{
if (!ModelState.IsValid)
{
// OnActionExecutedでModelStateをTempDataに保存する
return(RedirectToAction());
}
// 仮
return(Content("保存しました！"));
}
public virtual void UpdateUser(User user, UserFormModel model, bool updateRole)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
if (updateRole)
{
user.Role = model.Role;
}
DbContext.SaveChanges();
}
public int InsertUserForm(UserFormModel model)
{
try
{
Mapper.CreateMap <UserFormModel, UserFormTran>();
UserFormTran objUser = Mapper.Map <UserFormTran>(model);
Dbcontext.UserFormTrans.Add(objUser);
return(Dbcontext.SaveChanges());
}
catch (Exception ex)
{
throw ex;
}
}
public void PutUserTest400()
{
var userFormModel = new UserFormModel
{
FirstName = "First Name",
LastName = "Last Name",
Role = "InvalidRole"
};
_tester.TestController()
.Calling(c => c.Put(_tester.Admin.UId, userFormModel))
.ShouldReturn()
.BadRequest()
.WithStatusCode(400);
}
public string GetUser(string userid)
{
List <UserFormModel> users = new List <UserFormModel>();
UserFormModel user = _userservices.GetUserForm(userid);
string sdata = "er|NO DATOS ENCONTRADOS|Usuarios Mgr";
if (!string.IsNullOrWhiteSpace(user.Id))
{
users.Add(user);
sdata = Objeto.SerializarLista(users, '|', '~', false);
}
return(sdata);
}
public async Task <UserInfoModel> Register(UserFormModel iuser)
{
if (!_appSettings.AllowRegister)
{
throw new MethodAccessException("System not available");
}
var user = await _repo.CreateAsync(RegisterForm(iuser), iuser.password.Trim());
if (user == null)
{
return(null);
}
_user = user.Adapt <UserInfoModel>();
return(_user);
}
public ActionResult Create()
{
var model = new UserFormModel();
try
{
var user = UserService.UserNew();
this.Map(user, model, true);
}
catch (Exception ex)
{
this.ModelState.AddModelError(string.Empty, ex.Message);
}
return(this.View(model));
}
public async Task <IActionResult> SignIn(UserFormModel model)
{
ShopUser user = null;
if (model.UserName.IsEmail())
{
user = await userManager.FindByEmailAsync(model.UserName);
}
else
{
user = await userManager.FindByNameAsync(model.UserName);
}
if (user == null)
{
ModelState.AddModelError("UserName", "İstifadəçi adı və ya şifrə səhvdir");
}
if (user != null && !user.EmailConfirmed)
{
ModelState.AddModelError("UserName", "Email hesabınızı təsdiq edin");
}
if (ModelState.IsValid)
{
var result = await signInManager.PasswordSignInAsync(user, model.Password, true, true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home", routeValues: new
{
area = "Admin"
}));
}
else
{
ModelState.AddModelError("UserName", "İstifadəçi adı və ya şifrə səhvdir");
}
}
return(View(model));
}
public async Task <IActionResult> SignIn(UserFormModel model)
{
ResumeUser user = null;
if (model.UserName.IsEmail())
{
user = await userManager.FindByEmailAsync(model.UserName);
}
else
{
user = await userManager.FindByNameAsync(model.UserName);
}
if (user == null)
{
ModelState.AddModelError("UserName", "Istifadeci adi ve ya sifre sehdir");
}
if (user != null && !user.EmailConfirmed)
{
ModelState.AddModelError("UserName", "Email Hesabinizi tesdiq edin");
}
if (ModelState.IsValid)
{
var result = await signInManager.PasswordSignInAsync(user, model.Password, true, true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home", routeValues: new
{
area = ""
}));
}
else
{
ModelState.AddModelError("UserName", "Istifadeci adi ve ya sifre sehdir");
}
}
return(View(model));
}
public ActionResult AdminUsers()
{
UserFormModel model = new UserFormModel();
model.Rows = db.Users.Select(x => new UserRowData()
{
Email = x.Email,
Name = x.Name,
City = db.City.FirstOrDefault(c => c.CCode == x.CCode).Name,
Code = x.UCode,
Contacts = x.Contacts,
Phones = x.Phone,
Banned = x.Banned == 1 ? "banned" : "",
BannedMessage = x.Banned == 1 ? "Разбанить" : "Забанить"
}).ToList();
return(View(model));
}
public async Task <ActionResult> Register(UserFormModel model)
{
if (ModelState.IsValid)
{
var command = new UserRegisterCommand
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password,
Activated = true,
RoleId = (Int32)UserRoles.User
};
IEnumerable <ValidationResult> errors = commandBus.Validate(command);
ModelState.AddModelErrors(errors);
if (ModelState.IsValid)
{
var result = commandBus.Submit(command);
if (result.Success)
{
var user = this.userRepository.Get(x => x.Email.ToUpper() == command.Email.ToUpper() && Md5Encrypt.Md5EncryptPassword(command.Password) == x.PasswordHash);
FNHMVCUser appUser = new FNHMVCUser()
{
Id = user.UserId,
RoleName = Enum.GetName(typeof(UserRoles), user.RoleId),
UserName = user.DisplayName
};
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = true
}, await appUser.GenerateUserIdentityAsync(userManager));
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "An unknown error occurred.");
}
}
return(View(model));
}
return(View(model));
}
public IActionResult Edit(string id, UserFormModel userModel)
{
var allowedToEdit = id == this.userManager.GetUserId(User);
if (!allowedToEdit)
{
//userModel.IsCurrentlyLogged = false;
return(Unauthorized());
}
this.users.Edit(
id,
userModel.Email,
userModel.NewPassword,
userModel.Phonenumber);
return(RedirectToAction(nameof(Details)));
}
public virtual bool UpdateUser(int userId, UserFormModel model)
{
var user = GetUserById(userId);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
if (model is AdminUserFormModel)
{
user.Role = ((AdminUserFormModel)model).Role;
}
DbContext.SaveChanges();
return(true);
}
return(false);
}
public ActionResult Edit(int id, string message)
{
var model = new UserFormModel();
try
{
var user = UserService.UserFetch(id);
model.Message = message;
this.Map(user, model, true);
}
catch (Exception ex)
{
this.ModelState.AddModelError(string.Empty, ex.Message);
}
return(this.View(model));
}
public IActionResult Edit(string username, UserFormModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var user = this.userManager.FindByNameAsync(username);
var userExists = this.users.Exists(user.Result.Id);
if (!userExists)
{
return(this.NotFound());
}
this.users.Edit(model.Username, model.Name, model.Location, model.Birthdate, model.Gender, model.Image);
return(RedirectToAction("All"));
}
//[EFMVCAuthorize(Roles.Admin)]
public ActionResult JsonRegister(UserFormModel form)
{
if (ModelState.IsValid)
{
var command = new UserRegisterCommand
{
FirstName = form.FirstName,
LastName = form.LastName,
Email = form.Email,
Password = form.Password,
Activated = true,
RoleId = (Int32)form.Role
//RoleId = (Int32)UserRoles.User
};
IEnumerable <ValidationResult> errors = commandBus.Validate(command);
ModelState.AddModelErrors(errors);
if (ModelState.IsValid)
{
var result = commandBus.Submit(command);
if (result.Success)
{
User user = userRepository.Get(u => u.Email == form.Email);
formAuthentication.SetAuthCookie(this.HttpContext,
UserAuthenticationTicketBuilder.CreateAuthenticationTicket(
user));
return(Json(new { success = true }));
}
else
{
ModelState.AddModelError("", "An unknown error occurred.");
}
}
// If we got this far, something failed
return(Json(new { errors = GetErrorsFromModelState() }));
}
// If we got this far, something failed
return(Json(new { errors = GetErrorsFromModelState() }));
}
public ActionResult Edit(int id, UserFormModel model)
{
var user = UserService.UserFetch(id);
Csla.Data.DataMapper.Map(model, user, true);
if (!string.IsNullOrEmpty(model.Password))
{
user.SetPassword(model.Password);
}
user = UserService.UserSave(user);
if (user.IsValid)
{
model.Message = Resources.SaveSuccessfulMessage;
}
this.Map(user, model, true);
return(this.View(model));
}
private IActionResult PutUser([FromRoute] int id, [FromBody] UserFormModel model)
{
if (ModelState.IsValid)
{
if (model is AdminUserFormModel && !Role.IsRoleValid(((AdminUserFormModel)model).Role))
{
ModelState.AddModelError("Role", "Invalid Role");
}
else
{
if (!_userManager.UpdateUser(id, model))
{
return(NotFound());
}
Logger.LogInformation(5, "User with ID: " + id + " updated.");
return(Ok());
}
}
return(BadRequest(ModelState));
}
public ActionResult EditUser(UserFormModel model)
{
if (model != null)
{
if (ModelState.IsValid)
{
User user = new User();
user.Id = model.Id;
user.UserEmail = model.Email;
if (model.Birthdate > DateTime.Today)
{
ModelState.AddModelError("Birthdate", "Дата рождения не может быть в будущем");
return(View(model));
}
user.UserBirthdate = model.Birthdate;
user.RoleId = model.RoleId;
if (model.Password != null)
{
user.UserPassword = HashManager.HashData(model.Password);
}
if (model.Id > 0)
{
this.accountService.UpdateUser(user);
}
else
{
this.accountService.AddUser(user);
}
return(RedirectToAction("AdminPanelUser"));
}
return(View(model));
}
return(View());
}
public UserFormModel Map(User user, UserFormModel model, bool ignoreBrokenRules)
{
Csla.Data.DataMapper.Map(user, model, true);
model.Tab = "User";
model.Roles = DataHelper.GetRoleList();
model.IsNew = user.IsNew;
model.IsValid = user.IsValid;
if (!user.IsNew)
{
model.NoteListModel =
new NoteListModel
{
Source = user,
Notes = NoteService.NoteFetchInfoList(user).AsQueryable()
};
}
if (!ignoreBrokenRules)
{
foreach (var brokenRule in user.BrokenRulesCollection)
{
this.ModelState.AddModelError(string.Empty, brokenRule.Description);
}
}
if (!ignoreBrokenRules &&
!string.IsNullOrWhiteSpace(model.Password) &&
(model.Password != model.PasswordConfirmation))
{
this.ModelState.AddModelError("Password", "Passwords must match.");
this.ModelState.AddModelError("PasswordConfirmation", "Passwords must match.");
this.ModelState.AddModelError(string.Empty, "Passwords must match.");
}
return(model);
}
