/// <summary>
/// Place the order
/// </summary>
private void PlaceOrder()
{
SetState(TaskStateType.Placing);
// Create OrderEntry object
orderEntry = new OrderEntry();
// Wire up event handler for server response
orderEntry.TransactionResponse += orderEntry_TransactionResponse;
// Set order details
orderEntry.Client = Client;
orderEntry.Account = Account;
orderEntry.Quantity = Quantity;
orderEntry.Direction = Side;
orderEntry.OrderType = OType;
orderEntry.Instrument = Instrument;
if (OType == OrderType.Limit)
{
orderEntry.LimitPrice = Trigger;
}
// Send, ignoring any warnings
orderEntry.SendTransaction(true);
}
private static IList <OrderEntry> MockOrders(int count)
{
var orders = new List <OrderEntry>();
if (count == 0)
{
return(orders);
}
var order = new OrderEntry
{
OrderNumber = 111111,
VendorOrderNumber = "111111",
TrackingNumber = "EA222222222222222",
CreateDate = DateTime.Parse("2016-03-24 05:51:53"),
PaymentStatus = "ACCEPTED",
FulfillmentStatus = "SHIPPED",
PaymentMethod = "PayPal",
Email = "*****@*****.**"
};
count.Times(() => orders.Add(order));
return(orders);
}
public async Task <ActionResult> Payment_confirmation()
{
string orderno = Request.QueryString["invoice"];
// Save the order detail in database
if (Session["OrderInfo"] != null)
{
OrderEntry orderent = (OrderEntry)Session["OrderInfo"];
HttpClient client = detailAPI.Initial();
HttpContent content = new StringContent(JsonConvert.SerializeObject(orderent),
Encoding.UTF8, "application/json");
HttpResponseMessage res = await client.PostAsync("ShoppingCart/InsertCartItem", content);
if (res.IsSuccessStatusCode)
{
Session["cartitemcount"] = null;
Session["Shoppingcart"] = null;
await HeaderLoad();
Session["OrderInfo"] = null;
}
}
//Session["cartitemcount"] = null;
//Session["Shoppingcart"] = null;
//await HeaderLoad();
return(RedirectToAction("Payment_confirmation_succsess"));
}
public async Task <IActionResult> Edit(int?id, OrderEntry orderEntry)
{
if (id != orderEntry.OrderEntryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var restaurant = _session.GetInt32("restaurantsessionid");
if (restaurant != null)
{
orderEntry.RestaurantId = Convert.ToInt32(restaurant);
_db.Update(orderEntry);
await _db.SaveChangesAsync();
TempData["orderentry"] = "You have successfully modified " + orderEntry.Name + " Order Entry!!!";
TempData["notificationType"] = NotificationType.Success.ToString();
return(Json(new { success = true }));
}
}
return(RedirectToAction("Index"));
}
private void btnNewBill_Click(object sender, EventArgs e)
{
OrderEntry frmOrderEntry = new OrderEntry();
frmOrderEntry.OnClose += GenerateChallanList;
frmOrderEntry.Show(this);
}
public async Task <Response <Order> > PlaceOrder(AddOrderRequest request)
{
var order = new Order();
double total = 0;
List <OrderEntry> orderEntries = new List <OrderEntry>();
foreach (var temp in request.Orders)
{
var orderEntry = new OrderEntry();
orderEntry.MenuId = temp.MenuId;
orderEntry.Price = _context.Menu.Where(w => w.Id == temp.MenuId).FirstOrDefault().Price;
orderEntry.Quantity = temp.Quantity;
orderEntry.OrderId = order.Id;
orderEntry._CreatedDate = DateUtils.GetDateNow();
orderEntry.CreatedBy = "SYSTEM";
orderEntry.Id = new Guid();
total += orderEntry.Price * temp.Quantity;
orderEntries.Add(orderEntry);
}
order.Total = total;
_context.Order.Add(order);
_context.OrderEntry.AddRange(orderEntries);
await _context.SaveChangesAsync();
return(new Response <Order>());
}
public OrderEntry Parse(OrderEntryModel model)
{
try
{
var entry = new OrderEntry();
if (model.Quantity != default(int))
{
entry.Quantity = model.Quantity;
}
if (!string.IsNullOrWhiteSpace(model.BookUrl))
{
var uri = new Uri(model.BookUrl);
var bookId = int.Parse(uri.Segments.Last());
var book = _repo.GetBook(bookId);
entry.BookItem = book;
return(entry);
}
return(entry);
}
catch
{
return(null);
}
}
private void AddEntry(OrderEntry entry)
{
OrderEntryViewItem value = new OrderEntryViewItem(entry);
this.ltvEntries.Items.Add(value);
this.entryItems.Add(entry, value);
}
void SeedOrderEntries()
{
var order = _ctx.Orders.Where(f => f.UserName == "testuser" && f.CurrentDate == new DateTime(2016, 1, 3)).FirstOrDefault();
var entry = new OrderEntry
{
Quantity = 1
};
entry.BookItem = _ctx.Books.Where(f => f.Title == "JavaScript: The Good Parts").FirstOrDefault();
entry.Order = order;
_ctx.OrderEntries.Add(entry);
entry = new OrderEntry
{
Quantity = 1
};
entry.BookItem = _ctx.Books.Where(f => f.Title == "Web Design with HTML, CSS, JavaScript and jQuery Set").FirstOrDefault();
entry.Order = order;
_ctx.OrderEntries.Add(entry);
entry = new OrderEntry
{
Quantity = 1
};
entry.BookItem = _ctx.Books.Where(f => f.Title == "CLR via C#, Second Edition").FirstOrDefault();
entry.Order = order;
_ctx.OrderEntries.Add(entry);
_ctx.SaveChanges();
}
private void RemoveEntry(OrderEntry entry)
{
OrderEntryViewItem orderEntryViewItem = this.entryItems[entry];
this.entryItems.Remove(entry);
orderEntryViewItem.Remove();
}
protected void databind()
{
List<OrderEntry> list = new List<OrderEntry>();
for (int i = 0; i < 50; i++)
{
OrderEntry u = new OrderEntry();
list.Add(u);
}
Session["num"] = 0;
this.dg.DataKeyField = "OrderID";
this.dg.DataSource = list;
this.dg.DataBind();
//绑定页码
SetupPage();
this.Page_nPage.Text = Convert.ToString(this.dg.CurrentPageIndex + 1);
this.Page_nRecCount.Text = this.dg.PageCount.ToString();
this.Page_nRecCount_1.Text = list.Count.ToString();//this.dg.Items.Count.ToString();
ispages.Text = this.Page_nPage.Text;
IsFirstLastPage(this.dg.PageCount, this.dg.CurrentPageIndex);
if (this.dg.PageCount == 1)
{
this.dg.PagerStyle.Visible = false;
}
else
{
this.dg.PagerStyle.Visible = false;
}
}
private void addOrder(OrderEntry item)
{
//Intantiate object
GameObject order = (GameObject)GameObject.Instantiate(orderPrefab);
//set position
order.transform.SetParent(Content.transform);
order.transform.localScale = new Vector3(0.65f, 0.65f, 1);
if (Orders.Count != 0)
{
//wl("set local position");
order.transform.localPosition = new Vector3(Orders[Orders.Count - 1].transform.localPosition.x, Orders[Orders.Count - 1].transform.localPosition.y - orderHeight, 0);
}
else
{
order.transform.localPosition = new Vector3(401.015f, -orderHeight / 2, 0);
}
//set content
order.transform.Find("Dishname").GetComponent <Text>().text = item.foodFullName;
order.transform.Find("Price").GetComponent <Text>().text = "$" + item.price.ToString();
order.transform.Find("TotalPrice").GetComponent <Text>().text = "$" + item.totalPrice.ToString();
order.transform.Find("Quantity").GetComponent <Text>().text = item.quantity.ToString();
Content.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, ((RectTransform)Content.transform).rect.height + orderHeight);
//add to orders list
Orders.Add(order);
moveDisplacement.Add(0);
}
public ActionResult OrderEntry(OrderEntry orderEntry)
{
try
{
Stock stock = new Stock();
stock.SupplierId = orderEntry.Supplier.UniqueId;
stock.ProductId = orderEntry.Product.UniqueId;
stock.UnitId = orderEntry.Unit.UniqueId;
stock.EntryDate = orderEntry.Stock.EntryDate;
stock.Quatity = orderEntry.Stock.Quatity;
stock.CostPerProduct = orderEntry.Stock.CostPerProduct;
stock.CreatedBy = User.Identity.Name;
stock.CreatedDate = DateTime.Now;
stockService.Add(stock);
stockService.Save();
return(RedirectToAction("GetOrderEntry"));
}
catch (Exception ex)
{
ViewBag.Suppliers = supplierService.GetAll().Where(x => x.IsActive == true).ToList();
ViewBag.Products = productService.GetAll().Where(x => x.IsActive == true).ToList();
ViewBag.Units = unitService.GetAll().Where(x => x.IsActive == true).ToList();
}
return(View(orderEntry));
}
public async Task PutAsync(Int32 id, OrderEntry _orderEntry)
{
var entity = _unitOfWork.GetRepoInstance <OrderEntry>().GetById(id);
if (entity == null)
{
return;
}
entity.orderType = _orderEntry.orderType;
entity.location = _orderEntry.location;
entity.date = _orderEntry.date;
entity.fromTime = _orderEntry.fromTime;
entity.toTime = _orderEntry.toTime;
entity.cargo = _orderEntry.cargo;
entity.comments = _orderEntry.comments;
entity.status = _orderEntry.status;
entity.order = _orderEntry.order;
entity.delays = _orderEntry.delays;
entity.status = _orderEntry.status;
_unitOfWork.GetRepoInstance <OrderEntry>().Update(entity);
await _unitOfWork.saveAsync();
}
public IActionResult Edit(Guid id, OrderModel model)
{
try
{
OrderEntry orderEntry = GetOrder(id);
if (!IsOrderFoundAndCurrentUserHasPermission(orderEntry))
{
return(View());
}
orderEntry.LastModifiedTime = DateTime.Now;
OrderModel order = orderEntry.Order;
order.Info = model?.Info;
order.OccassionalIntro = model?.OccassionalIntro;
order.ExceptionsFromAnotherOrder = model?.ExceptionsFromAnotherOrder;
db.Entry(orderEntry).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
/// <inheritdoc />
public Task <UpdateStatus> UpdateOrderAsync(OrderEntry order, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(order.Id))
{
throw new ArgumentException("Order Id is empty.", nameof(order));
}
return(PutApiAsync <UpdateStatus>(GetUrl($"orders/{order.Id}"), order, cancellationToken));
}
/// <inheritdoc />
public Task <UpdateStatus> UpdateOrderAsync(OrderEntry order, CancellationToken cancellationToken)
{
if (order.OrderNumber <= 0)
{
throw new ArgumentException("Order number is 0.", nameof(order));
}
return(PutApiAsync <UpdateStatus>(GetUrl($"orders/{order.OrderNumber}"), order, cancellationToken));
}
/// <summary>
/// Update one order asynchronously.
/// </summary>
/// <param name="order">The order to update.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="EcwidConfigException">Order number is 0.</exception>
public async Task <UpdateStatus> UpdateOrderAsync(OrderEntry order, CancellationToken cancellationToken)
{
if (order.OrderNumber == 0)
{
throw new EcwidConfigException("Order number is 0.");
}
return(await PutApiAsync <UpdateStatus>(GetUrl($"orders/{order.OrderNumber}"), order, cancellationToken));
}
public OrderEntryModel Create(OrderEntry entry)
{
return(new OrderEntryModel
{
Url = _urlHelp.Link("OrderEntries", new { orderid = entry.Order.CurrentDate.ToString("yyyy-MM-dd"), id = entry.Id }),
Quantity = entry.Quantity,
BookTitle = entry.BookItem.Title,
BookUrl = _urlHelp.Link("Book", new { bookid = entry.BookItem.Id })
});
}
public async Task <IActionResult> PostOrderEntry([FromBody] OrderEntry orderEntry)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.OrderEntries.Add(orderEntry);
await _context.SaveChangesAsync();
//Make the HTTP Client Call to Products API for product info, Add to Full Order DB
//Get Full list of Products, URL: https://localhost:44350/api/products
//Get Specific Product, URL: https://localhost:44350/api/products/id
//List of Products to be added to FullOrder
List <Products> products = new List <Products>();
//The 'using' will help to prevent memory leaks.
//Create a new instance of HttpClient
using (HttpClient client = new HttpClient())
//Setting up the response...
//iterate through list of Product IDs, adding the products to Products List
foreach (var id in orderEntry.Items)
{
string baseUrl = $"https://localhost:44350/api/products/{id.ProductID}";
using (HttpResponseMessage res = await client.GetAsync(baseUrl))
using (HttpContent content = res.Content)
{
Products data = await content.ReadAsAsync <Products>();
if (data != null)
{
products.Add(data);
}
}
}
//FullOrder object
FullOrder fullOrder = new FullOrder
{
OrderID = Guid.NewGuid(),
orderEntry = orderEntry,
Products = products
};
//Add Fullorder object to FullOrder DB
_context.FullOrders.Add(fullOrder);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrderEntry", new { id = orderEntry.CustomerID }, fullOrder));
}
private void dgvBills_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (dgvadvanceReceipt.SelectedCells.Count > 0 && e.RowIndex != -1 && dgvadvanceReceipt.Columns[e.ColumnIndex].Name != "Action")
{
string orderID = dgvadvanceReceipt.CurrentRow.Cells["OrderID"].Value.ToString();
string status = dgvadvanceReceipt.CurrentRow.Cells["Status"].Value.ToString();
OrderEntry frmOrderEntry = new OrderEntry(orderID, status);
frmOrderEntry.OnClose += GenerateAdvancePaymentList;
frmOrderEntry.ShowDialog();
}
}
// GET: Order/Edit/5
public IActionResult Edit(Guid id)
{
OrderEntry orderEntry = GetOrder(id);
if (!IsOrderFoundAndCurrentUserHasPermission(orderEntry))
{
return(View());
}
return(View(orderEntry));
}
private void EditEntry(OrderEntry entry)
{
OrderEntryDetailsForm orderEntryDetailsForm = new OrderEntryDetailsForm();
orderEntryDetailsForm.Entry = entry;
if (orderEntryDetailsForm.ShowDialog(this) == DialogResult.OK)
{
this.entryItems[entry].UpdateValues();
this.ltvEntries.Sort();
}
orderEntryDetailsForm.Dispose();
}
public void AddOrderEntry(Order order, long selectedBookTypeId, int amount)
{
BookType bookType = BooksInformationService.GetBookTypeById(selectedBookTypeId);
OrderEntry orderEntry = new OrderEntry()
{
BookType = bookType,
Price = bookType.Price,
Amount = amount
};
order.OrderEntries.Add(orderEntry);
}
public async Task <ActionResult> SaveDelivery(string data)
{
try
{
//string Total = Session["SumTotal"].ToString();
string Total = Session["GrandTotal"].ToString();
var Custdelnmodel = JsonConvert.DeserializeObject <CustomerinfoDelivery>(data);
OrderEntry orderent = new OrderEntry();
List <ShoppingCartModel> listshop;
listshop = (List <ShoppingCartModel>)Session["Shoppingcart"];
orderent.listshoppingItems = listshop;
orderent.customerinfoDelivery = Custdelnmodel;
orderent.OrderType = "D";
orderent.EstimatedTime = Custdelnmodel.Time;
orderent.Comments = Custdelnmodel.Comments;
orderent.DeliveryCharge = dlvcharge;
//orderent.OrderAmt = decimal.Parse(Session["SumTotal"].ToString());
orderent.OrderAmt = decimal.Parse(Session["GrandTotal"].ToString());
if (Custdelnmodel.Paymentmode.Equals("COD"))
{
orderent.Paymentmode = "C";
HttpClient client = detailAPI.Initial();
HttpContent content = new StringContent(JsonConvert.SerializeObject(orderent),
Encoding.UTF8, "application/json");
HttpResponseMessage res = await client.PostAsync("ShoppingCart/InsertCartItem", content);
if (res.IsSuccessStatusCode)
{
Session["cartitemcount"] = null;
Session["Shoppingcart"] = null;
await HeaderLoad();
}
return(Json(new { msgType = "S", price = Total }));
}
else
{
// Store the Values in the session
orderent.Paymentmode = "O";
Session["OrderInfo"] = orderent;
var OrderAmt = decimal.Parse(Session["GrandTotal"].ToString());
string key1 = DateTime.Now.ToString("hh.mm.ss.ffffff");
return(Json(new { msgType = "O", price = OrderAmt, orderno = key1 }));
}
}
catch (Exception ex)
{
return(null);
//throw;
}
}
public static int SaveOrder(OrderDto orderDto)
{
var orderId = 0;
try
{
using (var context = new DineAndDashContext())
{
var originalOrder = orderDto.Id != 0
? context.Set <Order>().FirstOrDefault(o => o.OrderId == orderDto.Id)
: null;
if (originalOrder == null)
{
var order = orderDto.CreateOrderEntity();
foreach (var orderItem in orderDto.OrderItems)
{
var orderEntry = new OrderEntry
{
MenuItemId = orderItem.MenuItemId
};
foreach (var extra in orderItem.Extras)
{
var extraEntry = new OrderEntry
{
MenuItemId = extra.MenuItemId,
Parent = orderEntry
};
orderEntry.Children.Add(extraEntry);
}
order.OrderEntries.Add(orderEntry);
}
context.Orders.Add(order);
context.SaveChanges();
orderId = order.OrderId;
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.Message);
orderId = 0;
}
return(orderId);
}
public OrderEntryDto(OrderEntry entity)
{
Id = entity.OrderEntryId;
MenuItemId = entity.MenuItemId;
ItemName = entity.MenuItem.Name;
Extra = entity.MenuItem.Extra;
Extras = new List <OrderEntryDto>();
foreach (var extra in entity.Children)
{
Extras.Add(new OrderEntryDto(extra));
}
}
private bool IsOrderFoundAndCurrentUserHasPermission(OrderEntry orderEntry)
{
if (orderEntry == null || orderEntry.Deleted)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(false);
}
if (orderEntry.Owner != currentUser)
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(false);
}
return(true);
}
private void BuyButton_Click(object sender, RoutedEventArgs e)
{
try
{
((ListBoxItem)ProductsBox.SelectedItem).Tag.ToString();
}
catch
{
MessageBox.Show("No item was selected");
return;
}
string productidS = ((ListBoxItem)ProductsBox.SelectedItem).Tag.ToString();
int productid = Int32.Parse(productidS);
int orderid = orderObject.Id;
Product productObject = pizzaproxy.GetProductById(productid);
OrderEntry oe = pizzaproxy.Buy(orderid, productid, userid);
if (oe != null)
{
InventoryBox.Items.Clear();
foreach (OrderEntry o in pizzaproxy.OrderEntryList(orderid))
{
ListBoxItem oeitm = new ListBoxItem();
oeitm.Content = pizzaproxy.GetProductById(o.Product_Id).Name + ", " + o.Amount;
InventoryBox.Items.Add(oeitm);
}
}
else
{
if (pizzaproxy.GetCustomerById(userid).Money < pizzaproxy.GetProductById(productid).Price)
{
MessageBox.Show("Not enough money!");
}
else if (pizzaproxy.GetProductById(productid).Amount <= 0)
{
MessageBox.Show("Product out of stock!");
}
else
{
MessageBox.Show("An error has occured!");
}
}
RefreshButton_Click(sender, e);
}
public OrderEntryXmlNode Add(OrderEntry entry)
{
OrderEntryXmlNode orderEntryXmlNode = base.AppendChildNode();
orderEntryXmlNode.Enabled = entry.Enabled;
orderEntryXmlNode.DateTime.Value = entry.DateTime;
orderEntryXmlNode.Symbol.Value = ((entry.Instrument == null) ? "" : entry.Instrument.Symbol);
orderEntryXmlNode.Side.Value = entry.Side;
orderEntryXmlNode.OrdType.Value = entry.OrdType;
orderEntryXmlNode.Price.Value = entry.Price;
orderEntryXmlNode.StopPx.Value = entry.StopPx;
orderEntryXmlNode.OrderQty.Value = entry.OrderQty;
orderEntryXmlNode.Text.Value = entry.Text;
return(orderEntryXmlNode);
}
// GET: Order/Show/5
public IActionResult Show(Guid id)
{
OrderEntry orderEntry = GetOrder(id);
if (!IsOrderFoundAndCurrentUserHasPermission(orderEntry))
{
return(RedirectToAction(nameof(Index)));
}
string orderName = orderPdfService.CreateOrder(orderEntry.Order);
byte[] bytes = System.IO.File.ReadAllBytes(orderName);
System.IO.File.Delete(orderName);
return(File(bytes, "application/pdf"));
}