public void OrderDetails()
{
var conn = new NHibernateConnection();
var orderRepo = new OrdersRepository(conn);
var productRepo = new ProductsRepository(conn);
var userRepo = new UserRepository(conn);
var deliveryRepo = new DeliveryTypesRepository(conn);
Users user = userRepo.Get("*****@*****.**");
var orderDetailsRepo = new OrderDetailsRepository(conn);
Products product = productRepo.GetAll().First();
var delivetyType = deliveryRepo.GetAll().First();
if (delivetyType == null)
{
delivetyType = new DeliveryTypes("Poczta Polska", Convert.ToDecimal(8.99));
deliveryRepo.Save(delivetyType);
}
var order = new Orders(user, DateTime.Now,
Convert.ToDecimal(299.99),delivetyType);
orderRepo.Save(order);
var orderDetails = new OrderDetails(order, product, 2, Convert.ToDecimal(29.99));
orderDetailsRepo.Save(orderDetails);
var fromDB = orderDetailsRepo.Get(orderDetails.ID);
Assert.IsNotNull(fromDB);
}
/// <summary>
/// Default constructor.
/// </summary>
public PurchaseOrderDetails()
{
Id = string.Empty;
PayPalOrderDetails = new OrderDetails();
GlobalShippingPrice = 0;
GlobalTaxAmount = 0;
PurchasedProductList = new List<PurchasedProduct>();
}
private void BindDetails()
{
Order order = (Order)Session["ViewCurrentOrder"];
OrderDetails details = new OrderDetails();
details.GetOrderDetails(order.OrderID);
uiGridViewProducts.DataSource = details.DefaultView;
uiGridViewProducts.DataBind();
}
public void Delete(OrderDetails entity)
{
using (_session.BeginTransaction())
{
_session.Delete(entity);
_session.Transaction.Commit();
}
}
public void Test_Valid_OrderDetails_Creation()
{
OrderDetails orderDetails = new OrderDetails();
orderDetails.PackageList = new List<ItemDetails>();
for (int i = 0; i < 10; i++)
{
orderDetails.PackageList.Add(GetRandomItem());
}
Assert.AreEqual(10, orderDetails.PackageList.Count);
}
public static List<OrderDetails> Get_OrderDetails()
{
SqlConnection cn = null;
SqlDataReader rdr = null;
OrderDetails oDetails = null;
List<OrderDetails> odList = new List<OrderDetails>();
try
{
string query = "SELECT * FROM Order Details";
cn = Setup_Connection();
SqlCommand cmd = new SqlCommand(query, cn);
rdr = cmd.ExecuteReader();
while (rdr.Read())
{
oDetails = new OrderDetails(rdr);
odList.Add(oDetails);
}
}
catch (Exception e)
{
return odList;
}
finally
{
if (rdr != null)
{
rdr.Close();
}
if (cn != null)
{
cn.Close();
}
}
return odList;
}
protected void uiLinkButtonAddItem_Click(object sender, EventArgs e)
{
OrderDetails detail = new OrderDetails();
detail.AddNew();
detail.OrderID = CurrentOrder.OrderID;
detail.ProductID = Convert.ToInt32(uiDropDownListProducts.SelectedValue);
detail.Quantity = Convert.ToInt32(uiTextBoxQty.Text);
detail.ItemPrice = decimal.Parse(uiTextBoxPrice.Text);
detail.Save();
BindItems();
}
public async Task <IActionResult> UpdateItemQuantity(int orderDetailsID, int quantity)
{
ApplicationUser user = await GetCurrentUser();
ErrorMessage message = new ErrorMessage();
message.IsSuccess = false;
if (quantity < 1)
{
return(Json(message));
}
if (user != null)
{
Order order = _context.Order.Where(o => o.UserID == user.Id && o.OrderStatus == "Ongoing").FirstOrDefault();
if (order != null)
{
List <OrderDetails> orderDetailsList = _context.OrderDetails.Where(od => od.OrderID == order.OrderID)
.Include(od => od.Product).ThenInclude(p => p.ProductStatus)
.ToList();
OrderDetails orderDetails = orderDetailsList.Where(od => od.OrderDetailsID == orderDetailsID).FirstOrDefault();
if (orderDetails != null)
{
//set quantity to be max (the same as stock) if the user entered a value higher than the actual stock
if (orderDetails.Product.ProductStock >= quantity)
{
orderDetails.Quantity = quantity;
message.IsSuccess = true;
}
else
{
quantity = orderDetails.Product.ProductStock == null ? 0 : (int)orderDetails.Product.ProductStock;
orderDetails.Quantity = quantity;
}
//perform check if the item on discount or not
double priceAfterDiscount = orderDetails.Product.ProductPrice;
if (orderDetails.Product.ProductStatus.ProductStatusName == "Sale" &&
orderDetails.Product.SaleStartDateTime <= DateTime.Now &&
orderDetails.Product.SaleEndDateTime >= DateTime.Now)
{
priceAfterDiscount = orderDetails.Product.ProductPrice - (orderDetails.Product.ProductPrice * (orderDetails.Product.ProductDiscount == null ? 0 : (double)orderDetails.Product.ProductDiscount));
}
//calculate value and update total price
orderDetails.TotalPrice = quantity * priceAfterDiscount;
message.Message.Add(String.Format("{0:F2}", orderDetailsList.Sum(od => od.TotalPrice)));
message.Message.Add(String.Format("{0:F2}", orderDetails.TotalPrice));
//give back extra prompt if the stock is less than value inserted
if (!message.IsSuccess)
{
message.Message.Add(string.Format("Not Enough Stock, {0} Lefts", orderDetails.Product.ProductStock));
message.Message.Add($"{orderDetails.Product.ProductStock}");
}
_context.Update(orderDetails);
_context.SaveChanges();
}
}
}
return(Json(message));
}
private OrderDetails GetDummyCart()
{
OrderDetails orderDetails = new OrderDetails();
orderDetails.PackageList = new List<ItemDetails>();
orderDetails.PackageList.Add(new ItemDetails()
{
Item = "Item 1",
PicUrl = "http://sample-pic-source/pic.png",
Price = 10,
Quantity = 1,
VAT = 15,
Weight = 0.2M
});
orderDetails.PackageList.Add(new ItemDetails()
{
Item = "Item 2",
PicUrl = "http://sample-pic-source/pic2.png",
Price = 10,
Quantity = 1,
VAT = 15,
Weight = 0.2M
});
orderDetails.ServiceCharge = 100;
orderDetails.SubTotal = 23;
orderDetails.TotalVATAmount = 3;
orderDetails.TotalWeight = 0.4M;
orderDetails.TotalToPay = 123;
return orderDetails;
}
public IActionResult ProcessPayment(OrderDetails details)
{
/*
* The services container holds the various configurations the SDK needs to
* handle your card processing. It is important to note that the services container
* is a singleton. If you need to hold multiple configurations for the same service type
* (i.e. multiple gateway configurations) then it is important to name your configurations.
* Failing to do so will result in the default connector being replaced each time the ConfigureService
* method is called for a specific configuration type. You can add as many as you like
* and the services container will keep track of them all. Here we are configuring a gateway
* connector and calling it "MyGlobalPaymentsDemo".
*/
ServicesContainer.ConfigureService(new GatewayConfig {
SecretApiKey = "skapi_cert_MYl2AQAowiQAbLp5JesGKh7QFkcizOP2jcX9BrEMqQ",
// The following variables will be provided to you during certification
VersionNumber = "0000",
DeveloperId = "000000",
ServiceUrl = "https://cert.api2.heartlandportico.com"
}, "MyGlobalPaymentsDemo");
try {
var address = new Address {
StreetAddress1 = details.Address,
City = details.City,
State = details.State,
Country = "United States",
PostalCode = details.Zip ?? string.Empty
};
var creditCard = new CreditCardData {
Token = details.Token_value,
CardHolderName = string.Format("{0} {1}", details.FirstName ?? string.Empty, details.LastName ?? string.Empty).Trim()
};
/*
* Use method chaining to define your transactions and set all of your transaction
* options before finally calling the Execute method. Remember, if you are using
* named configurations to pass the name of the configuration you want to be used to
* the Execute method.
*/
var authResponse = creditCard.Charge(15.15m)
.WithCurrency("USD")
.WithAddress(address)
.WithAllowDuplicates(true)
.Execute("MyGlobalPaymentsDemo");
if (authResponse.ResponseCode == "00")
{
SendEmail();
return(View("Success", new SuccessModel {
FirstName = details.FirstName,
TransactionId = authResponse.TransactionId
}));
}
else
{
return(View("Error", model: "Transaction failed: " + authResponse.ResponseMessage));
}
}
catch (BuilderException exc) {
/*
* Handle invalid input exceptions:
* i.e. Missing amount, currency or payment method
*/
return(View("Error", model: "Invalid Input: " + exc.Message));
}
catch (GatewayException exc) {
// handle errors related to gateway communication and invalid requests
return(View("Error", model: "invalid cc number, gateway-timeout, etc: " + exc.Message));
}
catch (ApiException exc) {
// handle everything else
return(View("Error", model: "Something went wrong: " + exc.Message));
}
}
public async Task <IActionResult> SummaryPost(string stripeToken, OrderHeader orderHeader, OrderDetailsCart orderdetailsCart)
{
//-- sega dobaveno
//var detailCart = new Models.ViewModels.OrderDetailsCart()
//{
// OrderHeader = orderHeader
//};
//-- do tuk
//var detalCart = orderdetailsCart;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Desctiopion = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
// detailCart.OrderHeader.OrderTotalOriginal = detailCart.OrderHeader.OrderTotal;
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShopingCartCount, 0);
await _db.SaveChangesAsync();
//to execute the actual payment and charge the credit card
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "BGN",
Description = "Order ID: " + detailCart.OrderHeader.Id,
Source = stripeToken
};
//
var service = new ChargeService();
//to make the actual trasaction
Charge charge = service.Create(options);
//check the result
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//send order confirmation Email to the customer
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email,
"Lazy Dayze order " + detailCart.OrderHeader.Id.ToString() + " successfully accepted!",
"You order number " + detailCart.OrderHeader.Id.ToString() + " has been submitted successfully");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
// return RedirectToAction("Index", "Home");
}
partial void UpdateOrderDetails(OrderDetails instance);
/// <summary>
/// 生成返现实体
/// </summary>
/// <param name="totalMoney"></param>
/// <param name="model"></param>
/// <param name="dmodel"></param>
/// <returns></returns>
private ZJ_RebateInfo FormartZJ_RebateInfo(decimal totalMoney, OderModel model, OrderDetails dmodel)
{
ZJ_RebateInfo zrModel = new ZJ_RebateInfo();
zrModel.ID = MemCacheFactory.GetCurrentMemCache().Increment("commonId");
zrModel.CreateBY = "系统服务";
zrModel.CreateTime = DateTime.Now;
zrModel.OrderDetailsID = dmodel.OrderDetailsID;
zrModel.OrderID = dmodel.OrderID;
zrModel.ProductID = dmodel.ProductId;
zrModel.SKUID = dmodel.SKU_ProducId;
zrModel.StartTime = DateTime.Now;
zrModel.Status = 1;
if (isFixedDays == 1)
{
zrModel.TotalDay = backDays;
zrModel.TotalMoney = totalMoney * backPoint;
}
else
{
zrModel.TotalDay = dmodel.RetateDays != null ? (int)dmodel.RetateDays : backDays;
zrModel.TotalMoney = totalMoney * (decimal)(dmodel.ReateRedio != null ? dmodel.ReateRedio : backPoint);
}
zrModel.UserID = model.UserID;
return(zrModel);
}
/**
* Constructeur
* param eleve : l'objet Eleve contenant les infos sur l'élève à ajouter
*/
public AjouterLigneCommandeBd(OrderDetails orderD)
: base("AjouterLigneCommande")
{
NewOrderD = orderD;
}
public async Task<OrderDetails> GetPendingOrderFromQueue()
{
OrderDetails returnMessage = null;
try
{
var message = await _queue.GetMessageAsync();
if (message != null)
{
if (message.DequeueCount > 5)
{
// Poisoned message, delete it
await _queue.DeleteMessageAsync(message);
return null;
}
var messageContent = message.AsString;
string[] segments = messageContent.Split(';');
if (segments[0] == "Order")
{
var eventId = segments[1];
var userId = segments[2];
var ticketId = segments[3];
returnMessage = new OrderDetails()
{
EventId = eventId,
UserId = userId,
TicketId = ticketId,
MessageId = message.Id,
PopReceipt = message.PopReceipt
};
}
}
}
catch (Exception ex)
{
// Log the exception somewhere
}
return returnMessage;
}
private void button1_Click(object sender, EventArgs e)
{
try {
int count = dataGridView1.Rows.Count - 1;
if (flag == 1)
{
count++;
for (int i = 0; i < count; i++)
{
//OrderDetails item = new OrderDetails();
for (int j = 1; j < dataGridView1.ColumnCount; j++)
{
if (j == 1)
{
order.Items[i].ProductName = dataGridView1.Rows[i].Cells[j].Value.ToString();
}
else if (j == 2)
{
order.Items[i].ProductNum = int.Parse(dataGridView1.Rows[i].Cells[j].Value.ToString());
}
else if (j == 3)
{
order.Items[i].ProductPrice = double.Parse(dataGridView1.Rows[i].Cells[j].Value.ToString());
}
}
order.Items[i].CalTotalMoney();
}
}
else
{
for (int i = 0; i < count; i++)
{
OrderDetails item = new OrderDetails();
for (int j = 1; j < dataGridView1.ColumnCount; j++)
{
if (j == 1)
{
item.ProductName = dataGridView1.Rows[i].Cells[j].Value.ToString();
}
else if (j == 2)
{
item.ProductNum = int.Parse(dataGridView1.Rows[i].Cells[j].Value.ToString());
}
else if (j == 3)
{
item.ProductPrice = double.Parse(dataGridView1.Rows[i].Cells[j].Value.ToString());
}
}
item.CalTotalMoney();
order.AddItem(item);
}
}
/*格式判断
* 订单号符合年月日加三位流水号(四位数加两位数0到12加0到31)
* 电话号码规范
*/
Regex regexOrderNum = new Regex(@"^\d{4}[01]\d[0-3]\d{4}$");
//Regex regexPhoneNum = new Regex()
if (regexOrderNum.IsMatch(order.OrderID.ToString()))
{
if (flag == 0)
{
//orderService.AddOrder(order);
orderService.AddOrderDB(order);
}
else
{
orderService.Update(order);
}
this.Close();
}
else //失败添加失败
{
MessageBox.Show("订单号格式错误");
}
}
catch {
MessageBox.Show("添加失败");
}
}
public IActionResult OnPost(string StripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claims = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderdetailsCart.CartList = _unitOfWork.ShoppingCartRepository.GetAll(c => c.ApplicationUserID == claims.Value).ToList();
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentPending;
OrderdetailsCart.OrderHeader.OrderDate = DateTime.Now;
OrderdetailsCart.OrderHeader.UserId = claims.Value;
OrderdetailsCart.OrderHeader.Status = StaticDetails.PaymentPending;
OrderdetailsCart.OrderHeader.PickUpTime = Convert.ToDateTime(OrderdetailsCart.OrderHeader.PickUpDate.ToShortDateString() + " " + OrderdetailsCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderdetailsCart> details = new List <OrderdetailsCart>();
_unitOfWork.OrderHeaderRepository.Add(OrderdetailsCart.OrderHeader);
_unitOfWork.Save();
foreach (var item in OrderdetailsCart.CartList)
{
item.MenuItems = _unitOfWork.MenuItemsRepository.GetFirstOrDefault(m => m.Id == item.MenuItemID);
OrderDetails orderDetails = new OrderDetails()
{
MenuItemId = item.MenuItemID,
OrderId = OrderdetailsCart.OrderHeader.Id,
Descripiton = item.MenuItems.Description,
Name = item.MenuItems.Name,
Price = item.MenuItems.Price,
Count = item.Count
};
OrderdetailsCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetailsRepository.Add(orderDetails);
}
OrderdetailsCart.OrderHeader.OrderTotal = Convert.ToDouble(String.Format("{0:.##}", OrderdetailsCart.OrderHeader.OrderTotal));
_unitOfWork.ShoppingCartRepository.RemoveRange(OrderdetailsCart.CartList);
HttpContext.Session.SetInt32(StaticDetails.ShoppingCart, 0);
_unitOfWork.Save();
if (StripeToken != null)
{
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(OrderdetailsCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID :" + OrderdetailsCart.OrderHeader.Id,
Source = StripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
OrderdetailsCart.OrderHeader.TransactionId = charge.Id;
if (charge.Status.ToLower() == "Succeeded")
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentApproved;
OrderdetailsCart.OrderHeader.Status = StaticDetails.StatusSubmitted;
}
else
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentRejected;
}
}
else
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Cart/OrderConfirmation", new { id = OrderdetailsCart.OrderHeader.Id }));
}
protected void gdvOrderDetail_RowCommand(object sender, GridViewCommandEventArgs e)
{
try
{
if (e.CommandName.Equals("Add"))
{
OrderDetails objDetails = new OrderDetails();
TextBox txtAddquantity = (TextBox)gdvOrderDetail.FooterRow.FindControl("txtAddquantity");
TextBox txtAddSalePrice = (TextBox)gdvOrderDetail.FooterRow.FindControl("txtAddSalePrice");
DropDownList drpOrderDetail = (DropDownList)gdvOrderDetail.FooterRow.FindControl("drpAddOrderDetail");
objDetails.OrderID = Convert.ToInt32(Session["OrderID"]);
objDetails.ProductID = Convert.ToInt32(drpOrderDetail.SelectedValue);
objDetails.OrderDate = DateTime.Now;
objDetails.StatusDetails = "Initiated";
objDetails.OrderDescription = "Requested";
objDetails.OrderedQuantity = Convert.ToInt32(txtAddquantity.Text);
objDetails.SalePrice = Convert.ToInt32(txtAddSalePrice.Text);
PlaceOrderBLL objAdd = new PlaceOrderBLL();
objAdd.AddOrderDetails(objDetails);
}
else if (e.CommandName.Equals("Del"))
{
PlaceOrderBLL objDel = new PlaceOrderBLL();
OrderDetails objOrer = new OrderDetails();
objOrer.OrderDetailID = Convert.ToInt32(e.CommandArgument);
objDel.Delete(objOrer);
}
else if (e.CommandName.Equals("Upd"))
{
PlaceOrderBLL objupd = new PlaceOrderBLL();
OrderDetails objOrder = new OrderDetails();
TextBox txtSalePrice = (TextBox)gdvOrderDetail.Rows[gdvOrderDetail.EditIndex].FindControl("txtSalePrice");
TextBox txtquantity = (TextBox)gdvOrderDetail.Rows[gdvOrderDetail.EditIndex].FindControl("txtquantity");
DropDownList ddlPro = (DropDownList)(gdvOrderDetail.Rows[gdvOrderDetail.EditIndex].FindControl("drpOrderDetail"));
long DrpPro = Convert.ToInt64(ddlPro.SelectedItem.Value);
objOrder.OrderDetailID = Convert.ToInt32(e.CommandArgument);
objOrder.SalePrice = Convert.ToInt32(txtSalePrice.Text);
objOrder.ProductID = DrpPro;
objOrder.OrderDescription = "Requested";
objOrder.OrderedQuantity = Convert.ToInt32(txtquantity.Text);
objupd.update(objOrder);
}
else
{
//WebMessageBoxUtil.Show("Invalid input in Order Place field ");
}
}
catch (Exception)
{
throw;
}
finally
{
gdvOrderDetail.EditIndex = -1;
BindGdvDetails();
}
}
public async Task <IActionResult> Insert(OrderDetails entity)
{
var data = await unitOfWork.OrderDetails.Insert(entity);
return(Ok(data));
}
public async Task <IActionResult> SummaryPost(string stripeEmail, string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
ApplicationUser applicationUser = await _db.ApplicationUser.Where(c => c.Id == claim.Value).FirstOrDefaultAsync();
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Descrption = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email, "Spice - Order Created" + detailCart.OrderHeader.Id.ToString(), "Order has been submitted successfully.");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
// return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
public int CreateOrder(Orders order)
{
decimal orderTotal = 0;
_orderRepo.Save(order);
var cartItems = GetCartItems();
// Iterate over the items in the cart,
// adding the order details for each
foreach (var item in cartItems)
{
var product = _producRepo.Get(item.Product.ID);
var ord = _orderRepo.Get(order.Id);
var orderDetail = new OrderDetails(ord, product, item.Quantity,product.Price);
// Set the order total of the shopping cart
orderTotal += (item.Quantity * item.Product.Price);
_orderDetailsRepo.Save(orderDetail);
product.Quantity = product.Quantity - item.Quantity;
_producRepo.Update(product);
}
// Set the order's total to the orderTotal count
//order.SummaryPrice = orderTotal;
// Save the order
//_orderRepo.Save(order);
// Empty the shopping cart
EmptyCart();
// Return the OrderId as the confirmation number
return order.Id;
}
//public int SaveOrderDetails(string type, OrderDetails info)
public int SaveOrderDetails(string type, OrderDetails info)
{
if (string.IsNullOrEmpty(type))
{
return 0;
}
if (info == null)
{
return 0;
}
DbCommand cmd = null;
string sql;
if (type.Equals("Insert"))
{
sql = "INSERT INTO OrderDetails(DetailsId,OrderId,ProductId,ProductCount,UnitPrice,TotalPrice,"
+ "UseState,SendState,Remark,Discount,DiscountPrice,CreateDate)VALUES (@DetailsId,@OrderId,@ProductId,"
+ "@ProductCount,@UnitPrice,@TotalPrice,@UseState,@SendState,@Remark,@Discount,@DiscountPrice,@CreateDate)";
cmd = db.GetSqlStringCommand(sql);
db.AddInParameter(cmd, "DetailsId", DbType.Guid, info.DetailsId);
db.AddInParameter(cmd, "OrderId", DbType.Guid, info.OrderId);
db.AddInParameter(cmd, "ProductId", DbType.Guid, info.ProductId);
db.AddInParameter(cmd, "ProductCount", DbType.Int32, info.ProductCount);
db.AddInParameter(cmd, "UnitPrice", DbType.Decimal, info.UnitPrice);
db.AddInParameter(cmd, "TotalPrice", DbType.Decimal, info.TotalPrice);
db.AddInParameter(cmd, "UseState", DbType.String, info.UseState);
db.AddInParameter(cmd, "SendState", DbType.String, info.SendState);
db.AddInParameter(cmd, "Remark", DbType.String, info.Remark);
db.AddInParameter(cmd, "Discount", DbType.Decimal, info.Discount);
db.AddInParameter(cmd, "DiscountPrice", DbType.Decimal, info.DiscountPrice);
//db.AddInParameter(cmd, "CreateDate", DbType.DateTime, info.CreateDate);
}
if (type.Equals("Update"))
{
sql = "UPDATE OrderDetails set ProductCount= @ProductCount,CreateDate = @CreateDate,TotalPrice=@TotalPrice ,UseState=@UseState WHERE ProductId=@ProductId and OrderId=@OrderId";
cmd = db.GetSqlStringCommand(sql);
//db.AddInParameter(cmd, "DetailsId", DbType.Guid, info.DetailsId);
db.AddInParameter(cmd, "OrderId", DbType.Guid, info.OrderId);
db.AddInParameter(cmd, "ProductId", DbType.Guid, info.ProductId);
db.AddInParameter(cmd, "ProductCount", DbType.Int32, info.ProductCount);
//db.AddInParameter(cmd, "CreateDate", DbType.DateTime, info.CreateDate);
//db.AddInParameter(cmd, "UnitPrice", DbType.Decimal, info.UnitPrice);
db.AddInParameter(cmd, "TotalPrice", DbType.Decimal, info.TotalPrice);
db.AddInParameter(cmd, "UseState", DbType.String, info.UseState);
//db.AddInParameter(cmd, "SendState", DbType.String, info.SendState);
//db.AddInParameter(cmd, "Remark", DbType.String, info.Remark);
//db.AddInParameter(cmd, "Discount", DbType.Decimal, info.Discount);
//db.AddInParameter(cmd, "DiscountPrice", DbType.Decimal, info.DiscountPrice);
}
// "INSERT INTO OrderDetails(DetailsId,OrderId,ProductId,ProductCount,UnitPrice,TotalPrice,UseState,SendState,Remark,Discount,DiscountPrice,CreateDate)VALUES (@DetailsId,@OrderId,@ProductId,@ProductCount,@UnitPrice,@TotalPrice,@UseState,@SendState,@Remark,@Discount,@DiscountPrice,@CreateDate)";
try
{
db.AddInParameter(cmd, "CreateDate", DbType.DateTime, info.CreateDate);
return ExecSql(cmd);
}
catch (Exception ex)
{
Logger.Log(ex);
}
return 0;
}
private void detach_OrderDetails(OrderDetails entity)
{
this.SendPropertyChanging();
entity.Products = null;
}
public bool SubtractSalesSplitOrder(OrderDetails orderDetails)
{
int result = ExecuteUpdate("SubtractSalesSplitOrder", orderDetails);
return(result > 0);
}
private void button_modify_Click(object sender, EventArgs e) //修改订单
{
Form_modifyOrder modifyOrderForm = new Form_modifyOrder();
DialogResult dialogResult = modifyOrderForm.ShowDialog();
if (dialogResult == DialogResult.OK)
{
for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
if (dataGridView1.Rows[i].Cells[4].Value == null)
{
dataGridView1.Rows[i].Cells[4].Value = false;
continue;
}
if ((bool)dataGridView1.Rows[i].Cells[4].Value == true)
{
int num = (int)dataGridView1.Rows[i].Cells[0].Value;
using (var db = new OrderModel())
{
var order = db.Orders.Include("OrderDetails").First(p => p.orderNumber == num); //在数据库中找到一个订单num对应的订单
if (order != null)
{
order.guest = modifyOrderForm.modifyOrder.guest;
order.orderAddress = modifyOrderForm.modifyOrder.orderAddress;
var orderdetails = db.OrderDetails.Where(p => p.Order.orderNumber == order.orderNumber);
foreach (OrderDetails orderDetails1 in orderdetails)
{
db.OrderDetails.Remove(orderDetails1);
}
db.SaveChanges();
//order.orderDetails.Clear();
int cou = 1;
foreach (var good in modifyOrderForm.goods) //遍历字典，将所有商品及数量添加到订单中
{
OrderDetails orderDetails = new OrderDetails(good.Key, good.Value);
orderDetails.OrderId = order.orderNumber;
orderDetails.Order = order;
orderDetails.OrderDetailsId = int.Parse(order.orderTime.Day + "" + cou++);
order.orderDetails.Add(orderDetails);
}
order.reCalculatePrice();
db.SaveChanges();
}
}
//bindingSource1.List.Insert(i, modifyOrderForm.modifyOrder);
}
}
using (var db = new OrderModel())
{
bindingSource1.DataSource = db.Orders.ToList <Order>();
}
button_delete.Enabled = false;
button_delete.Visible = false;
button_modify.Enabled = false;
button_modify.Visible = false;
dataGridView1.Columns[4].Visible = false;
}
}
private OrderResponse BlockedUser(bool blocked, OrderDetails order) => new OrderResponse
{
IsBlocked = blocked,
Order = order
};
/// <summary>
/// Create a new OrderDetails object.
/// </summary>
/// <param name="orderID">Initial value of OrderID.</param>
/// <param name="productID">Initial value of ProductID.</param>
/// <param name="unitPrice">Initial value of UnitPrice.</param>
/// <param name="quantity">Initial value of Quantity.</param>
/// <param name="discount">Initial value of Discount.</param>
public static OrderDetails CreateOrderDetails(long orderID, long productID, decimal unitPrice, short quantity, float discount)
{
OrderDetails orderDetails = new OrderDetails();
orderDetails.OrderID = orderID;
orderDetails.ProductID = productID;
orderDetails.UnitPrice = unitPrice;
orderDetails.Quantity = quantity;
orderDetails.Discount = discount;
return orderDetails;
}
public async Task <IActionResult> SummaryPOST(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
this.DetailCart.ListCart = await this.db.ShoppingCart
.Where(c => c.ApplicationUserId == claim.Value)
.ToListAsync();
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
this.DetailCart.OrderHeader.OrderDate = DateTime.Now;
this.DetailCart.OrderHeader.UserId = claim.Value;
this.DetailCart.OrderHeader.Status = SD.PaymentStatusPending;
this.DetailCart.OrderHeader.PickupTime = Convert.ToDateTime(
this.DetailCart.OrderHeader.PickupDate.ToShortDateString() + " " + this.DetailCart.OrderHeader.PickupTime.ToShortTimeString());
this.db.OrderHeader.Add(this.DetailCart.OrderHeader);
await this.db.SaveChangesAsync();
this.DetailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in this.DetailCart.ListCart)
{
item.MenuItem = await this.db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
var orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = this.DetailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
this.DetailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
this.db.OrderDetails.Add(orderDetails);
}
var couponCode = this.HttpContext.Session.GetString(SD.ssCouponCode);
if (!string.IsNullOrWhiteSpace(couponCode))
{
this.DetailCart.OrderHeader.CouponCode = couponCode;
var couponFromDb = await this.db.Coupon
.FirstOrDefaultAsync(c => c.Name.ToUpper() == this.DetailCart.OrderHeader.CouponCode.ToUpper());
this.DetailCart.OrderHeader.OrderTotal =
SD.DiscountedPrice(couponFromDb, this.DetailCart.OrderHeader.OrderTotalOriginal);
}
else
{
this.DetailCart.OrderHeader.OrderTotal = this.DetailCart.OrderHeader.OrderTotalOriginal;
}
this.DetailCart.OrderHeader.CouponCodeDiscount =
this.DetailCart.OrderHeader.OrderTotalOriginal - this.DetailCart.OrderHeader.OrderTotal;
this.db.ShoppingCart.RemoveRange(this.DetailCart.ListCart);
this.HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await this.db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(this.DetailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + this.DetailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
var charge = await service.CreateAsync(options);
if (charge.BalanceTransactionId == null)
{
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
this.DetailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
await this.emailSender.SendEmailAsync(
(await this.db.Users.FirstOrDefaultAsync(u => u.Id == claim.Value)).Email,
$"Spice - Order created {this.DetailCart.OrderHeader.Id.ToString()}",
"Order has been submitted successfully!");
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
this.DetailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
this.DetailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await this.db.SaveChangesAsync();
//return this.RedirectToAction("Index", "Home");
return(this.RedirectToAction("Confirm", "Order", new { id = this.DetailCart.OrderHeader.Id }));
}
private static void AssertOrderAndDetailsFixedUp(
DbContext context,
OrderDetails orderDetails1a,
OrderDetails orderDetails1b,
OrderDetails orderDetails2a,
OrderDetails orderDetails2b)
{
Assert.Equal(8, context.ChangeTracker.Entries().Count());
Assert.Equal(EntityState.Added, context.Entry(orderDetails1a).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails1b).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails1a.Order).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails1b.Product).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails2a).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails2b).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails2a.Order).State);
Assert.Equal(EntityState.Added, context.Entry(orderDetails2b.Product).State);
Assert.Equal(orderDetails1a.OrderId, orderDetails1a.Order.Id);
Assert.Equal(orderDetails1b.OrderId, orderDetails1b.Order.Id);
Assert.Equal(orderDetails1a.ProductId, orderDetails1a.Product.Id);
Assert.Equal(orderDetails1b.ProductId, orderDetails1b.Product.Id);
Assert.True(orderDetails1a.OrderId > 0);
Assert.True(orderDetails1b.OrderId > 0);
Assert.True(orderDetails1a.ProductId > 0);
Assert.True(orderDetails1b.ProductId > 0);
Assert.Equal(orderDetails2a.OrderId, orderDetails2a.Order.Id);
Assert.Equal(orderDetails2b.OrderId, orderDetails2b.Order.Id);
Assert.Equal(orderDetails2a.ProductId, orderDetails2a.Product.Id);
Assert.Equal(orderDetails2b.ProductId, orderDetails2b.Product.Id);
Assert.True(orderDetails2a.OrderId > 0);
Assert.True(orderDetails2b.OrderId > 0);
Assert.True(orderDetails2a.ProductId > 0);
Assert.True(orderDetails2b.ProductId > 0);
Assert.Same(orderDetails1a.Order, orderDetails1b.Order);
Assert.Same(orderDetails2a.Order, orderDetails2b.Order);
Assert.Same(orderDetails1a.Product, orderDetails2a.Product);
Assert.Same(orderDetails1b.Product, orderDetails2b.Product);
Assert.Equal(2, orderDetails1a.Order.OrderDetails.Count);
Assert.Equal(2, orderDetails2a.Order.OrderDetails.Count);
Assert.Contains(orderDetails1a, orderDetails1a.Order.OrderDetails);
Assert.Contains(orderDetails1b, orderDetails1a.Order.OrderDetails);
Assert.Contains(orderDetails2a, orderDetails2a.Order.OrderDetails);
Assert.Contains(orderDetails2b, orderDetails2a.Order.OrderDetails);
Assert.Equal(2, orderDetails1a.Product.OrderDetails.Count);
Assert.Equal(2, orderDetails1b.Product.OrderDetails.Count);
Assert.Contains(orderDetails1a, orderDetails1a.Product.OrderDetails);
Assert.Contains(orderDetails2a, orderDetails1a.Product.OrderDetails);
Assert.Contains(orderDetails1b, orderDetails1b.Product.OrderDetails);
Assert.Contains(orderDetails2b, orderDetails1b.Product.OrderDetails);
}
public int ProcessPayment(OrderDetails details, ref string response)
{
try
{
//bool addressMatch = false;
string responseError = string.Empty;
if (!HelperClass.ValidateRequest(details, ref responseError))
{
response = responseError;
return(400);
}
//if (!string.IsNullOrEmpty(details.HPPAddressMatchIndicator) && details.HPPAddressMatchIndicator.ToLower() == "true")
//{
// bool.TryParse(details.HPPAddressMatchIndicator, out addressMatch);
//}
// configure client & request settings
ServicesContainer.ConfigureService(new GatewayConfig
{
MerchantId = _config.MerchantId,
AccountId = _config.AccountId,
SharedSecret = _config.SharedSecret,
ServiceUrl = _config.ServiceUrl
});
int expYear = 0;
int expMonth = 0;
int.TryParse(details.CardExpYear, out expYear);
int.TryParse(details.CardExpMonth, out expMonth);
// create the card object
var card = new CreditCardData
{
Number = details.CardNumber,
ExpMonth = expMonth,
ExpYear = expYear,
Cvn = details.CardCvn,
CardHolderName = details.CardHolderName
};
try
{
// process an auto-capture authorization
decimal amount = 0.0m;
decimal.TryParse(details.Amount, out amount);
Transaction GPresponse = card.Charge(amount)
.WithCurrency(details.Currency)
.Execute();
responseMsg["message"] = GPresponse.ResponseMessage;
responseMsg["code"] = GPresponse.ResponseCode;
responseMsg["OrderId"] = GPresponse.OrderId;
responseMsg["AuthorizationCode"] = GPresponse.AuthorizationCode;
responseMsg["TransactionId"] = GPresponse.TransactionId;
responseMsg["SchemeId"] = GPresponse.SchemeId;
response = JsonConvert.SerializeObject(responseMsg);
return(200);
}
catch (ApiException ex)
{
throw new Exception(ex.Message);
// TODO: Add your error handling here
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
//return null;
}
public int CreateOrder(Order order)
{
decimal orderTotal = 0;
var cartItems = GetCartItems();
foreach(var c in cartItems)
{
var orderDetails = new OrderDetails() {
BookId = c.BookId,
OrderId = order.OrderId,
UnitPrice = c.BookToBuy.Price,
Quantity = c.Count
};
dbContext.OrderDetails.Add(orderDetails);
orderTotal += (c.Count * c.BookToBuy.Price);
}
order.Total = orderTotal;
order.OrderDate = DateTime.Now;
dbContext.SaveChanges();
EmptyCart();
return order.OrderId;
}
private static int ComplexPrimaryKeyTest()
{
using (northwindEFEntities db = new northwindEFEntities())
{
long orderId = 10248;
long productId = 1;
int[] counts = { 0, 0 };
//
// NOTE: *REQUIRED* This is required so that the
// Entity Framework is prevented from opening
// multiple connections to the underlying SQLite
// database (i.e. which would result in multiple
// IMMEDIATE transactions, thereby failing [later
// on] with locking errors).
//
db.Connection.Open();
KeyValuePair <string, object> orderIdPair =
new KeyValuePair <string, object>("OrderID", orderId);
KeyValuePair <string, object> productIdPair =
new KeyValuePair <string, object>("ProductID", productId);
/////////////////////////////////////////////////////////////////
OrderDetails newOrderDetails = new OrderDetails();
newOrderDetails.OrderID = orderId;
newOrderDetails.ProductID = productId;
newOrderDetails.UnitPrice = (decimal)1.23;
newOrderDetails.Quantity = 1;
newOrderDetails.Discount = 0.0f;
newOrderDetails.OrdersReference.EntityKey = new EntityKey(
"northwindEFEntities.Orders",
new KeyValuePair <string, object>[] { orderIdPair });
newOrderDetails.ProductsReference.EntityKey = new EntityKey(
"northwindEFEntities.Products",
new KeyValuePair <string, object>[] { productIdPair });
db.AddObject("OrderDetails", newOrderDetails);
try
{
db.SaveChanges();
counts[0]++;
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
db.AcceptAllChanges();
}
try
{
db.Refresh(RefreshMode.StoreWins, newOrderDetails);
counts[0]++;
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.WriteLine("inserted {0}", counts[0]);
/////////////////////////////////////////////////////////////////
newOrderDetails.UnitPrice = (decimal)2.34;
newOrderDetails.Quantity = 2;
newOrderDetails.Discount = 0.1f;
try
{
db.SaveChanges();
counts[1]++;
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
db.AcceptAllChanges();
}
try
{
db.Refresh(RefreshMode.StoreWins, newOrderDetails);
counts[1]++;
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.WriteLine("updated {0}", counts[1]);
}
return(0);
}
public int SaveOrderDetails(string type, string productId, string unitPrice, string orderId, string productCount, string useStatus = null, string MemberCardNo = null, string RstType = null)
{
int i = 0;
try
{
int count = 1;
int.TryParse(productCount, out count);
OrderDetailsModel odm = new OrderDetailsModel();
OrderDetails info = new OrderDetails();
MyMenuModel odb = new MyMenuModel();
List<OrderDetails> orderD = odm.getOrderDetailInfoData(productId, orderId);
List<MyOrderDetail> detail = null;
if (MemberCardNo != null)
{
detail = odb.getMyOrderDetailListData(MemberCardNo, orderId, RstType);
}
if (orderD.Count > 0 && useStatus != "04")
{
type = "Update";
info.ProductCount = count;
info.CreateDate = DateTime.Now;
info.ProductId = new Guid(productId);
info.OrderId = new Guid(orderId);
info.TotalPrice = Convert.ToDecimal(unitPrice) * count;
}
else
{
if (useStatus == "04")
{
if (detail != null && detail.Count > 0)
{
foreach (MyOrderDetail item1 in detail)
{
if (item1.UseState == "04")
{
//已经有赠送的菜。（先删除已有的赠送菜，再添加现选择有赠送菜）
int j = odm.DelGiftOrderDetails(useStatus, orderId);
}
}
}
}
info.DetailsId = Guid.NewGuid();
info.OrderId = new Guid(orderId);
info.ProductId = new Guid(productId);
info.UnitPrice = Convert.ToDecimal(unitPrice);
info.TotalPrice = Convert.ToDecimal(unitPrice) * count;
info.CreateDate = DateTime.Now;
info.ProductCount = count;
if (useStatus != "04") { info.UseState = "00"; } else { info.UseState = useStatus; }
}
i = odm.SaveOrderDetails(type, info);
}
catch (Exception ex)
{
Logger.Log(ex);
i = 0;
}
return i;
}
/// <summary>
/// Updates an existing order
/// </summary>
public override bool UpdateOrder(OrderDetails order)
{
using (SqlConnection cn = new SqlConnection(this.ConnectionString))
{
object shippedDate = order.ShippedDate;
if (order.ShippedDate == DateTime.MinValue)
shippedDate = DBNull.Value;
SqlCommand cmd = new SqlCommand("tbh_Store_UpdateOrder", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@OrderID", SqlDbType.Int).Value = order.ID;
cmd.Parameters.Add("@StatusID", SqlDbType.Int).Value = order.StatusID;
cmd.Parameters.Add("@ShippedDate", SqlDbType.DateTime).Value = shippedDate;
cmd.Parameters.Add("@TransactionID", SqlDbType.NVarChar).Value = order.TransactionID;
cmd.Parameters.Add("@TrackingID", SqlDbType.NVarChar).Value = order.TrackingID;
cn.Open();
int ret = ExecuteNonQuery(cmd);
return (ret == 1);
}
}
public async Task ClearAndFillWithDemoData()
{
await OrderDetails.ForEachAsync(od => OrderDetails.Remove(od));
await Orders.ForEachAsync(o => Orders.Remove(o));
await Customers.ForEachAsync(c => Customers.Remove(c));
await Products.ForEachAsync(p => Products.Remove(p));
var demoCustomers = new[] {
new Customer()
{
CompanyName = "Corina Air Conditioning", CountryIsoCode = "AT"
},
new Customer()
{
CompanyName = "Fernando Engineering", CountryIsoCode = "AT"
},
new Customer()
{
CompanyName = "Murakami Plumbing", CountryIsoCode = "CH"
},
new Customer()
{
CompanyName = "Naval Metal Construction", CountryIsoCode = "DE"
}
};
Customers.AddRange(demoCustomers);
var demoProducts = new[] {
new Product()
{
Description = "Mountain Bike", IsAvailable = true, CategoryCode = "BIKE", PricePerUom = 2500
},
new Product()
{
Description = "Road Bike", IsAvailable = true, CategoryCode = "BIKE", PricePerUom = 2000
},
new Product()
{
Description = "Skate Board", IsAvailable = true, CategoryCode = "BOARD", PricePerUom = 100
},
new Product()
{
Description = "Long Board", IsAvailable = true, CategoryCode = "BOARD", PricePerUom = 250
},
new Product()
{
Description = "Scooter", IsAvailable = false, CategoryCode = "OTHERS", PricePerUom = 150
}
};
Products.AddRange(demoProducts);
var rand = new Random();
for (var i = 0; i < 100; i++)
{
var order = new OrderHeader()
{
OrderDate = new DateTimeOffset(new DateTime(2014, rand.Next(1, 12), rand.Next(1, 28))),
Customer = demoCustomers[rand.Next(demoCustomers.Length - 1)]
};
Orders.Add(order);
for (var j = 0; j < 3; j++)
{
OrderDetails.Add(new OrderDetail()
{
Order = order,
Product = demoProducts[rand.Next(demoProducts.Length - 1)],
Amount = rand.Next(1, 5)
});
}
}
await SaveChangesAsync();
}
/// <summary>
/// Request certificate from the ACME server
/// </summary>
/// <param name="binding"></param>
/// <returns></returns>
public CertificateInfo RequestCertificate(ICsrPlugin csrPlugin, Renewal renewal, Target target, OrderDetails order)
{
// What are we going to get?
var pfxFileInfo = new FileInfo(PfxFilePath(renewal));
// Determine/check the common name
var identifiers = target.GetHosts(false);
var commonName = target.CommonName;
if (!string.IsNullOrWhiteSpace(commonName))
{
var idn = new IdnMapping();
commonName = idn.GetAscii(commonName);
if (!identifiers.Contains(commonName, StringComparer.InvariantCultureIgnoreCase))
{
_log.Warning($"Common name {commonName} provided is invalid.");
commonName = identifiers.First();
}
}
// Determine the friendly name
var friendlyName = renewal.FriendlyName;
if (string.IsNullOrEmpty(friendlyName))
{
friendlyName = target.FriendlyName;
}
if (string.IsNullOrEmpty(friendlyName))
{
friendlyName = commonName;
}
// Try using cached certificate first to avoid rate limiting during
// (initial?) deployment troubleshooting. Real certificate requests
// will only be done once per day maximum unless the --force parameter
// is used.
var cache = CachedInfo(renewal);
if (cache != null &&
cache.CacheFile.LastWriteTime > DateTime.Now.AddDays(-1) &&
cache.Match(target))
{
if (_runLevel.HasFlag(RunLevel.IgnoreCache))
{
_log.Warning("Cached certificate available but not used with --{switch}. Use 'Renew specific' or " +
"'Renew all' in the main menu to run unscheduled renewals without hitting rate limits.",
nameof(MainArguments.Force).ToLower());
}
else
{
_log.Warning("Using cached certificate for {friendlyName}. To force issue of a new certificate within " +
"24 hours, delete the .pfx file from the CertificatePath or run with the --{switch} switch. " +
"Be ware that you might run into rate limits doing so.",
friendlyName,
nameof(MainArguments.Force).ToLower());
return(cache);
}
}
var csr = csrPlugin.GenerateCsr(commonName, identifiers);
var csrBytes = csr.CreateSigningRequest();
order = _client.SubmitCsr(order, csrBytes);
File.WriteAllText(GetPath(renewal, "-csr.pem"), _pemService.GetPem("CERTIFICATE REQUEST", csrBytes));
_log.Information("Requesting certificate {friendlyName}", friendlyName);
var rawCertificate = _client.GetCertificate(order);
if (rawCertificate == null)
{
throw new Exception($"Unable to get certificate");
}
var certificate = new X509Certificate2(rawCertificate);
var certificateExport = certificate.Export(X509ContentType.Cert);
var crtPem = _pemService.GetPem("CERTIFICATE", certificateExport);
// Get issuer certificate
var issuerCertificate = new X509Certificate2(rawCertificate.Skip(certificateExport.Length).ToArray());
var issuerCertificateExport = issuerCertificate.Export(X509ContentType.Cert);
var issuerPem = _pemService.GetPem("CERTIFICATE", issuerCertificateExport);
// Build pfx archive
var pfx = new bc.Pkcs.Pkcs12Store();
var bcCertificate = _pemService.ParsePem <bc.X509.X509Certificate>(crtPem);
var bcCertificateEntry = new bc.Pkcs.X509CertificateEntry(bcCertificate);
var bcCertificateAlias = bcCertificate.SubjectDN.ToString();
var bcPrivateKeyEntry = new bc.Pkcs.AsymmetricKeyEntry(csrPlugin.GetPrivateKey());
pfx.SetCertificateEntry(bcCertificateAlias, bcCertificateEntry);
pfx.SetKeyEntry(bcCertificateAlias, bcPrivateKeyEntry, new[] { bcCertificateEntry });
var bcIssuer = _pemService.ParsePem <bc.X509.X509Certificate>(issuerPem);
var bcIssuerEntry = new bc.Pkcs.X509CertificateEntry(bcIssuer);
var bcIssuerAlias = bcIssuer.SubjectDN.ToString();
pfx.SetCertificateEntry(bcIssuerAlias, bcIssuerEntry);
var pfxStream = new MemoryStream();
pfx.Save(pfxStream, null, new bc.Security.SecureRandom());
pfxStream.Position = 0;
using (var pfxStreamReader = new BinaryReader(pfxStream))
{
var tempPfx = new X509Certificate2(
pfxStreamReader.ReadBytes((int)pfxStream.Length),
(string)null,
X509KeyStorageFlags.MachineKeySet |
X509KeyStorageFlags.PersistKeySet |
X509KeyStorageFlags.Exportable);
if (csrPlugin.CanConvert())
{
try
{
var converted = csrPlugin.Convert(tempPfx.PrivateKey);
if (converted != null)
{
tempPfx.PrivateKey = converted;
}
}
catch
{
_log.Warning("Private key conversion error.");
}
}
tempPfx.FriendlyName = $"{friendlyName} {DateTime.Now.ToUserString()}";
File.WriteAllBytes(pfxFileInfo.FullName, tempPfx.Export(X509ContentType.Pfx, renewal.PfxPassword));
pfxFileInfo.Refresh();
}
// Update LastFriendlyName so that the user sees
// the most recently issued friendlyName in
// the WACS GUI
renewal.LastFriendlyName = friendlyName;
// Recreate X509Certificate2 with correct flags for Store/Install
return(new CertificateInfo()
{
Certificate = ReadForUse(pfxFileInfo, renewal.PfxPassword),
CacheFile = pfxFileInfo,
CacheFilePassword = renewal.PfxPassword
});
}
/// <summary>
/// Inserts a new order
/// </summary>
public override int InsertOrder(OrderDetails order)
{
using (SqlConnection cn = new SqlConnection(this.ConnectionString))
{
SqlCommand cmd = new SqlCommand("tbh_Store_InsertOrder", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@AddedDate", SqlDbType.DateTime).Value = order.AddedDate;
cmd.Parameters.Add("@AddedBy", SqlDbType.NVarChar).Value = order.AddedBy;
cmd.Parameters.Add("@StatusID", SqlDbType.Int).Value = order.StatusID;
cmd.Parameters.Add("@ShippingMethod", SqlDbType.NVarChar).Value = order.ShippingMethod;
cmd.Parameters.Add("@SubTotal", SqlDbType.Money).Value = order.SubTotal;
cmd.Parameters.Add("@Shipping", SqlDbType.Money).Value = order.Shipping;
cmd.Parameters.Add("@ShippingFirstName", SqlDbType.NVarChar).Value = order.ShippingFirstName;
cmd.Parameters.Add("@ShippingLastName", SqlDbType.NVarChar).Value = order.ShippingLastName;
cmd.Parameters.Add("@ShippingStreet", SqlDbType.NVarChar).Value = order.ShippingStreet;
cmd.Parameters.Add("@ShippingPostalCode", SqlDbType.NVarChar).Value = order.ShippingPostalCode;
cmd.Parameters.Add("@ShippingCity", SqlDbType.NVarChar).Value = order.ShippingCity;
cmd.Parameters.Add("@ShippingState", SqlDbType.NVarChar).Value = order.ShippingState;
cmd.Parameters.Add("@ShippingCountry", SqlDbType.NVarChar).Value = order.ShippingCountry;
cmd.Parameters.Add("@CustomerEmail", SqlDbType.NVarChar).Value = order.CustomerEmail;
cmd.Parameters.Add("@CustomerPhone", SqlDbType.NVarChar).Value = order.CustomerPhone;
cmd.Parameters.Add("@CustomerFax", SqlDbType.NVarChar).Value = order.CustomerFax;
cmd.Parameters.Add("@TransactionID", SqlDbType.NVarChar).Value = order.TransactionID;
cmd.Parameters.Add("@OrderID", SqlDbType.Int).Direction = ParameterDirection.Output;
cn.Open();
int ret = ExecuteNonQuery(cmd);
return (int)cmd.Parameters["@OrderID"].Value;
}
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value);
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product").ToList();
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
ShoppingCartVM.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = item.Product.Price;
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
ShoppingCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = _unitOfWork.Coupon.GetFirstOrDefault(c => c.Name.ToLower() == ShoppingCartVM.OrderHeader.CouponCode.ToLower());
ShoppingCartVM.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, ShoppingCartVM.OrderHeader.OrderTotalOriginal);
}
else
{
ShoppingCartVM.OrderHeader.OrderTotal = ShoppingCartVM.OrderHeader.OrderTotalOriginal;
}
ShoppingCartVM.OrderHeader.CouponCodeDiscount = ShoppingCartVM.OrderHeader.OrderTotalOriginal - ShoppingCartVM.OrderHeader.OrderTotal;
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "sar",
Description = "Order ID : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Id == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public static OrderDetails CreateOrderDetails(int orderID, int productID, decimal unitPrice, int quantity, decimal discount)
{
OrderDetails orderDetails = new OrderDetails();
orderDetails.OrderID = orderID;
orderDetails.ProductID = productID;
orderDetails.UnitPrice = unitPrice;
orderDetails.Quantity = quantity;
orderDetails.Discount = discount;
return orderDetails;
}
public IActionResult SummaryNoPayPost()
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value);
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product").ToList();
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
ShoppingCartVM.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = item.Product.Price;
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
ShoppingCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = _unitOfWork.Coupon.GetFirstOrDefault(c => c.Name.ToLower() == ShoppingCartVM.OrderHeader.CouponCode.ToLower());
ShoppingCartVM.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, ShoppingCartVM.OrderHeader.OrderTotalOriginal);
}
else
{
ShoppingCartVM.OrderHeader.OrderTotal = ShoppingCartVM.OrderHeader.OrderTotalOriginal;
}
ShoppingCartVM.OrderHeader.CouponCodeDiscount = ShoppingCartVM.OrderHeader.OrderTotalOriginal - ShoppingCartVM.OrderHeader.OrderTotal;
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
//order will be created without online payment
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
protected void uiGridViewProducts_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "DeleteDetail")
{
OrderDetails objData = new OrderDetails();
objData.LoadByPrimaryKey(Convert.ToInt32(e.CommandArgument.ToString()));
objData.MarkAsDeleted();
objData.Save();
BindItems();
}
}
public IActionResult NewOrder(NewOrderViewModel model)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Something wrong");
return(View(model));
}
List <AddToCartViewModel> addToCartList = HttpContext.Session.Get <List <AddToCartViewModel> >("CartItem");
if (addToCartList == null)
{
return(RedirectToAction("Index", "Home"));
}
var num = HttpContext.Session.GetInt32("TotalPrice");
double totalPrice = 0;
if (num != null)
{
totalPrice = Convert.ToDouble(num);
}
ApplicationUsers user = _userManager.GetUserAsync(HttpContext.User).Result;
//Inserting Order
Orders orders = new Orders
{
AddedDate = DateTime.Now,
DeliveryAddress = model.DeliveryAddress,
LocationId = model.LocationId,
ModifiedDate = DateTime.Now,
Number = GenerateRandomNo().ToString(),
PaymentMethodId = model.PaymentMethodId,
Total = totalPrice,
};
orders.UserId = user.Id;
orders.DeliveryCharge = _unitOfWork.Repository <Location>().Find(x => x.Id == model.LocationId).Charge;
_unitOfWork.Repository <Orders>().Insert(orders);
//Inserting Order Details
int oId = orders.Id;
for (int i = 0; i < addToCartList.Count; i++)
{
OrderDetails orderDetails = new OrderDetails();
orderDetails.AddedDate = DateTime.Now;
orderDetails.ModifiedDate = DateTime.Now;
orderDetails.OrderId = oId;
orderDetails.ProductId = addToCartList[i].ProductId;
orderDetails.Quantity = addToCartList[i].Quantity;
orderDetails.Rate = addToCartList[i].FinalPrice;
orderDetails.Remarks = "";
_unitOfWork.Repository <OrderDetails>().Insert(orderDetails);
}
addToCartList = new List <AddToCartViewModel>();
HttpContext.Session.Set <List <AddToCartViewModel> >("CartItem", addToCartList);
int itemInCart = HttpContext.Session.Get <List <AddToCartViewModel> >("CartItem").Count;
HttpContext.Session.SetInt32("itemCount", itemInCart);
HttpContext.Session.SetInt32("TotalPrice", 0);
return(RedirectToAction("Index", "Home"));
}
private void BindItems()
{
OrderDetails details = new OrderDetails();
details.GetOrderDetails(CurrentOrder.OrderID);
uiGridViewProducts.DataSource = details.DefaultView;
uiGridViewProducts.DataBind();
//uiTextBoxTotal.Text = CurrentDeliveryOrder.GetDeliveryOrderTotals(CurrentDeliveryOrder.DeliveryOrderID).ToString();
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser.GetFirstOrDefault(c => c.Id == claim.Value, includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId ==
claim.Value, includeProperties: "Product");
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price, item.Product.Price50, item.Product.Price100);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
if (stripeToken == null)
{
//order will be made for delayed payment for authorized company
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(15);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
private void attach_OrderDetails(OrderDetails entity)
{
this.SendPropertyChanging();
entity.Orders = this;
}
public IActionResult SummmaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claims = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _uow.ApplicationUser.GetFirstOrDefault(a => a.Id == claims.Value, includeProperties: "Company");
ShoppingCartVM.ListCart = _uow.ShoppingCart.GetAll(s => s.ApplicationUserId == claims.Value, includeProperties: "Product");
ShoppingCartVM.OrderHeader.PaymentStatus = ProjectContstant.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = ProjectContstant.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claims.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_uow.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_uow.Save();
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
foreach (var orderDetail in ShoppingCartVM.ListCart)
{
orderDetail.Price = ProjectContstant.GetPriceBaseOnQuantity(orderDetail.Count, orderDetail.Product.Price, orderDetail.Product.Price50, orderDetail.Product.Price100);
OrderDetails oDetails = new OrderDetails()
{
ProductId = orderDetail.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = orderDetail.Price,
Count = orderDetail.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += oDetails.Count * oDetails.Price;
_uow.OrderDetails.Add(oDetails);
}
_uow.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
HttpContext.Session.SetInt32(ProjectContstant.shoppingCart, 0);
if (stripeToken == null)
{
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
ShoppingCartVM.OrderHeader.PaymentStatus = ProjectContstant.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = ProjectContstant.StatusApproved;
}
else
{
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order Id:" + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = ProjectContstant.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = ProjectContstant.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = ProjectContstant.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_uow.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
partial void InsertOrderDetails(OrderDetails instance);
public IActionResult OnPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId == claim.Value).ToList();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_unitOfWork.OrderHeader.Add(detailCart.OrderHeader);
_unitOfWork.Save();
foreach (var item in detailCart.listCart)
{
item.MenuItem = _unitOfWork.MenuItem.GetFirstOrDefault(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetails.Add(orderDetails);
}
detailCart.OrderHeader.OrderTotal = Convert.ToDouble(String.Format("{0:.##}", detailCart.OrderHeader.OrderTotal));
_unitOfWork.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ShoppingCart, 0);
_unitOfWork.Save();
if (stripeToken != null)
{
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "EUR",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
detailCart.OrderHeader.TransactionId = charge.Id;
if (charge.Status.ToLower() == "succeeded")
{
//email
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Cart/OrderConfirmation", new { id = detailCart.OrderHeader.Id }));
}
partial void DeleteOrderDetails(OrderDetails instance);
protected void lnkNext_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(Convert.ToString(Session["username"])))
{
BEL obj_d = new BEL();
OrderDetails obj_order = new OrderDetails();
if (rdbilling.Checked == true)
{
txtFullName.Text = txtFullNameBill.Text;
txtEmailAddress.Text = txtEmailAddressBill.Text;
txtShippingAddress.Text = txtBillingAddressBill.Text;
txtShippingLandmark.Text = txtBillingLandmarkBill.Text;
txtCompany.Text = txtCompanyBill.Text;
txtContactNumber.Text = txtContactNumberBill.Text;
txtPostcodezip.Text = txtPostcodezipBill.Text;
txtSelectCity.Text = txtSelectCityBill.Text;
ddCountry.SelectedValue = ddCountryBill.SelectedValue;
ddState.SelectedValue = ddStateBill.SelectedValue;
}
try
{
string billfullname = txtFullNameBill.Text;
string billfirstname;
string billlastname;
string[] billnames = billfullname.ToString().Trim().Split(new char[] { ' ' }, 3);
if (billnames.Length == 1)
{
billfirstname = billnames[0];
billlastname = "";
}
else if (billnames.Length == 3)
{
billfirstname = billnames[0];
billlastname = billnames[1] + " " + billnames[2];
}
else
{
billfirstname = billnames[0];
billlastname = billnames[1];
}
obj_d.BillFname = billfirstname;
obj_d.BillLname = billlastname;
obj_d.BillEmailid = txtEmailAddressBill.Text;
obj_d.BillCompay = "";
if (txtCompanyBill.Text != "")
{
obj_d.BillCompay = txtCompanyBill.Text;
}
obj_d.BillContact = txtContactNumberBill.Text;
obj_d.BillAddress = txtBillingAddressBill.Text;
obj_d.BillNearby = "";
if (txtBillingLandmarkBill.Text != "")
{
obj_d.BillNearby = txtBillingLandmarkBill.Text;
}
obj_d.BillCountry = ddCountryBill.SelectedValue;
obj_d.BillState = ddStateBill.SelectedValue;
obj_d.BillCity = "";
if (txtSelectCityBill.Text != "")
{
obj_d.BillCity = txtSelectCityBill.Text;
}
obj_d.BillZip = "";
if (txtPostcodezipBill.Text != "")
{
obj_d.BillZip = txtPostcodezipBill.Text;
}
string fullname = txtFullName.Text;
string fname;
string lname;
string[] names = fullname.ToString().Trim().Split(new char[] { ' ' }, 3);
if (names.Length == 1)
{
fname = names[0];
lname = "";
}
else if (names.Length == 3)
{
fname = names[0];
lname = names[1] + " " + names[2];
}
else
{
fname = names[0];
lname = names[1];
}
obj_d.ShipFname = fname;
obj_d.ShipLname = lname;
obj_d.ShipEmail = "";
if (txtEmailAddress.Text != "")
{
obj_d.ShipEmail = txtEmailAddress.Text;
}
obj_d.ShipCompany = "";
if (txtCompany.Text != "")
{
obj_d.ShipCompany = txtCompany.Text;
}
obj_d.ShipMobile = "";
if (txtContactNumber.Text != "")
{
obj_d.ShipMobile = txtContactNumber.Text;
}
obj_d.ShipAddress = "";
if (txtShippingAddress.Text != "")
{
obj_d.ShipAddress = txtShippingAddress.Text;
}
obj_d.ShipNearby = "";
if (txtShippingLandmark.Text != "")
{
obj_d.ShipNearby = txtShippingLandmark.Text;
}
obj_d.ShipCountry = ddCountry.SelectedValue;
obj_d.ShipState = ddState.SelectedValue;
obj_d.ShipCity = "";
if (txtSelectCity.Text != "")
{
obj_d.ShipCity = txtSelectCity.Text;
}
obj_d.ShipZip = "";
if (txtPostcodezip.Text != "")
{
obj_d.ShipZip = txtPostcodezip.Text;
}
int result = 0;
if (Session["username"].ToString() == "Guest")
{
obj_d.TransId = Session["Transid"].ToString();
if (Session["guestcheckout"] == null)
{
result = obj_order.AddUpdateUserDetails(obj_d);
if (result != 0)
{
Response.Redirect("order-overview.aspx", false);
Session["guestcheckout"] = "guest checkout";
}
}
else
{
obj_order.UpdateUserDetailsGuest(obj_d);//by transid update
Response.Redirect("order-overview.aspx", false);
}
}
else
{
obj_d.UserId = Convert.ToInt32(Session["userid"]);
result = obj_order.UpdateUserDetails(obj_d);
if (result != 0)
{
Response.Redirect("order-overview.aspx", false);
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
else
{
Response.Redirect("Login.aspx", false);
}
}
public void Save(OrderDetails entity)
{
_session.Save(entity);
}
// GET: Checkout
public ActionResult Order()
{
OrderDetails order = null;
return(View(order));
}
/// <summary>
/// Добавление деталей заказа
/// </summary>
/// <param name="order"></param>
public bool AddOrderDetails(OrderDetailsDTO order)
{
try {
OrderDetails orderDAL = new OrderDetails();
orderDAL.OrderID = order.OrderID;
orderDAL.CustomerID = order.CustomerID;
orderDAL.EmployeeID = order.EmployeeID;
orderDAL.OrderDate = order.OrderDate;
orderDAL.RequiredDate = order.RequiredDate;
orderDAL.ShippedDate = order.ShippedDate;
orderDAL.ShipVia = order.ShipVia;
orderDAL.Freight = order.Freight;
orderDAL.ShipName = order.ShipName;
orderDAL.ShipAddress = order.ShipAddress;
orderDAL.ShipCity = order.ShipCity;
orderDAL.ShipRegion = order.ShipRegion;
orderDAL.ShipPostalCode = order.ShipPostalCode;
orderDAL.ShipCountry = order.ShipCountry;
orderDAL.ProductID = order.ProductID;
orderDAL.ProductName = order.ProductName;
orderDAL.Quantity = order.Quantity;
orderDAL.UnitPrice = order.UnitPrice;
orderDAL.Discount = order.Discount;
if (Data.AddOrderDetail(orderDAL) != true)
return true;
else return false;
}
catch (ArgumentException ex)
{
throw new ValidationException(ex.Message, ex.ParamName);
}
}
internal OrderDetails SubmitCsr(OrderDetails details, byte[] csr)
{
return(Retry(() => _client.FinalizeOrderAsync(details.Payload.Finalize, csr).Result));
}
/// <summary>
/// There are no comments for OrderDetails in the schema.
/// </summary>
public void AddToOrderDetails(OrderDetails orderDetails)
{
base.AddObject("OrderDetails", orderDetails);
}
internal byte[] GetCertificate(OrderDetails order)
{
return(Retry(() => _client.GetOrderCertificateAsync(order).Result));
}
[Fact] // Issue #1207
public void Can_add_identifying_one_to_many_via_dependents_with_key_generation()
{
using (var context = new EarlyLearningCenter())
{
var product1 = new Product();
var product2 = new Product();
var order1 = new Order();
var order2 = new Order();
var orderDetails1a = new OrderDetails { Order = order1, Product = product1 };
var orderDetails1b = new OrderDetails { Order = order1, Product = product2 };
var orderDetails2a = new OrderDetails { Order = order2, Product = product1 };
var orderDetails2b = new OrderDetails { Order = order2, Product = product2 };
context.Add(orderDetails1a);
context.Add(orderDetails2a);
context.Add(orderDetails1b);
context.Add(orderDetails2b);
context.Add(order1);
context.Add(product1);
context.Add(order2);
context.Add(product2);
AssertOrderAndDetailsFixedUp(context, orderDetails1a, orderDetails1b, orderDetails2a, orderDetails2b);
}
}
public Task <CertificateInfo> RequestCertificate(ICsrPlugin csrPlugin, RunLevel runLevel, Renewal renewal, Target target, OrderDetails order)
{
// Create self-signed certificate
var ecdsa = ECDsa.Create(); // generate asymmetric key pair
var req = new CertificateRequest($"CN={target.CommonName}", ecdsa, HashAlgorithmName.SHA256);
var cert = req.CreateSelfSigned(DateTimeOffset.Now, DateTimeOffset.Now.AddYears(5));
return(Task.FromResult(new CertificateInfo(cert)
{
CacheFile = null,
CacheFilePassword = null,
Certificate = cert,
}));
}
public ActionResult Index()
{
_session.CreateSQLQuery("delete orderdetails").ExecuteUpdate();
_session.CreateSQLQuery("delete shoppingcarts").ExecuteUpdate();
_session.CreateSQLQuery("delete productimages").ExecuteUpdate();
_session.CreateSQLQuery("delete orders").ExecuteUpdate();
_session.CreateSQLQuery("delete users").ExecuteUpdate();
_session.CreateSQLQuery("delete products").ExecuteUpdate();
_session.CreateSQLQuery("delete orderstate").ExecuteUpdate();
_session.CreateSQLQuery("delete deliverytypes").ExecuteUpdate();
_session.CreateSQLQuery("delete categories").ExecuteUpdate();
_session.CreateSQLQuery("delete manufacturers").ExecuteUpdate();
#region OrderStates
var orderState1 = new OrderState("Nowe zamówienie");
var orderState2 = new OrderState("W trakcie realizacji");
var orderState3 = new OrderState("Przekazano do doręczenia");
#endregion
#region manufacturers
var manufacturer = new Manufacturers("Electronic Arts");
var manufacturer2 = new Manufacturers("Ubisoft");
var manufacturer3 = new Manufacturers("CD Projekt RED");
var manufacturer4 = new Manufacturers("Blizzard");
var manufacturer5 = new Manufacturers("SEGA");
var manufacturer6 = new Manufacturers("RockstarGames");
#endregion
#region catregories
var category1 = new Categories("Akcja", "");
var category2 = new Categories("MMORpg", "Massively multiplayer online role-playing game");
var category3 = new Categories("Sport", "");
var category4 = new Categories("Klasyka", "");
var category5 = new Categories("Pozostałe", "");
#endregion
#region products
var productList = new List<Products>
{
new Products("Fifa", "", randomDecimal(5, 150), category3,
manufacturer, 15, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Need for speed", "", randomDecimal(5, 150), category3,
manufacturer, 15, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("The sims", "", randomDecimal(5, 150), category5,
manufacturer, 15, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Battlefield", "", randomDecimal(5, 150), category4,
manufacturer, 15, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Medal of honor", "", randomDecimal(5, 150), category4,
manufacturer, 15, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Watch dogs", "", randomDecimal(5, 150), category1,
manufacturer2, 5, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Far cry", "", randomDecimal(5, 150), category1,
manufacturer2, 12, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Heroes V", "", randomDecimal(5, 150), category4,
manufacturer2, 1, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Assassins Creed", "", randomDecimal(5, 150), category5,
manufacturer2, 4, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Wiedźmin", "", randomDecimal(5, 150), category1,
manufacturer3, 25, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Total war: Rome II", "", randomDecimal(5, 150), category1,
manufacturer4, 13, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Company of heroes", "", randomDecimal(5, 150), category4,
manufacturer4, 9, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("GTA", "", randomDecimal(5, 150), category5,
manufacturer5, 13, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), ""),
new Products("Max payne", "", randomDecimal(5, 150), category4,
manufacturer5, 9, Common.GetRandomBool(), Common.GetRandomBool(),
Common.GetRandomBool(), "")
};
#endregion
#region productImages
string filename = Server.MapPath(Url.Content("~/FrontEnd/img/empty_gallery.png"));
byte[] bytes = System.IO.File.ReadAllBytes(filename);
var products = _productRepo.GetAll();
#endregion
#region users
const string password = "******";
var crypto = new PBKDF2();
string enryptPass = crypto.Compute(password);
string passwordSalt = crypto.Salt;
const string email = "*****@*****.**";
const string city = "Warszawa";
const string address = "Sik 41/12";
const bool isAdmin = false;
const string userName = "******";
const string surname = "Surname";
const string ipAddress = "102.154.12.12";
const string zipCode = "12-222";
var user = new Users(userName, surname, email, enryptPass, city, address, zipCode, isAdmin,
passwordSalt, ipAddress);
var user2 = new Users(userName, surname, "*****@*****.**", enryptPass, "Łódź", address, zipCode, true,
passwordSalt, ipAddress);
var user3 = new Users(userName, surname, "*****@*****.**", enryptPass, "Katowice", address, zipCode,
isAdmin,
passwordSalt, ipAddress);
#endregion
#region deliveryTypes
var deliveryType = new DeliveryTypes("Poczta", Convert.ToDecimal(8.99));
var deliveryType2 = new DeliveryTypes("Kurier", Convert.ToDecimal(12.00));
var deliveryType3 = new DeliveryTypes("Obiór osobisty", Convert.ToDecimal(0.00));
#endregion
_catRepo.Save(category1);
_catRepo.Save(category2);
_catRepo.Save(category3);
_catRepo.Save(category4);
_catRepo.Save(category5);
_orderStateRepository.Save(orderState1);
_orderStateRepository.Save(orderState2);
_orderStateRepository.Save(orderState3);
_manuRepo.Save(manufacturer);
_manuRepo.Save(manufacturer2);
_manuRepo.Save(manufacturer3);
_manuRepo.Save(manufacturer5);
_manuRepo.Save(manufacturer4);
_manuRepo.Save(manufacturer6);
_userRepo.Save(user);
_userRepo.Save(user2);
_userRepo.Save(user3);
foreach (var item in productList)
{
item.Description =
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse sem mi, efficitur eget nisi vitae, facilisis efficitur massa. Sed rhoncus vestibulum velit, sit amet sodales nisl semper id. Praesent non nisi vitae orci facilisis dapibus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam auctor. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse sem mi, efficitur eget nisi vitae, facilisis efficitur massa. Sed rhoncus vestibulum velit, sit amet sodales nisl semper id. Praesent non nisi vitae orci facilisis dapibus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam auctor. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse sem mi, efficitur eget nisi vitae, facilisis efficitur massa. Sed rhoncus vestibulum velit, sit amet sodales nisl semper id. Praesent non nisi vitae orci facilisis dapibus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam auctor.";
item.ShortDescription =
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse sem mi, efficitur eget nisi vitae, facilisis efficitur massa. Sed rhoncus vestibulum velit, sit amet sodales nisl semper id. Praesent non nisi vitae orci facilisis dapibus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam auctor.";
_productRepo.Save(item);
}
foreach (var productse in products)
_productImagesRepository.Save(new ProductImages(filename, bytes, productse));
_deliveryRepo.Save(deliveryType);
_deliveryRepo.Save(deliveryType2);
_deliveryRepo.Save(deliveryType3);
Random rnd = new Random();
for (int i = 0; i < 150; i++)
{
System.Threading.Thread.Sleep(10);
var order1 = new Orders(user, DateTime.Now.AddDays(-rnd.Next(1, 365)),
Convert.ToDecimal(rnd.Next(50, 400)), deliveryType, orderState1);
var order2 = new Orders(user2, DateTime.Now.AddDays(-rnd.Next(1, 365)),
Convert.ToDecimal(rnd.Next(50, 400)), deliveryType, orderState2);
var order3 = new Orders(user3, DateTime.Now.AddDays(-rnd.Next(1, 365)),
Convert.ToDecimal(rnd.Next(50, 400)), deliveryType, orderState2);
_ordersRepository.Save(order1);
_ordersRepository.Save(order2);
_ordersRepository.Save(order3);
var random = rnd.Next(1, productList.Count);
var orderDetails = new OrderDetails(order1, productList[random], rnd.Next(1, 5),
productList[random].Price);
var orderDetails2 = new OrderDetails(order2, productList[random], rnd.Next(1, 5),
productList[random].Price);
var orderDetails3 = new OrderDetails(order3, productList[random], rnd.Next(1, 5),
productList[random].Price);
_orderDetailsRepository.Save(orderDetails);
_orderDetailsRepository.Save(orderDetails2);
_orderDetailsRepository.Save(orderDetails3);
}
string[] myCookies = Request.Cookies.AllKeys;
foreach (string cookie in myCookies)
{
Response.Cookies[cookie].Expires = DateTime.Now.AddDays(-1);
}
FormsAuthentication.SignOut();
return RedirectToAction("index", "Home");
}
public bool LadeOrderDetails(OrderDetails orderDetails)
{
int result = ExecuteUpdate("UpdateLadeOrderDetails", orderDetails);
return(result > 0);
}
