public async Task <ActionResult> GetOrder(Guid id)
{
try
{
IGetOrderByIdRequest getOrderByIdRequest = new GetOrderByIdRequest(id);
IGetOrderResponse getOrderResponse = await _orderProvider.GetOrderById(getOrderByIdRequest);
IGetOrderPositionsResponse getOrderPositionsResponse = await _orderPositionsProvider.GetOrderPositionsByOrderId(new GetOrderPositionsByOrderIdRequest(id));
return(getOrderResponse.Result switch
{
OrderProvideResultEnum.Success => (ActionResult)Ok(new GetOrderResponseModel
{
Order = _objectToApiModelConverter.ConvertOrder(getOrderResponse.Order),
Restaurant = _objectToApiModelConverter.ConvertRestaurant(_restaurantProvider.GetRestaurant(new GetRestaurantRequest(getOrderResponse.Order.RestaurantId)).Result.Restaurant),
OrderPositions = getOrderPositionsResponse.OrderPositions.Select(x =>
new ExtendedOrderPositionApiModel
{
Id = x.Id,
CreationDate = x.CreationDate,
MealId = x.MealId,
Meal = _objectToApiModelConverter.ConvertMeal(_mealProvider.GetMealById(new GetMealByIdRequest(x.MealId))?.Result?.Meal),
UserId = x.UserId,
OrderId = x.OrderId,
User = _objectToApiModelConverter.ConvertUser(_userProvider.GetUserById(new ProvideUserRequest(x.UserId))?.Result?.User)
}).ToList(),
OrderBoy = _objectToApiModelConverter.ConvertUser(_userProvider.GetUserById(new ProvideUserRequest(getOrderResponse.Order.OrderBoyId)).Result.User)
}),
OrderProvideResultEnum.NotFound => NotFound(),
OrderProvideResultEnum.Exception => StatusCode(500),
OrderProvideResultEnum.Forbidden => Forbid(),
_ => throw new ArgumentOutOfRangeException()
});
}
public override async Task <GetOrderByIdResponse> GetOrderById(GetOrderByIdRequest request,
ServerCallContext context)
{
// Calling repository to fetch Order by its Id
var orderModel = await _orderRepository.GetOrderByIdAsync(Guid.Parse(request.OrderId));
// Mapping found Order model to Order returned in gRPC response
var order = new Order
{
Id = orderModel.Id.ToString(),
CustomerName = orderModel.CustomerName,
Value = orderModel.Value
};
// Currently default Protocol Buffer compiler for .NET makes collections readonly,
// that's why we can't create this collection during initialization
order.Items.AddRange(orderModel.Items.Select(x => new OrderItem {
Id = x.Id.ToString(), Name = x.Name
}));
// Returning response with found and mapped Order
return(new GetOrderByIdResponse
{
Order = order
});
}
public Task <Result <GetOrderByIdResponse> > ExecuteAsync(GetOrderByIdRequest request)
{
var response = new GetOrderByIdResponse
{
OrderId = request.OrderId,
Products = Enumerable.Range(1, request.OrderId.Length).Select(x => new Product
{
ProductId = $"PROD_{x}",
Name = $"Product name {x}",
Description = $"Product description {x}"
}).ToList()
};
return(Task.FromResult(Result <GetOrderByIdResponse> .Success(response)));
}
public async Task Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log, CancellationToken cancellationToken)
{
var payload = eventGridEvent.GetPayload <OrderCreatedPayload>();
var request = new GetOrderByIdRequest
{
OrderId = payload.OrderId
};
GetOrderByIdResponse response = await _mediator.Send(request, cancellationToken);
// Handle the event
log.LogInformation($"Handled OnOrderCreated for OrderId {response.Order.OrderId}");
}
static async Task Main(string[] args)
{
// Creating Request with Order data, that we want to create
var createOrderRequest = new CreateOrderRequest
{
Order = new Order
{
Value = 15.5,
CustomerName = "Sample Customer Name",
Items =
{
new OrderItem
{
Name = "First Item"
},
new OrderItem
{
Name = "Second Item"
}
}
}
};
// Fetching gRPC Service URL from appsettings.json
var serviceUrl = Configuration.GetValue <string>("OrderingServiceUrl");
// Creating channel and client
using var channel = GrpcChannel.ForAddress(serviceUrl);
var client = new Ordering.OrderingClient(channel);
Info("Creating an Order ...");
// Invoking the client to create the Order and getting response from the Service
var createOrderResponse = await client.CreateOrderAsync(createOrderRequest);
Info($"Order created | OrderId: {createOrderResponse.OrderId}");
// Creating Request passing Id of created Order to fetch its data
var orderRequest = new GetOrderByIdRequest
{
OrderId = createOrderResponse.OrderId
};
Info($"Getting Order | OrderId: {orderRequest.OrderId}");
// Invoking the client to fetch created Order (with its Ids generated server-side)
var orderResponse = await client.GetOrderByIdAsync(orderRequest);
// Printing Order data
Info($"Order found | {orderResponse.Order}");
}
public async Task <ActionResult <Order> > Get(long orderId, CancellationToken cancellationToken)
{
if (orderId < 1)
{
return(BadRequest());
}
var request = new GetOrderByIdRequest
{
OrderId = orderId
};
GetOrderByIdResponse response = await _mediator.Send(request, cancellationToken);
return(new OkObjectResult(response.Order));
}
public async Task <IActionResult> RunAsync([HttpTrigger(AuthorizationLevel.Function, "get", Route = "v1/orders/{orderId}")]
HttpRequest request, string orderId,
[AzureAdToken("sales.bff.orders.search", "access.bff, test.bff")]
AzureAdToken authModel)
{
if (authModel == null)
{
return(_responseGenerator.GetResponse(null, Result <GetOrderByIdResponse> .Failure("Unauthorized", "User does not have authorization")));
}
var getOrderByIdRequest = new GetOrderByIdRequest(orderId);
var operation = await _getOrdersService.ExecuteAsync(getOrderByIdRequest);
var response = _responseGenerator.GetResponse(getOrderByIdRequest, operation);
return(response);
}
//获取指定订单详情：
public OrderResponse Post(GetOrderByIdRequest request)
{
if (request == null || request.Id < 1)
{
throw new Exception("请指定大于0的订单ID");
}
string operatorName = Request.Headers.Get("Gateway-OperatorName");
OrderResponse result = OrderLogic.Instance.GetOrder(request.Id);
if (result == null)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(default(OrderResponse));
}
return(result);
}
public async Task <IOrderUpdateResponse> MarkOrderAsOrdered(IOrderUpdateRequest request)
{
try
{
IGetOrderByIdRequest getOrderByIdRequest = new GetOrderByIdRequest(request.Id);
IGetOrderResponse getOrderByIdResponse = await _orderProvider.GetOrderById(new GetOrderByIdRequest(request.Id));
switch (getOrderByIdResponse.Result)
{
case OrderProvideResultEnum.Success:
break;
case OrderProvideResultEnum.NotFound:
return(new OrderUpdateResponse(UpdateOrderResultEnum.NotFound));
case OrderProvideResultEnum.Exception:
return(new OrderUpdateResponse(UpdateOrderResultEnum.Exception));
case OrderProvideResultEnum.Forbidden:
return(new OrderUpdateResponse(UpdateOrderResultEnum.Forbidden));
default:
throw new ArgumentOutOfRangeException();
}
if (getOrderByIdResponse.Order.OrderBoyId != request.CurrentLoggedInUserId)
{
return(new OrderUpdateResponse(UpdateOrderResultEnum.Forbidden));
}
await _orderRepository.MarkOrderAsOrdered(request.Id);
return(new OrderUpdateResponse(UpdateOrderResultEnum.Success));
}
catch (Exception ex)
{
_logger.Log(ex);
return(new OrderUpdateResponse(UpdateOrderResultEnum.Exception));
}
}
public async Task <IActionResult> GetAsync([FromQuery] GetOrderByIdRequest request)
{
return(await _mediator.Send(request));
}
