public void CreateCustomerRequestObject()
{
moq::Mock <CloudChannelService.CloudChannelServiceClient> mockGrpcClient = new moq::Mock <CloudChannelService.CloudChannelServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
CreateCustomerRequest request = new CreateCustomerRequest
{
Parent = "parent7858e4d0",
Customer = new Customer(),
};
Customer expectedResponse = new Customer
{
CustomerName = CustomerName.FromAccountCustomer("[ACCOUNT]", "[CUSTOMER]"),
OrgDisplayName = "org_display_nameb29ddfcb",
OrgPostalAddress = new gt::PostalAddress(),
PrimaryContactInfo = new ContactInfo(),
AlternateEmail = "alternate_email3cdfc6ce",
Domain = "domaine8825fad",
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
CloudIdentityId = "cloud_identity_idcb2e1526",
LanguageCode = "language_code2f6c7160",
CloudIdentityInfo = new CloudIdentityInfo(),
ChannelPartnerId = "channel_partner_ida548fd43",
};
mockGrpcClient.Setup(x => x.CreateCustomer(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
CloudChannelServiceClient client = new CloudChannelServiceClientImpl(mockGrpcClient.Object, null);
Customer response = client.CreateCustomer(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <bool> Handle(CreateCustomerRequest request, CancellationToken cancellationToken)
{
GuardAgainst.ArgumentBeingNull(request);
var customerDetail = mapper.Map <Customer>(request.CustomerViewModel);
return(await Task.Run(() => customerRedisContext.SetCustomer(customerDetail)));
}
public BaseResponse <CreateCustomerResponse> CreateCustomer(CreateCustomerRequest request)
{
var response = new BaseResponse <CreateCustomerResponse>();
try
{
if (request == null)
{
throw new ArgumentNullException("missing request");
}
var responseData = new CreateCustomerResponse();
var address = new Address(request.city, request.street, request.building);
var customerBuilder = new Customer(request.username, request.password, request.firstname, request.surname, request.email, address);
_customerDomainService.CreateCustomer(customer);
response.SetData(responseData);
}
catch (Exception e)
{
response.SetError(e);
}
return(response);
}
public CreateCustomerResponse Create(
[FromServices] ICreateCustomerHandler handler,
[FromBody] CreateCustomerRequest command
)
{
return(handler.Handle(command));
}
public IHttpActionResult CreateCustomer([FromBody] CreateCustomerRequest createCustomerRequest)
{
var createdCustomer = _repository.Customers.CreateCustomer(createCustomerRequest);
if (createdCustomer == null)
{
return(BadRequest("Not all fields were inputed"));
}
var accountType = _repository.BankAccount.GetAccountTypeByName(createCustomerRequest.Type);
if (accountType == null)
{
return(BadRequest("No AccountType exist with that name"));
}
var createdBankAccount = _repository.BankAccount.CreateBankAccount(
new BankAccount()
{
Balance = 0,
AccountNumber = _repository.BankAccount.CreateAccountNumber(),
ClearingNumber = _repository.BankAccountService.ReturnClearingNumber(),
CustomerId = createdCustomer.Id,
IBANNumber = _repository.BankAccount.CreateIBANNumber(),
AccountTypeId = accountType.Id,
});
var response = CreateCustomerResponse.Response(createdCustomer, createdBankAccount);
return(Ok(response));
}
public void CreateCharge_UsingCustomerId_Success()
{
var createCustomerRequest = new CreateCustomerRequest()
{
Name = "Customer Name",
Description = "Description",
Email = "*****@*****.**",
CardDetails = new Card()
{
Name = "Abdullah Ahmed",
Cvc = 123,
ExpireMonth = 12,
ExpireYear = 2020,
Number = "4242424242424242"
}
};
ApiResponse <Customer> customer = _customerService.CreateCustomer(createCustomerRequest);
_createChargeRequest.CustomerId = customer.Content.Id;
ApiResponse <Charge> response = _service.CreateCharge(_createChargeRequest);
Assert.IsTrue(!string.IsNullOrEmpty(response.Content.Id));
Assert.IsTrue(response.Content.State == ChargeState.Authorized);
}
private static async Task CreateCustomer(CustomerServiceDefinition.CustomerServiceDefinitionClient customerClient)
{
var input = new CreateCustomerRequest {
Name = "CIB"
};
var reply = await customerClient.CreateCustomerAsync(input);
}
public async Task <IActionResult> Post([FromBody] CreateCustomerModel customer)
{
var request = new CreateCustomerRequest(customer);
var result = await _mediator.Send(request);
return(Ok(result));
}
public async Task Valid_Create_Customer_Request_Must_Be_Successful()
{
//
// Arrange
//
var request = new CreateCustomerRequest
{
FirstName = "a",
LastName = "b",
DateOfBirth = new DateTime(1982, 1, 1)
};
//
// Act
//
var httpResponse = await _client.PostAsJsonAsync(BaseUrl, request);
//
// Assert
//
httpResponse.EnsureSuccessStatusCode();
var responseModel = JsonConvert.DeserializeObject <DisplayCustomerDto>(await httpResponse.Content.ReadAsStringAsync());
Assert.NotNull(responseModel);
}
public ActionResult <CreateCustomerResponse> CreateCustomer([FromBody] CreateCustomerRequest req)
{
if (!ModelState.IsValid)
{
return(this.FailWithMessage("invalid params"));
}
var options = new CustomerCreateOptions
{
Email = req.Email,
};
var service = new CustomerService();
Customer customer;
try
{
customer = service.Create(options);
}
catch (StripeException e)
{
return(this.FailWithMessage($"Failed to create customer: {e}"));
}
return(new CreateCustomerResponse
{
Customer = customer,
});
}
public Task <CreateCustomerResponse> Post(
[FromServices] IMediator mediator,
[FromBody] CreateCustomerRequest command
)
{
return(mediator.Send(command));
}
/// <summary>
/// Create the new customer
/// </summary>
/// <param name="customerRequest">Request parameters to create customer</param>
/// <returns>Customer</returns>
public Customer CreateCustomer(CreateCustomerRequest customerRequest)
{
try
{
//create customer API
var configuration = CreateApiConfiguration();
var customersApi = new CustomersApi(configuration);
//create the new customer
var createCustomerResponse = customersApi.CreateCustomer(customerRequest);
if (createCustomerResponse == null)
{
throw new NopException("No service response");
}
//check whether there are errors in the service response
if (createCustomerResponse.Errors?.Any() ?? false)
{
var errorsMessage = string.Join(";", createCustomerResponse.Errors.Select(error => error.ToString()));
throw new NopException($"There are errors in the service response. {errorsMessage}");
}
return(createCustomerResponse.Customer);
}
catch (Exception exception)
{
//log full error
_logger.Error($"Square payment error: {exception.Message}.", exception, _workContext.CurrentCustomer);
return(null);
}
}
public BaseResponse <GetCustomerResponse> CreateCustomer(CreateCustomerRequest request)
{
var method = HttpMethod.Post;
var endpoint = $"/customers";
return(this.HttpClientUtil.SendRequest <GetCustomerResponse>(method, endpoint, request));
}
public ActionResult <AccountView> ReceiveTokenAndRegister(string token, string returnUrl)
{
User user = _externalAuthenticationService.GetUserDetailsFrom(token);
if (user.IsAuthenticated)
{
_formsAuthentication.SetAuthenticationToken(user.AuthenticationToken);
// Register user
var createCustomerRequest = new CreateCustomerRequest();
createCustomerRequest.CustomerIdentityToken = user.AuthenticationToken;
createCustomerRequest.Email = user.Email;
createCustomerRequest.FirstName = "[Please Enter]";
createCustomerRequest.SecondName = "[Please Enter]";
_customerService.CreateCustomer(createCustomerRequest);
return(RedirectBasedOn(returnUrl));
}
else
{
AccountView accountView = InitializeAccountViewWithIssue(true,
"Sorry we could not authenticate you.");
accountView.CallBackSettings.ReturnUrl = GetReturnActionFrom(returnUrl).ToString();
return(accountView);
}
}
private CustomerCreatedResponse ImplementationOne(CreateCustomerRequest request)
{
try
{
int id = _repository.RegisterCustomer("name");
}
catch (Exception e)
{
return(new CustomerCreatedResponse {
IsSuccess = false
});
}
try
{
_gateway.SendMail("GOOD MORNING vietnam");
}
catch (Exception e)
{
return(new CustomerCreatedResponse {
IsSuccess = false
});
}
return(new CustomerCreatedResponse());
}
private async Task <Customer> CreateCustomer(
string countryCode,
string language,
string danishIdentityNumber = null,
string swedishIdentityNumber = null)
{
var request = new CreateCustomerRequest
{
AddressLine1 = "Address Line 1",
AddressLine2 = "Address Line 2",
AddressLine3 = "Address Line 3",
City = "London",
CompanyName = "Company Name",
CountryCode = countryCode,
DanishIdentityNumber = danishIdentityNumber,
Email = "*****@*****.**",
FamilyName = "Family Name",
GivenName = "Given Name",
Language = language,
Metadata = new Dictionary <string, string>
{
["Key1"] = "Value1",
["Key2"] = "Value2",
["Key3"] = "Value3",
},
PhoneNumber = "+44 1234 567890",
PostalCode = "SW1A 1AA",
Region = "Essex",
SwedishIdentityNumber = swedishIdentityNumber
};
var customersClient = new CustomersClient(_clientConfiguration);
return((await customersClient.CreateAsync(request)).Item);
}
public async Task <Guid> CreateCustomer(CreateCustomerRequest request)
{
var customerId = CustomerId.New;
await _commandBus.PublishAsync(new CreateCustomerCommand(customerId, request.UserName, request.PersonalIdentificationNumber), CancellationToken.None);
return(customerId.GetGuid());
}
public IActionResult CreateCustomer([FromBody] CreateCustomerRequest request)
{
Customer customer = customerService.CreateCustomer(request.Name, request.CreditLimit);
CreateCustomerResponse createCustomerResponse = new CreateCustomerResponse(customer.Id);
return(Ok(createCustomerResponse));
}
public async Task <IActionResult> Post([FromBody] CreateCustomerRequest request)
{
var validator = new CreateCustomerValidator();
var result = validator.Validate(request);
if (!result.IsValid)
{
return(BadRequest(result.Errors));
}
// convert request DTO to command DTO
var createCustomerCommand = Mapper.Map <CreateCustomerCommand1>(request);
// command handler returns response that wraps domain model
var createCustomerCommandResponse = await _mediator.Send(createCustomerCommand);
if (createCustomerCommandResponse.Result == OperationStatus.ValidationFailure)
{
return(BadRequest(createCustomerCommandResponse.ErrorMessages));
}
if (createCustomerCommandResponse.Result == OperationStatus.Conflict)
{
return(Conflict(createCustomerCommandResponse));
}
return(Ok(createCustomerCommandResponse.CustomerId));
}
public async Task Cannot_Create_Customer_With_Invalid_Data()
{
//
// Arrange
//
var customerService = GetCustomerService();
var firstNameNullCustomer = new CreateCustomerRequest(new CustomerCreateModel(null, "lastname", DateTime.Now.AddYears(-20)));
var lastNameNullCustomer = new CreateCustomerRequest(new CustomerCreateModel("firstname", null, DateTime.Now.AddYears(-20)));
var firstNameEmptyCustomer = new CreateCustomerRequest(new CustomerCreateModel("", "lastname", DateTime.Now.AddYears(-20)));
var lastNameEmptyCustomer = new CreateCustomerRequest(new CustomerCreateModel("firstname", "", DateTime.Now.AddYears(-20)));
var firstNameWithSpacesCustomer = new CreateCustomerRequest(new CustomerCreateModel(" ", "lastname", DateTime.Now.AddYears(-20)));
var lastNameWithSpacesCustomer = new CreateCustomerRequest(new CustomerCreateModel("firstname", " ", DateTime.Now.AddYears(-20)));
var futureCustomer = new CreateCustomerRequest(new CustomerCreateModel("firstname", "lastname", DateTime.Now.AddYears(1)));
var invalidRequests = new[]
{
firstNameNullCustomer, lastNameNullCustomer, firstNameEmptyCustomer, lastNameEmptyCustomer,
firstNameWithSpacesCustomer, lastNameWithSpacesCustomer, futureCustomer
};
//
// Act
//
var tasks = invalidRequests.Select(x => customerService.CreateCustomerAsync(x));
var operationResults = await Task.WhenAll(tasks);
//
// Assert
//
Assert.False(operationResults.All(x => x.Status));
}
public async Task With_Valid_Data_Customer_Can_Be_Created()
{
//
// Arrange
//
var guid = Guid.NewGuid().ToString();
var mockedCustomerRepository = new Mock <ICustomerRepository>();
mockedCustomerRepository.Setup(x => x.CreateCustomerAsync(It.IsAny <Customer>())).ReturnsAsync(OperationResult <Customer> .Success(new Customer
{
Id = guid,
FirstName = "Cheranga",
LastName = "Hatangala",
DateOfBirth = new DateTime(1982, 11, 1)
}));
var logger = Mock.Of <ILogger <CustomerService> >();
var customerService = new CustomerService(mockedCustomerRepository.Object, logger);
var createCustomerRequest = new CreateCustomerRequest(new CustomerCreateModel("Cheranga", "Hatangala", new DateTime(1982, 11, 1)));
//
// Act
//
var operationResult = await customerService.CreateCustomerAsync(createCustomerRequest);
//
// Assert
//
Assert.True(operationResult.Status);
Assert.NotNull(operationResult.Data?.Customer?.Id);
}
public async Task CreateCustomer_Valid_Created()
{
var createRequest = new CreateCustomerRequest
{
FirstName = "First name 1",
LastName = "Last name 1",
};
var createResponse = await Fixture.Api.Customers.CreateCustomerAsync(createRequest);
Assert.Equal(HttpStatusCode.Created, createResponse.StatusCode);
var createResponseContent = createResponse.Data;
AssertUtilities.NotEmpty(createResponseContent.Id);
Assert.Equal(createRequest.FirstName, createResponseContent.FirstName);
Assert.Equal(createRequest.LastName, createResponseContent.LastName);
var findRequest = new FindCustomerRequest {
Id = createResponseContent.Id
};
var findResponse = await Fixture.Api.Customers.FindCustomerAsync(findRequest);
Assert.Equal(HttpStatusCode.OK, findResponse.StatusCode);
var findResponseContent = findResponse.Data;
Assert.Equal(createResponseContent.Id, findResponseContent.Id);
Assert.Equal(createRequest.FirstName, findResponseContent.FirstName);
Assert.Equal(createRequest.LastName, findResponseContent.LastName);
}
public Task <CreateCustomerResponse> Create(
[FromServices] IMediator mediator, //here i add the injection
[FromBody] CreateCustomerRequest commad
)
{
return(mediator.Send(commad));
}
public ActionResult SaveCustomer(CreateCustomerRequest customer)
{
try
{
Customer newCustomer = new Customer
{
Name = customer.Name,
RegisteredAddress = new Address {
Address1 = customer.Address1, PostalCode = customer.PostalCode
},
Contacts = new List <Contact>()
{
new Contact {
Name = customer.MainContact
}
}
};
_customerRepository.InsertNewCustomer(newCustomer, "nobody");
messageSender.SendMessage(new NewCustomerCreatedEvent
{
NewCustomer = newCustomer,
CorrelationId = Guid.NewGuid()
});
return(Ok(newCustomer));
}
catch (Exception ex)
{
return(Redirect("Error.html"));
}
}
//public CreateCustomerResponse Create(
public Task <CreateCustomerResponse> Create(
//[FromServices]ICreateCustomerHandler handler,
[FromServices] IMediator mediator,
[FromBody] CreateCustomerRequest command)
{
// return handler.Handle(command);
return(mediator.Send(command));
}
public async Task <CreateCustomerResponse> CreateCustomer(CreateCustomerViewModel customer)
{
var client = _requestClientCreator.Create <ICreateCustomerRequest, CreateCustomerResponse>();
var createCustomerRequest = new CreateCustomerRequest(Guid.NewGuid(), customer.Name, customer.Address);
var response = await client.Request(createCustomerRequest);
return(response);
}
public IHttpActionResult AddAccount(CreateCustomerRequest request, string type)
{
var service = new AccountService();
var account = service.CreateAccount(Guid.NewGuid().ToString(), type,
request.Name, request.Line1, request.Line2);
return(Created($"api/accounts/{account.Reference}", account));
}
public async Task <IActionResult> Produce(CreateCustomerRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
public IActionResult CreateCustomer([FromBody] CreateCustomerRequest request)
{
CustomerDataService customerService = new CustomerDataService(customerRepository, domainEventPublisher);
Customer customer = customerService.CreateCustomer(request.Name, request.CreditLimit);
CreateCustomerResponse createCustomerResponse = new CreateCustomerResponse(customer.Id);
return(Ok(createCustomerResponse));
}
public int CreateCustomer(CreateCustomerRequest ObjCreateCustomerRequest)
{
CustomerServiceMethods ObjCustomerServiceMethods = new CustomerServiceMethods();
int CustomerId = ObjCustomerServiceMethods.AddCustomer(ObjCreateCustomerRequest);
return(CustomerId);
}
public CustomerInformation CreateCustomer(CustomerInformation cinfo)
{
global::CustomerInformation ci = new global::CustomerInformation();
ci.CompanyName = cinfo.CompanyName;
ci.EMail = cinfo.EMail;
ci.FirstName = cinfo.FirstName;
ci.LastModified = Convert.ToDateTime(cinfo.LastModified);
ci.LastModifiedSpecified = true;
ci.LastName = cinfo.LastName;
ci.Notes = cinfo.Notes;
ci.PhoneNumber = cinfo.PhoneNumber;
//ci.SQLID = cinfo.SQLID;
CreateCustomerRequest creq = new CreateCustomerRequest(ci);
Task<CreateCustomerResponse> cres = _sqlService.CreateCustomerAsync(creq);
ci = cres.Result.CreateCustomerResult;
return new CustomerInformation(ci.FirstName,ci.LastName,ci.PhoneNumber,ci.EMail,ci.CompanyName,ci.Notes,ci.SQLID,cinfo.LastModified);
}
/// <remarks/>
public void CreateCustomerAsync(CreateCustomerRequest CreateCustomerRequest) {
this.CreateCustomerAsync(CreateCustomerRequest, null);
}
/// <remarks/>
public void CreateCustomerAsync(CreateCustomerRequest CreateCustomerRequest, object userState) {
if ((this.CreateCustomerOperationCompleted == null)) {
this.CreateCustomerOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateCustomerOperationCompleted);
}
this.InvokeAsync("CreateCustomer", new object[] {
CreateCustomerRequest}, this.CreateCustomerOperationCompleted, userState);
}
