public ActionResult Create(UsersCreateViewModel model)
{
if (this.ModelState.IsValid)
{
var request = new CreateUserRequest
{
User = new UserDto
{
UserName = model.Email,
FirstName = model.FirstName.Trim(),
LastName = model.LastName.Trim(),
Email = model.Email
}
};
var response = this.userService.CreateUser(request);
if (response.Status == StatusCode.OK)
{
this.TempData["SuccessMessage"] = string.Format("You have successfully added '{0} {1}'.", request.User.FirstName, request.User.LastName);
return this.RedirectToAction("Index");
}
else if (response.Status == StatusCode.BadRequest)
{
this.ModelState.AddModelError(string.Empty, $"Your account was not created for the following reason: {this.GetErrorMessage(response.CreateAccountStatus)}");
}
else
{
this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError);
}
}
return View(model);
}
public async Task<HttpResponseMessage> Create([FromBody] UserDto User)
{
var request = new CreateUserRequest()
{
User = User
};
UserDto registeredUser = await _mediator.ExecuteAsync(request).ConfigureAwait(false);
return Request.CreateResponse(HttpStatusCode.Created, new { Id = registeredUser.Id, rating = registeredUser.Rating });
}
public CreateUserResponse CreateUser(CreateUserRequest request)
{
CreateUserResponse response = new CreateUserResponse();
AuthToken authToken = null;
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AuthToken, "Auth Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AntiForgeryToken, "Anti Forgery Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.FirstName, "First Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.LastName, "Last Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "User Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.EmailAddress, "Email Address");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Password, "Password");
Common.Helpers.ValidationHelper.ValidateUsername(request.Username);
Common.Helpers.ValidationHelper.ValidateStringLength(request.FirstName, "First Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.LastName, "Last Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateMinStringLength(request.Username, "User Name", Constants.MinUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.Username, "User Name", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.EmailAddress, "Email Address", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.Password, "Password", Constants.MaxPasswordLength);
Common.Helpers.ValidationHelper.ValidateEmailAddress(request.EmailAddress);
ValidationHelper.ValidatePassword(request.Password);
if (!UserController.ValidateSession(request.AuthToken, out authToken))
{
throw new AuthenticationException("Authentication failed.");
}
UserController.ValidateAntiForgeryToken(request.AntiForgeryToken, authToken);
UserController.CreateUser(request.Username, request.Password, request.EmailAddress, request.FirstName, request.LastName, authToken, false);
}
catch (AuthenticationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, authToken == null ? null : authToken.Username);
throw new WebFaultException<string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return response;
}
public void TestCreateUserRequest()
{
string json = @"{
""guid"": ""guid-9ca6119b-7311-48fa-96f8-6ab604dca950""
}";
CreateUserRequest request = new CreateUserRequest();
request.Guid = "guid-9ca6119b-7311-48fa-96f8-6ab604dca950";
string result = JsonConvert.SerializeObject(request, Formatting.None);
Assert.AreEqual(TestUtil.ToUnformatedJsonString(json), result);
}
public static async Task<HttpResponseMessage> Register(string user, string password, string fullName)
{
using (var client = new HttpClient())
{
var uri = UriHelper.GetUri("users");
var data = new CreateUserRequest()
{
UserName = user,
Password = password,
FullName = fullName
};
var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
return await client.PostAsync(uri, content);
}
}
public ActionResult CreateUser(CreateUserRequest req)
{
CreateUserResponse response = new CreateUserResponse();
UserModel model = new UserModel()
{
name = req.Name,
City = req.City,
IsActive = true,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
var res = model.CreateUser(model, dbFactory);
response.city = req.City;
response.name = req.Name;
response.id = res;
response.IsSuccess = true;
return(Json(response));
}
public override Task <CreateUserResponse> CreateUser(CreateUserRequest request, ServerCallContext context)
{
var user = new User
{
Uuid = Guid.NewGuid().ToString(),
Name = request.Name,
Email = request.Email,
PhoneNumber = request.PhoneNumber
};
usersList.Add(user);
var response = new CreateUserResponse
{
User = user
};
return(Task.FromResult(response));
}
public async Task Then_The_Command_Handled_And_Created_Returned(
Guid id,
CreateUserRequest request,
[Frozen] Mock <IMediator> mediator,
[Greedy] UsersController controller)
{
var actual = await controller.CreateUser(id, request) as CreatedResult;
mediator.Verify(x =>
x.Send(It.Is <CreateUserCommand>(c =>
c.Email.Equals(request.Email) &&
c.Id.Equals(id) &&
c.FirstName.Equals(request.FirstName) &&
c.LastName.Equals(request.LastName) &&
c.Password.Equals(request.Password) &&
c.ConfirmationEmailLink.Equals(request.ConfirmationEmailLink)
), CancellationToken.None), Times.Once);
actual.StatusCode.Should().Be((int)HttpStatusCode.Created);
}
public async Task ShouldCreateUser()
{
var createUserRequest = new CreateUserRequest
{
Email = "*****@*****.**",
Name = "Caio Eduardo Ragazzi Gemignani",
Password = "******"
};
var command = new CreateUserCommand(createUserRequest);
var result = await SendAsync(command);
result.Data.Email.Should().BeOfType(typeof(string));
result.Data.Email.Should().Be(createUserRequest.Email);
result.Data.Id.Should().NotBeEmpty();
result.Data.Name.Should().BeOfType(typeof(string));
result.Data.Name.Should().Be(createUserRequest.Name);
}
public async Task ShoudlReturnUserAlreadyExistsError()
{
var createUserRequest = new CreateUserRequest
{
Email = "*****@*****.**",
Name = "Caio Eduardo Ragazzi Gemignani",
Password = "******"
};
var command = new CreateUserCommand(createUserRequest);
await SendAsync(command);
var result = await SendAsync(command);
result.Errors.Should().NotBe(null);
result.Errors.data.Should().Contain("Already exists");
result.IsOk.Should().BeFalse();
result.Data.Should().BeNull();
}
public async Task <User> Add(CreateUserRequest CreateUserRequest)
{
var user = mapper.Map <CreateUserRequest, User>(CreateUserRequest);
user.IsActive = true;
user.LastPasswordChangedDate = DateTime.UtcNow;
user.CreateDate = DateTime.UtcNow;
try
{
await context.User.AddAsync(user);
await context.SaveChangesAsync();
foreach (var userUserRole in CreateUserRequest.UserRoles)
{
user.UserUserRole.Add(new UserUserRole()
{
UserId = user.Id,
UserRoleId = userUserRole.UserRoleId
});
}
foreach (var userFields in CreateUserRequest.UserFields)
{
user.UserField.Add(new UserField()
{
FieldTypeName = userFields.FieldTypeName,
FieldData = userFields.FieldData
});
}
context.User.Update(user);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
// TODO: log
throw ex;
}
return(user);
}
public async Task CreateUserCommand_DoesNot_create_user_when_email_exists_in_users_db()
{
//Arrange
var request = new CreateUserRequest {
Name = "test", Email = "*****@*****.**", Salary = 2000, Expenses = 2000
};
var response = new CreateUserResponse();
using (var db = MockDbContext())
{
db.Users.RemoveRange(db.Users);
db.SaveChanges();
var command = new CreateUserCommand(request);
var handler = new CreateUserCommandHandler(db);
//Act
response = await handler.Handle(command, CancellationToken.None);
}
//Assert
response.Status.Should().Contain("Success");
response.Id.Should().NotBeEmpty();
//Arrange 2
request = new CreateUserRequest {
Name = "new user", Email = "*****@*****.**", Salary = 3000, Expenses = 500
};
response = new CreateUserResponse();
using (var db = MockDbContext())
{
var command = new CreateUserCommand(request);
var handler = new CreateUserCommandHandler(db);
//Act
response = await handler.Handle(command, CancellationToken.None);
}
//Assert
response.Status.Should().Contain("User cannot be created");
response.Id.Should().BeEmpty();
}
public async Task <bool> CreateUser(CreateUserRequest request)
{
var isExist = await _userRepository.GetUserByMailAsync(request.Email);
if (isExist != null)
{
_logger.LogInformation("Girilen mail ile kayıt zaten mevcut");
throw new ApiException(new Error
{
Message = "Bu e-mail hesabı ile kayıtlı bir kullanıcı sistemde mevcut"
});
}
var passTuple = PassHasherGenerator.HashPassword(request.Password, null);
var newUser = new User(request, passTuple);
await _userRepository.Create(newUser);
return(true);
}
public async Task <UserModel> CreateAsync(CreateUserRequest request, CancellationToken token)
{
UserDbModel user = new UserDbModel
{
UserName = request.UserName,
PasswordHash = request.Password,
FirstName = request.FirstName,
LastName = request.LastName,
PhoneNumber = request.Phone,
Email = request.Email,
Photo = request.Photo,
CreationDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
ModificationDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
};
var result = await _repository.CreateAsync(user);
return(user.ConvertTo <UserModel>());
}
public async Task <ActionResult> ConfirmEmail(string Token, string Email)
{
ApplicationUser user = this.UserManager.FindById(Token);
if (user != null)
{
if (user.Email == Email)
{
user.EmailConfirmed = true;
await UserManager.UpdateAsync(user);
// Solo se crea el registro en la tabla de usuarios de la aplicación
// cuando el email fue confirmado.
var userService = new UserService();
var request = new CreateUserRequest
{
User = new User
{
Name = user.UserName,
AspNetUserId = user.Id,
Email = user.Email
}
};
var response = userService.CreateUser(request);
UserManager.AddToRole(user.Id, RoleTypes.User.ToString());
return(View());
}
else
{
return(RedirectToAction("Confirm", "Account", new { Email = user.Email }));
}
}
else
{
return(RedirectToAction("Confirm", "Account", new { Email = "" }));
}
}
public ActionResult Register(Register model)
{
if (ModelState.IsValid)
{
//Create user request
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
var appAccessToken = WebUtils.GetVaultSecret("AppConnectionKey");
CreateUserRequest request = new CreateUserRequest(connection, appAccessToken);
request.Email = model.Email;
request.FirstName = model.FirstName;
request.LastName = model.LastName;
request.Nicknane = model.Nicknane;
request.Password = model.password1;
CreateUserResponse response = request.Send();
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
TempData["Success"] = "You have successfully registered an account. You can now sign in below.";
return(RedirectToAction("Login", "Account"));
}
else
{
if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
//TODO: Parse the actual response error
TempData["Errors"] = "Bad request";
}
else
{
TempData["Errors"] = "There was an error processing your request. Please try again.";
}
return(View(model));
}
}
else
{
return(View(model));
}
}
public ManagerResponse <CreateUserResult, CommerceUser> RegisterUser(RegisterUserInputModel inputModel)
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
Assert.ArgumentNotNullOrEmpty(inputModel.UserName, nameof(inputModel.UserName));
Assert.ArgumentNotNullOrEmpty(inputModel.Password, nameof(inputModel.Password));
if (StorefrontContext.Current == null)
{
throw new InvalidOperationException("Cannot be called without a valid storefront context.");
}
CreateUserResult result;
// Attempt to register the user
try
{
var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, StorefrontContext.Current.ShopName);
result = CustomerServiceProvider.CreateUser(request);
result.WriteToSitecoreLog();
if (result.Success && result.CommerceUser == null && !result.SystemMessages.Any())
{
// Connect bug: This is a work around to a Connect bug. When the user already exists,connect simply aborts the pipeline but
// does not set the success flag nor does it return an error message.
result.Success = false;
result.SystemMessages.Add(new SystemMessage
{
Message = DictionaryPhraseRepository.Current.Get("/System Messages/Accounts/User Already Exists", "User name already exists. Please enter a different user name.")
});
}
}
catch (MembershipCreateUserException e)
{
result = new CreateUserResult {
Success = false
};
result.SystemMessages.Add(new SystemMessage {
Message = ErrorCodeToString(e.StatusCode)
});
}
return(new ManagerResponse <CreateUserResult, CommerceUser>(result, result.CommerceUser));
}
public async Task <IActionResult> CreateUser(CreateUserRequest request)
{
var result = new CreateUserRequestValidation().Validate(request);
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
ModelState.AddModelError(failure.PropertyName, failure.ErrorMessage);
}
var errors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage)).ToList();
_telemetryClient.TrackTrace(new TraceTelemetry(
$"CreateUserRequest validation failed: {string.Join(Separator, errors)}",
SeverityLevel.Error));
return(BadRequest(ModelState));
}
try
{
var adUserAccount =
await _userAccountService.CreateUserAsync(request.FirstName, request.LastName,
request.RecoveryEmail, request.IsTestUser);
var response = new NewUserResponse
{
UserId = adUserAccount.UserId,
Username = adUserAccount.Username,
OneTimePassword = adUserAccount.OneTimePassword
};
return(CreatedAtRoute("GetUserByAdUserId", new { userId = adUserAccount.UserId }, response));
}
catch (UserExistsException e)
{
return(new ConflictObjectResult(new
{
Message = "User already exists",
Code = "UserExists",
e.Username
}));
}
}
public async Task <IActionResult> CreateAsync(CreateUserRequest request)
{
if (request == null)
{
return(BadRequest());
}
// AutoMap the request into a new IdentityUser
var identityUser = Mapper.Map <IdentityUser>(request);
IdentityResult identityResult;
try
{ identityResult = await UserManager.CreateAsync(identityUser, request.Password); }
catch (Exception ex)
{
var errorMessage = Utils.Write(UserCreatedFailedTemplate, identityUser.NormalizedUserName);
Log.Logger.Error(ex, errorMessage);
return(BadRequest(errorMessage));
}
if (identityResult.Succeeded)
{
var logMessage = Utils.Write(UserCreatedTemplate, identityUser.NormalizedUserName);
Log.Logger.Information(logMessage);
return(Ok(logMessage));
}
else
{
var errorMessage = Utils.Write(UserCreatedFailedTemplate, identityUser.NormalizedUserName);
var badRequest = BadRequest(errorMessage);
// Add additional details to internal logging - but not to the BadRequest message.
for (int i = 0; i < identityResult.Errors.Count(); i++)
{
errorMessage += string.Format(UserCreatedAdditionalErrorTemplate, i, identityResult.Errors.ElementAt(i).Description);
}
Log.Logger.Error(errorMessage);
return(badRequest);
}
}
public async Task ShouldCreateUserProfile()
{
string hdid = "1234567890123456789012345678901234567890123456789012";
string token = "Fake Access Token";
string userId = "1001";
UserProfile userProfile = new UserProfile
{
HdId = hdid,
AcceptedTermsOfService = true
};
CreateUserRequest createUserRequest = new CreateUserRequest
{
Profile = userProfile
};
RequestResult <UserProfileModel> expected = new RequestResult <UserProfileModel>
{
ResourcePayload = UserProfileModel.CreateFromDbModel(userProfile),
ResultStatus = Common.Constants.ResultType.Success
};
Mock <IHttpContextAccessor> httpContextAccessorMock = CreateValidHttpContext(token, userId, hdid);
Mock <IUserProfileService> userProfileServiceMock = new Mock <IUserProfileService>();
userProfileServiceMock.Setup(s => s.CreateUserProfile(createUserRequest, It.IsAny <Uri>(), It.IsAny <string>())).Returns(expected);
Mock <IUserEmailService> emailServiceMock = new Mock <IUserEmailService>();
Mock <IUserSMSService> smsServiceMock = new Mock <IUserSMSService>();
UserProfileController service = new UserProfileController(
userProfileServiceMock.Object,
httpContextAccessorMock.Object,
emailServiceMock.Object,
smsServiceMock.Object
);
IActionResult actualResult = await service.CreateUserProfile(hdid, createUserRequest);
Assert.IsType <JsonResult>(actualResult);
Assert.True(((JsonResult)actualResult).Value.IsDeepEqual(expected));
}
/// <summary>
/// Registers the user.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager result where the user is returned as the Result.
/// </returns>
public virtual ManagerResponse <CreateUserResult, CommerceUser> RegisterUser([NotNull] CommerceStorefront storefront, RegisterUserInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(inputModel, "inputModel");
Assert.ArgumentNotNullOrEmpty(inputModel.UserName, "inputModel.UserName");
Assert.ArgumentNotNullOrEmpty(inputModel.Password, "inputModel.Password");
CreateUserResult result;
// Attempt to register the user
try
{
var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, storefront.ShopName);
result = this._customerServiceProvider.CreateUser(request);
// if (!result.Success)
// {
// Helpers.LogSystemMessages(result.SystemMessages, result);
// }
// else
if (result.Success && result.CommerceUser == null && result.SystemMessages.Count() == 0)
{
// Connect bug: This is a work around to a Connect bug. When the user already exists,connect simply aborts the pipeline but
// does not set the success flag nor does it return an error message.
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.UserAlreadyExists)
});
}
}
catch (MembershipCreateUserException e)
{
result = new CreateUserResult {
Success = false
};
result.SystemMessages.Add(new Commerce.Services.SystemMessage {
Message = ErrorCodeToString(e.StatusCode)
});
}
return(new ManagerResponse <CreateUserResult, CommerceUser>(result, result.CommerceUser));
}
/// <summary>
/// Creates the user.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <APIResponse> CreateUser(CreateUserRequest request)
{
try
{
var client = httpClientFactory.CreateClient(IdentityServiceOperation.serviceName);
var param = JsonConvert.SerializeObject(request);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
var response = await client.PostAsync(servicesConfig.Identity + IdentityServiceOperation.CreateUser(), contentPost);
return(JsonConvert.DeserializeObject <APIResponse>(await response.Content.ReadAsStringAsync()));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'CreateUser()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
public IActionResult Post([FromBody] CreateUserRequest userRequest)
{
try
{
var user = userUsesCase.Create(userRequest).ToCreateUserResponse();
return(StatusCode((int)HttpStatusCode.Created, user));
}
catch (FormatException)
{
return(BadRequest(new { message = "Photo invalid" }));
}
catch (DbUpdateException)
{
return(BadRequest(new { message = "Email has already been registered" }));
}
catch (System.Exception)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
private void OnCreateUserRequest(SyncFilesRequest syncFilesRequest, CreateUserRequest request, HttpRequestEventArgs arg3)
{
foreach (var availableFolder in request.AvailableFolders)
{
switch (availableFolder.AvailableFolderAction)
{
case AvailableFolderAction.Add:
_userTableDataBase.Add(request.Login, request.Password, availableFolder.Path);
break;
case AvailableFolderAction.Remove:
_userTableDataBase.Remove(request.Login, request.Password, availableFolder.Path);
_syncTableDataBase.RemoveSyncStatesByAvailableFolder(request.Login, availableFolder.Path);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public CreateUserResponse Create(CreateUserRequest request)
{
var response = new CreateUserResponse();
try
{
var user = request.User.ToDomain(_userRepository);
_userRepository.Add(user);
_unitOfWork.Commit();
response.User = user.ToDataContract();
}
catch (Exception ex)
{
response.Exception = ex;
}
return(response);
}
public async Task <CreateUserResponse> CreateNewUser([FromBody] CreateUserRequest model)
{
var validationResult = await _createUserRequestValidator.ValidateAsync(model);
if (!validationResult.IsValid)
{
validationResult.Errors.Select(a => new { a.PropertyName, a.ErrorMessage });
return(new CreateUserResponse
{
IsSuccessfull = false,
Errors = validationResult.Errors.Select(a => new PropertyErrorModel {
PropertyName = a.PropertyName.ToCamelCase(), ErrorMessage = a.ErrorMessage
}).ToArray()
});
}
var response = await _mediator.Send(model);
return(response);
}
public async Task <ActionResult <User> > Post([FromBody] CreateUserRequest request)
{
var service = ServiceFactory.CreateUsersService(
_configuration.GetConnectionString("UsersDatabase"));
var response = await service.CreateUser(request);
if (response.Status == ResponseStatus.Success)
{
return(Accepted(response.User));
}
else if (response.Status == ResponseStatus.ValidationError)
{
return(BadRequest(response.Message));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public User Create(CreateUserRequest newUser)
{
var salt = GenerateSalt();
var insertResponse = _context.Users.Add(new User
{
FirstName = newUser.FirstName,
LastName = newUser.LastName,
Email = newUser.Email,
Username = newUser.Username,
ProfileImageUrl = newUser.ProfileImageUrl,
CoverImageUrl = newUser.CoverImageUrl,
Salt = salt,
HashedPassword = HashPassword(newUser.PasswordInput, salt)
});
_context.SaveChanges();
return(insertResponse.Entity);
}
public static void CreateDemoUser()
{
var client = new AmazonIdentityManagementServiceClient();
var request = new CreateUserRequest
{
UserName = "******"
};
try
{
var response = client.CreateUser(request);
Console.WriteLine("User Name = '{0}', ARN = '{1}'",
response.User.UserName, response.User.Arn);
}
catch (EntityAlreadyExistsException)
{
Console.WriteLine("User 'DemoUser' already exists.");
}
}
public User Create(CreateUserRequest newUser)
{
IHashService hash = new HashAlgorithm();
var salt = hash.GetSalt();
var insertResponse = _context.Users.Add(new User
{
FirstName = newUser.FirstName,
LastName = newUser.LastName,
Email = newUser.Email,
Username = newUser.Username,
ProfileImageUrl = newUser.ProfileImageUrl,
CoverImageUrl = newUser.CoverImageUrl,
Salt = salt,
HashedPassword = hash.HashPassword(salt, newUser.Password)
});
_context.SaveChanges();
return(insertResponse.Entity);
}
public static UserDomain CriandoUsuarioComSucesso(string username, string password, string realName, string email, string acessLevelName, string ativacao, string protecao, string statusCodeExpected)
{
UserDomain userDomain = new UserDomain();
CreateUserRequest createUserRequest = new CreateUserRequest();
createUserRequest.SetJsonBody(username, password, realName, email, acessLevelName, ativacao, protecao);
IRestResponse <dynamic> response = createUserRequest.ExecuteRequest();
if (!response.StatusCode.ToString().Equals(statusCodeExpected))
{
throw new Exception("Erro ao executar a requisição.");
}
userDomain.Username = response.Data["user"]["name"].ToString();
userDomain.RealName = response.Data["user"]["real_name"].ToString();
userDomain.Email = response.Data["user"]["email"].ToString();
return(userDomain);
}
protected override async Task <Entity> CreateNewAsync(ApiOptions options)
{
var request = new CreateUserRequest()
{
User = this
};
ApiOptions.Apply(request, options);
// Create a new object
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
{
throw response.Status.ToFault();
}
// 3. Update the last known state based on the differences
Debug.Assert(response.User != null, "If status is successful, then created user should not be null.");
return(response.User);
}
public CreateUserResponse CreateUser(CreateUserRequest createUserRequest)
{
//generate salt
string salt = GenerateSalt(maxLenghtOfSalt); // new byte[maxLenghtOfSalt];
//create hash and then store user name and hased password and salt
string hashedPassword = CreateHashedPassword(Encoding.UTF8.GetBytes(createUserRequest.Password + salt));
User user = new User()
{
UserName = createUserRequest.Username,
HashedPassword = hashedPassword,
Salt = salt.ToString(),
PAN = createUserRequest.PAN
};
var createUserResponse = UserAccess.CreateUser(user);
return(createUserResponse);
}
public IActionResult Post([FromBody] CreateUserRequest createUser)
{
if (createUser.Name.Equals("") || createUser.Surname.Equals("") || createUser.Email.Equals("") || createUser.Password.Equals(""))
{
return(BadRequest("Missing or invalid data!"));
}
else
{
if (userRepository.FindByEmail(createUser.Email))
{
return(Conflict("User with this email is existing in database!"));
}
else
{
createUser.Password = BCryptUtilities.encodePassword(createUser.Password);
return(Ok(userRepository.Create(createUser.ReturnUser())));
}
}
}
/// <summary>
/// CreateUser's Logic
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <CreateUserResponse> CreateUser(CreateUserRequest request)
{
Random rnd = new Random();
int rndNumber = rnd.Next(1, 10000);
UsersData.UsersDataInMem.Add(new UserDto
{
Id = rndNumber,
Name = request.RequestData.Name,
Age = request.RequestData.Age,
Address = request.RequestData.Address.ToString()
});
var response = new CreateUserResponse()
{
Success = true,
};
return(await Task.FromResult(response));
}
public CommandResult<User> CreateUser(CreateUserRequest createUserRequest)
{
return _createUserCommand.ExecuteRequest(createUserRequest);
}
public void CreateUserTest()
{
using (ShimsContext.Create())
{
MockClients clients = new MockClients();
string json = @"{
""metadata"": {
""guid"": ""guid-9ca6119b-7311-48fa-96f8-6ab604dca950"",
""url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950"",
""created_at"": ""2015-05-19T15:27:24+00:00"",
""updated_at"": null
},
""entity"": {
""admin"": false,
""active"": false,
""default_space_guid"": null,
""spaces_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/spaces"",
""organizations_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/organizations"",
""managed_organizations_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/managed_organizations"",
""billing_managed_organizations_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/billing_managed_organizations"",
""audited_organizations_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/audited_organizations"",
""managed_spaces_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/managed_spaces"",
""audited_spaces_url"": ""/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/audited_spaces""
}
}";
clients.JsonResponse = json;
clients.ExpectedStatusCode = (HttpStatusCode)201;
var cfClient = clients.CreateCloudFoundryClient();
CreateUserRequest value = new CreateUserRequest();
var obj = cfClient.Users.CreateUser(value).Result;
Assert.AreEqual("guid-9ca6119b-7311-48fa-96f8-6ab604dca950", TestUtil.ToTestableString(obj.EntityMetadata.Guid), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950", TestUtil.ToTestableString(obj.EntityMetadata.Url), true);
Assert.AreEqual("2015-05-19T15:27:24+00:00", TestUtil.ToTestableString(obj.EntityMetadata.CreatedAt), true);
Assert.AreEqual("", TestUtil.ToTestableString(obj.EntityMetadata.UpdatedAt), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.Admin), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.Active), true);
Assert.AreEqual("", TestUtil.ToTestableString(obj.DefaultSpaceGuid), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/spaces", TestUtil.ToTestableString(obj.SpacesUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/organizations", TestUtil.ToTestableString(obj.OrganizationsUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/managed_organizations", TestUtil.ToTestableString(obj.ManagedOrganizationsUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/billing_managed_organizations", TestUtil.ToTestableString(obj.BillingManagedOrganizationsUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/audited_organizations", TestUtil.ToTestableString(obj.AuditedOrganizationsUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/managed_spaces", TestUtil.ToTestableString(obj.ManagedSpacesUrl), true);
Assert.AreEqual("/v2/users/guid-9ca6119b-7311-48fa-96f8-6ab604dca950/audited_spaces", TestUtil.ToTestableString(obj.AuditedSpacesUrl), true);
}
}
public CreateUserResponse CreateUser(CreateUserRequest request)
{
var response = new CreateUserResponse();
try
{
var user = request.User;
var password = request.Password ?? Membership.GeneratePassword(14, 5);
var now = DateTimeOffset.Now;
var propertyValues = new
{
FirstName = user.FirstName.Trim(),
LastName = user.LastName.Trim(),
Email = user.Email.Trim().ToLower(),
Created = now,
Updated = now
};
WebSecurity.CreateUserAndAccount(user.UserName.Trim(), password, propertyValues, requireConfirmationToken: false);
response.Password = password;
response.Status = StatusCode.OK;
}
// https://msdn.microsoft.com/en-us/library/system.web.security.membershipcreateuserexception.statuscode(v=vs.110).aspx
catch (MembershipCreateUserException ex)
{
response.Status = StatusCode.BadRequest;
response.CreateAccountStatus = this.MapCreateAccountStatus(ex.StatusCode);
}
catch (Exception ex)
{
response.Status = StatusCode.InternalServerError;
this.exceptionHandler.HandleException(ex);
}
return response;
}
/// <summary>
/// Registers the user.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager result where the user is returned as the Result.
/// </returns>
public virtual ManagerResponse<CreateUserResult, CommerceUser> RegisterUser([NotNull] CommerceStorefront storefront, RegisterUserInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(inputModel, "inputModel");
Assert.ArgumentNotNullOrEmpty(inputModel.UserName, "inputModel.UserName");
Assert.ArgumentNotNullOrEmpty(inputModel.Password, "inputModel.Password");
CreateUserResult result;
// Attempt to register the user
try
{
var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, storefront.ShopName);
result = this.CustomerServiceProvider.CreateUser(request);
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
}
catch (MembershipCreateUserException e)
{
result = new CreateUserResult { Success = false };
result.SystemMessages.Add(new Commerce.Services.SystemMessage { Message = ErrorCodeToString(e.StatusCode) });
}
return new ManagerResponse<CreateUserResult, CommerceUser>(result, result.CommerceUser);
}
public CreateUserResponse Post(CreateUserRequest request)
{
_log.StartLog(request);
try
{
if (String.IsNullOrWhiteSpace(request.Password))
{
var password = _authProvider.CreateUser(request.Username);
if (password != null)
{
return new CreateUserResponse {Password = password};
}
throw new Exception("User could not be created. May already be registered?");
}
else
{
if (_authProvider.CreateUserWithPassword(request.Username, request.Password))
{
return new CreateUserResponse();
}
throw new Exception("User could not be created. May already be registered?");
}
}
catch (Exception e)
{
_log.Fatal("error", e);
Errors.Add(e.Message + " " + e.StackTrace);
return new CreateUserResponse {Errors = Errors};
}
}
public CreateUserViewModel Get(CreateUserRequest request)
{
return new CreateUserViewModel();
}
/// <summary>
/// Registers the user.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager result where the user is returned as the Result.
/// </returns>
public virtual ManagerResponse<CreateUserResult, CommerceUser> RegisterUser([NotNull] CommerceStorefront storefront, RegisterUserInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(inputModel, "inputModel");
Assert.ArgumentNotNullOrEmpty(inputModel.UserName, "inputModel.UserName");
Assert.ArgumentNotNullOrEmpty(inputModel.Password, "inputModel.Password");
CreateUserResult result;
// Attempt to register the user
try
{
var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, storefront.ShopName);
result = this.CustomerServiceProvider.CreateUser(request);
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
else if (result.Success && result.CommerceUser == null && result.SystemMessages.Count() == 0)
{
// Connect bug: This is a work around to a Connect bug. When the user already exists,connect simply aborts the pipeline but
// does not set the success flag nor does it return an error message.
result.Success = false;
result.SystemMessages.Add(new SystemMessage { Message = StorefrontManager.GetSystemMessage("UserAlreadyExists") });
}
}
catch (MembershipCreateUserException e)
{
result = new CreateUserResult { Success = false };
result.SystemMessages.Add(new Commerce.Services.SystemMessage { Message = ErrorCodeToString(e.StatusCode) });
}
return new ManagerResponse<CreateUserResult, CommerceUser>(result, result.CommerceUser);
}
/// <summary>
/// Creating a User
/// <para>For detailed information, see online documentation at: "http://apidocs.cloudfoundry.org/195/users/creating_a_user.html"</para>
/// </summary>
public async Task<CreateUserResponse> CreateUser(CreateUserRequest value)
{
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
uriBuilder.Path = "/v2/users";
var client = this.GetHttpClient();
client.Uri = uriBuilder.Uri;
client.Method = HttpMethod.Post;
var authHeader = await BuildAuthenticationHeader();
if (!string.IsNullOrWhiteSpace(authHeader.Key))
{
client.Headers.Add(authHeader);
}
client.ContentType = "application/x-www-form-urlencoded";
client.Content = JsonConvert.SerializeObject(value).ConvertToStream();
var expectedReturnStatus = 201;
var response = await this.SendAsync(client, expectedReturnStatus);
return Utilities.DeserializeJson<CreateUserResponse>(await response.ReadContentAsStringAsync());
}
