public RegisterUserResponse RegisterUser(RegisterCustomerRequest request)
{
var ct = request.NewCustomer;
ct.Salt = Convert.ToBase64String(Security.GenerateNewSalt());
DL_Customer CustormerToSave =
Context.Customers.Add(ct);
int result = 0;
try
{
result = Context.SaveChanges();
}
catch (Exception e)
{
return(new RegisterUserResponse {
CallResult = 1, Message = REGISTER_CUSTOMER_SAVE_FAILED + "\n" + e.Message, MessageType = MessageType.Error
});
}
if (result != 0)
{
return(new RegisterUserResponse {
CallResult = 1, Message = REGISTER_CUSTOMER_SAVE_FAILED, MessageType = MessageType.Error
});
}
return(new RegisterUserResponse {
CallResult = 0
});
}
public async Task <OperationResult <UserDataResponse> > Handle(RegisterCustomerRequest message, CancellationToken cancellationToken)
{
var customerEntity = _mapper.Map <CustomerEntity>(message);
using (var context = _companyContextFactory())
using (var transaction = context.Database.BeginTransaction())
{
try
{
var username = message.Username.ToUpper();
var isUnique = !await context.Users.AnyAsync(x => username == x.Username.ToUpper(), cancellationToken)
.ConfigureAwait(false);
if (!isUnique)
{
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Registration_Username_Already_Taken));
}
var userEntity = context.Users.Add(customerEntity);
await context.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
transaction.Commit();
var response = _mapper.Map <UserDataResponse>(userEntity);
return(OperationResultBuilder.CreateSuccess(response));
}
catch (TaskCanceledException)
{
transaction.Rollback();
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Registration_Canceled));
}
}
}
public static Customer Register(RegisterCustomerRequest request)
{
var customer = new Customer();
customer.Id = Guid.NewGuid();
customer.User = new User();
customer.User.Id = request.UserId;
customer.User.Username = request.EmailAddress;
customer.User.Password = request.Password;
customer.User.Role = request.CustomerRole;
customer.User.CreatedBy = request.ApplicationUser;
customer.User.CreatedOn = DateTime.Now;
customer.User.Deleted = false;
customer.FamilyName = request.FamilyName;
customer.GivenName = request.GivenName;
customer.Address1 = request.Address1;
customer.Address2 = request.Address2;
customer.Address3 = request.Address3;
customer.Address4 = request.Address4;
customer.PostCode = request.PostCode;
customer.CreatedBy = request.ApplicationUser;
customer.CreatedOn = DateTime.Now;
customer.Deleted = false;
return(customer);
}
public void RegisterUserFailure()
{
//ARRANGE
var MockCustomer = new MOCK_DL_Customer();
MockCustomer.fail = true;
var customer = Common.GetCustomer();
var request = new RegisterCustomerRequest {
NewCustomer = customer, UserName = Common.USERNAME, Password = Common.PASSWORD
};
var MockSecurity = new Mock <ISecurityMethods>();
MockSecurity.Setup(x => x.GenerateNewSalt()).Returns(Common.SALT);
MockSecurity.Setup(x => x.GetPasswordHash(It.IsAny <byte[]>(), It.IsAny <String>())).Returns(Common.PASSWORD_HASH);
//create service object with mocks
var svc = new BB.Implementation.BBService();
svc.MockCustomer = MockCustomer;
svc.MockSecurity = MockSecurity.Object;
var s = svc.MockSecurity.GetPasswordHash(null, "");
//ACT
var response = svc.RegisterUser(request);
//ASSERT
Assert.AreEqual(1, response.CallResult);
Assert.IsFalse(String.IsNullOrEmpty(response.Message));
Assert.IsTrue(response.Message.StartsWith(BBService.REGISTER_CUSTOMER_SAVE_FAILED));
Assert.IsTrue(response.Message.EndsWith(MOCK_DL_Customer.ERR_SAVE_FAILED));
}
public async Task <OperationResult <UserDataResponse> > CreateCustomerAsync(
RegisterCustomerRequest request,
CancellationToken cancellationToken = default(CancellationToken))
{
var response = await _mediator.Send(request, cancellationToken)
.ConfigureAwait(false);
return(response);
}
public void InvalidRequestFails()
{
var request = new RegisterCustomerRequest();
var validationMessages = Customer.ValidateRegister(request);
Assert.AreEqual(4, validationMessages.Count);
Assert.IsTrue(validationMessages.Any(x => x.Text.Equals("ApplicationUser not supplied")));
Assert.IsTrue(validationMessages.Any(x => x.Text.Equals("CustomerRole not supplied")));
Assert.IsTrue(validationMessages.Any(x => x.Text.Equals("Email not supplied")));
Assert.IsTrue(validationMessages.Any(x => x.Text.Equals("Post code not supplied")));
}
public async Task <IActionResult> Register([FromBody] RegisterCustomerRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var command = _mapper.Map <RegisterCustomerCommand>(request);
return(Response(await _mediator.Send(command)));
}
private async Task <ResponseMessage> SendRegisterCustomerRequest(CustomerRegisteredEvent request)
{
var customerRequest = new RegisterCustomerRequest(request.Id, request.Name, request.Email, request.Cpf);
using var scope = _serviceProvider.CreateScope();
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
var requestResult = await mediator.Send(customerRequest);
return(new ResponseMessage {
ValidationResult = requestResult.ValidationResult
});
}
public static ValidationMessageCollection ValidateRegister(RegisterCustomerRequest request)
{
var validationMessages = new ValidationMessageCollection();
//Only a selection of fields validated for demo purposes.
var rxPostCode =
new Regex(
@"^(([gG][iI][rR] {0,}0[aA]{2})|((([a-pr-uwyzA-PR-UWYZ][a-hk-yA-HK-Y]?[0-9][0-9]?)|(([a-pr-uwyzA-PR-UWYZ][0-9][a-hjkstuwA-HJKSTUW])|([a-pr-uwyzA-PR-UWYZ][a-hk-yA-HK-Y][0-9][abehmnprv-yABEHMNPRV-Y]))) {0,}[0-9][abd-hjlnp-uw-zABD-HJLNP-UW-Z]{2}))$");
if (string.IsNullOrEmpty(request.PostCode))
{
validationMessages.AddError("PostCode", "Post code not supplied");
}
else
{
if (!rxPostCode.IsMatch(request.PostCode))
{
validationMessages.AddError("PostCode", "Post code is not valid.");
}
}
if (string.IsNullOrEmpty(request.EmailAddress))
{
validationMessages.AddError("EmailAddress", "Email not supplied");
}
else if (request.EmailAddress.Length > 50)
{
validationMessages.AddError("EmailAddress", "Email must be 50 characters or less.");
}
else
{
var rxNonStrictEmail = new Regex(@"[A-Za-z0-9\.-_\+]+@[A-Za-z0-9\.-_\+]+");
if (!rxNonStrictEmail.IsMatch(request.EmailAddress))
{
validationMessages.AddError("EmailAddress", "Email is not valid.");
}
}
if (request.ApplicationUser == null)
{
validationMessages.AddError("ApplicationUser", "ApplicationUser not supplied");
}
if (request.CustomerRole == null)
{
validationMessages.AddError("CustomerRole", "CustomerRole not supplied");
}
return(validationMessages);
}
public IActionResult RegisterCustomer([FromForm] RegisterCustomerRequest request)
{
var customerID = _customerService.RegisterCustomer(request);
if (customerID.HasValue)
{
return(Ok(new
{
CustomerID = customerID
}));
}
return(BadRequest());
}
public int?RegisterCustomer(RegisterCustomerRequest request)
{
try
{
var passwordHash = ComputeHash(request.Password);
var customerID = _customersDA.InsertCustomer(request, passwordHash);
return(customerID);
}
catch (Exception ex)
{
throw;
}
}
public RegisterUserResponse RegisterUser(RegisterCustomerRequest request)
{
var ct = request.NewCustomer;
//convert Customer to DLCustomer
ADL_Customer CustomerToSave;
if (MockCustomer == null)
{
CustomerToSave = GetMappingObject().MapCustomertoDLCustomer(ct);
}
else
{
CustomerToSave = MockCustomer;
}
ISecurityMethods security;
if (MockSecurity == null)
{
security = new SecurityMethods();
}
else
{
security = MockSecurity;
}
//Add additional fields
byte[] Salt = security.GenerateNewSalt();
CustomerToSave.Salt = Salt;
CustomerToSave.PasswordNeedsChanging = false;
CustomerToSave.UserName = request.UserName;
CustomerToSave.PasswordHash = security.GetPasswordHash(Salt, request.Password);
try
{
CustomerToSave.Save();
}
catch (Exception e)
{
return(new RegisterUserResponse {
CallResult = 1, Message = REGISTER_CUSTOMER_SAVE_FAILED + "\n" + e.Message, MessageType = MessageType.Error
});
}
return(new RegisterUserResponse {
CallResult = 0
});
}
public RegisterCustomerRequest Map(RegisterViewModel viewModel)
{
var request = new RegisterCustomerRequest();
request.ApplicationUser = _userRepository.GetById(UserIds.Application);
request.CustomerRole = _roleRepository.GetById(RoleIds.Customer);
request.EmailAddress = viewModel.EmailAddress;
request.Password = viewModel.Password;
request.FamilyName = viewModel.FamilyName;
request.GivenName = viewModel.GivenName;
request.Address1 = viewModel.Address1;
request.Address2 = viewModel.Address2;
request.Address3 = viewModel.Address3;
request.Address4 = viewModel.Address4;
request.PostCode = viewModel.PostCode;
return(request);
}
public RegisterCustomerRequest GetRequest()
{
var request = new RegisterCustomerRequest();
request.UserId = Guid.NewGuid();
request.ApplicationUser = new User()
{
Id = Guid.NewGuid()
};
request.CustomerRole = new Role()
{
Id = Guid.NewGuid()
};
request.EmailAddress = "*****@*****.**";
request.FamilyName = "Silver";
request.GivenName = "Silvia";
request.Address1 = "1 Silver Lane";
request.Address2 = "Silverville";
request.Address3 = "Silvershire";
request.PostCode = "M1 1AA";
return(request);
}
public void RegisterUserHappyPath()
{
//ARRANGE
var MockCustomer = new MOCK_DL_Customer();
var customer = Common.GetCustomer();
var request = new RegisterCustomerRequest {
NewCustomer = customer, UserName = Common.USERNAME, Password = Common.PASSWORD
};
var MockSecurity = new Mock <ISecurityMethods>();
MockSecurity.Setup(x => x.GenerateNewSalt()).Returns(Common.SALT);
MockSecurity.Setup(x => x.GetPasswordHash(It.IsAny <byte[]>(), It.IsAny <String>())).Returns(Common.PASSWORD_HASH);
//create service object with mocks
var svc = new BB.Implementation.BBService();
svc.MockCustomer = MockCustomer;
svc.MockSecurity = MockSecurity.Object;
var s = svc.MockSecurity.GetPasswordHash(null, "");
//ACT
var response = svc.RegisterUser(request);
//ASSERT
Assert.AreEqual(0, response.CallResult);
Assert.IsTrue(String.IsNullOrEmpty(response.Message));
//check what was returned
Assert.AreEqual(Common.SALT, MockCustomer.Salt);
Assert.IsFalse(MockCustomer.PasswordNeedsChanging);
Assert.AreEqual(Common.USERNAME, MockCustomer.UserName);
Assert.AreEqual(Common.PASSWORD_HASH, MockCustomer.PasswordHash);
}
public int?InsertCustomer(RegisterCustomerRequest customer, string passwordHash)
{
try
{
using (var connection = OpenConnection())
{
var result = connection.QueryFirstOrDefault <int?>(ScriptProvider.Get("InsertCustomer"),
new
{
FirstName = customer.FirstName,
LastName = customer.LastName,
CustomerLogin = customer.Login,
PasswordHash = passwordHash,
CustomerType = customer.Type
});
return(result);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> RegisterCustomer([FromBody] RegisterCustomerRequest request)
{
var customer = await _mediator.Send(new RegisterCustomerCommand(request.Email, request.Name));
return(Created(string.Empty, customer));
}
Task <RegisterUserResponse> IManageOrders.RegisterUserAsync(RegisterCustomerRequest request)
{
throw new NotImplementedException();
}
public async Task <IActionResult> Register([FromBody] RegisterCustomerRequest request)
{
var command = _mapper.Map <RegisterCustomerCommand>(request);
return(await Response(command));
}
public async Task CreateCustomer([FromBody] RegisterCustomerRequest request) => await _mediator.Send(new RegisterCustomerCommand(request.Id, request.FirstName, request.LastName, request.BirthDate, request.Email, request.Phone));
