public IncomingUser ToIncomingUser(RegisterUserModel apiModel)
{
return new IncomingUser
{
Email = apiModel.Email,
Name = apiModel.Login,
Password = apiModel.Password
};
}
public async Task <IHttpActionResult> Register(RegisterUserModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var user = new RegisterUserDTO {
UserName = userModel.UserName, PasswordHash = userModel.Password
};
_userService.CreateUser(user);
return(Ok( ));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public Task <HttpResponseMessage> Post(RegisterUserModel model)
{
HttpResponseMessage response = new HttpResponseMessage();
try
{
_service.Register(model.Name, model.Email, model.Password, model.ConfirmPassword);
response = Request.CreateResponse(HttpStatusCode.OK, new { name = model.Name, email = model.Email });
}
catch (Exception ex)
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
}
var tsc = new TaskCompletionSource <HttpResponseMessage>();
tsc.SetResult(response);
return(tsc.Task);
}
public async Task <IHttpActionResult> Create(RegisterUserModel userModel)
{
var claims = Helper.GetClaims(User.Identity as ClaimsIdentity);
int workSpaceId = Convert.ToInt32(claims["WorkSpaceId"]);
var workSpace = _repository.GetWorkSpace(workSpaceId, claims[ClaimTypes.Name]);
if (workSpace == null)
{
return(BadRequest("Ocurrio un error al obtener datos del espacio de trabajo."));
}
if (!_repository.IsValidCreateUser(workSpaceId, workSpace.MaxUsers))
{
return(BadRequest("Supero el máximo de usuarios permitidos."));
}
userModel.Password = userModel.UserName;
userModel.ConfirmPassword = userModel.UserName;
userModel.UserName = userModel.UserName.ToLower() + "@" + workSpace.Domain + ".com";
userModel.Role = "Usuario";
userModel.WorkSpaceId = workSpaceId;
ModelState.Remove("userModel.Password");
ModelState.Remove("userModel.Role");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await _repository.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
_log.Info("se ha registrado un nuevo usuario: " + userModel.UserName, "AuthenticationAPI", claims[ClaimTypes.Name]);
return(Ok());
}
private async Task SaveImagesAsync(RegisterUserModel userModel)
{
var host = AppDomain.CurrentDomain.GetData("DataDirectory").ToString();
try
{
if (!Directory.Exists($"{host}\\Images"))
{
Directory.CreateDirectory($"{host}\\Images");
}
var imageBytes = string.IsNullOrEmpty(userModel.ImageBase64String) ? null : Convert.FromBase64String(userModel.ImageBase64String);
if (imageBytes != null)
{
await SaveImageAsync($"{host}\\Images\\{userModel.Id}-avatar.jpg", imageBytes);
}
}
catch (Exception)
{
// ignore
}
try
{
var backgroundBytes = string.IsNullOrEmpty(userModel.BackgroundImageBase64String) ? null : Convert.FromBase64String(userModel.BackgroundImageBase64String);
if (!Directory.Exists($"{host}\\Images"))
{
Directory.CreateDirectory($"{host}\\Images");
}
if (backgroundBytes != null)
{
await SaveImageAsync($"{host}\\Images\\{userModel.Id}-background.jpg", backgroundBytes);
}
}
catch (Exception)
{
// ignore
}
}
public async Task <IActionResult> Register(RegisterUserModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
user = new UserDTO {
Id = Guid.NewGuid(), FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, BirthDate = model.BirthDate
};
var activationLink = Url.Action("ConfirmEmail", "Account", new
{
token = Security.Encrypt(await _userManager.GenerateEmailConfirmationTokenAsync(user)),
email = Security.Encrypt(model.Email)
}, Request.Scheme);
var create = await _userManager.CreateAsync(user, Security.Decrypt(model.PasswordHash));
if (create.Succeeded && await _emailSender.SendAsync(model.Email, activationLink, "Confirm your email account"))
{
ViewBag.Succeeded = 200;
}
else
{
foreach (var error in create.Errors)
{
Handler.Error(error.Description, this);
}
}
}
else
{
Handler.Error("This email already exists", this);
}
return(View());
}
public IHttpActionResult Post(RegisterUserModel user)
{
if (user.Password != user.ConfirmPassword)
{
return(BadRequest("Hasłą nie są takie same."));
}
if (string.IsNullOrEmpty(user.Email))
{
return(BadRequest("Adres e-mail jest niepoprawny."));
}
if (string.IsNullOrEmpty(user.Password) || string.IsNullOrEmpty(user.ConfirmPassword) ||
string.IsNullOrEmpty(user.Email) || string.IsNullOrEmpty(user.FirstName) ||
string.IsNullOrEmpty(user.LastName) || string.IsNullOrEmpty(user.PhoneNumber) ||
string.IsNullOrEmpty(user.TicketNumber))
{
return(BadRequest("Wszystkie pola muszą być wypełnione."));
}
var userExists = _userRepository.Get().Where(x => x.Email == user.Email).Count() > 0;
if (userExists)
{
return(BadRequest("Istnieje już użytkownik z takim adresem e-mail."));
}
var ticketExists = _userRepository.Get().FirstOrDefault(x => x.TicketNumber == user.TicketNumber);
if (ticketExists == null)
{
return(BadRequest("Niestety, zaproszenie jest niepoprawne."));
}
ticketExists.Email = user.Email;
ticketExists.Password = user.Password;
ticketExists.FirstName = user.FirstName;
ticketExists.LastName = user.LastName;
ticketExists.PhoneNumber = user.PhoneNumber;
ticketExists.Active = true;
_userRepository.Put(ticketExists);
return(Ok("Rejestracja przebiegła pomyślnie. Można się już zalogować."));
}
public async Task SendCreateUser(RegisterUserModel messageObject)
{
// Retrieve storage account from connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_cloudStorageAccountSetting.ConnectionString);
// Create the queue client.
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
// Retrieve a reference to a queue.
CloudQueue queue = queueClient.GetQueueReference(_cloudStorageAccountSetting.CreateUserQeue);
// Create the queue if it doesn't already exist.
await queue.CreateIfNotExistsAsync();
// Create a message and add it to the queue.
string serializedMessage = JsonConvert.SerializeObject(messageObject);
CloudQueueMessage cloudQueueMessage = new CloudQueueMessage(serializedMessage);
await queue.AddMessageAsync(cloudQueueMessage);
}
private async void CreateFunction()
{
Console.WriteLine(Email);
Console.WriteLine(Username);
Console.WriteLine(Password);
Console.WriteLine(ConfirmPassword);
var user = new MobileUser()
{
Email = Email, Username = Username, Password = Password
};
var userr = new RegisterUserModel()
{
Email = Email, UserName = Username, Password = Password
};
await database.createUser(user);
await server.RegisterUser(userr);
Console.WriteLine("adadsf");
}
/// <summary>
/// Получает Сущность из <paramref name="model"/>
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static User CreateUser(RegisterUserModel model)
{
User user = new User()
{
UserName = model.Email,
UserPhone = model.Phone,
Password = model.Password,
AccessRoleId = model.RoleId,
UserInfo = new UserInfo()
{
Name = model.Name,
LastName = model.LastName,
Company = model.Company,
Position = model.Position,
},
};
StatusService.ChangeStatus(user, UserStatusType.System);
return(user);
}
public IActionResult Register([FromBody] RegisterUserModel model)
{
// map model to entity
var user = _mapper.Map <User>(model);
try
{
// create user
_userService.Create(user, model.Password);
return(Ok(new {
data = user,
message = "Successfully registered user."
}));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public IActionResult Register([FromBody] RegisterUserModel userIn)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var user = new User()
{
FirstName = userIn.FirstName,
LastName = userIn.LastName,
Username = userIn.Username,
Email = userIn.Email,
DateOfBirth = userIn.DateOfBirth,
Image = userIn.Image
};
_userService.Register(user, userIn.Password);
return(CreatedAtAction("GetMovieCollection", new { id = user.Id }, user));
}
public async Task <Guid> Register(RegisterUserModel model)
{
var userToRegister = new User
{
Id = Guid.NewGuid(),
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
// encrypt password
Password = _passwordHasher.HashPassword(model.Password),
CreatedAtTimestamp = DateTime.UtcNow,
PasswordChangedTimestamp = DateTime.UtcNow
};
await _authContext.Users.AddAsync(userToRegister);
await _authContext.SaveChangesAsync();
return(userToRegister.Id);
}
public async Task <IActionResult> Register(RegisterUserModel model)
{
var applicationUser = new IdentityUser()
{
UserName = model.Username.ToLower(),
Email = model.Email.ToLower()
};
try
{
var result = await _userManager.CreateAsync(applicationUser, model.Password);
return(Ok(result));
}
catch (Exception ex)
{
// TODO: log exceptions
return(BadRequest(new { message = "Something went wrong. Please try again later." }));
}
}
public async Task <object> RegisterUser(RegisterUserModel model)
{
//if (!ModelState.IsValid) return BadRequest(model);
var user = new User
{
UserName = model.UserName,
Email = model.Email
};
try
{
var result = await _userManager.CreateAsync(user, model.Password);
return(Ok(result));
}
catch (Exception ex)
{
throw ex;
}
}
public async void Execute_WithValidModel_Successful()
{
// arrange
RegisterUserModel registrationModel = new RegisterUserModel {
Username = "******"
};
this.userAccessMock.Setup(x => x.TryGetByName(registrationModel.Username)).Returns(Maybe <User> .Empty);
this.userAccessMock.Setup(x => x.Add(registrationModel.Username)).Returns(new User {
Name = registrationModel.Username
});
var command = this.commandRepository.RegisterNewUser(registrationModel);
// act
var commandResult = await this.CommandExecutor.ExecuteAsync(command);
// assert
CommandAssert.IsSuccessful(commandResult);
Assert.AreEqual(registrationModel.Username, commandResult.SuccessData.Name);
}
public Task <IActionResult> Add([FromBody] RegisterUserModel userModel)
{
IActionResult result;
try
{
_service.Add(userModel);
result = Ok(new ResultViewModel {
Success = true, Message = "Usuário cadastrado com sucesso"
});
}
catch (Exception ex)
{
result = BadRequest(new ResultViewModel {
Success = false, Message = ex.Message, Docs = ex
});
}
return(GetResult(result));
}
public async Task <User> Register(RegisterUserModel userModel)
{
var existingUser = await _userRepository.GetAsync(userModel.Email);
if (existingUser != null)
{
throw new LibraryDomainException($"User with email {userModel.Email} already exists.");
}
var user = new User(userModel.FirstName, userModel.LastName, new Email(userModel.Email), userModel.Role);
var(passwordHash, passwordSalt) = _passwordHashService.CreatePasswordHash(userModel.Password);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
_userRepository.Create(user);
await _userRepository.UnitOfWork.SaveChangesAsync();
return(user);
}
public ActionResult Register([FromBody] RegisterUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = _userManager.RegisterUser(model.Email, model.Password);
if (!string.IsNullOrEmpty(result.Message))
{
var errors = new List <string>()
{
result.Message
};
return(GetErrorResult(new ErrorResult(errors, false)));
}
return(Ok());
}
public async Task <UserReturnModel> Register([FromBody] RegisterUserModel creds)
{
// Console.WriteLine("Here it should be");
// Console.WriteLine(creds);
if (ModelState.IsValid)
{
UserReturnModel user = _db.Register(creds);
if (user != null)
{
ClaimsPrincipal principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
}
}
// Console.WriteLine("It didnt validate, better figure out why.");
return(null);
}
public void Register_Post_Fail_Unknown_Reason()
{
// arrange
var auth = new Mock <IAuthenticationService>();
var notification = new Mock <INotificationService>();
var redirect = new RedirectService();
var controller = new RegistrationController(auth.Object, notification.Object, redirect);
var model = new RegisterUserModel()
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
auth.Setup(a => a.ValidateCaptcha()).Returns(true);
auth.Setup(a => a.RegisterNewUser("*****@*****.**", "password")).Throws(new Exception());
//act / post
var result = controller.Register(model) as ViewResult;
}
public async Task <ActionResult> RegisterUserAsync(RegisterUserModel model)
{
model.AcceptUserAgreement = true;
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.Name,
IsActive = true,
Registered = DateTime.Now,
EmailConfirmed = true
};
try
{
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// 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(PartialView("_RegisterUserPartial", model));
}
AddUserErrors(result);
}
catch (Exception e)
{
}
}
// If we got this far, something failed, redisplay form
return(PartialView("_RegisterUserPartial", model));
}
public ActionResult Register([FromBody] RegisterUserModel userModel)
{
// map userModel to entity
var user = _mapper.Map <User>(userModel);
try {
_userService.Create(user, userModel.Password);
} catch (RequestException ex) {
if (ex.Code == UserExceptionCodes.BadPassword)
{
return(BadRequest(new { message = "Password doesn't meet requirements" }));
}
if (ex.Code == UserExceptionCodes.EmailAlreadyExists)
{
return(BadRequest(new { message = "Email already in use" }));
}
return(BadRequest(new { message = "unknown error" }));
}
return(Ok());
}
public async Task RegisterAlreadyExist_Valid()
{
var model = new UserDTO {
FirstName = "Anton", LastName = "Molch", Email = "*****@*****.**", Password = "******", UserJobCategories = new List <string>()
{
"Programmer", "QA"
}
};
_mockService.Setup(s => s.Register(model)).ReturnsAsync(ForTestComment().FirstOrDefault(u => u.Email == model.Email).ToString());
var RegisterModel = new RegisterUserModel {
FirstName = "Anton", LastName = "Molch", Email = "*****@*****.**", Password = "******", UserJobCategories = new List <string>()
{
"Programmer", "QA"
}
};
var result = await _controller.Register(RegisterModel);
Assert.IsInstanceOf <OkResult>(result);
}
public async Task <IActionResult> Register(RegisterUserModel model)
{
// The obsolete check for old custom identiy
// model.Username = model.Username.ToLower();
// if (await this.repo.UserExistsAsync(model.Username))
// return BadRequest("Username already exists");
User userToCreate = this.mapper.Map <User>(model);
var result = await this.userManager.CreateAsync(userToCreate, model.Password);
if (result.Succeeded)
{
DetailedUserModel userToReturn = this.mapper.Map <DetailedUserModel>(userToCreate);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = userToCreate.Id }, userToReturn));
}
return(BadRequest(result.Errors));
}
public void createUser(RegisterUserModel userModel)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(SQL_RegisterUser, conn);
cmd.Parameters.AddWithValue("@username", userModel.userName);
cmd.Parameters.AddWithValue("@firstName", userModel.firstName);
cmd.Parameters.AddWithValue("@lastName", userModel.lastName);
cmd.Parameters.AddWithValue("@password", userModel.password);
cmd.Parameters.AddWithValue("@salt", userModel.salt);
cmd.ExecuteNonQuery();
}
}
catch (SqlException)
{
throw;
}
}
public async Task <bool> DoesUserExist(RegisterUserModel model)
{
try
{
// Verifying if user exists
var result = await _gatewayRepository.ApiAccountsUsersExistsGetAsync(model.Email);
return(result != null);
}
catch (ApiException apiExc)
{
if (apiExc.StatusCode == 404)
{
throw new BusinessException("Cet utilisateur n'existe pas. Veuillez vous inscrire via la page précédente.");
}
else
{
throw new TechnicalException(ErrorMessages.serverErrorText + apiExc.StatusCode);
}
}
}
public static bool RegisterUser(RegisterUserModel model)
{
try
{
var stringContent = new StringContent(
JsonConvert.SerializeObject(model),
Encoding.UTF8,
"application/json");
var response = HttpClient.PostAsync(WebApiUrls.RegisterUser, stringContent)
.GetAwaiter()
.GetResult();
return(response.IsSuccessStatusCode);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public ActionResult Employee(RegisterUserModel model)
{
if (ModelState.IsValid)
{
try
{
//Insert Employee
UserBusinessLogic.CreateEmployee(model.Nama, model.TempatLahir, model.TanggalLahir, model.NoTelpon, model.Email, model.Jabatan);
//Insert User
UserBusinessLogic.CreateUser(model.Username, model.Password, model.IdRole);
}
catch (System.Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return View(model);
}
public RegisterUserViewModel()
{
userModel = new RegisterUserModel();
SaveCommand = new Command(async() =>
{
string username = userModel.Username;
string password = userModel.Password;
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(cpassword))
{
ErrorIdentified = "Hay uno o mas campos vacios. Por favor llene todos.";
}
else if (password != cpassword)
{
ErrorIdentified = "The passwords do not match";
}
else
{
await App.Current.MainPage.Navigation.PushAsync(new HomePage(null));
}
});
}
public async Task Register_Should_Return_Validation_Errors(
RegisterUserModel model,
User userToRegister,
IdentityError[] expectedErrors)
{
// Arrange
MockMapper(model, userToRegister);
_userManagerMock.Setup(userManager => userManager
.CreateAsync(userToRegister, model.Password))
.ReturnsAsync(IdentityResult.Failed(expectedErrors));
// Act
var result = await _usersService.Register(model);
// Assert
result.HasValue.ShouldBeFalse();
result.MatchNone(error => error.Messages
.ShouldAllBe(message => expectedErrors
.Any(expectedError => expectedError.Description == message)));
}
public void Map_FieldsAreEqual()
{
//Arrange
var initial = new RegisterUserModel
{
Email = "*****@*****.**",
Login = "******",
Password = "******"
};
var expected = new User
{
Email = "*****@*****.**",
Name = "Roman",
Password = "******"
};
//Act
var actual = (new UserMapper()).Map(initial);
//Assert
Assert.AreEqual(expected.Email, actual.Email);
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.Password, actual.Password);
}
public ActionResult RegisterUser(RegisterUserModel model, string[] Companies, string[] Permissions)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
Membership.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
Roles.AddUserToRoles(model.UserName, Companies);
Roles.AddUserToRoles(model.UserName, Permissions);
FormsAuthentication.SetAuthCookie(model.UserName, false /* createPersistentCookie */);
User newUser = new User();
newUser.Username = model.UserName;
newUser.UserId = secRep.GetUserId(model.UserName);
newUser = secRep.AddUser(newUser);
Account_Rep.SetUserLogin(model.UserName);
return RedirectToAction("Home", "Home");
}
else
{
ModelState.AddModelError("", ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult RegisterCompany(RegisterCompanyModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the comapny
string rolename = "u_" + model.CompanyName;
Roles.CreateRole(rolename);
// Add Company to Database
Company comp = new Company();
comp.Name = model.CompanyName;
comp.RoleId = secRep.GetRoleId(rolename);
comp.Removed = false;
comp = secRep.AddCompany(comp);
RegisterUserModel userNew = new RegisterUserModel();
userNew.CompanyRole = rolename;
return RedirectToAction("RegisterUser", "Account", new { CompanyName = model.CompanyName});
}
// If we got this far, something failed, redisplay form
return View(model);
}
