public override void OnQueryTradeOrder(TradeOrderList trades)
{
Console.WriteLine("- OnQueryTradeOrder:");
for (int i = 0; i < trades.Count; i++)
{
TradeOrder trade = trades[i];
PrintTradeInfo(trade);
//ToDo ...
}
}
internal void CheckDeal(TradeOrder order) {
lock (__cGridPrices) {
Interlocked.Add(ref __iDealCount, order.Contracts);
string sName = order.Name;
if (__cGridPrices.ContainsKey(sName)) {
if (order.IsDealed) {
__cGridPrices.Remove(sName);
}
}
}
}
/// <summary>
/// 根据参数构造返回结果
/// </summary>
/// <param name="order"></param>
public PayBuyerScanDynaResponse(TradeOrder order, SxfBuildPayTokenResponse rsp)
: base(order)
{
Return_Code = PayTradeHelper.TransCodeBySxf(rsp.RspCod);
Return_Msg = rsp.RspMsg;
Sign_Type = PayConst.DEF_SIGNTYPE;
Version = PayConst.DEF_VERSION;
Out_Trade_No = rsp.PayOrderNo;
Pay_Token = rsp.PayToken;
QRCode_Url = rsp.ImageUrl;
}
public async Task <string> PutOrder(TradeOrder order, OrderType orderType, string userId)
{
var userSecret = _exchangeSecretRepository.GetByUserAndExchange(userId, _exchangeName);
var translations = await _marketDataService.GetMarketTranslationsAsync(_exchangeName);
try
{
order.Symbol = translations[order.Symbol];
return(await _binanceWrapper.PutOrder(userSecret.ApiKey, userSecret.ApiSecret, order, orderType));
}
catch { return(null); }
}
public async Task <string> PutOrder(string apiKey, string apiSecret, TradeOrder order, OrderType type)
{
var url = _baseEndpoint + "/api/v3/order";
var response = await _client.BinanceSignedRequest <BinanceOrderResult>(url, HttpMethod.Post, new Dictionary <string, string> {
{ "side", type == OrderType.Buy ? "BUY": "SELL" },
{ "symbol", order.Symbol },
{ "quantity", order.Amount.ToString() },
{ "price", order.Rate.ToString() },
{ "type", "LIMIT" }
}, apiKey, apiSecret);
return(response.orderId);
}
/// <summary>
/// 根据参数构造返回结果
/// </summary>
/// <param name="order"></param>
/// <param name="rsp"></param>
public PayMerchScanResponse(TradeOrder order, SxfScanPayResponse rsp)
: base(order)
{
Return_Code = PayTradeHelper.TransCodeBySxf(rsp.RspCod);
Return_Msg = rsp.RspMsg;
Sign_Type = PayConst.DEF_SIGNTYPE;
Version = PayConst.DEF_VERSION;
Out_Trade_No = rsp.PayOrderNo;
Receipt_Amount = PayTradeHelper.FromCent2Yuan(rsp.TxAmt);
Pay_Status = (PayTradeHelper.Convert2EnumString <PayState>(PayTradeHelper.Convert2EnumValue <SxfPayState>(rsp.PayResult))).ToUpper();
Pay_Channel = rsp.PayChannel;
}
public void Test_UpdateOrder()
{
TradeOrderBLL bll = new TradeOrderBLL(_unit);
var order = bll.GetByID(58);
TradeOrder to = new TradeOrder();
to = ObjHelper.DeepCopy(order);
to.Id = order.Id;
to.Size = 1000;
bll.UpdateOrder(to);
}
/// <summary>
/// 根据TradeOrder构造退款申请订单
/// </summary>
/// <param name="order"></param>
/// <param name="rfdNotifyUrl"></param>
public SxfRefundApplyRequest(TradeOrder order, string rfdNotifyUrl) : base(order)
{
CharSet = PayConst.SXF_DEF_CHARSET;
SignType = PayConst.SXF_DEF_SIGNTYPE;
Version = PayConst.SXF_DEF_VERSION;
Type = PayConst.SXF_TYPE_RFDAPPLY;
OutTradeNo = order.OutTradeNo;
OldOutTradeNo = order.OldOutTradeNo;
RefundAmount = Convert.ToInt32(order.TotalAmount * PayConst.YUAN_2_CENT_RATE);
RefundReason = order.RefundReason;
RfdNotifyUrl = rfdNotifyUrl;
}
/// <summary>
/// Caculate the hash of the order
/// </summary>
/// <param name="order">
/// order
/// </param>
/// <returns>
/// the hash of the order
/// </returns>
private static byte[] CalculateOrderHash(TradeOrder order)
{
var bytes = order.owner
.Concat(order.tokenS)
.Concat(order.tokenB)
.Concat(order.miner)
.Concat(order.amountS.AsByteArray())
.Concat(order.amountB.AsByteArray())
.Concat(order.lrnFee.AsByteArray())
.Concat(order.nonce.AsByteArray());
return(Hash256(bytes));
}
private void HandleSellExecution(ParentOrder parentOrder, TradeExecution execution)
{
TradeOrder order = parentOrder.GetChildOrderByID(execution.OrderID);
if (order == null)
{
Log.Error(string.Format("Cannot find trade order, orderID: {0}", execution.OrderID));
}
else
{
if (string.IsNullOrWhiteSpace(order.Notes))
{
Log.Warn("HandleSellExecution error. Cannot resolve execution level due to emtpy order notes");
}
else
{
int exeLevel = int.Parse(order.Notes);
TradeMap[exeLevel].CurrentQty -= execution.Shares;
if (TradeMap[exeLevel].CurrentQty < 0)
{
//should not hit here
Log.Error(string.Format("Negative CurrentQty detected. level: {0}, qty: {1}", exeLevel, TradeMap[exeLevel].CurrentQty));
}
if (TradeMap[exeLevel].CurrentQty <= 0)
{
if (TradeMap.ContainsKey(CurrentLevel))
{
TradeMap[CurrentLevel].WasFilledSellOnPartial = false;
TradeMap[CurrentLevel].LastBuyPrice = 0;
}
CurrentLevel--;
//TradeMap.Remove(CurrentLevel);
//for (int i = CurrentLevel + 1; i <= ScaleLevel; i++)
//{
// if (TradeMap.ContainsKey(i)) TradeMap.Remove(i);
//}
//if (CurrentLevel >= 0)
//{
// GenerateTradeMapNextLevel(TradeMap[CurrentLevel].LastBuyPrice);
//}
}
}
Log.Info("After sld execution." + Util.PrintTradeMapCurrLvl(this));
}
}
/// <summary>
/// order数据复制
/// </summary>
/// <param name="result"></param>
/// <param name="tradeorder"></param>
private void TradeOrderCopyData(TradeOrder result, View_TradeStock tradeorder)
{
#region Using All Items Replace To Update ,Default UnUse
result.CustomTid = tradeorder.CustomTid;
result.iid = tradeorder.iid;
result.sku_id = tradeorder.sku_id;
result.oid = tradeorder.oid;
result.outer_sku_id = tradeorder.outer_sku_id;
result.outer_iid = tradeorder.outer_iid;
result.sku_properties_name = tradeorder.sku_properties_name;
result.price = (double)tradeorder.price;
result.total_fee = (double)tradeorder.total_fee;
result.discount_fee = (double)tradeorder.discount_fee;
result.adjust_fee = (double)tradeorder.adjust_fee;
result.payment = (double)tradeorder.payment;
result.item_meal_name = tradeorder.item_meal_name;
result.num = (int)tradeorder.num;
result.title = tradeorder.title;
result.pic_path = tradeorder.pic_path;
result.seller_nick = tradeorder.seller_nick;
result.buyer_nick = tradeorder.buyer_nick;
result.type = tradeorder.type;
result.created = (DateTime)tradeorder.created;
result.status = tradeorder.status;
result.OrderType = tradeorder.OrderType;
result.OrderTimeStamp = tradeorder.TradeTimeStamp;
#endregion
}
public List <TradeOrder> GetMatchOrders(TradeOrder order)
{
switch (order.Type)
{
case TranType.Bid:
return(items.Where(e => e.Price <= order.Price && e.Type == TranType.Ask).ToList());
case TranType.Ask:
return(items.Where(e => e.Price >= order.Price && e.Type == TranType.Bid).ToList());
default:
return(new List <TradeOrder>());
}
}
/// <summary>
/// 取消委託中訂單
/// </summary>
/// <param name="name">下單名稱(如果 name 為 null 則取消全部委託中的訂單)</param>
/// <returns>回傳值: 取消委託中訂單的總口數</returns>
public int Cancel(string name = null)
{
int iCancelLots = 0, iDealCount = 0;
if (name == null)
{
List <TradeOrder> cTrades = __cEntrusts.Trades;
int iCount = cTrades.Count;
for (int i = iCount - 1; i >= 0; i--) //由最後一筆往前移動索引值(避免因為移除委託單導致索引指向錯誤)
{
TradeOrder cOrder = cTrades[i];
if ((cOrder.IsSended || cOrder.IsTrusted) && cOrder.Action == Info.Action && cOrder.Category == Info.Category)
{
if (cOrder.Contracts == 0)
{
++iDealCount; //當已經完成成交後, 已經沒有合約量, 但是因為還沒有經過倉部位計算, 所以還不會移除此筆委託單, 所以還是要認定此筆委託單尚未取消
}
else
{
iCancelLots += cOrder.Contracts;
if (cOrder.IsTrusted && !cOrder.IsCancel)
{
cOrder.IsCancel = __cSender.Send(cOrder, true);
}
}
}
}
}
else
{
TradeOrder cOrder = __cEntrusts.GetTradeFromName(name);
if (cOrder != null && (cOrder.IsSended || cOrder.IsTrusted) && cOrder.Action == Info.Action && cOrder.Category == Info.Category)
{
if (cOrder.Contracts == 0)
{
++iDealCount; //當已經完成成交後, 已經沒有合約量, 但是因為還沒有經過倉部位計算, 所以還不會移除此筆委託單, 所以還是要認定此筆委託單尚未取消
}
else
{
iCancelLots += cOrder.Contracts;
if (cOrder.IsTrusted && !cOrder.IsCancel)
{
cOrder.IsCancel = __cSender.Send(cOrder, true);
}
}
}
}
return((iCancelLots == 0) ? iDealCount : iCancelLots);
}
private List <Entity.Indicator> GetIndicatorsForTrade(TradeOrder order, int dateToProcess)
{
List <Entity.Indicator> iList = new List <Entity.Indicator>();
int startDate = this.GetOrderStartDate(order);
IndicatorBLL iBll = new IndicatorBLL(_unit);
iList = iBll.GetIndicatorListByShareDate(order.ShareId, startDate, dateToProcess).OrderByDescending(p => p.TradingDate).ToList();
List <Ticker> tList = new TickerBLL(_unit).GetTickerListByShareDB(order.ShareId, startDate, dateToProcess).OrderByDescending(p => p.TradingDate).ToList();
iBll.PopulateIndicatorsWithTickers(iList, tList);
return(iList.OrderBy(p => p.TradingDate).ToList());
}
public void AddChildOrder(TradeOrder tradeOrder)
{
if (!Parent_Child_Order_Map.ContainsKey(tradeOrder.ParentOrderID))
{
return;
}
lock (locker)
{
ParentOrder pOrder = GetParentOrderByParentID(tradeOrder.ParentOrderID);
pOrder.AddChildOrder(tradeOrder);
Parent_Child_Order_Map[tradeOrder.ParentOrderID].Add(tradeOrder.OrderID);
Child_Parent_Order_Map[tradeOrder.OrderID] = tradeOrder.ParentOrderID;
}
}
private TradeResult MakeMacth(TradeOrder order)
{
switch (order.Type)
{
case TranType.Bid:
var asks = TradeQueue.Instance.GetMatchOrders(order).Select(e => e as AskOrder).ToList();
return(MakeMatch(order as BidOrder, asks));
case TranType.Ask:
var bids = TradeQueue.Instance.GetMatchOrders(order).Select(e => e as BidOrder).ToList();
return(MakeMatch(order as AskOrder, bids));
default:
return(TradeResult.Fail());
}
}
//确认订单修改
private void barConfirmNumChange_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
int totalRowCount = gvGiftOrders.RowCount;//循环获取需要提交的Trade
TradeOrder orderItem = null;
WaitDialogForm waitFrm = new WaitDialogForm(Alading.Taobao.Constants.OPERATE_DB_DATA);
for (int runner = 0; runner < totalRowCount; runner++)
{
orderItem = gvGiftOrders.GetRow(runner) as Alading.Entity.TradeOrder;
TradeOrderService.UpdateTradeOrder(orderItem);
}
waitFrm.Close();
InitTradeList();
XtraMessageBox.Show("保存修改成功！");
}
/// <summary>
/// 根据TradeOrder构造Sxf主扫支付动态支付订单
/// </summary>
/// <param name="order"></param>
public SxfBuildPayTokenRequest(TradeOrder order, string payNotifyUrl) : base(order)
{
CharSet = PayConst.SXF_DEF_CHARSET;
SignType = PayConst.SXF_DEF_SIGNTYPE;
Version = PayConst.SXF_DEF_VERSION;
Type = PayConst.SXF_TYPE_BUILDPAYTOKEN;
PayOrderNo = order.OutTradeNo;
TxDate = order.CreateDT.ToString("yyyyMMdd");
TxAmt = PayTradeHelper.FromYuan2Cent(order.TotalAmount);
UserMobile = order.BuyerMobile;
PayNotifyUrl = payNotifyUrl;
OrderType = PayConst.SXF_DEF_ORDERTYPE;
GoodsName = order.GoodsName;
GoodDesc = order.GoodsDesc;
}
public NotifyRefundRequest(TradeOrder order, TradeResult result)
{
Charset = PayConst.DEF_CHARSET;
Mch_Id = order.CID;
Store_Id = order.SID;
Device_Id = order.DeviceId;
Sign_Type = PayConst.SXF_DEF_SIGNTYPE;
Version = PayConst.DEF_VERSION;
Method = PayConst.QCTTRADE_NOTIFY_REFUND;
Out_Trade_No = result.OutTradeNo;
Refund_Amount = result.ReceiptAmount;
Refund_Status = (PayTradeHelper.Convert2EnumString <RefundState>(result.TradeState)).ToUpper();
Pay_Channel = PayTradeHelper.Convert2EnumString <PayChannel>(result.PayChannel).ToUpper();
Refund_Date = PayTradeHelper.Convert2DateFormat(result.TradeDate, result.TradeTime, "yyyy-MM-dd HH:mm:ss");
}
internal TradeOrder GetChildOrderByID(int ID)
{
TradeOrder res = null;
lock (locker)
{
foreach (var order in TradeOrders)
{
if (order.OrderID == ID)
{
res = order;
break;
}
}
}
return(res);
}
/// <summary>
/// 傳送下單命令
/// </summary>
/// <param name="trust">交易訂單資訊</param>
/// <param name="isCancel">是否要取消此交易訂單(成功委託才能取消訂單)</param>
/// <returns>返回值: true=成功, false=失敗</returns>
bool IOrderSender.Send(TradeOrder trust, bool isCancel) {
if (isCancel) {
string[] sNames = trust.Name.Split('|');
_Truster cTruster = null;
lock (__cTrusts) {
__cTrusts.TryGetValue(sNames[0], out cTruster);
}
if (cTruster != null && !cTruster.IsCancel) {
cTruster.Cancel();
}
return base.SendTrust(trust, true);
} else {
return base.SendTrust(trust, false);
}
}
/// <summary>
/// 傳送下單命令
/// </summary>
/// <param name="action">下單進出場動作</param>
/// <param name="category">下單類型</param>
/// <param name="limitPrice">限價價格(市價=0)</param>
/// <param name="lots">下單數量</param>
/// <param name="isReverse">是否需反轉倉位</param>
/// <param name="touchPrice">觸發或停損價格</param>
/// <param name="name">下單註解</param>
/// <param name="openNextBar">是否開倉在下一根 Bars</param>
public bool Send(EOrderAction action, OrderCategory category, double limitPrice, int lots, bool isReverse, double touchPrice = 0, string name = null, bool openNextBar = false) {
limitPrice = Math.Round(limitPrice, __iDecimalPoint);
TradeOrder cTrust = __cEntrusts.GetTradeFromName(name);
if (cTrust != null) {
if (openNextBar) {
__cNextBarRequires.Add(name); //標記 NextBar 時, 可以下單
return true;
} else {
if (cTrust.Price == limitPrice) { //委託價格一樣就忽略
return false;
} else {
if (cTrust.IsTrusted && !cTrust.IsDealed) { //如果已經委託完成且尚未成交就取消單號
this.SendCancel(cTrust);
} else { //如果還沒有委託成功
return false; //直接離開(可能需要等到委託成功之後才能處理)
}
}
}
}
TradeOrder cOrder = new TradeOrder(); //建立預約委託單的資訊
cOrder.Action = action;
cOrder.BarNumber = Bars.CurrentBar;
cOrder.Category = category;
cOrder.Contracts = lots;
cOrder.Name = name;
cOrder.Price = limitPrice;
cOrder.IsReverse = isReverse;
cOrder.SymbolId = Bars.Request.Symbol;
cOrder.Time = Bars.Time.Value;
cOrder.Ticket = (openNextBar) ? name : GetTrustID();
__cEntrusts.Add(cOrder); //加入至委託列表內
if (openNextBar) { //如果需要在下一根 Bars 下單, 就先保留 name 在佇列, 以方便比對委託單
__cReserves.Enqueue(name);
__cNextBarRequires.Add(name);
} else {
if (isReverse) { //如果有反轉倉單
CancelLimit(action); //取消所有反向之前的限價委託單
}
this.SendTrust(cOrder); //傳送新委託單(模擬成交)
}
return true;
}
//保存修改
private void BtnModify_Click(object sender, EventArgs e)
{
DialogResult result = DialogResult.OK;
if (!Alading.Utils.SystemHelper.CompareTimeStamp(_orderTimeStamp as byte[], _tradeStock.OrderTimeStamp))
{
result = XtraMessageBox.Show("当前订单已经被修改,继续修改(OK)/查看流程信息(Canel)", "订单修改", MessageBoxButtons.OKCancel);
}
if (result == DialogResult.OK)
{
string skuProsName = cmbProperties.Text.ToString();//取得选中sku_pros
TradeOrder order = TradeOrderService.GetTradeOrder(p => p.TradeOrderCode == _tradeStock.TradeOrderCode).FirstOrDefault();
if (order.sku_properties_name != skuProsName) //的的确确修改订单信息才提交笔生成流程信息
{
//创建一条交易信息
string flowMeassge = "商品\"" + _tradeStock.title + "\"销售属性修改:" + order.sku_properties_name + "-->" + skuProsName;
SystemHelper.CreateFlowMessage(_tradeStock.CustomTid, "订单信息修改", flowMeassge, "订单管理");
order.sku_properties_name = skuProsName;
#region 保存修改信息到数据库和并同步到淘宝
WaitDialogForm wdf = new WaitDialogForm(Alading.Taobao.Constants.OPERATE_TBDB_DATA);
try
{
UpdateTaobaoOrder();
TradeOrderService.UpdateTradeOrder(order);
wdf.Close();
XtraMessageBox.Show("修改订单信息成功！");
}
catch (Exception ex)
{
wdf.Close();
XtraMessageBox.Show("将修改信息保存到淘宝失败，修改无效！原因:" + ex.Message);
}
#endregion
}
else
{
result = DialogResult.Ignore; //实际什么都没做，不需要更新数据库时间戳
}
}
//如果在主界面接受到的结果为Dialog.Canel，则跳转流程信息页面。如果是Dialog.OK则修改界面信息，Dialog.Ignore不做
this.DialogResult = result;
this.Close();
}
/// <summary>
/// 创建生成退款通知
/// </summary>
/// <param name="reqModel"></param>
/// <returns></returns>
public override SxfPayReturn Build(SxfRefundNotifyRequest reqModel)
{
TradeOrder tradeOrder = null;
var rfdTradeResult = new TradeResult(reqModel);
//保存通知结果并更改TradeOrder状态
var success = PaySvc.SaveMchTradeResult(rfdTradeResult, out tradeOrder);
if (!success)
{
return(SxfPayReturn.Fail(msg: "数据接收失败"));
}
else
{
var rfdNotify = new NotifyRefundRequest(tradeOrder, rfdTradeResult);
var rfdNotifyDic = PaySignHelper.ToASCIIDictionary(rfdNotify);
return(SendPost(PayConst.QCTTRADE_NOTIFY_REFUND, rfdNotifyDic, tradeOrder.CID, tradeOrder.RfdNotifyUrl));
}
}
/// <summary>
/// 根据TradeOrder构造Sxf被扫支付订单
/// </summary>
/// <param name="order"></param>
/// <param name="payNotifyUrl"></param>
public SxfScanPayRequest(TradeOrder order, string payNotifyUrl) : base(order)
{
CharSet = PayConst.SXF_DEF_CHARSET;
SignType = PayConst.SXF_DEF_SIGNTYPE;
Version = PayConst.SXF_DEF_VERSION;
Type = PayConst.SXF_TYPE_SCANPAY;
PayOrderNo = order.OutTradeNo;
TxDate = order.CreateDT.ToString("yyyyMMdd");
UserPayToken = order.BuyerPayToken;
TxAmt = Convert.ToInt32(order.TotalAmount * PayConst.YUAN_2_CENT_RATE);
UserPayToken = order.BuyerPayToken;
UserMobile = order.BuyerMobile;
PayNotifyUrl = payNotifyUrl;
OrderType = PayConst.SXF_DEF_ORDERTYPE;
GoodsName = order.GoodsName;
GoodDesc = order.GoodsDesc;
}
public AccountBalance ApplyEntryTransaction(Transaction tr, TradeOrder order, TradePosition tp)
{
AccountBalance ab = null;
TradeOrderBLL toBll = new TradeOrderBLL(_unit);
ab = this.GetAccountBalanceByAccount(order.AccountId);
if (ab != null)
{
ab.FeeSum += tr.Fee;
ab.TradingDate = tr.TradingDate;
ab.UpdateDT = DateTime.Now;
}
this.Update(ab);
return(ab);
}
private void HandleBuyExecution(ParentOrder parentOrder, TradeExecution execution)
{
/*
* check if buy execution create new tradeMap entry
* 1.curr level =-1;
* 2. Curre level filled and next level exist
* 3. curr level partial filled but wasfilled and next level exist
* 4. curr level is zero and partial filled and buyback enabled
*
* */
TradeOrder order = parentOrder.GetChildOrderByID(execution.OrderID);
if (order == null)
{
Log.Error(string.Format("Cannot find trade order, orderID: {0}", execution.OrderID));
}
else
{
int exeLevel = int.Parse(order.Notes);
TradeMap[exeLevel].CurrentQty += execution.Shares;
if (TradeMap[exeLevel].CurrentQty > TradeMap[exeLevel].TargetQty)
{
//should not hit here
Log.Error(string.Format("Overbot Qty detected. level: {0}, qty: {1}, target qty: {2}",
exeLevel, TradeMap[exeLevel].CurrentQty, TradeMap[exeLevel].TargetQty));
}
TradeMap[exeLevel].LastBuyPrice = execution.Price;
//TradeMap[exeLevel].TargetSellPrice = (exeLevel == 0) ? int.MaxValue : TradeMap[exeLevel - 1].LastBuyPrice;
CurrentLevel = Math.Max(CurrentLevel, exeLevel);
if (TradeMap[CurrentLevel].Filled)
{
TradeMap[CurrentLevel].WasFilledSellOnPartial = true;
//GenerateTradeMapNextLevel(TradeMap[CurrentLevel].LastBuyPrice);
}
Log.Info("After bot execution." + Util.PrintTradeMapCurrLvl(this));
}
}
public Transaction CreateTransaction(TradeOrder order, Entity.Indicator ind)
{
Share s = new ShareBLL(_unit).GetByID(order.ShareId);
Transaction tr = new Transaction
{
Direction = order.Direction,
Message = string.Format("{0} {1} * {2} @ ${3}", order.Direction, s.Symbol, order.Size, order.OrderPrice),
ModifiedBy = order.UpdatedBy,
ModifiedDate = DateTime.Now,
Price = order.OrderPrice,
Size = order.Size,
Fee = order.Fee,
TradingDate = ind.TradingDate,
TradeOrderId = order.Id
};
this.Create(tr);
return(tr);
}
/// <summary>
/// 保存购买者付款扫码返回结果
/// </summary>
/// <param name="tradeResult"></param>
/// <param name="tradeOrder"></param>
/// <returns></returns>
public bool SaveMchTradeResult(TradeResult tradeResult, out TradeOrder tradeOrder)
{
tradeOrder = null;
var result = false;
var tradeResultObj = _tradeResultRepost.GetQuery(o => o.OutTradeNo == tradeResult.OutTradeNo && o.MchId3 == tradeResult.MchId3 && o.StoreId3 == tradeResult.StoreId3).FirstOrDefault();
using (var trans = new EFDbContext().Database.BeginTransaction())
{
try
{
if (tradeResultObj != null)
{
tradeResult.ToCopyProperty(tradeResultObj, new List <string>()
{
"CreateDT", "OutTradeNo", "Id", "MchId3", "StoreId3"
});
}
else
{
_tradeResultRepost.Add(tradeResult);
}
//变更TradeOrder数据状态
tradeOrder = _tradeOrderRepost.GetQuery(o => o.OutTradeNo == tradeResult.OutTradeNo && o.MchId3 == tradeResult.MchId3 && o.StoreId3 == tradeResult.StoreId3).FirstOrDefault();
tradeOrder.ReceiptAmount = tradeResult.ReceiptAmount;
tradeOrder.TradeNo3 = tradeResult.TradeNo3;
tradeOrder.State = tradeResult.TradeState;
tradeOrder.TradeDate = tradeResult.TradeDate;
tradeOrder.TradeTime = tradeResult.TradeTime;
tradeOrder.UpdateDT = DateTime.Now;
tradeOrder.PayChannel = tradeResult.PayChannel;
result = _tradeResultRepost.SaveChanges();
var result1 = _tradeOrderRepost.SaveChanges();
}
catch (Exception ex)
{
trans.Rollback();//回滚事务
_logEngine.WriteError(string.Format("保存后台结果通知并更新状态异常执行回滚操作：{0}，参数：{1}，异常信息：{2}", tradeResult.OutTradeNo, tradeResult.ToJson(), ex.Message), ex, LogModule.支付交易);
result = false;
}
}
return(result);
}
/// <summary>
/// 用于还原合并但
/// </summary>
/// <param name="combineCode">副交易的CustomTid</param>
/// <returns></returns>
public ReturnType Update_TradeOrder(string combineCode)
{
try
{
using (AladingEntities alading = new AladingEntities(AppSettings.GetConnectionString()))
{
/*删除订单副本*/
List <Alading.Entity.TradeOrder> tradeOrderList = alading.TradeOrder.Where(q => q.CustomTid == combineCode).ToList();
foreach (Alading.Entity.TradeOrder tradeOrder in tradeOrderList)
{
TradeOrder order = alading.TradeOrder.Where(q => q.TradeOrderCode == tradeOrder.TradeOrderCode).FirstOrDefault();
alading.DeleteObject(order);
}/*foreach*/
/*修改子交易LocalStatus*/
List <Alading.Entity.Trade> tradeList = alading.Trade.Where(q => q.CombineCode == combineCode).ToList();
foreach (Alading.Entity.Trade trade in tradeList)
{
if (alading.Trade.Where(q => q.CustomTid == trade.CustomTid).FirstOrDefault() != null)
{
Trade tradeDb = alading.Trade.Where(q => q.CustomTid == trade.CustomTid).FirstOrDefault();
tradeDb.LocalStatus = LocalTradeStatus.HasNotSummit;
tradeDb.CombineCode = string.Empty;
}
}/*foreach*/
//删除父交易
if (alading.Trade.Where(q => q.CustomTid == combineCode).FirstOrDefault() != null)
{
Alading.Entity.Trade fatherTrade = alading.Trade.Where(q => q.CustomTid == combineCode).FirstOrDefault();
alading.DeleteObject(fatherTrade);
}
alading.SaveChanges();
return(ReturnType.Success);
}
}
catch (System.Exception ex)
{
throw ex;
}
}
/// <summary>
/// Convert TradeOrder to MarketOrdersData
/// </summary>
/// <param name="order">TradeOrder</param>
/// <returns>MarketOrdersData</returns>
internal static MarketOrderData ToMarketOrderData(TradeOrder order)
{
return new MarketOrderData
{
OccupiedDeposit = order.OccMoney,
OrderID = order.OrderId,
OrderPrice = order.OrderPrice,
OrderQuantity = order.UseQuantity,
OrderTime = order.OrderTime,
OrderType = (TRANSACTION_TYPE)Enum.Parse(typeof(TRANSACTION_TYPE), order.OrderType),
ProductCode = order.ProductCode,
ProductName = order.ProductName,
RemainingQuantity = order.UseQuantity,
StopLoss = order.LossPrice,
StopProfit = order.ProfitPrice,
StorageFee = order.StorageFee,
TradeAccount = order.TradeAccount,
TradeFee = order.TradeFee,
AllowStore = order.AllowStore,//马友春
TotalWeight = order.TotalWeight,
};
}
public void SelectTradeOrderFromUI(int id)
{
if (availableOrders.ContainsKey(id))
{
if (selectedTradeOrder == availableOrders[id])
{
// This means we clicked on it a second time which means we should add it to active
AcceptTradeOrder(id);
}
else
{
selectedTradeOrder = availableOrders[id];
// First time player clicks on Order, display its info through UI
DisplayTradeOrderInfo();
}
}
else if (activeOrders.ContainsKey(id))
{
selectedTradeOrder = activeOrders[id];
DisplayTradeOrderInfo();
}
}
