// not mapped
// handle duplicates outside
// simple version that deals with one type of pack only
public async Task <AppOrder> AddOneOrder(int quantity, AppOrder order)
{
// Order table
var newOrder = new Order
{
OrderId = order.OrderId,
UserId = order.OrdererId,
Date = order.Date,
Total = order.Total,
};
await _context.Orders.AddAsync(newOrder);
await _context.SaveChangesAsync();
// OrderItem table
// order packA quan 2
// order packB quan 3
// for loop
var newOrderItem = new OrderItem
{
OrderId = order.OrderId,
PackId = order.PackId,
PackQty = quantity,
};
await _context.OrderItems.AddAsync(newOrderItem);
await _context.SaveChangesAsync();
return(order);
}
private void btnOrdenar_Click(object sender, EventArgs e)
{
AppOrder o = new AppOrder();
o.createDate = dateTimePicker1.Value;
o.idAddress = (int)cmbAiD.SelectedValue;
o.idProduct = (int)cmbPiD.SelectedValue;
try
{
AppOrderDAO.addOrder(o);
MessageBox.Show($"Orden agregada exitosamente.",
"HugoApp - Food Delivery",
MessageBoxButtons.OK, MessageBoxIcon.Information);
btnClearProduct_Click(sender, e);
actualizarControlesCommon();
actualizarTablasCommon();
}
catch (Exception exception)
{
MessageBox.Show("Error: " + exception.Message, "Error dialog",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async Task <ActionResult <OrderCreateDTO> > Post(OrderCreateDTO newOrder)
{
//check if order exists
var check = await _orderRepo.GetOneOrder(newOrder.OrderId);
if (check == null)
{
var createdOrder = new AppOrder()
{
//order
OrderId = await _orderRepo.IdGen(),
OrdererId = newOrder.UserId,
Date = newOrder.Date,
Total = newOrder.Total,
//order details
PackId = newOrder.PackId,
PackQty = newOrder.PackQty // pack qty saved in order detail db table
};
//execute any business logic associated with the order
createdOrder.Pack = await _packRepo.GetOnePack(createdOrder.PackId);
createdOrder.Orderer = await _userRepo.GetOneUser(createdOrder.OrdererId);
createdOrder.CalculateTotal();
//createdOrder.FillOrder();
//should just call fillOrder(), will modify later
Random rand = new Random();
if (createdOrder.Orderer.CurrencyAmount >= createdOrder.Total)
{
createdOrder.Orderer.CurrencyAmount -= createdOrder.Total;
int cards = 5 * createdOrder.PackQty;
for (int i = 0; i < cards; ++i)
{
string cardId = Convert.ToString(rand.Next(64)); //only grabs from the first 64 cards in the set, PackId = base set number
AppCard card = await _orderRepo.GetCardFromApi(cardId, createdOrder.PackId);
createdOrder.Orderer.AddCardToInventory(card); //add to the AppUser
await _cardRepo.AddOneCard(card); //add to card table
await _userRepo.AddOneCardToOneUser(createdOrder.OrdererId, card.CardId);
}
}
else
{
throw new Exception("User funds insufficient.");
}
await _userRepo.UpdateUserById(createdOrder.OrdererId, createdOrder.Orderer);
await _orderRepo.AddOneOrder(createdOrder.PackQty, createdOrder);
return(CreatedAtAction(nameof(GetOrderById), new { id = createdOrder.OrderId }, createdOrder)); //201 new order created
}
return(Conflict()); //order already exists and cant be created
}
private AppOrder createAppOrder(String buySell, String triggerRule, double triggerPrice, String remark, Order order, DateTime currentTimeStamp)
{
AppOrder appOrder = AppObjectUtil.createAppOrder(stgName, order, stgIndex);
appOrder.IBOrder = order;
appOrder.TriggerRule = triggerRule;
appOrder.TriggerPrice = triggerPrice;
appOrder.TriggerTime = currentTimeStamp;
appOrder.Remark = remark;
return(appOrder);
}
private void setupOrderAndContext(AppOrder appOrder, String buySell, double triggerPrice, String remark, int indexExecution)
{
appOrderManager.addAppOrUpdateOrder(appOrder);
appOrderManager.addOpenAppOrder(stgIndex, appOrder);
if (indexExecution == 1)
{
execution.setPendingSignal1(buySell, triggerPrice, appOrder, remark);
}
else
{
execution.setPendingSignal2(buySell, triggerPrice, appOrder, remark);
}
}
public void Run()
{
var appOrder = new AppOrder();
if (appOrder == null)
{
WriteLine("appOrder == null:appOrder is null");
}
if (appOrder is null)
{
WriteLine("appOrder is null:appOrder is null");
}
}
public void placeStopTrade(String buySell, String triggerRule, double triggerPrice, String remark, int size, int indexExecution)
{
DateTime currentTimeStamp = DateTime.Now;
AppOrder appOrder = null;
lock (OrderIDLock)
{
Order order = createStopOrder(buySell, triggerPrice, size);
appOrder = createAppOrder(buySell, triggerRule, triggerPrice, remark, order, currentTimeStamp);
setupOrderAndContext(appOrder, buySell, triggerPrice, remark, indexExecution);
appStgManager.getOrderManager().PlaceOrder(appStgManager.CurrentContract, order);
}
persistOrderRecord(appOrder, currentTimeStamp);
}
public static AppOrder createAppOrder(String stgShortName, Order order, int stgIndex)
{
AppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = stgIndex;
appOrder.OrderId = order.OrderId;
appOrder.OrderType = order.OrderType;
appOrder.BuySell = order.Action;
appOrder.TotalQuantity = order.TotalQuantity;
appOrder.LmtPrice = order.LmtPrice;
appOrder.AuxPrice = order.AuxPrice;
appOrder.StratgeyShortName = stgShortName;
return(appOrder);
}
private IAppOrder createOrder_for_addAppOrUpdateOrder()
{
IAppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = 3;
appOrder.OrderId = 1001;
appOrder.OrderType = AppConstant.ORDER_TYPE_LIMIT;
appOrder.BuySell = AppConstant.SELL_SIGNAL;
appOrder.TotalQuantity = 10;
appOrder.LmtPrice = 22000;
appOrder.AuxPrice = 0;
appOrder.StratgeyShortName = "Test Strategy 1";
return(appOrder);
}
private void persistOrderRecord(AppOrder appOrder, DateTime currentTimeStamp)
{
Order order = appOrder.IBOrder;
OrderRecord orderR = new OrderRecord();
orderR.orderId = order.OrderId;;
orderR.sno = stgName;
orderR.orderTime = currentTimeStamp;
appOrderManager.addOrderRecordToRepositry(order.OrderId.ToString(), orderR);
List <OrderRecord> orderRecords = new List <OrderRecord>();
orderRecords.Add(orderR);
appOrderManager.OrderPersister.SaveLastRow(orderRecords);
}
private IAppOrder createOrder_Sell1Contract_0Complete()
{
IAppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = 1;
appOrder.OrderId = 1001;
appOrder.OrderType = AppConstant.ORDER_TYPE_STOP;
appOrder.BuySell = AppConstant.SELL_SIGNAL;
appOrder.TotalQuantity = 1;
appOrder.LmtPrice = 0;
appOrder.AuxPrice = 22000;
appOrder.StratgeyShortName = "Test Strategy 1";
return(appOrder);
}
//ToDo: createMktOrder()
//ToDo: createStopOrder()
//ToDo: createLimitOrder()
//ToDo: createAppOrder()
private IAppOrder createOrder_1Contract_1Complete()
{
IAppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = 1;
appOrder.OrderId = 1001;
appOrder.OrderType = AppConstant.ORDER_TYPE_LIMIT;
appOrder.BuySell = AppConstant.BUY_SIGNAL;
appOrder.TotalQuantity = 1;
appOrder.LmtPrice = 20000;
appOrder.AuxPrice = 0;
appOrder.StratgeyShortName = "Test Strategy 1";
appOrder.addExecution(createExecution1Contract());
return(appOrder);
}
/// <summary>
/// 创建业务员配送单（但是未结算)
/// </summary>
/// <param name="order">订单信息</param>
/// <param name="user">业务员信息</param>
/// <param name="outStock">出库单信息</param>
/// <remarks>2014-9-17 朱成果 创建</remarks>
private void DeliveryTwoSaleSoOrder(AppOrder order, SyUser user, WhStockOut outStock)
{
if (order.Invoice != null)
{
order.Invoice.LastUpdateBy = user.SysNo;
order.Invoice.LastUpdateDate = DateTime.Now;
order.Invoice.Status = (int)Hyt.Model.WorkflowStatus.FinanceStatus.发票状态.已开票;
Hyt.BLL.Order.SoOrderBo.Instance.UpdateOrderInvoice(order.Invoice); //更新发票 余勇 修改 改为调用业务层方法
}
outStock.Status = (int)Hyt.Model.WorkflowStatus.WarehouseStatus.出库单状态.配送中;
outStock.StockOutBy = user.SysNo;
outStock.StockOutDate = DateTime.Now;
Hyt.DataAccess.Warehouse.IOutStockDao.Instance.Update(outStock); //更新出库单状态
GenerateOtherDataForTwoSale(order, user, outStock); //创建业务员配送单
Hyt.BLL.Warehouse.WhWarehouseBo.Instance.UpdateErpProductNumber(outStock.SysNo); //修改EAS库存
}
public void processExecution(ExecutionMessage message)
{
IAppOrderManager orderManager = appStgManager.getAppOrderManager();
String[] stgNames = appStgManager.getStgNames();
if (!appStgManager.getAppOrderManager().AppOrderStore.ContainsKey(message.Execution.OrderId))
{
return;
}
if (!orderManager.isExecutionProcessed(message.Execution.ExecId))
{
AppExecution execution = orderManager.updateAppOrderExecution(message);
IAppOrder order = orderManager.AppOrderStore[message.Execution.OrderId];
AppOrder cloneOrder = (AppOrder)order.Clone();
if (AppObjectUtil.isOrderClosed(cloneOrder))
{
orderManager.closeOpenAppOrder(order.StrategyIndex, order);
}
orderManager.updatePosition(order.StrategyIndex, execution);
String stgName = stgNames[order.StrategyIndex];
AppPosition stgPosition = orderManager.StoreStgPositions[stgName];
log.Info("Total PnL : " + stgPosition.TotalPnL);
orderManager.markExeProcessed(message.Execution.ExecId);
//***New for send order executed email***
IAppEventManager appEventManager = appStgManager.getAppEventManager();
appEventManager.putOrderExeEvents(message, stgName);
/*TSAppExecution execution = appForm.StrategyManager.updateAppOrderExecution(message);
* TSAppOrder order = appForm.StrategyManager.AppOrderStore[message.Execution.OrderId];
* TSAppOrder cloneOrder = (TSAppOrder)order.Clone();
* if (StrategyManager.isOrderClosed(cloneOrder))
* {
* appForm.StrategyManager.closeOpenAppOrder(order.StrategyIndex, order);
* //appForm.StrategyManager.removeOpenAppOrder(order.StrategyIndex, order);
* //appForm.StrategyManager.addClosedAppOrder(order.StrategyIndex, order);
* }
* appForm.StrategyManager.updatePosition(order.StrategyIndex, execution);
* String stgName = appForm.StrategyManager.StgNames[order.StrategyIndex];
* AppPosition stgPosition = appForm.StrategyManager.StoreStgPositions[stgName];
* log.Info("Total PnL : " + stgPosition.TotalPnL);
* //log.Info("Total PnL : " + appForm.StrategyManager.StgPositions[order.StrategyIndex].TotalPnL);
* appForm.StrategyManager.markExeProcessed(message.Execution.ExecId);*/
}
log.Info("Order Executed");
log.Info("*********************************************");
}
/// <summary>
/// 创建业务员配送单（但是未结算)
/// </summary>
/// <param name="order">订单信息</param>
/// <param name="user">业务员信息</param>
/// <remarks>2014-9-17 朱成果 创建</remarks>
public void DeliveryTwoSaleSoOrder(AppOrder order, SyUser user)
{
bool flg = SoOrderBo.Instance.AuditSoOrder(order.SoOrder.SysNo, user.SysNo, false);//审核订单
if (flg)
{
foreach (var pitem in order.Products)
{
pitem.RealStockOutQuantity = pitem.Quantity; ////如果不设置分摊会出错
}
var outStock = SoOrderBo.Instance.CreateOutStock(order.Products, order.SoOrder.DefaultWarehouseSysNo, user); //订单出库
if (outStock != null)
{
DeliveryTwoSaleSoOrder(order, user, outStock);//创建业务员配送单（但是未结算)
}
}
}
/// <summary>
/// 构建业务员配送单信息
/// </summary>
/// <param name="order">订单</param>
/// <param name="user">业务员</param>
/// <param name="outStock">出库单</param>
/// <remarks>2014-9-17 朱成果 创建</remarks>
private void GenerateOtherDataForTwoSale(AppOrder order, SyUser user, WhStockOut outStock)
{
var payType = PaymentTypeBo.Instance.GetPaymentTypeFromMemory(order.SoOrder.PayTypeSysNo);
bool isNeedPay = payType.PaymentType == (int)BasicStatus.支付方式类型.预付;//是否预付
var delivery = new LgDelivery()
{
DeliveryUserSysNo = user.SysNo,
DeliveryTypeSysNo = outStock.DeliveryTypeSysNo,
CreatedBy = user.SysNo,
CreatedDate = DateTime.Now,
Status = (int)LogisticsStatus.配送单状态.配送在途,
StockSysNo = outStock.WarehouseSysNo,
IsEnforceAllow = 0,
PaidAmount = isNeedPay ? order.SoOrder.CashPay : 0,
CODAmount = isNeedPay ? 0 : order.SoOrder.CashPay,
};
var deliverySysNo = Hyt.DataAccess.Logistics.ILgDeliveryDao.Instance.CreateLgDelivery(delivery);//创建配送单
var deliveryItem = new LgDeliveryItem()
{
DeliverySysNo = deliverySysNo,
NoteType = (int)Hyt.Model.WorkflowStatus.LogisticsStatus.配送单据类型.出库单,
NoteSysNo = outStock.SysNo,
Status = (int)Hyt.Model.WorkflowStatus.LogisticsStatus.配送单明细状态.待签收,
AddressSysNo = outStock.ReceiveAddressSysNo,
TransactionSysNo = outStock.TransactionSysNo,
StockOutAmount = outStock.StockOutAmount,
PaymentType = payType.PaymentType,
Receivable = !isNeedPay ? order.SoOrder.CashPay : 0,
IsCOD = !isNeedPay ? (int)Hyt.Model.WorkflowStatus.LogisticsStatus.是否到付.是 : (int)Hyt.Model.WorkflowStatus.LogisticsStatus.是否到付.否,
Remarks = "【二次销售自动创建】",
CreatedBy = user.SysNo,
CreatedDate = DateTime.Now
};
Hyt.DataAccess.Logistics.ILgDeliveryDao.Instance.AddDeliveryItem(deliveryItem);//配送单明细
Order.SoOrderBo.Instance.WriteSoTransactionLog(outStock.TransactionSysNo,
"出库单" + outStock.SysNo +
"分配配送成功，配送单<span style='color:red'>" +
deliverySysNo + "</span>",
user.UserName);//日志
string msg = "出库单" + outStock.SysNo + "由百城当日达配送员<span style='color:red'>{0}</span>配送中，送货人联系电话<span style='color:red'>{1}</span>";
msg = string.Format(msg, user.UserName, user.MobilePhoneNumber);
Order.SoOrderBo.Instance.WriteSoTransactionLog(outStock.TransactionSysNo, msg, user.UserName);//日志
}
// not mapped
public async Task <AppOrder> GetOneOrder(string id)
{
var dbOrder = await _context.Orders.FirstOrDefaultAsync(x => x.OrderId == id);
if (dbOrder == null)
{
return(null);
}
var AppOrder = new AppOrder
{
OrderId = dbOrder.OrderId,
OrdererId = dbOrder.UserId,
Date = dbOrder.Date,
Total = dbOrder.Total,
};
return(AppOrder);
}
private IAppOrder createOrder_Sell3Contract()
{
IAppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = 2;
appOrder.OrderId = 1001;
appOrder.OrderType = AppConstant.ORDER_TYPE_LIMIT;
appOrder.BuySell = AppConstant.SELL_SIGNAL;
appOrder.TotalQuantity = 3;
appOrder.LmtPrice = 23100;
appOrder.AuxPrice = 0;
appOrder.StratgeyShortName = "Test Strategy 1";
Order IBOrder = new Order();
IBOrder.OrderId = 1001;
appOrder.IBOrder = IBOrder;
return(appOrder);
}
private IAppOrder createSellOrder_10Contract_10Complete(int position, String reason, String rule)
{
IAppOrder appOrder = new AppOrder();
appOrder.StrategyIndex = 3;
appOrder.OrderId = 1002;
appOrder.OrderType = AppConstant.ORDER_TYPE_LIMIT;
appOrder.BuySell = AppConstant.SELL_SIGNAL;
appOrder.TotalQuantity = position;
appOrder.Position = 0;
appOrder.LmtPrice = 20400;
appOrder.TriggerPrice = 20400;
appOrder.AuxPrice = 0;
appOrder.TriggerRule = rule;
appOrder.Remark = reason;
appOrder.addExecution(createSellExecution10Contract());
appOrder.StratgeyShortName = "Test Strategy 1";
return(appOrder);
}
/// <summary>
/// 验证订单数据
/// </summary>
/// <param name="order">订单</param>
///<param name="user">配送员</param>
/// <remarks>2014-9-17 朱成果 创建</remarks>
private void CheckAppOrder(AppOrder order, SyUser user)
{
if (order == null || order.SoOrder == null)
{
throw new HytException("订单信息不能为空");
}
if (order.Products == null || order.Products.Count < 1)
{
throw new HytException("订购商品信息不能为空");
}
if (order.SoReceiveAddress == null)
{
throw new HytException("收货地址不能为空");
}
if (user == null)
{
throw new HytException("配送员信息不能为空");
}
if (order.SoOrder.CustomerSysNo < 1)
{
throw new HytException("购买客户信息不能为空");
}
}
/// <summary>
/// 创建二次销售订单
/// </summary>
/// <param name="order">订单信息</param>
/// <param name="user">用户信息</param>
/// <param name="hasDelivery">是否配送员立即配送</param>
/// <returns></returns>
/// <remarks>2014-9-17 朱成果 创建</remarks>
public AppOrder CreateTwoSaleSoOrder(AppOrder order, SyUser user, bool hasDelivery = true)
{
CheckAppOrder(order, user);//验证订单数据
#region 创建销售单
var payType = PaymentTypeBo.Instance.GetPaymentTypeFromMemory(order.SoOrder.PayTypeSysNo);
order.SoOrder.OnlineStatus = payType.PaymentType == (int)BasicStatus.支付方式类型.到付 ? Constant.OlineStatusType.待审核 : Constant.OlineStatusType.待支付;
order.SoOrder.Status = (int)OrderStatus.销售单状态.待审核;
order.SoOrder.PayStatus = (int)OrderStatus.销售单支付状态.未支付;
order.SoOrder.OrderCreatorSysNo = order.SoOrder.LastUpdateBy = user.SysNo;
order.SoOrder.CreateDate = order.SoOrder.LastUpdateDate = DateTime.Now;
order.SoOrder.DefaultWarehouseSysNo = BLL.Warehouse.WhWarehouseBo.Instance.GetDeliveryUserWarehouseSysNo(user.SysNo);//获取仓库信息
order.SoOrder.OrderSource = (int)OrderStatus.销售单来源.业务员下单;
order.SoOrder.OrderSourceSysNo = user.SysNo;
if (order.SoOrder.DefaultWarehouseSysNo < 1)
{
throw new HytException("配送员仓库信息获取失败");
}
var whinfo = WhWarehouseBo.Instance.GetWarehouse(order.SoOrder.DefaultWarehouseSysNo); //仓库信息
if (hasDelivery) //马上配送
{
order.SoOrder.DeliveryTypeSysNo = DeliveryType.普通百城当日达;
if (payType.PaymentType == (int)BasicStatus.支付方式类型.到付)//此情况不允许下到付订单
{
throw new HytException("此流程必须先收款。");
}
}
else//不必立刻配送
{
bool Isdrd = false;//是否满足当日达
if (whinfo != null)
{
var zb = Hyt.BLL.Map.BaiduMapAPI.Instance.Geocoder(order.SoReceiveAddress.StreetAddress, whinfo.CityName);//仓库所在城市->收货地址
if (zb != null)
{
Isdrd = LgDeliveryScopeBo.Instance.IsInScope(whinfo.CitySysNo, new Coordinate()
{
X = zb.Lng, Y = zb.Lat
}); //是否支持当日达
}
}
order.SoOrder.DeliveryTypeSysNo = Isdrd?DeliveryType.普通百城当日达:DeliveryType.第三方快递;
}
ISoReceiveAddressDao.Instance.InsertEntity(order.SoReceiveAddress); //收货地址
order.SoOrder.ReceiveAddressSysNo = order.SoReceiveAddress.SysNo; //收货地址
if (order.Invoice != null) //发票信息
{
order.Invoice.Status = FinanceStatus.发票状态.待开票.GetHashCode();
order.Invoice.CreatedBy = order.Invoice.LastUpdateBy = user.SysNo;
order.Invoice.CreatedDate = order.Invoice.LastUpdateDate = DateTime.Now;
IFnInvoiceDao.Instance.InsertEntity(order.Invoice);
order.SoOrder.InvoiceSysNo = order.Invoice.SysNo;
}
ISoOrderDao.Instance.InsertEntity(order.SoOrder); //创建订单
order.SoOrder = SoOrderBo.Instance.GetEntity(order.SoOrder.SysNo); //获取订单
foreach (var item in order.Products) //创建订单明细
{
item.OrderSysNo = order.SoOrder.SysNo;
item.TransactionSysNo = order.SoOrder.TransactionSysNo;
item.SysNo = ISoOrderItemDao.Instance.Insert(item);
}
SoOrderBo.Instance.WriteSoTransactionLog(order.SoOrder.TransactionSysNo, string.Format(Constant.ORDER_TRANSACTIONLOG_CREATE, order.SoOrder.SysNo), user.UserName);//创建订单日志
#endregion
#region 订单收款单
decimal shoupay = SoOrderBo.Instance.SynchronousOrderAmount(order.SoOrder.SysNo, true); //同步订单价格
order.SoOrder.CashPay = shoupay;
order.SoOrder.ProductChangeAmount = order.Products.Sum(m => m.ChangeAmount); //记录调价总额
Finance.FnReceiptVoucherBo.Instance.CreateReceiptVoucherByOrder(order.SoOrder); //创建订单收款单
if (payType.PaymentType == (int)BasicStatus.支付方式类型.预付)
{
var easinfo = Hyt.BLL.Finance.FnReceiptVoucherBo.Instance.GetFnReceiptTitleAssociation(order.SoOrder.DefaultWarehouseSysNo, payType.SysNo).OrderByDescending(m => m.IsDefault).FirstOrDefault();//eas信息
FnReceiptVoucherItem fvitem = new FnReceiptVoucherItem()
{
Amount = order.SoOrder.CashPay,
CreatedDate = DateTime.Now,
PaymentTypeSysNo = order.SoOrder.PayTypeSysNo,
TransactionSysNo = order.SoOrder.TransactionSysNo,
Status = (int)Hyt.Model.WorkflowStatus.FinanceStatus.收款单明细状态.效,
EasReceiptCode = easinfo == null?string.Empty:easinfo.EasReceiptCode, //eas收款科目
ReceivablesSideType = (int)Hyt.Model.WorkflowStatus.FinanceStatus.收款方类型.仓库, //收款方来源
ReceivablesSideSysNo = order.SoOrder.DefaultWarehouseSysNo,
CreatedBy = user.SysNo
};
Finance.FnReceiptVoucherBo.Instance.InsertOrderReceiptVoucher(order.SoOrder.SysNo, fvitem); //插入收款单明细
Hyt.BLL.Finance.FnReceiptVoucherBo.Instance.AutoConfirmReceiptVoucher(order.SoOrder.SysNo, user); //收现金自动确认收款单
if (order.SoOrder.PayTypeSysNo == PaymentType.现金预付)
{
InsertTwoSaleCashHistory(
new Rp_业务员二次销售()
{
CreateDate = order.SoOrder.CreateDate,
DeliveryUserSysNo = user.SysNo,
DeliveryUserName = user.UserName,
StockSysNo = whinfo.SysNo,
StockName = whinfo.WarehouseName,
OrderSysNo = order.SoOrder.SysNo,
OrderAmount = order.SoOrder.CashPay
}
);
}//二次销售收款记录
}
#endregion
//同步支付时间的到订单主表
ISoOrderDao.Instance.UpdateOrderPayDteById(order.SoOrder.SysNo);
#region 创建审单任务（可选)
if (!hasDelivery) //未配送
{
SyJobPoolPublishBo.Instance.OrderAuditBySysNo(order.SoOrder.SysNo); //创建审单任务
SyJobDispatcherBo.Instance.WriteJobLog(string.Format("二次销售下单成功创建订单审核任务，销售单编号:{0}", order.SoOrder.SysNo), order.SoOrder.SysNo, null, 0);
}
#endregion
return(order);
}
// возвращает признак того, что были сделаны какие-то изменения во внутренней коллекции заказов
private bool updateAppOrders(List <Order> orders)
{
bool retVal = false;
// признак того, что появился заказ в статусе ГОТОВ и надо проиграть мелодию
bool isCooked = false;
if ((orders == null) || (orders.Count == 0))
{
hideCells(G15); hideCells(G24);
_appOrders.Clear();
AppLib.WriteLogTraceMessage("- app-orders clear");
return(true);
}
int[] dbIds = orders.Select(o => o.Id).ToArray();
// удалить выданные заказы
int[] delIds = _appOrders.Select(o => o.Id).Except(dbIds).ToArray();
if (delIds.Length > 0)
{
foreach (int item in delIds)
{
_appOrders.RemoveAll(o => o.Id == item);
}
AppLib.WriteLogTraceMessage("- app-orders remove(ids): " + string.Join(",", delIds));
retVal = true;
}
// добавить новые
double estDT = (double)WpfHelper.GetAppGlobalValue("OrderEstimateTime", 0d);
string ordersAdded = null;
AppOrder curAppOrd;
foreach (Order dbOrd in orders)
{
curAppOrd = _appOrders.FirstOrDefault(ao => (ao.Id == dbOrd.Id));
// add new
if (curAppOrd == null)
{
AppOrder newAppOrder = new AppOrder()
{
Id = dbOrd.Id, Order = dbOrd
};
// удалить граничные пробелы из имени клиента
if (!newAppOrder.Order.ClientName.IsNull())
{
newAppOrder.Order.ClientName = newAppOrder.Order.ClientName.Trim();
}
//newAppOrder.IsExistOrderEstimateDT = (estDT != 0d);
//newAppOrder.OrderCookingBaseDT = (estDT == 0d) ? dbOrd.CreateDate : dbOrd.CreateDate.AddMinutes(estDT);
// новый заказ сразу в статусе ГОТОВ
if (dbOrd.QueueStatusId == 1)
{
isCooked = true;
}
_appOrders.Add(newAppOrder);
if (ordersAdded == null)
{
ordersAdded = dbOrd.Id.ToString();
}
else
{
ordersAdded += "," + dbOrd.Id.ToString();
}
retVal = true;
}
// update exists
else
{
// заказ поменял статус
if (curAppOrd.Order.QueueStatusId != dbOrd.QueueStatusId)
{
if (dbOrd.QueueStatusId == 1)
{
isCooked = true; // ready
}
// изменения в лог
AppLib.WriteLogTraceMessage("- app-order id {0} changing its state: {1}({2}) to {3}({4})",
dbOrd.Id, curAppOrd.Order.QueueStatusId, (OrderStatusEnum)curAppOrd.Order.QueueStatusId,
dbOrd.QueueStatusId, (OrderStatusEnum)dbOrd.QueueStatusId);
retVal = true;
}
curAppOrd.Order = dbOrd;
}
}
// в лог новые заказы
if (ordersAdded != null)
{
AppLib.WriteLogTraceMessage("- app-orders add(ids): " + ordersAdded);
}
// проиграть мелодию
if ((isCooked) && (simpleSound != null))
{
simpleSound.Play();
}
// если есть изменения
if (retVal)
{
// сортировка orderby o.CreateDate ascending, o.Number ascending
_appOrders = _appOrders.OrderBy(o => o.Order.CreateDate).ThenBy(o => o.Order.Number).ToList();
}
return(retVal);
}
/// <summary>
/// 订单对象转换
/// </summary>
/// <param name="order">wcf 传入订单对象</param>
/// <returns></returns>
/// <remarks>2014-9-17 朱成果 创建</remarks>
public AppOrder MapToAppOrder(AppOrder2 order)
{
AppOrder neworder = new AppOrder();
int levelSysNo = 0;//客户等级
if (order != null)
{
if (order.SoReceiveAddress != null)
{
neworder.SoReceiveAddress = order.SoReceiveAddress;
}
if (order.Order != null)
{
#region 订单和发票
var oo = order.Order;
neworder.SoOrder = new SoOrder()
{
CustomerSysNo = oo.CustomerSysNo,
PayTypeSysNo = oo.PayTypeSysNo,
DeliveryTypeSysNo = oo.DeliveryTypeSysNo,
DeliveryRemarks = oo.DeliveryRemarks,
DeliveryTime = oo.DeliveryTime,
ContactBeforeDelivery = oo.ContactBeforeDelivery,
InternalRemarks = oo.InternalRemarks,
CustomerMessage = oo.CustomerMessage,
CreateDate = DateTime.Now,
SalesType = (int)Hyt.Model.WorkflowStatus.OrderStatus.销售方式.普通订单
};
if (oo.Invoice != null)
{
neworder.Invoice = new FnInvoice()
{
InvoiceTypeSysNo = oo.Invoice.InvoiceTypeSysNo,
InvoiceTitle = oo.Invoice.InvoiceTitle,
InvoiceRemarks = oo.Invoice.InvoiceRemarks
};
}
#endregion
var cr = Hyt.BLL.CRM.CrCustomerBo.Instance.GetModel(order.Order.CustomerSysNo);//客户信息
if (cr != null)
{
levelSysNo = cr.LevelSysNo; //客户等级
neworder.SoOrder.LevelSysNo = levelSysNo; //下单时候的客户等级
}
}
if (order.OrderItems != null)
{
#region 订单明细
decimal amount = 0;
neworder.Products = new List <SoOrderItem>();
foreach (var p in order.OrderItems)
{
if (!CheckTwoSalePrice(p.SysNo, p.Price))
{
throw new HytException(string.Format("商品（{0}）销售价格不允许少于限定价格{1}.", p.ProductName, p.Price));
}
var pitem = new SoOrderItem()
{
Quantity = p.Quantity,
ProductSysNo = p.SysNo,
OriginalPrice = p.Price,
SalesUnitPrice = p.Price,
ProductName = p.ProductName,
ProductSalesType = (int)CustomerStatus.商品销售类型.普通,
SalesAmount = p.Price * p.Quantity,
};
if (levelSysNo > 0)
{
var originalPrice = GetProductPriceByCustomerLevel(pitem.ProductSysNo, levelSysNo); //商城原单价
pitem.OriginalPrice = originalPrice > 0 ? originalPrice : p.Price; //商城原单价
pitem.SalesUnitPrice = originalPrice > 0 ? originalPrice : p.Price; //商城销售单价;
pitem.SalesAmount = pitem.SalesUnitPrice * pitem.Quantity; //销售总额
pitem.ChangeAmount = p.Price * p.Quantity - pitem.SalesAmount; //调价金额
if (originalPrice != p.Price && neworder.SoOrder != null)
{
neworder.SoOrder.ImgFlag = MallTypeFlag.二次销售并调价;
}
}
neworder.Products.Add(pitem);
amount += pitem.SalesAmount;
}
if (neworder.SoOrder != null)
{
neworder.SoOrder.ProductAmount = neworder.SoOrder.OrderAmount = neworder.Products.Sum(m => m.SalesAmount); //总金额
neworder.SoOrder.ProductChangeAmount = neworder.Products.Sum(m => m.ChangeAmount); //调价金额
neworder.SoOrder.CashPay = neworder.SoOrder.OrderAmount + neworder.SoOrder.ProductChangeAmount; //支付金额
}
#endregion
}
}
return(neworder);
}
