public async Task <ActionResult> Registration(UserRegistrationViewModel model, string RoleAccess)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = admin.GenerateUserName(), Email = model.Email, PhoneNumber = model.PhoneNumber, EmailConfirmed = true
};
var result = await UserManager.CreateAsync(user, "cahngeme");
if (result.Succeeded)
{
var status = UserManager.AddToRole(user.Id, "Admin");
if (status.Succeeded)
{
// Assign user to Role
//string role = admin.GetAllRoleAcessLevelMapping(RoleAccess).FirstOrDefault().Role ;
// UserManager.AddToRole(user.Id, role);
admin.AddUserProfileDetails(user.Id, model.Name, RoleAccess);
}
}
}
//PopulateRoleAccessLevel();
return(View());
}
public IActionResult Register(UserRegistrationViewModel urvm)
{
if (ModelState.IsValid)
{
User u = new User();
u.Firstname = urvm.Firstname;
u.Lastname = urvm.Lastname;
u.Email = urvm.Email;
u.Password = urvm.Password;
u.IsAdmin = false;
User newUser = _repository.Create(u);
if (newUser == null)
{
ModelState.AddModelError("", "This Use Already Exists.");
return(View(urvm));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
return(View(urvm));
}
public ActionResult Register([Bind(Include = "Name, Password, ConfirmedPassword, Email, PhoneNumber,RoleName,Roles")] UserRegistrationViewModel userRegistrationViewModel)
{
userRegistrationViewModel.roles = roleBasicDTOList.roles;
try
{
ModelState.Remove("roles");
if (ModelState.IsValid)
{
UserDTO userDTO = RegistrationMapper.Map <UserRegistrationViewModel, UserDTO>(userRegistrationViewModel);
UserBasicDTO userBasicDTO = userBusinessContext.RegisterUser(userDTO);
return(View("Success"));
}
else
{
return(View(userRegistrationViewModel));
}
}
catch (UserNameAlreadyExistsException) {
ModelState.AddModelError("", "Username is already taken");
return(View(userRegistrationViewModel));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong. Please try after some time");
}
return(View("Error"));
}
public async Task <IActionResult> Register(UserRegistrationViewModel registrationViewModel)
{
if (ModelState.IsValid)
{
User newUser = new User()
{
UserName = registrationViewModel.Username,
YearOfBirth = registrationViewModel.YearOfBirth
};
IdentityResult userCreationResult =
await _userManager.CreateAsync(newUser, registrationViewModel.Password);
if (userCreationResult.Succeeded)
{
await _signinManager.PasswordSignInAsync(newUser.UserName, registrationViewModel.Password, false, false);
return(RedirectToAction("Index", "Books"));
}
else
{
IEnumerable <string> userCreationErrors = from e in userCreationResult.Errors select e.Description;
string concatenatedErrors = string.Join(Environment.NewLine, userCreationErrors);
ModelState.AddModelError("", concatenatedErrors);
}
}
return(View());
}
public ActionResult Registration(UserRegistrationViewModel obj, Roles roles)
{
try
{
if (ModelState.IsValid == true)
{
bool status = this.objUDSvc.RegisterUser(obj, roles);
if (status == true)
{
return(Json(new Response {
IsSuccess = true, Code = 200, Result = status
}));
}
}
return(Json(new Response {
IsSuccess = false, Code = 500, Result = "", Message = "Validation error"
}));
}
catch (Exception ex)
{
if (typeof(UserDefinedException) == ex.GetType())
{
return(Json(new Response {
IsSuccess = false, Code = 500, Result = "", Message = ex.Message
}));
}
ErrorLog.Log("UserController", "Registration", ex);
throw ex;
}
}
public async Task <ActionResult> PostRegistrationForm(UserRegistrationViewModel viewModel)
{
if (!viewModel.Password.Equals(viewModel.ConfirmPassword, System.StringComparison.Ordinal))
{
ModelState.AddModelError("ConfirmPassword", "The two passwords do not match.");
}
if (ModelState.IsValid)
{
try
{
var user = new UserToCreate(viewModel.Email, viewModel.Password);
await userService.AddUserAsync(user);
}
catch (InvalidEmailException e)
{
ModelState.AddModelError("Email", e.Message);
}
catch (InvalidPasswordException e)
{
ModelState.AddModelError("Password", e.Message);
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(ActionNames.REGISTRATION_SUCCESS));
}
else
{
return(View(ViewNames.REGISTRATION_FORM, viewModel));
}
}
public async Task <IActionResult> Register(UserRegistrationViewModel userRegistration)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = _mapper.Map <User>(userRegistration);
var result = await _userManager.CreateAsync(user, userRegistration.Password);
if (!result.Succeeded)
{
return(BadRequest());
}
//para confirmação de email
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action(nameof(ConfirmEmail), "Account", new { token, email = user.Email }, Request.Scheme);
var message = new Message(new string[] { user.Email }, "Confirmation email link", confirmationLink, null);
// await _emailSender.SendEmailAsync(message);
await _emailSenderMacoratti.SendEmailAsync(user.Email, "Confirmation email link", confirmationLink);
//adicionando roles
await _userManager.AddToRoleAsync(user, "Visitor");
return(Ok());
}
public IActionResult Post([FromBody] UserRegistrationViewModel users)
{
//users.InstituteId = 1;
// DBMContext db = new DBMContext();
DigitalBoardMarkerContext db = new DigitalBoardMarkerContext();
if (users.EmailAlreadyExists(users.Email, users.Designation))
{
ModelState.AddModelError("EmailAddress", "This email already exists for this designation.");
return(BadRequest(ModelState));
}
Users u = new Users();
u.FirstName = users.FirstName;
u.LastName = users.LastName;
u.RegNo = users.RegistrationNumber;
u.Cnic = users.Cnic;
u.Email = users.Email;
u.Password = users.Password;
u.DateOfBirth = users.DateOfBirth;
u.Designation = users.Designation;
u.LoginStatus = 0;
u.ActiveStatue = 1;
u.InstituteId = db.Institute.Where(p => p.Name.Equals(users.InstituteName)).FirstOrDefault().Id;
db.Users.Add(u);
//db.Users.Add(users);
db.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Registration([FromBody] UserRegistrationViewModel newUser)
{
try
{
if (ModelState.IsValid)
{
var user = Mapper.Map <User>(newUser);
await _userService.RegistrationAsync(user);
return(Ok("Welcome, " + user.Email + ", now you can login"));
}
else
{
return(BadRequest(ModelState.Errors()));
}
}
catch (UserIsAlreadyExistException e)
{
return(new JsonResult(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Server error. Try to reload page."));
}
}
public ActionResult UpdateRegistration(UserRegistrationViewModel obj, Roles roles)
{
try
{
int LoginID = GetLogin();
if (LoginID > 0)
{
bool status = this.objUDSvc.UpdateRegisterUser(obj, roles, LoginID);
if (status == true)
{
bool log = this.objUDSvc.UserActivitylogs(LoginID, "Update Profile", "Update Successfully.");
return(Json(new Response {
IsSuccess = true, Code = 200, Result = status
}));
}
}
return(Json(new Response {
IsSuccess = false, Code = 500, Result = "", Message = "Validation error"
}));
}
catch (Exception ex)
{
if (typeof(UserDefinedException) == ex.GetType())
{
return(Json(new Response {
IsSuccess = false, Code = 500, Result = "", Message = ex.Message
}));
}
ErrorLog.Log("UserController", "UpdateRegistration", ex);
throw ex;
}
}
public async Task <IActionResult> Register(UserRegistrationViewModel userRegistration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
var user = new User
{
UserToken = Guid.NewGuid(),
Name = userRegistration.Name,
UserName = userRegistration.Email,
Email = userRegistration.Email,
EmailConfirmed = true,
CreateDate = DateTime.Now,
LastUpdateDate = DateTime.Now
};
var result = await _userManager.CreateAsync(user, userRegistration.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, false);
return(Ok(await GenerateJwt(userRegistration.Email)));
}
public async Task Register(UserRegistrationViewModel registration)
{
ValidateUserRegistration(registration);
var toCreate = new UserEntity()
{
Username = registration.Username,
Email = registration.Email,
Password = _passwordHasher.HashPassword(registration.Password),
Name = registration.Name,
Active = true,
Locked = false
};
_userRepository.Create(toCreate);
var registrationKeyValid = false;
try
{
registrationKeyValid = _userRegistrationKeyService.Use(registration.RegistrationKey, toCreate.UserId);
}
finally
{
if (!registrationKeyValid)
{
_userRepository.Delete(toCreate.UserId);
}
}
AddRole(toCreate.UserId, Roles.User.Id);
await CreateEmailVerificationRequest(toCreate);
}
public IActionResult Register(UserRegistrationViewModel urvm)
{
//if (urvm.Password != urvm.VerificationPassword)
//{
// ModelState.AddModelError("", "Passwords did not match.");
//}
if (ModelState.IsValid)
{
User u = new User();
u.IsAdmin = false;
u.Password = urvm.Password;
u.Email = urvm.Email;
u.FirstName = urvm.FirstName;
u.LastName = urvm.LastName;
u.PhoneNumber = urvm.PhoneNumber;
u.Address = urvm.Address;
User newUser = _repository.Create(u);
if (newUser == null)
{
ModelState.AddModelError("", "This User Already Exists.");
return(View(urvm));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Could not register this account. Try again.");
return(View(urvm));
}
public List <string> ValidateUser(UserRegistrationViewModel userDTO)
{
var result = new List <string>();
if (userDTO.Username.Length < 5 || userDTO.Username.Length > 20)
{
result.Add("Ivalid username input.");
}
if (!Regex.IsMatch(userDTO.Email, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"))
{
result.Add("Invalid email address input");
}
if (userDTO.Password.Length < 6 || userDTO.Password.Length > 20)
{
result.Add("Invalid password input");
}
if (userDTO.Password != userDTO.ConfirmPassword)
{
result.Add("Password input dose not match confirmation password!");
}
return(result);
}
public User RegisterUser(UserRegistrationViewModel registration)
{
ValidateRegistration(registration);
User user = new User()
{
Username = registration.Username,
Email = registration.Email,
Password = _passwordHasher.HashPassword(registration.Password),
Name = registration.Name,
Active = true,
Locked = false
};
_db.Users.Add(user);
var registrationKeyValid = false;
try
{
registrationKeyValid = _registrationKeyService.UseKey(registration.RegistrationKey, user);
}
finally
{
if (!registrationKeyValid)
{
//if we failed to use the registration key, delete the user
_db.Users.Remove(user);
}
_db.SaveChanges();
}
return(user);
}
protected void ValidateRegistration(UserRegistrationViewModel registration)
{
if (string.IsNullOrWhiteSpace(registration.Username))
{
throw new EntityValidationException("Username cannot be blank!");
}
if (!IsUsernameAvailable(registration.Username))
{
throw new EntityValidationException("Username is not available!");
}
if (string.IsNullOrWhiteSpace(registration.Password))
{
throw new EntityValidationException("Password must not be blank!");
}
if (registration.Password.Length < 8)
{
throw new EntityValidationException("Password must be at least 8 characters long.");
}
if (string.IsNullOrWhiteSpace(registration.Email))
{
throw new EntityValidationException("Email must not be blank!");
}
if (!_registrationKeyService.IsValid(registration.RegistrationKey))
{
throw new EntityValidationException("Registration Key is not valid!");
}
}
public async Task <IActionResult> Register(UserRegistrationViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
City = model.City
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
{
return(RedirectToAction("ListUsers", "Administration"));
}
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View());
}
public async Task <ActionResult> SignUp(UserRegistrationViewModel userRegistration)
{
if (ModelState.IsValid == false)
{
return(Response(ModelState));
}
var user = new IdentityUser
{
UserName = userRegistration.Email,
Email = userRegistration.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userRegistration.Password);
if (result.Succeeded == false)
{
foreach (var identityError in result.Errors)
{
AddError(identityError.Description);
}
return(Response());
}
return(Response(await CreateUserAuth(userRegistration.Email)));
}
public async void Registration_CalledAndFailedUserCreate_ReturnsBadRequestWithErrorContext()
{
IUnitOfWork _unitOfWork = Substitute.For <IUnitOfWork>();
ICookieManager _cookieManager = Substitute.For <ICookieManager>();
IUserStore <User> _usersStore = Substitute.For <IUserStore <User> >();
var manager = Substitute.For <UserManager <User> >(_usersStore, null, null, null, null, null, null, null, null);
UserRegistrationViewModel model = new UserRegistrationViewModel();
var errorContext = new ErrorContext();
errorContext.Errors.Add("test");
manager.CreateAsync(Arg.Any <User>(), Arg.Any <string>()).Returns(Task.FromResult(IdentityResult.Failed(new IdentityError()
{
Code = "Test", Description = "test"
})));
var usersController = new UsersController(_unitOfWork, manager, _cookieManager);
var result = await usersController.Registration(model);
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
var returnValue = Assert.IsType <ErrorContext>(badRequestObjectResult.Value);
Assert.Equal(errorContext.Errors, returnValue.Errors);
}
public async Task <IActionResult> RegisterAsync(UserRegistrationViewModel registrationViewModel)
{
var validator = new UserRegistrationViewModelValidator(_accountService);
ValidationResult result = validator.Validate(registrationViewModel);
if (!result.IsValid)
{
return(BadRequest(new ErrorResponseFormat(result.Errors.First().ErrorMessage)));
}
UserRegistrationModel authorizationModel = _mapper.Map <UserRegistrationModel>(registrationViewModel);
UserModel user = await _accountService.CreateUserAsync(authorizationModel);
if (user == null)
{
return(BadRequest(new ErrorResponseFormat(Constants.Errors.USER_CREATION_FAILED)));
}
string tokenString = _jwtService.GetJWTToken(user, new EmailClaimsService(_jwtSettings));
await _accountService.AddAccountTokenAsync(
new AccountTokenModel()
{
ExpirationDate = DateTime.Now.AddMinutes(10),
UserId = user.Id
}
);
await _emailService.SendEmailConfirmationLinkAsync(user.Email, tokenString);
return(NoContent());
}
public async Task <IActionResult> Registration([FromBody] UserRegistrationViewModel newUser, string role)
{
if (newUser == null)
{
return(BadRequest("User info cannot be null."));
}
var User = new User {
UserName = newUser.UserName, Email = newUser.Email, PhoneNumber = newUser.PhoneNumber, Role = Role.Student.ToString()
};
var result = await _userManager.CreateAsync(User, newUser.Password);
var ErrorContext = new ErrorContext();
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(User, Role.Student.ToString());
return(Ok());
}
else
{
foreach (var error in result.Errors.ToArray())
{
ErrorContext.Errors.Add(error.Description);
}
}
return(BadRequest(ErrorContext));
}
public ActionResult CreateUser()
{
UserRegistrationViewModel userRegistrationViewModel = new UserRegistrationViewModel();
//Country dropdown,
//just remember all the method that you have use dwith milind all are right
//List<Country> countriesList = new List<Country>();
//List<Course> coursesList = new List<Course>();
//List<Role> rolesList = new List<Role>();
try
{
//data from db is filled in the data variable which is in the form of list
var countriesList = db.Countries.ToList();
var coursesList = db.Courses.ToList();
var rolesList = db.Roles.ToList();
var subjectList = db.Subjects.ToList();
//using loop putting each value in the countriesList
//foreach (var item in countryData)
//{
// Country testCountry = new Country
// {
// CountryId = Convert.ToInt32(item.Value),
// CountryName = item.Text.ToString()
// };
// countriesList.Add(testCountry);
//}
//foreach (var item in courseData)
//{
// Course testCourse = new Course
// {
// CourseId = Convert.ToInt32(item.Value),
// CourseName = item.Text.ToString()
// };
// coursesList.Add(testCourse);
//}
//foreach (var item in roleData)
//{
// Role testRole = new Role
// {
// RoleId = Convert.ToInt32(item.Value),
// RoleName = item.Text.ToString()
// };
// rolesList.Add(testRole);
//}
//Assigning that list to that viewmodel
userRegistrationViewModel.CountryList = countriesList;
userRegistrationViewModel.CourseList = coursesList;
userRegistrationViewModel.RoleList = rolesList;
userRegistrationViewModel.SubjectList = subjectList;
}
catch (Exception ex)
{
Console.WriteLine("Exception source: {0}", ex.Message);
}
return(View(userRegistrationViewModel));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationViewModel registration)
{
await _userService.Register(registration);
// if registration failed it will throw an EntityValidationException, in which case our middleware will
// handle that if we make it here registration was successful so we return 200.
return(Ok());
}
public UserToRegister(UserRegistrationViewModel registrationRequest)
{
Username = registrationRequest.Username;
Password = registrationRequest.Password;
Email = registrationRequest.Email;
Name = registrationRequest.Name;
LoginType = registrationRequest.LoginType;
}
private UserRegistrationViewModel CreateRegisterShape(UserRegistrationViewModel viewModel, IMembershipSettings membershipSettings)
{
UserRegistrationViewModel shape = shapeFactory.RegisterUser(typeof(UserRegistrationViewModel));
SetViewModelValue(viewModel, shape);
SetMembershipSettings(shape, membershipSettings);
return(shape);
}
public async Task CreateUser(UserRegistrationViewModel profile)
{
using (var db = new HeznekServiceDbEntities())
{
db.User_Profile.Add(this.MapUserProfile(profile));
await db.SaveChangesAsync();
}
}
public async Task <IActionResult> CreateAsync()
{
var vm = new UserRegistrationViewModel();
vm = (UserRegistrationViewModel) await populateDropDownAsync(vm);
return(View(vm));
}
private void SetMembershipSettings(UserRegistrationViewModel viewModel, IMembershipSettings memnerSetting)
{
viewModel.PasswordLength = memnerSetting.GetMinimumPasswordLength();
viewModel.LowercaseRequirement = memnerSetting.GetPasswordLowercaseRequirement();
viewModel.UppercaseRequirement = memnerSetting.GetPasswordUppercaseRequirement();
viewModel.SpecialCharacterRequirement = memnerSetting.GetPasswordSpecialRequirement();
viewModel.NumberRequirement = memnerSetting.GetPasswordNumberRequirement();
}
// GET: User
public ActionResult Index(bool OnlyAddCustomer = false)
{
UserRegistrationViewModel objVm = new UserRegistrationViewModel();
objVm.Country = this.objHSSvc.GetCountry().ToList();
objVm.State = this.objHSSvc.GetState(0).ToList();
objVm.OnlyAddCustomer = OnlyAddCustomer;
return(View(objVm));
}
public Task <IActionResult> UserRegistration(UserRegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(UserRegistration(model));
}
return(UserRegistrationInternal(model));
}
public ActionResult SignUp(UserRegistrationViewModel model)
{
if (this.ModelState.IsValid)
{
try
{
var user = Mapper.Map<UserDto>(model);
user.Role = UserDtoRole.Customer;
user.State = UserDtoState.Normal;
this.userService.CreateUser(user);
this.userService.Commit();
return this.RedirectToAction("Index", "Home", new { area = "Common" });
}
catch (Exception e)
{
return this.RedirectToAction("Index", "Home", new { area = "Common" });
}
}
return this.View(model);
}
