private OperationResult ServerConnect(string method, string servAddress, string streamDir)
{
ConnectParam connParam = new ConnectParam()
{
QuoteAddress = servAddress,
StreamFolder = streamDir
};
byte[] param_data = DataTranslater.Serialize(connParam);
byte[] ret_data = null; // Request(method, param_data);
if (ret_data != null)
{
OperationReturn rt = DataTranslater.Deserialize <OperationReturn>(ret_data);
return(new OperationResult
{
Success = rt.Success,
ErrorMessage = rt.ErrorMessage
});
}
else
{
return new OperationResult
{
Success = false,
ErrorMessage = "Returned data (Connect) is invalid"
}
};
}
public void QueryPositionDetails(string symbol)
{
entity.StringParam strParam = new entity.StringParam();
strParam.Data = symbol;
byte[] param_data = DataTranslater.Serialize(strParam);
//byte[] ret_data = Request("QueryPositionDetails", param_data);
}
public OperationResult ManualCloseOrder(string symbol, trade.TradeDirectionType direction,
DateTime openDate, int quantity)
{
entity.ManualCloseOrderParam closeOrdParam = new entity.ManualCloseOrderParam();
closeOrdParam.Symbol = symbol;
closeOrdParam.Direction = direction;
closeOrdParam.OpenDate = openDate.ToString("yyyyMMdd");
closeOrdParam.Quantity = quantity;
byte[] param_data = DataTranslater.Serialize(closeOrdParam);
byte[] ret_data = null; // Request("ManualCloseOrder", param_data);
if (ret_data != null)
{
OperationReturn rt = DataTranslater.Deserialize <OperationReturn>(ret_data);
return(new OperationResult
{
Success = rt.Success,
ErrorMessage = rt.ErrorMessage
});
}
else
{
return new OperationResult
{
Success = false,
ErrorMessage = "Returned data (ManualCloseOrder) is invalid"
}
};
}
private OperationResult ServerLogin(string method, string brokerId, string userId, string password, AccountSettings acctSettings = null)
{
LoginParam connParam = new LoginParam()
{
BrokerId = brokerId,
UserId = userId,
Password = password,
AcctSettings = acctSettings
};
byte[] param_data = DataTranslater.Serialize(connParam);
byte[] ret_data = Request(method, param_data);
if (ret_data != null)
{
OperationReturn rt = DataTranslater.Deserialize <OperationReturn>(ret_data);
return(new OperationResult
{
Success = rt.Success,
ErrorMessage = rt.ErrorMessage
});
}
else
{
return new OperationResult
{
Success = false,
ErrorMessage = "Returned data (Login) is invalid"
}
};
}
void OnDataRecieved(string data)
{
if (player.kills <= lastKills && player.deaths <= lastDeaths)
{
return;
}
int killsSinceLast = player.kills - lastKills;
int deathsSinceLast = player.deaths = lastDeaths;
int kills = DataTranslater.DataToKill(data);
int deaths = DataTranslater.DataToDeaths(data);
int newKills = killsSinceLast + kills;
int newDeaths = deathsSinceLast + deaths;
string newData = DataTranslater.VAluesToData(newKills, newDeaths);
Debug.Log("Syncing: " + newData);
lastKills = player.kills;
lastDeaths = player.deaths;
UserAccountManager.instance.SendData(newData);
}
public void PortfApplyStrategySettings(string portfId, string strategyName, byte[] strategyData)
{
entity.ModifyStrategyParam modifyParam = new entity.ModifyStrategyParam();
modifyParam.PortfId = portfId;
modifyParam.StrategyName = strategyName;
modifyParam.StrategyData = strategyData;
byte[] param_data = DataTranslater.Serialize(modifyParam);
//byte[] ret_data = Request("ApplyStrategySettings", param_data);
}
public void PortfEnableStrategy(string portfId, bool isEnabled)
{
entity.ModifyRunningStatusParam runningParam = new entity.ModifyRunningStatusParam();
runningParam.PortfId = portfId;
runningParam.Enabled = isEnabled;
byte[] param_data = DataTranslater.Serialize(runningParam);
byte[] ret_data = Request("PortfEnableStrategy", param_data);
}
public void PortfSetPreferredLeg(string portfId, string legName)
{
entity.ModifyPortfolioPreferredLegParam modifyParam = new entity.ModifyPortfolioPreferredLegParam();
modifyParam.PortfId = portfId;
modifyParam.LegSymbol = legName;
byte[] param_data = DataTranslater.Serialize(modifyParam);
byte[] ret_data = Request("PortfSetPreferredLeg", param_data);
}
public override byte[] Serialize()
{
entity.ChangePosiStrategySettings settings = new entity.ChangePosiStrategySettings();
settings.CloseLeg = CloseLeg;
settings.CloseLegSide = CloseLegSide;
settings.TriggerCondition = (entity.CompareCondition)TriggerCondition;
settings.Threshold = Threshold;
return(DataTranslater.Serialize <entity.ChangePosiStrategySettings>(settings));
}
public void AddPortfCollection(IEnumerable <PortfolioItem> portfItems)
{
AddPortfolioParam addPortfParam = new AddPortfolioParam();
addPortfParam.PortfolioItems.AddRange(portfItems);
byte[] portf_data = DataTranslater.Serialize(addPortfParam);
byte[] ret_data = Request("AddPortfCollection", portf_data);
}
public void RegisterQuote(string[] symbols)
{
RegQuoteParam regQuoteParam = new RegQuoteParam();
regQuoteParam.Symbols.AddRange(symbols);
byte[] param_data = DataTranslater.Serialize(regQuoteParam);
byte[] ret_data = Request("RegQuote", param_data);
}
void OnReceivedData(string data)
{
if (killCount == null || deathCount == null)
{
return;
}
killCount.text = DataTranslater.DataToKill(data).ToString() + " kills";
deathCount.text = DataTranslater.DataToDeaths(data).ToString() + " deaths";
}
public void PorfClosePosition(string pid, int quantity, bool isVirtual)
{
PorfOpenPosiParam opParam = new PorfOpenPosiParam();
opParam.PortfId = pid;
opParam.Quantity = quantity;
opParam.IsVirtual = isVirtual;
byte[] param_data = DataTranslater.Serialize(opParam);
byte[] ret_data = Request("PorfClosePosition", param_data);
}
public void PortfModifyQuantity(string portfId, int onceQty, int maxQty)
{
ModifyPortfolioQtyParam qtyParam = new ModifyPortfolioQtyParam();
qtyParam.PortfId = portfId;
qtyParam.OnceQty = onceQty;
qtyParam.MaxQty = maxQty;
byte[] param_data = DataTranslater.Serialize(qtyParam);
byte[] ret_data = Request("PortfChgQuantity", param_data);
}
public void ScalperOpenPosition(string pid, int quantity)
{
PorfOpenPosiParam opParam = new PorfOpenPosiParam();
opParam.PortfId = pid;
opParam.Quantity = quantity;
opParam.IsVirtual = false;
byte[] param_data = DataTranslater.Serialize(opParam);
//byte[] ret_data = Request("ScalperOpenPosition", param_data);
}
protected override void DispatchCallback(string method, byte[] paramData)
{
if (method == "TestCallback")
{
if (OnCallbackEvent != null)
{
TestCallbackParams cbParams = DataTranslater.Deserialize <TestCallbackParams>(paramData);
OnCallbackEvent(cbParams.param3, cbParams.param4);
}
}
}
protected void DispatchCallback(string method, byte[] paramData)
{
if (method == "QuotePush")
{
if (OnQuoteReceived != null)
{
Quote quoteData = DataTranslater.Deserialize <Quote>(paramData);
OnQuoteReceived(quoteData);
}
}
else if (method == "PortfolioPush")
{
if (OnPortfolioItemUpdated != null)
{
PortfolioItem porfItem = DataTranslater.Deserialize <PortfolioItem>(paramData);
OnPortfolioItemUpdated(porfItem);
}
}
else if (method == "MultiLegOrderPush")
{
if (OnMultiLegOrderUpdated != null)
{
MultiLegOrder mlOrder = DataTranslater.Deserialize <MultiLegOrder>(paramData);
OnMultiLegOrderUpdated(mlOrder);
}
}
else if (method == "LegOrderPush")
{
if (OnLegOrderUpdated != null)
{
LegOrderUpdateParam orderUpdateParam = DataTranslater.Deserialize <LegOrderUpdateParam>(paramData);
OnLegOrderUpdated(orderUpdateParam.PortfId,
orderUpdateParam.MultiLegOrderId,
orderUpdateParam.LegOrderRef,
orderUpdateParam.LegOrder);
}
}
else if (method == "TradePush")
{
if (OnTradeUpdated != null)
{
Trade trade = DataTranslater.Deserialize <Trade>(paramData);
OnTradeUpdated(trade);
}
}
else if (method == "PositionDetailReturn")
{
if (OnPositionDetialReturn != null)
{
PositionDetailInfo posiDetail = DataTranslater.Deserialize <PositionDetailInfo>(paramData);
OnPositionDetialReturn(posiDetail);
}
}
}
public void RemovePortf(string portfId)
{
StringParam strParam = new StringParam()
{
Data = portfId
};
byte[] param_data = DataTranslater.Serialize(strParam);
//byte[] ret_data = Request("RemovePortf", param_data);
}
public override byte[] Serialize()
{
entity.ArbitrageStrategySettings entitySettings = new entity.ArbitrageStrategySettings();
entitySettings.Side = Direction;
entitySettings.OpenCondition = (entity.CompareCondition)OpenCondition;
entitySettings.OpenPosiThreshold = OpenThreshold;
entitySettings.StopGainCondition = (entity.CompareCondition)StopGainCondition;
entitySettings.StopGainThreshold = StopGainThreshold;
entitySettings.StopLossCondition = (entity.CompareCondition)StopLossCondition;
entitySettings.StopLossThreshold = StopLossThreshold;
return(DataTranslater.Serialize(entitySettings));
}
public void AddPortf(PortfolioItem portfItem)
{
Debug.Assert(!string.IsNullOrEmpty(portfItem.ID), "Portfolio item must have ID already");
if (string.IsNullOrEmpty(portfItem.ID))
{
return;
}
byte[] portf_data = DataTranslater.Serialize(portfItem);
byte[] ret_data = Request("AddPortf", portf_data);
}
public void CancelOrder(trade.Order legOrder)
{
CancelOrderParam cxlParam = new CancelOrderParam();
cxlParam.OrderRef = legOrder.OrderRef;
cxlParam.ExchangeId = legOrder.ExchangeID;
cxlParam.OrdSysId = legOrder.OrderSysID;
cxlParam.UserId = legOrder.UserID;
cxlParam.Symbol = legOrder.InstrumentID;
byte[] param_data = DataTranslater.Serialize(cxlParam);
//byte[] ret_data = Request("CancelOrder", param_data);
}
public string PortfClosePosition(trade.MultiLegOrder mlOrder, string legRef)
{
ClosePositionParam cpParam = new ClosePositionParam();
cpParam.MultiLegOrder = mlOrder;
cpParam.LegOrdRef = legRef;
byte[] param_data = DataTranslater.Serialize(cpParam);
byte[] ret_data = Request("ClosePosition", param_data);
StringParam strReturn = DataTranslater.Deserialize <StringParam>(ret_data);
return(strReturn.Data);
}
/*
* public void PortfModifyQuantity(string portfId, int perOpenQty, int perStartQty, int totalOpenLimit, int maxCancelQty)
* {
* ModifyPortfolioQtyParam qtyParam = new ModifyPortfolioQtyParam();
* qtyParam.PortfId = portfId;
* qtyParam.OnceQty = onceQty;
* qtyParam.MaxQty = maxQty;
*
* byte[] param_data = DataTranslater.Serialize(qtyParam);
* //byte[] ret_data = Request("PortfChgQuantity", param_data);
* }
*
* public void PortfSetPreferredLeg(string portfId, string legName)
* {
* entity.ModifyPortfolioPreferredLegParam modifyParam = new entity.ModifyPortfolioPreferredLegParam();
* modifyParam.PortfId = portfId;
* modifyParam.LegSymbol = legName;
*
* byte[] param_data = DataTranslater.Serialize(modifyParam);
* //byte[] ret_data = Request("PortfSetPreferredLeg", param_data);
* }
*/
public void PortfTurnSwitches(string portfId, bool autoOpen, bool autoStopGain, bool autoStopLoss,
bool autoTracking, bool enablePrefer)
{
entity.ModifyPortfolioSwitchParam modifyParam = new entity.ModifyPortfolioSwitchParam();
modifyParam.PortfId = portfId;
modifyParam.AutoOpen = autoOpen;
modifyParam.AutoStopGain = autoStopGain;
modifyParam.AutoStopLoss = autoStopLoss;
modifyParam.AutoTracking = autoTracking;
modifyParam.EnablePrefer = enablePrefer;
byte[] param_data = DataTranslater.Serialize(modifyParam);
//byte[] ret_data = Request("PortfTurnSwitches", param_data);
}
public override byte[] Serialize()
{
entity.ScalperSettings setting = new entity.ScalperSettings();
setting.Threshold = Threshold;
setting.PriceTick = PriceTick;
setting.CaseGE4Tick = CaseGE4Tick;
setting.CaseLE2Tick = CaseLE2Tick;
setting.CaseLE3Tick = CaseLE3Tick;
setting.CaseNoChange = CaseNoChange;
setting.StopLossStrategy = StopLossCloseMethod;
setting.RetryTimes = RetryTimes;
setting.OpenTimeout = OpenTimeout;
return(DataTranslater.Serialize(setting));
}
public entity.SymbolInfo QuerySymbolInfo(string symbol)
{
entity.RegQuoteParam symbParam = new entity.RegQuoteParam();
symbParam.Symbols.Add(symbol);
byte[] param_data = DataTranslater.Serialize(symbParam);
byte[] ret_data = null; // Request("QuerySymbolInfo", param_data);
if (ret_data != null)
{
return(DataTranslater.Deserialize <entity.SymbolInfo>(ret_data));
}
return(null);
}
public bool TestHello(string p1, string p2)
{
TestHelloParams tp = new TestHelloParams()
{
param1 = p1,
param2 = p2
};
byte[] param_data = DataTranslater.Serialize(tp);
byte[] ret_data = Request("TestHello", param_data);
if (ret_data != null)
{
TestHelloReturn rt = DataTranslater.Deserialize <TestHelloReturn>(ret_data);
return(rt.success);
}
else
{
throw new Exception("Returned data is invalid");
}
}
//public void PortfSetPreferLeg(string portfId, string legId, )
public trade.AccountInfo QueryAccountInfo()
{
byte[] ret_data = null; //Request("QueryAccountInfo", new byte[]{});
return(DataTranslater.Deserialize <trade.AccountInfo>(ret_data));
}
