/// <summary author="Eric Bostwick" created="2019/02/27">
/// Inserts a Supplier Order
/// using a SupplierOrder Object and a list of SupplierOrderLines
/// </summary>
/// <returns>
/// List of ItemSupplers
/// </returns>
public int CreateSupplierOrder(SupplierOrder supplierOrder, List <SupplierOrderLine> supplierOrderLines)
{
int result;
try
{
if (!supplierOrder.IsValid())
{
throw new ArgumentException("Data for this supplier order record is invalid");
}
//check each of the supplier order lines for valid inputs
foreach (var line in supplierOrderLines)
{
if (!line.IsValid())
{
throw new ArgumentException("Data for this supplier line item record is invalid");
}
}
result = _supplierOrderAccessor.InsertSupplierOrder(supplierOrder, supplierOrderLines);
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public ActionResult MakeSupplierOrder(int?id)
{
db.Configuration.ProxyCreationEnabled = false;
ViewBag.products = db.Products.ToList();
SupplierOrder so = db.SupplierOrders.Where(order => order.SupplierID == id)
.Where(order => order.SupplierStatusID == 1)
.Include(order => order.SupplierOrderLines)
.Include(order => order.Supplier)
.FirstOrDefault();
if (so == null)
{
so = new SupplierOrder();
so.SupplierID = Convert.ToInt32(id);
so.SupplierStatusID = 1;
db.SupplierOrders.Add(so);
so.Supplier = db.Suppliers.Where(sup => sup.SupplierID == so.SupplierID).FirstOrDefault();
so.SupplierID = so.Supplier.SupplierID;
db.SaveChanges();
}
TempData["SuppOrdID"] = so.SupplierOrderID;
return(View(so));
}
public async Task <IActionResult> PostSupplierOrder([FromBody] SupplierOrder supplierOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.SupplierOrder.Add(supplierOrder);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SupplierOrderExists(supplierOrder.SupplierId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetSupplierOrder", new { id = supplierOrder.SupplierId }, supplierOrder));
}
public async Task <IActionResult> Edit(int id, [Bind("SupplierId,OrderingMethod,OrderingEmail,PriceFound,DiscountOw,DiscountOr,DiscountNotes,Terms,LeadTime,SalesReq,Books,PaymentMethod,PaymentNotes")] SupplierOrder supplierOrder)
{
if (id != supplierOrder.SupplierId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(supplierOrder);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SupplierOrderExists(supplierOrder.SupplierId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SupplierId"] = new SelectList(_context.Supplier, "SupplierId", "Company", supplierOrder.SupplierId);
return(View(supplierOrder));
}
public ActionResult AddToList(int Product, int Quantity)
{
db.Configuration.ProxyCreationEnabled = false;
bool inList = false;
int SuppOrdID = Convert.ToInt32(TempData["SuppOrdID"]);
SupplierOrder so = db.SupplierOrders.Include(sos => sos.Supplier)
.Include(sos => sos.SupplierOrderLines)
.Where(sos => sos.SupplierOrderID == SuppOrdID)
.FirstOrDefault();
foreach (SupplierOrderLine sol in so.SupplierOrderLines)
{
if (sol.ProductID == Product)
{
inList = true;
sol.QuantityOrdered += Quantity;
db.SaveChanges();
break;
}
}
if (!inList)
{
SupplierOrderLine newLine = new SupplierOrderLine();
newLine.ProductID = Product;
newLine.QuantityOrdered = Quantity;
newLine.QuantityReceived = 0;
newLine.SupplierOrderID = Convert.ToInt32(TempData["SuppOrdID"]);
so.SupplierOrderLines.Add(newLine);
db.SaveChanges();
}
return(RedirectToAction("MakeSupplierOrder", new { id = so.SupplierID }));
}
/// <summary>
/// Kevin Broskow
/// Created 4/2/209
/// Gets a specific supplierOrder by id
/// </summary>
/// <returns>
/// SupplierOrder object
/// </returns>
public SupplierOrder RetrieveSupplierOrderByID(int supplierOrderID)
{
SupplierOrder order = null;
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_select_supplier_order_by_id";
SqlCommand cmd = new SqlCommand(cmdText, conn);
cmd.Parameters.AddWithValue("@SupplierOrderID", supplierOrderID);
try
{
conn.Open();
var reader = cmd.ExecuteReader();
while (reader.Read())
{
order.EmployeeID = reader.GetInt32(0);
order.Description = reader.GetString(1);
order.OrderComplete = reader.GetBoolean(2);
order.DateOrdered = reader.GetDateTime(3);
order.SupplierID = reader.GetInt32(4);
}
}
catch (Exception ex)
{
throw ex;
}
return(order);
}
public ActionResult FinalizeOrder(string options)
{
db.Configuration.ProxyCreationEnabled = false;
int SuppOrdID = Convert.ToInt32(TempData["SuppOrdID"]);
SupplierOrder so = db.SupplierOrders
.Where(sl => sl.SupplierOrderID == SuppOrdID)
.Include(sl => sl.Supplier)
.Include(sl => sl.SupplierOrderLines.Select(l => l.Product))
.FirstOrDefault();
so.SupplierStatusID = 6;
so.OrderDate = DateTime.Today;
db.SaveChanges();
if (options == "yes")
{
try
{
SendEmailController sendemail = new SendEmailController();
sendemail.NewSupplierOrderEmail(so);
TempData["SuccessMessage"] = "Order request made - Email Sent";
return(RedirectToAction("Index"));
}
catch (Exception)
{
TempData["ErrorMessage"] = "Email error - Email not sent";
return(RedirectToAction("Index"));
}
}
TempData["SuccessMessage"] = "Order request made";
return(RedirectToAction("Index"));
}
public async Task Add(string referenceCode, ServiceTypes serviceType, MoneyAmount convertedSupplierPrice, MoneyAmount originalSupplierPrice,
Deadline deadline, int supplier, SupplierPaymentType paymentType, DateTime paymentDate)
{
var now = _dateTimeProvider.UtcNow();
var supplierOrder = new SupplierOrder
{
Created = now,
Modified = now,
ConvertedPrice = convertedSupplierPrice.Amount,
ConvertedCurrency = convertedSupplierPrice.Currency,
Price = originalSupplierPrice.Amount,
Currency = originalSupplierPrice.Currency,
RefundableAmount = 0,
State = SupplierOrderState.Created,
Supplier = supplier,
Type = serviceType,
ReferenceCode = referenceCode,
Deadline = deadline,
PaymentDate = paymentDate,
PaymentType = paymentType
};
_context.SupplierOrders.Add(supplierOrder);
await _context.SaveChangesAsync();
_context.Detach(supplierOrder);
}
public async Task <IActionResult> PutSupplierOrder([FromRoute] int id, [FromBody] SupplierOrder supplierOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != supplierOrder.SupplierId)
{
return(BadRequest());
}
_context.Entry(supplierOrder).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SupplierOrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void LoadNewOrderControls()
{
_supplierOrder = new SupplierOrder();
_supplierOrder.DateOrdered = DateTime.Now.Date;
_supplierOrder.EmployeeID = _loggedInEmployeeID;
_supplierOrder.SupplierID = _supplier.SupplierID;
_supplierOrder.OrderComplete = false;
_supplierOrderLine = new SupplierOrderLine();
this.txtItemDescription.Text = _itemSupplier.Name;
this.txtUnitPrice.Text = _itemSupplier.UnitPrice.ToString("c");
_supplierOrderLine.ItemID = _itemSupplier.ItemID;
_supplierOrderLine.SupplierItemID = _itemSupplier.SupplierItemID;
_supplierOrderLine.UnitPrice = _itemSupplier.UnitPrice;
_supplierOrderLine.Description = _itemSupplier.Description;
this.lblItemDescription.Visibility = Visibility.Visible;
this.txtItemDescription.Visibility = Visibility.Visible;
this.lblOrderQty.Visibility = Visibility.Visible;
this.txtOrderQuantity.Visibility = Visibility.Visible;
this.lblUnitPrice.Visibility = Visibility.Visible;
this.txtUnitPrice.Visibility = Visibility.Visible;
this.txtUnitPrice.IsReadOnly = true;
this.txtExtendedPrice.Visibility = Visibility.Visible;
this.lblExtendedPrice.Visibility = Visibility.Visible;
this.dgOrderLines.Visibility = Visibility.Visible;
btnAddOrder.Content = "Submit Order";
}
public int UpdateSupplierOrder(SupplierOrder supplierOrder, List <SupplierOrderLine> supplierOrderLines)
{
int rowsAffected = 0;
var cmdText1 = "sp_delete_supplier_order_lines";
var cmdText2 = "sp_update_supplier_order";
var cmdText3 = "sp_insert_supplier_order_line";
var cmdText4 = "sp_update_supplier_order_line";
try
{
using (TransactionScope scope = new TransactionScope())
{
using (var conn = DBConnection.GetDbConnection())
{
conn.Open();
var cmd1 = new SqlCommand(cmdText1, conn);
cmd1.CommandType = CommandType.StoredProcedure;
cmd1.Parameters.AddWithValue("@SupplierOrderID", supplierOrder.SupplierOrderID);
cmd1.ExecuteNonQuery();
var cmd2 = new SqlCommand(cmdText2, conn);
cmd2.CommandType = CommandType.StoredProcedure;
cmd2.Parameters.AddWithValue("@SupplierOrderID", supplierOrder.SupplierOrderID);
cmd2.Parameters.AddWithValue("@Description", supplierOrder.Description);
cmd2.ExecuteNonQuery();
foreach (var line in supplierOrderLines)
{
var cmd3 = new SqlCommand(cmdText3, conn);
cmd3.CommandType = CommandType.StoredProcedure;
var cmd4 = new SqlCommand(cmdText4, conn);
cmd4.CommandType = CommandType.StoredProcedure;
line.SupplierOrderID = supplierOrder.SupplierOrderID;
cmd3.Parameters.AddWithValue("@SupplierOrderID", line.SupplierOrderID);
cmd3.Parameters.AddWithValue("@ItemID", line.ItemID);
cmd3.Parameters.AddWithValue("@Description", line.Description);
cmd3.Parameters.AddWithValue("@OrderQty", line.OrderQty);
cmd3.Parameters.AddWithValue("@UnitPrice", line.UnitPrice);
rowsAffected += cmd3.ExecuteNonQuery();
cmd4.Parameters.AddWithValue("@SupplierOrderID", line.SupplierOrderID);
cmd4.Parameters.AddWithValue("@ItemID", line.ItemID);
cmd4.Parameters.AddWithValue("@QtyReceived", line.QtyReceived);
cmd4.ExecuteNonQuery();
}
}
scope.Complete();
}
}
catch (Exception)
{
throw;
}
return(rowsAffected);
}
public void TestUpdateSupplierOrder()
{
SupplierOrder newSupplierOrder = new SupplierOrder()
{
SupplierID = 100005,
SupplierOrderID = 100010,
DateOrdered = DateTime.Today,
Description = "test order",
EmployeeID = 100000,
OrderComplete = false
};
SupplierOrderLine supplierOrderLine1 = new SupplierOrderLine()
{
SupplierOrderID = 100010,
Description = "test item 1",
ItemID = 100015,
OrderQty = 100,
QtyReceived = 0,
UnitPrice = 1.00M
};
SupplierOrderLine supplierOrderLine2 = new SupplierOrderLine()
{
SupplierOrderID = 100010,
Description = "testString",
ItemID = 100015,
OrderQty = 500,
QtyReceived = 0,
UnitPrice = 1.00M
};
List <SupplierOrder> supplierOrders;
List <SupplierOrderLine> lines;
SupplierOrder supplierOrder;
_supplierOrderLines.Add(supplierOrderLine1);
_supplierOrderLines.Add(supplierOrderLine2);
//Act
_supplierOrderManager.CreateSupplierOrder(newSupplierOrder, _supplierOrderLines);
newSupplierOrder.Description = "updated description";
_supplierOrderLines[0].OrderQty = 10000;
_supplierOrderLines[1].OrderQty = 10001;
_supplierOrderManager.UpdateSupplierOrder(newSupplierOrder, _supplierOrderLines);
supplierOrders = _supplierOrderManager.RetrieveAllSupplierOrders();
supplierOrder = supplierOrders.Find(s => s.SupplierOrderID == 100010);
lines = _supplierOrderManager.RetrieveAllSupplierOrderLinesBySupplierOrderID(100010);
Assert.AreEqual(supplierOrder.Description, "updated description");
Assert.AreEqual(lines[0].OrderQty, 10000);
Assert.AreEqual(lines[1].OrderQty, 10001);
}
private bool SettleUpOrder(SupplierOrder supplierOrder, decimal settleUpAmount, HyperStoreServiceContext db)
{
supplierOrder.SettledPayedAmount += settleUpAmount;
db.Entry(supplierOrder).State = EntityState.Modified;
if (supplierOrder.SettledPayedAmount == supplierOrder.BillAmount)
{
return(true);
}
return(false);
}
public List <SupplierOrder> SelectAllSupplierOrders()
{
/// <summary>
/// Eric Bostwick
/// Created 3/7/2019
/// Gets list of All SupplierOrders from SupplierOrder table
/// </summary>
/// <returns>
/// List of SupplierOrder Objects
/// </returns>
List <SupplierOrder> supplierOrders = new List <SupplierOrder>();
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_select_all_supplier_orders"; //sp_retrieve_itemsuppliers_by_itemid
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
SupplierOrder supplierOrder = new SupplierOrder();
supplierOrder.SupplierOrderID = reader.GetInt32(reader.GetOrdinal("SupplierOrderID"));
supplierOrder.DateOrdered = reader.GetDateTime(reader.GetOrdinal("DateOrdered"));
supplierOrder.Description = reader["Description"].ToString();
supplierOrder.EmployeeID = reader.GetInt32(reader.GetOrdinal("EmployeeID"));
supplierOrder.FirstName = reader["FirstName"].ToString();
supplierOrder.LastName = reader["LastName"].ToString();
supplierOrder.OrderComplete = reader.GetBoolean(reader.GetOrdinal("OrderComplete"));
supplierOrder.SupplierID = reader.GetInt32(reader.GetOrdinal("SupplierID"));
supplierOrder.SupplierName = reader["SupplierName"].ToString();
supplierOrders.Add(supplierOrder);
}
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(supplierOrders);
}
public async Task <IActionResult> Create([Bind("SupplierId,OrderingMethod,OrderingEmail,PriceFound,DiscountOw,DiscountOr,DiscountNotes,Terms,LeadTime,SalesReq,Books,PaymentMethod,PaymentNotes")] SupplierOrder supplierOrder)
{
if (ModelState.IsValid)
{
_context.Add(supplierOrder);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["SupplierId"] = new SelectList(_context.Supplier, "SupplierId", "Company", supplierOrder.SupplierId);
return(View(supplierOrder));
}
public int InsertSupplierOrder(SupplierOrder supplierOrder, List <SupplierOrderLine> supplierOrderLines)
{
int rowsAffected = 0;
var cmdText1 = "sp_insert_supplier_order";
var cmdText2 = "sp_insert_supplier_order_line";
try
{
using (TransactionScope scope = new TransactionScope())
{
using (var conn = DBConnection.GetDbConnection())
{
conn.Open();
var cmd1 = new SqlCommand(cmdText1, conn);
cmd1.CommandType = CommandType.StoredProcedure;
cmd1.Parameters.Add("@SupplierOrderID", SqlDbType.Int);
cmd1.Parameters["@SupplierOrderID"].Direction = ParameterDirection.Output;
cmd1.Parameters.AddWithValue("@SupplierID", supplierOrder.SupplierID);
cmd1.Parameters.AddWithValue("@EmployeeID", supplierOrder.EmployeeID);
cmd1.Parameters.AddWithValue("@Description", supplierOrder.Description);
cmd1.ExecuteNonQuery();
int supplierOrderID = (int)cmd1.Parameters["@SupplierOrderID"].Value;
foreach (var line in supplierOrderLines)
{
var cmd2 = new SqlCommand(cmdText2, conn);
cmd2.CommandType = CommandType.StoredProcedure;
line.SupplierOrderID = supplierOrderID;
cmd2.Parameters.AddWithValue("@SupplierOrderID", line.SupplierOrderID);
cmd2.Parameters.AddWithValue("@ItemID", line.ItemID);
cmd2.Parameters.AddWithValue("@Description", line.Description);
cmd2.Parameters.AddWithValue("@OrderQty", line.OrderQty);
//cmd2.Parameters.Add("@UnitPrice", SqlDbType.Decimal);
//cmd2.Parameters["@UnitPrice"].Value = line.UnitPrice;
//line.UnitPrice = decimal.Round(line.UnitPrice,2);
cmd2.Parameters.AddWithValue("@UnitPrice", line.UnitPrice);
rowsAffected += cmd2.ExecuteNonQuery();
}
}
scope.Complete();
}
}
catch (Exception)
{
throw;
}
return(rowsAffected);
}
public frmAddEditSupplierOrder(SupplierOrder supplierOrder, EditMode editMode)
{
InitializeComponent();
_editMode = EditMode.Edit;
_supplierOrder = supplierOrder;
LoadSupplierCombo();
_supplier = _suppliers.Find(s => s.SupplierID == supplierOrder.SupplierID);
txtDescription.Text = _supplierOrder.Description;
LoadControls();
}
/// <summary>
/// Kevin Broskow
/// 3/29/2019
/// Added functionality to recieve external orders
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnReceived_Click(object sender, RoutedEventArgs e)
{
if ((SupplierOrder)dgSupplierOrders.SelectedItem != null)
{
_supplierOrder = (SupplierOrder)dgSupplierOrders.SelectedItem;
var orderReceived = new OrderRecieving(_supplierOrder);
var result = orderReceived.ShowDialog();
}
else
{
MessageBox.Show("You must select an order");
}
}
private void ExecuteSupplierOrderAction(int colorId, int sizeId, int quantity, Supplier selectedSupplier, Clothes selectedClothes, Rate rate)
{
int supplierId = selectedSupplier.Id;
int clothesId = selectedClothes.Id;
string clothesName = selectedClothes.Name;
Console.WriteLine("# Create supplier order: ");
var newOrder = new SupplierOrder
{
ClothesId = clothesId,
SupplierId = supplierId,
Status = OrderStatus.New,
OrderDate = DateTime.Now
};
Console.WriteLine($"+ New supplier order - Id: {newOrder.Id}, Order date: {newOrder.OrderDate}, Supplier Id: {supplierId}, Supplier Name: {selectedSupplier.Name}");
var tempSupplierOrders = _dataProvider.supplierOrders.GetAll();
var tempSupplierOrderDetail = _dataProvider.supplierOrderDetails.GetAll();
Console.WriteLine("+ Save temp order");
TransactionProvider.ExecuteOperationInTransaction(() =>
{
Console.WriteLine("# Create supplier order detail");
var buyingRateByClothes = _dataProvider.clothesRates.GetBy(x => x.ClothesId == selectedClothes.Id && x.RateId == rate.Id).FirstOrDefault();
if (buyingRateByClothes == null)
{
throw new Exception("Buying rate does not exist for clothes");
}
int newOrderId = tempSupplierOrders.Add <SupplierOrder>(newOrder);
var newOrderDetail = new SupplierOrderDetail
{
OrderId = newOrderId,
ClothesId = clothesId,
ColorId = colorId,
SizeId = sizeId,
Quantity = quantity,
TotalPrice = quantity * buyingRateByClothes.Price
};
tempSupplierOrderDetail.Add(newOrderDetail);
Console.WriteLine($"+ New supplier order detail - OrderId: {newOrderDetail.OrderId}, Clothes Id: {clothesId}, Clothes Name: {clothesName}, Quantity: {newOrderDetail.Quantity}, TotalPrice: {newOrderDetail.TotalPrice}");
});
Console.WriteLine("+ Save actual order");
_dataProvider.supplierOrders = tempSupplierOrders;
_dataProvider.supplierOrderDetails = tempSupplierOrderDetail;
}
public SupplierOrder RetrieveSupplierOrderByID(int supplierOrderID)
{
SupplierOrder order = new SupplierOrder();
try
{
order = _supplierOrderAccessor.RetrieveSupplierOrderByID(supplierOrderID);
}
catch (Exception ex)
{
throw ex;
}
return(order);
}
public void TestDeleteSupplierOrder()
{
//Arrange This is a known item supplier
int supplierOrderID = 100000;
SupplierOrder supplierOrder = new SupplierOrder();
List <SupplierOrder> supplierOrders;
//Act
_supplierOrderManager.DeleteSupplierOrder(supplierOrderID);
supplierOrders = _supplierOrderManager.RetrieveAllSupplierOrders();
supplierOrder = supplierOrders.Find(s => s.SupplierOrderID == supplierOrderID);
//Assert
Assert.AreEqual(supplierOrder.SupplierOrderID, null);
}
public void TestCreateSupplierOrderValidInput()
{
//arrange
SupplierOrder newSupplierOrder = new SupplierOrder()
{
SupplierID = 100005,
SupplierOrderID = 100010,
DateOrdered = DateTime.Today,
Description = "test order",
EmployeeID = 100000,
OrderComplete = false
};
SupplierOrderLine supplierOrderLine1 = new SupplierOrderLine()
{
SupplierOrderID = 100010,
Description = "test item 1",
ItemID = 100015,
OrderQty = 100,
QtyReceived = 0,
UnitPrice = 1.00M
};
SupplierOrderLine supplierOrderLine2 = new SupplierOrderLine()
{
SupplierOrderID = 100010,
Description = "test item 1",
ItemID = 100015,
OrderQty = 100,
QtyReceived = 0,
UnitPrice = 1.00M
};
List <SupplierOrderLine> supplierOrderLines = new List <SupplierOrderLine>();
supplierOrderLines.Add(supplierOrderLine1);
supplierOrderLines.Add(supplierOrderLine2);
//Act
_supplierOrderManager.CreateSupplierOrder(newSupplierOrder, supplierOrderLines);
//Assert
_supplierOrders = _supplierOrderManager.RetrieveAllSupplierOrders();
Assert.IsNotNull(_supplierOrders.Find(x => x.SupplierOrderID == newSupplierOrder.SupplierOrderID && x.DateOrdered == newSupplierOrder.DateOrdered &&
x.Description == newSupplierOrder.Description && x.EmployeeID == newSupplierOrder.EmployeeID && x.OrderComplete == newSupplierOrder.OrderComplete)
);
}
/// <summary>
/// Author: Kevin Broskow
/// Created : 3/25/2019
/// Real constructor for the window being opened for a supplier order being received
///
/// </summary>
public OrderRecieving(SupplierOrder supplierOrder)
{
order = supplierOrder;
try
{
supplierOrderLine = _supplierManager.RetrieveAllSupplierOrderLinesBySupplierOrderID(supplierOrder.SupplierOrderID);
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
}
InitializeComponent();
this.lblRecieving.Content += supplierOrder.SupplierOrderID.ToString();
this.btnSubmit.Content = "Submit";
dgOrderRecieving.ItemsSource = supplierOrderLine;
}
public Task Add(string referenceCode, ServiceTypes serviceType, decimal supplierPrice)
{
var now = _dateTimeProvider.UtcNow();
var supplierOrder = new SupplierOrder
{
Created = now,
Modified = now,
Price = supplierPrice,
State = SupplierOrderState.Created,
Supplier = Suppliers.Netstorming,
Type = serviceType,
ReferenceCode = referenceCode
};
_context.SupplierOrders.Add(supplierOrder);
return(_context.SaveChangesAsync());
}
public ActionResult RemoveAll()
{
db.Configuration.ProxyCreationEnabled = false;
int SuppOrdID = Convert.ToInt32(TempData["SuppOrdID"]);
SupplierOrder so = db.SupplierOrders
.Include(sl => sl.SupplierOrderLines)
.Where(sl => sl.SupplierOrderID == SuppOrdID)
.FirstOrDefault();
List <SupplierOrderLine> soll = so.SupplierOrderLines.ToList();
foreach (SupplierOrderLine sol in soll)
{
so.SupplierOrderLines.Remove(sol);
}
db.SaveChanges();
return(RedirectToAction("MakeSupplierOrder", new { id = so.SupplierID }));
}
private void DgSupplierOrders_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
_supplierOrder = (SupplierOrder)dgSupplierOrders.SelectedItem;
var supplierOrderManager = new frmAddEditSupplierOrder(_supplierOrder, EditMode.Edit);
var result = supplierOrderManager.ShowDialog();
if (result == true)
{
LoadSupplierCombo();
LoadSupplierOrderGrid();
}
else
{
return;
}
}
public dynamic AddSupplierOrder([FromBody] SupplierOrder Items)
{
//{
// var admin = db.Users.Where(zz => zz.SessionID == sess).ToList();
// if (admin == null)
// {
// dynamic toReturn = new ExpandoObject();
// toReturn.Error = "Session is no longer available";
// return toReturn;
// }
SupplierOrder newObject = new SupplierOrder();
newObject.OrderID = Items.OrderID;
newObject.SupplierID = Items.SupplierID;
newObject.Description = Items.Description;
decimal total = 0;
foreach (StockItemLine details in Items.StockItemLines)
{
decimal findPrice = db.StockItems.Where(zz => zz.ItemID == details.ItemID).Select(zz => zz.Price).FirstOrDefault();;
total += (decimal)(details.Quantity * findPrice);
}
newObject.Price = total;
newObject.Date = DateTime.Now;
db.SupplierOrders.Add(newObject);
db.SaveChanges();
db.Entry(newObject).GetDatabaseValues();
int OrderID = newObject.OrderID;
List <StockItemLine> lineList = new List <StockItemLine>();
foreach (StockItemLine details in Items.StockItemLines)
{
StockItemLine addItems = new StockItemLine();
addItems.ItemID = details.ItemID;
addItems.Quantity = details.Quantity;
addItems.OrderID = OrderID;
lineList.Add(addItems);
}
db.StockItemLines.AddRange(lineList);
db.SaveChanges();
return("success");
}
public static List <SupplierOrder> ParseApplicants(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
return(null);
}
var word = new WordService(fileName, false);
if (word == null)
{
return(null);
}
List <SupplierOrder> supplierOrders = new List <SupplierOrder>();
try {
int rowQuantity = word.GetTableRowsCount(1);
SupplierOrder applicant = new SupplierOrder();
for (var rowCount = 2; rowCount <= rowQuantity + 1; rowCount++)
{
var supplierName = word.GetCell(1, rowCount, 2);
applicant.Name = supplierName != null ? supplierName : "";
var brokerName = word.GetCell(1, rowCount, 3);
applicant.BrokerName = brokerName != null ? brokerName : "";
supplierOrders.Add(applicant);
}
} catch {
return(null);
} finally {
if (word.IsOpenDocument())
{
word.CloseDocument();
}
if (word.IsOpenWord())
{
word.CloseWord(false);
}
}
return(supplierOrders);
}
/// <summary>
/// Author: Kevin Broskow
/// Created : 3/25/2019
/// Real constructor for the window being opened
///
/// </summary>
public OrderRecieving(ReceivingTicket ticket)
{
originalTicket = ticket;
try
{
supplierOrderLine = _supplierManager.RetrieveAllSupplierOrderLinesBySupplierOrderID(ticket.SupplierOrderID);
order = _supplierManager.RetrieveSupplierOrderByID(ticket.SupplierOrderID);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
InitializeComponent();
this.lblRecieving.Content += ticket.SupplierOrderID.ToString();
this.btnSubmit.Content = "Save";
dgOrderRecieving.ItemsSource = supplierOrderLine;
}
public int UpdateSupplierOrder(SupplierOrder supplierOrder, List <SupplierOrderLine> supplierOrderLines)
{
int result = 0;
SupplierOrder _oldOrder;
_oldOrder = _orders.Find(s => s.SupplierOrderID == supplierOrder.SupplierOrderID);
foreach (var order in _orders)
{
if (supplierOrder.SupplierOrderID == _oldOrder.SupplierOrderID)
{
_oldOrder.Description = supplierOrder.Description;
result = 1;
}
}
return(result);
}
