public static List <Order> GetOrders(string userName, string password, DateTime fromDate)
{
var apiKey = EkmConnector.GetApiKey(userName, password);
var myBinding = new BasicHttpBinding()
{
Name = PartnerEndpointName
};
var shopClient = new PartnerAPISoapClient(myBinding, new EndpointAddress(apiKey.EndPoint));
var getOrdersRequest = new GetOrdersRequest();
// Your unique APIKey must be passed with each request
getOrdersRequest.APIKey = apiKey.Key;
getOrdersRequest.PartnerKey = PartnerKey;
getOrdersRequest.ToDate = GetToday();
getOrdersRequest.FromDate = Get00Format(fromDate);
var Orders = new List <Order>();
getOrdersRequest.ItemsPerPage = 100;
int iPage = 0;
OrdersObject getOrdersResponse;
do
{
iPage++;
getOrdersRequest.PageNumber = iPage;
getOrdersResponse = shopClient.GetOrders(getOrdersRequest);
if (getOrdersResponse.Orders != null)
{
Orders.AddRange(getOrdersResponse.Orders);
}
} while (getOrdersResponse.Status != StatusCodes.Failure);
return(Orders);
}
public GetOrdersResponse Gets(GetOrdersCondition condition)
{
string mid = condition.memberId;
if (string.IsNullOrWhiteSpace(mid))
{
mid = DefaultMemberId;
}
var password = GetPassword(mid);
var datetime = DateTime.Now;
var request = new GetOrdersRequest
{
dataMap = condition,
sign = BuildSign(condition, datetime, password),
reqTime = datetime.ToString(DateTimeFormat)
};
var jSetting = new JsonSerializerSettings();
jSetting.NullValueHandling = NullValueHandling.Ignore;
var content = JsonConvert.SerializeObject(request, jSetting);
_log.Debug("Post data:" + content);
var config = new CommonConfig(null);
var req = (HttpWebRequest)WebRequest.Create(config.JavaOrder_Uri + "queryOrders");
req.Method = "POST";
req.ContentType = "Application/Json";
req.Credentials = CredentialCache.DefaultCredentials;
req.Timeout = 300000;
// 如果服务器返回错误，他还会继续再去请求，不会使用之前的错误数据，做返回数据
//req.ServicePoint.Expect100Continue = false;
WriteRequestData(req, content);
var response = req.GetResponse();
if (response == null)
{
throw new Exception("请求失败！");
}
var stream = response.GetResponseStream();
if (stream == null)
{
throw new Exception("请求Stream为空！");
}
var sr = new StreamReader(stream, Encoding.UTF8);
var retXml = sr.ReadToEnd();
sr.Close();
_log.Debug(retXml);
var obj = JsonConvert.DeserializeObject <GetOrdersResponse>(retXml);
if (obj.respCode != "0")
{
throw new ApplicationException(obj.respMsg);
}
return(obj);
}
public IActionResult GetOrders([FromBody] GetOrdersRequest request)
{
if (CheckToken(request, out CourierToken courierToken))
{
IEnumerable <Order> orders;
if (request.OrdersDate != default(DateTime))
{
orders = _context.Orders
.Include(o => o.Address)
.Include(o => o.Customer)
.Where(order => order.Courier.ID == courierToken.CourierID && order.DeliveryTime.Date == request.OrdersDate.Date);
}
else
{
orders = _context.Orders
.Include(o => o.Address)
.Include(o => o.Customer)
.Where(order => order.Courier.ID == courierToken.CourierID);
}
return(Ok(orders));
}
else
{
return(BadRequest(ModelState));
}
}
internal async Task <GetOrdersResponse> GetOrders(GetOrdersRequest request)
{
if (request == null)
{
throw new Exception("No data provided to API");
}
if (request.Limit == 0)
{
request.Limit = 100;
}
if (request.Limit > 100)
{
throw new Exception("Maximum number of records that can be retrieved is 100");
}
var statusString = request.OrderStatus == OrderStatus.NoFilter
? string.Empty
: $"&status={request.OrderStatus.GetOrderStatus()}";
var apiResponse =
await _client.GetAsync <GetOrdersResponse>(
$"orders?offset={request.Offset}&limit={request.Limit}{statusString}");
return(apiResponse);
}
public List <GetOrdersResponce> GetListOfOrders(GetOrdersRequest request)
{
string name = request.Name;
if (name != null)
{
int count = _context.Customer.Where(cust => cust.Name == name).Count();
if (count == 0)
{
throw new NoSuchCustomerException("No customer found with name " + name);
}
}
if (name == null)
{
name = "";
}
return(_context.Order.Join(_context.Confectionery_Order,
order => order.IdOrder,
con_order => con_order.IdOrder,
(order, con_order) => new GetOrdersResponce()
{
IdOrder = order.IdOrder,
DateAccepted = order.DateAccepted,
DateFinished = order.DateFinished,
Notes = order.Notes,
IdCustomer = order.IdCustomer,
IdConfectionery = con_order.IdConfectionary
}).Where(resp => _context.Customer.Where(customer => customer.Name.Contains(name)).Select(cust => cust.IdCustomer)
.Contains(resp.IdCustomer)).ToList());
}
public IActionResult Get(GetOrdersRequest request)
{
var orders = _data.Orders
.Skip(request.Page - 1)
.Take(request.PageSize);
var total = _data.Orders.Count();
var response = new OrderListResponse
{
//TODO: поставить автомаппер
Orders = orders.Select(m => new OrderItemResponse
{
Id = m.Id,
Client = m.Client,
Email = m.Email,
Status = m.Status,
Sum = m.Sum
}),
Page = request.Page,
PageSize = request.PageSize,
Total = total
};
return(Json(response));
}
public async Task <GetOrdersResponse> GetPaginatedOrdersAsync(GetOrdersRequest request)
{
Expression <Func <Domain.Entities.Order, bool> > statusFilter =
(x => request.Statuses.Contains(x.Status));
if (!OrderSortingMapping.TryGetValue(request.OrderBy, out var orderByPropertyName))
{
throw new MappingException($"No entity property mapping found for '{nameof(request.OrderBy)}'");
}
var paginatedOrders = await _unitOfWork.OrderRepository.GetPaginatedFilteredOrderedListAsync(request.Page,
request.PageSize,
statusFilter,
orderByPropertyName,
request.OrderDescending);
var paginatedProductsResponse = _mapper.Map <GetOrdersResponse>(paginatedOrders,
o => o.AfterMap((source, destination) =>
{
destination.OrderedBy = request.OrderBy;
destination.OrderDescending = request.OrderDescending;
}));
return(paginatedProductsResponse);
}
public async Task <PaginatedResponse <OrderModel> > Query(GetOrdersRequest request)
{
var parameters = new Dictionary <string, object>();
var where = new SqlWhereBuilder(request, _columns).Build();
var orderBy = new SqlOrderByBuilder($@"{nameof(OrderModel.Id)} ASC", _columns, request).Build();
var pagination = new SqlPaginationBuilder(request).Build();
var select = $@"
SELECT DISTINCT
{nameof(OrderModel.Id)},
{nameof(OrderModel.CarFrame)},
{nameof(OrderModel.Model)},
{nameof(OrderModel.LicensePlate)},
{nameof(OrderModel.DeliveryDate)}
FROM {nameof(CarsContext.Orders)} {where.Sql} {orderBy} {pagination.Sql}";
var count = $@"SELECT COUNT(*) FROM {nameof(CarsContext.Orders)} O {where.Sql}";
parameters.AddRange(where.Parameters);
parameters.AddRange(pagination.Parameters);
var result = await _db.QueryMultipleAsync($"{select};{count}", parameters);
return(new PaginatedResponse <OrderModel>(result.Read <OrderModel>(), result.ReadFirst <long>()));
}
public override async Task <GetOrdersReply> GetOrders(GetOrdersRequest request, ServerCallContext context)
{
var orders = GetOrders();
var result = new GetOrdersReply();
result.Orders.AddRange(orders);
return(result);
}
public async Task <IActionResult> GetOrders([FromQuery] GetOrdersRequest request)
{
var response = await mediator.Send(request);
Log.Information($"User #{HttpContext.GetCurrentUserId()} fetched orders history");
return(this.CreateResponse(response));
}
public GetOrdersResponse GetOrders(GetOrdersRequest request)
{
GetOrdersResponse response = new GetOrdersResponse();
response.addresses = BaseBLL <OrderBLL> .Instance.GetOrders(request.Id);
response.State = response.addresses.Count > 0 ? true : false;
return(response);
}
private static void OnGetOrdersExecuting(GetOrdersRequest request)
{
if (!string.IsNullOrWhiteSpace(request.Criteria.CustomerAccountNumber) ||
!string.IsNullOrWhiteSpace(request.Criteria.CustomerFirstName) ||
!string.IsNullOrWhiteSpace(request.Criteria.CustomerLastName))
{
request.RequestContext.Execute <NullResponse>(new CheckAccessServiceRequest(RetailOperation.CustomerTransactions));
}
}
public IEnumerable <Zamowienie> GetOrders(GetOrdersRequest request)
{
IEnumerable <Zamowienie> orders = _context.Zamowienies.ToList();
if (request.ClientLastName != null)
{
orders = orders.Where(x => x.Klient.Nazwisko.Equals(request.ClientLastName));
}
return(orders);
}
public IActionResult GetListOfOrders(GetOrdersRequest requets)
{
try
{
return(Ok(_service.GetListOfOrders(requets)));
}catch (NoSuchCustomerException ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult GetOrders(GetOrdersRequest request)
{
try
{
var list = _service.GetOrders(request);
return(Ok(list));
}catch (Exception e)
{
return(BadRequest("Error: " + e.Message));
}
}
public GetOrdersResponse GetOrdersByCriteria(GetOrdersRequest request)
{
GetOrdersResponse response = new GetOrdersResponse();
OrderBusinessComponent bc = DependencyInjectionHelper.GetOrderBusinessComponent();
IQueryable <Order> orders = bc.GetOrdersByCriteria(request.SearchType, request.CustomerId);
response.Orders = OrderAdapter.OrdersToListDtos(orders);
return(response);
}
public async Task <IActionResult> GetOrdersAsync([FromQuery] GetOrdersRequest request)
{
Logger?.LogDebug("{0} has been invoked", nameof(GetOrdersAsync));
// Get response from business logic
var response = await SalesService
.GetOrdersAsync(request.PageSize, request.PageNumber, request.OrderStatusID, request.CustomerID, request.EmployeeID, request.ShipperID, request.CurrencyID, request.PaymentMethodID);
// Return as http response
return(response.ToHttpResult());
}
public async Task <List <Order> > GetOrders(string username, string accountID)
{
var id = NextValidId;
var request = new GetOrdersRequest
{
ID = id,
Username = username,
AccountID = accountID
};
return(await RequestHelper <List <Order> > .ProceedRequest(id, _client, request));
}
public IEnumerable <Zamowienie> GetOrders(GetOrdersRequest request)
{
IEnumerable <Zamowienie> list = _context.Zamowienie.ToList();
if (request.NazwiskoKlienta != null)
{
//int liczbaKlientow = _context.Klienci.Count(e => e.Nazwisko == request.NazwiskoKlienta);
var Klient = _context.Klienci.ToList().Where(e => e.Nazwisko == request.NazwiskoKlienta);
return(list.Where(e => e.IdKlient == Klient.First().IdKlient));
}
return(list);
}
public GetOrdersResponse GetOrdersByCriteria(GetOrdersRequest request)
{
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
throw new FaultException <NotAuthenticatedFault>(new NotAuthenticatedFault());
}
GetOrdersResponse response = new GetOrdersResponse();
OrderBusinessComponent bc = DependencyInjectionHelper.GetOrderBusinessComponent();
IQueryable <Order> orders = bc.GetOrdersByCriteria(request.SearchType, request.CustomerId);
response.Orders = OrderAdapter.OrdersToListDtos(orders);
return(response);;
}
public IActionResult GetOrders(GetOrdersRequest request)
{
IActionResult response;
try
{
IEnumerable <Zamowienie> orders = _service.GetOrders(request);
response = Ok(orders);
}
catch (Exception e)
{
response = BadRequest($"Could not get orders due to:\n{e.StackTrace}\n{e.Message}");
}
return(response);
}
public async Task <IActionResult> GetOrders([FromQuery] GetOrdersRequest getOrdersRequest)
{
QueryOrderRequest queryOrderRequest = getOrdersRequest != null
? new QueryOrderRequest(getOrdersRequest.Offset,
getOrdersRequest.Take
)
{
OrderId = getOrdersRequest.OrderId
}
: null;
OrderCollectionResponse orderCollectionResponse = await _orderService.QueryOrderAsync(queryOrderRequest);
return(StatusCode((int)HttpStatusCode.OK, orderCollectionResponse));
}
public async Task TestSearchOrdersAsync()
{
// Arrange
var userInfo = IdentityMocker.GetCustomerIdentity().GetUserInfo();
var service = ServiceMocker.GetSalesService(userInfo, nameof(TestSearchOrdersAsync), true);
var controller = new SalesController(null, null, null, service);
var request = new GetOrdersRequest();
// Act
var response = await controller.GetOrdersAsync(request) as ObjectResult;
var value = response.Value as IPagedResponse <OrderInfo>;
// Assert
Assert.False(value.DidError);
}
public List <Order> All(uint offset = 0, uint limit = 0, string ordering = "-created", string loanOfficer = null, string filters = "")
{
var result = new GetOrdersRequest(offset, limit, ordering, loanOfficer, filters).Execute(Api.Client);
var fetchedOrders = result.Data.Orders;
List <Order> orders = new List <Order>();
if (result.Status == 200)
{
for (int i = 0; i < fetchedOrders.Count; i++)
{
Order tempOrder = new Order();
tempOrder.UpdateFromRequest(Utils.DictionaryOfJsonFields(fetchedOrders[i]));
orders.Add(tempOrder);
}
}
return(orders);
}
public async Task <IActionResult> GetOrders([FromBody] GetOrdersRequest request)
{
var ordersToSkip = (request.Page - 1) * request.Count;
var(responseOrders, filteredOrdersCount) = await orderManager.GetOrdersAsync(ordersToSkip, request.Count, request.Ascending,
request.OrderDateFrom, request.OrderDateTo, request.DeliveryDateFrom, request.DeliveryDateTo, request.IsApproved, request.IsDelivered);
var ordersForResponse = responseOrders.ToList();
var response = new GetOrdersResponse
{
Orders = ordersForResponse,
OrdersCount = filteredOrdersCount
};
return(Ok(response));
}
//Refresh the page every 10 seconds
public async Task AutoRefreshEnabled()
{
while (true)
{
uxReceivedOrdersControl0.IsEnabled = false;
uxReceivedOrdersControl1.IsEnabled = false;
uxReceivedOrdersControl2.IsEnabled = false;
uxReceivedOrdersControl4.IsEnabled = false;
var validSendGetOrdersRequest = await GetOrdersRequest.SendGetOrdersRequest();
RefreshItemSource();
uxReceivedOrdersControl0.IsEnabled = true;
uxReceivedOrdersControl1.IsEnabled = true;
uxReceivedOrdersControl2.IsEnabled = true;
uxReceivedOrdersControl4.IsEnabled = true;
await Task.Delay(TimeSpan.FromSeconds(10));
}
}
private IList <OrderListDTO> getOrders(OrderSearchType searchType, int customerid)
{
try
{
GetOrdersRequest request = new GetOrdersRequest();
request.SearchType = searchType;
request.CustomerId = customerid;
GetOrdersResponse response = Service.GetOrdersByCriteria(request);
return(response.Orders);
}
catch (Exception ex)
{
if (ExceptionPolicy.HandleException(ex, "PL Policy"))
{
throw;
}
return(new List <OrderListDTO>());
}
}
public async Task GetOrdersByEmployeeAsync()
{
// Arrange
var userInfo = IdentityMocker.GetCustomerIdentity().GetUserInfo();
var service = ServiceMocker.GetSalesService(userInfo, nameof(GetOrdersByEmployeeAsync), true);
var controller = new SalesController(null, null, null, service);
var request = new GetOrdersRequest
{
EmployeeID = 1
};
// Act
var response = await controller.GetOrdersAsync(request) as ObjectResult;
var value = response.Value as IPagedResponse <OrderInfo>;
// Assert
Assert.False(value.DidError);
Assert.True(value.Model.Count(item => item.EmployeeID == request.EmployeeID) == value.Model.Count());
}
public override Task <GetOrdersResponse> GetOrders(GetOrdersRequest request, ServerCallContext context)
{
var service = new BlazorInsider.App.Services.DatabaseService();
var orders = service.GetOrders();
var result = new GetOrdersResponse();
foreach (var item in orders)
{
var order = new GetOrderModel()
{
OrderID = item.OrderId,
Description = item.Description,
Quantity = item.Quantity,
Status = item.Status,
Total = item.Total
};
result.GetOrderModels.Add(order);
}
return(Task.FromResult(result));
}
public List <Order> GetOrders(GetOrdersRequest request)
{
var orders = new List <Order>();
foreach (var orderId in request.OrderIds)
{
orders.Add(new Order
{
OrderId = orderId,
Customer = new Customer
{
FirstName = "John",
LastName = "Doe",
DateOfBirth = DateTime.UtcNow
},
DateTimePlaced = DateTime.Now,
Skus = new List <string> {
"a1", "a2"
}
});
}
return(orders);
}
/// <remarks/>
public void GetOrdersAsync(GetOrdersRequest GetOrdersRequest) {
this.GetOrdersAsync(GetOrdersRequest, null);
}
/// <remarks/>
public void GetOrdersAsync(GetOrdersRequest GetOrdersRequest, object userState) {
if ((this.GetOrdersOperationCompleted == null)) {
this.GetOrdersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetOrdersOperationCompleted);
}
this.InvokeAsync("GetOrders", new object[] {
GetOrdersRequest}, this.GetOrdersOperationCompleted, userState);
}
