public async Task <OrderRepoResponse> GetOrder(int orderId) { validateOrderId(orderId); _dataLogger.LogInformation("Input data", orderId); try { return(await GetOrderData(orderId)); } catch (Exception ex) { _dataLogger.LogError(ex); throw; } }
public async Task <List <ClientOrderRepoResponseModel> > GetClientOrders(int clientId) { validateGetClientOrders(clientId); _dataLogger.LogInformation("Input data", clientId); try { return(await GetClientOrdersSqlResults(clientId)); } catch (Exception ex) { _dataLogger.LogError(ex); throw; } }
public async Task <List <ClientOrderApplicationResponseModel> > GetClientOrders(int clientId) { _dataLogger.LogInformation("Application.UseCases.GetClientOrders.GetClientOrders(clientId)", clientId); var repoClientOrders = await _clientOrders.GetClientOrders(clientId); return(_mapper.Map <List <ClientOrderApplicationResponseModel> >(repoClientOrders)); }
public async Task <List <CustomerSearchApplicationResponseModel> > GetCustomersByName(string name) { _dataLogger.LogInformation("Application.UseCases.SearchCustomerByName.GetCustomersByName(name)", name); var customers = await _customerSearchRepo.SearchCustomers(name); return(_mapper.Map <List <CustomerSearchApplicationResponseModel> >(customers)); }
public async Task <OrderApplicationResponseModel> GetOrder(int clientId, int orderId) { _dataLogger.LogInformation("Application.UseCases.Order.GetOrder(clientId, orderId)", clientId, orderId); var repoOrder = await _orderRepo.GetOrder(orderId); var order = _mapper.Map <OrderApplicationResponseModel>(repoOrder); _clientOrderAuthorization.AuthorizeClientToViewOrder(clientId, order); return(order); }
public async Task <ActionResult <IEnumerable <CustomerSearchMvcResponseModel> > > Index() { _dataLogger.LogInformation("In WebUi.Controllers.CustomerSearchControllerIndex()"); try { return(View(await GetCustomers(string.Empty))); } catch (Exception ex) { _dataLogger.LogError(ex); return(BadRequest(base.GetResponseObject(Constants.ERROR_RESPONSE, Constants.ERROR_RESPONSE))); } }
// Middleware: Custom middleware needs an Invoke method that is called when requests come in for processing. // It should have an HttpContext as its first argument and, optionally, other services that are // needed from DI. Dependencies which are injected at this level will be scoped to the lifetime of the request. public async Task Invoke(HttpContext context, IDataLogger dataLogger) { try { //First, get the incoming request var request = await FormatRequest(context.Request); dataLogger.LogInformation("Request", request); dataLogger.LogInformation("RequestHeader", FormatHeaders(context.Request)); //Copy a pointer to the original response body stream var originalBodyStream = context.Response.Body; //Create a new memory stream... using (var responseBody = new MemoryStream()) { //...and use that for the temporary response body context.Response.Body = responseBody; //Continue down the Middleware pipeline, eventually returning to this class await _next(context); //Format the response from the server var response = await FormatResponse(context.Response); dataLogger.LogInformation("Response", response); //Copy the contents of the new memory stream (which contains the response) to the original stream, which is then returned to the client. await responseBody.CopyToAsync(originalBodyStream); } } catch (Exception) { // Do nothing. We don't want to stop execution. await _next(context); } }