public string InsertReviseOrder(OrderDetailViewModel OrderDetailViewModelObj)
{
OperationsStatusViewModel OperationsStatusViewModelObj = null;
try
{
OrderDetailViewModelObj.commonObj = new LogDetailsViewModel();
OrderDetailViewModelObj.commonObj.CreatedBy = _commonBusiness.GetUA().UserName;
OrderDetailViewModelObj.commonObj.CreatedDate = _commonBusiness.GetCurrentDateTime();
OperationsStatusViewModelObj = Mapper.Map <OperationsStatus, OperationsStatusViewModel>(_orderBusiness.InsertReviseOrder(Mapper.Map <OrderDetailViewModel, OrderDetail>(OrderDetailViewModelObj)));
if (OperationsStatusViewModelObj.StatusCode == 1)
{
return(JsonConvert.SerializeObject(new { Result = "OK", Record = OperationsStatusViewModelObj }));
}
else
{
return(JsonConvert.SerializeObject(new { Result = "Error", Record = OperationsStatusViewModelObj }));
}
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new { Result = "", Message = ex.Message }));
}
}
public ActionResult OrderDetail(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction("Index", "Orders"));
}
var entity = _ordersService.FindById(id.Value);
if (entity == null)
{
return(RedirectToAction("Index", "Orders"));
}
var model = new OrderDetailViewModel()
{
Status = entity.Status,
Id = entity.Id,
Couponid = entity.CouponId != null ? entity.Coupon.Id : null,
Discount = entity.Coupon != null ? entity.Coupon.Discount : 0,
Items = entity.OrderDetails.Select(a => new CartItemViewModel()
{
Price = a.Price,
Quantity = a.Quantity,
ProductName = a.Product != null ? a.Product.Name : "",
Description = a.Product != null ? a.Product.Description : "",
Image = a.Product != null && a.Product.Images != null ? a.Product.Images.FirstOrDefault().Name : "",
}).ToList()
};
return(View(model));
}
public async Task <IHttpActionResult> Post(OrderDetailViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var stf = await _orderDetailService.InsertAsync(model, GetCurrentUserID());
_unitOfWorkAsync.Commit();
var resultObject = new OrderDetailViewModel()
{
ID = stf.Id,
IsGift = stf.IsGift,
CreatDate = DateTime.Now,
LastModifiedDate = DateTime.Now
};
return(Created(resultObject));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Cart()
{
if (ModelState.IsValid)
{
var name = User.Identity.Name;
List <OrderDetail> carts;
if (_ordersService.TryGetCartForUser(name, out carts))
{
IEnumerable <KeyValuePair <OrderDetailViewModel, LocationViewModel> > orderDetailViewModels =
carts.Select(orderDetail =>
{
var orderDetailViewModel = new OrderDetailViewModel(orderDetail);
var firstOrDefault = _locationService.FirstOrDefault(p => p.Id == orderDetail.LocationId);
return(new KeyValuePair <OrderDetailViewModel, LocationViewModel>(orderDetailViewModel,
new LocationViewModel(
firstOrDefault)));
});
return(View(orderDetailViewModels));
}
return(RedirectToAction("ShowAll"));
}
return(null);
}
public HttpResponseMessage Create(OrderDetailViewModel model)
{
var entity = new Order();
entity.SupplierId = model.SupplierId;
entity.LocationId = model.LocationId;
entity.OrderDate = model.OrderDate;
entity.AcceptDate = model.AcceptDate;
entity.Accept = model.Accept;
foreach (var product in model.Products)
{
var productEntity = context.Product.Find(product.ProductId);
if (productEntity != null)
{
entity.Products.Add(new ProductOrdered()
{
ProductId = product.ProductId,
Value = product.Value,
Tax = product.Tax,
Price = product.Price
});
}
}
context.Order.Add(entity);
context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK));
}
public ActionResult Create(OrderDetailViewModel orderDetailVM)
{
using (GoodSupplyEntities db = new GoodSupplyEntities())
{
var orderDetails = new OrderDetails
{
Quantity = orderDetailVM.OrderDetails.Quantity,
QuantityPrice = orderDetailVM.OrderDetails.QuantityPrice,
ItemPrice = orderDetailVM.OrderDetails.ItemPrice,
TotalOrderPrice = orderDetailVM.OrderDetails.TotalOrderPrice,
OrderId = orderDetailVM.OrderDetails.OrderId,
Orders = orderDetailVM.OrderDetails.Orders,
ManufacturerProductId = orderDetailVM.OrderDetails.ManufacturerProductId,
ManufacturerProducts = orderDetailVM.OrderDetails.ManufacturerProducts
};
if (ModelState.IsValid)
{
db.OrderDetails.Add(orderDetails);
db.SaveChanges();
return(RedirectToAction("Index"));
}
orderDetailVM.ManufacturerProducts = db.ManufacturerProducts.ToList();
orderDetailVM.Orders = db.Orders.ToList();
return(View(orderDetailVM));
}
}
public OrderDetailViewModel Create(OrderDetailViewModel input)
{
try
{
decimal totalOrderAmount = 0.00M;
var documentNumber = _documentSequenceService.GetDocumentNumber(DocumentType.Order);
var newOrder = new Order()
{
CustomerContactNumber = input.Order.CustomerContactNumber,
CustomerName = input.Order.CustomerName,
OrderAmount = input.Order.OrderAmount,
OrderDate = (input.Order.OrderDate == null ? DateTime.Now : input.Order.OrderDate.GetValueOrDefault()),
OrderId = Guid.NewGuid().ToString(),
OrderNumber = documentNumber,
OrderStatus = OrderStatus.NewOrder,
OrderTakenBy = _userInfo.UserId,
OrderType = input.Order.OrderType,
CreatedBy = _userInfo.UserId,
CreatedOn = DateTime.Now
};
_databaseContext.Orders.Add(newOrder);
foreach (var item in input.OrderLines)
{
var addedItem = _databaseContext.Items.Where(x => x.ItemId == item.ItemId).FirstOrDefault();
if (addedItem != null)
{
totalOrderAmount = totalOrderAmount + (item.OrderQuantity * addedItem.ItemCharge);
}
var newOrderLine = new OrderLine()
{
CreatedBy = _userInfo.UserId,
CreatedOn = DateTime.Now,
ItemId = item.ItemId,
OrderId = newOrder.OrderId,
OrderLineId = Guid.NewGuid().ToString(),
OrderQuantity = item.OrderQuantity
};
_databaseContext.OrderLines.Add(newOrderLine);
}
_databaseContext.SaveChanges();
var order = _databaseContext.Orders.Include(x => x.OrderLines).Where(x => x.OrderId == newOrder.OrderId).FirstOrDefault();
order.OrderAmount = totalOrderAmount;
_databaseContext.Orders.Update(order);
_databaseContext.SaveChanges();
input.Order.OrderNumber = documentNumber;
input.Order.OrderId = newOrder.OrderId;
return(input);
}
catch (Exception ex)
{
throw ex;
}
}
// GET: Orders/DeleteProduct/5?param=5
public async Task <IActionResult> DeleteProduct(int?id, int?param)
{
if (id == null)
{
return(NotFound());
}
OrderDetailViewModel orderDetail = new OrderDetailViewModel();
var order = await _context.Order
.Include(o => o.PaymentType)
.Include(o => o.OrderProducts)
.SingleOrDefaultAsync(m => m.OrderId == id);
if (order == null)
{
return(NotFound());
}
orderDetail.Order = order;
// Ollie - 9/1
// Get the products that belong to each order
orderDetail.Products = (
from p in _context.Product
join op in order.OrderProducts
on p.ProductId equals op.ProductId
where op.OrderId == id && p.ProductId == param
select p
).ToList();
return(View(orderDetail));
}
public ActionResult AdminDetails(Guid id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Order order = db.Orders.FirstOrDefault(current => current.Id == id);
if (order == null)
{
return(HttpNotFound());
}
OrderDetailViewModel orderDetail = new OrderDetailViewModel()
{
FooterRecentBlog = baseHelper.GetFooterRecentBlog(),
MenuServiceGroups = baseHelper.GetMenuServices(),
MenuProductGroups = baseHelper.GetMenu()
};
orderDetail.Order = order;
orderDetail.OrderDetails = db.OrderDetails.Where(current => current.OrderId == order.Id).ToList();
return(View(orderDetail));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
ApplicationUser user = await GetCurrentUserAsync();
var viewModel = new OrderDetailViewModel();
viewModel.Order = await _context.Order
.Include(o => o.OrderProducts)
.ThenInclude(op => op.Product)
.Where(o => o.OrderId == id).SingleOrDefaultAsync();
viewModel.UserPaymentTypes = new SelectList(_context.PaymentType.Where(pt => pt.UserId == user.Id), "PaymentTypeId", "Description");
if (viewModel.Order == null)
{
return(NotFound());
}
return(View(viewModel));
}
private void SendEmailReceipt(OrderDetailViewModel orderDetail)
{
if (orderDetail.TransactionStatus == TransactionStatus.PaymentComplete)
{
var viewModel = new EmailReceiptViewModel
{
Order = orderDetail,
Site = ColonyContext.CurrentSite
};
var path = System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "EmailTemplates";
var templatePath = Path.Combine(path, string.Format("{0}.cshtml", "Receipt"));
// read in the contents of this template.
var template = System.IO.File.ReadAllText(templatePath);
// do the merge and return
//var body = Razor.Parse(template, model);
//_mailer.Send("*****@*****.**",
// ColonyContext.Current.CurrentSite.DefaultSenderEmail,
// string.Format("{0} Order ({1}) - Receipt",
// viewModel.Site.Name, viewModel.Order.OrderNumber),
// "Receipt", viewModel);
}
}
public async Task <IActionResult> ViewCart(int id)
{
var viewModel = new OrderDetailViewModel();
var currentUser = await GetCurrentUserAsync();
Order order = await _context.Order
.Include(o => o.PaymentType)
.Include(o => o.User)
.ThenInclude(U => U.PaymentTypes)
.Include(o => o.OrderProducts)
.ThenInclude(op => op.Product)
.FirstOrDefaultAsync(m => m.UserId == currentUser.Id.ToString() && m.PaymentTypeId == null);
viewModel.Order = order;
if (order == null || order.PaymentType != null)
{
return(View(viewModel));
}
viewModel.LineItems = order.OrderProducts
.GroupBy(op => op.Product)
.Select(g => new OrderLineItem
{
Product = g.Key,
Units = g.Select(x => x.Product).Count(),
Cost = g.Key.Price * g.Select(x => x.ProductId).Count()
}).ToList();
return(View(viewModel));
}
// GET: /<controller>/
public IActionResult Index()
{
IEnumerable <OrderViewModel> AllOrders = _repo.GetAllOrders().Select(m =>
{
List <OrderDetailViewModel> productlist = new List <OrderDetailViewModel>();
foreach (var item in m.ProductDetail)
{
OrderDetailViewModel purchase = new OrderDetailViewModel
{
ProductName = item.Key,
Quantity = item.Value,
Price = (decimal)m.ProductPrice[item.Key],
};
productlist.Add(purchase);
}
return(new OrderViewModel
{
ID = m.OrderId,
CustomerName = m.CustomerName,
Location = (m?.Location.X + " " + m?.Location.Y),
Purchase = productlist,
PurchaseDate = m.PurchaseDate
});
});
return(View());
}
// GET: Order/Details/5
public ActionResult Details(int paymentId, string what)
{
IEnumerable <CartToDeliver> carts = aCartToDeliverManager.GetCartListForAdmin(paymentId);
OrderDetailViewModel aOrderDetailViewModel = new OrderDetailViewModel();
Order aOrder = aOrderManager.GetaOrder(paymentId);
Payment aPayment = aPaymentManager.GetAPayment(paymentId);
ApplicationUser user = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>().FindById(aPayment.UserId);
User aUser = aCustomUserManager.GetUser(user.UserName);
aOrderDetailViewModel.CustomerName = user.UserName;
aOrderDetailViewModel.CustomerAddress = aUser.Address;
aOrderDetailViewModel.CustomerPhn = aUser.Number;
aOrderDetailViewModel.OrderId = aOrder.Id;
aOrderDetailViewModel.OrderDate = aOrder.Date;
aOrderDetailViewModel.PaymentDate = aPayment.Date;
aOrderDetailViewModel.PaymentId = aPayment.Id;
if (aPayment.CashOnDelivery == true)
{
aOrderDetailViewModel.PaymentType = "Cash on delivery";
}
else if (aPayment.CreditCardNumber != null)
{
aOrderDetailViewModel.PaymentType = "By Credit Card = " + aPayment.CreditCardNumber;
}
else
{
aOrderDetailViewModel.PaymentType = "By Bkash number = " + aPayment.BkashNumber + " and TrxNo is = " +
aPayment.TrxNo;
}
return(View(aOrderDetailViewModel));
}
public OrderDetailViewModel RecieveOrder(OrderDetailViewModel entity)
{
var order = context.tbl_PurchaseOrderDetail
.Where(c => c.PurchaseOrderDetailId == entity.purchaseOrderDetailId)
.FirstOrDefault();
order.IsRecieved = true;
StockViewModel stork = AddStockItems(entity, order);
stock.AddStockEntries(stork);
//var existingStock = context.tbl_Stock.Where(s => s.ProductId == entity.productId).FirstOrDefault();
//if (existingStock != null)
//{
// existingStock.QuantitySupplied += entity.quantity;
//}
//else
//{
// StockViewModel stork = AddStockItems(entity, order);
// stock.AddStockEntries(stork);
//}
if (context.SaveChanges() > 0)
{
UpdateOrderifFullyReceived(entity.purchaseOrderId);
return(SetOrderDetails(entity, order));
}
else
{
return(null);
}
}
// GET: OrderRecords/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var orderRecord = await _context.OrderRecords
.SingleOrDefaultAsync(m => m.Id == id);
if (orderRecord == null)
{
return(NotFound());
}
var orderRecordDetails = await _context.OrderRecordDetails
.Where(o => o.OrderId == orderRecord.Id)
.ToListAsync();
var model = new OrderDetailViewModel();
model.OrderRecord = orderRecord;
model.OrderRecordDetails = orderRecordDetails;
return(View(model));
}
public OrderDetailViewModel GetOrderDetails(int orderId, string userId)
{
var order = (from o in _db.OrderInfo
where orderId == o.OrderId && userId == o.UserId
select o).SingleOrDefault();
if (order == null)
{
return(null);
}
var orderedBooks = GetBooks(orderId);
var orderInfo = GetOrderInfo(orderId);
var shippingBillingInfo = GetShippingBilling(orderInfo);
var paymentInfo = Payment(orderInfo);
var orderDetailed = new OrderDetailViewModel
{
Id = order.OrderId,
Books = orderedBooks,
ShippingBillingInfo = shippingBillingInfo,
PaymentInfo = paymentInfo
};
return(orderDetailed);
}
public OrderDetailPage(int orderID)
{
InitializeComponent();
order = OrderProvider.GetOrder(orderID);
if (order.Status != OrderStatus.Ordered)
{
btnSendOrder.Visibility = System.Windows.Visibility.Hidden;
btnPrint.Content = "补打订单";
}
//转换成页面模型进行处理
detailModel = new OrderDetailViewModel();
detailModel.OrderID = order.OrderID;
detailModel.Receiver = order.Receiver;
detailModel.ReceiverPhone = order.Phone;
detailModel.UserName = order.UserName;
detailModel.TotalPrice = order.TotalPrice;
detailModel.Address = order.Address;
detailModel.OrderTime = order.OrderTime;
detailModel.Remark = order.Remark;
detailModel.DetailItems = new List<OrderDetailItemViewModel>();
totalPageCount = (order.OrderDetails.Count + eachPagedItemNumber - 1) / eachPagedItemNumber;
ShowPagedOrderDetail();
btnPrePage.DataContext = this;
btnNextPage.DataContext = this;
}
//public async Task<PartialViewResult> SelctMaterials(int? id)
//{
// var output = await _purchaseOrderAppService.GetOrderForEditAsync(new Abp.Application.Services.Dto.NullableIdDto { Id = id });
// var viewModel = new CreateOrEditOrderViewModel(output);
// return PartialView("CreateOrUpdateModal", viewModel);
//}
public async Task <ActionResult> OrderDetails(string orderCode)
{
var output = _purchaseOrderAppService.GetPurchaseOrderDet(orderCode);
var viewModel = new OrderDetailViewModel(output);
return(View(viewModel));
}
public void AddProductToCart(string productCode, int qty)
{
var product = productProvider.GetProduct(productCode);
if (product != null)
{
var orderInCart = MyCart.OrderDetails.FirstOrDefault(cart => cart.ProductCode == productCode);
if (orderInCart != null)
{
orderInCart.Qty += qty;
}
else
{
var orderModel = new OrderDetailViewModel
{
ProductCode = product.Code,
ProductId = product.Id,
ProductName = product.Name,
UnitPrice = product.UnitPrice,
Qty = qty,
LineNo = MyCart.OrderDetails.Count + 1
};
MyCart.OrderDetails.Add(orderModel);
}
}
}
public void TestOrderDetailModel()
{
OrderDetailDTO detailDto = new OrderDetailDTO()
{
Id = 1, QuantityInUnits = 123, UnitPrice = 213, ProductId = 1, ProductName = "FAkeProduct", Version = 1
};
OrderDTO dto = new OrderDTO()
{
Id = 1, OrderStatus = OrderStatus.Ordered, OrderDate = DateTime.Now, ShippedDate = null, CustomerId = 123, CustomerName = "Fakecustomer"
};
dto.Details.Add(detailDto);
OrderDetailViewModel orderDetailViewModel = new OrderDetailViewModel(dto, false);
orderDetailViewModel.Service = serviceFacade;
Expect.Once.On(serviceFacade).Method("StoreOrder").With(dto);
orderDetailViewModel.SaveCommand.Command.Execute(null);
Assert.AreEqual(dto, orderDetailViewModel.Model);
Assert.AreEqual(Strings.OrderDetailViewModel_DisplayName, orderDetailViewModel.DisplayName);
OrderItemViewModel detailListViewModel = (OrderItemViewModel)orderDetailViewModel.ListViewModel;
Assert.AreEqual(detailDto, detailListViewModel.Items.FirstOrDefault());
}
// GET: Orders/Details/5
public async Task <IActionResult> Details(int?id)
{
OrderDetailViewModel currentOrderModel = new OrderDetailViewModel();
if (id == null)
{
return(NotFound());
}
currentOrderModel.Order = await _context.Order
.Include(o => o.PaymentType)
.Include(op => op.OrderProducts)
.SingleOrDefaultAsync(m => m.OrderId == id);
if (currentOrderModel.Order == null)
{
return(NotFound());
}
foreach (var orderProduct in currentOrderModel.Order.OrderProducts)
{
var currentProductsInOrder = _context.Product.SingleOrDefault(p => p.ProductId == orderProduct.ProductId);
currentOrderModel.Products.Add(currentProductsInOrder);
}
return(View(currentOrderModel));
}
public OrderDetailViewModel GetOrderDetail(int?orderID)
{
var orders = db.Database.SqlQuery <OrderViewModel>("exec OrderViewModel").AsQueryable().Where(o => o.OrderID == orderID).ToList()[0];
var orderDetails = new OrderDetailViewModel()
{
OrderID = orders.OrderID,
CustomerName = orders.CustomerName,
ProductNames = new List <OrderDetailProduct>(),
TotalPrice = orders.TotalPrice,
OrderDate = orders.OrderDate
};
foreach (var o in db.OrderDetails.Include(o => o.Product).Where(o => o.OrderID == orderID))
{
orderDetails.ProductNames.Add(new OrderDetailProduct()
{
ProductName = o.Product.ProductName,
ColorName = db.Colors.Find(o.ColorID).ColorName,
SizeID = o.SizeID,
UnitPrice = o.UnitPrice,
Discount = o.Discount,
Quantity = o.Quantity,
TotalPrice = o.UnitPrice * (1 - o.Discount) * o.Quantity
});
}
return(orderDetails);
}
public HttpResponseMessage Get(int orderId)
{
var order = context.Order.Find(orderId);
if (order == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var model = new OrderDetailViewModel();
var products = order.Products.Select(x => new ProductOrderedViewModel()
{
ProductName = x.Product.Name,
ProductId = x.ProductId,
Value = x.Value,
Price = x.Price,
Tax = x.Tax
}).ToList();
model.OrderId = order.OrderID;
model.OrderDate = order.OrderDate;
model.AcceptDate = order.AcceptDate;
model.Accept = order.Accept;
model.Products = products;
return(Request.CreateResponse(HttpStatusCode.OK, model));
}
public OrderDetailViewModel Get(int id)
{
var order = _travelAgencyOrderService.Get(id);
var orderDetails = _travelAgencyOrderDetailService.GetList(order.OrderNo);
var data = new OrderDetailViewModel
{
Id = order.Id,
ValidityDate = order.ValidityDateStart,
PlaceOrderTypeName = ((TraveAgencyPlaceOrderType)order.PlaceOrderType).GetDescription(),
IdCard = order.IdCard,
Linkman = order.Linkman,
Mobile = order.Mobile,
Remark = order.Remark,
AuditStatus = order.AuditStatus,
RejectTime = order.RejectTime,
RejectReason = order.RejectReason,
OrderStatus = order.OrderStatus,
TicketItem = new List <TicketItemModel>()
};
foreach (var row in orderDetails)
{
data.TicketItem.Add(new TicketItemModel
{
TicketId = row.TicketId,
TicketName = row.TicketName,
BookCount = row.Quantity,
Price = row.Price,
TotalAmount = row.Quantity * row.Price
});
}
data.TicketItemJson = JsonSerializeHelper.ToJsonForlowercase(data.TicketItem);
return(data);
}
// GET: Details
public ActionResult Details(int?id)
{
using (GoodSupplyEntities db = new GoodSupplyEntities())
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrderDetails orderDetails = db.OrderDetails.Find(id);
if (orderDetails == null)
{
return(HttpNotFound());
}
var model = new OrderDetailViewModel
{
OrderDetails = orderDetails,
ManufacturerProducts = db.ManufacturerProducts.ToList(),
Orders = db.Orders.ToList()
};
return(View(model));
}
}
public async Task <IActionResult> OrderDetail(int?orderId)
{
if (orderId == null)
{
return(NotFound());
}
var orderRecord = await _context.OrderRecords
.SingleOrDefaultAsync(m => m.Id == orderId);
if (orderRecord == null)
{
return(NotFound());
}
var orderRecordDetails = await _context.OrderRecordDetails
.Where(o => o.OrderId == orderRecord.Id)
.ToListAsync();
var model = new OrderDetailViewModel();
model.OrderRecord = orderRecord;
model.OrderRecordDetails = orderRecordDetails;
var res = new ResultModel()
{
Code = 100,
Data = model
};
return(Json(res));
}
public OrderDetailPage(long orderId)
{
InitializeComponent();
orderDetailViewModel = new OrderDetailViewModel(orderId);
BindingContext = orderDetailViewModel;
}
public async Task AddNewAsync(OrderDetailViewModel model)
{
var odDetail = _mapper.Map <OrderDetail>(model);
await _context.AddAsync(odDetail);
await _context.SaveChangesAsync();
}
public async Task SettingOrderPropertyShouldRaisePropertyChanged()
{
bool invoked = false;
Xamarin.Forms.DependencyService.RegisterSingleton <ISettingsService>(new MockSettingsService());
var orderService = new OrderMockService();
Xamarin.Forms.DependencyService.RegisterSingleton <IOrderService>(orderService);
var orderViewModel = new OrderDetailViewModel();
orderViewModel.PropertyChanged += (sender, e) =>
{
if (e.PropertyName.Equals("Order"))
{
invoked = true;
}
};
var order = await orderService.GetOrderAsync(1, GlobalSetting.Instance.AuthToken);
await orderViewModel.InitializeAsync(new Dictionary <string, string> {
{ nameof(Order.OrderNumber), order.OrderNumber.ToString() }
});
Assert.True(invoked);
}
public OrderDetailViewModel CreateDetail(OrderDetailViewModel OrderDetailVm)
{
var OrderDetail = Mapper.Map <OrderDetailViewModel, OrderDetail>(OrderDetailVm);
_orderDetailRepository.Add(OrderDetail);
return(OrderDetailVm);
}
public ActionResult Edit(OrderDetailViewModel vmChanged)
{
var vm = GetViewModelFromTempData<OrderDetailViewModel>();
if (vm == null) { return RedirectToReferrer(); }
vm.DisplayName = Strings.OrderDetailDetailView_Title;
vm.LatestControllerAction = ControllerAction.Edit;
vm.ApplyFormAttributes(vmChanged.SelectedItem);
return StoreEntity(vm);
}
public void TestOrderDetailModel()
{
OrderDetailDTO detailDto = new OrderDetailDTO() {Id = 1, QuantityInUnits = 123, UnitPrice = 213, ProductId = 1, ProductName = "FAkeProduct", Version = 1};
OrderDTO dto = new OrderDTO() {Id = 1, OrderStatus = OrderStatus.Ordered, OrderDate = DateTime.Now, ShippedDate = null, CustomerId = 123, CustomerName = "Fakecustomer"};
dto.Details.Add(detailDto);
OrderDetailViewModel orderDetailViewModel = new OrderDetailViewModel(dto, false);
orderDetailViewModel.Service = serviceFacade;
Expect.Once.On(serviceFacade).Method("StoreOrder").With(dto);
orderDetailViewModel.SaveCommand.Command.Execute(null);
Assert.AreEqual(dto, orderDetailViewModel.Model);
Assert.AreEqual(Strings.OrderDetailViewModel_DisplayName, orderDetailViewModel.DisplayName);
OrderItemViewModel detailListViewModel = (OrderItemViewModel) orderDetailViewModel.ListViewModel;
Assert.AreEqual(detailDto, detailListViewModel.Items.FirstOrDefault());
}
private void CalculateProductValues(OrderDetailViewModel vm)
{
if (vm.SelectedItem == null) return;
var product = vm.Products.Single(i => i.Id == vm.SelectedItem.ProductId);
vm.SelectedItem.ProductName = product.Name;
vm.SelectedItem.UnitPrice = product.ListUnitPrice;
vm.EstimatedDeliveryTime = CalculateEstimatedDeliveryTime(product.Id);
}
protected ActionResult StoreEntity(OrderDetailViewModel vm)
{
try
{
CalculateProductValues(vm);
if (ModelState.IsValid)
{
switch(vm.LatestControllerAction)
{
case ControllerAction.Create:
vm.Items.Add(vm.SelectedItem);
break;
case ControllerAction.Edit:
int index = vm.Items.FindIndex(i => i.Id == vm.SelectedItem.Id);
vm.Items[index] = vm.SelectedItem;
break;
case ControllerAction.Delete:
vm.Items.Remove(vm.SelectedItem);
vm.ItemsToDelete.Add(vm.SelectedItem);
break;
}
// Finish Action and go back to Index
StoreViewModelToTempData(vm);
TempData.Keep();
return RedirectToAction(vm.ReturnAction, vm.ReturnController, new { id = vm.ReturnId });
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex);
}
// Finish Action without saving
StoreViewModelToTempData(vm);
TempData.Keep();
return View(vm);
}
