public ActionResult Save(User user, HttpPostedFileBase ImageFile)
{
if (!ModelState.IsValid)
{
var viewModel = new NewUserViewModel
{
User = user
};
return(View("Index", viewModel));
}
if (user.Id == 0)
{
if (ImageFile != null)
{
string filename = Path.GetFileName(ImageFile.FileName);
user.ImagePath = "/Images/" + filename;
filename = Path.Combine(Server.MapPath("~/Images/"), filename);
ImageFile.SaveAs(filename);
}
else
{
user.ImagePath = "/Images/LOG-IN.png";
}
user.UserRank = "Customer";
user.Password = EncDecPassword.EncryptPassword(user.Password);
_context.Users.Add(user);
}
_context.SaveChanges();
return(RedirectToAction("Index", "Login"));
}
public ActionResult NewCoordinator()
{
var model = new NewUserViewModel();
model.Birthday = DateTime.Today;
return(View(model));
}
public ActionResult Register(NewUserViewModel viewModel)
{
// Log any logged-in user out
this.ClearSession();
if (!ModelState.IsValid)
{
return(View(viewModel));
}
// Create the new user profile
UserProfile profile = new UserProfile();
profile.Username = viewModel.Username;
profile.Salt = CryptHelper.CreateSalt(256);
profile.Password = CryptHelper.CreatePasswordHash(viewModel.Password, profile.Salt);
profile.RoleId = DomainHelper.GetIdByKeyValue(ref this._db, "PersonType", "Mentor");
profile.CanBeDeleted = true;
// Add the profile to the dataset
this._db.UserProfiles.Add(profile);
// Save the changes
this._db.SaveChanges();
// Let the user in
FormsAuthentication.SetAuthCookie(profile.Username, true);
// Send the user on to the registration page
return(RedirectToAction("Index", "Registration"));
}
public async Task <IActionResult> Register(NewUserViewModel model)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = model.Email,
Email = model.Email,
City = model.City,
Country = model.Country
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action("ConfirmEmail", "Account",
new { userId = user.Id, token }, Request.Scheme);
mailService.SendEmailCustom(confirmationLink, model.Email, "Email confirmation link");
return(View("RegistrationConfirmation"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public ActionResult NewUser(NewUserViewModel model)
{
if (IsAuthenticated)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
var currentUser = usersDAL.GetUser(model.Username);
if (currentUser != null)
{
ModelState.AddModelError("Username", "This username is unavailable.");
return(View("newUser", model));
}
var hashProvider = new HashProvider();
var hashedPassword = hashProvider.HashPassword(model.Password);
var salt = hashProvider.SaltValue;
var newUser = new UserModel
{
Username = model.Username,
Password = hashedPassword,
Salt = salt
};
usersDAL.RegisterNewUser(newUser);
LogUserIn(model.Username);
return(RedirectToAction("Index", "Home"));
}
return(View("NewUser", model));
}
public virtual async Task <ActionResult> NewUser(
Guid?siteId)
{
var selectedSite = await SiteManager.GetSiteForDataOperations(siteId);
// only server admin site can edit other sites settings
if (selectedSite.Id != SiteManager.CurrentSite.Id)
{
ViewData["Title"] = string.Format(CultureInfo.CurrentUICulture, StringLocalizer["{0} - New User"], selectedSite.SiteName);
}
else
{
ViewData["Title"] = StringLocalizer["New User"];
}
var model = new NewUserViewModel
{
SiteId = selectedSite.Id
};
var viewName = await CustomUserInfo.GetNewUserViewName(UserManager.Site, HttpContext);
await CustomUserInfo.HandleNewUserGet(
UserManager.Site,
model,
HttpContext,
ViewData);
return(View(viewName, model));
}
public IActionResult AddUserForm(NewUserViewModel model)
{
if (ModelState.IsValid)
{
if (_context.users.SingleOrDefault(u => u.email == model.email) != null)
{
TempData["Error"] = "☝🏻 Email is already in use, please try another email address";
return(RedirectToAction("Register"));
}
PasswordHasher <NewUserViewModel> Hasher = new PasswordHasher <NewUserViewModel>();
model.password = Hasher.HashPassword(model, model.password);
user AddUser = new user
{
firstName = model.firstName,
lastName = model.lastName,
stAddress = model.stAddress,
city = model.city,
state = model.state,
zip = model.zip,
email = model.email,
userType = model.userType,
password = model.password
};
_context.users.Add(AddUser);
_context.SaveChanges();
AddUser = _context.users.SingleOrDefault(u => u.email == AddUser.email);
HttpContext.Session.SetInt32("userid", AddUser.userid);
return(RedirectToAction("Dashboard", "Home"));
}
return(View("Register"));
}
public ActionResult UpdateUserDetails(User user)
{
var userInDb = _context.Get(user.Id);
var emailIsUnique = _context.EmailIsUnique(user.Email);
if (user.Email == userInDb.Email)
{
emailIsUnique = true;
}
if (emailIsUnique)
{
userInDb.FullName = user.FullName;
userInDb.Email = user.Email;
userInDb.BranchId = user.BranchId;
userInDb.PhoneNumber = user.PhoneNumber;
_context.Update(user);
TempData["Success"] = "Update Successful";
return(RedirectToAction("Index"));
}
if (!emailIsUnique)
{
ModelState.AddModelError("EmailExist", "Email Already Exist");
}
var viewModel = new NewUserViewModel
{
User = user,
Branches = _context.GetBranches().ToList()
};
return(View("EditUserForm", viewModel));
}
public async Task <ActionResult> New([Bind("Name", "Password", "ConfirmPassword", "Role")] NewUserViewModel model)
{
if (ModelState.IsValid)
{
var newUser = new IdentityUser
{
UserName = model.Name,
};
var result = await _users.CreateAsync(newUser, model.Password);
if (!result.Succeeded)
{
throw new Exception(string.Join(", ", result.Errors.Select(x => x.Description)));
}
result = await _users.AddToRoleAsync(newUser, model.Role);
if (!result.Succeeded)
{
throw new Exception(string.Join(", ", result.Errors.Select(x => x.Description)));
}
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <ActionResult> Create(NewUserViewModel user)
{
if (ModelState.IsValid)
{
ApplicationUser admin = new ApplicationUser()
{
Email = user.Email,
UserName = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
CreateDate = DateTime.Now,
LastUpdate = DateTime.Now
};
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var result = await userManager.CreateAsync(admin, user.Password);
if (result.Succeeded)
{
userManager.AddToRole(admin.Id, Roles.Admin);
}
return(RedirectToAction("Index"));
}
return(View(user));
}
public async Task <ActionResult> Create(NewUserViewModel model)
{
if (ModelState.IsValid)
{
string currentUserId = User.Identity.GetUserId();
int companyId = db.Users.Single(a => a.Id == currentUserId).CompanyId; //TODO Save Campny id in session when during t he login
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
CompanyId = companyId,
Profile = new Profile()
{
DateOfCreate = DateTime.Now,
DateOfUpdate = DateTime.Now,
Job = model.Job,
Address = "Not Set",
FirstName = model.FirstName,
LastName = model.LastName,
Gender = model.Gender,
PhoneNumber = "Not Set"
}
};
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, Roles.Staff);
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <IActionResult> EditAsync(string id)
{
// TODO: CLEAN UP
ApplicationUser userToEdit = await _userManager.FindByIdAsync(id);
IList <string> userToEditRoles = await _userManager.GetRolesAsync(userToEdit);
IdentityRole userToEditRole;
bool noRole = userToEditRoles.Count == 0;
if (noRole)
{
userToEditRole = await _roleManager.FindByNameAsync("Employee");
}
else
{
userToEditRole = await _roleManager.FindByNameAsync(userToEditRoles[0]);
}
NewUserViewModel editUserViewModel = new NewUserViewModel(_context.PaymentProfiles.ToList(),
_context.Roles.ToList(), userToEdit, userToEditRole);
if (noRole)
{
editUserViewModel.OldRoleName = "N/A";
}
return(View(editUserViewModel));
}
public async Task <IActionResult> New(NewUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var newUser = new UserModel()
{
FullName = model.FullName, UserName = model.Email, Email = model.Email, EmailConfirmed = true, PhoneNumberConfirmed = true
};
var addUser = await _userService.RegisterUser(newUser, model.Password, model.Role);
if (addUser == RegisterStatus.Succeeded)
{
return(RedirectToAction(nameof(UserController.List), "User"));
}
else if (addUser == RegisterStatus.ExistUser)
{
ViewData["Message"] = Model.Resources.ValidationMessages.ExistEmail;
return(View(model));
}
ViewData["Message"] = Model.Resources.ValidationMessages.CreateError;
return(View(model));
}
public async Task <IActionResult> EditAsync(NewUserViewModel editUserViewModel)
{
if (ModelState.IsValid)
{
ApplicationUser userToEdit = await _userManager.FindByIdAsync(editUserViewModel.UserId);
IdentityRole newRole = await _roleManager.FindByIdAsync(editUserViewModel.IdentityRoleId);
if (newRole.Name != editUserViewModel.OldRoleName)
{
await _userManager.AddToRoleAsync(userToEdit, newRole.Name);
}
if (editUserViewModel.OldRoleName != "N/A" && editUserViewModel.OldRoleName != newRole.Name)
{
await _userManager.RemoveFromRoleAsync(userToEdit, editUserViewModel.OldRoleName);
}
ApplicationUser.EditUser(userToEdit, editUserViewModel);
await _userManager.UpdateAsync(userToEdit);
return(Redirect("/User/Index"));
}
return(View(editUserViewModel));
}
public IActionResult New()
{
NewUserViewModel newUserViewModel = new NewUserViewModel(_context.PaymentProfiles.ToList(),
_context.Roles.ToList());
return(View(newUserViewModel));
}
public ActionResult Save(RegisteredUsers registeredUser)
{
if (!ModelState.IsValid)
{
var viewModel = new NewUserViewModel
{
RegisteredUser = registeredUser,
Biographies = _context.Biographies.ToList()
};
return(View("UserForm", viewModel));
}
if (registeredUser.Id == 0)
{
_context.RegisteredUsers.Add(registeredUser);
}
else
{
var registeredUserInDb = _context.RegisteredUsers.Single(c => c.Id == registeredUser.Id);
registeredUserInDb.Name = registeredUser.Name;
registeredUserInDb.Birthdate = registeredUser.Birthdate;
registeredUserInDb.Gender = registeredUser.Gender;
registeredUserInDb.Email = registeredUser.Email;
registeredUserInDb.Address = registeredUser.Address;
registeredUserInDb.Postcode = registeredUser.Postcode;
registeredUserInDb.Phonenumber = registeredUser.Phonenumber;
registeredUserInDb.BiographyId = registeredUser.BiographyId;
}
_context.SaveChanges();
return(RedirectToAction("Index", "User"));
}
public void TestNewUserPostReturnsRedirectToRouteResultType()
{
var model = new NewUserViewModel();
var result = _controller.NewUser(model) as RedirectToRouteResult;
Assert.AreEqual(typeof(RedirectToRouteResult), result.GetType());
}
public void TestNewUserPostReturnsCorrectRedirectToRouteResult()
{
var model = new NewUserViewModel();
var result = _controller.NewUser(model) as RedirectToRouteResult;
Assert.AreEqual("NewUser", result.RouteValues["action"]);
}
public int Save(NewUserViewModel data)
{
var role = UnitOfWork.Role
.Where(p => p.Name == "AppUser")
.Select(p => new
{
Id = p.IdRole
})
.FirstOrDefault();
if (role != null)
{
var model = new User
{
Name = data.Name,
Email = data.Email,
Password = data.Password,
Birthday = data.Birthday,
LastName = data.LastName,
FkRole = role.Id,
Active = true
};
UnitOfWork.Set <User>().Add(model);
UnitOfWork.SaveChanges();
return(model.IdUser);
}
return(-1);
}
public async Task <IActionResult> Register([FromBody] NewUserViewModel registration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityUser newUser = new IdentityUser
{
UserName = registration.User,
Email = registration.Email
};
IdentityResult result = await _userManager.CreateAsync(newUser,
registration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
return(Ok());
}
public ActionResult NewUser(NewUserViewModel model)
{
if (base.IsAuthenticated)
{
return(RedirectToAction("Dashboard", "Messages", new { username = base.CurrentUser }));
}
if (ModelState.IsValid)
{
var currentUser = userDal.GetUser(model.Username);
if (currentUser != null)
{
ViewBag.ErrorMessage = "This username is unavailable";
return(View("NewUser", model));
}
var newUser = new User
{
Username = model.Username,
Password = model.Password,
};
// Add the user to the database
userDal.CreateUser(newUser);
// Log the user in and redirect to the dashboard
base.LogUserIn(model.Username);
return(RedirectToAction("Dashboard", "Messages", new { username = model.Username }));
}
else
{
return(View("NewUser", model));
}
}
private void CreateUser(UserManager <ErasmusUser> manager, NewUserViewModel user, string role)
{
//Check for existing user
var dbUser = manager.Users.SingleOrDefault(x => x.Email == user.Email);
if (dbUser == null)
{
//Doesn't exist - create
dbUser = new ErasmusUser
{
Email = user.Email,
UserName = user.Email,
EmailConfirmed = true,
FirstName = user.FirstName,
LastName = user.LastName,
Birthday = user.Birthday,
PhoneNumber = user.Telephone,
UniversityId = user.UniversityId == 0 ? null : user.UniversityId,
PersonalIdCode = user.PersonalCode,
StudentId = user.StudentId
};
manager.Create(dbUser, user.Password);
manager.AddToRole(dbUser.Id, role);
}
else
{
throw new FormValidationException(
new Dictionary <string, string>()
{
{ "Email", "User with the same email already exists." }
}
);
}
}
public void RegisterNewUser()
{
//Arrange
var newUser = new NewUserViewModel
{
FullName = "Narendiran Dorairaj",
Email = "*****@*****.**",
CompanyName = "The Little Kingdom",
PhoneNumber = "1234567890",
Title = "Senior HR Specialist",
NumberOfEmployees = NumberOfEmployees.Xs
};
var mockCompanyServices = new Mock <ICompanyService>();
var mockUserServices = new Mock <IUserService>();
mockCompanyServices.Setup(c => c.Add(It.IsAny <Company>()));
mockUserServices.Setup(u => u.Add(It.IsAny <User>()));
var registerController = new RegisterController(mockCompanyServices.Object, mockUserServices.Object);
//Act
var result = (HttpStatusCodeResult)registerController.AddUser(newUser);
//Assert
Assert.AreEqual(HttpStatusCode.Created, (HttpStatusCode)result.StatusCode);
mockCompanyServices.Verify(cs => cs.Add(It.IsAny <Company>()), Times.Once);
mockUserServices.Verify(us => us.Add(It.IsAny <User>()), Times.Once);
}
public async Task <IActionResult> Register(NewUserViewModel model)
{
if (ModelState.IsValid)
{
// Copy data from RegisterViewModel to IdentityUser
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email
};
// Store user data in AspNetUsers database table
var result = await userManager.CreateAsync(user, model.Password);
// If user is successfully created, sign-in the user using
// SignInManager and redirect to index action of HomeController
if (result.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
// If there are any errors, add them to the ModelState object
// which will be displayed by the validation summary tag helper
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> Register(
NewUserViewModel newUserViewModel,
CancellationToken cancellationToken)
{
if (ModelState.IsValid)
{
try
{
await this.registrationService.RegisterUser(newUserViewModel, cancellationToken);
return(View("SuccessfullyRegistered"));
}
catch (ValidationException ex)
{
ModelState.AddModelError(nameof(newUserViewModel.Username), ex.Message);
SetSkippedIfValid(nameof(newUserViewModel.Password));
SetSkippedIfValid(nameof(newUserViewModel.ConfirmPassword));
void SetSkippedIfValid(string key)
{
if (ModelState.GetFieldValidationState(key) == ModelValidationState.Valid)
{
ModelState.MarkFieldSkipped(key);
}
}
}
}
return(View(nameof(RegistrationForm)));
}
public async Task <IActionResult> CreateUser(NewUserViewModel model)
{
ViewBag.AllCompanies = new SelectList(_companyService.GetCompaniesList(), "CompanyId", "CompanyName");
ViewBag.allRoles = new SelectList(_roleManager.Roles.ToList(), "Name", "Name");
if (ModelState.IsValid)
{
AppUser newUser = new AppUser()
{
Email = model.Email,
UserName = model.Email,
MemberName = model.MemberName,
JoinDateTime = DateTime.Now,
CompanyId = model.CompanyID
};
var result = await _userManager.CreateAsync(newUser, model.ConfirmPassword);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(newUser, model.UserRole);
Company company = await _companyService.GetCompanyById(model.CompanyID);
if (company.AppUsers.Count >= (int)company.CompanyMemberSize)
{
ViewBag.SizeExceeded = "Company Membership Size Exceeded";
return(View(model));
}
company.AppUsers.Add(newUser);
return(RedirectToAction("GetUserList"));
}
}
return(View("~/Views/Admin/CreateUser.cshtml", model));
}
public async Task AddNewUser(NewUserViewModel model)
{
var info = new ContactInfo
{
PhoneNumber = model.Phone,
Email = model.Email,
};
_dataContext.ContactInfos.Add(info);
await _dataContext.SaveChangesAsync();
var contactInfoId = info.Id;
var user = new User {
Name = model.Name, ContactInfo = info,
};
_dataContext.Users.Add(user);
await _dataContext.SaveChangesAsync();
ContactGroup group = _dataContext.ContactGroups.FirstOrDefault(e => e.Id == model.ContactGroupId);
_dataContext.Contacts.Add(new Contact
{
User = user,
ContactGroup = group,
ContactMethod = model.ContactMethod,
});
await _dataContext.SaveChangesAsync();
}
public async Task <bool> HandleNewUserValidation(
ISiteContext site,
NewUserViewModel viewModel,
HttpContext httpContext,
ViewDataDictionary viewData,
ModelStateDictionary modelState,
CancellationToken cancellationToken = default(CancellationToken)
)
{
await EnsureProps();
var result = true;
foreach (var p in _props.Properties)
{
if (p.VisibleOnRegistration)
{
var postedValue = httpContext.Request.Form[p.Key];
if (_userPropertyValidator.IsValid(p, postedValue, modelState))
{
// if valid keep the field populated in case some other model validation failed and the form is re-displayed
viewData[p.Key] = postedValue;
}
else
{
result = false;
}
}
}
return(result);
}
public async Task <IHttpActionResult> NewUser([FromBody] NewUserViewModel data)
{
data.Id = Guid.NewGuid().ToString();
if (data.Username.IsNullOrWhiteSpace() || data.Password.IsNullOrWhiteSpace())
{
return(Content(HttpStatusCode.BadRequest, "Invalid Data"));
}
var user = new ApplicationUser
{
Id = data.Id,
UserName = data.Username
};
var result = await _userManager.CreateAsync(user, data.Password);
if (result.Succeeded)
{
return(Ok("User added"));
}
return(BadRequest());
}
public async Task <ActionResult> QQLogin(NewUserViewModel viewModel)
{
var owinContext = Request.GetOwinContext();
var identity = await owinContext.Environment.GetIdentityServerPartialLoginAsync();
if (identity == null || identity.IsAuthenticated == false)
{
return(new HttpUnauthorizedResult());
}
var qqConnectProfile = new QQConnectProfile(identity.Claims);
var newUser = new InMemoryUser
{
Username = viewModel.UserName ?? "Default Name",
Subject = Guid.NewGuid().ToString(),
Enabled = true,
Provider = qqConnectProfile.Issuer,
ProviderId = qqConnectProfile.OpenId,
Claims = new[]
{
new Claim(Constants.ClaimTypes.NickName, qqConnectProfile.NickName),
new Claim(Constants.ClaimTypes.Picture, qqConnectProfile.Avatar),
}
};
Users.All.Add(newUser);
var resumeUrl = await owinContext.Environment.GetPartialLoginResumeUrlAsync();
return(Redirect(resumeUrl));
}
public ViewModelLocator()
{
// The hell with IoC. Let's just create all out VM's when application loads.
MainView = new MainViewModel();
LoginView = new LoginViewModel();
NewUserView = new NewUserViewModel();
HomeView = new HomeViewModel();
AccountsView = new AccountsViewModel();
AccountViewer = new AccountDetailsViewModel();
StatementsView = new StatementsViewModel();
StatementViewer = new StatementViewerViewModel();
RecentActivityView = new RecentActivityViewModel();
FeedbackView = new FeedbackViewModel();
AboutView = new AboutViewModel();
AccountNew = new AccountNewViewModel();
}
public async Task<ActionResult> CreateUser(NewUserViewModel model)
{
try
{
//model.Email = model.UserName;
if (!ModelState.IsValid)
{
AddRedirectMessage(ModelState);
return View("Users", model);
}
model.Roles = model.AvailableRoles.Where(x => x.IsSelected).ToArray();
await ViewModelsService.Execute(model);
AddRedirectMessage(ServerResponseStatus.SUCCESS, string.Format("User '{0}' created!", model.UserName));
return RedirectToAction("Users", "UserAdministration", new { id = model.UserId });
}
catch (Exception ex)
{
AddRedirectMessage(ex);
return RedirectToAction("Users", "UserAdministration");
}
}
