public void PaymentCallBack(FormCollection collection)
{
int orderId = _paymentService.GetOrderIdFor(collection);
GetOrderRequest request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest =
response.Order.ConvertToOrderPaymentRequest();
TransactionResult transactionResult =
_paymentService.HandleCallBack(orderPaymentRequest, collection);
if (transactionResult.PaymentOk)
{
SetOrderPaymentRequest paymentRequest = new SetOrderPaymentRequest();
paymentRequest.Amount = transactionResult.Amount;
paymentRequest.PaymentToken = transactionResult.PaymentToken;
paymentRequest.PaymentMerchant = transactionResult.PaymentMerchant;
paymentRequest.OrderId = orderId;
_orderService.SetOrderPayment(paymentRequest);
}
else
{
LoggingFactory.GetLogger().Log(String.Format(
"Payment not ok for order id {0}, payment token {1}",
orderId, transactionResult.PaymentToken));
}
}
public static async Task <GetOrderResponse> GetOrder3(string orderID)
{
TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1);
double timeUnix = t.TotalSeconds;
HttpRequestMessage mesg = new HttpRequestMessage()
{
RequestUri = new Uri("account/getorder?apikey=" + API_KEY3 + "&nonce=" + timeUnix + "&uuid=" + orderID, UriKind.Relative),
Method = HttpMethod.Get
};
//Compute Signature and add to request header:
string sign = GetSignature3(new Uri(client.BaseAddress, mesg.RequestUri));
mesg.Headers.Add("apisign", sign);
//SendAsync request and await response object:
GetOrderResponse orderResponse = null;
HttpResponseMessage response = await client.SendAsync(mesg);
if (response.IsSuccessStatusCode)
{
orderResponse = await response.Content.ReadAsAsync <GetOrderResponse>();
}
return(orderResponse);
}
public IActionResult GetOrder([FromRoute] long id)
{
Order order = orderService.GetOrder(id);
GetOrderResponse getOrderResponse = new GetOrderResponse(order.Id, order.OrderDetails, order.State, order.Version);
return(Ok(getOrderResponse));
}
public void GetOrder(int wid, string openid, int orderId)
{
AjaxResult ajaxResult;
try
{
GetOrderResponse responseData = null;
IAsyncResult asyncResult = new BusEntry("WeixinPF.Hotel.Plugins").MyBus.Send("WeixinPF.Hotel.Plugins.Service", new GetOrderRequest()
{
OrderId = orderId
})
.Register(response =>
{
CompletionResult result = response.AsyncState as CompletionResult;
if (result != null)
{
responseData = result.Messages[0] as GetOrderResponse;
}
}, this);
WaitHandle asyncWaitHandle = asyncResult.AsyncWaitHandle;
asyncWaitHandle.WaitOne(WaitSeconds);
ajaxResult = asyncResult.IsCompleted ?
AjaxResult.Succeed(responseData.Order) :
AjaxResult.Fail("获取订单信息失败。");
}
catch
{
ajaxResult = AjaxResult.Fail("获取订单信息失败。");
}
this.WriteJson(ajaxResult);
}
public GetOrderResponse GetOrders(string surname = null)
{
var response = new GetOrderResponse();
if (surname == null)
{
response.orders = _context.Order.ToList();
return(response);
}
var customer = _context.Customer.FirstOrDefault(s => s.Surname == surname);
if (customer == null)
{
throw new Exception("there is no such customer");
}
var order = _context.Order.Where(o => o.IdCustomer == customer.IdCustomer).FirstOrDefault();
var confectionery_order = _context.Confectionery_Order.FirstOrDefault(co => co.IdOrder == order.IdOrder);
var confectionery = _context.Confectionery.Where(c => c.IdConfectionery == confectionery_order.IdConfectionery).FirstOrDefault();
response.DateAccepted = order.DateAccepted;
response.DateFinished = order.DateFinished;
response.Notes = order.Notes;
response.NameConfectionery = confectionery.Name;
return(response);
}
private async Task <GetOrderResult> CancelOrderGetData(string UniqueID, string OrderID)
{
//CANCEL ORDER:
var cancelRequest = await BtrexREST.CancelLimitOrder(OrderID);
if (!cancelRequest.success)
{
Trace.WriteLine(" !!!!ERR CANCEL-ORDER>>> " + UniqueID + ": " + cancelRequest.message);
return(null);
}
//Get data from cancelled order:
var canceledOrderData = new GetOrderResponse();
do
{
canceledOrderData = await BtrexREST.GetOrder(OrderID);
if (!canceledOrderData.success)
{
Trace.WriteLine(" !!!!ERR GET-CANCELED-ORDDATA>>> " + UniqueID + ": " + canceledOrderData.message);
}
}while (canceledOrderData.result == null || canceledOrderData.result.IsOpen == false);
return(canceledOrderData.result);
}
public override Task <GetOrderResponse> GetOrder(GetOrderRequest request, grpc::ServerCallContext context)
{
var response = new GetOrderResponse();
var order = this.repository.GetOrder(request.OrderID);
if (order != null)
{
response.OrderID = order.OrderId;
response.CreatedOn = (ulong)order.CreatedOn;
response.TaxRate = (uint)order.TaxRate;
foreach (var li in order.LineItems)
{
response.LineItems.Add(new LineItem
{
SKU = li.SKU,
Quantity = (uint)li.Quantity,
UnitPrice = (uint)li.UnitPrice,
});
}
var status = OrderStatus.Open;
if (order.Activities.FirstOrDefault(a => a.ActivityType == ActivityType.Canceled) != null)
{
status = OrderStatus.Canceled;
}
response.Status = status;
}
return(Task.FromResult(response));
}
public GetOrderResponse GetOrder(GetOrderRequest agor_gor)
{
GetOrderResponse lgor_response;
lgor_response = new GetOrderResponse();
lgor_response.status = new Status();
try
{
IOrderServiceBusiness liosb_iosb;
liosb_iosb = new OrderServiceBusiness();
lgor_response = liosb_iosb.GetOrder(agor_gor);
}
catch (Exception ae_e)
{
Exception le_e;
le_e = ae_e.InnerException != null ? ae_e.InnerException : ae_e;
lgor_response.status.CodeResp = "01";
lgor_response.status.MessageResp = ae_e.InnerException != null ? "Error en la ejecucion del servicio" : ae_e.Message;
lgor_response.result = null;
Common.CreateTrace.WriteLog(Common.CreateTrace.LogLevel.Error, "ERROR EN LA CAPA DE SERVICIO OrderService:GetOrder");
Common.CreateTrace.WriteLog(Common.CreateTrace.LogLevel.Error, " :: " + le_e.Message);
}
return(lgor_response);
}
public async Task PaymentCallBack(IFormCollection collection)
{
int orderId = _paymentService.GetOrderIdFor(collection);
GetOrderRequest request = new GetOrderRequest
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest = _mapper.Map <OrderView, OrderPaymentRequest>(response.Order);
TransactionResult transactionResult = await _paymentService.HandleCallBack(orderPaymentRequest, collection);
if (transactionResult.PaymentOk)
{
SetOrderPaymentRequest paymentRequest = new SetOrderPaymentRequest();
paymentRequest.Amount = transactionResult.Amount;
paymentRequest.PaymentToken = transactionResult.PaymentToken;
paymentRequest.PaymentMerchant = transactionResult.PaymentMerchant;
paymentRequest.OrderId = orderId;
paymentRequest.CustomerEmail = _cookieAuthentication.GetAuthenticationToken();
_orderService.SetOrderPayment(paymentRequest);
}
else
{
_logger.LogWarning(string.Format("Payment not ok for order id {0}, payment token {1}", orderId, transactionResult.PaymentToken));
}
}
public void Execute()
{
Console.Clear();
OrderManager orderManager = OrderManagerFactory.Create();
Console.WriteLine("Remove Order");
Console.WriteLine("************");
_orderDate = prompt.GetOrderDate();
_orderNumber = prompt.GetOrderNumber();
// Sends the order date and order number off to the order manager to get the order requested
GetOrderResponse getOrderResponse = orderManager.GetOrder(_orderDate, _orderNumber);
if (!getOrderResponse.IsValidDate)
{
prompt.PrintError(ErrorCode.NotAValidDate);
}
else if (!getOrderResponse.IsFutureDate)
{
prompt.PrintError(ErrorCode.NotAFutureDate);
}
else if (!getOrderResponse.Success)
{
prompt.PrintError(getOrderResponse.Code);
}
else
{
// Sends the order to the order manager for validation
ValidateRemoveOrderResponse response = orderManager.ValidateRemoveOrder(_orderDate, getOrderResponse.Order);
if (!response.Success)
{
prompt.PrintError(response.Code);
}
else
{
// Prints the order to be removed to the screen for confirmation
prompt.PrintOrder(_orderDate, getOrderResponse.Order);
// Gets confirmation on whether to remove or not
do
{
_code = prompt.GetConfirmation("remove");
} while (_code == YesNo.Invalid);
// If user decides not to remove, print that to the screen
if (_code == YesNo.No)
{
prompt.PrintError(ErrorCode.DidntConfirmOrder);
}
else
{
// Sends the orders list to the order manager to be written to the file
orderManager.RemoveOrder(response.Orders);
prompt.PrintSuccessMessage("Order removed successfully.");
}
}
}
}
public GetOrderResponse GetOrder(GetOrderRequest request)
{
GetOrderResponse response = new GetOrderResponse();
Order order = _orderRepository.FindBy(request.OrderId);
response.Order = _mapper.Map <Order, OrderView>(order);
return(response);
}
public GetOrderResponse GetOrderById(GetOrderRequest request)
{
GetOrderResponse response = new GetOrderResponse();
OrderBusinessComponent bc = DependencyInjectionHelper.GetOrderBusinessComponent();
response.Order = OrderAdapter.OrderToDto(bc.GetOrderById(request.Id));
return(response);
}
public GetOrderResponse GetOrder(GetOrderRequest request)
{
GetOrderResponse response = new GetOrderResponse();
Order order = _orderRepository.FindBy(request.OrderId);
response.Order = order.ConvertToOrderView();
return(response);
}
public GetOrderResponse GetOrder(GetOrderRequest request)
{
var order = _repository.GetOrder(request.Id);
var response = new GetOrderResponse()
{
Order = OrderApiDto.FromDomain(order)
};
return(response);
}
public IActionResult CreatePaymentFor(int orderId)
{
GetOrderRequest request = new GetOrderRequest
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest = _mapper.Map <OrderView, OrderPaymentRequest>(response.Order);
PaymentPostData paymentPostData = _paymentService.GeneratePostDataFor(orderPaymentRequest);
return(View("PaymentPost", paymentPostData));
}
public GetOrderResponse GetOrder(int request)
{
var getOrderResponse = new GetOrderResponse();
try
{
var query = from b in context.BuysEntity
join bd in context.BuysDetailsEntity on b.IdBuy equals bd.IdBuy
where (b.IdOrder == request)
select new
{
buyDetails = new BuysDetailsEntity
{
IdBuyDetail = bd.IdBuyDetail,
IdProduct = bd.IdProduct,
Quantity = bd.Quantity,
IdBuy = bd.IdBuy
},
buyheader = new BuysEntity
{
IdBuy = b.IdBuy,
UploadDate = b.UploadDate,
TotalAmount = b.TotalAmount,
IdOrder = b.IdOrder,
IdClient = b.IdClient
}
};
if (query != null)
{
var ListTemp = new List <BuysDetailsEntity>();
foreach (var obj in query)
{
if (getOrderResponse.IdClient == 0)
{
getOrderResponse.IdBuy = obj.buyheader.IdBuy;
getOrderResponse.UploadDate = obj.buyheader.UploadDate;
getOrderResponse.TotalAmount = obj.buyheader.TotalAmount;
getOrderResponse.IdOrder = obj.buyheader.IdOrder;
getOrderResponse.IdClient = obj.buyheader.IdClient;
}
ListTemp.Add(obj.buyDetails);
}
getOrderResponse.BuyDetailsEntities = ListTemp;
}
}
catch (Exception ex)
{
Console.WriteLine("OrderDataAccess.GetOrder : ERROR : " + ex.Message);
throw;
}
return(getOrderResponse);
}
public GetOrderResponse GetOrderById(GetOrderRequest request)
{
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
throw new FaultException <NotAuthenticatedFault>(new NotAuthenticatedFault());
}
GetOrderResponse response = new GetOrderResponse();
OrderBusinessComponent bc = DependencyInjectionHelper.GetOrderBusinessComponent();
response.Order = OrderAdapter.OrderToDto(bc.GetOrderById(request.Id));
return(response);
}
public void GetPatientNextOrder_ReturnsNonCancelledOrder()
{
//arrange
var utcNow = DateTime.UtcNow;
var patient = _fixture
.Build <Patient>()
.Without(x => x.Orders)
.Create();
var cancelledOrder = _fixture
.Build <Order>()
.With(x => x.StartTime, utcNow.AddHours(1))
.With(x => x.IsCancelled, true)
.With(x => x.PatientId, patient.Id)
.With(x => x.SurgeryType, (int)patient.Clinic.SurgeryType)
.Without(x => x.Doctor)
.Without(x => x.Patient)
.Create();
var nonCancelledOrder = _fixture
.Build <Order>()
.With(x => x.StartTime, utcNow.AddHours(2))
.With(x => x.IsCancelled, false)
.With(x => x.PatientId, patient.Id)
.With(x => x.SurgeryType, (int)patient.Clinic.SurgeryType)
.Without(x => x.Doctor)
.Without(x => x.Patient)
.Create();
_context.Patient.Add(patient);
_context.Order.Add(cancelledOrder);
_context.Order.Add(nonCancelledOrder);
_context.SaveChanges();
var expected = new GetOrderResponse
{
Id = nonCancelledOrder.Id,
StartTime = nonCancelledOrder.StartTime,
EndTime = nonCancelledOrder.EndTime,
DoctorId = nonCancelledOrder.DoctorId,
PatientId = nonCancelledOrder.PatientId,
SurgeryType = nonCancelledOrder.SurgeryType
};
//act
var res = _orderService.GetPatientNextOrder(patient.Id);
//assert
res.Should().BeEquivalentTo(expected);
}
public CustomerOrderView getCustomerOrderView(int orderId)
{
GetOrderRequest request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
CustomerOrderView orderView = new CustomerOrderView();
orderView.BasketSummary = base.GetBasketSummaryView();
orderView.Order = response.Order;
return(orderView);
}
public IActionResult Detail(int orderId)
{
GetOrderRequest request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
CustomerOrderView orderView = new CustomerOrderView();
orderView.BasketSummary = GetBasketSummaryView();
orderView.Order = response.Order;
return(View(orderView));
}
public ActionResult CreatePaymentFor(int orderId)
{
GetOrderRequest request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest = response.Order.ConvertToOrderPaymentRequest();
PaymentPostData paymentPostData = _paymentService.GeneratePostDataFor(orderPaymentRequest);
return(View("PaymentPost", paymentPostData));
}
public void TestGetOrder()
{
int orderId = 1;
GetOrderResponse response = new GetOrderResponse();
response.Order = new OrderDTO()
{
Id = orderId
};
Expect.Once.On(service).Method("GetOrderById").Will(Return.Value(response));
OrderDTO order = serviceFacade.GetOrderById(orderId);
Assert.AreEqual(order.Id, orderId);
}
public JsonResult GetDetail(System.Int32 id)
{
OrderDetailView vm = new OrderDetailView();
GetOrderRequest request = new GetOrderRequest();
request.OrderID = id;
GetOrderResponse response = _orderService.GetOrder(request);
if (response.OrderFound)
{
vm = response.Order.ConvertToOrderDetailView();
}
return(Json(vm, JsonRequestBehavior.AllowGet));
}
public PaymentPostData CreatePaymentPostData(int orderId)
{
GetOrderRequest request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest =
response.Order.ConvertToOrderPaymentRequest();
PaymentPostData paymentPostData =
_paymentService.GeneratePostDataFor(orderPaymentRequest);
return(paymentPostData);
}
public ActionResult <PaymentPostData> CreatePaymentFor(int orderId)
{
var request = new GetOrderRequest()
{
OrderId = orderId
};
GetOrderResponse response = _orderService.GetOrder(request);
OrderPaymentRequest orderPaymentRequest =
DTOs.OrderMapper.ConvertToOrderPaymentRequest(response.Order);
PaymentPostData paymentPostData =
_paymentService.GeneratePostDataFor(orderPaymentRequest);
return(paymentPostData);
}
/// <summary>
/// Retrieve an order with specified ID.
/// </summary>
/// <param name="apiKey">Your apiKey.</param>
/// <param name="apiSecret">Your apiSecretKey.</param>
/// <param name="ID">The ID of an order.</param>
/// <response code="200">The order with a specified ID.</response>
/// <response code="400_InvalidUrlParameters">Invalid URL parameters.</response>
/// <response code="403">Not authorized to use this endpoint.</response>
/// <response code="404">Order is not found.</response>
/// <response code="500">Server error.</response>
/// <returns></returns>
public async Task <Result <GetOrderResponse, ErrorResponse> > GetOrderAsync(string apiKey, string apiSecret, Guid?ID)
{
#region
if (ID == null || ID == Guid.Empty)
{
throw new ArgumentNullException(nameof(ID));
}
#endregion
string token = getAuthToken(apiKey, apiSecret);
var result = new Result <GetOrderResponse, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/Orders/{ID}";
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add(AUTHORIZATION, $"{BASIC} {token}");
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
{
if (response.IsSuccessStatusCode)
{
GetOrderResponse orderResponse = await response.Content.ReadAsAsync <GetOrderResponse>();
result.IsSuccess = true;
result.Data = orderResponse;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
public OrderDTO GetOrderById(int id)
{
try
{
GetOrderRequest request = new GetOrderRequest();
request.Id = id;
GetOrderResponse response = Service.GetOrderById(request);
return(response.Order);
}
catch (Exception ex)
{
if (ExceptionPolicy.HandleException(ex, "PL Policy"))
{
throw;
}
return(new OrderDTO());
}
}
private GetOrderResponse InvokeGetOrder(PXGraph graph, ServiceCallParameters objParams)
{
GetOrderResponse getOrderRes = new GetOrderResponse();
try
{
GetOrderRequest request = new GetOrderRequest();
request.SellerId = objParams.objSOAmazonSetup.SellerId;
request.MWSAuthToken = objParams.objSOAmazonSetup.AuthToken;
List <string> liAmazonOrderId = new List <string>();
if (!string.IsNullOrEmpty(objParams.amwOrderID))
{
liAmazonOrderId.Add(objParams.amwOrderID);
}
request.AmazonOrderId = liAmazonOrderId;
getOrderRes = this.clientOrder.GetOrder(request);
}
catch (Exception ex)
{
if (ex is MarketplaceWebServiceOrdersException)
{
MarketplaceWebServiceOrdersException exception = ex as MarketplaceWebServiceOrdersException;
if (!string.IsNullOrEmpty(exception.ErrorCode) && exception.ErrorCode.ToLower().Trim() == SOMessages.requestThrottled)
{
Thread.Sleep(SOHelper.DelayProcess(graph, SOConstants.apiGetOrder));
getOrderRes = InvokeGetOrder(graph, objParams);
}
else
{
throw new PXException(!string.IsNullOrEmpty(ex.Message) ? ex.Message :
ex.InnerException != null && ex.InnerException.InnerException != null ? ex.InnerException.InnerException.Message
: SOConstants.exceptionIsEmpty);
}
}
else
{
throw new PXException(!string.IsNullOrEmpty(ex.Message) ? ex.Message :
ex.InnerException != null && ex.InnerException.InnerException != null ? ex.InnerException.InnerException.Message
: SOConstants.exceptionIsEmpty);
}
}
return(getOrderRes);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
GetOrderResponse response = new GetOrderResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("Order", targetDepth))
{
var unmarshaller = OrderUnmarshaller.Instance;
response.Order = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public async Task <GetOrderResponse> GetOrderAsync(GetOrderRequest request)
{
var response = new GetOrderResponse {
Code = 200
};
try
{
var result = await this.gateway.GetOrderAsync(request.Order.AsEntity());
response.Order = result.AsResponse();
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
response.Code = 500;
}
return(response);
}
public object Get(GetOrder request)
{
GetOrderResponse response=new GetOrderResponse();
response.Goodses = Db.Select<Goods>();
response.Costs = Db.Select<Cost>();
response.Customers = Db.Select<Customer>().OrderBy(e=>e.Khmc).ToList();
response.Categories = Db.Select<Category>();
if (request.ID==0)
{
response.Order=new Order() {OrderGoodses = new List<OrderGoods>()};
}
else
{
response.Order = Db.SingleById<Order>(request.ID);
response.Order.OrderGoodses = Db.Select<OrderGoods>(e => e.OrderID == request.ID);
response.Order.OrderCosts = Db.Select<OrderCost>(e => e.OrderID == request.ID);
foreach (var orderGoodse in response.Order.OrderGoodses)
{
var goods = response.Goodses.FirstOrDefault(e => e.ID == orderGoodse.GoodsID);
if (goods!=null)
{
orderGoodse.Category = goods.Category;
orderGoodse.Name = goods.Name;
orderGoodse.Size = goods.Size;
}
}
foreach (var orderCost in response.Order.OrderCosts)
{
var cost = response.Costs.FirstOrDefault(e => e.ID == orderCost.CostID);
if (cost!=null)
{
orderCost.Name = cost.Name;
}
}
}
return response;
}
