public static List <Order> GetAll()
{
List <Order> orderList = new List <Order>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetOrdersCommand objectCommand = new GetOrdersCommand(objectConnection))
{
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(orderList);
}
using (OrderSqlDataReader objectSqlDataReader = new OrderSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Order order = objectSqlDataReader.Order;
orderList.Add(order);
}
}
}
}
}
return(orderList);
}
public async Task <IActionResult> Get([FromQuery] GetOrdersCommand command)
{
var response = await _mediator.Send(command);
if (response.Errors.Any())
{
return(BadRequest(response.Errors));
}
return(Response(response));
}
public async Task <IActionResult> GetAll([FromQuery] GetOrdersCommand model)
{
try
{
return(await _mediator.Send(model));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in {0}", HttpContext.Request.Path);
return(BadRequest(ErrorMessages.InternalExceptionModel));
}
}
public async Task <IResultResponse <List <GetOrdersResponse> > > Handle(GetOrdersCommand request, CancellationToken cancellationToken)
{
IResultResponse <List <GetOrdersResponse> > result = new ResultResponse <List <GetOrdersResponse> >();
var validator = await new UserIDPropertyValidator(_uow).ValidateAsync(request.UserID);
if (!validator.IsValid)
{
result.AddMessage(validator.Errors);
return(result);
}
var orders = await _uow.OrderRepository.GetByUserId(request.UserID);
var user = await _uow.UserRepository.GetById(request.UserID);
result.Value = ConvertToModel(orders, user);
return(result);
}
private async Task <List <Order> > CollectOrdersFromAllPagesAsync(DateTime startDateUtc, DateTime endDateUtc, CancellationToken token, Mark mark)
{
var orders = new List <Order>();
LogicBrokerGetOrdersResponse response;
var paging = new Paging(base.PageSize);
var command = new GetOrdersCommand(base.Config.DomainUrl, base.Credentials.SubscriptionKey, startDateUtc, endDateUtc, paging);
do
{
response = await base.GetAsync <LogicBrokerGetOrdersResponse>(command, token, mark).ConfigureAwait(false);
if (response?.Records != null)
{
orders.AddRange(response.Records.Select(r => r.ToSvOrder()).ToList());
}
command.Paging.UpdateCurrentPage(response?.CurrentPage + 1);
} while(command.Paging.CurrentPage < response?.TotalPages);
return(orders);
}
private async void GetOrders()
{
if (!string.IsNullOrWhiteSpace(SearchTerm))
{
MessageToDisplay = "Searching...";
IsBusy = true;
ButtonEnabled = false;
IsLoading = true;
GetOrdersCommand.RaiseCanExecuteChanged();
var proxy = _serviceFactory.CreateClient <IOrderService>();
using (proxy)
{
var orders = proxy.FindOrdersByCompanyAsync((Company)CurrentCompany, SearchTerm);
await orders;
if (orders.Result.Count > 0)
{
foreach (var order in orders.Result)
{
FoundItems.Add(Map(order));
}
SelectedItem = FoundItems[0];
SelectedItemIndex = 0;
}
}
MessageToDisplay = FoundItems.Count.ToString() + " order(s) found";
ButtonEnabled = true;
GetOrdersCommand.RaiseCanExecuteChanged();
}
else
{
MessageToDisplay = "You must enter a search term in order to find an order";
}
IsLoading = false;
IsBusy = false;
}
private async void GetOrders()
{
if (!string.IsNullOrWhiteSpace(SearchTerm))
{
MessageToDisplay = "Searching...";
IsBusy = true;
ButtonEnabled = false;
IsLoading = true;
GetOrdersCommand.RaiseCanExecuteChanged();
var order_service = _serviceFactory.CreateClient <IOrderService>();
using (order_service)
{
try
{
var orders = order_service.FindOrdersByCompanyAsync((Company)CurrentCompany, SearchTerm);
await orders;
Orders = new ObservableCollection <Order>(orders.Result);
}
catch (Exception ex)
{
MessageToDisplay = ex.Message;
return;
}
}
MessageToDisplay = Orders.Count.ToString() + " order(s) found";
ButtonEnabled = true;
GetOrdersCommand.RaiseCanExecuteChanged();
}
else
{
MessageToDisplay = "You must enter a search term in order to find an order";
}
IsLoading = false;
IsBusy = false;
}
