public static OrderDetailDto ToOrderDetail(this Order p, bool?onlyShow = null)
{
var result = new OrderDetailDto();
p.ToOrderDto(result);
result.OrderLogs = new List <OrderLogDto>();
if (p.OrderLogs != null && p.OrderLogs.Count > 0)
{
var logQuery = p.OrderLogs.AsQueryable();
if (onlyShow.HasValue)
{
logQuery = logQuery.Where(q => q.IsShowLog == onlyShow.Value);
}
result.OrderLogs = logQuery.Select(l => new OrderLogDto()
{
Id = l.Id,
OperationContent = l.OperationContent,
OperationDatetime = l.OperationDatetime,
OperationPerson = l.OperationPerson,
Remark = l.Remark
}).ToList();
}
return(result);
}
public static void Map(this OrderDetailDto OrderDetailDto, OrderDetail OrderDetail)
{
OrderDetail.OrderDetailId = OrderDetailDto.OrderDetailId;
OrderDetail.DetailProductId = OrderDetailDto.DetailProductId;
OrderDetail.DetailOrderId = OrderDetailDto.DetailOrderId;
OrderDetail.Quantity = OrderDetailDto.Quantity;
}
public ActionResult Add(OrderDetailDto entity)
{
var OrderDetail = mapper.Map <OrderDetail>(entity);
IOrderService.Add(OrderDetail);
return(Ok("添加成功"));
}
public void PlaceOrder()
{
List <CartVM> cart = Cart;
string username = User.Identity.Name;
int orderId;
using (DB db = new DB())
{
OrderDto order = new OrderDto();
var q = db.Users.FirstOrDefault(x => x.Username == username);
int userId = q.Id;
order.UserId = userId;
order.CreatedOn = DateTime.Now;
db.Orders.Add(order);
db.SaveChanges();
orderId = order.OrderId;
OrderDetailDto orderdet = new OrderDetailDto();
foreach (var item in cart)
{
orderdet.OrderId = orderId;
orderdet.ProductId = item.ProductId;
orderdet.Quantity = item.Quantity;
db.OrderDetails.Add(orderdet);
db.SaveChanges();
}
}
SendTestEmail("*****@*****.**", "*****@*****.**",
"Order Completed", "Order ID: " + orderId.ToString());
Session["cart"] = null;
}
/// <summary>
/// Creates Order for given shopping cart.
/// </summary>
/// <param name="orderDto">Order details</param>
/// <param name="shoppingCartBs">Shoping cart that is purchased.</param>
public void CreateOrder(OrderDto orderDto, IShoppingCartBs shoppingCartBs)
{
base.Add(orderDto);
IOrderDetailBs _orderDetailBs = new OrderDetailBs(AppDbContext);
var shoppingCartItems = shoppingCartBs.ShoppingCartItems;
foreach (var shoppingCartItem in shoppingCartItems)
{
var orderDetailDto = new OrderDetailDto()
{
Amount = shoppingCartItem.Amount,
Pie = new PieDto()
{
Id = shoppingCartItem.Pie.Id
},
Order = new OrderDto()
{
Id = orderDto.Id
},
Price = shoppingCartItem.Pie.Price,
Id = Guid.NewGuid()
};
_orderDetailBs.Add(orderDetailDto);
}
}
public void EditOrderDetail(OrderDetailDto orderDetailDto)
{
var order = GetOrder(orderDetailDto.OrderId);
var orderDetail = order.OrderDetails.SingleOrDefault(x => x.ProductId == orderDetailDto.Product.Id && x.OrderId == orderDetailDto.OrderId);
var detailAlreadyExists = true;
if (orderDetail == null)
{
detailAlreadyExists = false;
var product = GetProduct(orderDetailDto.Product.Id);
orderDetail = new OrderDetails
{
Product = product
};
}
orderDetail.Quantity = orderDetailDto.Quantity;
orderDetail.Discount = orderDetailDto.Discount;
orderDetail.UnitPrice = orderDetailDto.UnitPrice;
if (!detailAlreadyExists)
{
order.OrderDetails.Add(orderDetail);
}
_context.SaveChanges();
}
//thiết kế giao diện hóa đơn
public ActionResult ExportOrder(int?Id)
{
var lstOrder = db.OrderDetails.Where(w => w.OrderId == Id).ToList();
var customer = db.Orders.Join(db.Customers, o => o.CustomerId, c => c.Id, (o, c) => new
{
FirstName = c.FistName,
LastName = c.LastName,
Address = c.Address,
PhoneNumber = c.PhoneNumber,
OrderDate = o.OrderDate,
OrderId = o.Id
}).ToList().Where(w => w.OrderId == Id).FirstOrDefault();
OrderDetailDto orderDetailDto = new OrderDetailDto();
orderDetailDto.FirstName = customer.FirstName;
orderDetailDto.LastName = customer.LastName;
orderDetailDto.Address = customer.Address;
orderDetailDto.PhoneNumber = customer.PhoneNumber;
orderDetailDto.OrderDate = customer.OrderDate;
orderDetailDto.OrderId = customer.OrderId;
ViewBag.Customer = orderDetailDto;
return(View(lstOrder));
}
public void Update(OrderDetailDto item)
{
using (var ctx = DbContextManager <ModelContainer> .GetManager())
{
var data = (from o in ctx.DbContext.OrderDetails
where (o.OrderDetailId.Equals(item.Id))
select o).FirstOrDefault();
if (data == null)
{
throw new DataNotFoundException("OrderDetail");
}
data.OrderOrderId = item.OrderId;
data.OrderDetailId = item.Id;
data.LineNo = item.LineNo;
data.Item = item.Item;
data.Price = item.Price;
data.Qty = item.Qty;
data.Discount = item.Discount;
var count = ctx.DbContext.SaveChanges();
if (count == 0)
{
throw new Exception();
}
}
}
internal static void ShowPrintTravel(OrderDetailDto order, PassengerDto passenger, ResponseChangeOrder rasorder = null, ResponseAfterSalePassenger raspassenger = null, int flag = 0, OrderInfoViewModel orderInfoViewModel = null, AfterSaleInfoViewModel afterSaleInfoViewModel = null, Action <bool?> call = null)
{
DispatcherHelper.UIDispatcher.Invoke(new Action(() =>
{
var window = new PrintTravelWindow {
Owner = Application.Current.MainWindow
};
var vm = new PrintTravelViewModel
{
RspOrder = order,
Passenger = passenger,
RsAferSaleOrder = rasorder,
RsAfterSalePassenger = raspassenger,
RFlag = flag,
OrderInfoViewModel = orderInfoViewModel,
AfterSaleInfoViewModel = afterSaleInfoViewModel
};
vm.Init();
window.DataContext = vm;
var result = window.ShowDialog();
if (call != null)
{
call(result);
}
window.DataContext = null;
}));
}
public async Task <OrderDto> GetOrderDetailsAsync(long id)
{
OrderDto orderDto = GetOrder(id);
if (orderDto != null)
{
OrderDetailDto orderDetailDto = new OrderDetailDto
{
Id = orderDto.Id,
TotalMoney = orderDto.TotalMoney,
Address = orderDto.Address,
Addressee = orderDto.Addressee,
From = orderDto.From,
SendAddress = orderDto.SendAddress
};
var client = _clientFactory.CreateClient(ServiceName.ProductService);
var response = await client.GetAsync($"/productapi/product/getall");
var result = await response.Content.ReadAsStringAsync();
orderDetailDto.Products = JsonConvert.DeserializeObject <List <OrderProductDto> >(result);
return(orderDetailDto);
}
return(orderDto);
}
public static OrderDetails ToOrderDetailsDto(this OrderDetailDto orderDetails) => new OrderDetails
{
Id = orderDetails.Id,
ProductId = orderDetails.ProductId,
Quantity = orderDetails.Quantity,
OrderId = orderDetails.OrderId
};
public IActionResult UpdateOrder(int?orderId, [FromBody] OrderUpdateDto model)
{
if (model == null)
{
return(this.BadRequest("The request object cannot be null."));
}
if (orderId != null)
{
model.OrderId = orderId;
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
try
{
this._logger.LogInformation("Updating order.", model, orderId);
OrderDetailDto order = this._orderService.UpdateOrder(model);
this._logger.LogInformation("Updated order successfully.", order);
return(this.Ok(order));
}
catch (ArgumentException ex)
{
this._logger.LogWarning("Failed to update order.", model, orderId);
return(this.BadRequest(ex.Message));
}
}
public OrderEditSplitPanelControl(BadgerDataModel context, BindingSource BSorder)
{
InitializeComponent();
ctx = context;
orderDTO = (OrderDetailDto)BSorder.DataSource;
this.orderHeaderVerticalControl1.OnSaveHandler += OrderHeaderVerticalControl1_OnSaveHandler;
this.orderHeaderVerticalControl1.OnPrintHandler += OrderHeaderVerticalControl1_OnPrintHandler;
}
public void copy(OrderDetail order_detail, OrderDetailDto dto)
{
order_detail.menu_id = dto.menu_id;
order_detail.order_detail_id = dto.order_detail_id;
order_detail.order_id = dto.order_id;
order_detail.quantity = dto.quantity;
order_detail.rate = dto.rate;
}
public bool SaveReportCombination(OrderDto dto, OrderDetailDto orderDetailDto, string orderTypeAbbrev, string remarksType = null)
{
var productList = _inventoryService.FindByProductId((int)orderDetailDto.ProductId);
ReportCombinationDto reportDto = new ReportCombinationDto()
{
TrackingID = 0,
ProductID = (long)orderDetailDto.ProductId,
RequestNum = dto.OrderNum,
DateCreated = System.DateTime.Now,
ProductQty = productList.Quantity,
Qty = orderDetailDto.Quantity,
BranchId = productList.BranchID
};
if (orderTypeAbbrev == Enums.OrderTypeAbbrev.SO.ToString())
{
reportDto.RequestType = Enums.OrderTypeAbbrev.SO.ToString();
//reportDto.SalesOrderQty = (productList.Quantity - orderDetailDto.Quantity);
reportDto.SalesOrderQty = orderDetailDto.Quantity;
}
else if (orderTypeAbbrev == Enums.OrderTypeAbbrev.PO.ToString())
{
reportDto.RequestType = Enums.OrderTypeAbbrev.PO.ToString();
if (!orderDetailDto.isNewPurchaseOrder)
{
//reportDto.PurchaseOrderQty = (productList.Quantity + orderDetailDto.Quantity);
reportDto.PurchaseOrderQty = orderDetailDto.Quantity;
}
else
{
reportDto.PurchaseOrderQty = orderDetailDto.Quantity;
}
}
else if (orderTypeAbbrev == Enums.OrderTypeAbbrev.CR.ToString())
{
reportDto.RequestType = Enums.OrderTypeAbbrev.CR.ToString();
reportDto.Remarks = dto.Remarks;
if (remarksType == "+")
{
//reportDto.PurchaseOrderQty = (productList.Quantity + orderDetailDto.Quantity);
reportDto.PurchaseOrderQty = (orderDetailDto.Quantity);
}
else if (remarksType == "-")
{
//reportDto.SalesOrderQty = (productList.Quantity - orderDetailDto.Quantity);
reportDto.SalesOrderQty = (orderDetailDto.Quantity);
}
}
if (_reportCombination.Insert(reportDto.DtoToEntity()).IsNull())
{
return(false);
}
return(true);
}
public ViewResult OrderDetail(string orderId)
{
using (var cf = new ChannelFactory <IStationOrderService>(typeof(IStationOrderService).Name))
{
var _service = cf.CreateChannel();
OrderDetailDto orderDetail = _service.GetCarrierOrderDetail(orderId);
orderDetail.OrderStatusStr = GetDesc(((EnumOrderStatus)orderDetail.OrderStatus));
return(View(orderDetail));
}
}
public static OrderDetail ConvertToOrderDetail(this OrderDetailDto OrderDetailDto)
{
return(new OrderDetail()
{
OrderDetailId = OrderDetailDto.OrderDetailId,
DetailProductId = OrderDetailDto.DetailProductId,
DetailOrderId = OrderDetailDto.DetailOrderId,
Quantity = OrderDetailDto.Quantity
});
}
public bool SavePurchaseOrderDetail(OrderDetailDto listDto)
{
this.purchaseOrderDetail = listDto.DtoToEntityPurchaseOrderDetail();
if (_purchaseOrderDetail.Insert(this.purchaseOrderDetail).IsNull())
{
return(false);
}
return(true);
}
private OrderDetailDto CreateOrderDetailDto(IDataRecord dataRecord)
{
OrderDetailDto orderDetailDto = new OrderDetailDto();
orderDetailDto.OrderID = dataRecord.GetInt32("OrderID");
orderDetailDto.ProductID = dataRecord.GetInt32("ProductID");
orderDetailDto.Quantity = dataRecord.GetInt16("Quantity");
orderDetailDto.Discount = dataRecord.GetFloat("Discount");
return(orderDetailDto);
}
public JsonResult Edit([FromBody] OrderDetailDto orderDetail)
{
if (orderDetail == null)
{
return(new JsonResult(new { Success = false }));
}
_ordersService.EditOrderDetail(orderDetail);
return(new JsonResult(new { Success = true }));
}
public JsonResult Delete([FromBody] OrderDetailDto orderDetail)
{
if (orderDetail == null)
{
return(new JsonResult(new { Success = false }));
}
_ordersService.DeleteOrderDetail(orderDetail.OrderId, orderDetail.Product.Id);
return(new JsonResult(new { Success = true }));
}
public bool SaveOrderDetail(OrderDetailDto newDetails)
{
this.purchaseOrderDetail = newDetails.DtoToEntity();
if (this._purchaseOrderDetail.Insert(this.purchaseOrderDetail).IsNull())
{
return(false);
}
return(true);
}
public virtual ActionResult VoidProductQty(ProductDto dto)
{
string alertMessage = string.Empty;
bool isSuccess = true;
var createdBy = Session[SessionVariables.UserDetails].GetUserIdFromSession();
var branchId = Session[SessionVariables.UserDetails].GetBranchIdFromSession();
var userTypeId = Session[SessionVariables.UserDetails].GetUserTypeIdFromSession();
DateTime?dateNow = System.DateTime.Now;
dto.UpdatedBy = createdBy;
dto.DateUpdated = dateNow;
if (!_inventoryService.VoidQty(dto))
{
isSuccess = false;
Danger(Messages.ErrorOccuredDuringProcessing);
}
else
{
OrderDto orderDto = new OrderDto()
{
OrderNum = string.Empty,
Remarks = dto.Remarks
};
OrderDetailDto orderDetailDto = new OrderDetailDto()
{
ProductId = dto.ProductID,
Quantity = dto.Quantity
};
if (!_orderService.SaveReportCombination(orderDto, orderDetailDto, Enums.OrderTypeAbbrev.CR.ToString(), dto.CRType))
{
isSuccess = false;
Danger(Messages.ErrorOccuredDuringProcessing);
}
else
{
isSuccess = true;
Success(Messages.UpdateSuccess);
}
}
alertMessage = this.RenderRazorViewToString(IOBALANCEMVC.Shared.Views._Alerts, string.Empty);
var jsonResult = new
{
isSuccess = isSuccess,
alertMessage = alertMessage
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
private static OrderDetail MapTo(this OrderDetailDto dto)
{
return(new()
{
OrderID = dto.OrderID,
ProductID = dto.ProductID,
UnitPrice = dto.UnitPrice,
Quantity = dto.Quantity,
Discount = dto.Discount,
Product = MapTo(dto.Product)
});
}
public static OrderDetailViewModel ToViewModel(this OrderDetailDto source)
{
return(new OrderDetailViewModel
{
Count = source.Count,
Id = source.Id,
OrderId = source.OrderId,
Price = source.Price,
Product = source.Product?.ToViewModel(),
ProductId = source.ProductId,
DisCount = source.DisCount
});
}
public static OrderDetail ToEntity(this OrderDetailDto viewModel)
{
return(viewModel == null ? null : new OrderDetail
{
Id = viewModel.Id,
OrderId = viewModel.OrderId,
MenuDetailId = viewModel.SubMenuId,
Quantity = viewModel.Quantity,
Rate = viewModel.Rate,
Discount = viewModel.Discount,
FinalTotal = viewModel.Quantity * viewModel.Rate - viewModel.Discount
});
}
public string OrderProduct(OrderDetailDto order, DateTime dateCreate)
{
try
{
using (var dbContext = new XeNangEntities())
{
int ID = (from o in dbContext.DatHangs select o.ID).Count() + 1;
var or = new DatHang()
{
ID = ID,
DiaChi = order.CustomerAddr,
MailZalo = order.CustomerEmail,
//CreateDt = dateCreate,
SDT = order.CustomerPhoneNo,
SoLuong = order.Quantities,
TenHang = order.ProductName,
TenNguoiDat = order.CustomerName,
ThoiGianCanLay = order.DateOfDelivery,
TrangThai = order.Status,
};
if (order.Description != null)
{
or.MoTa = order.Description;
}
dbContext.DatHangs.Add(or);
dbContext.SaveChanges();
return(Constant.MESSAGE_SUCCESS);
}
}
// CATCH EXEPTION FOR DEBUG PURPOSE
catch (DbEntityValidationException ex)
{
foreach (var e in ex.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
e.Entry.Entity.GetType().Name, e.Entry.State);
foreach (var ve in e.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
return(Constant.MESSAGE_ERROR);
}
catch (DbUpdateException ex)
{
return(Constant.MESSAGE_ERROR);
}
}
public void CreateOrder_Pass()
{
// Setup Fixtures.
OrderCreateDto dto = TestValues.OrderCreateDto;
// Execute SUT.
OrderDetailDto result = this._sut.CreateOrder(dto);
// Verify Results.
Assert.Equal(dto.Description, result.Description);
this._orderStoreMock
.Verify(
m => m.AddOrder(
It.Is <Order>(o => o.OrderId == null && o.Description.Equals(dto.Description))),
Times.Once);
}
// Main preferred control datasource --
public void SetDataSource(BadgerDataModel context, int orderID)
{
// reference the context object
ctx = context;
// create a new DTO to hold the order
orderDTO = new OrderDetailDto();
_orderService = new OrdersService(ctx);
// Init the mapper
// Retrieve to PurchaseOrder Entity
_purchaseOrder = _orderService.GetOrderByID(orderID);
if (_purchaseOrder != null)
{
// Map to the DTO detached data transfer object
mapper.Map(_purchaseOrder, orderDTO);
// wire a BindingSource for the order binding
bsOrder.DataSource = orderDTO;
// Bind line items to the grid
bsLineitems.DataSource = orderDTO.LineItems;
BindLineItemsToGrid(bsLineitems);
bsOrderFees.DataSource = orderDTO.OrderFees;
bsAttachments.DataSource = orderDTO.Attachments;
}
// Event wiring -------------------------------------------------------------------
// dgOrderLineItem.DataError += DgOrderLineItem_DataError;
dgOrderLineItem.CellValidating += DgOrderLineItem_CellValidating;
dgOrderLineItem.CellEndEdit += DgOrderLineItem_CellEndEdit;
dgOrderLineItem.CellValueChanged += DgOrderLineItem_CellValueChanged;
bsLineitems.ListChanged += BslineItems_ListChanged;
bsOrder.ListChanged += BsOrder_ListChanged;
bsOrderFees.ListChanged += BsOrderFees_ListChanged;;
bsAttachments.ListChanged += BsAttachments_ListChanged;
// Event Wiring -------------------------------------------------------------------
// start with the PartFinder
// partFinderControl
// .LoadDatasource(ctx, orderDTO.SupplierID);
orderHeaderVerticalControl1.LoadDataSource(bsOrder);
}
private void ExecuteOpenOrderInfoCommand(ResponseOrder order)
{
var oo = new OrderDetailDto();
CommunicateManager.Invoke <IOrderService>(service =>
{
oo = service.GetClientOrderDetail(order.OrderId);
}, UIManager.ShowErr);
try
{
var flag = oo.Policy.PolicySourceType == "接口" ? 1 : 0;
LocalUIManager.ShowOrderInfo(order.OrderId, null, flag);
}
catch (Exception exx)
{
Logger.WriteLog(LogType.ERROR, exx.Message, exx);
}
}
