public static QuickFix.Fields.Side c(OrderAction s)
{
var val = s_sides.Find(v => v.second == s);
if (val == null)
throw new Exception("Unmapped OrderAction value : " + s.ToString());
return val.first;
}
public static MarketOrder Create(string traderId, string asset, string baseCurrency, OrderAction action, double volume)
{
return new MarketOrder
{
TraderId = traderId,
Asset = asset,
Action = action,
Volume = volume,
BaseCurrency = baseCurrency
};
}
public static void FromFIX_SendOrder(OrderFixBridge orderFixBridge, string instrumentId, OrderAction orderAction, OrderType orderType, int quantity, double limitPrice, double stopPrice, string signalName)
{
lock (locker_)
{
MarketDataDef mdd = s_fixConnectors.GetMarketDataDefForSymbol(instrumentId);
if (mdd == null)
{
throw new Exception("No FixConnector available for symbol to create order on '" + instrumentId + "'.");
}
mdd.fixConnector.FromFIX_SendOrder(orderFixBridge, mdd.internal_barinprogress, orderAction, orderType, quantity, limitPrice, stopPrice, signalName);
}
}
public abstract List <TEntity> GetAllList(Expression <Func <TEntity, bool> > predicate, OrderAction <TEntity> orderAction = null, params Expression <Func <TEntity, dynamic> >[] eagerLoadingProperties);
private static OrderBL NewMarketOrder(String accountId, OrderAction type, String ticker, int quantity)
{
return(new OrderBL(accountId, type, ticker, OrderType.OrderMarket, quantity,
0, OrderTimeInForce.OrderDay));
}
private void Refresh(int waitmillisecond = 0, List <CellInfo> cells = null, FightStadus fightStadus = FightStadus.prop_refresh)
{
bool hasRefresh = false;
rootAction = new OrderAction();
ParallelAction scale1 = new ParallelAction();
ParallelAction movos = new ParallelAction();
ParallelAction scale2 = new ParallelAction();
if (cells == null)
{
for (int i = 0; i < CellModel.Instance.allCells.Count; i++)
{
List <CellInfo> xCells = CellModel.Instance.allCells[i];
for (int j = 0; j < xCells.Count; j++)
{
CellInfo cellInfo = xCells[j];
CoverInfo coverInfo = CoverModel.Instance.GetCoverByPos(cellInfo.posY, cellInfo.posX);
if (cellInfo.isBlank == false && cellInfo.config.cell_type == (int)CellType.five && coverInfo.IsNull())
{
hasRefresh = true;
FightCellItem item = GetItemByRunId(cellInfo.runId);
if (fightStadus == FightStadus.changer)
{
item.transform.localRotation = Quaternion.identity;
scale1.AddNode(new RoatateActor((RectTransform)item.transform, new Vector3(0, 0, 180), 0.2f));
}
else
{
scale1.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.3f));
}
if (fightStadus == FightStadus.changer)
{
scale2.AddNode(new RoatateActor((RectTransform)item.transform, new Vector3(0, 0, 360), 0.2f));
}
else
{
Vector2 toPos = PosUtil.GetFightCellPos(cellInfo.posX, cellInfo.posY);
movos.AddNode(new MoveActor((RectTransform)item.transform, new Vector3(toPos.x, toPos.y, 0), 0, 0.1f));
scale2.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(1, 1, 1), 0.3f));
}
}
}
}
}
else
{
for (int j = 0; j < cells.Count; j++)
{
CellInfo cellInfo = cells[j];
if (cellInfo.isBlank == false && cellInfo.config.cell_type == (int)CellType.five)
{
hasRefresh = true;
FightCellItem item = GetItemByRunId(cellInfo.runId);
if (fightStadus == FightStadus.changer)
{
item.transform.localRotation = Quaternion.identity;
scale1.AddNode(new RoatateActor((RectTransform)item.transform, new Vector3(0, 0, 180), 0.2f));
}
else
{
scale1.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.3f));
}
if (fightStadus == FightStadus.changer)
{
scale2.AddNode(new RoatateActor((RectTransform)item.transform, new Vector3(0, 0, 360), 0.2f));
}
else
{
Vector2 toPos = PosUtil.GetFightCellPos(cellInfo.posX, cellInfo.posY);
movos.AddNode(new MoveActor((RectTransform)item.transform, new Vector3(toPos.x, toPos.y, 0), 0, 0.1f));
scale2.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(1, 1, 1), 0.3f));
}
}
}
}
if (waitmillisecond > 0)
{
rootAction.AddNode(new WaitActor(waitmillisecond));
}
if (hasRefresh)
{
rootAction.AddNode(new PlaySoundActor("Refresh"));
}
rootAction.AddNode(scale1);
rootAction.AddNode(movos);
rootAction.AddNode(scale2);
ExecuteAction(fightStadus);
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='assetIdTo'>
/// </param>
/// <param name='orderAction'>
/// Possible values include: 'Buy', 'Sell'
/// </param>
/// <param name='assetsFrom'>
/// </param>
public static IList <ConversionResult> ApiRateCalculatorGetMarketAmountInBaseByAssetIdToByOrderActionPost(this IRateCalculatorAPI operations, string assetIdTo, OrderAction orderAction, IList <AssetWithAmount> assetsFrom = default(IList <AssetWithAmount>))
{
return(operations.ApiRateCalculatorGetMarketAmountInBaseByAssetIdToByOrderActionPostAsync(assetIdTo, orderAction, assetsFrom).GetAwaiter().GetResult());
}
/// <summary>
/// 每小时检索待付款以及待收货的订单并且判断是否修改状态
/// </summary>
/// <param name="context"></param>
/// <param name="scope"></param>
/// <returns></returns>
protected override Task Execute(IJobExecutionContext context, IScope scope)
{
var orders = scope.Resolve <IOrderService>()
.GetListExtension(u =>
u.OrderStatus == OrderStatus.WaitingBuyerPay || u.OrderStatus == OrderStatus.WaitingReceiptProduct);
if (orders.Count > 0)
{
var orderConfig = scope.Resolve <IAutoConfigService>().GetValue <OrderConfig>();
foreach (var item in orders)
{
var ts = DateTime.Now.Subtract(item.CreateTime);
if (item.OrderExtension == null || item.OrderExtension.ProductSkuItems == null)
{
continue;
}
//待付款定时关闭
if (item.OrderStatus == OrderStatus.WaitingBuyerPay)
{
if (ts.Hours >= orderConfig.OrderClosedHour)
{
item.OrderStatus = OrderStatus.Closed;
#region 根据订单内商品 增加对应库存
//先获取skuId的list
var skuList = new List <long>();
foreach (var view in item.OrderExtension.ProductSkuItems)
{
skuList.Add(view.ProductSkuId);
}
//根据获取的skulist来获取数据 减少循环数量
var productSkus = scope.Resolve <IProductSkuService>().GetList(skuList);
foreach (var view in productSkus)
{
var buyCount =
item.OrderExtension.ProductSkuItems.FirstOrDefault(u => u.ProductSkuId == view.Id)
.BuyCount;
var stock = view.Stock + buyCount;
view.Stock = stock;
scope.Resolve <IProductSkuService>().Update(view);
}
#endregion 根据订单内商品 增加对应库存
scope.Resolve <IOrderService>().Update(item);
var orderAction = new OrderAction
{
Intro = "买家未在指定时间内付款，系统已关闭订单",
OrderId = item.Id,
ActionUserId = item.UserId,
OrderActionType = OrderActionType.AdminClose
};
scope.Resolve <IOrderActionService>().Add(orderAction);
}
}
//待收货定时确认收货
if (item.OrderStatus == OrderStatus.WaitingReceiptProduct)
{
if (ts.Days >= orderConfig.OrderTakeDay)
{
item.OrderStatus = OrderStatus.WaitingEvaluated;
scope.Resolve <IOrderService>().Update(item);
var orderAction = new OrderAction
{
Intro = "买家15天内未确认收货，系统已自动确认收货",
OrderId = item.Id,
ActionUserId = item.UserId,
OrderActionType = OrderActionType.AdminClose
};
scope.Resolve <IOrderActionService>().Add(orderAction);
}
}
}
}
return(Task.FromResult(true));
}
private void MakeOrder(OrderType orderType, OrderAction orderAction)
{
Contract contract = new Contract();
IBApi.Order order = new IBApi.Order();
switch (orderType)
{
case OrderType.MTL:
// AUC
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderAuction orderAuction = new OrderAuction();
orderAuction.Action = orderAction;
orderAuction.LimitPrice = 10;
orderAuction.Quantity = 1;
order = orderAuction.GetOrder;
break;
case OrderType.MKT:
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderMarket orderMarket = new OrderMarket();
orderMarket.Action = orderAction;
orderMarket.Quantity = 1;
orderMarket.TimeInForce = OrderTimeInForce.GTC;
order = orderMarket.GetOrder;
break;
case OrderType.LMT:
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderLimit orderLimit = new OrderLimit();
orderLimit.Action = orderAction;
orderLimit.LimitPrice = 10;
orderLimit.Quantity = 1;
orderLimit.TimeInForce = OrderTimeInForce.GTC;
order = orderLimit.GetOrder;
break;
}
manager.SubmitOrder(contract, order);
}
private async void PlaceOrder(OrderAction action)
{
if (this.SelectedOrderType == OrderType.Limit && !this.LimitPrice.HasValue)
{
this.SetFieldError(true, "LimitPrice");
return;
}
if (this.SelectedOrderType == OrderType.Stop && !this.StopPrice.HasValue)
{
this.SetFieldError(true, "StopPrice");
return;
}
this.cancellationTokenSource = new CancellationTokenSource();
var searchRequest = new SearchRequest{NumberOfResults = 1};
if (this.Ticker.Length == 7 && this.Ticker[3] == '.')
{
searchRequest.LocalSymbol = this.Ticker;
searchRequest.SecurityType = SecurityType.CASH;
}
else
{
searchRequest.Symbol = this.Ticker;
}
Contract contract;
try
{
contract = (await this.client.FindContracts(searchRequest,
this.cancellationTokenSource.Token)).First();
}
catch (IbException)
{
this.SetFieldError(true, "Ticker");
return;
}
try
{
var orderParams = new OrderParams
{
Contract = contract,
LimitPrice = this.LimitPrice,
OrderAction = action,
OrderType = this.SelectedOrderType,
Quantity = this.Quantity,
StopPrice = this.StopPrice,
};
var account = this.client.Accounts.First(acc => acc.AccountId == this.SelectedAccount);
await account.PlaceOrder(orderParams, this.cancellationTokenSource.Token);
}
catch (IbException)
{
}
}
protected void Page_Load(object sender, System.EventArgs e)
{
base.NeedLogin = true;
base.ReturnUrl = base.Request.RawUrl;
if (base.IsPost)
{
this.Action = WebUtils.GetFormString("action").ToLower();
OrdersInfo dataById = Orders.GetDataById(WebUtils.GetFormInt("oid"));
if (!string.IsNullOrEmpty(this.Action) && dataById != null)
{
string action = this.Action;
if (action != null)
{
if (!(action == "sign"))
{
if (!(action == "cancel"))
{
if (action == "delete")
{
if (dataById != null && dataById.OrderStatus >= 99)
{
Orders.Delete(dataById.AutoID);
OrderItem.DeleteItemByOrderID(dataById.AutoID);
base.WriteJsonTip(true, base.GetCaption("OperationSuccess"), UrlRewrite.Get("myorders_url"));
}
else
{
base.WriteJsonTip(base.GetCaption("Order_StatusIncorrect"));
}
}
}
else if (dataById != null && dataById.OrderStatus <= 1)
{
System.Collections.Generic.IList <OrderItemInfo> listByOID = OrderItem.GetListByOID(dataById.AutoID);
if (listByOID.Count > 0)
{
foreach (OrderItemInfo current in listByOID)
{
Orders.ReBackStock(Product.GetDataById(current.ProID), GoodsSpecify.Get(current.ProID, current.GuiGePath), current.Quantity);
}
}
OrderAction.AddLog(dataById, base.UserName, "会员[" + base.UserName + "]取消了订单");
base.WriteJsonTip(true, base.GetCaption("OperationSuccess"), UrlRewrite.Get("myorders_url"));
}
else
{
base.WriteJsonTip(base.GetCaption("Order_StatusIncorrect"));
}
}
else if (dataById != null && dataById.OrderStatus == 11)
{
dataById.GoodsServedTime = System.DateTime.Now;
dataById.OrderFinishTime = System.DateTime.Now;
dataById.OrderStatus = 99;
if (Orders.Update(dataById))
{
OrderAction.AddLog(dataById, base.UserName, "会员[" + base.UserName + "]签收了订单");
base.WriteJsonTip(true, base.GetCaption("OperationSuccess"), UrlRewrite.Get("myorders_url"));
}
else
{
base.WriteJsonTip(base.GetCaption("Order_StatusIncorrect"));
}
}
else
{
base.WriteJsonTip(base.GetCaption("Order_StatusIncorrect"));
}
}
}
}
else
{
Orders.CancelExpireOrder(base.UserID);
Orders.AutoSignOrder(base.UserID);
this.Condition = this.Condition + " 1=1 AND UserID=" + base.UserID.ToString();
System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
System.DateTime dateTime = WebUtils.GetQueryDatetime("filter_dtstart");
System.DateTime dateTime2 = WebUtils.GetQueryDatetime("filter_dtend");
if (dateTime == new System.DateTime(1900, 1, 1))
{
dateTime = System.DateTime.Now.AddYears(-1);
}
if (dateTime2 == new System.DateTime(1900, 1, 1))
{
dateTime2 = System.DateTime.Now;
}
if (dateTime2 < dateTime)
{
dateTime2 = dateTime.AddMonths(1);
}
if (dateTime2 > dateTime.AddYears(5))
{
dateTime2 = dateTime.AddYears(5);
this.Alert("仅允许查询5年之内的数据");
}
int queryInt = WebUtils.GetQueryInt("filter_status", -1);
int queryInt2 = WebUtils.GetQueryInt("filter_ordertype", -1);
string queryString = WebUtils.GetQueryString("filter_searchkey");
base.Put("filter_dtstart", dateTime.ToString("yyyy-MM-dd"));
base.Put("filter_dtend", dateTime2.ToString("yyyy-MM-dd"));
base.Put("filter_status", queryInt);
base.Put("filter_ordertype", queryInt2);
base.Put("filter_searchkey", queryString);
stringBuilder.Append(string.Concat(new string[]
{
" AND OrderAddTime between CONVERT(datetime,'",
dateTime.ToString("yyyy-MM-dd"),
" 00:00:00') and CONVERT(datetime,'",
dateTime2.ToString("yyyy-MM-dd"),
" 23:59:59') "
}));
if (queryInt != -1)
{
if (queryInt == 12)
{
stringBuilder.Append(" AND OrderStatus>11 and OrderStatus<=99 and exists(select 1 from shop_OrderItem where OrderID=shop_Orders.AutoID and IsEva=0) ");
}
else
{
stringBuilder.Append(" AND OrderStatus= " + queryInt);
}
}
if (queryInt2 != -1)
{
stringBuilder.Append(" AND OrderType= " + queryInt2);
}
if (!string.IsNullOrEmpty(queryString))
{
stringBuilder.Append(" AND OrderNo like '%" + queryString + "%' ");
}
this.Condition += stringBuilder.ToString();
this.UrlPattern = string.Concat(new object[]
{
UrlRewrite.Get("myorders_url"),
"?filter_dtstart=",
dateTime.ToString("yyyy-MM-dd"),
"&filter_dtend=",
dateTime2.ToString("yyyy-MM-dd"),
"&filter_status=",
queryInt,
"&filter_ordertype=",
queryInt2,
"&filter_searchkey=",
queryString,
"&page=$page"
});
OrderStatusSTAT orderStatusSTAT = new OrderStatusSTAT(base.UserID);
base.Put("AllCount", orderStatusSTAT.AllCount);
base.Put("DaiFKCount", orderStatusSTAT.WaitPayCount);
base.Put("DaiFHCount", orderStatusSTAT.WaitSendGoodsCount);
base.Put("DaiSHCount", orderStatusSTAT.WaitSignGoodsCount);
base.Put("DaiPJCount", orderStatusSTAT.WaitEvaCount);
base.Put("SuccessCount", orderStatusSTAT.SuccessCount);
base.AutoPageing <OrdersInfo>(new OrdersInfo());
base.UsingClient("user/我的订单.html");
}
}
/// <summary>
/// Initializes a new instance of the StopLimitOrderRequest class.
/// </summary>
/// <param name="orderAction">Possible values include: 'Buy',
/// 'Sell'</param>
public StopLimitOrderRequest(string assetPairId, double volume, double lowerLimitPrice, double lowerPrice, double upperLimitPrice, double upperPrice, OrderAction orderAction)
{
AssetPairId = assetPairId;
Volume = volume;
LowerLimitPrice = lowerLimitPrice;
LowerPrice = lowerPrice;
UpperLimitPrice = upperLimitPrice;
UpperPrice = upperPrice;
OrderAction = orderAction;
CustomInit();
}
/// <summary>
/// Get the last signal before barNo by OrderActionType
/// </summary>
/// <param name="barNo"></param>
/// <param name="signalActionType"></param>
/// <returns></returns>
public TradeSignal GetLastTradeSignalByActionType(int barNo, SortedDictionary <int, List <TradeSignal> > listSignals, OrderAction ord_actiontype)
{
int k = barNo;
foreach (int kk in listSignals.Keys.Reverse())
{
if (kk < k)
{
Print(CurrentBar + ": kk,k=" + kk + "," + k);
TradeSignal sig = GetTradeSignalByActionType(k, listSignals, ord_actiontype);
if (sig != null)
{
return(sig);
}
k = kk;
}
}
return(null);
}
public FakeOrderForRejectReport(int qty, OrderAction side)
{
m_qty = qty;
m_side = side;
}
public void FromFIX_SendOrder(NinjaTrader_FixBridge.OrderFixBridge orderFixBridge, int index, OrderAction orderAction, OrderType orderType, int quantity, double limitPrice, double stopPrice, string signalName)
{
lock (locker_)
{
try
{
orderFixBridge.Order = this.SubmitOrder(index, orderAction, orderType, quantity, limitPrice, stopPrice, string.Empty, signalName);
}catch(Exception e)
{
orderFixBridge.Order = null;
this.Error("[FromFIX_SendOrder]", e.ToString());
}
}
}
public virtual PagedResult <TEntity> GetPaged(int pageNumber, int pageSize, OrderAction <TEntity> orderAction, params Expression <Func <TEntity, dynamic> >[] eagerLoadingProperties)
{
return(GetPaged(pageNumber, pageSize, null, orderAction, eagerLoadingProperties));
}
private void order_Click(object sender, RoutedEventArgs e)
{
if (instrumentSelector.Instrument == null)
{
Console.WriteLine("Select an Instrument");
return;
}
string Btn = (sender as Button).Name;
Order entryOrder;
OrderAction orderAction = OrderAction.Buy;
OrderType type = OrderType.Market;
double price = 0;
if (Btn == "buy")
{
orderAction = OrderAction.Buy;
}
else if (Btn == "sell")
{
orderAction = OrderAction.Sell;
}
else if (Btn == "close")
{
return;
}
else
{
return;
}
if (orderType == "bid")
{
marketData = new MarketData(instrumentSelector.Instrument);
type = OrderType.Limit;
price = marketData.Bid.Price;
}
else if (orderType == "ask")
{
marketData = new MarketData(instrumentSelector.Instrument);
type = OrderType.Limit;
price = marketData.Ask.Price;
}
else if (orderType == "mkt")
{
type = OrderType.Market;
price = 0;
}
else
{
type = OrderType.Market;
price = 0;
}
entryOrder = accountSelector.SelectedAccount.CreateOrder(
instrumentSelector.Instrument, // Order instrument
orderAction, // Possible values:
// OrderAction.Buy
// OrderAction.BuyToCover
// OrderAction.Sell
// OrderAction.SellShort
type, // Possible values:
// OrderType.Limit
// OrderType.Market
// OrderType.MIT
// OrderType.StopMarket
// OrderType.StopLimit
OrderEntry.Automated, // Possible values:
// OrderEntry.Automated
// OrderEntry.Manual
// Allows setting the tag for orders submitted manually or via automated trading logic
TimeInForce.Day, // Possible values:
// TimeInForce.Day
// TimeInForce.Gtc
// TimeInForce.Gtd
// TimeInForce.Ioc
// TimeInForce.Opg
qudSelector.Value, // Order quantity
0, // Order limit price. Use "0" should this parameter be irrelevant for the OrderType being submitted.
price, // Order stop price.Use "0" should this parameter be irrelevant for the OrderType being submitted.
string.Empty, // A string representing the OCO ID used to link OCO orders together
string.Empty, // A string representing the name of the order. Max 50 characters.
NinjaTrader.Core.Globals.MaxDate, // A DateTime value to be used with TimeInForce.Gtd - for all other cases you can pass in Core.Globals.MaxDate
null // Custom order if it is being used
);
accountSelector.SelectedAccount.Submit(new[] { entryOrder });
Console.WriteLine("Order Type: " + orderType + " Action: " + orderAction + " Price: " + Convert.ToString(price));
}
public string SyncReturn(HttpRequestBase request)
{
var payment = _paymentService.LoadPayment(PaymentType.WeiXin.ToString());
var config = _configService.Get <WeiXinConfig>();
WxPayData notifyData = GetNotifyData(request, config.Key);
//检查支付结果中transaction_id是否存在
if (!notifyData.IsSet("transaction_id"))
{
//若transaction_id不存在，则立即返回结果给微信支付后台
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "支付结果中微信订单号不存在");
Log.Error(this.GetType().ToString(), "The Pay result is error : " + res.ToXml());
return("支付结果中微信订单号不存在");
}
string transaction_id = notifyData.GetValue("transaction_id").ToString();
string out_trade_no = notifyData.GetValue("out_trade_no").ToString();
//查询订单，判断订单真实性
if (!QueryOrder(transaction_id))
{
//若订单查询失败，则立即返回结果给微信支付后台
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "订单查询失败");
Log.Error(this.GetType().ToString(), "Order query failure : " + res.ToXml());
return("订单查询失败");
}
//查询订单成功
else
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "SUCCESS");
res.SetValue("return_msg", "OK");
Log.Info(this.GetType().ToString(), "order query success : " + res.ToXml());
PayLog payLog = _currencyService.GetSingleByConditon <PayLog>(o => o.TransactionNo == out_trade_no);
if (payLog != null)
{
using (TransactionScope scope = new TransactionScope())
{
payLog.PayTime = DateTime.Now;
payLog.LogStatus = LogStatus.Paid;
_currencyService.Update(payLog);
Order order = _currencyService.GetSingleByConditon <Order>(o => o.Id == payLog.OrderId);
order.PayStatus = PayStatus.Paid;
order.PayTime = DateTime.Now;
order.PaymentId = payment.Id;
order.PaymentName = payment.Name;
order.OrderStatus = OrderStatus.WaitingForDelivery;
_orderService.ChangeOrderStatus(order.Id, order.OrderStatus, order.PayStatus);
_currencyService.Update(order);
var orderAction = new OrderAction
{
Id = KeyGenerator.GetGuidKey(),
OrderId = order.Id,
Memo = "微信支付",
CreateTime = DateTime.Now,
OrderStatus = order.OrderStatus,
PayStatus = order.PayStatus,
ShippingStatus = order.ShippingStatus,
EvaluateStatus = order.EvaluateStatus,
UserId = order.MemberId,
UserName = order.MemberName
};
_currencyService.Create(orderAction);
//提交
scope.Complete();
}
}
return("OK");
}
}
private async Task <IResponse> UpdateOrder <TPayload>(string purchaseOrderId, OrderAction desiredAction, TPayload payload)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
string action = "";
switch (desiredAction)
{
case OrderAction.Ack:
action = "acknowledge";
break;
case OrderAction.Cancel:
action = "cancel";
break;
case OrderAction.Refund:
action = "refund";
break;
case OrderAction.Shipping:
action = "shipping";
break;
default:
throw new Base.Exception.InvalidValueException("Unknown order action provided >" + action.ToString() + "<");
}
var request = CreateRequest();
request.ApiFormat = ApiFormat.XML;
// Allow for stream or conventional typed payload
if (payload != null)
{
if (payload is System.IO.Stream)
{
request.AddMultipartContent(payload as System.IO.Stream);
}
else
{
request.AddPayload(payload);
}
}
request.EndpointUri = String.Format("/v3/orders/{0}/{1}", purchaseOrderId, action);
var response = await client.PostAsync(request);
return(response);
}
public async Task <string> EditAsync(OrderEditInputModel input)
{
var order = this.orders.All().FirstOrDefault(o => o.Id == input.Id);
order.OrderFrom.ReferenceNum = input.OrderFromReferenceNum;
foreach (var orderTo in order.OrderTos)
{
var orderToInput = input.OrderTos.FirstOrDefault(o => o.Id == orderTo.Id);
orderTo.CarrierOrder.CompanyId = orderToInput.CarrierOrderCompanyId;
orderTo.PriceNetOut = orderToInput.PriceNetOut;
orderTo.CurrencyOutId = orderToInput.CurrencyOutId;
orderTo.PriceNetIn = orderToInput.PriceNetIn;
orderTo.CurrencyInId = orderToInput.CurrencyInId;
orderTo.ContactId = orderToInput.ContactId;
orderTo.VehicleId = orderToInput.VehicleId;
var actions = orderTo.OrderActions;
var notDeletedIds = new List <int>();
foreach (var inputAction in orderToInput.OrderActions)
{
var orderAction = actions.FirstOrDefault(a => a.Id == inputAction.Id);
if (orderAction is null)
{
orderAction = new OrderAction();
orderAction.Address = new Address();
orderAction.AdminId = order.AdminId;
orderAction.Address.AdminId = order.AdminId;
actions.Add(orderAction);
}
orderAction.TypeId = inputAction.TypeId;
orderAction.Address.City = inputAction.Address.City;
orderAction.Address.Postcode = inputAction.Address.Postcode;
orderAction.Address.Area = inputAction.Address.Area;
orderAction.Address.State = inputAction.Address.State;
orderAction.Address.StreetLine = inputAction.Address.StreetLine;
orderAction.Until = inputAction.Until;
orderAction.Details = inputAction.Details;
notDeletedIds.Add(orderAction.Id);
}
foreach (var action in actions)
{
if (!notDeletedIds.Contains(action.Id))
{
action.IsDeleted = true;
}
}
var cargo = orderTo.Cargo;
cargo.TypeId = orderToInput.Cargo.TypeId;
cargo.VehicleType = this.vehicleTypes.All().FirstOrDefault(vt => vt.Name == VehicleTypeNames.Truck.ToString());
cargo.LoadingBodyId = orderToInput.Cargo.LoadingBodyId;
cargo.Name = orderToInput.Cargo.Name;
cargo.Lenght = orderToInput.Cargo.Lenght;
cargo.Width = orderToInput.Cargo.Width;
cargo.Height = orderToInput.Cargo.Height;
cargo.WeightGross = orderToInput.Cargo.WeightGross;
cargo.WeightNet = orderToInput.Cargo.WeightNet;
cargo.Cubature = orderToInput.Cargo.Cubature;
cargo.Quantity = orderToInput.Cargo.Quantity;
cargo.Details = orderToInput.Cargo.Details;
var inputDocumentation = orderToInput.Documentation;
var documentation = orderTo.Documentation;
documentation.CMR = inputDocumentation.CMR;
documentation.BillOfLading = inputDocumentation.BillOfLading;
documentation.AOA = inputDocumentation.AOA;
documentation.DeliveryNote = inputDocumentation.DeliveryNote;
documentation.PackingList = inputDocumentation.PackingList;
documentation.ListItems = inputDocumentation.ListItems;
documentation.Invoice = inputDocumentation.Invoice;
documentation.BillOfGoods = inputDocumentation.BillOfGoods;
}
await this.documentations.SaveChangesAsync();
await this.orders.SaveChangesAsync();
return(order.Id);
}
private void PlayEliminate()
{
FuncEliminate.Eliminate();
List <List <CellAnimInfo> > cellAnims = CellModel.Instance.anims;
List <List <FloorAnimInfo> > floorAnims = FloorModel.Instance.anims;
List <List <WallAnimInfo> > wallAnims = WallModel.Instance.anims;
List <List <CoverAnimInfo> > coverAnims = CoverModel.Instance.anims;
List <List <MonsterAnimInfo> > monsterAnims = MonsterModel.Instance.anims;
rootAction = new OrderAction();
for (int i = 0; i < cellAnims.Count; i++)
{
ParallelAction paralle = new ParallelAction();
List <CellAnimInfo> cellAnimss = cellAnims[i];
int j;
for (j = 0; j < cellAnimss.Count; j++)
{
CellAnimInfo animInfo = cellAnimss[j];
FightCellItem item = GetItemByRunId(animInfo.runId);
if (item == null && animInfo.animationType != CellAnimType.nullbomb)
{
continue; //todo不因该有这个判断 变色技能需要再研究
}
OrderAction order = new OrderAction();
switch (animInfo.animationType)
{
case CellAnimType.clear:
order.AddNode(new PlaySoundActor("clear"));
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f));
FightEffectItem effectItem = effectLayer.GetEffectItemByPos(animInfo.toInfo.posX, animInfo.toInfo.posY);
order.AddNode(new ShowBombActor(item, effectItem, false));
order.AddNode(new ShowEffectActor(item.transform, "effect_cell_clear", fightModule.transform));
order.AddNode(new DestroyActor(item.gameObject));
break;
case CellAnimType.wreck:
order.AddNode(new PlaySoundActor("wreck"));
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f));
effectItem = effectLayer.GetEffectItemByPos(animInfo.toInfo.posX, animInfo.toInfo.posY);
order.AddNode(new ShowBombActor(item, effectItem, false));
order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform));
order.AddNode(new ChangeCellActor(item, animInfo.toInfo));
if (animInfo.toInfo.isBlank)
{
order.AddNode(new DestroyActor(item.gameObject));
}
break;
case CellAnimType.bomb:
order.AddNode(new PlaySoundActor("wreck"));
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(1.2f, 1.2f, 1), 0.1f));
effectItem = effectLayer.GetEffectItemByPos(animInfo.toInfo.posX, animInfo.toInfo.posY);
order.AddNode(new ShowBombActor(item, effectItem, false));
order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform));
order.AddNode(new ChangeCellActor(item, animInfo.toInfo));
if (animInfo.toInfo.isBlank)
{
order.AddNode(new DestroyActor(item.gameObject));
}
break;
case CellAnimType.nullbomb:
effectItem = effectLayer.GetEffectItemByPos(animInfo.toInfo.posX, animInfo.toInfo.posY);
order.AddNode(new ShowBombActor(item, effectItem, false));
break;
}
if (item != null && item.cell_info.isBlank)
{
if (item.cell_info.timer > 0)
{
order.AddNode(new AddStepActor(item.cell_info.addCount));
order.AddNode(new WaitActor(200));
}
}
paralle.AddNode(order);
}
floorLayer.PlayEliminate(floorAnims[i], paralle);
coverLayer.PlayEliminate(coverAnims[i], paralle);
fancelayer.PlayEliminate(wallAnims[i], paralle);
monsterLayer.PlayEliminate(monsterAnims[i], paralle);
rootAction.AddNode(paralle);
}
ExecuteAction(FightStadus.eliminate);
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='assetIdTo'>
/// </param>
/// <param name='orderAction'>
/// Possible values include: 'Buy', 'Sell'
/// </param>
/// <param name='assetsFrom'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <IList <ConversionResult> > ApiRateCalculatorGetMarketAmountInBaseByAssetIdToByOrderActionPostAsync(this IRateCalculatorAPI operations, string assetIdTo, OrderAction orderAction, IList <AssetWithAmount> assetsFrom = default(IList <AssetWithAmount>), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ApiRateCalculatorGetMarketAmountInBaseByAssetIdToByOrderActionPostWithHttpMessagesAsync(assetIdTo, orderAction, assetsFrom, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private void UnlockMonster(bool isJet = false)
{
List <int> unLockIds = MonsterModel.Instance.UnLock(isJet);
MonsterModel.Instance.BackUpUnLockMonster(unLockIds);
rootAction = new OrderAction();
for (int j = 0; j < unLockIds.Count; j++)
{
int monsterRunId = unLockIds[j];
FightMonsterItem monsterItem = monsterLayer.GetItemByRunId(monsterRunId);
rootAction.AddNode(new SetLayerActor(monsterItem.transform, effectLayer.transform));
CellInfo monsterCell = new CellInfo();
monsterCell.posX = monsterItem.monsterInfo.posX;
monsterCell.posY = monsterItem.monsterInfo.posY;
if (isJet)
{
if (monsterItem.monsterInfo.IsNull())
{
CellDirType dirType = WallModel.Instance.GetGapWallDir(monsterCell);
int zrotate = PosUtil.GetRotateByDir(dirType);
rootAction.AddNode(new RoatateActor((RectTransform)monsterItem.transform, new Vector3(0, 0, zrotate), 0.25f));
}
else
{
rootAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(1.15f, 1.15f, 1f), 0.2f));
}
}
List <CellInfo> releaseList = MonsterModel.Instance.ReleaseList(monsterRunId);
if (releaseList.Count > 0)
{
ParallelAction paralle = new ParallelAction();
for (int i = 0; i < releaseList.Count; i++)
{
CellInfo cellInfo = releaseList[i];
FightCellItem item = GetItemByRunId(cellInfo.runId);
if (item == null)
{
GameObject itemObj = CreateCellItem(cellInfo);
item = itemObj.GetComponent <FightCellItem>();
}
OrderAction order = new OrderAction();
order.AddNode(new PlaySoundActor("Refresh"));
order.AddNode(new ShowEffectLineActor(effectLayer, cellInfo, monsterCell, monsterItem.monsterInfo.releaseId));
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f));
order.AddNode(new ChangeCellActor(item, cellInfo, monsterItem.monsterInfo.releaseId));
paralle.AddNode(order);
}
rootAction.AddNode(paralle);
}
if (monsterItem.monsterInfo.IsNull())
{
rootAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(1.25f, 1.25f, 0), 0.15f));
if (j == 0)
{
rootAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(0, 0, 0), 0.25f));
}
else
{
rootAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(0, 0, 0), 0.15f));
}
}
else
{
rootAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(1, 1, 1), 0.05f));
CoverInfo coverInfo = CoverModel.Instance.GetCoverByPos(monsterItem.monsterInfo.posY, monsterItem.monsterInfo.posX);
FightCoverItem coverItem = coverLayer.GetItemByRunId(coverInfo.runId);
rootAction.AddNode(new ChangeCoverActor(coverLayer, coverItem, coverInfo));
rootAction.AddNode(new ProgressMonsterActor(monsterItem, monsterItem.monsterInfo.progress));
rootAction.AddNode(new SetLayerActor(monsterItem.transform, monsterLayer.transform));
}
}
if (isJet)
{
ExecuteAction(FightStadus.jet_monster);
}
else
{
ParallelAction paralleTimer = new ParallelAction();
List <CellInfo> timerCells = CellModel.Instance.Timing();
for (int i = 0; i < timerCells.Count; i++)
{
CellInfo cellInfo = timerCells[i];
FightCellItem item = GetItemByRunId(cellInfo.runId);
if (item != null)
{
OrderAction order = new OrderAction();
order.AddNode(new PlaySoundActor("Refresh"));
order.AddNode(new ChangeCellActor(item, cellInfo));
if (cellInfo.isBlank)
{
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.2f));
order.AddNode(new DestroyActor(item.gameObject));
}
paralleTimer.AddNode(order);
}
}
List <CoverInfo> timerCovers = CoverModel.Instance.Timing();
for (int i = 0; i < timerCovers.Count; i++)
{
CoverInfo coverInfo = timerCovers[i];
FightCoverItem item = coverLayer.GetItemByRunId(coverInfo.runId);
OrderAction order = new OrderAction();
order.AddNode(new PlaySoundActor("Refresh"));
order.AddNode(new ChangeCoverActor(coverLayer, item, coverInfo));
if (coverInfo.IsNull())
{
order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.2f));
order.AddNode(new DestroyActor(item.gameObject));
List <CoverInfo> covers = CoverModel.Instance.GetNeighbors(coverInfo);
for (int n = 0; n < covers.Count; n++)
{
CoverInfo cover = covers[n];
if (cover != null)
{
item = coverLayer.GetItemByRunId(cover.runId);
order.AddNode(new ChangeCoverActor(coverLayer, item, cover));
if (cover.config != null)
{
coverFlowInterrupt = true;
}
}
}
}
paralleTimer.AddNode(order);
}
rootAction.AddNode(paralleTimer);
if (coverFlowInterrupt)
{
rootAction.AddNode(new FuncActor(coverLayer.ShowList)); //todo 爆后流动导致多出蜘蛛网
}
ExecuteAction(FightStadus.unlock_monster);
}
}
/// <summary>
/// 主库订单确认收货
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public ServiceResult ConfirmToMaster(ConfirmInput parameter)
{
if (TenantContext.CurrentTenant != "master")
{
return(ServiceResult.Failed);
}
var user = Resolve <IUserService>().GetUserDetail(parameter.UserId);
if (user == null)
{
return(ServiceResult.Failure("用户不存在！"));
}
//if (user.Detail.PayPassword != parameter.PayPassword.ToMd5HashString())
//{
// return ServiceResult.Failure("支付密码不正确！");
//}
var orderId = parameter.EntityId.ConvertToLong();
var order = Resolve <IOrderService>().GetSingle(r => r.Id == orderId);
if (order == null)
{
return(ServiceResult.Failure("订单不存在！"));
}
if (order.OrderStatus == OrderStatus.WaitingReceiptProduct)
{
order.OrderStatus = OrderStatus.WaitingEvaluated;
}
else
{
return(ServiceResult.Failure("商品状态不支持收货确认操作！"));
}
var result = Resolve <IOrderService>().Update(order);
if (result)
{
var orderAction = new OrderAction {
Intro = "会员已确认收货",
OrderId = order.Id,
ActionUserId = order.UserId,
OrderActionType = OrderActionType.UserConfirmOrder
};
Resolve <IOrderActionService>().Add(orderAction);
order.OrderExtension = order.Extension.ToObject <OrderExtension>();
if (TenantContext.CurrentTenant == "master" && order?.OrderExtension?.TenantOrderInfo?.OrderId > 0)
{
// 收货后如果是租户订单, 同步到租户的自提
var tenant = Resolve <ITenantService>().GetSingle(x => x.UserId == order.UserId);
if (tenant != null)
{
var sql =
$@"SELECT o.id OrderId ,p.* FROM Shop_Order o JOIN Shop_OrderProduct od ON o.Id = od.OrderId JOIN Shop_Product p ON p.Id = od.ProductId
WHERE o.Id = {order.Id} AND o.OrderStatus = 4 AND o.UserId = {order.UserId}";
var orderProductList = Ioc.Resolve <IUserRepository>().RepositoryContext
.Fetch <PickUpProductView>(sql);
if (orderProductList.Count > 0)
{
var apiUrl = tenant.ServiceUrl + "/Api/PickUpProduct/AddPickUpProduct";
var dicHeader = new Dictionary <string, string>
{
{ "zk-tenant", tenant.Sign }
};
apiUrl.Post(orderProductList.ToJsons(), dicHeader);
}
}
}
}
return(ServiceResult.Success);
}
protected void RejectNew(QuickFix.SessionID session, string symbol, string order_id, int qty, OrderAction side, string reply_text)
{
IOrder fake_order = new FakeOrderForRejectReport(qty, side);
OrderFixBridge order = new OrderFixBridge(fake_order, order_id, session);
SendExecutionReport(order, symbol, 0, 0, reply_text);
}
private void PlayPutAutoSkill()
{
rootAction = new OrderAction();
WaitActor waitActor = new WaitActor(200);
rootAction.AddNode(waitActor);
List <SkillEntityInfo> skillEntitys = SkillModel.Instance.GetNewSkillEntitys();
fightUI.ShowSkill();
if (lastTouchCell != null && skillEntitys.Count > 0)
{
ParallelAction parallelAction = new ParallelAction();
int holdIndex = 0;
bool lastIsHump = lastTouchCell.IsHump();
for (int i = 0; i < skillEntitys.Count; i++)
{
OrderAction skillOrder = new OrderAction();
SkillEntityInfo skillEntity = skillEntitys[i];
Vector2 addPos = new Vector2();
for (int h = holdIndex; h < 19; h++)
{
Vector2 holePos = FightConst.GetHoleByLevel(h, lastIsHump);
Vector2 checkPos = new Vector2(lastTouchCell.posX + holePos.x, lastTouchCell.posY - holePos.y);
CellInfo checkCell = CellModel.Instance.GetCellByPos((int)checkPos.x, (int)checkPos.y);
if (checkCell != null && checkCell.isBlank)
{
addPos = checkPos;
holdIndex = h + 1;
break;
}
}
CellInfo addItem = CellModel.Instance.AddItem(skillEntity.seed.config_cell_item.id, (int)addPos.x, (int)addPos.y);
SkillModel.Instance.ThrowSkillEntity(skillEntity, addItem);
GameObject itemObj = CreateCellItem(addItem);
itemObj.transform.SetParent(effectLayer.transform, false);
Vector2 toPos = PosUtil.GetFightCellPos(addItem.posX, addItem.posY);
PosUtil.SetCellPos(itemObj.transform, skillEntity.seed.seed_x, skillEntity.seed.seed_y, 1.0f);
rootAction.AddNode(new PlaySoundActor("Useskill"));
rootAction.AddNode(new ShowEffectActor(itemObj.transform, "effect_skill_fly"));
rootAction.AddNode(new MoveActor((RectTransform)itemObj.transform, new Vector3(toPos.x, toPos.y, 0), 1200));
skillOrder.AddNode(new SetLayerActor(itemObj.transform, transform));
skillOrder.AddNode(new PlaySoundActor("PutAutoSkill"));
skillOrder.AddNode(new ClearEffectActor(itemObj.transform, "effect_skill_fly"));
skillOrder.AddNode(new ScaleActor((RectTransform)itemObj.transform, new Vector3(1.2f, 1.2f, 0), 0.2f));
skillOrder.AddNode(new ScaleActor((RectTransform)itemObj.transform, new Vector3(1, 1, 0), 0.1f));
parallelAction.AddNode(skillOrder);
}
rootAction.AddNode(parallelAction);
}
waitActor = new WaitActor(200);
rootAction.AddNode(waitActor);
ExecuteAction(FightStadus.auto_skill);
}
public static LimitOrder Create(string traderId, string asset, string baseCurrency, OrderAction action, double volume, double price)
{
return new LimitOrder
{
TraderId = traderId,
Asset = asset,
Action = action,
Volume = volume,
Price = price,
BaseCurrency = baseCurrency
};
}
private void Crawl()
{
rootAction = new OrderAction();
if (!isDeductStep)
{
MonsterModel.Instance.Crawl();
List <MonsterCrawlInfo> crawAnims = MonsterModel.Instance.crawAnims;
rootAction = new OrderAction();
ParallelAction paralle = new ParallelAction();
for (int i = 0; i < crawAnims.Count; i++)
{
MonsterCrawlInfo crawAnim = crawAnims[i];
OrderAction orderAction = new OrderAction();
paralle.AddNode(orderAction);
FightMonsterItem monsterItem = monsterLayer.GetItemByRunId(crawAnim.monster.runId);
for (int j = 0; j < crawAnim.pathCells.Count; j++)
{
CellInfo pathCell = crawAnim.pathCells[j];
Vector2 toPos = PosUtil.GetFightCellPos(pathCell.posX, pathCell.posY);
float zrotate = 0;
if (j > 0)
{
Vector2 fromPos = PosUtil.GetFightCellPos(crawAnim.pathCells[j - 1].posX, crawAnim.pathCells[j - 1].posY);
zrotate = PosUtil.VectorAngle(new Vector2(fromPos.x, fromPos.y), new Vector2(toPos.x, toPos.y));
}
else
{
Vector2 anchoredPos = ((RectTransform)monsterItem.transform).anchoredPosition;
zrotate = PosUtil.VectorAngle(new Vector2(anchoredPos.x, anchoredPos.y), new Vector2(toPos.x, toPos.y));
}
orderAction.AddNode(new RotationActor((RectTransform)monsterItem.transform, zrotate));
float speed = 600;
orderAction.AddNode(new MoveActor((RectTransform)monsterItem.transform, new Vector3(toPos.x, toPos.y, 0), speed));
if (pathCell.isBlank == false)
{
FightCellItem cellItem = GetItemByRunId(pathCell.runId);
pathCell.SetConfig((int)crawAnim.monster.releaseList[0].id);
pathCell.changer = 0;
orderAction.AddNode(new ChangeCellActor(cellItem, pathCell));
}
}
if (crawAnim.roadEnd)
{
orderAction.AddNode(new ScaleActor((RectTransform)monsterItem.transform, new Vector3(0, 0, 0), 0.3f));
orderAction.AddNode(new ChangeMonsterActor(monsterItem, crawAnim.monster));
}
}
rootAction.AddNode(paralle);
}
ExecuteAction(FightStadus.crawl);
}
public async Task <IEnumerable <ConversionResult> > GetMarketAmountInBase(IEnumerable <AssetWithAmount> from,
string assetIdTo, OrderAction orderAction)
{
var limitOrdersTask = _activeLimitOrdersRepository.GetAsync();
var assetsDictTask = _assetsDict.GetDictionaryAsync();
var assetPairsTask = _assetPairsDict.Values();
var marketProfileTask = _bestPriceRepository.GetAsync();
var limitOrders = await limitOrdersTask;
var assetsDict = await assetsDictTask;
var assetPairs = await assetPairsTask;
var marketProfile = await marketProfileTask;
return(@from.Select(item => GetMarketAmountInBase(orderAction, limitOrders, item, assetIdTo, assetsDict, assetPairs, marketProfile)));
}
private static OrderBL NewLimitDayOrder(String accountId, String ticker, int quantity,
decimal orderPrice, OrderAction action)
{
return(new OrderBL(accountId, action, ticker, OrderType.OrderLimit, quantity,
orderPrice, OrderTimeInForce.OrderDay));
}
private ConversionResult GetMarketAmountInBase(OrderAction orderAction, IEnumerable <ILimitOrder> limitOrders, AssetWithAmount from,
string assetTo, IDictionary <string, IAsset> assetsDict, IEnumerable <IAssetPair> assetPairs, MarketProfile marketProfile)
{
var result = new ConversionResult();
var assetPair = assetPairs.PairWithAssets(from.AssetId, assetTo);
if (!IsInputValid(from, assetTo, assetsDict) || assetPair == null)
{
result.SetResult(OperationResult.InvalidInputParameters);
return(result);
}
if (from.AssetId == assetTo)
{
result.From = result.To = from;
result.Price = result.VolumePrice = 1;
result.SetResult(OperationResult.Ok);
return(result);
}
limitOrders = limitOrders.Where(x => x.AssetPairId == assetPair.Id).GetAsync(orderAction, assetPair.IsInverted(assetTo));
double sum = 0;
double priceSum = 0;
int n = 0;
var neededSum = double.MaxValue;
foreach (var order in limitOrders)
{
if (n != 0 && sum >= neededSum)
{
break;
}
sum += Math.Abs(order.Volume);
priceSum += order.Price;
n++;
neededSum = from.Amount * GetRate(assetTo, assetPair, priceSum / n);
}
if (n == 0)
{
result.SetResult(OperationResult.NoLiquidity);
return(result);
}
var price = priceSum / n;
result.From = from;
var rate = GetRate(assetTo, assetPair, price);
var displayRate = GetRate(from.AssetId, assetPair, price);
result.To = new AssetWithAmount
{
AssetId = assetTo,
Amount = (rate * from.Amount).TruncateDecimalPlaces(assetsDict[assetTo].Accuracy, orderAction == OrderAction.Buy)
};
result.SetResult(sum < neededSum ? OperationResult.NoLiquidity : OperationResult.Ok);
result.Price = GetRate(from.AssetId, assetPair, marketProfile.GetPrice(assetPair.Id, orderAction).GetValueOrDefault());
result.VolumePrice = displayRate;
return(result);
}
public virtual List <TEntity> GetAllList(OrderAction <TEntity> orderAction = null, params Expression <Func <TEntity, dynamic> >[] eagerLoadingProperties)
{
return(GetAllList(null, orderAction, eagerLoadingProperties));
}
public virtual UpdateResult performOrderAction(OrderAction orderAction, Statement filterStatement) {
object[] results = this.Invoke("performOrderAction", new object[] { orderAction, filterStatement });
return ((UpdateResult) (results[0]));
}
public abstract PagedResult <TEntity> GetPaged(int pageNumber, int pageSize, Expression <Func <TEntity, bool> > predicate, OrderAction <TEntity> orderAction, params Expression <Func <TEntity, dynamic> >[] eagerLoadingProperties);
public Task ValidateAsync(Order entity, OrderAction action)
{
throw new NotImplementedException();
}
public void DoBuild(Tile tile)
{
if (buildMode == BuildMode.ROOMBEHAVIOR)
{
string roomBehaviorType = buildModeType;
if (tile.Room != null && WorldController.Instance.World.IsRoomBehaviorValidForRoom(roomBehaviorType, tile.Room))
{
RoomBehavior proto = PrototypeManager.RoomBehavior.Get(roomBehaviorType);
tile.Room.DesignateRoomBehavior(proto.Clone());
}
}
else if (buildMode == BuildMode.FURNITURE)
{
// Create the Furniture and assign it to the tile
// Can we build the furniture in the selected tile?
// Run the ValidPlacement function!
string furnitureType = buildModeType;
if (
World.Current.FurnitureManager.IsPlacementValid(furnitureType, tile, CurrentPreviewRotation) &&
World.Current.FurnitureManager.IsWorkSpotClear(furnitureType, tile) &&
DoesFurnitureBuildJobOverlapExistingBuildJob(tile, furnitureType, CurrentPreviewRotation) == false)
{
// This tile position is valid for this furniture
// Check if there is existing furniture in this tile. If so delete it.
if (tile.Furniture != null)
{
tile.Furniture.SetDeconstructJob();
}
// Create a job for it to be build
Job job;
Furniture toBuildProto = PrototypeManager.Furniture.Get(furnitureType);
OrderAction orderAction = toBuildProto.GetOrderAction <Build>();
if (orderAction != null)
{
job = orderAction.CreateJob(tile, furnitureType);
if (useCratedObject)
{
// We want to use a crated furniture, so set requested items to crated version.
job.RequestedItems.Clear();
job.RequestedItems.Add(this.buildModeType, new ProjectPorcupine.Jobs.RequestedItem(this.buildModeType, 1));
useCratedObject = false;
}
// this is here so OrderAction can be used for utility as well as furniture
job.OnJobCompleted += (theJob) => World.Current.FurnitureManager.ConstructJobCompleted(theJob);
}
else
{
UnityDebugger.Debugger.LogError("BuildModeController", "There is no furniture job prototype for '" + furnitureType + "'");
job = new Job(tile, furnitureType, World.Current.FurnitureManager.ConstructJobCompleted, 0.1f, null, Job.JobPriority.High);
job.adjacent = true;
job.Description = "job_build_" + furnitureType + "_desc";
}
Furniture furnitureToBuild = PrototypeManager.Furniture.Get(furnitureType).Clone();
furnitureToBuild.SetRotation(CurrentPreviewRotation);
job.buildablePrototype = furnitureToBuild;
// Add the job to the queue or build immediately if in Dev mode
if (SettingsKeyHolder.DeveloperMode)
{
World.Current.FurnitureManager.PlaceFurniture(furnitureToBuild, job.tile);
}
else
{
for (int x_off = tile.X; x_off < (tile.X + job.buildablePrototype.Width); x_off++)
{
for (int y_off = tile.Y; y_off < (tile.Y + job.buildablePrototype.Height); y_off++)
{
// FIXME: I don't like having to manually and explicitly set
// flags that prevent conflicts. It's too easy to forget to set/clear them!
Tile offsetTile = World.Current.GetTileAt(x_off, y_off, tile.Z);
HashSet <Job> pendingBuildJobs = WorldController.Instance.World.GetTileAt(x_off, y_off, tile.Z).PendingBuildJobs;
if (pendingBuildJobs != null)
{
// if the existing buildJobs furniture is replaceable by the current furnitureType,
// we can pretend it does not overlap with the new build
// We should only have 1 furniture building job per tile, so this should return that job and only that job
IEnumerable <Job> pendingFurnitureJob = pendingBuildJobs.Where(pendingJob => pendingJob.buildablePrototype.GetType() == typeof(Furniture));
if (pendingFurnitureJob.Count() == 1)
{
pendingFurnitureJob.Single().CancelJob();
}
}
offsetTile.PendingBuildJobs.Add(job);
job.OnJobStopped += (theJob) => offsetTile.PendingBuildJobs.Remove(job);
}
}
World.Current.jobQueue.Enqueue(job);
// Let our workspot tile know it is reserved for us
World.Current.ReserveTileAsWorkSpot((Furniture)job.buildablePrototype, job.tile);
}
}
}
else if (buildMode == BuildMode.UTILITY)
{
// Create the Furniture and assign it to the tile
// Can we build the furniture in the selected tile?
// Run the ValidPlacement function!
string utilityType = buildModeType;
if (
World.Current.UtilityManager.IsPlacementValid(utilityType, tile) &&
DoesSameUtilityTypeAlreadyExist(utilityType, tile) == false &&
DoesUtilityBuildJobOverlapExistingBuildJob(utilityType, tile) == false)
{
// This tile position is valid for this furniture
// Create a job for it to be build
Job job;
Utility toBuildProto = PrototypeManager.Utility.Get(utilityType);
OrderAction orderAction = toBuildProto.GetOrderAction <Build>();
if (orderAction != null)
{
job = orderAction.CreateJob(tile, utilityType);
// this is here so OrderAction can be used for utility as well as furniture
job.OnJobCompleted += (theJob) => World.Current.UtilityManager.ConstructJobCompleted(theJob);
}
else
{
UnityDebugger.Debugger.LogError("BuildModeController", "There is no furniture job prototype for '" + utilityType + "'");
job = new Job(tile, utilityType, World.Current.UtilityManager.ConstructJobCompleted, 0.1f, null, Job.JobPriority.High);
job.Description = "job_build_" + utilityType + "_desc";
}
job.buildablePrototype = PrototypeManager.Utility.Get(utilityType);
// Add the job to the queue or build immediately if in dev mode
if (SettingsKeyHolder.DeveloperMode)
{
World.Current.UtilityManager.PlaceUtility(job.Type, job.tile, true);
}
else
{
// FIXME: I don't like having to manually and explicitly set
// flags that preven conflicts. It's too easy to forget to set/clear them!
Tile offsetTile = World.Current.GetTileAt(tile.X, tile.Y, tile.Z);
offsetTile.PendingBuildJobs.Add(job);
job.OnJobStopped += (theJob) => offsetTile.PendingBuildJobs.Remove(job);
World.Current.jobQueue.Enqueue(job);
}
}
}
else if (buildMode == BuildMode.FLOOR)
{
// We are in tile-changing mode.
////t.Type = buildModeTile;
TileType tileType = buildModeTile;
if (
tile.Type != tileType &&
tile.Furniture == null &&
tile.PendingBuildJobs.Count == 0 &&
tileType.CanBuildHere(tile))
{
// This tile position is valid tile type
// Create a job for it to be build
Job buildingJob = tileType.BuildingJob;
buildingJob.tile = tile;
// Add the job to the queue or build immediately if in Dev mode
if (SettingsKeyHolder.DeveloperMode)
{
buildingJob.tile.SetTileType(buildingJob.JobTileType);
}
else
{
buildingJob.OnJobStopped += (theJob) => theJob.tile.PendingBuildJobs.Remove(theJob);
WorldController.Instance.World.jobQueue.Enqueue(buildingJob);
}
}
}
else if (buildMode == BuildMode.DECONSTRUCT)
{
bool canDeconstructAll = SettingsKeyHolder.DeveloperMode;
if (tile.Furniture != null && (canDeconstructAll || tile.Furniture.HasTypeTag("Non-deconstructible") == false))
{
// check if this is a WALL neighbouring a pressured and pressureless environment, and if so, bail
if (IsTilePartOfPressuredRoom(tile))
{
return;
}
tile.Furniture.SetDeconstructJob();
}
else if (tile.PendingBuildJobs != null && tile.PendingBuildJobs.Count > 0)
{
tile.PendingBuildJobs.Last().CancelJob();
}
else if (tile.Utilities.Count > 0)
{
tile.Utilities.Last().Value.SetDeconstructJob();
}
}
else if (buildMode == BuildMode.MINE)
{
if (tile.Furniture != null)
{
Job existingMineJob;
bool hasMineJob = tile.Furniture.Jobs.HasJobWithPredicate(x => x.OrderName == typeof(Mine).Name, out existingMineJob);
if (!hasMineJob)
{
OrderAction mineAction = tile.Furniture.GetOrderAction <Mine>();
if (mineAction != null)
{
// check if this is a WALL neighbouring a pressured and pressureless environment, and if so, bail
if (IsTilePartOfPressuredRoom(tile))
{
return;
}
Job job = mineAction.CreateJob(tile, null);
if (SettingsKeyHolder.DeveloperMode)
{
// complete job right away, needs buildable
job.buildable = tile.Furniture;
job.DoWork(0);
}
else
{
tile.Furniture.Jobs.Add(job);
}
}
}
}
}
else
{
UnityDebugger.Debugger.LogError("BuildModeController", "UNIMPLEMENTED BUILD MODE");
}
}
/// <summary>
/// Reads the prototype utility from XML.
/// </summary>
/// <param name="readerParent">The XML reader to read from.</param>
public void ReadXmlPrototype(XmlReader readerParent)
{
Type = readerParent.GetAttribute("type");
XmlReader reader = readerParent.ReadSubtree();
while (reader.Read())
{
switch (reader.Name)
{
case "TypeTag":
reader.Read();
typeTags.Add(reader.ReadContentAsString());
break;
case "CanBeBuiltOn":
tileTypeBuildPermissions.Add(reader.GetAttribute("tileType"));
break;
case "Action":
XmlReader subtree = reader.ReadSubtree();
EventActions.ReadXml(subtree);
subtree.Close();
break;
case "ContextMenuAction":
contextMenuLuaActions.Add(new ContextMenuLuaAction
{
LuaFunction = reader.GetAttribute("FunctionName"),
LocalizationKey = reader.GetAttribute("Text"),
RequireCharacterSelected = bool.Parse(reader.GetAttribute("RequireCharacterSelected")),
DevModeOnly = bool.Parse(reader.GetAttribute("DevModeOnly") ?? "false")
});
break;
case "GetSpriteName":
getSpriteNameAction = reader.GetAttribute("FunctionName");
break;
case "Params":
ReadXmlParams(reader); // Read in the Param tag
break;
case "LocalizationCode":
reader.Read();
LocalizationName = reader.ReadContentAsString();
break;
case "UnlocalizedDescription":
reader.Read();
LocalizationDescription = reader.ReadContentAsString();
break;
case "OrderAction":
OrderAction orderAction = OrderAction.Deserialize(reader);
if (orderAction != null)
{
orderActions[orderAction.Type] = orderAction;
}
break;
}
}
}
/// <summary>
/// Reads the prototype furniture from XML.
/// </summary>
/// <param name="readerParent">The XML reader to read from.</param>
public void ReadXmlPrototype(XmlReader readerParent)
{
Type = readerParent.GetAttribute("type");
XmlReader reader = readerParent.ReadSubtree();
while (reader.Read())
{
switch (reader.Name)
{
case "TypeTag":
reader.Read();
typeTags.Add(reader.ReadContentAsString());
break;
case "MovementCost":
reader.Read();
MovementCost = reader.ReadContentAsFloat();
break;
case "PathfindingModifier":
reader.Read();
PathfindingModifier = reader.ReadContentAsFloat();
break;
case "PathfindingWeight":
reader.Read();
PathfindingWeight = reader.ReadContentAsFloat();
break;
case "Width":
reader.Read();
Width = reader.ReadContentAsInt();
break;
case "Height":
reader.Read();
Height = reader.ReadContentAsInt();
break;
case "Health":
reader.Read();
health = new HealthSystem(reader.ReadContentAsFloat(), false, true, false, false);
break;
case "LinksToNeighbours":
reader.Read();
LinksToNeighbour = reader.ReadContentAsString();
break;
case "EnclosesRooms":
reader.Read();
RoomEnclosure = reader.ReadContentAsBoolean();
break;
case "CanReplaceFurniture":
replaceableFurniture.Add(reader.GetAttribute("typeTag").ToString());
break;
case "CanRotate":
reader.Read();
CanRotate = reader.ReadContentAsBoolean();
break;
case "DragType":
reader.Read();
DragType = reader.ReadContentAsString();
break;
case "CanBeBuiltOn":
tileTypeBuildPermissions.Add(reader.GetAttribute("tileType"));
break;
case "Animations":
XmlReader animationReader = reader.ReadSubtree();
ReadAnimationXml(animationReader);
break;
case "Action":
XmlReader subtree = reader.ReadSubtree();
EventActions.ReadXml(subtree);
subtree.Close();
break;
case "ContextMenuAction":
contextMenuLuaActions.Add(new ContextMenuLuaAction
{
LuaFunction = reader.GetAttribute("FunctionName"),
LocalizationKey = reader.GetAttribute("LocalizationKey"),
RequireCharacterSelected = bool.Parse(reader.GetAttribute("RequireCharacterSelected")),
DevModeOnly = bool.Parse(reader.GetAttribute("DevModeOnly") ?? "false")
});
break;
case "IsEnterable":
isEnterableAction = reader.GetAttribute("FunctionName");
break;
case "GetProgressInfo":
getProgressInfoNameAction = reader.GetAttribute("functionName");
break;
case "JobWorkSpotOffset":
Jobs.ReadWorkSpotOffset(reader);
break;
case "JobInputSpotOffset":
Jobs.ReadInputSpotOffset(reader);
break;
case "JobOutputSpotOffset":
Jobs.ReadOutputSpotOffset(reader);
break;
case "Params":
ReadXmlParams(reader); // Read in the Param tag
break;
case "LocalizationCode":
reader.Read();
LocalizationCode = reader.ReadContentAsString();
break;
case "UnlocalizedDescription":
reader.Read();
UnlocalizedDescription = reader.ReadContentAsString();
break;
case "Component":
BuildableComponent component = BuildableComponent.Deserialize(reader);
if (component != null)
{
component.InitializePrototype(this);
components.Add(component);
}
break;
case "OrderAction":
OrderAction orderAction = OrderAction.Deserialize(reader);
if (orderAction != null)
{
orderActions[orderAction.Type] = orderAction;
}
break;
}
}
if (orderActions.ContainsKey("Uninstall"))
{
Inventory asInventory = Inventory.CreatePrototype(Type, 1, 0f, "crated_furniture", LocalizationCode, UnlocalizedDescription);
PrototypeManager.Inventory.Add(asInventory);
}
}
/// <summary>
/// Converts order action into reversed order action - buy to sell and sell to buy.
/// </summary>
/// <param name="orderAction">Order action to be reversed.</param>
/// <returns>Reversed order action.</returns>
public static OrderAction Reverse(this OrderAction orderAction)
{
return(orderAction == OrderAction.Buy ? OrderAction.Sell : OrderAction.Buy);
}
