public ActionResult Create([Bind(Include = "ProductID,Quantity")] ProductInOrderCreateModel viewModel)
{
ProductInOrder productInOrder = new ProductInOrder();
productInOrder.ProductID = viewModel.ProductID;
productInOrder.Quantity = viewModel.Quantity;
string userID = User.Identity.GetUserId();
Order activeOrder = db.Orders.FirstOrDefault(x => x.UserId == userID && x.OrderStatus == 0);
if (activeOrder == null)
{
return(RedirectToAction("Warning", "Home", new { message = "No active order currently. Click New order below if you are a customer to proceed to an order. " }));
}
productInOrder.OrderID = activeOrder.OrderID;
ProductInOrder p = db.ProductInOrders.FirstOrDefault(x => x.OrderID == activeOrder.OrderID && x.ProductID == productInOrder.ProductID);
//If product is already in Order
if (p != null)
{
p.Quantity = viewModel.Quantity;
db.SaveChanges();
return(RedirectToAction("Warning", "Home", new { message = "Product already in order, updated the amount order!" }));
}
db.ProductInOrders.Add(productInOrder);
db.SaveChanges();
ViewBag.Message = "Product added to order";
return(RedirectToAction("Index", "Products"));
}
public async Task <ActionResult <string> > AddToOrderStore([FromBody] ProductInOrder product)
{
string OrganizationName = (string)RouteData.Values["OrganizationName"];
Organization orgExist = await _organizationRepository.OraganizationExist(OrganizationName);
if (orgExist != null)
{
_orderProductRepository.setConnectionString(OrganizationName);
byte[] error = new byte[500];
int status = await _orderProductRepository.AddPotentialProduct(product, error);
string z = System.Text.Encoding.ASCII.GetString(error);
if (status != 0)
{
return(BadRequest(z.Remove(z.IndexOf('\0'))));
}
else
{
return(Ok("successfuly added"));
}
}
else
{
return(NotFound("This organization does not exist"));
}
}
private void AddProductToOrder(Product product)
{
if (IsExistProductInOrder(product))
{
var productInOrder = GetProductInOrder(product);
productInOrder.Quantity = productInOrder.Quantity + 1;
}
else
{
var productInOrder = new ProductInOrder {
ID = product.Id,
Name = product.Name,
ProductId = product.Id
};
if (product.Cost != null)
{
productInOrder.Cost = (double)product.Cost;
}
_listProductsInOrder.Add(productInOrder);
productInOrder.Quantity = productInOrder.Quantity + 1;
}
ProductInOrderListView.ItemsSource = null;
ProductInOrderListView.ItemsSource = _listProductsInOrder;
}
public async Task <IActionResult> Edit(int id, [Bind("ProductInOrderId,ProductId,OrderId")] ProductInOrder productInOrder)
{
if (id != productInOrder.ProductInOrderId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(productInOrder);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductInOrderExists(productInOrder.ProductInOrderId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["OrderId"] = new SelectList(_context.Order, "OrderId", "OrderGuid", productInOrder.OrderId);
ViewData["ProductId"] = new SelectList(_context.Product, "ProductId", "Description", productInOrder.ProductId);
return(View(productInOrder));
}
private void SetInitialValues(ProductInOrder productToRemove)
{
productToRemove.SelectedQuantity = 0;
productToRemove.SourceProductOnStore.UnitsInStock += productToRemove.SourceProductOnStore.UnitsOnOrder;
productToRemove.SourceProductOnStore.UnitsOnOrder = 0;
TotalSum -= productToRemove.Sum;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Quantity")] ProductInOrder productInOrder)
{
if (id != productInOrder.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(productInOrder);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductInOrderExists(productInOrder.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(productInOrder));
}
private void SaveChangesToProducts(ProductInOrder newProductInOrder, int newValue)
{
Product productToReplace = db.Products.First(x => x.ProductID == newProductInOrder.ProductID);
productToReplace.UnitsInStock -= (short)newValue;
db.SaveChanges();
}
private void RemoveProduct(ProductInOrder productToRemove)
{
if (!productToRemove.IsSaled)
{
productToRemove.SourceProductOnStore.UnitsInStock += productToRemove.SelectedQuantity;
}
TotalSum -= productToRemove.Sum;
}
public async Task <int> Create(T entity, byte[] error)
{
int status = 0;
if (typeof(T) == typeof(Inventory))
{
Inventory inventory = (Inventory)(object)(entity);
status = await Task.Run(() => Warehouse_Wrapper.addInventory(inventory, error, _ConnectionString));
}
if (typeof(T) == typeof(ProductInInventory))
{
ProductInInventory product = (ProductInInventory)(object)(entity);
status = await Task.Run(() => Warehouse_Wrapper.addProductToInventory(product, error, _ConnectionString));
}
if (typeof(T) == typeof(Product))
{
Product product = (Product)(object)(entity);
status = await Task.Run(() => Warehouse_Wrapper.addProduct(product, error, _ConnectionString));
}
if (typeof(T) == typeof(Order))
{
Order order = (Order)(object)(entity);
status = await Task.Run(() => Warehouse_Wrapper.addOrder(order, error, _ConnectionString));
}
if (typeof(T) == typeof(ProductInOrder))
{
ProductInOrder product = (ProductInOrder)(object)(entity);
status = await Task.Run(() => Warehouse_Wrapper.addProductToOrder(product, error, _ConnectionString));
}
if (typeof(T) == typeof(Customer))
{
Customer customer = (Customer)(object)entity;
if (_ConnectionString != null)
{
status = await Task.Run(() => Crm_Wrapper.AddCustomer(customer, error, _ConnectionString));
}
}
if (typeof(T) == typeof(Opportunity))
{
Opportunity opportunity = (Opportunity)(object)(entity);
status = await Task.Run(() => Crm_Wrapper.AddOpportunity(opportunity, error, _ConnectionString));
}
if (typeof(T) == typeof(OpportunityProduct))
{
OpportunityProduct product = (OpportunityProduct)(object)(entity);
status = await Task.Run(() => Crm_Wrapper.AddOpportunityProduct(product, error, _ConnectionString));
}
return(status);
}
public async Task <IActionResult> Create([Bind("Id,Quantity")] ProductInOrder productInOrder)
{
if (ModelState.IsValid)
{
_context.Add(productInOrder);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(productInOrder));
}
private void SubscribeToChanges(ProductInOrder newProductInOrder)
{
newProductInOrder.WhenAnyValue(x => x.SelectedDiscount, x => x.SelectedQuantity)
.Subscribe(a =>
{
int newSelectedDiscount = a.Item1;
int newSelectedQuantity = a.Item2;
//-UnitPrice или +UnitPrice к TotalSum и цене товара в заказке
decimal newValue = (newSelectedQuantity - (short)newProductInOrder.SourceProductOnStore.UnitsOnOrder) * (decimal)newProductInOrder.UnitPrice;
//-1% или +1% скидки от товара
decimal percentageOff = (decimal)(newSelectedDiscount - newProductInOrder.PreviousSelectedDiscount) / 100;
//Запускается когда меняется SelectedDiscount
if (percentageOff != 0)
{
newProductInOrder.Sum -= newProductInOrder.SelectedQuantity * (decimal)newProductInOrder.UnitPrice * percentageOff;
TotalSum -= newProductInOrder.SelectedQuantity * (decimal)newProductInOrder.UnitPrice * percentageOff;
}
//Запускается когда меняется SelectedQuantity и при этом SelectedDiscount больше нуля
else if (newSelectedDiscount != 0)
{
//
decimal sumOff = ((decimal)newProductInOrder.PreviousSelectedDiscount / 100) * newProductInOrder.SelectedQuantity * (decimal)newProductInOrder.UnitPrice;
decimal sumToAdd = sumOff - newProductInOrder.Sum;
newProductInOrder.Sum = sumOff;
TotalSum += sumToAdd;
return;
}
newProductInOrder.PreviousSelectedDiscount = newSelectedDiscount;
newProductInOrder.Sum += newValue;
TotalSum += newValue;
});
newProductInOrder.WhenAnyValue(x => x.SelectedQuantity)
.Select(newSelectedQuantity =>
{
short?unitsOnOrder = newProductInOrder.SourceProductOnStore.UnitsOnOrder;
return(newSelectedQuantity - unitsOnOrder);
})
.Subscribe(newValue =>
{
newProductInOrder.SourceProductOnStore.UnitsInStock -= (short)newValue;
newProductInOrder.SourceProductOnStore.UnitsOnOrder += (short)newValue;
SaveChangesToProducts(newProductInOrder, (int)newValue);
});
}
public async Task Do(int orderId, int productId)
{
var productInOrder = new ProductInOrder
{
OrderRefId = orderId,
ProductRefId = productId,
};
_context.ProductInOrders.Remove(productInOrder);
await _context.SaveChangesAsync();
}
public async Task Do(ProductInOrdersViewModel vm)
{
var productInOrder = new ProductInOrder
{
OrderRefId = vm.OrderRefId,
ProductRefId = vm.ProductRefId,
UsedQuantity = vm.UsedQuantity,
};
_context.ProductInOrders.Update(productInOrder);
await _context.SaveChangesAsync();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
if (!User.IsInRole("Administrator"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Restricted to administrator only!" }));
}
ProductInOrder productInOrder = await db.ProductInOrders.FindAsync(id);
db.ProductInOrders.Remove(productInOrder);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([Bind("ProductInOrderId,ProductId,OrderId")] ProductInOrder productInOrder)
{
if (ModelState.IsValid)
{
_context.Add(productInOrder);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["OrderId"] = new SelectList(_context.Order, "OrderId", "OrderGuid", productInOrder.OrderId);
ViewData["ProductId"] = new SelectList(_context.Product, "ProductId", "Description", productInOrder.ProductId);
return(View(productInOrder));
}
public async Task <ActionResult> RemoveFromOrder(int id, int orderID)
{
ProductInOrder productInOrder = await db.ProductInOrders.FindAsync(id);
if (productInOrder.OrderID != orderID)
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - NON VALID REMOVE-FROM-ORDER REQUEST" }));
}
db.ProductInOrders.Remove(productInOrder);
await db.SaveChangesAsync();
return(RedirectToAction("OrderDetails", "Orders"));
}
private void AddToOrder(ProductOnStore product)
{
if (product == null)
{
return;
}
if (productsInOrder.Items.Any(o => o.ProductID == product.ProductID))
{
return;
}
ProductInOrder productInOrder = new ProductInOrder(product);
productsInOrder.Add(productInOrder);
}
// GET: ProductsInOrders/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductInOrder productsInOrder = this.service.ProductInOrder(db.ProductsInOrders.Find(id));
if (productsInOrder == null)
{
return(HttpNotFound());
}
return(View(productsInOrder));
}
public async Task <ActionResult <string> > EditProductInOrder(ProductInOrder product)
{
byte[] error = new byte[500];
int status = await _orderProductRepository.EditProductInOrder(product, error);
string z = System.Text.Encoding.ASCII.GetString(error);
if (status != 0)
{
return(BadRequest(z.Remove(z.IndexOf('\0'))));
}
else
{
return(Ok("successfuly added"));
}
}
/// <summary>
/// Subscribes to the changes of added property
/// </summary>
/// <param name="productOnStore">
/// New product that was added into products on store list
/// </param>
private void MakeSubscribtion(ProductOnStore productOnStore)
{
productOnStore.WhenAnyValue(a => a.Added).
Subscribe(isInOrder =>
{
if (isInOrder)
{
ProductInOrder newProductInOrder = new ProductInOrder(productOnStore);
productsInOrder.AddOrUpdate(newProductInOrder);
}
else
{
productsInOrder.Remove(productOnStore.ProductID);
}
});
}
/// <summary>
/// Method to remove a selected product from the order
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonRemovefromOrder_Click(object sender, EventArgs e)
{
if (dataGridViewOrder.SelectedRows.Count == 0)
{
MessageBox.Show("No products in the order were selected");
return;
}
foreach (DataGridViewRow row in dataGridViewOrder.SelectedRows)
{
ProductInOrder productInOrder = row.DataBoundItem as ProductInOrder;
order.Products.Remove(productInOrder.Product);
}
//When a product is removed we map the order to the form
MapOrderToForm();
}
public async Task <ActionResult <int> > RemoveFromStock(ProductInOrder product)
{
byte[] error = new byte[500];
int status = await _orderProductRepository.removeFromStock(product, error);
string z = System.Text.Encoding.ASCII.GetString(error);
string y = z.Remove(z.IndexOf('\0'));
if (status == 0)
{
return(Ok("Succesfully removed"));
}
else
{
return(BadRequest(y));
}
}
public async Task <ActionResult> Edit([Bind(Include = "ProductInOrderID,ProductID,OrderID,Quantity")] ProductInOrder productInOrder)
{
if (!User.IsInRole("Administrator"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Restricted to administrator only!" }));
}
if (ModelState.IsValid)
{
db.Entry(productInOrder).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.OrderID = new SelectList(db.Orders, "OrderID", "UserId", productInOrder.OrderID);
ViewBag.ProductID = new SelectList(db.Products, "ProductID", "ProductName", productInOrder.ProductID);
return(View(productInOrder));
}
// GET: ProductInOrders/Details/5
public async Task <ActionResult> Details(int?id)
{
if (!User.IsInRole("Administrator"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Restricted to administrator only!" }));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductInOrder productInOrder = await db.ProductInOrders.FindAsync(id);
if (productInOrder == null)
{
return(HttpNotFound());
}
return(View(productInOrder));
}
// GET: ProductInOrders/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (!User.IsInRole("Administrator"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Restricted to administrator only!" }));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductInOrder productInOrder = await db.ProductInOrders.FindAsync(id);
if (productInOrder == null)
{
return(HttpNotFound());
}
ViewBag.OrderID = new SelectList(db.Orders, "OrderID", "UserId", productInOrder.OrderID);
ViewBag.ProductID = new SelectList(db.Products, "ProductID", "ProductName", productInOrder.ProductID);
return(View(productInOrder));
}
private void Button_CompleteOrder_Click(object sender, RoutedEventArgs e)
{
if (ProductInOrderListView.ItemsSource == null)
{
MessageBox.Show("CART IS EMPTY!!!!");
}
else
{
ProductInOrderListView.IsEnabled = false;
ProductInOrderListView.ItemsSource = null;
ButtonCompleteOrder.IsEnabled = false;
ButtonCancel.IsEnabled = false;
ButtonAddOrder.IsEnabled = true;
// Create new order
int idOrder = _databaseHelper.CreateOrder();
List <ProductInOrderTable> productInOrders = ProductInOrder.ConvertToProductInOrderTable(_listProductsInOrder, idOrder);
// Add to list product in order to database after creating ordder
this._databaseHelper.SaveListProductsInOrderTable(productInOrders);
OrderList_UserControl.UpdateListOrder();
_listProductsInOrder.Clear();
}
}
public static extern int removeFromStock(ProductInOrder product, byte[] error, ConnectionString connectionString);
public static extern int editProductInOrder(ProductInOrder product, byte[] error, ConnectionString connectionString);
public static extern int addPotentialProduct(ProductInOrder product, byte[] error, ConnectionString connectionString);
public OrderInfo InsertOrder(OrderPost post)
{
var result = new OrderInfo();
var userObjId = new ObjectId(post.userId);
//获取最近一个订单信息
var builderOrder = Builders<OrderMongo>.Filter;
var filterOrder = builderOrder.Eq(x => x.UserId, userObjId);
filterOrder &= builderOrder.Eq(x => x.IsDel, false);
var colOrder = MongoDBHelper.Instance.GetOrder();
try
{
//判断两个订单时间间隔，避免短时间频繁提交订单
var queryOrder = colOrder.Find(filterOrder).SortByDescending(x => x.CreatedAt).FirstOrDefault();
if (queryOrder != null)
{
TimeSpan interval = DateTime.Now - queryOrder.CreatedAt;
if (interval.TotalSeconds < 10)
return null;
}
//根据产品Id获取产品信息
var productObjIdList = post.productList.Select(x => new ObjectId(x.id)).ToList();
var buiderProduct = Builders<ProductMongo>.Filter;
var filterProduct = buiderProduct.In(x => x._id, productObjIdList);
filterProduct &= buiderProduct.Eq(x => x.IsDel, false);
var queryProduct = MongoDBHelper.Instance.GetProduct().Find(filterProduct).ToList();
var productList = new List<ProductInOrder>(); //订单内产品信息列表
var proDtoList = new List<ProductInOrderDto>(); //返回给前端的订单内产品信息列表
foreach (var x in queryProduct)
{
var product = new ProductInOrder
{
_id = x._id,
Name = x.Name,
Description = x.Description,
Price = x.Price
};
product.Num = post.productList.Find(s => s.id == x._id.ToString()).Num;
productList.Add(product);
var proDto = new ProductInOrderDto
{
Id = x._id.ToString(),
Name = x.Name,
Description = x.Description,
Price = x.Price,
Num=product.Num,
};
proDtoList.Add(proDto);
}
<<<<<<< HEAD
var order = new OrderMongo
{
_id=ObjectId.GenerateNewId(),
CreatedAt = DateTime.Now.AddHours(8),
ProductList = productList,
UserId = userObjId
=======
var ran = new Random();
string tradeNo = string.Format("DT{0}{1}", DateTime.Now.ToString("yyyyMMddHHmmss"), ran.Next(9999));
var order = new OrderMongo
{
_id = ObjectId.GenerateNewId(),
CreatedAt = DateTime.Now.AddHours(8),
ProductList = productList,
UserId = userObjId,
TradeNo = tradeNo
>>>>>>> c26f92d240a523a1903a8e87db204683ad299860
};
order.TotalPrice = productList.Select(x => x.Num * x.Price).Sum();
colOrder.InsertOne(order);
order.ProductList = productList;
var orderDto = new OrderDto
{
Id = order._id.ToString(),
ProductList = proDtoList,
<<<<<<< HEAD
TotalPrice = order.TotalPrice
=======
TotalPrice = order.TotalPrice,
CreatedAt = order.CreatedAt,
TradeNo = order.TradeNo
>>>>>>> c26f92d240a523a1903a8e87db204683ad299860
};
result.order = orderDto;
