public void GetById()
{
// Arrange
var _service = new Mock <ISalesOrderService>();
_container.RegisterInstance <ISalesOrderService>(_service.Object);
var salesOrder1 = new SalesOrderModel
{
Created = DateTime.UtcNow,
Description = "test1",
ID = Guid.NewGuid(),
Submitted = null
};
var salesOrder2 = new SalesOrderModel
{
Created = DateTime.UtcNow,
Description = "test1",
ID = Guid.NewGuid(),
Submitted = null
};
var salesOrders = new List <SalesOrderModel>();
salesOrders.Add(salesOrder1);
salesOrders.Add(salesOrder2);
_service.Setup(x => x.Get()).Returns(salesOrders.ToArray());
SalesOrderController controller = _container.Resolve <SalesOrderController>();
// Act
var result = controller.Get(salesOrder2.ID);
// Assert
Assert.AreEqual(salesOrder2, result);
}
public ActionResult ViewOrders()
{
CASDatabaseEntities db = new CASDatabaseEntities();
List <SalesOrderModel> list = new List <SalesOrderModel>();
SalesOrderModel dt = new SalesOrderModel();
int id = Convert.ToInt32(Session["ID"]);
var getData = from so in db.SalespersonOrderDetails
where so.SupplierID == id
select new
{
so.DrugName,
so.SalespersonOrderID,
so.OrderNumber,
so.OrderDate,
so.Quantity,
so.OrderStatus
};
foreach (var item in getData)
{
list.Add(new SalesOrderModel
{
SalespersonOrderID = item.SalespersonOrderID,
OrderNumber = item.OrderNumber,
DrugName = item.DrugName,
Quantity = Convert.ToInt32(item.Quantity),
OrderStatus = item.OrderStatus,
OrderDate = Convert.ToDateTime(item.OrderDate)
});
}
dt.ListOrder = list;
return(View(dt));
}
public ActionResult UpdateOrder(int?ID, string str)
{
CASDatabaseEntities db = new CASDatabaseEntities();
SalesOrderModel dt = new SalesOrderModel();
SalespersonOrderDetail objOrder = new SalespersonOrderDetail();
DrugDelivery objDelivery = new DrugDelivery();
var id = Convert.ToInt32(ID);
var getData = db.SalespersonOrderDetails.Where(m => m.SalespersonOrderID == id).FirstOrDefault();
if (str == "Deliver")
{
getData.OrderStatus = "Delivered";
objDelivery.SalespersonOrderID = getData.SalespersonOrderID;
objDelivery.DeliveryDate = DateTime.Today;
db.DrugDeliveries.Add(objDelivery);
Session["Deliver"] = "Delivered";
}
else
{
getData.OrderStatus = "Rejected";
}
dt.OrderStatus = getData.OrderStatus;
db.SaveChanges();
return(RedirectToAction("ViewOrders", "Supplier"));
}
/// <summary>
/// 更新
/// </summary>
/// <param name="model"></param>
/// <param name="userId"></param>
public void Update4Cash(SalesOrderModel model, int userId)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var entity = GetItem(model.Id);
Action(db =>
{
entity.CashDate = model.CashDate;
entity.CashNum = model.CashNum;
entity.CashStatus = model.CashStatus;
entity.UpdatedDate = DateTime.Now;
entity.UpdatedUser = userId;
EFHelper.UpdateEntityFields(db, entity, new List <string>
{
"CashDate",
"CashNum",
"CashStatus",
"UpdatedDate",
"UpdatedUser",
});
});
}
public ActionResult GetOrders(int?ID)
{
SalesOrderModel dt = new SalesOrderModel();
dt.SupplierID = Convert.ToInt32(ID);
return(View(dt));
}
public static int SelectSalesOrderID(SalesOrderModel salesOrderModel)
{
string procedure = "[dbo].[SelectSalesOrderID]";
var p = new DynamicParameters();
p.Add("@id", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
p.Add("@SalesOrder", salesOrderModel.SalesOrder);
p.Add("@LineItem", salesOrderModel.SalesOrderItem);
int i;
using (IDbConnection connection = new SqlConnection(sapConnect))
{
try
{
var retrun = connection.Query(procedure, p, commandType: CommandType.StoredProcedure);
i = p.Get <int>("@id");
}
catch (Exception e)
{
txtWriter.writeInfo($"{salesOrderModel.SalesOrder}, {e}");
throw;
}
}
return(i);
}
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 ActionResult AddInvoice(Guid CustomerId, Guid?SalesOrderId)
{
SalesOrder salesOrder = new SalesOrder();
SalesOrderModel salesOrderModel = new SalesOrderModel();
if (SalesOrderId != null && SalesOrderId != new Guid())
{
salesOrder = salesFacade.GetSalesOrderBySalesOrderId(SalesOrderId.Value);
if (salesOrder != null)
{
List <SalesOrderDetailVM> salesDetailList = salesDetailFacade.GetAllSalesDetailsBySaleOrderId(salesOrder.SalesOrderId);
salesOrderModel.SalesOrder = salesOrder;
salesOrderModel.SalesOrderDetailList = salesDetailList;
}
}
else
{
salesOrderModel.SalesOrder = salesOrder;
salesOrderModel.SalesOrderDetailList = new List <SalesOrderDetailVM>();
}
#region Viewbag
List <SelectListItem> WarehouseList = new List <SelectListItem>();
WarehouseList.AddRange(wareHouseFacade.GetAll().Select(x => new SelectListItem()
{
Text = x.WarehouseName,
Value = x.WarehouseId.ToString()
}).ToList());
//ViewBag.LeadUserList = SalesList;
ViewBag.WarehouseList = WarehouseList;
#endregion
ViewBag.CustomerId = CustomerId;
return(View(salesOrderModel));
}
public ActionResult Index(SalesOrderModel model)
{
var client = new SalesOrderServiceClient();
var sales = client.GetSales(model.StartDate, model.EndDate, model.Name).ToList();
model.Items = sales;
return(View(model));
}
private void ActiveOrderDetails_Tapped(object sender, EventArgs e)
{
(BindingContext as OrdersUserControlViewModel).SoListPageIsVisible = false;
(BindingContext as OrdersUserControlViewModel).ActiveOrderPageIsVisible = true;
SalesOrderModel salesOrder = (((TappedEventArgs)e).Parameter) as SalesOrderModel;
(BindingContext as OrdersUserControlViewModel).GetActiveOrderDetails(salesOrder);
}
/// <summary>
/// Helper for adding sales items
/// </summary>
/// <param name="connection"></param>
/// <param name="salesOrder"></param>
private void AddSalesItems(IDbConnection connection, SalesOrderModel salesOrder)
{
var sqlInsertSalesItem = @"INSERT INTO dbo.SalesOrderItem(Sku, QtyOrdered, UnitPrice, OrderId)
VALUES(@Sku, @QtyOrdered, @UnitPrice, @OrderId)";
foreach (var item in salesOrder.SalesOrderItems)
{
connection.Execute(sqlInsertSalesItem, new { item.Sku, item.QtyOrdered, item.UnitPrice, OrderId = salesOrder.Id });
}
}
/// <summary>
/// If the sales order has the "finished" status - it disables the "finish order" button/otherwise it enables it
/// </summary>
private void ToggleFinishOrder_Button(SalesOrderModel salesOrder)
{
if (salesOrder.Status == OrderStatus.Finished)
{
FinishSalesOrderButton.Enabled = false;
}
else
{
FinishSalesOrderButton.Enabled = true;
}
}
public HttpResponseMessage CreateSalesOrder(SalesOrderModel _SalesOrderModel)
{
try
{
SALES_ORDER so = new SALES_ORDER();
so.INVOICE_TO = _SalesOrderModel.INVOICE_TO;
so.DELIVERY_TO = _SalesOrderModel.DELIVERY_TO;
so.ORDER_NO = _SalesOrderModel.ORDER_NO;
so.ORDER_REF = _SalesOrderModel.ORDER_REF;
so.ORDER_DATE = _SalesOrderModel.ORDER_DATE;
so.SALES_PERSON = _SalesOrderModel.SALES_PERSON;
so.MARKET_CODE = _SalesOrderModel.MARKET_CODE;
so.OVERALL_DISC_PER = _SalesOrderModel.OVERALL_DISC_PER;
so.ORDER_VALUE = _SalesOrderModel.ORDER_VALUE;
so.STANDARD_DISCOUNT = _SalesOrderModel.STANDARD_DISCOUNT;
so.TOTAL_VAT = _SalesOrderModel.TOTAL_VAT;
so.TOTAL_ORDER_VALUE = _SalesOrderModel.TOTAL_ORDER_VALUE;
so.NET_VALUE = _SalesOrderModel.NET_VALUE;
if (_SalesOrderModel.MARGIN == "*N/A*")
{
so.MARGIN = 0;
}
else
{
so.MARGIN = Convert.ToDecimal(_SalesOrderModel.MARGIN);
}
if (_SalesOrderModel.MARGIN_PERCENT == "*N/A*")
{
so.MARGIN_PERCENT = 0;
}
else
{
so.MARGIN_PERCENT = Convert.ToDecimal(_SalesOrderModel.MARGIN_PERCENT);
}
if (_SalesOrderModel.COST == "*N/A*")
{
so.COST = 0;
}
else
{
so.COST = Convert.ToDecimal(_SalesOrderModel.COST);
}
db.SALES_ORDER.Add(so);
db.SaveChanges();
}
catch (Exception)
{
throw;
}
return(Request.CreateResponse(HttpStatusCode.OK, "success"));
}
/// <summary>
/// Overloaded constructor that recieves data from the calling form that will be used to preview the "bill"
/// and finish the sale process for the current order
/// </summary>
public FinishSalesOrderPreviewForm(ISalesOrderPreviewer caller, SalesOrderModel _salesOrder, List <OrderProductModel> salesOrderContent, TaxModel _taxToUse)
{
InitializeComponent();
callingForm = caller;
salesOrder = _salesOrder;
taxToUse = _taxToUse;
DisplaySalesOrderContent(salesOrderContent);
ToggleFinishOrder_Button(salesOrder);
CustomerTextBox.Text = salesOrder.Name;
}
/// <summary>
/// Add a new product to the selected sales order content(sales order product list)
/// </summary>
public void AddNewProductToSalesOrderContent(SalesOrderModel selectedOrder, ProductModel selectedProduct, TaxModel defaultTax, int productQtyToAdd)
{
OrderProductModel newProduct = new OrderProductModel
{
ProductId = selectedProduct.Id,
ProductName = selectedProduct.Name,
OrderId = selectedOrder.Id,
OrderedQuantity = productQtyToAdd,
TaxId = defaultTax.Id
};
GlobalConfig.Connection.Create_SO_Product(newProduct);
}
public SalesOrderUnitTests()
{
var SalesOrder = new SalesOrderModel
{
Id = 123,
AccountReference = "JOE001",
SalesOrderDate = DateTime.Parse("2014-01-01 00:00:00"),
VatInclusive = true,
SalesOrderAddress = new AddressModel
{
Title = "Mr",
Forename = "Joe",
Surname = "Harrison",
Company = "Deepsnik Software Limited",
Address1 = "Business Centre",
Address2 = "Renishaw",
Town = "Sheffield",
Postcode = "S21 3WY",
County = "South Yorkshire"
},
SalesOrderDeliveryAddress = new AddressModel
{
Title = "Mr",
Forename = "Joe",
Surname = "Harrison",
Company = "Deepsnik Software Limited",
Address1 = "Business Centre",
Address2 = "Renishaw",
Town = "Sheffield",
Postcode = "S21 3WY",
County = "South Yorkshire"
},
SalesOrderItems = new List <SalesOrderItemModel>
{
new SalesOrderItemModel
{
Sku = "TEST01",
QtyOrdered = 1,
UnitPrice = 200
},
new SalesOrderItemModel
{
Sku = "TEST02",
QtyOrdered = 1,
UnitPrice = 300
}
}
};
_mockSalesData.Add(SalesOrder);
}
private void SOUpdateSaveButton_Click(object sender, EventArgs e)
{
string status = "Pending";
DateTime today = DateTime.Today;
string soId = _soId;
byte checkInitialRun = 0;
using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(connectionString))
{
//Add entries to the Sales Order table.
SalesOrderModel soModel = new SalesOrderModel(
soId,
decimal.Parse(SOUpdateTotalAmountTextBox.Text.ToString()),
today,
status);
var p = new DynamicParameters();
p.Add("@SOId", soModel.SOId);
p.Add("@SOTotalAmount", soModel.SOTotalAmount);
p.Add("@SODate", soModel.SODate);
p.Add("@SOStatus", soModel.SOStatus);
connection.Execute("dbo.spSO_UpdateSO", p, commandType: CommandType.StoredProcedure);
//Add entries to the Sales Order Item table.
for (int j = 0; j < SOUpdateListView.Items.Count; j++)
{
SalesOrderModel orderModel = new SalesOrderModel(
soId,
SOUpdateListView.Items[j].SubItems[2].Text, //Quantity
today,
status,
SOUpdateListView.Items[j].SubItems[0].Text, //Item Id
decimal.Parse(SOUpdateListView.Items[j].SubItems[3].Text), //Item Price
checkInitialRun);
var o = new DynamicParameters();
o.Add("@SOId", orderModel.SOId);
o.Add("@ItemId", orderModel.ItemId);
o.Add("@ItemPrice", orderModel.ItemPrice);
o.Add("@SOQuantity", orderModel.SOQuantity);
o.Add("@checkInitialRun", orderModel.CheckInitialRun);
connection.Execute("dbo.spSO_UpdateItemsToOrderItems", o, commandType: CommandType.StoredProcedure); //TODO - create stored procedure
checkInitialRun = 1;
}
}
}
/// <summary>
/// Adds the selected product to the selected sales order in the selected quantities and
/// updates the product stock available quantity
/// </summary>
public void AddProductToSalesOrder(SalesOrderModel selectedOrder, ProductModel selectedProduct, ProductStockModel selectedProductStock, TaxModel taxToUse, int productQtyToAdd)
{
OrderProductModel productToSell = CheckIfProductExistsInSalesOrder(selectedProduct, selectedOrder);
if (productToSell == null)
{
AddNewProductToSalesOrderContent(selectedOrder, selectedProduct, taxToUse, productQtyToAdd);
}
else
{
IncrementExistingProductInSalesOrderContent(productToSell, productQtyToAdd);
}
UpdateProductStock_OnAddToSalesOrder(selectedProductStock, productQtyToAdd);
}
public SalesOrderModel GetSalesOrderDetail(int salesOrderId)
{
salesOrderRepository = new SalesOrderRepository(unitOfWork);
SalesOrderModel salesOrderModel = new SalesOrderModel();
SalesOrder salesOrder = salesOrderRepository.SingleOrDefault(x => x.SalesOrderId == salesOrderId && x.RecordDeleted == false);
AutoMapper.Mapper.Map(salesOrder.Address, salesOrderModel.AddressModel);
AutoMapper.Mapper.Map(salesOrder.Account, salesOrderModel.AccountModel);
//AutoMapper.Mapper.Map(salesOrder.Address1, salesOrderModel.AddressModel1);
AutoMapper.Mapper.Map(salesOrder.ProductSalesOrderAssociations, salesOrderModel.ProductSalesOrderAssociationModels);
AutoMapper.Mapper.Map(salesOrder, salesOrderModel);
return(salesOrderModel);
}
/// <summary>
/// Creates a new Sales Order model
/// </summary>
public void CreateNewOrder(TableModel newOrderTable, IDeliveryMethod newOrderDeliveryAdress)
{
if (newOrderTable != null || newOrderDeliveryAdress != null)
{
SalesOrderModel newSalesOrder = new SalesOrderModel
{
Status = OrderStatus.Active
};
InitializeNewSalesOrderDeliveryMethod(newSalesOrder, newOrderTable, newOrderDeliveryAdress);
if (newSalesOrder.Name != null)
{
GlobalConfig.Connection.CreateSalesOrder(newSalesOrder);
}
}
}
public ActionResult Detail(string id)
{
var model = new SalesOrderModel();
if (!string.IsNullOrEmpty(id))
{
var salesOrderID = int.Parse(id);
if (salesOrderID > 0)
{
var client = new SalesOrderServiceClient();
var orderDetails = client.GetSalesOrderDetailBySalesOrderID(salesOrderID).ToList();
model.Items = orderDetails;
}
}
return(View(model));
}
public HttpResponseMessage DeleteSalesOrderCustomerOtherDetails(SalesOrderModel pSalesOrder)
{
try
{
IEnumerable <SALESORDER_CUSTOMER_OTHER_DETAILS> salesOrderCustomerOtherDetailsList = db.SALESORDER_CUSTOMER_OTHER_DETAILS.Where(a => a.ORDER_NO.Equals(pSalesOrder.ORDER_NO));
foreach (SALESORDER_CUSTOMER_OTHER_DETAILS salesOrderCustomerOtherDetails in salesOrderCustomerOtherDetailsList)
{
db.SALESORDER_CUSTOMER_OTHER_DETAILS.Remove(salesOrderCustomerOtherDetails);
}
db.SaveChanges();
}
catch (Exception)
{
throw;
}
return(Request.CreateResponse(HttpStatusCode.OK, "success"));
}
public HttpResponseMessage DeleteSalesOrderCustomerDeliveryTo(SalesOrderModel pSalesOrder)
{
try
{
IEnumerable <SALESORDER_CUSTOMER_DELIVERY_TO> salesOrderCustomerDeliveryToList = db.SALESORDER_CUSTOMER_DELIVERY_TO.Where(a => a.ORDER_NO.Equals(pSalesOrder.ORDER_NO));
foreach (SALESORDER_CUSTOMER_DELIVERY_TO salesOrderCustomerDeliveryTo in salesOrderCustomerDeliveryToList)
{
db.SALESORDER_CUSTOMER_DELIVERY_TO.Remove(salesOrderCustomerDeliveryTo);
}
db.SaveChanges();
}
catch (Exception)
{
throw;
}
return(Request.CreateResponse(HttpStatusCode.OK, "success"));
}
public HttpResponseMessage DeleteSalesOrder(SalesOrderModel pSalesOrder)
{
try
{
IEnumerable <SALES_ORDER> salesOrderList = db.SALES_ORDER.Where(a => a.ORDER_NO.Equals(pSalesOrder.ORDER_NO));
foreach (SALES_ORDER salesOrder in salesOrderList)
{
db.SALES_ORDER.Remove(salesOrder);
}
db.SaveChanges();
}
catch (Exception)
{
throw;
}
return(Request.CreateResponse(HttpStatusCode.OK, "success"));
}
/*
* PostFreightLines
* Post the freight line to the specified sales order with the SYSPRO WCF library
*/
public void CreateSalesOrder(SalesOrderModel salesOrderModel)
{
try
{
LogonToSYSPRO();
StringBuilder sXmlIn = new StringBuilder();
sXmlIn.Append("<SalesOrders><Orders>");
sXmlIn.Append("<OrderHeader>");
sXmlIn.Append("<Customer>" + salesOrderModel.Customer + "</Customer>");
sXmlIn.Append("<CustomerPoNumber>" + salesOrderModel.CustomerPoNumber + "</CustomerPoNumber>");
sXmlIn.Append("</OrderHeader>");
sXmlIn.Append("<OrderDetails>");
foreach (SalesOrderLine line in salesOrderModel.lines)
{
sXmlIn.Append("<StockLine>");
sXmlIn.Append("<CustomerPoLine>" + line.CustomerPoLine + "</CustomerPoLine>");
sXmlIn.Append("<StockCode>" + line.StockCode + "</StockCode>");
sXmlIn.Append("<OrderQty>" + line.OrderQty + "</OrderQty>");
sXmlIn.Append("<OrderUom>EA</OrderUom>");
sXmlIn.Append("</StockLine>");
}
sXmlIn.Append("</OrderDetails>");
sXmlIn.Append("</Orders></SalesOrders>");
_xmlOutput = _client.TransactionPost(_sysproGuid, "SORTOI", CreateXMLParams(), sXmlIn.ToString());
XmlDocument doc = GetSysproOutputDoc(_xmlOutput);
SalesOrderPostModel postModel = new SalesOrderPostModel();
XmlNode salesOrderNode = doc.SelectSingleNode("//SalesOrder");
if (salesOrderNode != null)
{
postModel.SalesOrderNumber = salesOrderNode.InnerText;
}
LogoffOfSYSPRO();
}
catch (Exception ex)
{
if (_client != null)
{
LogoffOfSYSPRO();
}
throw ex;
}
}
//Register sales in accounts database
public bool RegisterSalesOrder(SalesOrderModel salesOrder)
{
string sqlOrderDetails = "SELECT Count(Id) FROM SalesOrder WHERE Id = @Id;";
using (var connection = ConnectionFactory.GetConnection(_ConnectionString))
{
var orderCount = connection.Query <int>(sqlOrderDetails, new { salesOrder.Id }).First();
if (orderCount > 0)
{
UpdateSale(connection, salesOrder);
}
else
{
AddSale(connection, salesOrder);
}
}
return(true);
}
public ActionResult SendMessages()
{
CASDatabaseEntities db = new CASDatabaseEntities();
List <SalesOrderModel> list = new List <SalesOrderModel>();
SalesOrderModel dt = new SalesOrderModel();
int ID = Convert.ToInt32(Session["ID"]);;
var getDetails = from o in db.SalespersonOrderDetails
join s in db.Suppliers
on o.SupplierID equals s.SupplierID
where (o.SalespersonID == ID && (o.OrderStatus == "Requested" || o.OrderStatus == "Delivered"))
select new
{
s.FirstName,
s.LastName,
o.SalespersonOrderID,
o.OrderNumber,
o.OrderDate,
o.DrugName,
o.Quantity,
o.OrderStatus
};
foreach (var item in getDetails)
{
list.Add(new SalesOrderModel
{
SalespersonOrderID = item.SalespersonOrderID,
SupplierName = item.FirstName + " " + item.LastName,
OrderNumber = item.OrderNumber,
OrderDate = Convert.ToDateTime(item.OrderDate),
DrugName = item.DrugName,
Quantity = Convert.ToInt32(item.Quantity),
OrderStatus = item.OrderStatus
});
}
dt.ListOrder = list;
return(View(dt));
}
//Retrieve Sales Order by Id from Database
public SalesOrderModel RetrieveSalesOrderById(int Id)
{
using (var connection = ConnectionFactory.GetConnection(_ConnectionString))
{
var sqlAllOrders = @"SELECT Id, AccountReference, SalesOrderDate, VatInclusive, SalesOrderAddressId, SalesOrderDeliveryAddressId
FROM dbo.SalesOrder
WHERE Id = @Id";
SalesOrderModel model = connection.Query <SalesOrderModel>(sqlAllOrders, new { Id }).FirstOrDefault();
model.SalesOrderAddress = GetAddress(connection, model.SalesOrderAddressId);
model.SalesOrderDeliveryAddress = GetAddress(connection, model.SalesOrderDeliveryAddressId);
var sqlSalesItems = @"SELECT Sku, QtyOrdered, UnitPrice
FROM dbo.SalesOrderItem
WHERE OrderId = @Id";
model.SalesOrderItems = connection.Query <SalesOrderItemModel>(sqlSalesItems, new { Id }).ToList();
return(model);
}
}
public static void InsertSalesOrder(SalesOrderModel salesOrder)
{
string procedure = "[dbo].[InsertSalesOrder]";
object values = new
{
@SalesOrder = salesOrder.SalesOrder,
@LineItem = salesOrder.SalesOrderItem,
@MaterialNumber = salesOrder.MaterialNumber,
@MaterialDescription = salesOrder.MaterialDescription,
@CustomerMateria = salesOrder.CustomerMaterialNmb,
@Quantity = salesOrder.Quantity,
@PlannedShipDate = salesOrder.PlannedShipDate,
@MaterialAvailabilityDate = salesOrder.AvailabilityDate,
@SoldToParty = salesOrder.SoldTo,
@SoldToName = salesOrder.SoldToName,
@ShipTo = salesOrder.ShipTo,
@ShipToName = salesOrder.ShipToName,
@MRPController = salesOrder.MRPController
};
executeProcedure(procedure, values);
}
public ActionResult ViewOrders()
{
CASDatabaseEntities db = new CASDatabaseEntities();
List <SalesOrderModel> list = new List <SalesOrderModel>();
SalesOrderModel dt = new SalesOrderModel();
int id = Convert.ToInt32(Session["ID"]);
var getDetails = from o in db.SalespersonOrderDetails
join s in db.Suppliers
on o.SupplierID equals s.SupplierID
select new
{
s.FirstName,
s.LastName,
s.CompanyName,
o.DrugName,
o.OrderNumber,
o.OrderDate,
o.OrderStatus,
o.Quantity
};
foreach (var item in getDetails)
{
list.Add(new SalesOrderModel
{
SupplierName = item.FirstName + " " + item.LastName,
SupplierCompanyName = item.CompanyName,
DrugName = item.DrugName,
OrderNumber = item.OrderNumber,
OrderDate = Convert.ToDateTime(item.OrderDate),
OrderStatus = item.OrderStatus,
Quantity = Convert.ToInt32(item.Quantity)
});
}
dt.ListOrder = list;
return(View(dt));
}
