public IActionResult CreatePickOrder(PickOrderViewModel model)
{
if (ModelState.IsValid)
{
PickOrder pickOrder = model.CopyTo();
if (pickOrder.Orders.Any())
{
if (pickOrder.Orders.Count >= 4)
{
if (this._pickOrder.CreatePickOrder(pickOrder))
{
TempData["message"] = "Pickorder has been created";
return(RedirectToAction("PickOrders"));
}
else
{
TempData["errormessage"] = "Pickorder cannot be created";
return(View("PickOrder", model));
}
}
else
{
TempData["errormessage"] = "Must be atleast 4 orders within a pickorder";
return(RedirectToAction("PickOrder", model));
}
}
else
{
TempData["errormessage"] = "Pickorder cannot be empty";
return(RedirectToAction("PickOrder", model));
}
}
return(View("PickOrder", model));
}
public PickOrder CopyTo()
{
List <Order> orders = new List <Order>();
if (this.Orders != null)
{
orders.AddRange(this.Orders);
}
if (this.SelectedOrders != null)
{
orders.AddRange(SelectedOrders);
}
PickOrder pickOrder = new PickOrder()
{
Id = this.Id,
Orders = orders,
Lenght = orders.Sum(o => o.Length),
Width = orders.Sum(o => o.Width),
Height = orders.Sum(o => o.Height),
Weight = orders.Sum(o => o.Weight),
};
return(pickOrder);
}
public IActionResult UpdatePickOrder(PickOrderViewModel model)
{
//TODO can not really remove only add new orders....
if (ModelState.IsValid)
{
PickOrder pickOrder = model.CopyTo();
if (pickOrder.Orders.Count >= 4)
{
if (this._pickOrder.UpdatePickOrder(pickOrder))
{
try
{
TempData["message"] = "PickOrder has been succesfully updated.";
return(RedirectToAction("PickOrders"));
}
catch (Exception e)
{
TempData["message"] = e.Message;
return(RedirectToAction("PickOrders"));
}
}
else
{
TempData["errormessage"] = "PickOrder cannot be updated.";
return(RedirectToAction("PickOrders"));
}
}
else
{
TempData["errormessage"] = "Must be atleast 4 orders within a pickorder";
return(View("PickOrder", model));
}
}
return(View("PickOrder", model));
}
public IEnumerable <PickOrder> All()
{
//TODO finish this function
this._query = "SELECT PickOrder.Id, PickOrder.Length, PickOrder.Width, PickOrder.Height, OCount = (SELECT COUNT(*) FROM [Order] WHERE PickOrder.Id = [Order].PickOrderId) FROM PickOrder;";
List <PickOrder> pickOrders = new List <PickOrder>();
using (SqlConnection conn = new SqlConnection(this._connectionstring))
{
using (SqlCommand cmd = new SqlCommand(this._query, conn))
{
conn.Open();
foreach (DbDataRecord record in cmd.ExecuteReader())
{
PickOrder pickOrder = new PickOrder()
{
Id = record.GetInt32(record.GetOrdinal("Id")),
Lenght = record.GetDouble(record.GetOrdinal("Length")),
Width = record.GetDouble(record.GetOrdinal("Width")),
Height = record.GetDouble(record.GetOrdinal("Height")),
AmountOfOrders = record.GetInt32(record.GetOrdinal("OCount")),
};
pickOrders.Add(pickOrder);
}
return(pickOrders);
}
}
}
private static PickOrder CopyOrder(PickOrder order)
{
PickOrder _newOrder = new PickOrder()
{
EmployeeID = order.EmployeeID,
DeptID = order.DeptID,
DeptDescription = order.DeptDescription,
DeliveryDate = order.DeliveryDate,
DeliveryDateView = order.DeliveryDateView,
InternalOrderID = order.InternalOrderID,
ItemDescription = order.ItemDescription,
ItemID = order.ItemID,
ItemOrderID = order.ItemOrderID,
OrderDateView = order.OrderDateView,
OrderDate = order.OrderDate,
Orderer = order.Orderer,
OrderQty = order.OrderQty,
OrderReceivedDate = order.OrderReceivedDate,
OrderReceivedDateView = order.OrderReceivedDateView,
OrderStatus = order.OrderStatus,
OrderStatusView = order.OrderStatusView,
PickCompleteDateView = order.PickCompleteDateView,
PickCompleteDate = order.PickCompleteDate,
PickSheetID = order.PickSheetID,
PickSheetIDView = order.PickSheetIDView,
QtyReceived = order.QtyReceived,
UnitPrice = order.UnitPrice,
OutOfStock = order.OutOfStock
};
return(_newOrder);
}
private void ChkPPDetailMarkOutOfStock_Unchecked(object sender, RoutedEventArgs e)
{
PickOrder _selectedOrder = (PickOrder)dgProcessPickDetail.SelectedItem;
try
{
var x = _selectedOrder.OutOfStock;
}
catch
{
return;
}
//already done do nothing
if (!_selectedOrder.OutOfStock)
{
return;
}
var _newOrder = new PickOrder();
//_newOrder = _selectedOrder;
_newOrder = CopyOrder(_selectedOrder);
//Mark the order out of stock
_newOrder.OutOfStock = false;
try
{
int orderComplete = _pickManager.Update_PickOrder(_newOrder, _selectedOrder);
// MessageBox.Show("Order Updated " + orderComplete);
LoadPickSheetDetailGrid(_newOrder.PickSheetID);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <IActionResult> PutPickOrder(Guid id, PickOrder pickOrder)
{
if (id != pickOrder.PickOrderId)
{
return(BadRequest());
}
_context.Entry(pickOrder).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PickOrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void BtnPPDetailMarkQtyFilled_Click(object sender, RoutedEventArgs e)
{
var _selectedOrder = (PickOrder)dgProcessPickDetail.SelectedItem;
if (_selectedOrder.OrderQty == _selectedOrder.QtyReceived)
{
//already done do nothing
return;
}
var _newOrder = new PickOrder();
//_newOrder = _selectedOrder;
_newOrder = CopyOrder(_selectedOrder);
//Make the fill qty the same as the order qty
_newOrder.QtyReceived = _selectedOrder.OrderQty;
_newOrder.PickCompleteDate = new DateTime(1001, 1, 1);
try
{
int orderComplete = _pickManager.Update_PickOrder(_newOrder, _selectedOrder);
// MessageBox.Show("Order Updated " + orderComplete);
LoadPickSheetDetailGrid(_newOrder.PickSheetID);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public bool CreatePickOrder(PickOrder pickOrder)
{
this._query = "INSERT INTO PickOrder (Length, Width, Height, Weight) VALUES (@Length, @Width, @Height, @Weight); SELECT SCOPE_IDENTITY()";
using (SqlConnection conn = new SqlConnection(this._connectionstring))
{
using (SqlCommand cmd = new SqlCommand(this._query, conn))
{
conn.Open();
cmd.Parameters.AddWithValue("@Length", pickOrder.Lenght);
cmd.Parameters.AddWithValue("@Width", pickOrder.Width);
cmd.Parameters.AddWithValue("@Height", pickOrder.Height);
cmd.Parameters.AddWithValue("@Weight", pickOrder.Weight);
int Id = Convert.ToInt32(cmd.ExecuteScalar());
if (Id > 0)
{
return(InsertIntoOrder(pickOrder, Id));
}
else
{
return(false);
}
}
}
}
public bool Update(PickOrder entity)
{
this._query = "UPDATE PickOrder SET Length = @Length, Width = @Width, Height = @Height, Weight = @Weight WHERE PickOrder.Id = @Id";
using (SqlConnection conn = new SqlConnection(this._connectionstring))
{
using (SqlCommand cmd = new SqlCommand(this._query, conn))
{
conn.Open();
cmd.Parameters.AddWithValue("@Id", entity.Id);
cmd.Parameters.AddWithValue("@Length", entity.Lenght);
cmd.Parameters.AddWithValue("@Width", entity.Width);
cmd.Parameters.AddWithValue("@Height", entity.Height);
cmd.Parameters.AddWithValue("@Weight", entity.Weight);
int count = cmd.ExecuteNonQuery();
if (count > 0)
{
return(InsertIntoOrder(entity, entity.Id));
}
else
{
return(false);
}
}
}
}
public async Task CreatePickOrder(PickOrder pickOrder)
{
if (ModelState.IsValid)
{
db.PickOrders.Add(pickOrder);
await db.SaveChangesAsync();
}
}
public bool UpdatePickOrder(PickOrder pickOrder)
{
if (pickOrder == null)
{
throw new ArgumentNullException("PickOrder cannot be null");
}
return(this._repository.Update(pickOrder));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
PickOrder pickOrder = await db.PickOrders.FindAsync(id);
db.PickOrders.Remove(pickOrder);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,OrderId,PartId,Location,Destination,Start,Confirmed,IsConfirmed,UserId,PartQuantity")] PickOrder pickOrder)
{
if (ModelState.IsValid)
{
db.Entry(pickOrder).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(pickOrder));
}
public async Task <ActionResult <PickOrder> > PostPickOrder(PickOrder pickOrder)
{
_context.PickOrders.Add(pickOrder);
_context.Barcodes.Where(o => pickOrder.PickOrderSubs.Select(p => p.BarcodeId).Contains(o.BarcodeId)).ToList().ForEach(o => o.Picked = true);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPickOrder", new { id = pickOrder.PickOrderId }, pickOrder));
}
public int Delete_TmpPickSheet_Item(PickOrder pickOrder)
{
int result = 0;
int count = _tmpPickOrders.Count;
_tmpPickOrders.Remove(pickOrder);
if (_tmpPickOrders.Count == count - 1)
{
result = 1;
}
return(result);
}
public int Insert_Record_To_TmpPicksheet(PickOrder pickOrder)
{
int result = 0;
int count = _tmpPickOrders.Count;
_tmpPickOrders.Add(pickOrder);
if (_tmpPickOrders.Count == count + 1)
{
result = 1;
}
return(result);
}
// GET: PickOrders/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PickOrder pickOrder = await db.PickOrders.FindAsync(id);
if (pickOrder == null)
{
return(HttpNotFound());
}
return(View(pickOrder));
}
public int Update_PickOrder(PickOrder pickOrder, PickOrder oldPickOrder)
{
var index = _pickOrders.FindIndex(x => x.PickSheetID == pickOrder.PickSheetID);
_pickOrders[index] = pickOrder;
if (index > 0)
{
return(1);
}
else
{
return(0);
}
}
public async Task <PickOrder> AssignPickOrder(Job job, string partId, int partQuantity)
{
PickOrder pickOrder = new PickOrder
{
OrderId = job.OrderID,
PartId = partId,
IsConfirmed = false,
Location = await db.Inventory.Where(i => i.PartID == partId && i.Location != job.Workstation).Select(p => p.Location).FirstAsync(),
Destination = job.Workstation,
PartQuantity = partQuantity,
JobId = job.ID
};
return(pickOrder);
}
public int Delete_TmpPickSheet_Item(PickOrder pickOrder)
{
int result;
try
{
result = _pickAccessor.Delete_TmpPickSheet_Item(pickOrder);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
return(result);
}
private int InsertRecordToTempPickTable(PickOrder pickOrder)
{
int result = 0;
//Insert to tmpPickTable
try
{
result = _pickManager.Insert_Record_To_TmpPicksheet(pickOrder);
//increment the number of picked items
_numPickedItems += 1;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(result);
}
/// Eric Bostwick
/// 4/10/2019
public void UpdatePickOrder()
{
PickOrder pickOrder;
pickOrder = _pickOrders.Find(o => (o.PickSheetID == "1000011111") && (o.ItemOrderID == 100000) & (o.ItemID == 100000));
PickOrder newPickOrder = new PickOrder();
newPickOrder = CopyOrder(pickOrder);
newPickOrder.EmployeeID = 999999;
int result;
//Act
result = _pickManager.Update_PickOrder(newPickOrder, pickOrder);
//Assert
Assert.AreNotEqual(pickOrder, newPickOrder);
}
/// Eric Bostwick
/// 4/10/2019
public void UpdateQtyReceivedLessThanZero()
{
PickOrder pickOrder;
pickOrder = _pickOrders.Find(o => (o.PickSheetID == "1000011111") && (o.ItemOrderID == 100000) & (o.ItemID == 100000));
PickOrder newPickOrder = new PickOrder();
newPickOrder = CopyOrder(pickOrder);
newPickOrder.QtyReceived = -1;
int result;
//Act
result = _pickManager.Update_PickOrder(newPickOrder, pickOrder);
//Assert
//Assert.AreNotEqual(pickOrder, newPickOrder);
}
/// Eric Bostwick
/// 4/10/2019
public void TestInsertRecordToTempPickSheet()
{
//arrange
PickOrder tmpPickOrder = new PickOrder()
{
PickSheetID = "10000012345",
ItemID = 100000,
InternalOrderID = 100000,
OrderReceivedDate = DateTime.Now
};
//act
_pickManager.Insert_Record_To_TmpPicksheet(tmpPickOrder);
_tmpPickOrders = _pickManager.Select_All_Tmp_PickOrders();
//assert
Assert.IsNotNull(_tmpPickOrders.Find(x => x.PickSheetID == "10000012345"));
}
public IActionResult EditPickOrder(int id)
{
try
{
IEnumerable <Order> orders = this._order.GetAllOrders();
PickOrder pickOrder = this._pickOrder.GetPickOrderById(id);
PickOrderViewModel model = new PickOrderViewModel(orders, pickOrder);
return(View("PickOrder", model));
}
catch (Exception e)
{
TempData["errormessage"] = e.Message;
IEnumerable <Order> orders = null;
PickOrder pickOrder = this._pickOrder.GetPickOrderById(id);
PickOrderViewModel model = new PickOrderViewModel(orders, pickOrder);
return(View("PickOrder", model));
}
}
public int Update_PickOrder(PickOrder pickOrder, PickOrder oldPickOrder)
{
int result;
try
{
if (!pickOrder.IsValid())
{
throw new ArgumentException("Data for this order record is invalid");
}
result = _pickAccessor.Update_PickOrder(pickOrder, oldPickOrder);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
return(result);
}
public void TestSetup()
{
_pickAccessorMock = new PickAccessorMock();
_pickManager = new PickManager(_pickAccessorMock);
_pickOrders = new List <PickOrder>();
_pickSheets = new List <PickSheet>();
_tmpPickOrders = new List <PickOrder>();
_tmpPickSheet = new PickSheet();
_tmpPickOrder = new PickOrder();
_dt = new DateTime();
_dt = DateTime.Now.AddDays(-60);
//there two items that will be returned here for later testing
_pickSheets = _pickAccessorMock.Select_All_PickSheets();
_pickOrders = _pickAccessorMock.Select_Orders_For_Acknowledgement(_dt, false);
_tmpPickOrders = _pickAccessorMock.Select_All_Temp_PickOrders();
//_pickOrders = _pickAccessorMock.
}
public int Insert_Record_To_TmpPicksheet(PickOrder pickOrder)
{
int result;
try
{
if (!pickOrder.IsValid())
{
throw new ArgumentException("Data for this order record is invalid");
}
result = _pickAccessor.Insert_Record_To_TmpPicksheet(pickOrder);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
return(result);
}
public int Insert_Record_To_TmpPicksheet(PickOrder pickOrder)
{
int result;
string cmdtext;
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_insert_tmp_picksheet";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmdtext = cmd.CommandText;
cmd.Parameters.Add("@PickSheetID", SqlDbType.NVarChar, 25);
cmd.Parameters["@PickSheetID"].Value = pickOrder.PickSheetID;
cmd.Parameters.Add("@InternalOrderID", SqlDbType.Int);
cmd.Parameters["@InternalOrderID"].Value = pickOrder.InternalOrderID;
cmd.Parameters.Add("@ItemID", SqlDbType.Int);
cmd.Parameters["@ItemID"].Value = pickOrder.ItemID;
cmd.Parameters.Add("@PickedBy", SqlDbType.Int);
cmd.Parameters["@PickedBy"].Value = pickOrder.EmployeeID;
try
{
conn.Open();
result = cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(result);
}
