public UserCreateResponse CreateUser(UserCreateRequest createRequest)
{
var response = new UserCreateResponse();
var validationErrors = _validation.createRequestValidation.Validate(createRequest);
var DBErrors = new List <DatabaseErrors>();
if (validationErrors.Count != 0 && validationErrors != null)
{
response.ValidationErrors = validationErrors;
}
else
{
try
{
var user = AddUserToDB(createRequest);
response.User = user;
}
catch (NullReferenceException)
{
DBErrors.Add(DatabaseErrors.DB_CONNECTION_FAILED);
}
response.DBErrors = DBErrors;
}
return(response);
}
public UserResponse Execute(UserCreateRequest createRequestData)
{
string createdUserId = null;
try
{
createdUserId = _authGateway.CreateUser(createRequestData);
}
catch (AmazonCognitoIdentityProviderException e)
{
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
return(null);
}
var userDomain = SaveNewUser(createRequestData, createdUserId);
var userCreateResponse = new UserResponse
{
Id = userDomain.Id,
CreatedAt = userDomain.CreatedAt,
Email = createRequestData.Email,
Name = createRequestData.Name,
SubId = createdUserId,
Status = userDomain.Status
};
return(userCreateResponse);
}
public async Task Can_update_user_metadata()
{
// Add a new user with metadata
var newUserRequest = new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******",
AppMetadata = new
{
a = 1,
b = 2
},
UserMetadata = new
{
c = 3,
d = 4
}
};
var newUserResponse = await apiClient.Users.CreateAsync(newUserRequest);
// Do some updating
var updateUserRequest = new UserUpdateRequest();
updateUserRequest.AppMetadata = new ExpandoObject();
updateUserRequest.AppMetadata.IsSubscribedTo = "1";
var updateUserResponse = await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest);
// Get the user to ensure the metadata was set
var user = await apiClient.Users.GetAsync(newUserResponse.UserId);
// Delete the user
await apiClient.Users.DeleteAsync(user.UserId);
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_managementApiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
// We will need a connection to add the users to...
_connection = await _managementApiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
_newUser = await _managementApiClient.Users.CreateAsync(newUserRequest);
_authenticationApiClient = new TestAuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL"));
}
public async Task <IActionResult> CreateUser([FromBody] UserCreateRequest userRequest)
{
if (string.IsNullOrEmpty(userRequest.Email) || string.IsNullOrEmpty(userRequest.DisplayName) || string.IsNullOrEmpty(userRequest.Password))
{
return(BadRequest());
}
GoNorthUser user = new GoNorthUser {
UserName = userRequest.Email, Email = userRequest.Email, DisplayName = userRequest.DisplayName
};
IdentityResult result = await _userCreator.CreateUser(Url, Request.Scheme, userRequest.DisplayName, userRequest.Email, userRequest.Password, string.Empty);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _timelineService.AddTimelineEntry(null, TimelineEvent.NewUser, user.Email);
return(Ok(user.Email));
}
else
{
return(ReturnErrorResultFromIdentityResult(result));
}
}
public async Task <HttpResponseMessage> Create(UserCreateRequest userCreateRequest)
{
int newId;
if (userCreateRequest == null)
{
ModelState.AddModelError(" ", "missing body data");
}
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
try
{
newId = await userService.Create(userCreateRequest);
}
catch (DuplicateEmailException)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new ErrorResponse("Email already in use")));
}
return(Request.CreateResponse(HttpStatusCode.Created, new ItemResponse <int> {
Item = newId
}));
}
public async Task LoadTestAddUsers()
{
string token = await GenerateManagementApiToken();
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
var connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
for (int i = 1; i <= 200; i++)
{
TestContext.Out.WriteLine($"Adding user {i}");
var newUserRequest = new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******"
};
await apiClient.Users.CreateAsync(newUserRequest);
}
await apiClient.Connections.DeleteAsync(connection.Id);
}
public ActionResult Create(UserCreateRequest model)
{
if (ModelState.IsValid == false)
{
return(View(model));
}
if (_userManageService.ExistsUser(model.UserName) == false)
{
_userManageService.Create(new User
{
UserName = model.UserName,
UserPwd = model.Password.ToMd5(),
Nick = model.Nick,
CreateTime = DateTime.Now,
IsEnable = model.IsEnable
});
return(RedirectToAction("Index"));
}
ModelState.AddModelError("_error", "登录账号已存在");
return(View(model));
}
public async Task <IResultResponse> Create(UserCreateRequest request)
{
IResultResponse response = new ResultResponse();
User user = _mapper.Map <User>(request);
UserValidator validator = new UserValidator();
var result = await validator.ValidateAsync(user);
if (result.IsValid)
{
User userExist = await _unitOfWork.UserRepository.GetByDocument(user.Document.Value);
if (userExist == null)
{
await _unitOfWork.UserRepository.Create(user);
_logger.LogInformation(LoggingEvent.Create, "Usuário criado com sucesso");
}
else
{
response.AddMessage($"Usuário com o Cpf {request.Document} já está cadastrado");
_logger.LogInformation(LoggingEvent.Create, $"Usuário com o Cpf {request.Document} já está cadastrado");
}
}
else
{
response.AddMessage(result.Errors);
_logger.LogInformation(LoggingEvent.Create, $"Encontrado algum erro de validação");
}
return(response);
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
_authenticationApiClient = new TestAuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL"));
// We will need a connection to add the users to...
_connection = await _apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = "Temp-Int-Test-" + MakeRandomName(),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
_user = await _apiClient.Users.CreateAsync(newUserRequest);
// Now try and sign in with a wrong password until we get "too many attempts"
bool userBlocked = false;
int attempts = 0;
do
{
try
{
attempts++;
await _authenticationApiClient.GetTokenAsync(new ResourceOwnerTokenRequest
{
ClientId = GetVariable("AUTH0_CLIENT_ID"),
ClientSecret = GetVariable("AUTH0_CLIENT_SECRET"),
Realm = _connection.Name,
Scope = "openid",
Username = _user.Email,
Password = "******"
});
}
catch (RateLimitApiException)
{
await Task.Delay(1000);
}
catch (ErrorApiException ex)
{
if (ex.ApiError.Error == "too_many_attempts")
{
userBlocked = true;
}
}
} while (!userBlocked && attempts < 20); // Add failsafe to stop if we go over 20 attempts. User should be blocked by then, but just to make sure...
}
public async Task Test_users_crud_sequence()
{
// Get all the users
var usersBefore = await apiClient.Users.GetAllAsync();
// Add a new user
var newUserRequest = new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******"
};
var newUserResponse = await apiClient.Users.CreateAsync(newUserRequest);
newUserResponse.Should().NotBeNull();
newUserResponse.Email.Should().Be(newUserRequest.Email);
// Get all the users again. Verify we now have one more
var usersAfter = await apiClient.Users.GetAllAsync();
usersAfter.Count.Should().Be(usersBefore.Count + 1);
// Update the user
var updateUserRequest = new UserUpdateRequest
{
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
VerifyEmail = false
};
var updateUserResponse = await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest);
updateUserResponse.Should().NotBeNull();
updateUserResponse.Email.Should().Be(updateUserRequest.Email);
// Ensure firstname, lastname etc are ignored and not sent to Auth0. If not, the following will throw an exception
updateUserRequest = new UserUpdateRequest
{
EmailVerified = true, // We need to pass in at least one property, so we set this as the other properties below will not be serialized
FirstName = "firstname",
LastName = "lastname",
NickName = "nickname",
FullName = "fullname",
Picture = "picture url.."
};
await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest);
// Get a single user
var user = await apiClient.Users.GetAsync(newUserResponse.UserId);
user.Should().NotBeNull();
user.Email.Should().Be(updateUserResponse.Email);
// Delete the user and ensure we get an exception when trying to fetch them again
await apiClient.Users.DeleteAsync(user.UserId);
Func <Task> getFunc = async() => await apiClient.Users.GetAsync(user.UserId);
getFunc.ShouldThrow <ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_user");
}
public ActionResult Create()
{
var viewModel = new UserCreateRequest {
IsEnable = true
};
return(View(viewModel));
}
public UserCreateResponse Create([FromBody] UserCreateRequest request)
{
var response = new UserCreateResponse();
response.Id = _facade.Create(request.User);
return(response);
}
public async Task <Guid> Create(UserCreateRequest request)
{
var user = UserAggregate.CreateFromRequest(request);
await _repo.Add(user);
return(user.Id);
}
public IActionResult Register(RegisterUserViewModel model)
{
var username = model.UserName;
var request = new UserCreateRequest(username);
var response = bus.Handle(request);
return(Redirect("Index"));
}
public OperationResult <int> Post([FromBody] UserCreateRequest dto)
{
return(_userService.Create(new UserCreateDto
{
BirthDate = dto.BirthDate,
FirstName = dto.FirstName,
LastName = dto.LastName
}));
}
public bool Create(UserCreateRequest entity)
{
string gmail = entity.Gmail;
string gmailToken = entity.GmailToken;
string facebook = entity.Facebook;
string facebookToken = entity.FacebookToken;
string name = entity.Name;
string img = entity.Img;
string address = entity.Address;
string phone = entity.Phone;
DateTime dob = entity.BirthDate;
if (gmail == null && facebook == null)
{
return(false);
}
User newEntity = new User();
newEntity.Name = name;
newEntity.Address = address;
newEntity.BirthDate = dob;
newEntity.CreatedDate = DateTime.Now;
newEntity.Img = img;
newEntity.Phone = phone;
newEntity.Gmail = gmail;
newEntity.GmailToken = gmailToken;
newEntity.Facebook = facebook;
newEntity.FacebookToken = facebookToken;
//facebook
if (util.ValidRangeLengthInput(facebook, 1, 100) && util.ValidRangeLengthInput(facebookToken, 1, 500))
{
if (!_userRepo.ExistedFacebook(facebook))
{
User existed = _userRepo.GetAll().FirstOrDefault(e => e.Facebook.Equals(facebook) || e.FacebookToken.Equals(facebookToken));
if (existed == null)
{
return(_userRepo.Create(newEntity));
}
}
}
//gmail
if (util.ValidRangeLengthInput(gmail, 1, 100) && util.ValidRangeLengthInput(gmailToken, 1, 500))
{
if (!_userRepo.ExistedGmail(gmail))
{
User existed = _userRepo.GetAll().FirstOrDefault(e => e.Gmail.Equals(gmail) || e.GmailToken.Equals(gmailToken));
if (existed == null)
{
return(_userRepo.Create(newEntity));
}
}
}
return(false);
}
public async Task <IWrappedResponse> Create(UserCreateRequest request)
{
var cmd = ServiceCommand <User, Rules.User.Create.MainRule>
.Create(_serviceProvider)
.When(new Rules.User.Create.MainRule(request))
.Then(CreateAction);
return(await cmd.Execute());
}
public IActionResult CreateUser([FromBody] UserCreateRequest request)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
return(Created("", request));
}
public async Task <UserResponse> CreateAsync(UserCreateRequest req)
{
return(await Task.FromResult(new UserResponse
{
Id = req.Id,
Name = req.Name,
Code = req.Code,
}));
}
public async Task <ActionResult <UserGetViewModel> > PostCurrent([FromBody] UserCreateRequest request)
{
var model = _mapper.Map <UserCreateModel>(request);
model.Id = User.UserId().Value;
var user = await _userService.CreateUserAsync(model);
return(Ok(_mapper.Map <UserGetViewModel>(user)));
}
public async Task <IActionResult> CreateUser([FromBody] UserCreateRequest userCreateRequestDto)
{
var user = await _userService.Create(userCreateRequestDto).ConfigureAwait(false);
return(Ok(new UserCreateResponse
{
UserId = user.Id,
Username = user.Username
}));
}
public Task <UserResponse> CreateAsync(UserCreateRequest request)
{
return(base.ExecuteWithExceptionHandledOperation(async() =>
{
var user = Mapper.Map <User>(request);
_userRepository.Add(user);
await _userRepository.SaveChangeAsync();
return Mapper.Map <UserResponse>(user);
}));
}
public async override Task <UserResponse> Register(UserCreateRequest request, ServerCallContext context)
{
var isRegistred = await _userService.Register(request.Username, request.Password,
request.FirstName, request.LastName);
return(new UserResponse
{
Status = isRegistred ? StatusCode.Ok : StatusCode.Error
});
}
public async Task <User> Create(UserCreateRequest dto)
{
var user = _userFactory.Create(dto.Username, dto.Name, dto.Password, dto.Email);
await _context.AddAsync(user).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(user);
}
public ActionResult <User> PostUser(UserCreateRequest entity)
{
bool success = _ser.Create(entity);
if (success)
{
return(Ok(entity));
}
return(Problem("Create failed!"));
}
public ActionResult <User> PostAuthentication(UserCreateRequest entity)
{
var user = _ser.Authentication(entity);
if (user == null)
{
return(Problem("Server is maintain. Please try later"));
}
return(Ok(user));
}
public void CreateUser(UserCreateRequest user)
{
var result = ValidateUser(user);
if (result)
{
var newUser = new Users(user.Name, user.Email, user.Password, user.Role);
_repository.CreateUser(newUser);
}
}
public ActionResult Create()
{
BindSelectListDataSource();
var viewModel = new UserCreateRequest {
IsEnable = true
};
return(View(viewModel));
}
public UserCreateResponse Post([FromBody] UserCreateRequest Model)
{
// TODO: insert the user in the db and return the UserId
int userId = this.GetFakeUserId();
return(new UserCreateResponse
{
UserId = userId
});
}
