public IActionResult CreateCustomerRequest(CustomerRequest customerRequest)
{
try
{
var create = new CreateCustomerRequestModel(customerRequest.FirstName
, customerRequest.LastName
, customerRequest.Nickname
, customerRequest.CPF
, customerRequest.CNPJ
, customerRequest.Phone
, customerRequest.Email
, customerRequest.BirthDate);
if (create.Invalid)
{
return(StatusCode(412, create.Notifications));
}
if (_service.RequestCreateCustomer(create))
{
return(Created("Customers", create));
}
else
{
return(StatusCode(412, "Erro ao criar cliente"));
}
}
catch (Exception e)
{
return(StatusCode(500, e));
}
}
public async Task <IActionResult> CreateAsync([FromBody] CreateCustomerRequestModel model)
{
var createdCustomer = await _customerService.CreateAsync(model.FirstName, model.LastName);
var response = createdCustomer.Adapt <CustomerResponseModel>();
return(JsonResult(response));
}
public static Customer MapAsNewEntity(this CreateCustomerRequestModel model)
{
return(new Customer
{
Name = model.Name,
City = model.City,
Address = model.Address
});
}
public async Task <ActionResult> PostCustomer(CreateCustomerRequestModel model)
{
var id = await _customerService.CreateCustomer(
model.Email,
model.FirstName,
model.LastName);
await _kafkaService.Produce("AddCustomer", model);
return(Created(nameof(PostCustomer), id));
}
public void CreateCustomer(CreateCustomerRequestModel createCustomerRequestModel)
{
try
{
CreateUserMessageEntity createUserMessageEntity = customerServiceApiMapper.MapCreateUserMessageEntity(createCustomerRequestModel);
ResultMessageEntity resultMessageEntity = customerService.CreateUser(createUserMessageEntity);
}
catch (Exception ex)
{
}
}
private bool ValidateRequest(CreateCustomerRequestModel requestModel)
{
var isValid = true;
var validations = requestModel.GetValidations();
if (validations.Any())
{
badRequestPresenter.Populate(validations);
isValid = false;
}
return(isValid);
}
public static CustomerRequestEntity ToCustomerRequest(this CreateCustomerRequestModel model)
{
return(new CustomerRequestEntity()
{
Id = 0,
BirthDate = model.BirthDate,
CNPJ = model.CNPJ,
CostumerRefusal = null,
CPF = model.CPF,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
Deleted = false,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Nickname = model.Nickname,
Phone = model.Phone
});
}
public async Task PostCustomer_ShouldReturn_OkResult()
{
//Arrange
var customerServiceMock = new Mock <ICustomerService>();
var kafkaServiceMock = new Mock <IKafkaService>();
customerServiceMock
.Setup(x => x.CreateCustomer(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(1);
var customersController = new CustomersController(customerServiceMock.Object, kafkaServiceMock.Object);
var model = new CreateCustomerRequestModel();
//Act
var result = await customersController.PostCustomer(model);
//Assert
result
.Should()
.BeOfType <CreatedResult>();
}
public CreateUserMessageEntity MapCreateUserMessageEntity(CreateCustomerRequestModel createCustomerRequestModel)
{
CreateUserMessageEntity createUserMessageEntity = new CreateUserMessageEntity
{
Addresses = new ConcurrentBag <AddressMessageEntity>(),
Credential = new CredentialMessageEntity
{
Password = createCustomerRequestModel.CustomerDetail.Credential?.UserName,
UserName = createCustomerRequestModel.CustomerDetail.Credential?.Password,
SecurityQuestions = new ConcurrentBag <SecurityQuestionMessageEntity>()
},
EmailAddresses = new ConcurrentBag <EmailAddressMessageEntity>(),
Name = new NameMessageEntity
{
FirstName = createCustomerRequestModel.CustomerDetail.Name?.FirstName,
LastName = createCustomerRequestModel.CustomerDetail.Name?.LastName,
MiddleName = createCustomerRequestModel.CustomerDetail.Name?.MiddleName
},
Occupation = new ConcurrentBag <OccupationMessageEntity>(),
Phones = new ConcurrentBag <PhoneMessageEntity>()
};
if (createCustomerRequestModel.CustomerDetail.Credential.SecurityQuestions.AnyWithNullCheck())
{
foreach (SecurityQuestionModel securityQuestionModel in createCustomerRequestModel.CustomerDetail.Credential.SecurityQuestions)
{
createUserMessageEntity.Credential.SecurityQuestions.Add(new SecurityQuestionMessageEntity
{
SecurityQuestionAnswer = securityQuestionModel.SecurityQuestionAnswer,
SecurityQuestionId = securityQuestionModel.SecurityQuestionId
});
}
}
if (createCustomerRequestModel.CustomerDetail.Addresses.AnyWithNullCheck())
{
foreach (AddressModel addressModel in createCustomerRequestModel.CustomerDetail.Addresses)
{
createUserMessageEntity.Addresses.Add(new AddressMessageEntity
{
AddressLine1 = addressModel.AddressLine1,
AddressLine2 = addressModel.AddressLine2,
CityCode = addressModel.CityCode,
CountryCode = addressModel.CountryCode,
IsPrimary = addressModel.IsPrimary,
StateCode = addressModel.StateCode
});
}
}
if (createCustomerRequestModel.CustomerDetail.EmailAddresses.AnyWithNullCheck())
{
foreach (EmailAddressModel emailAddressModel in createCustomerRequestModel.CustomerDetail.EmailAddresses)
{
createUserMessageEntity.EmailAddresses.Add(new EmailAddressMessageEntity
{
EmailAddress = emailAddressModel.EmailAddress,
IsPrimary = emailAddressModel.IsPrimary
});
}
}
if (createCustomerRequestModel.CustomerDetail.Phones.AnyWithNullCheck())
{
foreach (PhoneModel phoneModel in createCustomerRequestModel.CustomerDetail.Phones)
{
createUserMessageEntity.Phones.Add(new PhoneMessageEntity
{
IsPrimary = phoneModel.IsPrimary,
CountryCode = phoneModel.CountryCode,
PhoneNumber = phoneModel.PhoneNumber
});
}
}
return(createUserMessageEntity);
}
public void RequestCreateCustomer(CreateCustomerRequestModel createCustomerRequestModel) => customerService.RequestCreateCustomer(createCustomerRequestModel);
