public IActionResult UpdateCustomerDetails([FromBody] UpdateCustomerRequestModel requestModel)
{
try
{
var authId = User.Claims.FirstOrDefault(x => x.Type == "UserAuthId");
var websiteId = User.Claims.FirstOrDefault(x => x.Type == "CustomerId").Value;
var websiteUserId = User.Claims.FirstOrDefault(x => x.Type == "WebsiteUserId").Value;
var accessType = User.Claims.FirstOrDefault(x => x.Type == "AccessType").Value;
requestModel.AccessType = accessType;
var request = (HttpWebRequest)WebRequest.Create(new Uri(String.Format(Constants.CustomerEndpoints.UpdateCustomerDetailsEndpoint, Constants.KitsuneServerUrl, websiteId, websiteUserId)));
request.Method = "POST";
request.ContentType = "application/json";
request.Headers.Add(HttpRequestHeader.Authorization, authId.Value);
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
string jsonData = JsonConvert.SerializeObject(requestModel);
streamWriter.Write(jsonData);
}
var httpResponse = (HttpWebResponse)request.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
UpdateCustomerName(requestModel.ContactDetails.FullName);
return(new JsonResult(streamReader.ReadToEnd()));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateCustomerRequestModel model)
{
var updatedCustomer = await _customerService.UpdateAsync(model.Id, model.FirstName, model.LastName);
var response = updatedCustomer.Adapt <CustomerResponseModel>();
return(JsonResult(response));
}
public async Task <ActionResult> UpdateCustomer(UpdateCustomerRequestModel model)
{
var isUpdated = await this._customerService.UpdateCustomer(
model.Id,
model.Email,
model.FirstName,
model.LastName);
if (!isUpdated)
{
return(BadRequest());
}
await _kafkaService.Produce("EditCustomer", model);
return(Ok());
}
public async Task UpdateCustomer_ShouldReturn_BadrequestResult()
{
//Arrange
var customerService = new Mock <ICustomerService>();
customerService
.Setup(x => x.UpdateCustomer(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(false);
var customersController = new CustomersController(customerService.Object, null);
var model = new UpdateCustomerRequestModel();
//Act
var result = await customersController.UpdateCustomer(model);
//Assert
result
.Should()
.BeOfType <BadRequestResult>();
}
public async Task UpdateCustomer_ShouldReturn_OkResult()
{
//Arrange
var customerServiceMock = new Mock <ICustomerService>();
var kafkaServiceMock = new Mock <IKafkaService>();
customerServiceMock
.Setup(x => x.UpdateCustomer(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var customersController = new CustomersController(customerServiceMock.Object, kafkaServiceMock.Object);
var model = new UpdateCustomerRequestModel();
//Act
var result = await customersController.UpdateCustomer(model);
//Assert
result
.Should()
.BeOfType <OkResult>();
}
public async Task <HttpResponseMessage> UpdateCustomerRecord(string customerId, [FromBody] UpdateCustomerRequestModel updateRequest)
{
var cus = await _app.GetCustomerById(customerId);
if (cus == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Update Can't perform, Record not existed."));
}
await _app.UpdateCustomer(customerId, Mapper.Map <UpdateCustomerRequestEntity>(updateRequest));
return(Request.CreateResponse(HttpStatusCode.OK, "Successfully updated."));
}
