private void LoadOrder()
{
OrderInfoDto order = null;
if (!string.IsNullOrEmpty(OrderNumber))
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
OrderFacade facade = new OrderFacade(uow);
order = facade.RetrieveOrderInfo(OrderNumber, new OrderInfoConverter());
}
if (order != null)
{
lblMsg.Visible = false;
ucOrder.Visible = true;
ucOrder.LoadData(order);
}
else
{
lblMsg.Visible = true;
ucOrder.Visible = false;
}
}
}
public Order ScaffoldOrderForCreation(OrderInfoDto customerInfo, BasketForPaymentDto basketForPaymentDto)
{
var result = new Order()
{
OrderRef = Guid.NewGuid(),
Name = customerInfo.Name,
SurName = customerInfo.SurName,
Street = customerInfo.Street,
PostCode = customerInfo.PostCode,
Phone = customerInfo.Phone,
Email = customerInfo.Email,
City = customerInfo.City,
Country = customerInfo.Country,
DeliveryType = customerInfo.DeliveryType,
OrderPrice = basketForPaymentDto.BasketPrice,
StripeRef = basketForPaymentDto.StripeRef,
OrderStocks = basketForPaymentDto.BasketProducts.Select(x => new OrderStock()
{
StockId = x.StockId,
Quantity = x.StockQty,
Price = _ctx.Stocks.Include(s => s.Product).FirstOrDefault(s => s.Id == x.StockId).Product.Price
}).ToList()
};
return(result);
}
public IActionResult Index(string basketCurrentUserId, OrderInfoDto orderInfoDto)
{
var _basketModel = _servicesManager.Baskets.GetBasketsList().Where(b => b.CurrentUser == basketCurrentUserId && b.isProcessed == false);
EmailService emailService = new EmailService();
string emailText = "<div>Firstname: " + orderInfoDto.FirstName + "</div><div>Lastname: " + orderInfoDto.LastName + "</div><div>Phone: " + orderInfoDto.PhoneNum +
"</div><div>Email: " + orderInfoDto.Email + "</div><div>";
int totalPrice = 0;
foreach (var item in _basketModel)
{
if (item.CurrentUser == basketCurrentUserId && item.isProcessed == false)
{
var clothesModel = _servicesManager.Clothes.GetClothesModelById(item.ClothesId);
emailText = emailText + "<div>Clothes name: " + clothesModel.Name + " Price:" + clothesModel.Price + "$</div>";
totalPrice += clothesModel.Price;
item.isProcessed = true;
}
_servicesManager.Baskets.UpdateBasketsDtoToDb(item);
}
emailText += "<div style=\"font-weight:bold\">Total price: " + totalPrice.ToString() + "</div></div>";
emailService.SendEmail(orderInfoDto.Email, "CasualShop Order",
emailText);
return(RedirectToAction("Index", "Shop"));
}
protected void ucOrder_OrderChanged(object sender, InstanceChangedEventArgs e)
{
LoadListsData();
OrderInfoDto order = e.Instance as OrderInfoDto;
LoadSelectedOrder(order.OrderId);
}
public void LoadData(OrderInfoDto order)
{
lvItems.DataSource = order.OrderItems;
lvItems.DataBind();
lblQtyOrderedTotal.Text = order.QtyOrderedTotal.ToString();
lblTotalAmount.Text = order.Amount.ToString();
}
private void LoadOrderInfo(OrderInfoDto order)
{
if (order != null)
{
ucOrder.Visible = true;
ucOrder.Order = order;
ucOrder.LoadData();
}
}
private DeliveryInfo getDeliveryInfo(OrderInfoDto orderInfoDto)
{
var result = orderInfoDto.delivery;
result.abcd = orderInfoDto.abcd;
result.orderid = orderInfoDto.orderid;
result.prescriptionid = orderInfoDto.prescriptionid;
result.createtime = DateTime.Now;
return result;
}
private InvoiceInfo getInoviceInfo(OrderInfoDto orderInfoDto)
{
var result = orderInfoDto.invoice;
result.abcd = orderInfoDto.abcd;
result.orderid = orderInfoDto.orderid;
result.prescriptionid = orderInfoDto.prescriptionid;
result.createtime = DateTime.Now;
return result;
}
public async Task <int> UpdateOrder(OrderInfoDto model)
{
var order = await _service.QueryAsync(model.Id);
order.UpdateTime = DateTime.Now;
order.AcceptName = model.AcceptName;
order.Phone = model.Phone;
order.Address = model.Address;
return(await _service.EditAsync(order));
}
public void SaveOrderInfoDtoToDb(OrderInfoDto orderInfoDto)
{
OrderInfo _orderInfoDbModel;
_orderInfoDbModel = new OrderInfo();
_orderInfoDbModel.FirstName = orderInfoDto.FirstName;
_orderInfoDbModel.LastName = orderInfoDto.LastName;
_orderInfoDbModel.PhoneNum = orderInfoDto.PhoneNum;
_orderInfoDbModel.Email = orderInfoDto.Email;
_dataManager.OrderInfos.SaveOrderInfo(_orderInfoDbModel);
}
private void LoadSelectedOrder(object orderId)
{
OrderInfoDto order = null;
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
OrderFacade facade = new OrderFacade(uow);
order = facade.RetrieveOrderInfo(orderId, new OrderInfoConverter());
order.OrderCommands = facade.GetOrderCommands(order.StatusId);
}
LoadOrderInfo(order);
}
public ActionResult ClientValidation()
{
OrderInfoDto dto =
new OrderInfoDto
{
OrderInfoID = 1,
Delay = null,
DeliveryDate = null,
OrderDateTime = null
};
return View(dto);
}
public ActionResult ClientValidation()
{
OrderInfoDto dto =
new OrderInfoDto
{
OrderInfoID = 1,
Delay = null,
DeliveryDate = null,
OrderDateTime = null
};
return(View(dto));
}
public async Task <int> AddOrder(OrderInfoDto model)
{
return(await _service.AddAsync(new OrderInfo()
{
PayState = model.PayState,
UserId = model.UserId,
Phone = model.Phone,
Address = model.Address,
AcceptName = model.AcceptName,
TotalPrice = model.TotalPrice,
PayType = model.PayType
}));
}
public List <OrderInfoDto> CreateOrdersFromCart(CartDto cart, ShipToDto shipTo)
{
ArgumentValidator.IsNotNull("cart", cart);
ArgumentValidator.IsNotNull("shipTo", shipTo);
List <OrderInfoDto> orders = new List <OrderInfoDto>();
// validate cart
bool isValid = Validate(cart);
if (isValid)
{
IEnumerable <object> supplierIds = cart.CartItems.Select(o => o.SupplierId).Distinct();
int orderNo = 0;
foreach (object supplierId in supplierIds)
{
orderNo++;
OrderInfoDto order = new OrderInfoDto();
order.OrderNumber = orderNo.ToString();
order.SupplierId = supplierId;
order.ShipTo = shipTo;
order.OrderItems = new List <OrderItemInfoDto>();
foreach (CartItemDto cartItem in cart.CartItems)
{
// filter by supplierId
if (object.Equals(cartItem.SupplierId, supplierId))
{
order.SupplierName = cartItem.SupplierName;
OrderItemInfoDto orderItem = new OrderItemInfoDto();
order.OrderItems.Add(orderItem);
orderItem.ProductId = cartItem.ProductId;
orderItem.ProductName = cartItem.ProductName;
orderItem.QtyOrdered = cartItem.QtyOrdered;
orderItem.UnitPrice = cartItem.UnitPrice;
orderItem.Amount = cartItem.Amount;
}
}
order.QtyOrderedTotal = order.OrderItems.Sum(o => o.QtyOrdered);
order.Amount = order.OrderItems.Sum(o => o.Amount);
if (order.QtyOrderedTotal > 0)
{
orders.Add(order);
}
}
}
return(orders);
}
public IActionResult OrderInfoList(int pageIndex = 1)
{
int pageSize = 30;
var openId = HttpContext.Session.GetString("OpenId");
var owner = _context.Menbers.FirstOrDefault(x => x.WeChatOpenId == openId);
var tempData = _context.Orders.Where(x => x.OwnerId == owner.Id).OrderByDescending(x => x.CreateTime);
OrderInfoDto vm = new OrderInfoDto();
vm.Orders = tempData.Skip(pageIndex - 1).Take(pageSize).ToList();
vm.PageCount = (tempData.Count() % pageSize > 0) ? ((tempData.Count() / pageSize) + 1) : (tempData.Count() / pageSize);
vm.PageIndex = pageIndex;
return(View(vm));
}
private OrderInfo getOrderInfo(OrderInfoDto dto)
{
var result = new OrderInfo();
result.abcd = dto.abcd;
result.orderid = dto.orderid;
result.prescriptionid = dto.prescriptionid;
result.fee = dto.fee;
result.ybfee = (dto.ybfee);
result.ybpay = (dto.ybpay);
result.thirdpay = (dto.thirdpay);
result.type = dto.type;
result.paymentstandard = dto.paymentstandard;
result.pharmacyId = dto.pharmacyId;
result.createtime = DateTime.Now;
return result;
}
public IFacadeUpdateResult <OrderData> SaveNewOrder(OrderInfoDto dto)
{
UnitOfWork.BeginTransaction();
IFacadeUpdateResult <OrderData> result = OrderSystem.SaveNewOrder(dto);
if (result.IsSuccessful)
{
UnitOfWork.CommitTransaction();
}
else
{
UnitOfWork.RollbackTransaction();
}
return(result);
}
public ActionResult <OrderInfoDto> OrderInfo(int signId)
{
using (var transaction = dataContext.Database.BeginTransaction())
{
var data = dataContext.Set <Order>().FirstOrDefault(x => x.Id == signId);
{
if (data == null)
{
return(BadRequest("No info found"));
}
OrderInfoDto response = new OrderInfoDto();
response.purchaseTime = data.purchaseTime;
response.email = data.email;
response.address = data.address;
transaction.Commit();
return(Ok(response));
};
}
}
private void LoadSelectedOrder(object orderId)
{
OrderInfoDto order = null;
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
OrderFacade facade = new OrderFacade(uow);
order = facade.RetrieveOrderInfo(orderId, new OrderInfoConverter());
}
if (order != null)
{
ucOrder.Visible = true;
ucOrder.LoadData(order);
}
else
{
ucOrder.Visible = false;
}
}
private void TransferOrderData(OrderInfoDto dto, Order instance)
{
if (dto.ShipToId == null)
{
instance.ShipToContactPhone = dto.ShipTo.ContactPhone;
instance.ShipToContactPerson = dto.ShipTo.ContactPerson;
instance.ShipToAddress = dto.ShipTo.AddressLine1;
instance.ShipToZipCode = dto.ShipTo.ZipCode;
}
instance.OrderNumber = ComposeOrderNumber(instance.ShipToContactPhone, instance.TimeOrdered, dto.OrderNumber);
instance.CustomerId = dto.CustomerId;
instance.ContactId = dto.ContactId;
instance.TimeShipped = dto.TimeShipped;
instance.TimeShipBy = dto.TimeShipBy;
instance.TimeCancelBy = dto.TimeCancelBy;
instance.QtyOrderedTotal = dto.QtyOrderedTotal;
instance.Amount = dto.Amount;
instance.CurrencyId = dto.CurrencyId;
instance.SupplierId = dto.SupplierId;
instance.ShipToId = dto.ShipToId;
instance.Notes = dto.Notes;
}
public async Task <JsonResult> UpdateOrderInfo(OrderInfoDto model)
{
IOrderInfoManager manager = new OrderInfoManager(new OrderInfoService());
var result = await manager.UpdateOrder(model);
if (result == 1)
{
_msg = new MsgResult()
{
IsSuccess = true,
Info = "修改成功"
};
}
else
{
_msg = new MsgResult()
{
IsSuccess = false,
Info = "修改失败"
};
}
return(Json(_msg));
}
internal IFacadeUpdateResult <OrderData> SaveNewOrder(OrderInfoDto dto)
{
ArgumentValidator.IsNotNull("dto", dto);
FacadeUpdateResult <OrderData> result = new FacadeUpdateResult <OrderData>();
IOrderService service = UnitOfWork.GetService <IOrderService>();
// Create Order
Order instance = service.CreateNew <Order>();
TransferOrderData(dto, instance);
// Create OrderItems
foreach (OrderItemInfoDto itemDto in dto.OrderItems)
{
OrderItem item = instance.OrderItems.AddNewBo();
TransferOrderItemData(itemDto, item);
}
// Save
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <OrderData>());
result.Merge(saveQuery);
return(result);
}
public IActionResult Index()
{
var model = new OrderInfoDto();
return(View(model));
}
public async Task <IActionResult> Charge([FromHeader(Name = "Stripe-Token")] string stripeToken, OrderInfoDto customerInfo)
{
var basketJson = HttpContext.Session.GetString("Basket");
if (string.IsNullOrEmpty(basketJson))
{
return(BadRequest("Basket Cookie is empty"));
}
var basketProductsCookie = JsonConvert.DeserializeObject <List <ProductFromBasketCookieDto> >(basketJson);
if (!await _synchronizeBasket.Do(HttpContext.Session, basketProductsCookie) && !_synchronizeBasket.MissingStocks.Any())
{
return(BadRequest("Stocks in Basket are not able to be assign to that Session"));
}
var productsFromRepo = await _unitOfWork.StockOnHold.GetStockOnHoldWithProductForCharge(HttpContext.Session, basketProductsCookie);
if (productsFromRepo.Count < 1)
{
return(BadRequest("Error occured during retrieving data products from Database"));
}
decimal basketPrice = _countOrderPrice.Do(productsFromRepo);
var basketForPaymentDto = _createCharge.Do(stripeToken, basketPrice, basketProductsCookie);
var order = _unitOfWork.Order.ScaffoldOrderForCreation(customerInfo, basketForPaymentDto);
// var stockIdWithQtyToRemove = productsFromRepo.ToDictionary(s => s.StockId, s => s.StockQty);
// await _unitOfWork.Stock.RemoveStockQty(stockIdWithQtyToRemove);
await _unitOfWork.StockOnHold.DeleteRangeAsync(s => s.SessionId == HttpContext.Session.Id);
_unitOfWork.Order.Add(order);
if (await _unitOfWork.SaveAsync())
{
Response.Cookies.Delete("Basket");
//TODO Replace that
return(Ok(201));
}
return(BadRequest("Something went wrong during saving Order"));
}
public void LoadData(OrderInfoDto order)
{
Order = order;
LoadData();
}
public ActionResult ClientValidation(OrderInfoDto dto)
{
return(View(dto));
}
public ActionResult ClientValidation(OrderInfoDto dto)
{
return View(dto);
}
/// <summary>
/// 用户在线下单
/// </summary>
/// <param name="orderInfo">订单信息</param>
/// <returns></returns>
public async Task CreateOrder(OrderInfoDto orderInfo)
{
var context = new Model.LogisticsContext();
using (var transaction = context.Database.BeginTransaction())
{
try
{
//创建订单
var order = new Model.Order()
{
BarCode = orderInfo.BarCode,
Region = orderInfo.Region,
StartWebsiteId = orderInfo.StartWebsiteId
};
context.Set <Model.Order>().Add(order);
await context.SaveChangesAsync();
//添加寄件人信息
var cargoSender = new Model.CargoSender()
{
OrderId = order.Id,
Name = orderInfo.SName,
MobliePhone = orderInfo.SMobliePhone,
Provinces = orderInfo.SProvince,
DetailAddress = orderInfo.SAddress,
PostCode = orderInfo.SPostCode,
TelPhone = orderInfo.STelPhone,
FirmName = orderInfo.SFirmName,
Location = orderInfo.SLocation
};
context.Set <Model.CargoSender>().Add(cargoSender);
await context.SaveChangesAsync();
//添加收件人信息
var cargoReceiver = new Model.CargoReceiver()
{
OrderId = order.Id,
Name = orderInfo.RName,
MobliePhone = orderInfo.RMobliePhone,
Provinces = orderInfo.RProvince,
DetailAddress = orderInfo.RAddress,
PostCode = orderInfo.RPostCode,
TelPhone = orderInfo.RTelPhone,
FirmName = orderInfo.RFirmName,
Location = orderInfo.RLocation
};
context.Set <Model.CargoReceiver>().Add(cargoReceiver);
await context.SaveChangesAsync();
//创建订单明细表
var orderDetaile = new Model.OrderDetails()
{
OrderId = order.Id,
Freight = Convert.ToDecimal(orderInfo.Freight),
IsInsured = orderInfo.IsInsured,
CargoName = orderInfo.CargoName,
CargoWeight = orderInfo.CargoWeight,
CargoVolume = orderInfo.CargoVolume,
UitNum = orderInfo.UitNum,
PayType = orderInfo.PayType,
Mark = orderInfo.Mark,
SenderId = cargoSender.Id,
ReceiverId = cargoReceiver.Id,
GetGoodsTime = orderInfo.TakeTime,
ServiceCharge = Convert.ToDecimal(orderInfo.ServiceCharge)
};
context.Set <Model.OrderDetails>().Add(orderDetaile);
await context.SaveChangesAsync();
if (orderInfo.IsInsured)
{
var insure = new Model.InsuranceInfo()
{
OrderId = order.Id,
InsurerId = cargoSender.Id,
Value = orderInfo.CargoValue,
Risk = orderInfo.Risk,
Fee = decimal.Parse(Tools.MaverickCost.CalcInSurenceFee(Convert.ToDouble(orderInfo.CargoValue)))
};
context.Set <Model.InsuranceInfo>().Add(insure);
await context.SaveChangesAsync();
}
transaction.Commit();
}
catch (Exception errer)
{
transaction.Rollback();
throw errer;
}
finally
{
context.Dispose();
}
}
}
