public ActionResult Create([Bind(Include = "id,itemid,quantity,price")] SalesLineItem salesLineItem, string shellsOrder)
{
if (ModelState.IsValid)
{
salesLineItem.orderid = Convert.ToInt32(Session["orderid"]);
db.salesLineItem.Add(salesLineItem);
db.SaveChanges();
salesLineItem.price = salesLineItem.quantity * (from d in db.salesLineItem where d.id == salesLineItem.id select d.item.product.price).FirstOrDefault();
db.Entry(salesLineItem).State = EntityState.Modified;
db.SaveChanges();
if (shellsOrder != null)
{
Session["shellsOrder"] = shellsOrder;
Switch.idsToSwitch.Add(salesLineItem.itemid);
}
var sli2 = (List <int>)(Session["ListShellsItem"]);
return(RedirectToAction("Index", "SalesLineItems"));
}
ViewBag.itemid = new SelectList(db.item, "id", "name", salesLineItem.itemid);
ViewBag.orderid = new SelectList(db.order, "id", "id", salesLineItem.orderid);
return(View(salesLineItem));
}
public void SetDiscountStringWithInvalidDiscountStringShouldThrowException()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 10);
Assert.Throws <FormatException>(() => lineItem.SetDiscount("$x"),
"Attempting to set a invalid discount should result in an exception.");
}
public bool DeleteInvoiceLineItem(SalesInvoice salesInvoice, SalesLineItem item)
{
_unitOfWork.SalesInvoiceRepository.Edit(salesInvoice);
AddLineItemStock(item, salesInvoice.BranchId);
_unitOfWork.Save();
return(true);
}
public void SetDiscountStringWithNegativeMoneyDiscountShouldThrowException()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 10);
Assert.Throws <ArgumentOutOfRangeException>(() => lineItem.SetDiscount("$-5.00"),
"Attempting to set a negative discount should result in an exception.");
}
public List <SalesLineItem> GetSalesLineItemsFromOrderID(int id)
{
List <SalesLineItem> list = new List <SalesLineItem>();
ProductController prodController = new ProductController();
using (SqlConnection con = new SqlConnection(_connectionString)) {
con.Open();
using (SqlCommand cmd = con.CreateCommand()) {
cmd.CommandText = "SELECT * FROM SalesLineItem WHERE orderID = @ID";
cmd.Parameters.AddWithValue("ID", id);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
SalesLineItem sli = new SalesLineItem()
{
amount = reader.GetInt32(reader.GetOrdinal("amount")),
Price = reader.GetDecimal(reader.GetOrdinal("price")),
Order = GetOrder(id),
Product = prodController.GetProduct(reader.GetInt32(reader.GetOrdinal("productID"))),
ProductVersion = new ProductVersion()
{
ColorCode = reader.GetString(reader.GetOrdinal("colorCode")),
SizeCode = reader.GetString(reader.GetOrdinal("sizeCode")),
}
};
list.Add(sli);
}
}
}
return(list);
}
public async Task <IActionResult> Create([Bind("Id,SalesDate,CustomerId")] Sales sales, string[] selectedProducts, string[] productQuantities)
{
if (selectedProducts != null)
{
sales.LineItems = new List <SalesLineItem>();
var selectedProductsHS = new List <string>(selectedProducts);
var productQuantitiesHS = new List <string>(productQuantities);
foreach (var product in selectedProductsHS)
{
int lineItemIndex = selectedProductsHS.FindIndex(p => p == product);
int quantity = int.Parse(productQuantitiesHS.ElementAt(lineItemIndex));
var lineItemToAdd = new SalesLineItem {
SalesId = sales.Id, ProductId = int.Parse(product), Quantity = quantity
};
sales.LineItems.Add(lineItemToAdd);
}
}
if (ModelState.IsValid)
{
_context.Add(sales);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
PopulateCustomersDropDownList(sales.CustomerId);
PopulateProductsData(sales);
return(View(sales));
}
public void SetDiscountStringAppliesPercentageDiscountOnLineItemWithSingleQuantity()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 1);
lineItem.SetDiscount("33%");
Assert.That(lineItem.GetDiscount(), Is.EqualTo(0.33m));
}
public void SetDiscountDiscountAppliesAbsoluteDiscountOnLineItemWithSingleQuantity()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 1);
lineItem.SetDiscount(new Discount(DiscountType.Absolute, 0.5m));
Assert.That(lineItem.GetDiscount(), Is.EqualTo(0.5m));
}
void SubtractLineItemStock(SalesLineItem item, int branchId)
{
var stock = _unitOfWork.StockRepository.FindBy(x => x.BranchId == branchId &&
x.ProductcId == item.ProductId).SingleOrDefault();
stock.Quantity = stock.Quantity - item.Quantity;
_unitOfWork.StockRepository.Edit(stock);
}
public void SetDiscountDiscountAppliesPercentageDiscountOnLineItemWithMultipleQuantity()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 10);
lineItem.SetDiscount(new Discount(DiscountType.Percentage, 50));
Assert.That(lineItem.GetDiscount(), Is.EqualTo(5.00m));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
SalesLineItem salesLineItem = await db.SalesOrderItems.FindAsync(id);
db.SalesOrderItems.Remove(salesLineItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
SalesLineItem salesLineItem = db.salesLineItem.Find(id);
db.salesLineItem.Remove(salesLineItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void SetDiscountStringAppliesAbsoluteDiscountOnLineItemWithMultipleQuantity()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 10);
lineItem.SetDiscount("$5.00");
Assert.That(lineItem.GetDiscount(), Is.EqualTo(5.00m));
}
public void AddQuantityNegativeValueShouldDecrement()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 1);
lineItem.AddQuantity(-1);
Assert.That(lineItem.Quantity, Is.EqualTo(0));
}
/// <summary>
/// Mutates the sale with 'Buy N Get One' type discounts and gets the total.
/// </summary>
/// <param name="sale"></param>
/// <returns></returns>
public decimal GetTotal(Sale sale)
{
var discountedLineItems = new List <SalesLineItem>();
var originalLineItems = new List <SalesLineItem>();
foreach (var lineItem in sale.LineItems)
{
// Apply discounts directly to line item, if any.
foreach (
var discount in
_discounts
.Where(d => d.IsValid() && d.DiscountAppliedOnNextProduct)
.Where(d => d.ProductId == lineItem.ProductId && lineItem.Quantity > d.ThresholdQuantity)
.OrderByDescending(d => d.ThresholdQuantity))
{
// There may be eligible discount(s) to apply to current line item based on quantity.
// Apply the discounts with the largest quantities first as they generally have the better discounts.
while (lineItem.Quantity > discount.ThresholdQuantity)
{
// Create a separate line item that receives the discount.
var discountedLineItem =
new SalesLineItem(new Product(lineItem.ProductId, lineItem.ProductPrice), 1);
discountedLineItem.SetDiscount(discount.Discount);
// Save to temporary list.
discountedLineItems.Add(discountedLineItem);
// Decrement original line item quantity by the threshold quantity plus the promotional item.
lineItem.AddQuantity(-1 * (discount.ThresholdQuantity + 1));
// Create a new line item with the original threshold quantity to a temporary list.
// Do not want to count these quantities again.
var originalLineItem = new SalesLineItem(new Product(lineItem.ProductId, lineItem.ProductPrice),
discount.ThresholdQuantity);
originalLineItems.Add(originalLineItem);
// TODO: Add a limit, i.e. only get the discount a certain number of times.
}
}
}
sale.RemoveZeroQuantityLineItems();
foreach (var item in originalLineItems)
{
sale.MakeLineItem(new Product(item.ProductId, item.ProductPrice), item.Quantity);
}
foreach (var item in discountedLineItems)
{
sale.AddLineItem(item); // Add these directly to the sale.
}
var total = sale.LineItems.Sum(i => i.GetSubtotal());
return(total);
}
public void SetDiscountStringWithNullOrEmptyDiscountStringShouldThrowException()
{
var lineItem = new SalesLineItem(new Product("A", price: 1.0m), quantity: 10);
Assert.Throws <ArgumentNullException>(() => lineItem.SetDiscount(""),
"Attempting to set a empty discount should result in an exception.");
Assert.Throws <ArgumentNullException>(() => lineItem.SetDiscount(null),
"Attempting to set a null discount should result in an exception.");
}
public LineItemStatus GetStatusAfterUnship(SalesLineItem lineItem, int qty)
{
if (lineItem.Quantity > (lineItem.ProcessedQty - qty))
{
return(LineItemStatus.Open);
}
return(lineItem.Status);
}
public ActionResult Index(CompanyProduct product, FormCollection form)
{
if (Session["ShoppingCart"] == null)
{
ShoppingCart = new List <SalesLineItem>();
Session["ShoppingCart"] = ShoppingCart;
}
// add productversions to product
ServiceProduct service = new ServiceProduct();
product = service.GetProductById(product.StyleNumber);
var selectedColor = form.Get("colors");
var selectedSize = form.Get("sizes");
int selectedAmount = Int32.Parse(form.Get("amount"));
CompanyProductVersion prodVer = product.GetProductVersion(selectedSize, selectedColor);
ConvertDataModel converter = new ConvertDataModel();
if (prodVer != null)
{
SalesLineItem lineitem = new SalesLineItem()
{
amount = selectedAmount,
Product = converter.ConvertFromCompanyProduct(product),
ProductVersion = converter.ConvertFromCompanyProductVersion(prodVer),
Price = (selectedAmount * product.Price)
};
ShoppingCart = (List <SalesLineItem>)Session["ShoppingCart"];
// check if item is already in cart
if (ItemAlreadyExists(lineitem))
{
foreach (var item in ShoppingCart)
{
if (item.Product.StyleNumber == lineitem.Product.StyleNumber && item.ProductVersion.SizeCode.Equals(lineitem.ProductVersion.SizeCode) && item.ProductVersion.ColorCode.Equals(lineitem.ProductVersion.ColorCode))
{
item.amount += lineitem.amount;
}
}
}
else
{
ShoppingCart.Add(lineitem);
}
}
else
{
return(RedirectToAction("NotInStock", "Product", new { id = product.StyleNumber }));
}
Session["ShoppingCart"] = ShoppingCart;
return(RedirectToAction("index", "Cart"));
}
public ActionResult Edit([Bind(Include = "Id,ItemName,Price,Qty,OrderId,CompanyId")] SalesLineItem salesLineItem)
{
if (ModelState.IsValid)
{
db.Entry(salesLineItem).State = EntityState.Modified;
db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(salesLineItem));
}
public ActionResult Edit([Bind(Include = "id,orderid,itemid,quantity,price")] SalesLineItem salesLineItem)
{
if (ModelState.IsValid)
{
db.Entry(salesLineItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.itemid = new SelectList(db.item, "id", "name", salesLineItem.itemid);
ViewBag.orderid = new SelectList(db.order, "id", "id", salesLineItem.orderid);
return(View(salesLineItem));
}
public async Task <ActionResult> Create([Bind(Include = "Id,ItemName,Price,Qty,OrderId,CompanyId")] SalesLineItem salesLineItem)
{
if (ModelState.IsValid)
{
db.SalesOrderItems.Add(salesLineItem);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(salesLineItem));
}
// GET: SalesLineItems/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SalesLineItem salesLineItem = db.salesLineItem.Find(id);
if (salesLineItem == null)
{
return(HttpNotFound());
}
return(View(salesLineItem));
}
public LineItemStatus GetStatusAfterShipment(SalesLineItem lineItem, int qty)
{
if (lineItem.Quantity == (lineItem.ProcessedQty + qty))
{
return(LineItemStatus.Closed);
}
if (lineItem.OpenQty == 0)
{
return(LineItemStatus.Scheduled);
}
return(lineItem.Status);
}
/// <summary>
/// Mutates the sale with quantity type discounts and gets the total.
/// </summary>
/// <param name="sale"></param>
/// <returns></returns>
public decimal GetTotal(Sale sale)
{
var discountedLineItems = new List <SalesLineItem>();
foreach (var lineItem in sale.LineItems)
{
// Apply discounts directly to line item, if any.
foreach (
var discount in
_discounts
.Where(d => d.IsValid() && !d.DiscountAppliedOnNextProduct)
.Where(d => d.ProductId == lineItem.ProductId && lineItem.Quantity >= d.ThresholdQuantity)
.OrderByDescending(d => d.ThresholdQuantity))
{
// There may be eligible discount(s) to apply to current line item based on quantity.
// Apply the discounts with the largest quantities first as they generally have the better discounts.
while (lineItem.Quantity >= discount.ThresholdQuantity)
{
// Create new line item with the quantity that gets the discount.
var discountedLineItem =
new SalesLineItem(new Product(lineItem.ProductId, lineItem.ProductPrice), discount.ThresholdQuantity);
discountedLineItem.SetDiscount(discount.Discount);
// Store in temporary list.
discountedLineItems.Add(discountedLineItem);
// Decrement the threshold quantity from the original line item.
lineItem.AddQuantity(-1 * discount.ThresholdQuantity);
// TODO: Add a limit, i.e. only get the discount a certain number of times.
}
}
}
sale.RemoveZeroQuantityLineItems();
// Add newly created line items that have the discount directly to the sale.
foreach (var item in discountedLineItems)
{
sale.AddLineItem(item);
}
var total = sale.LineItems.Sum(i => i.GetSubtotal());
return(total);
}
private bool ItemAlreadyExists(SalesLineItem lineItem)
{
bool result = false;
ShoppingCart = (List <SalesLineItem>)Session["ShoppingCart"];
foreach (var item in ShoppingCart)
{
if (item.Product.StyleNumber == lineItem.Product.StyleNumber && item.ProductVersion.SizeCode.Equals(lineItem.ProductVersion.SizeCode) && item.ProductVersion.ColorCode.Equals(lineItem.ProductVersion.ColorCode))
{
result = true;
}
}
return(result);
}
// GET: SalesLineItems/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SalesLineItem salesLineItem = db.salesLineItem.Find(id);
if (salesLineItem == null)
{
return(HttpNotFound());
}
ViewBag.itemid = new SelectList(db.item, "id", "name", salesLineItem.itemid);
ViewBag.orderid = new SelectList(db.order, "id", "id", salesLineItem.orderid);
return(View(salesLineItem));
}
public static int GetShipQtyForLine(SalesLineItem lineItem)
{
ShippingLineSummary partSummary;
try
{
partSummary =
OrderRepository.GetShippingSummaryForLine(lineItem);
}
catch (Exception)
{
return(0);
}
if (partSummary == null)
{
return(0);
}
return(partSummary.Qty);
}
public ActionResult AddLineItem([Bind(Include = "SalesInvoiceId,Quantity,ProductId")] SalesInvoiceLineItemViewModel salesInvoiceLineItemViewModel)
{
var salesInvoice = _salesInvoiceService.Get(t => t.SalesInvoiceId == salesInvoiceLineItemViewModel.SalesInvoiceId, null, "SalesLineItems").FirstOrDefault();
int exists = salesInvoice.SalesLineItems.Where(t => t.ProductId == salesInvoiceLineItemViewModel.ProductId).ToList().Count;
if (exists > 0)
{
return(RedirectToAction("Create", "SalesInvoices", new { id = salesInvoice.SalesInvoiceId }));
}
var salesInvoiceLineItem = new SalesLineItem()
{
ProductId = salesInvoiceLineItemViewModel.ProductId,
Quantity = salesInvoiceLineItemViewModel.Quantity,
SalesInvoiceId = salesInvoiceLineItemViewModel.SalesInvoiceId,
UnitPrice = _productService.FindById(salesInvoiceLineItemViewModel.ProductId).UnitPrice
};
salesInvoice.SalesLineItems.Add(salesInvoiceLineItem);
_salesInvoiceService.EditSalesInvoice(salesInvoice);
return(RedirectToAction("Create", "SalesInvoices", new { id = salesInvoice.SalesInvoiceId }));
}
private Sales Map(SalesCommand command)
{
var sales = new Sales
{
Id = command.SalesId,
SalesDate = command.SalesDate
};
foreach (SalesProduct product in command.SalesProducts)
{
var salesLineItem = new SalesLineItem
{
ProductId = product.ProductId,
ProductName = product.ProductName,
SalesQuantity = product.SalesQuantity,
UnitName = product.UnitName,
UnitSalePrice = product.SalesUnitPrice
};
sales.SalesLineItems.Add(salesLineItem);
}
return(sales);
}
private bool AdexLineItemIsReceivable()
{
return(true);
if (m_lineItem.PurchaseOrder.Order.OrderType == OrderType.ADEX)
{
SalesOrder so =
m_lineItem.PurchaseOrder.Order.GetContract <SalesOrder>() as SalesOrder;
if (so != null)
{
SalesLineItem sli = so.GetLineByPart(m_lineItem.Part);
if (sli.ProcessedQty <= m_lineItem.ProcessedQty)
{
m_error = "This line cannot be received against until more units are shipped for this part.";
return(false);
}
}
}
return(true);
}
