}// part-three, Insert button.
#endregion
#region Create ReturnedOrderDetails
public void Create_ReturnedOrderDetails(int receorderid, List <RecevingOrderList> quanreceList)
{
using (var context = new eToolsContext())
{
// var purchaseorderid = context.PurchaseOrders.Find(item.PurchaseOrderID);
foreach (var item in quanreceList)
{
if (item.Returning > 0)
{
ReturnedOrderDetail newReturnOrderDetail = new ReturnedOrderDetail();
newReturnOrderDetail.ReceiveOrderID = receorderid;
newReturnOrderDetail.PurchaseOrderDetailID = item.PurchasePrderDetail;
var stoItem = context.StockItems.Find(item.SID);
newReturnOrderDetail.ItemDescription = stoItem.Description;
newReturnOrderDetail.VendorStockNumber = stoItem.VendorStockNumber;
newReturnOrderDetail.Reason = item.Reason;
newReturnOrderDetail.Quantity = item.Returning.GetValueOrDefault();
context.ReturnedOrderDetails.Add(newReturnOrderDetail);
}
}
context.SaveChanges();
}
}// Create ReturnedOrderDetails.
public void ReceivePurchaseOrder(int orderNumber, List <ViewPurchaseOrderItems> orderDetails, bool orderCompleted)
{
using (var context = new eToolsContext())
{
PurchaseOrder purchaseOrder = context.PurchaseOrders.Find(orderNumber);
purchaseOrder.Closed = orderCompleted;
context.Entry(purchaseOrder).Property("Closed").IsModified = true;
ReceiveOrder receiveOrder = new ReceiveOrder();
receiveOrder.PurchaseOrderID = orderNumber;
receiveOrder.ReceiveDate = DateTime.Now;
context.ReceiveOrders.Add(receiveOrder);
StockItem stockItem = null;
PurchaseOrderDetail purchaseOrderDetail = null;
ReceiveOrderDetail receiveOrderDetail = null;
ReturnedOrderDetail returnedOrderDetail = null;
foreach (ViewPurchaseOrderItems item in orderDetails)
{
purchaseOrderDetail = purchaseOrder.PurchaseOrderDetails.Where(order => order.StockItemID == item.ItemID).SingleOrDefault();
if (item.Received > 0)
{
receiveOrderDetail = new ReceiveOrderDetail();
receiveOrderDetail.ReceiveOrderID = receiveOrder.ReceiveOrderID;
receiveOrderDetail.PurchaseOrderDetailID = purchaseOrderDetail.PurchaseOrderDetailID;
receiveOrderDetail.QuantityReceived = item.Received;
context.ReceiveOrderDetails.Add(receiveOrderDetail);
stockItem = context.StockItems.Find(item.ItemID);
stockItem.QuantityOnHand += item.Received;
context.Entry(stockItem).Property("QuantityOnHand").IsModified = true;
if (item.Received > stockItem.QuantityOnOrder)
{
stockItem.QuantityOnOrder = 0;
}
else
{
stockItem.QuantityOnOrder -= item.Received;
}
context.Entry(stockItem).Property("QuantityOnOrder").IsModified = true;
}
if (item.Returned > 0)
{
returnedOrderDetail = new ReturnedOrderDetail();
returnedOrderDetail.ReceiveOrderID = receiveOrder.ReceiveOrderID;
returnedOrderDetail.PurchaseOrderDetailID = purchaseOrderDetail.PurchaseOrderDetailID;
returnedOrderDetail.ItemDescription = stockItem.Description;
returnedOrderDetail.Quantity = item.Returned;
returnedOrderDetail.Reason = item.Reason;
context.ReturnedOrderDetails.Add(returnedOrderDetail);
}
}
context.SaveChanges();
}
}
} //eom
public void Add_ReceivedOrders(int purchaseOrderId, int poNumber, List <ReceiveNewOrders> newOrders)
{
using (var context = new eBikesContext())
{
int idValue = 0;
ReceiveOrder receiveNewOrder = null;
ReceiveOrderDetail receiveNewOrderDetail = null;
ReturnedOrderDetail returnedOrder = null;
//Add new received order
receiveNewOrder = new ReceiveOrder();
receiveNewOrder.PurchaseOrderID = purchaseOrderId;
receiveNewOrder.ReceiveDate = DateTime.Now;
receiveNewOrder = context.ReceiveOrders.Add(receiveNewOrder);
idValue = receiveNewOrder.ReceiveOrderDetails.Count() + 1;
//Loop through the details of order
foreach (ReceiveNewOrders item in newOrders)
{
if (item.QtyReceived != 0)
{
if (item.QtyReceived <= item.Outstanding)
{
receiveNewOrderDetail = new ReceiveOrderDetail();
receiveNewOrderDetail.PurchaseOrderDetailID = item.PurchaseOrderDetailId;
receiveNewOrderDetail.ReceiveOrderID = idValue;
receiveNewOrderDetail.QuantityReceived = item.QtyReceived;
receiveNewOrder.ReceiveOrderDetails.Add(receiveNewOrderDetail);
//Update quantities in parts table
var partExists = context.Parts.Where(p => p.PartID == item.PartId).SingleOrDefault();
if (partExists != null)
{
if (partExists.QuantityOnOrder >= item.Outstanding)
{
context.Parts.Attach(partExists);
partExists.QuantityOnHand += item.QtyReceived;
partExists.QuantityOnOrder -= item.QtyReceived;
context.Entry(partExists).State = EntityState.Modified;
}
else
{
throw new Exception("There is an issue with Part Number " + partExists.PartID +
" - " + partExists.Description +
" the quanity on order (" + partExists.QuantityOnOrder + ") is less than that outsanding.");
}
}
else
{
throw new Exception("Part does not exist in database or there is no quantity on order");
}
}
else
{
throw new Exception("Receive Quantity can not be more than Outstanding quantity");
}
}
//Process returned items
if (!string.IsNullOrEmpty(item.QtyReturned.ToString()) && !string.IsNullOrEmpty(item.Notes))
{
returnedOrder = new ReturnedOrderDetail();
returnedOrder.ReceiveOrderID = idValue;
returnedOrder.PurchaseOrderDetailID = item.PurchaseOrderDetailId;
returnedOrder.ItemDescription = item.PartDescription;
returnedOrder.Quantity = item.QtyReturned;
returnedOrder.Reason = item.Notes;
returnedOrder.VendorPartNumber = item.PartId.ToString();
receiveNewOrder.ReturnedOrderDetails.Add(returnedOrder);
}
}
//Process items in unorder cart
var unordered =
context.UnorderedPurchaseItemCarts.Where(up => up.PurchaseOrderNumber == 0);
if (unordered.Count() > 0)
{
foreach (var unorderedItem in unordered)
{
ReturnedOrderDetail unorderedReturn = new ReturnedOrderDetail();
unorderedReturn.ReceiveOrderID = idValue;
unorderedReturn.Quantity = unorderedItem.Quantity;
unorderedReturn.Reason = unorderedItem.Description;
unorderedReturn.VendorPartNumber = unorderedItem.VendorPartNumber;
receiveNewOrder.ReturnedOrderDetails.Add(unorderedReturn);
context.UnorderedPurchaseItemCarts.Remove(unorderedItem);
}
}
//Get count of outstanding items
int outstandingSum = newOrders.Sum(item => item.Outstanding);
int receivedSum = newOrders.Sum(rs => rs.QtyReceived);
if ((outstandingSum - receivedSum) == 0)
{
PurchaseOrder po = context.PurchaseOrders.Find(purchaseOrderId);
if (po != null)
{
context.PurchaseOrders.Attach(po);
po.Closed = true;
context.Entry(po).State = EntityState.Modified;
}
}
context.SaveChanges();
}
}
public void ReceiveOrder(int purchaseOrderID, List <OpenPurchaseOrderDetails> openPODetails)
{
//openpodetails and unordereditems collected in code-behind from controls on page
using (var context = new eToolsContext())
{
UnorderedPurchaseItemCartController unorderedItemsController = new UnorderedPurchaseItemCartController();
List <UnorderedPurchaseItemCart> unorderedItems = unorderedItemsController.Get_ListUnorderedPurchaseItemCart();
//transaction
//create a receiveorder for the purchaseorderid
ReceiveOrder receiveOrder = new ReceiveOrder();
receiveOrder.PurchaseOrderID = purchaseOrderID;
receiveOrder.ReceiveDate = DateTime.Now;
context.ReceiveOrders.Add(receiveOrder);
//create receiveorderdetails for each openPODetails if there is anything entered in receivedquantity
foreach (OpenPurchaseOrderDetails openPO in openPODetails)
{
//make a receiveorderdetail if quantityreceived > 0 and update stockitems, make a returnorderdetail if quantityreturned > 0
if (openPO.ReceivedQuantity > 0)
{
ReceiveOrderDetail rOD = new ReceiveOrderDetail();
rOD.ReceiveOrderID = receiveOrder.ReceiveOrderID;
rOD.PurchaseOrderDetailID = openPO.PurchaseOrderDetailID;
rOD.QuantityReceived = openPO.ReceivedQuantity;
openPO.QuantityOutstanding -= openPO.ReceivedQuantity;
context.ReceiveOrderDetails.Add(rOD);
//adjust stockitem QoH (+ReceivedQuantity) and QoO (-ReceivedQuantity) with same stockitemid
StockItem stockItem = context.StockItems.Find(openPO.StockItemID);
stockItem.QuantityOnHand += openPO.ReceivedQuantity;
stockItem.QuantityOnOrder -= openPO.ReceivedQuantity;
context.Entry(stockItem).State = System.Data.Entity.EntityState.Modified;
}
if (openPO.ReturnedQuantity > 0)
{
ReturnedOrderDetail reOD = new ReturnedOrderDetail();
reOD.ReceiveOrderID = receiveOrder.ReceiveOrderID;
reOD.PurchaseOrderDetailID = openPO.PurchaseOrderDetailID;
reOD.ItemDescription = openPO.StockItemDescription;
reOD.Quantity = openPO.ReturnedQuantity;
reOD.Reason = openPO.ReturnReason;
reOD.VendorStockNumber = openPO.VendorStockNumber;
context.ReturnedOrderDetails.Add(reOD);
}
}
//create returnorderdetail for each unorderedItems and delete them from database
UnorderedPurchaseItemCartController unOsysmgr = new UnorderedPurchaseItemCartController();
foreach (UnorderedPurchaseItemCart item in unorderedItems)
{
ReturnedOrderDetail reOD = new ReturnedOrderDetail();
reOD.ReceiveOrderID = receiveOrder.ReceiveOrderID;
reOD.ItemDescription = item.Description;
reOD.Quantity = item.Quantity;
reOD.VendorStockNumber = item.VendorStockNumber;
context.ReturnedOrderDetails.Add(reOD);
unOsysmgr.Delete_UnorderedPurchaseItemCart(item.CartID);
}
//if no purchaseorderdetails have > 0 QOS, close the order
if (!(openPODetails.Any(x => x.QuantityOutstanding > 0)))
{
PurchaseOrder pOrder = context.PurchaseOrders.Find(purchaseOrderID);
pOrder.Closed = true;
context.Entry(pOrder).State = System.Data.Entity.EntityState.Modified;
}
context.SaveChanges();
}
}
/// <summary>
/// Transactional process of an outstanding order:
/// <para>>> Updates the order details</para>
/// <para>>> Updates stock item quantity fields for the receive order detail rows</para>
/// <para>>> Creates a receive order record</para>
/// <para>>> Creates receive order details and/or returned order details record(s)</para>
/// <para>>> Updates the outstanding order as closed if fully received</para>
/// </summary>
/// <param name="_poID"></param>
/// <param name="_OODs"></param>
/// <param name="_UPICs"></param>
public bool OpenOrder_Receive(int _poID, List <OpenOrderDetail> _OODs, List <int> _UPICs)
{
using (var context = new eToolsContext())
{
// Transaction process:
// A) Create a ReceiveOrder record when at least one item is received, returned, or unordered
// B) Create a new ReceiveOrderDetail record for each item that is received
// C) Increase stock item QuantityOnHand by the received quantity
// D) Decrease stock item QuantityOnOrder by the received quantity
// E) Create a new ReturnedOrderDetail record for each item that is returned
// F) Check if the PurchaseOrder can be closed
// G) Create a new ReturnedOrderDetail record for each item that is unordered
// H) Save all changes
// All the records that can be created or updated in the transaction processs
List <ReceiveOrderDetail> ReceiveOrderDetails = new List <ReceiveOrderDetail>();
List <ReturnedOrderDetail> ReturnedOrderDetails = new List <ReturnedOrderDetail>();
List <StockItem> StockItems = new List <StockItem>();
PurchaseOrder purchaseOrder = null;
// A >>
ReceiveOrder receiveOrder = new ReceiveOrder(); // Note: ReceiveOrderID is an identity created when ReceiveOrder inserted
receiveOrder.PurchaseOrderID = _poID;
receiveOrder.ReceiveDate = DateTime.Now; // Nullable
// Continue if order details exist
if (_OODs.Count > 0)
{
bool isOpen = false; // Reverse logic check where order has to be proven to be open (upon iteration through each order detail row)
// Process each open order detail
foreach (OpenOrderDetail ood in _OODs)
{
StockItem stockItem = null;
int qtyOutstanding = ood.QtyOutstanding;
int qtyReceived = (int)ood.QtyReceived;
// Check if item was received
if (ood.QtyReceived != null && ood.QtyReceived > 0)
{
// Ensure received qty is not greather than the outstanding qty
if (qtyReceived > qtyOutstanding)
{
throw new Exception("Each received qty must be less than the outstanding qty");
}
else
{
// Monitor order state
if (qtyReceived < qtyOutstanding)
{
isOpen = true;
}
// B >>
ReceiveOrderDetail receiveOrderDetail = new ReceiveOrderDetail(); // Note: ReceiveOrderID is an identity created when ReceiveOrder inserted
receiveOrderDetail.PurchaseOrderDetailID = ood.PODetailID;
receiveOrderDetail.QuantityReceived = qtyReceived;
// Pull stock item from database
int stockItemID = ood.StockItemID;
stockItem = (
from x in context.StockItems
where x.StockItemID == stockItemID
select x)
.FirstOrDefault();
// C >>
stockItem.QuantityOnHand += qtyReceived;
// D >>
stockItem.QuantityOnOrder -= qtyReceived;
// Hold created and updated records
ReceiveOrderDetails.Add(receiveOrderDetail);
StockItems.Add(stockItem);
}
}
else // Item not received
{
// Monitor order state
if (qtyOutstanding > 0)
{
isOpen = true;
}
}
// Check if item was returned
if (ood.QtyReturned != null && ood.QtyReturned > 0)
{
// Ensure a reason was entered by the user
if (string.IsNullOrEmpty(ood.ReturnReason))
{
throw new Exception("Returned quantities require a reason entry");
}
else
{
// Pull stock item from database (if it has not yet been retrieved)
if (stockItem == null)
{
int stockItemID = ood.StockItemID;
stockItem = (
from x in context.StockItems
where x.StockItemID == stockItemID
select x)
.FirstOrDefault();
}
// E >>
ReturnedOrderDetail returnedOrderDetail = new ReturnedOrderDetail(); // Note: ReceiveOrderID is an identity created when ReceiveOrder inserted
returnedOrderDetail.PurchaseOrderDetailID = ood.PODetailID; // Nullable
returnedOrderDetail.ItemDescription = stockItem.Description; // Nullable
returnedOrderDetail.Quantity = (int)ood.QtyReturned;
returnedOrderDetail.Reason =
string.IsNullOrEmpty(ood.ReturnReason)
? null
: ood.ReturnReason;
returnedOrderDetail.VendorStockNumber = null; // Nullable
// Hold created record
ReturnedOrderDetails.Add(returnedOrderDetail);
}
}
}
// F >>
if (isOpen == false)
{
// Pull purchase order from database
purchaseOrder = (
from x in context.PurchaseOrders
where x.PurchaseOrderID == _poID
select x)
.FirstOrDefault();
// Close order
purchaseOrder.Closed = true;
}
}
// Process each unordered purchase item cart (Note: This can happen even if there are no order details for the order)
if (_UPICs.Count > 0)
{
foreach (int cart in _UPICs)
{
// Pull upic from database
int cartID = cart;
var upic = (
from x in context.UnorderedPurchaseItemCart
where x.CartID == cartID
select x)
.FirstOrDefault();
// G >>
ReturnedOrderDetail returnedOrderDetail = new ReturnedOrderDetail(); // Note: ReceiveOrderID is an identity created when ReceiveOrder inserted
returnedOrderDetail.PurchaseOrderDetailID = null; // Nullable
returnedOrderDetail.ItemDescription = upic.Description; // Nullable
returnedOrderDetail.Quantity = upic.Quantity;
returnedOrderDetail.Reason = null; // Nullable
returnedOrderDetail.VendorStockNumber =
string.IsNullOrEmpty(upic.VendorStockNumber)
? null
: upic.VendorStockNumber;
// Hold created record
ReturnedOrderDetails.Add(returnedOrderDetail);
}
}
// H >>
context.ReceiveOrders.Add(receiveOrder); // Creates identity ID used by detail records
foreach (ReceiveOrderDetail rod in ReceiveOrderDetails)
{
// Set detail records receive order ID
rod.ReceiveOrderID = receiveOrder.ReceiveOrderID;
// Stage detail record
context.ReceiveOrderDetails.Add(rod);
}
foreach (ReturnedOrderDetail rod in ReturnedOrderDetails)
{
// Set detail record receive order ID
rod.ReceiveOrderID = receiveOrder.ReceiveOrderID;
// Stage detail record
context.ReturnedOrderDetails.Add(rod);
}
foreach (StockItem si in StockItems)
{
context.Entry(si).Property(y => y.QuantityOnHand).IsModified = true;
context.Entry(si).Property(y => y.QuantityOnOrder).IsModified = true;
}
bool closed = false;
if (purchaseOrder != null) // Purchase order can be closed
{
context.Entry(purchaseOrder).Property(y => y.Closed).IsModified = true;
closed = true;
}
// Commit transaction
context.SaveChanges();
// Return order state
return(closed);
}
}
public bool ReceiveOrder(PurchaseOrderProcessed order)
{
using (var context = new eBikesContext())
{
bool fulfilled = false;
// Create and populate Receive Order
var receiveOrder = context.ReceiveOrders.Add(new ReceiveOrder());
receiveOrder.PurchaseOrderID = order.POid;
receiveOrder.ReceiveDate = DateTime.Now;
foreach (var item in order.receivedDetails)
{
fulfilled = true;
// Update Part QOH and QOO
var part = context.Parts.Find(item.PartID);
part.QuantityOnHand += item.QtyReceiving;
part.QuantityOnOrder -= item.QtyReceiving;
context.Entry(part).State = EntityState.Modified; // FLAG for UPDATE
// Create ReceiveOrderDetail and populate
if (item.QtyReceiving > 0)
{
var newReceiveDetail = new ReceiveOrderDetail
{
PurchaseOrderDetailID = item.PODetailID,
QuantityReceived = item.QtyReceiving
};
receiveOrder.ReceiveOrderDetails.Add(newReceiveDetail); // FLAG new ReceiveOrderDetail
}
// Create ReturnOrderDetail and populate
if (item.QtyReturning > 0)
{
var newReturnDetail = new ReturnedOrderDetail
{
PurchaseOrderDetailID = item.PODetailID,
Quantity = item.QtyReturning,
Reason = item.ReturnReason
};
receiveOrder.ReturnedOrderDetails.Add(newReturnDetail); // FLAG new ReturnOrderDetail
}
var pOrderDetail = context.PurchaseOrderDetails.Find(item.PODetailID);
var qtyOutstaning = pOrderDetail.Quantity - (pOrderDetail.ReceiveOrderDetails.FirstOrDefault() == null ? 0 : pOrderDetail.ReceiveOrderDetails.Sum(x => x.QuantityReceived));
if (qtyOutstaning != 0)
{
fulfilled = false;
}
}
// close order if fulfilled comes back true
var pOrder = context.PurchaseOrders.Find(order.POid);
if (fulfilled)
{
pOrder.Closed = fulfilled;
context.Entry(pOrder).State = EntityState.Modified; // FLAG updated PurchaseOrder
}
// Move data from Unordered Cart into returned items
List <UnorderedPart> partList = GetUnorderedPart(pOrder.PurchaseOrderNumber.Value);
foreach (var item in partList)
{
var newReturnDetail = new ReturnedOrderDetail
{
Quantity = item.Quantity,
Reason = "Not Part of Order",
ItemDescription = item.Description,
VendorPartNumber = item.VendorPartNumber
};
receiveOrder.ReturnedOrderDetails.Add(newReturnDetail);
}
// Empty the Unordered Purchase Cart
var unorderedParts = from u in context.UnorderedPurchaseItemCarts
where u.PurchaseOrderNumber == pOrder.PurchaseOrderNumber
select u;
var unorderedPartsList = unorderedParts.ToList();
foreach (var item in unorderedPartsList)
{
context.UnorderedPurchaseItemCarts.Remove(item); // FLAG delete Cart items
}
context.SaveChanges(); // PROCCESS ALL CHANGES
return(fulfilled);
}
}
/// <summary>
/// Adds a new ReceiveOrderDetails
/// </summary>
/// <param name="receivingOrder"></param>
public void ReceiveOrder(int orderId, List <ReceivingItems> receivingOrder)
{
using (var context = new ToolsContext())
{
bool orderCanBeClosed = true;
// Creates a new Receive Order
ReceiveOrder receiveOrder = new ReceiveOrder()
{
PurchaseOrderID = orderId,
ReceiveDate = DateTime.Now
};
context.ReceiveOrders.Add(receiveOrder);
// Loops through each item to add a ReceiveOrderDetails and/or ReturnedOrderDetails
foreach (var item in receivingOrder)
{
// Gets StockItemID and PurchaseOrderDetailID
int stockItemId = item.StockItemID;
int purchaseOrderDetailID = (from purchaseOrderDetail in context.PurchaseOrderDetails
where purchaseOrderDetail.PurchaseOrderID == orderId &&
purchaseOrderDetail.StockItemID == stockItemId
select purchaseOrderDetail.PurchaseOrderDetailID).SingleOrDefault();
if (item.QuantityReceived > 0)
{
// Creates a new ReceiveOrderDetails
ReceiveOrderDetail newReceiveOrderDetails = new ReceiveOrderDetail();
newReceiveOrderDetails.PurchaseOrderDetailID = purchaseOrderDetailID;
newReceiveOrderDetails.QuantityReceived += item.QuantityReceived;
newReceiveOrderDetails.ReceiveOrder = receiveOrder;
context.ReceiveOrderDetails.Add(newReceiveOrderDetails);
// Updates Stock Item information (Quantity on Hand and Quantity on Order)
StockItem stockItem = context.StockItems.Attach(context.StockItems.Find(stockItemId));
stockItem.QuantityOnHand = stockItem.QuantityOnHand + item.QuantityReceived;
stockItem.QuantityOnOrder = stockItem.QuantityOnOrder - item.QuantityReceived;
var dbItem = context.Entry(stockItem);
dbItem.State = EntityState.Modified;
}
if (item.QuantityReturned > 0)
{
// Creates a new ReturnedOrderDetails
ReturnedOrderDetail returnedOrderDetails = new ReturnedOrderDetail();
returnedOrderDetails.PurchaseOrderDetailID = purchaseOrderDetailID;
returnedOrderDetails.ItemDescription = item.StockItemDescription;
returnedOrderDetails.Quantity += item.QuantityReturned;
returnedOrderDetails.Reason = item.ReturnReason;
returnedOrderDetails.ReceiveOrder = receiveOrder;
context.ReturnedOrderDetails.Add(returnedOrderDetails);
}
// Checks if outstanding quantity is zero so the order can be closed
int outstandingQuantity = item.QuantityOutstanding - item.QuantityReceived;
if (outstandingQuantity > 0)
{
orderCanBeClosed = false;
}
}
// Checks if the order can be closed
if (orderCanBeClosed)
{
PurchaseOrder purchaseOrder = context.PurchaseOrders.Attach(context.PurchaseOrders.Find(orderId));
purchaseOrder.Closed = true;
var dbItem = context.Entry(purchaseOrder);
dbItem.State = EntityState.Modified;
}
context.SaveChanges();
}
}
protected void ReceiveButton_Click(object sender, EventArgs e)
{
eToolsReceivingController controller = new eToolsReceivingController();
int PurchaseOrderID;
PurchaseOrderID = Int32.Parse(OutstandingPOGridView.SelectedRow.Cells[1].Text);
//create new ReceiveOrder
ReceiveOrder receipt = new ReceiveOrder();
receipt.PurchaseOrderID = PurchaseOrderID;
receipt.ReceiveDate = DateTime.Now;
//actually add the ReceiveOrder
int ReceiveOrderID = controller.ReceivedOrder_Add(receipt);
//grab the receiveOrder so I can use it to fill the details in
//updating stockItems, inserting ReceiveOrder
bool OrderFullyReceived = true;
foreach (GridViewRow row in PODetailsGrid.Rows)
{
int StockItemID;
int QuantityReceived;
int QuantityReturned;
string Reason;
//manually fill in my variables
StockItemID = Int32.Parse(row.Cells[0].Text);
TextBox Received = (TextBox)row.Cells[3].FindControl("Receive");
QuantityReceived = Int32.Parse(Received.Text);
TextBox Returned = (TextBox)row.Cells[4].FindControl("Return");
QuantityReturned = Int32.Parse(Returned.Text);
TextBox ReasonBox = (TextBox)row.Cells[5].FindControl("Reason");
Reason = ReasonBox.Text;
//grab the stock item and manipulate it's values
StockItem stockItem = controller.StockItemByID(StockItemID);
stockItem.QuantityOnHand = stockItem.QuantityOnHand + QuantityReceived;
stockItem.QuantityOnOrder = stockItem.QuantityOnOrder - QuantityReceived;
//actually update the StockItem
controller.StockItem_Update(stockItem);
//create new ReceiveOrderDetails
ReceiveOrderDetail receiptDetail = new ReceiveOrderDetail();
receiptDetail.ReceiveOrderID = ReceiveOrderID;
//Make PurchOrdDet list with the purchase order ID,
//grab the detail individually bu matching values (new LINQ queryto do this)
int PurchaseOrderDetailID = controller.PurchaseOrderDetail_GetByPoIdStockId(PurchaseOrderID,StockItemID).PurchaseOrderDetailID;//ERROR here
receiptDetail.PurchaseOrderDetailID = PurchaseOrderDetailID;
receiptDetail.QuantityReceived = QuantityReceived;
//actually insert the receipt detail
controller.ReceivedOrderDetail_Add(receiptDetail);
if (QuantityReturned > 0)
{
//create new return order details
ReturnedOrderDetail ReturnDetails = new ReturnedOrderDetail();
ReturnDetails.ReceiveOrderID = ReceiveOrderID;
ReturnDetails.PurchaseOrderDetailID = PurchaseOrderDetailID;
ReturnDetails.ItemDescription = row.Cells[1].Text;
ReturnDetails.Quantity = QuantityReturned;
ReturnDetails.Reason = Reason;
controller.ReturnOrderDetails_Add(ReturnDetails);
OrderFullyReceived = false;
}
}
if (OrderFullyReceived)
{
//update the purchase order as closed
PurchaseOrder updating = controller.PurchaseOrder_GetByID(PurchaseOrderID);
updating.Closed = true;
controller.PurchaseOrder_Update(updating);
}
}
public void Add_ReceivedOrders(List <NewReceiveOrderPOCO> receiveNewOrders)
{
using (var context = new eBikeContext())
{
int id = 0; //this int will hold future PK for update;
ReceiveOrder receivedOrdersData = new ReceiveOrder();
ReceiveOrderDetail receivedOrdersDetailsData = null;
ReturnedOrderDetail returnOrdersDetailsData = null;
receivedOrdersData.PurchaseOrderID = receiveNewOrders[0].PurchaseOrderID;
receivedOrdersData.ReceiveDate = DateTime.Now;
receivedOrdersData = context.ReceiveOrders.Add(receivedOrdersData);
id = receivedOrdersData.ReceiveOrderDetails.Count() + 1;
foreach (NewReceiveOrderPOCO item in receiveNewOrders)
{
if (item.QuantityReceived != 0)
{ //Part table
if (item.QuantityReceived <= item.Outstanding)
{
receivedOrdersDetailsData = new ReceiveOrderDetail();
receivedOrdersDetailsData.PurchaseOrderDetailID = item.PurchaseOrderDetailID;
receivedOrdersDetailsData.ReceiveOrderID = id;
receivedOrdersDetailsData.QuantityReceived = item.QuantityReceived;
receivedOrdersData.ReceiveOrderDetails.Add(receivedOrdersDetailsData);
var checkPartExists = (from p in context.Parts
where p.PartID == item.PartID
select p).SingleOrDefault();
if (checkPartExists != null)
{
if (checkPartExists.QuantityOnOrder >= item.Outstanding)
{
checkPartExists.QuantityOnHand += item.QuantityReceived;
checkPartExists.QuantityOnOrder -= item.QuantityReceived;
}
else
{
throw new Exception("The quantity on order is less than outstanding quantity.");
}
}
else
{
throw new Exception("Sorry there is no such part number in database.");
}
}
else
{
throw new Exception("The received quantity can't be more than outstanding.");
}
}
//ReturnOrderDetails Table
if (!string.IsNullOrEmpty(item.QuantityReturned.ToString()) && !string.IsNullOrEmpty(item.Notes))
{
returnOrdersDetailsData = new ReturnedOrderDetail();
returnOrdersDetailsData.ReceiveOrderID = id;
returnOrdersDetailsData.PurchaseOrderDetailID = item.PurchaseOrderDetailID;
returnOrdersDetailsData.ItemDescription = item.PartDescription;
returnOrdersDetailsData.Quantity = item.QuantityReturned;
returnOrdersDetailsData.Reason = item.Notes;
returnOrdersDetailsData.VendorPartNumber = item.PartID.ToString();
receivedOrdersData.ReturnedOrderDetails.Add(returnOrdersDetailsData);
}
}
int outstanding = receiveNewOrders.Sum(item => item.Outstanding);
int received = receiveNewOrders.Sum(item => item.QuantityReceived);
if ((outstanding - received) == 0)
{
PurchaseOrder poData = context.PurchaseOrders.Find(receiveNewOrders[0].PurchaseOrderID);
if (poData != null)
{
poData.Closed = true;
}
}
context.SaveChanges();
}
}
