static Order CreateFromDataModel(DataModel.Order Source)
{
return(new Order()
{
Id = Source.Id, CreateDate = Source.CreateDate, OrderName = Source.OrderName, Status = Source.Status.ToString()
});
}
private void ShowOrderComplete(Order completedOrder)
{
this.completedOrder = completedOrder;
stepsNav.Visible = false;
pnlOrderComplete.Visible = true;
pnlAjaxPanels.Visible = false;
pnlReviewOrder.Visible = false;
}
public Order Get(Int32 Id)
{
DataModel.Order FoundOrder = OrderDB.Orders.FirstOrDefault(x => x.Id == Id);
if (FoundOrder == null)
{
return(null);
}
return(CreateFromDataModel(FoundOrder));
}
public OrderTotal GetTotalForOrder(Int32 OrderId)
{
DataModel.Order TargetOrder = OrderDB.Orders.Include(x => x.OrderDetails).FirstOrDefault(x => x.Id == OrderId);
if (TargetOrder == null)
{
return(null);
}
return(new OrderTotal()
{
OrderId = OrderId, TotalQuantity = TargetOrder.OrderDetails.Sum(x => x.Quantity), TotalValue = TargetOrder.OrderDetails.Sum(x => x.Total)
});
}
/// <summary>
/// Adds order to a particular customer
/// </summary>
/// <param name="order">Order Added</param>
public void AddOrderByCustomerId(int customerId, int productId, int locationId, int quantity)
{
using var context = new project0Context(_dbContext);
var dbOrders = new DataModel.Order()
{
CustomerId = customerId,
ProductId = productId,
LocationId = locationId,
OrderQuantity = quantity,
};
context.Add(dbOrders);
context.SaveChanges();
}
/// <summary>
/// Takes an order, and checks that the customer and the store are in the model.
/// If they are not, then they are loaded into the model.
/// </summary>
/// <param name="o">The DB Order to be checked.</param>
private void checkForModelMissingOrderData(DataModel.Order o)
{
if (!Locations.Instance.HasLocation(o.StoreLocation))
{
//load up the location
GetLocation(o.StoreLocation);
}
Name custname = Db_StoreMapper.getCustomerName(o.Customer);
if (!Customers.Instance.HasCustomer(custname))
{
GetCustomerByName(custname);
}
}
private Order ConvertBLOrderToDBOrder(DataModel.Order order)
{
Order dbOrder = new Order();
dbOrder.Date = order.OrderDate;
for (int i = 0; i < order.Ordered.ProductList.Count(); ++i)
{
OrderDetail details = new OrderDetail();
details.ProductId = order.Ordered.ProductList[i].Id;
details.Quantity = order.Quantity[i];
dbOrder.OrderDetails.Add(details);
}
dbOrder.User = ConvertBLUserToDbUser(order.Orderer);
return(dbOrder);
}
public void AddToOrderDb(Library.Order order)
{
using var context = new AquariumContext(_contextOptions);
var newEntry = new DataModel.Order
{
StoreId = order.StoreId,
CustomerId = order.Customer.CustomerId,
AnimalId = order.Animal.AnimalId,
Quantity = order.Quantity,
Total = order.Total,
Date = order.Date
};
context.Orders.Add(newEntry);
context.SaveChanges();
}
/// <summary>
/// One of the beefiest functions. It has to create the new order, then create all the subsequent orderlines
/// that contain each product in the order, and finally it has to update the locationlines table
/// to represent the change in inventory from when the order is placed.
/// </summary>
/// <param name="order"></param>
public void AddOrder(Order order)
{
using var context = new StoredbContext(_contextOptions);
// get all values to create new order
var _LocationID = context.Locations.Where(x => x.Name == order.Location.Name).First().Id;
var _CustomerID = context.Customers.Where(x => x.FirstName == order.Customer.FirstName && x.LastName == order.Customer.LastName).First().Id;
var _total = order.Items.Sum(x => x.Price * x.Amount);
var _date = DateTime.Now;
// create and add the new order to the database
var new_order = new DataModel.Order
{
LocationId = _LocationID,
CustomerId = _CustomerID,
Total = (decimal)_total,
Date = _date
};
context.Orders.Add(new_order);
context.SaveChanges();
var OrderID = new_order.Id;
foreach (var product in order.Items)
{
// create a new orderline for each product
var productID = context.Products.Where(x => x.Name == product.Name).First().Id;
var new_orderline = new DataModel.OrderLine
{
OrderId = OrderID,
ProductId = productID,
Quantity = product.Amount,
Discount = (decimal)product.Discount
};
context.OrderLines.Add(new_orderline);
// update the inventory lines of the location to reflect the new order
var locationline = context.LocationLines
.Include(x => x.Location)
.Where(x => _LocationID == x.Location.Id && productID == x.ProductId).First();
locationline.Quantity -= product.Amount;
}
context.SaveChanges();
}
/// <summary>
/// Adds order to a particular customer
/// </summary>
/// <param name="order">Order Added</param>
public void AddOrderByCustomerId(int customerId, int locationId)
{
using var context = new project0Context(_dbContext);
var appOrders = new Library.Order()
{
CustomerId = customerId,
LocationId = locationId,
};
var dbOrders = new DataModel.Order()
{
CustomerId = appOrders.CustomerId,
LocationId = appOrders.LocationId,
// OrderDetails.Quantity = quantity,
};
context.Add(dbOrders);
context.SaveChanges();
}
public void MapToEfObject(DataModel.Order efObject, Model.Order domObject)
{
throw new NotImplementedException();
}
public Model.Order MapToDomain(DataModel.Order efObject)
{
throw new NotImplementedException();
}
protected void Page_Load(object sender, EventArgs e)
{
pnlOrderDetails.Visible = false;
LoadResourceFileSettings();
if (!IsPostBack)
{
PayPalStandardProvider payPalStandard =
new PayPalStandardProvider(
StoreContext.CurrentStore.GetPaymentProviderConfig(PaymentProviderName.PayPalStandard));
bool isPayPalIpn = false;
bool isPayPalReferrer = false;
bool isPayPalStandardReturn = false;
if (payPalStandard.IsEnabled)
{
isPayPalIpn = payPalStandard.IsIpnResponse(Request);
isPayPalReferrer = (Request.UrlReferrer != null)
? Request.UrlReferrer.ToString().Contains("paypal.com")
: false;
isPayPalStandardReturn = Request.Params["ppstdreturn"] != null;
}
Guid?completedOrderId = WA.Parser.ToGuid(Request.Params["dsoid"]);
if (completedOrderId.HasValue && !(isPayPalReferrer || isPayPalIpn))
{
// load an on-site order
OrderQuery q = new OrderQuery();
q.Where(q.CreatedFromCartId == completedOrderId.Value);
q.es.Top = 1;
order.Load(q);
}
else if (isPayPalReferrer || isPayPalIpn)
{
OrderController orderController = new OrderController(StoreContext);
CheckoutResult checkoutResult = orderController.CheckoutWithPayPalStandardCheckout(Request);
if (checkoutResult != null)
{
order = checkoutResult.SubmittedOrder;
}
}
//bool clientHasCartIdCookie = order.CreatedFromCartId.Value == StoreContext.CartId;
//if (UserInfo.IsSuperUser || UserInfo.IsInRole("Administrator") || UserInfo.UserID == order.UserId)
//if (UserInfo.IsSuperUser || UserInfo.IsInRole("Administrator") || clientHasCartIdCookie)
//{
pnlOrderDetails.Visible = true;
pnlOrderReceipt.Visible = true;
if (order.Id.HasValue)
{
ShowDigitalDownloads();
if (order.PaymentStatus == PaymentStatusName.Pending)
{
pnlDigitalDownloads.Visible = false;
}
if (isPayPalStandardReturn)
{
pnlOrderReceipt.Visible = false;
}
else
{
LoadOrderReceipt();
}
}
else
{
//ShowFlash("Unable to find order");
//flash.Text = "Unable to find order";
ShowFlash("Could not load Order from DB");
//flash.Text = "Could not load Order from DB";
pnlOrderReceipt.Visible = false;
pnlDigitalDownloads.Visible = false;
}
//}
}
}
