public async Task <IActionResult> Edit(Guid id, [Bind("ID,SalesOrderID,ProductID,Description,Qty")] SalesOrderLine salesOrderLine)
{
if (id != salesOrderLine.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderLineExists(salesOrderLine.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProductID"] = new SelectList(_context.Product, "ID", "Name", salesOrderLine.ProductID);
ViewData["SalesOrderID"] = new SelectList(_context.SalesOrder, "ID", "Name", salesOrderLine.SalesOrderID);
return(View(salesOrderLine));
}
public async Task <IActionResult> PostSalesOrderLine([FromBody] SalesOrderLine salesOrderLine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
SalesOrder salesOrder = await _context.SalesOrder.Where(x => x.salesOrderId.Equals(salesOrderLine.salesOrderId)).FirstOrDefaultAsync();
if (salesOrder.salesOrderStatus == SalesOrderStatus.Completed)
{
return(Json(new { success = false, message = "Error. Can not edit [Completed] order" }));
}
salesOrderLine.totalAmount = (decimal)salesOrderLine.qty * salesOrderLine.price;
if (salesOrderLine.salesOrderLineId == string.Empty)
{
salesOrderLine.salesOrderLineId = Guid.NewGuid().ToString();
_context.SalesOrderLine.Add(salesOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Add new data success." }));
}
else
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Edit data success." }));
}
}
public void Create_ZeroQuantity_ThrowSalesOrderDomainException(
string productNumber,
string productName,
decimal unitPrice,
decimal unitPriceDiscount,
SpecialOfferProduct specialOfferProduct
)
{
//Arrange
//Act
Action act = () => {
var salesOrderLine = new SalesOrderLine(
productNumber,
productName,
unitPrice,
unitPriceDiscount,
specialOfferProduct,
0
);
};
//Assert
act.Should().Throw <SalesDomainException>();
}
public void Returns_15_PriceBasedPriceRates()
{
Setup();
//Price based rate returns 15.00m , Weight based rate returns 10.00m , API returns 0.00m
var ExpectedValue = 15.00m;
var orderline = new SalesOrderLine();
orderline.Price = 300.00m;
orderline.Quantity = 2;
orderline.Product = new Product();
orderline.Product.ID = 11;
orderline.Product.Name = "Genuine Side Mirrors Honda";
orderline.Product.Type = ProductType.Physical;
orderline.Product.Weight = 2.5m;
//First Product added
order.Lines.Add(orderline);
orderline = new SalesOrderLine();
orderline.Price = 410.00m;
orderline.Quantity = 1;
orderline.Product = new Product();
orderline.Product.ID = 12;
orderline.Product.Name = "Side Mirror Installation";
orderline.Product.Type = ProductType.Service;
//orderline.Product.Weight = 5.5m;
//Second Product added
order.Lines.Add(orderline);
ShippingCalculator shippingCalculator = new ShippingCalculator();
var price = shippingCalculator.Calculate(order);
Assert.AreEqual(ExpectedValue, price);
}
public void ReturnsEqualPriceRates()
{
Setup();
//Price based rate returns 10.00m and Weight based rate returns 10.00m
var ExpectedValue = 10.00m;
var orderline = new SalesOrderLine();
orderline.Price = 240.00m;
orderline.Quantity = 1;
orderline.Product = new Product();
orderline.Product.ID = 1;
orderline.Product.Name = "GPS Navigation System";
orderline.Product.Type = ProductType.Physical;
orderline.Product.Weight = 4.30m;
//First Product added
order.Lines.Add(orderline);
orderline = new SalesOrderLine();
orderline.Price = 120.00m;
orderline.Quantity = 1;
orderline.Product = new Product();
orderline.Product.ID = 2;
orderline.Product.Name = "Nav Installation";
orderline.Product.Type = ProductType.Service;
orderline.Product.Weight = 0.00m;
//Second Product added
order.Lines.Add(orderline);
ShippingCalculator shippingCalculator = new ShippingCalculator();
var price = shippingCalculator.Calculate(order);
Assert.AreEqual(ExpectedValue, price);
}
public async Task <IActionResult> PutSalesOrderLine(int id, SalesOrderLine salesOrderLine)
{
if (id != salesOrderLine.SalesOrderLineId)
{
return(BadRequest());
}
_context.Entry(salesOrderLine).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderLineExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(string id, [Bind("SalesOrderLineId,Discount,DiscountAmount,Price,TotalBeforeDiscount,ProductId,ProductVAT,ProductVATAmount,Qty,SalesOrderId,SpecialTaxAmount,SpecialTaxDiscount,TotalAmount,UnitCost,createdAt,TotalAfterDiscount,TotalSpecialTaxAmount,TotalWithSpecialTax,IsGift")] SalesOrderLine salesOrderLine)
{
if (id != salesOrderLine.SalesOrderLineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderLineExists(salesOrderLine.SalesOrderLineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["productId"] = new SelectList(_context.Product, "productId", "productCode", salesOrderLine.ProductId);
ViewData["salesOrderId"] = new SelectList(_context.SalesOrder, "salesOrderId", "salesOrderNumber", salesOrderLine.SalesOrderId);
return(View(salesOrderLine));
}
public void Returns_20_WeightBasedPriceRates()
{
Setup();
//Weight based rate returns 20.00m while Price based returns 0.00m. API returns null
var ExpectedValue = 20.00m;
var orderline = new SalesOrderLine();
orderline.Price = 2.00m;
orderline.Quantity = 12;
orderline.Product = new Product();
orderline.Product.ID = 4;
orderline.Product.Name = "Charging Cable";
orderline.Product.Type = ProductType.Physical;
orderline.Product.Weight = 0.50m;
//First Product added
order.Lines.Add(orderline);
orderline = new SalesOrderLine();
orderline.Price = 15.00m;
orderline.Quantity = 2;
orderline.Product = new Product();
orderline.Product.ID = 6;
orderline.Product.Name = "Charging Socket Replacement Part";
orderline.Product.Type = ProductType.Physical;
orderline.Product.Weight = 24.50m;
//Second Product added
order.Lines.Add(orderline);
ShippingCalculator shippingCalculator = new ShippingCalculator();
var price = shippingCalculator.Calculate(order);
Assert.AreEqual(ExpectedValue, price);
}
static void Main(string[] args)
{
EnetHelper enetService;
string baseAddress = System.Configuration.ConfigurationManager.AppSettings["wcfBaseAddress"].ToString();
string sysOperator = System.Configuration.ConfigurationManager.AppSettings["sysproOperator"].ToString();
string operatorPwd = System.Configuration.ConfigurationManager.AppSettings["sysproOperatorPwd"].ToString();
string company = System.Configuration.ConfigurationManager.AppSettings["sysproCompany"].ToString();
string companyPwd = System.Configuration.ConfigurationManager.AppSettings["sysproCompanyPwd"].ToString();
enetService = new EnetHelper(baseAddress, sysOperator, operatorPwd, company, companyPwd);
enetService.GetCustomerPrice("0000001", "ABC", 212);
SalesOrderModel salesOrder = new SalesOrderModel();
List <SalesOrderLine> salesOrderLines = new List <SalesOrderLine>();
salesOrder.Customer = "0000001";
salesOrder.CustomerPoNumber = "Test14";
SalesOrderLine line1 = new SalesOrderLine();
line1.StockCode = "A100";
line1.OrderQty = 323;
line1.CustomerPoLine = 1;
salesOrderLines.Add(line1);
salesOrder.lines = salesOrderLines;
enetService.CreateSalesOrder(salesOrder);
}
public async Task <IActionResult> Edit(int id, [Bind("SalesOrderLineId,Product,Qty,Price,SalesOrderHeaderId")] SalesOrderLine salesOrderLine)
{
if (id != salesOrderLine.SalesOrderLineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderLineExists(salesOrderLine.SalesOrderLineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SalesOrderHeaderId"] = new SelectList(_context.SalesOrderHeader, "SalesOrderHeaderId", "SalesOrderHeaderId", salesOrderLine.SalesOrderHeaderId);
return(View(salesOrderLine));
}
public async Task <DialogTurnResult> AnotherProductOrNotStepAsync(WaterfallStepContext stepContext,
CancellationToken cancellationToken)
{
var state = await Accessors.CustomerDataState.GetAsync(stepContext.Context,
cancellationToken : cancellationToken);
var salesOrderLine = new SalesOrderLine
{
Item = state.TempItem,
Quantity = state.TempQuantity,
UnitPrice = state.TempItem.UnitPrice
};
if (state.TempSalesOrderLines != null)
{
state.TempSalesOrderLines.Add(salesOrderLine);
}
else
{
state.TempSalesOrderLines = new List <SalesOrderLine> {
salesOrderLine
};
}
await Accessors.CustomerDataState.SetAsync(stepContext.Context, state, cancellationToken);
return(await stepContext.PromptAsync(AnotherProductPrompt, new PromptOptions
{
Prompt = await Chatter.GetActivityAsync(stepContext.Context, StaticTexts.AnotherProductText),
RetryPrompt = await Chatter.GetActivityAsync(stepContext.Context, StaticTexts.AnotherProductText)
}, cancellationToken));
}
public async Task <IActionResult> Create([Bind("SalesOrderLineId,Discount,DiscountAmount,Price,TotalBeforeDiscount,ProductId,ProductVAT,ProductVATAmount,Qty,SalesOrderId,SpecialTaxAmount,SpecialTaxDiscount,TotalAmount,UnitCost,createdAt,TotalAfterDiscount,TotalSpecialTaxAmount,TotalWithSpecialTax,IsGift")] SalesOrderLine salesOrderLine)
{
if (ModelState.IsValid)
{
_context.Add(salesOrderLine);
await _context.SaveChangesAsync();
var so = await _context.SalesOrder.Include(x => x.salesOrderLine).SingleOrDefaultAsync(m => m.salesOrderId == salesOrderLine.SalesOrderId);
so.totalOrderAmount = so.salesOrderLine.Sum(x => x.TotalAmount);
so.totalDiscountAmount = so.salesOrderLine.Sum(x => x.DiscountAmount);
so.TotalProductVAT = so.salesOrderLine.Sum(x => x.ProductVATAmount);
so.TotalWithSpecialTax = so.salesOrderLine.Sum(x => x.TotalWithSpecialTax);
so.TotalBeforeDiscount = so.salesOrderLine.Sum(x => x.TotalBeforeDiscount);
_context.Update(so);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["productId"] = new SelectList(_context.Product, "productId", "productCode", salesOrderLine.ProductId);
ViewData["salesOrderId"] = new SelectList(_context.SalesOrder, "salesOrderId", "salesOrderNumber", salesOrderLine.SalesOrderId);
return(View(salesOrderLine));
}
public async Task <IActionResult> Edit(string id, [Bind("salesOrderLineId,salesOrderId,productId,qty,price,discountAmount,totalAmount,createdAt")] SalesOrderLine salesOrderLine)
{
if (id != salesOrderLine.salesOrderLineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesOrderLineExists(salesOrderLine.salesOrderLineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["productId"] = new SelectList(_context.Product, "productId", "productCode", salesOrderLine.productId);
ViewData["salesOrderId"] = new SelectList(_context.SalesOrder, "salesOrderId", "salesOrderNumber", salesOrderLine.salesOrderId);
return(View(salesOrderLine));
}
public async Task <IActionResult> PostSalesOrderLine([FromBody] SalesOrderLine salesOrderLine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
SalesOrder salesOrder = await _context.SalesOrder.Where(x => x.salesOrderId.Equals(salesOrderLine.SalesOrderId)).FirstOrDefaultAsync();
Customer customer = await _context.Customer.Where(c => c.customerId.Equals(salesOrder.customerId)).FirstOrDefaultAsync();
Product product = await _context.Product.Where(p => p.productId.Equals(salesOrderLine.ProductId)).FirstOrDefaultAsync();
if (salesOrder.salesOrderStatus == SalesOrderStatus.Completed)
{
return(Json(new { success = false, message = "Σφάλμα. Δεν μπορεί να γίνει Επεξεργασία Παραγγελίας που είναι [Ολοκληρωμένη]." }));
}
if (string.IsNullOrEmpty(salesOrderLine.SalesOrderLineId))
{
salesOrderLine.SalesOrderLineId = Guid.NewGuid().ToString();
_context.SalesOrderLine.Add(salesOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Η Προσθήκη στοιχείου Παραγγελίας, έγινε με επιτυχία." }));
}
else
{
_context.Update(salesOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Η Επεξεργασία στοιχείου Παραγγελίας, έγινε με επιτυχία." }));
}
}
public async Task <ActionResult <SalesOrderLine> > PostSalesOrderLine(SalesOrderLine salesOrderLine)
{
_context.SalesOrderLines.Add(salesOrderLine);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSalesOrderLine", new { id = salesOrderLine.SalesOrderLineId }, salesOrderLine));
}
public void AddOrderLineWithDiscount_OrderLineWithProductFound_UpdatedOrderLine(
SalesOrder salesOrder,
SalesOrderLine salesOrderLine,
SpecialOfferProduct specialOfferProduct
)
{
//Arrange
salesOrder.AddOrderLine(
salesOrderLine.ProductNumber,
salesOrderLine.ProductName,
salesOrderLine.UnitPriceDiscount,
0,
specialOfferProduct
);
var orderLines = salesOrder.OrderLines.ToList();
var existingOrderLine = orderLines[0];
var originalQuantity = existingOrderLine.UnitPriceDiscount;
//Act
salesOrder.AddOrderLine(
existingOrderLine.ProductNumber,
existingOrderLine.ProductName,
existingOrderLine.UnitPrice,
existingOrderLine.UnitPriceDiscount + 1,
specialOfferProduct
);
//Assert
orderLines.Count.Should().Be(1);
orderLines[0].UnitPriceDiscount.Should().Be((short)(originalQuantity + 1));
}
public async Task <IActionResult> AddEditLine(Guid?ID, SalesOrderLine salesOrderLine)
{
try
{
if (ModelState.IsValid)
{
bool isNew = ID.Equals(Guid.Empty);
if (isNew)
{
salesOrderLine.ID = Guid.NewGuid();
_context.Add(salesOrderLine);
}
else
{
_context.Update(salesOrderLine);
}
await _context.SaveChangesAsync();
}
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction(nameof(Edit), new { ID = salesOrderLine.SalesOrderID }));
}
public void Delete(SalesOrderLine salesOrderLine)
{
if (salesOrderLine == null)
{
throw new ArgumentNullException(nameof(salesOrderLine));
}
_context.SalesOrderLines.Remove(salesOrderLine);
}
public Task AddLine(AddSalesOrderLineMessage message)
{
var line = new SalesOrderLine(message.ProductKey, message.Quantity, message.Price, message.Comment);
_salesOrder.AddLine(line);
return(TaskDone.Done);
}
public IActionResult DeleteLine(Guid ID)
{
SalesOrderLine salesOrderLine = _context.SalesOrderLine
.Where(x => x.ID.Equals(ID)).FirstOrDefault();
string model = Newtonsoft.Json.JsonConvert.SerializeObject(salesOrderLine);
return(PartialView("_ModalDelete", model: model));
}
public void Create(SalesOrderLine salesOrderLine)
{
if (salesOrderLine == null)
{
throw new ArgumentNullException(nameof(salesOrderLine));
}
_context.SalesOrderLines.Add(salesOrderLine);
}
public IActionResult Remove([FromBody] CrudViewModel <SalesOrderLine> payload)
{
SalesOrderLine soline = _functionalService.GetById <SalesOrderLine>(Convert.ToInt32(payload.key));
var result = _functionalService.Delete <SalesOrderLine>(soline);
this.UpdateSalesOrder(soline.SalesOrderId);
return(Ok());
}
public ActionResult SaveOrder(Models.ViewModels.Sales.SalesHeaderViewModel model)
{
SalesOrderHeader order = null;
if (model.Id == 0)
{
order = new SalesOrderHeader();
order.CreatedBy = User.Identity.Name;
order.CreatedOn = DateTime.Now;
}
else
{
order = _salesService.GetSalesOrderById(model.Id);
}
order.ModifiedBy = User.Identity.Name;
order.ModifiedOn = DateTime.Now;
order.CustomerId = model.CustomerId.Value;
order.PaymentTermId = model.PaymentTermId;
order.Date = model.Date;
foreach (var line in model.SalesLine.SalesLineItems)
{
SalesOrderLine lineItem = null;
var item = _inventoryService.GetItemByNo(line.ItemNo);
if (!line.Id.HasValue)
{
lineItem = new SalesOrderLine();
lineItem.CreatedBy = User.Identity.Name;
lineItem.CreatedOn = DateTime.Now;
order.SalesOrderLines.Add(lineItem);
}
else
{
lineItem = order.SalesOrderLines.Where(i => i.Id == line.Id).FirstOrDefault();
}
lineItem.ModifiedBy = User.Identity.Name;
lineItem.ModifiedOn = DateTime.Now;
lineItem.ItemId = line.ItemId;
lineItem.MeasurementId = item.SellMeasurementId.Value;
lineItem.Quantity = line.Quantity;
lineItem.Discount = line.Discount;
lineItem.Amount = line.Price;
}
if (model.Id == 0)
{
_salesService.AddSalesOrder(order, true);
}
else
{
_salesService.UpdateSalesOrder(order);
}
return(RedirectToAction("SalesOrders"));
}
public async Task<EntityEntry<SalesOrderLine>> AddSalesOrderLine (SalesOrderLine formdata) {
var result = await _applicationDbContext.SalesOrderLine.AddAsync (formdata);
try {
await _applicationDbContext.SaveChangesAsync ();
return result;
} catch (Exception) {
return null;;
}
}
public void CalculateLineLineTotals()
{
var line = new SalesOrderLine();
line.OrderQuantity = 10;
line.BCUnitPrice = 10.99m;
line.CalculcateTotals(0, 1);
Assert.AreEqual(109.9m, line.LineTotal);
Assert.AreEqual(109.9m, line.BCLineTotal);
}
public SalesOrderLine addSalesOrderLine(int qty, string prod, SalesOrder s)
{
SalesOrderLine sol = new SalesOrderLine();
sol.ProductCode = prod;
sol.Quantity = qty;
s.addLine(sol);
return(sol);
}
public IActionResult Update([FromBody] CrudViewModel <SalesOrderLine> payload)
{
SalesOrderLine salesOrderLine = payload.value;
salesOrderLine = this.Recalculate(salesOrderLine);
_context.SalesOrderLine.Update(salesOrderLine);
_context.SaveChanges();
this.UpdateSalesOrder(salesOrderLine.SalesOrderId);
return(Ok(salesOrderLine));
}
private async Task <SalesOrderLine> GetSingleMultiDropSalesOrderLine(SalesOrderParserSettingsBlob settings)
{
var line = new SalesOrderLine();
var drawingNumberMatches = _pdfParser.Find(settings.DrawingNumberExpr, settings.DrawingNumberOptions);
if (string.IsNullOrEmpty(settings.DrawingNumberReplacementExpr))
{
line.DrawingNumber = drawingNumberMatches.Count == 0 ? "N/A" : drawingNumberMatches[0].Value;
}
else
{
if (drawingNumberMatches.Count == 0)
{
line.DrawingNumber = "N/A";
}
else
{
line.DrawingNumber = RegexReplace(
drawingNumberMatches[0].Value,
settings.DrawingNumberReplacementExpr,
settings.DrawingNumberReplacementValue,
settings.DrawingNumberReplacementOptions);
}
}
line.Photo = await _photos.GetPhotoByDrawingNumber(line.DrawingNumber);
line.Name = await _tricorn.GetNameByDrawingNumberAsync(line.DrawingNumber);
var deliveryMatches = _pdfParser.Find(settings.MultiDropExpr, settings.MultiDropOptions);
line.OriginalDeliveryDate = DateTime.MaxValue;
foreach (Match match in deliveryMatches)
{
var quantityString = match.Groups["quantity"].Value;
var deliveryString = match.Groups["delivery"].Value;
var batch = new BatchDelivery
{
DeliveryDate = DateTime.Parse(deliveryString),
Quantity = int.Parse(quantityString)
};
line.BatchDeliveries.Add(batch);
if (batch.DeliveryDate < line.OriginalDeliveryDate)
{
line.OriginalDeliveryDate = batch.DeliveryDate;
}
}
return(line);
}
public async Task <IActionResult> Update([FromBody] SalesOrderLine payload)
{
SalesOrderLine salesOrderLine = payload;
salesOrderLine = this.Recalculate(salesOrderLine);
_context.SalesOrderLine.Update(salesOrderLine);
await _context.SaveChangesAsync();
this.UpdateSalesOrder(salesOrderLine.SalesOrderId);
return(Ok(salesOrderLine));
}
public IActionResult Remove([FromBody] CrudViewModel <SalesOrderLine> payload)
{
SalesOrderLine salesOrderLine = _context.SalesOrderLine
.Where(x => x.SalesOrderLineId == (int)payload.key)
.FirstOrDefault();
_context.SalesOrderLine.Remove(salesOrderLine);
_context.SaveChanges();
this.UpdateSalesOrder(salesOrderLine.SalesOrderId);
return(Ok(salesOrderLine));
}
void ButtonSaveClick(object sender, EventArgs e)
{
try {
ValidateForm();
salesOrderLine = GetSalesOrderLineFromForm();
this.Close();
} catch (Exception ex) {
MessageBox.Show(ex.Message,"",MessageBoxButtons.OK,MessageBoxIcon.Error);
}
}
public void Copy(SalesOrderLine OldSOLine)
{
Customer = OldSOLine.Customer;
ItemNo = OldSOLine.ItemNo;
ItemName = OldSOLine.ItemName;
ItemType = OldSOLine.ItemType;
Material = OldSOLine.Material;
OrderNo = OldSOLine.OrderNo;
OrderIndex = OldSOLine.OrderIndex;
CustomerItemNo = OldSOLine.CustomerItemNo;
OurPrice = OldSOLine.OurPrice;
ShipMethod = OldSOLine.ShipMethod;
NeedQty = OldSOLine.NeedQty;
ShippedQty = OldSOLine.ShippedQty;
Priority = OldSOLine.Priority;
PriorityList = OldSOLine.PriorityList;
PromisedDate = OldSOLine.PromisedDate;
PromisedDateList = OldSOLine.PromisedDateList;
OrderDate = OldSOLine.OrderDate;
NeedDate = OldSOLine.NeedDate;
}
SalesOrderLine GetSalesOrderLineFromForm()
{
SalesOrderLine salesOrderLine = new SalesOrderLine { Product = selectedProduct, quantity = int.Parse(TBQuantity.Text), salesPrice = double.Parse(TBSalesPrice.Text), amount = double.Parse(TBAmount.Text), SalesOrderStatus = (SalesOrderStatus)ComboSalesOrderStatus.SelectedItem };
return salesOrderLine;
}
public bool Equals(SalesOrderLine other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other.Quantity == Quantity && Equals(other.ProductId, ProductId) && other.ItemValue == ItemValue;
}
private static SalesOrderLine FindOrCreateSalesOrderLine(RotoTrackDb db, string TxnLineID, string TxnID, string TimeCreated, string TimeModified, string EditSequence, string TxnDate, string AmountDue, string IsManuallyClosed, string IsFullyInvoiced)
{
SalesOrderLine sol = null;
if (db.SalesOrderLines.Any(f => f.TxnLineId == TxnLineID))
{
sol = db.SalesOrderLines.First(f => f.TxnLineId == TxnLineID);
}
else
{
sol = new SalesOrderLine();
db.SalesOrderLines.Add(sol);
}
sol.TxnLineId = TxnLineID;
sol.SalesOrderTxnId = TxnID;
DateTime createdDate;
if (DateTime.TryParse(TimeCreated, out createdDate)) sol.SalesOrderCreated = createdDate;
DateTime modifiedDate;
if (DateTime.TryParse(TimeModified, out modifiedDate)) sol.SalesOrderModified = modifiedDate;
sol.SalesOrderEditSequence = EditSequence;
DateTime txnDate;
if (DateTime.TryParse(TxnDate, out txnDate)) sol.SalesOrderTxnDate = txnDate;
decimal amountDue;
if (Decimal.TryParse(AmountDue, out amountDue)) sol.SalesOrderTotalAmount = amountDue;
bool isManuallyClosed;
if (bool.TryParse(IsManuallyClosed, out isManuallyClosed))
{
sol.SalesOrderIsManuallyClosed = isManuallyClosed;
}
bool isFullyInvoiced;
if (bool.TryParse(IsFullyInvoiced, out isFullyInvoiced))
{
sol.SalesOrderIsFullyInvoiced = isFullyInvoiced;
}
return sol;
}
