public async Task <string> CancelOrder(string orderNumber, string message)
{
await _hubContext.Clients.All.SendAsync("OutgoingCall", $"Avboka order: {orderNumber}");
var payload = new OrderCancelModel
{
CallingUser = "******",
OrderNumber = orderNumber,
Message = message
};
using var content = new StringContent(JsonConvert.SerializeObject(payload, Formatting.Indented), Encoding.UTF8, "application/json");
var response = await client.PostAsync(_options.TolkApiBaseUrl.BuildUri("Order/Cancel"), content);
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
return("Anropet saknar autentisering");
}
if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
var errorMessage = JsonConvert.DeserializeObject <ValidationProblemDetails>(await response.Content.ReadAsStringAsync());
return($"Det gick inte att avboka order {orderNumber}: {errorMessage.Title}");
}
if (JsonConvert.DeserializeObject <ResponseBase>(await response.Content.ReadAsStringAsync()).Success)
{
var info = JsonConvert.DeserializeObject <ResponseBase>(await response.Content.ReadAsStringAsync());
return($"Order: {orderNumber} har avbokats");
}
else
{
var errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(await response.Content.ReadAsStringAsync());
return($"Det gick inte att avboka order {orderNumber}. Felmeddelande: {errorResponse.ErrorMessage}");
}
}
[OpenApiIgnore]//Not applicable for broker api, hence hiding it from swagger
public async Task <IActionResult> Cancel([FromBody] OrderCancelModel model)
{
var method = $"{nameof(OrderController)}.{nameof(Cancel)}";
_logger.LogDebug($"{method} was called");
if (model == null)
{
return(ReturnError(ErrorCodes.IncomingPayloadIsMissing, method));
}
if (!_tolkBaseOptions.EnableCustomerApi)
{
_logger.LogWarning($"{model.CallingUser} called {method}, but CustomerApi is not enabled!");
return(BadRequest(new ValidationProblemDetails {
Title = "CustomerApi is not enabled!"
}));
}
if (string.IsNullOrEmpty(model.CallingUser))
{
return(ReturnError(ErrorCodes.CallingUserMissing, method));
}
_logger.LogInformation($"{model.CallingUser} is confirming that no-one accepted {model.OrderNumber}");
if (ModelState.IsValid)
{
AspNetUser apiUser = await _dbContext.Users.GetUserWithCustomerOrganisationById(User.UserId());
Order order = await _dbContext.Orders.GetOrderByOrderNumber(model.OrderNumber);
if (order == null || order.CustomerOrganisationId != apiUser.CustomerOrganisationId)
{
return(ReturnError(ErrorCodes.OrderNotFound, method));
}
var user = await _apiUserService.GetCustomerUser(model.CallingUser, apiUser.CustomerOrganisationId);
if (user == null)
{
return(ReturnError(ErrorCodes.CallingUserMissing, method));
}
Order fullOrder = await _dbContext.Orders.GetFullOrderById(order.OrderId);
//NOTE Not handling central order handlers correctly (this is not a public api, just used in internal testing)
if (!fullOrder.IsAuthorizedAsCreator(GetUnitsForUser(user.Id), apiUser.CustomerOrganisationId, user.Id, false))
{
return(ReturnError(ErrorCodes.Unauthorized, method, "The user does not have the right to cancel this order"));
}
try
{
await _orderService.CancelOrder(fullOrder, user.Id, apiUser.Id, model.Message);
await _dbContext.SaveChangesAsync();
}
catch (InvalidOperationException ex)
{
return(ReturnError(ErrorCodes.OrderNotInCorrectState, ex.Message));
}
_logger.LogInformation($"{order.OrderId} was denied");
return(Ok(new ResponseBase()));
}
return(ReturnError(ErrorCodes.OrderNotValid, method));
}
public async Task <ApiResult> Cancel(OrderCancelModel model)
{
var res = await orderService.OrderCancelAsync(model.OrderId);
if (!res)
{
return(new ApiResult {
status = 0, msg = "取消订单失败"
});
}
return(new ApiResult {
status = 1, msg = "取消订单成功"
});
}
public ActionResult <OrderModel> CancelOrder(int orderNumber, OrderCancelModel model)
{
try
{
var order = orderRepository.GetOrder(orderNumber);
if (order == null)
{
logger.LogInfo($"Trying to cancel nonexistent order: {orderNumber}");
var response = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)404,
ReasonPhrase = "You are trying to cancel nonexistent Order."
};
return(StatusCode(StatusCodes.Status404NotFound, response));
}
logger.LogInfo($"Trying to cancel order: {orderNumber}");
bool result = orderRepository.CancelOrder(orderNumber, model.Description);
if (result)
{
var returnOrder = mapper.Map <OrderModel>(order);
logger.LogInfo($"Order cancelled: {Newtonsoft.Json.JsonConvert.SerializeObject(returnOrder)}");
return(CreatedAtRoute("GetOrder", new { orderNumber = returnOrder.OrderNumber }, returnOrder));
}
}
catch (Exception ex)
{
logger.LogError($"Message: {ex.Message}");
logger.LogError($"StackTrace: {ex.StackTrace}");
return(StatusCode(StatusCodes.Status500InternalServerError));
}
return(BadRequest());
}
public ResultModel <OrderCancelResultModel> NewOrderCancel(OrderCancelModel model)
{
var bprovider = new BusinessProvider();
return(bprovider.NewOrderCancel(model));
}
