public async Task <IActionResult> GetOrder(Guid orderId)
{
var command = new GetOrder(orderId);
var accountProjection = await _mediator.Send(command);
return(Ok(accountProjection));
}
public async Task <IActionResult> GetOrderInfo(string customerId)
{
var currUser = customerId;
if (currUser == "undefined")
{
currUser = _httpContextAccessor.HttpContext.Request.Cookies["anonymousUsr"];
}
var Order = new GetOrder(_context).Do(currUser, "Pending");
if (Order == null)
{
await new CreateOrder(_context).Do(new OrderViewModel
{
Status = "Pending",
CustomerId = currUser
});
Order = new GetOrder(_context).Do(currUser, "Pending");
}
var OrderInfos = new GetOrderInfo(_context).Do(Order.OrderId);
if (OrderInfos == null)
{
OrderInfos = new OrderInfosViewModel {
OrderRefId = Order.OrderId
}
}
;
return(Ok(OrderInfos));
}
private void GetWorkdayContext(GetOrder<int, IWorkdayContext> order)
{
var callback = order.Callback;
var projectId = order.Param;
var context = new WorkdayContext(Path.Combine(this.workdaySettingFolder, projectId + ".json"));
callback(context);
}
public void GetOrderWithJsonServClt()
{
GetOrder request = new GetOrder
{
Id = 1,
CustomerName = "客户_1",
//IsTakeAway = true,
StatusCode = StatusCode.Active,
CreatedDate = DateTime.Now
};
OrderResponse response = null;
using (JsonServiceClient client = new JsonServiceClient(listenOnUrl))
{
response = client.Get <OrderResponse>(request);
}
if (response != null)
{
response.PrintDump();
}
Console.WriteLine("成功获取指定的订单详情。");
Console.ReadLine();
}
public async Task <IActionResult> OnGet()
{
var currUser = _userManager.GetUserId(User);
ShoppingCart = new GetShoppingCart(_context).Do(currUser);
CartItems = new GetCartItems(_context).Do(ShoppingCart.CartId);
Products = new GetAllProducts(_context).Do()
.Where(prod => CartItems.Select(cartItem => cartItem.ProductRefId)
.Contains(prod.ProductId));
Order = new GetOrder(_context).Do(currUser, "Pending");
foreach (var cartitem in CartItems.ToList())
{
await new CreateProductInOrder(_context).Do(new ProductInOrdersViewModel
{
OrderRefId = Order.OrderId,
ProductRefId = cartitem.ProductRefId,
UsedQuantity = cartitem.Quantity,
});
await new UpdateProduct(_context, _fileManager).UpdateStockAfterOrder(cartitem.ProductRefId, cartitem.Quantity);
}
Order.Status = "Ordered";
Order.TotalOrdered = ShoppingCart.TotalInCart;
await new UpdateOrder(_context).Do(Order);
ShoppingCart.Status = "Closed";
await new UpdateShoppingCart(_context).Do(ShoppingCart);
return(RedirectToPage("/Account/Manage/Orders", new { Area = "Identity" }));
}
public async Task <IActionResult> Order(
[FromServices] IEmailSink emailSink,
[FromServices] IWebHostEnvironment env,
[FromServices] GetOrder getOrder,
[FromServices] IEmailTemplateFactory etf)
{
if (env.IsProduction())
{
return(Ok());
}
var order = getOrder.ForUserById("dummy");
// var templatePath = Path.Combine(env.WebRootPath, "email-templates", "order.liquid");
// var templateString = await System.IO.File.ReadAllTextAsync(templatePath);
// var template = Template.Parse(templateString);
await emailSink.SendAsync(new SendEmailRequest
{
Subject = $"Order Placed, {order.Id}",
To = "*****@*****.**",
Message = await etf.RenderShippingConfirmationAsync(order),// template.Render(Hash.FromAnonymousObject(OrderProjections.Project(order))),
Html = true,
});
return(Ok());
}
public async Task <IActionResult> Order(
[FromServices] IEmailSink emailSink,
[FromServices] IWebHostEnvironment env,
[FromServices] GetOrder getOrder)
{
if (env.IsProduction())
{
return(Ok());
}
var order = getOrder.Do("dummy");
var templatePath = Path.Combine(env.WebRootPath, "email-templates", "order.liquid");
var templateString = await System.IO.File.ReadAllTextAsync(templatePath);
var template = Template.Parse(templateString);
await emailSink.SendAsync(new EmailRequest
{
Subject = "Test",
To = "*****@*****.**",
Message = template.Render(Hash.FromAnonymousObject(ToAnon(order))),
Html = true,
});
return(Ok());
}
public Action(GetAbstractConsequences consequences, GetOrder order, System.Type requiredSubjectType = null, System.Type requiredTargetType = null, string name = "Action")
{
this.name = name;
this.consequences = consequences;
this.order = order;
this.subjectType = requiredSubjectType;
this.targetType = requiredTargetType;
Actions.RegisterAction(this);
}
public Task <Order> Handle(GetOrder request, CancellationToken cancellationToken)
{
return(Task.FromResult(new Order()
{
CustomerId = 1234,
Id = 2201,
OrderTotal = 9.95m,
OrderLines = new List <OrderLine>()
}));
}
public async Task <ActionResult <OrderDto> > Get([FromRoute] GetOrder query)
{
var order = await _queryDispatcher.QueryAsync(query);
if (order is null)
{
return(NotFound());
}
return(order);
}
public Task <Order> Handle(GetOrder request, CancellationToken cancellationToken)
{
//Interact with Service, DatabaseContext, Stream or something else
return(Task.FromResult(new Order()
{
CustomerId = 1234,
Id = 2201,
OrderTotal = 9.95m,
OrderLines = new List <OrderLine>()
}));
}
public PaymentModel(
ApplicationDbContext ctx,
CreateOrder createOrder,
GetOrder getOrder,
OneOffPayment payment)
{
_ctx = ctx;
_payment = payment;
_createOrder = createOrder;
_getOrder = getOrder;
}
public OrderReply GetOrder(Stock stock, int id)
{
GetOrder request = new GetOrder(Name, stock, id);
bool success = request.Execute();
OrderReply reply = (request.Reply as OrderReply) ?? new OrderReply(false);
if (success)
{
UpdateOrder(reply);
}
return(reply);
}
//获取指定订单详情：
public OrderResponse Get(GetOrder request)
{
OrderResponse result = OrderRepository.GetOrder(request);
if (result == null)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(default(OrderResponse));
}
return(result);
}
public async Task <IActionResult> Payment(string stripeEmail, string stripeToken)
{
//stripe custom classes
var customers = new CustomerService();
var charges = new ChargeService();
var CartOrder = new GetOrder(HttpContext.Session, _db).Get();
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
Source = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = CartOrder.GetTotalCharge(),
Description = "Shop Purchase",
Currency = "USD",
Customer = customer.Id
});
var sessionId = HttpContext.Session.Id;
await new CreateOrder(_db).Create(new CustomerInformation
{
StripeReference = charge.Id,
SessionId = sessionId,
FirstName = CartOrder.CustomerInformation.FirstName,
LastName = CartOrder.CustomerInformation.LastName,
Email = CartOrder.CustomerInformation.Email,
PhoneNumber = CartOrder.CustomerInformation.PhoneNumber,
Adress1 = CartOrder.CustomerInformation.Adress1,
Adress2 = CartOrder.CustomerInformation.Adress2,
City = CartOrder.CustomerInformation.City,
PostCode = CartOrder.CustomerInformation.PostCode,
Stocks = CartOrder.Products.Select(x => new CreateOrder.Stock
{
StockId = x.StockId,
Qty = x.Qty
}).ToList()
});
return(View());
}
//returns a single order
public OrderResponse Get(GetOrder request)
{
var domainObject = OrderRepository.GetById(request.Id);
if (domainObject == null)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(null);
}
else
{
//transform to OrderResponse and return
return(OrderMapper.ToOrderResponse(domainObject));
}
}
public async Task <IActionResult> OnPost(string stripeEmail, string stripeToken)
{
var customers = new CustomerService();
var charges = new ChargeService();
var CartOrder = new GetOrder(HttpContext.Session, _ctx).Do();
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = CartOrder.GetTotalCharge(),
Description = "Sample Charge",
Currency = "eur",
CustomerId = customer.Id
});
var sessionID = HttpContext.Session.Id;
#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
await new CreateOrder(_ctx).Do(new CreateOrder.Request
{
StripeRef = charge.Id,
SessionID = sessionID,
FirstName = CartOrder.CustomerInformation.FirstName,
LastName = CartOrder.CustomerInformation.LastName,
email = CartOrder.CustomerInformation.email,
PhoneNumber = CartOrder.CustomerInformation.PhoneNumber,
Address1 = CartOrder.CustomerInformation.Address1,
Address2 = CartOrder.CustomerInformation.Address2,
City = CartOrder.CustomerInformation.City,
PostCode = CartOrder.CustomerInformation.PostCode,
Stocks = CartOrder.Robots.Select(x => new CreateOrder.Stock
{
StockID = x.StockID,
Quantity = x.Quantity
}).ToList()
});
#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
HttpContext.Session.Clear();
return(RedirectToPage("/Index"));
}
public IActionResult OnGet(string id,
[FromServices] GetOrder getOrder)
{
if (string.IsNullOrEmpty(id))
{
return(RedirectToPage("/Index"));
}
Order = getOrder.Do(id);
if (Order == null)
{
return(RedirectToPage("/Index"));
}
return(Page());
}
public async Task <IActionResult> OnPost(string stripeEmail, string stripeToken)
{
var customers = new CustomerService();
var charges = new ChargeService();
var CartOrder = new GetOrder(HttpContext.Session, _context).Do();
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = CartOrder.GetTotalCharge(),
Description = "Sample Charge",
Currency = "usd",
CustomerId = customer.Id
});
var sessionId = HttpContext.Session.Id;
await new CreateOrder(_context).Do(new CreateOrder.Request
{
StripeReference = charge.OrderId,
SessionId = sessionId,
FirstName = CartOrder.CustomerInformation.FirstName,
LastName = CartOrder.CustomerInformation.LastName,
Email = CartOrder.CustomerInformation.Email,
PhoneNumber = CartOrder.CustomerInformation.PhoneNumber,
Address1 = CartOrder.CustomerInformation.Address1,
Address2 = CartOrder.CustomerInformation.Address2,
City = CartOrder.CustomerInformation.City,
PostCode = CartOrder.CustomerInformation.PostCode,
Stocks = CartOrder.Products.Select(x => new CreateOrder.Stock
{
StockId = x.StockId,
Qty = x.Qty
}).ToList()
});
return(RedirectToPage("/Index"));
}
/// <summary>
/// Initializes a new instance of the <see cref="GetOrderTest"/> class.
/// </summary>
public GetOrderTest()
{
this.orderId = 1;
this.customerId = 1;
this.request = new GetVisitorOrderRequest(this.orderId.ToString(), this.customerId.ToString(), "NopShop");
this.result = new GetVisitorOrderResult();
this.args = new ServicePipelineArgs(this.request, this.result);
this.client = Substitute.For <IOrdersServiceChannel>();
var clientFactory = Substitute.For <ServiceClientFactory>();
clientFactory.CreateClient <IOrdersServiceChannel>(Arg.Any <string>(), Arg.Any <string>()).Returns(this.client);
this.processor = new GetOrder {
ClientFactory = clientFactory
};
}
public OrderResponse GetOrder(GetOrder request)
{
OrderResponse result = orderList.OrderList.FirstOrDefault(x => x.Id == request.Id);
if (result != null)
{
if ((!string.IsNullOrWhiteSpace(request.CustomerName) && !result.CustomerName.Equals(request.CustomerName)) ||
(request.CreatedDate != DateTime.MinValue && result.CreatedDate.Date != request.CreatedDate.Date) ||
(request.StatusCode.HasValue && result.StatusCode != request.StatusCode) ||
(request.IsTakeAway.HasValue && result.IsTakeAway != request.IsTakeAway)
)
{
return(null);
}
}
return(result);
}
public void GetOrder()
{
// Arrange
var request = new GetOrder()
{
Meta = { MerchantId = 7454 },
Order =
{
OrderId = 1200003770
}
};
var text = request.ToString();
var caller = new ServiceApiCaller("HTTPS://ps.gcsip.nl/wdl/wdl");
// Act
var responseText = caller.Send(text);
// Assert
AssertResponseOk(responseText);
}
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;
}
//controller za payment
public IActionResult OnPost(string stripeEmail, string stripeToken)
{
var customers = new CustomerService();
var charges = new ChargeService();
var CartOrder = new GetOrder(HttpContext.Session, _ctx).Do();
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
Source = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = CartOrder.GetTotalCharge(),
Description = "Shop Purchase",
Currency = "eu",
Customer = customer.Id
});
return(RedirectToPage("/Index"));
}
public static void AddOrderToDb()
{
DataTable sellerAccountDt = Db.Db.GetEbayDeveloperInfo();
foreach (DataRow sellerAccountDr in sellerAccountDt.Rows)
{
try
{
string token = sellerAccountDr["Token"].ToString();
string accountName = sellerAccountDr["AccountName"].ToString();
List <string> exceptList = ConfigurationManager.AppSettings["exceptList"].Split(',').ToList();
if (exceptList.Contains(accountName))
{
continue;
}
else
{
List <EbayOrderType> orderList = GetOrder.GetOrderFromEbay(token, accountName);
foreach (EbayOrderType ebayOrderType in orderList)
{
try
{
Db.Db.AddEbayOrderToDb(ebayOrderType);
}
catch (Exception)
{
continue;// continue if order already exist in DB
}
}
}
}
catch (Exception ex)
{
throw ExceptionUtility.GetCustomizeException(ex);
}
}
}
private void GetUser(GetOrder<IUser> order)
{
order.Callback(this.context.GetUser(order.Predicate));
}
public Task <string> RenderOrderConfirmationAsync(Order order) =>
Compose(
RenderHeaderAsync(),
RenderTemplateAsync("order-confirmation", GetOrder.Projection(order)),
RenderFooterAsync()
);
public async Task <IActionResult> Get([FromRoute] GetOrder query) => Select(await Dispatcher.QueryAsync(query));
public IActionResult GetOrder(
int id,
[FromServices] GetOrder getOrder) =>
Ok(getOrder.Do(id));
private void GetProject(GetOrder <IProject> order)
{
order.Callback(this.context.GetProjects(order.Predicate));
}
private void GetTaskWithRecord(GetOrder <ITaskWithRecord> order)
{
order.Callback(this.context.GetTaskRecords(order.Predicate));
}
private void GetUser(GetOrder <IUser> order)
{
order.Callback(this.context.GetUser(order.Predicate));
}
public object Get(GetOrder request)
{
return(Db.SingleById <Customer>(request.CustomerId));
}
private void GetDeleteTaskRecordPermission(GetOrder<Tuple<int, int>, IPermission> order)
{
order.Callback(this.context.GetDeleteTaskRecordPermission(order.Param));
}
private void GetProject(GetOrder<IProject> order)
{
order.Callback(this.context.GetProjects(order.Predicate).Select(ToWithRecordsProject).ToArray());
}
private void GetTaskWithRecord(GetOrder<ITaskWithRecord> order)
{
order.Callback(this.context.GetTaskRecords(order.Predicate));
}
