public CreateNewUserResponse Create(CreateNewUserRequest request)
{
try
{
ValidateRequest(request);
}
catch (ValidationException)
{
return(null);
}
var response = _users.FilterBy(x => x.UserName == request.UserName).FirstOrDefault();
if (response != null)
{
throw new Exception($"User with username: {request.UserName} already exists.");
}
var user = new User
{
FirstName = request.FirstName,
LastName = request.LastName,
UserName = request.UserName,
AccountType = AccountType.Internal,
Password = request.Password.Hash(),
};
_users.InsertOne(user);
return(new CreateNewUserResponse {
User = user
});
}
public async Task <CreateNewUserResponse> CreateNewUser([FromBody] CreateNewUserRequest request)
{
var user = await _userService.CreateUser(request);
return(new CreateNewUserResponse
{
});
}
public async Task <ActionResult> Post(UsersControllerPostDto dto)
{
var command = new CreateNewUserRequest(dto.UserId);
await this.mediator.Send(command);
return(this.Accepted());
}
private void ValidateRequest(CreateNewUserRequest request)
{
var validationResults = new List <ValidationResult>();
if (!Validator.TryValidateObject(request, new ValidationContext(request), validationResults))
{
throw new ValidationException(nameof(request));
}
}
public IActionResult Create(CreateNewUserRequest request)
{
var res = _userService.Create(request);
if (res == null)
{
return(BadRequest(new { message = "Could not create user" }));
}
return(Ok(res));
}
public IActionResult CreateUser([FromBody] CreateNewUserRequest request)
{
var rs = _userLogic.CreateUser(request);
if (rs)
{
return(Ok());
}
return(NotFound());
}
public ServiceResponse <UserResponse> CreateNewUser(CreateNewUserRequest request)
{
var user = new User()
{
FirstName = request.FirstName,
LastName = request.LastName
};
_userRepository.Save(user);
return(new ServiceResponse <UserResponse>()
{
Result = user.MapToResponse(),
IsSuccess = true
});
}
public void Post([FromBody] CreateNewUserRequest newUserRequest)
{
if (newUserRequest == null)
{
return;
}
var up = new Domain.User.UserProfile
{
FirstName = newUserRequest.FirstName,
LastName = newUserRequest.LastName,
Address = newUserRequest.Address,
DateOfBirth = DateTime.Now,
};
var user = new Domain.User.User
{
EmailAddress = newUserRequest.EmailAddress,
UserRoleId = newUserRequest.RoleId,
UserProfile = up
};
_userService.Add(user);
}
public async Task <User> CreateUser(CreateNewUserRequest request)
{
//Should verify the request here and return validation errors
var user = await _ctx.Database.GetDbConnection().QueryFirstOrDefaultAsync <User>(@"
insert into public.users
(username,passwordHash,firstName,lastName,email,phoneNumber)
values
(@Username,@PasswordHash,@FirstName,@LastName,@Email,@PhoneNumber)
returning *;
",
new
{
Username = request.Username,
PasswordHash = _passwordService.Hash(request.Password),
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
PhoneNumber = request.PhoneNumber
});
return(user);
}
public async Task <IActionResult> CreateUser([FromBody] CreateNewUserRequest request)
{
var userFilter = Builders <ApplicationUser> .Filter.Where(x => x.Email.Equals(request.Email.Trim().ToLower()));
var userAlreadyExists = await _mongoDbService.GetCollection <ApplicationUser>(Collections.Users)
.Find(userFilter).AnyAsync();
if (userAlreadyExists)
{
throw new CustomException("The entered email is already in use.");
}
var newUser = new ApplicationUser()
{
FullName = request.FullName.Trim(),
Address = request.Address.Trim(),
PhoneNumber = request.PhoneNumber.Trim(),
Email = request.Email.Trim().Normalize().ToLowerInvariant(),
UserName = request.Email.Trim().Normalize().ToLowerInvariant(),
Enabled = true
};
var password = Guid.NewGuid().ToString("n").Substring(0, 8).ToLower();
var createResult = await _userManager.CreateAsync(newUser, password);
var addToRoleResult = await _userManager.AddToRoleAsync(newUser, request.Role.ToLower());
if (!(createResult.Succeeded && addToRoleResult.Succeeded))
{
throw new InvalidOperationException();
}
string appBaseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{HttpContext.Request.PathBase}";
var emailBody = $"Your account has been successfully created. Password: <b>[ {password} ].</b> To access the site click on the following <a target='_blank' href='{appBaseUrl}'>link.</a>";
await _emailService.SendAsync(newUser.Email, "Basic Sales System", emailBody);
return(new SuccessResult());
}
private static bool handleCreateNewUser(ClientSession session)
{
bool success = false;
CreateNewUserRequest request = (CreateNewUserRequest)session.Reader.GetMessage();
var userInfo = request.username;
if (session.loginUsername.isAdmin)
{
success = db.createNewUser(userInfo.name, userInfo.password, request.makeAdmin);
if (!success)
{
ErrorResponse resp = new ErrorResponse(CreateNewUserResponse.MessageID,
"Another user with this username already exists");
byte[] respPayload = MessageUtils.SerializeMessage(resp).GetAwaiter().GetResult();
session.Client.Client.Send(respPayload);
return(false);
}
}
CreateNewUserResponse response = new CreateNewUserResponse(success);
byte[] payload = MessageUtils.SerializeMessage(response).GetAwaiter().GetResult();
session.Client.Client.Send(payload);
return(success);
}
public bool CreateNewUser(CreateNewUserRequest userRequest)
{
throw new NotImplementedException();
}
public ActionResult Register(RegisterModel model)
{
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)
{
// Put into default Role "RegisteredUser". "Administrators" are flagged manually
// in the database.
_accountRepository.AssignUserToRole(model.UserName, "RegisteredUser");
// Add user data to the custom model database
var snippetData = new SnippetCacheDataServiceClient();
var aspnetData = new AccountRepository(snippetData);
const string defaultImagePath = "~/Content/images/default_user_avatar.png";
{
using (
var avatarStream =
new FileStream(System.Web.HttpContext.Current.Server.MapPath(defaultImagePath),
FileMode.Open))
{
var buffer = new byte[avatarStream.Length];
avatarStream.Read(buffer, 0, (int) avatarStream.Length);
var request = new CreateNewUserRequest
{
LoginName = model.UserName,
Email = model.Email,
FormsAuthId = aspnetData.GetUserGuid(model.UserName),
//AvatarImage = Encoding.UTF8.GetBytes(Url.Content("~/Content/images/default_user_avatar.png"))
AvatarImage = buffer
};
CreateNewUserResponse response = snippetData.CreateNewUser(request);
if (!response.Success)
{
const string message = "Failure creating new user.";
var e = new Exception(response.FailureInformation);
Logger.LogError(message, e);
throw new AuthenticationException(message, e);
}
// Create welcome message for user's inbox
_managerService.CreateNewUserNotification(new NotificationDTO
{
NotificationType_Id = 1,
User_FormsAuthId = response.FormsAuthId,
User_Id = response.Id,
Text = "Welcome to SnippetCache!",
DateCreated = DateTime.UtcNow
});
}
FormsAuthentication.SetAuthCookie(model.UserName, false);
}
;
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("Error", "Please correct any issues and try again.");
}
// If we got this far, something failed, redisplay form
return View(model);
}
