public void TestCalculateAccountExposure()
{
decimal equity;
decimal reservedMargin;
decimal exposure;
List <MarketOrder> orders;
var profitCalculator = ProfitCalculator.Instance;
fakeAccountManager.GetMarketOrders(testAccount.ID, out orders);
var dicExp = profitCalculator.CalculateAccountExposure(testAccount.ID,
out equity, out reservedMargin, out exposure, QuoteStorage.Instance.ReceiveAllData(),
fakeAccountManager, i => testGroup);
Assert.AreEqual(orders.Select(o => o.Symbol).Distinct().Count(),
dicExp.Count, "CalculateAccountExposure() - вернула нужное количество записей");
// проверить общую экспозицию
var dealByTicker = orders.GroupBy(o => o.Symbol).ToDictionary(o => o.Key,
o => Math.Abs(o.Sum(ord => ord.Side * ord.Volume)));
var quotes = QuoteStorage.Instance.ReceiveAllData();
var mustBeExposure = dealByTicker.Sum(deal =>
{
string errorStr;
return(DalSpot.Instance.ConvertToTargetCurrency(deal.Key, true, testAccount.Currency,
deal.Value, quotes, out errorStr, true) ?? 0);
});
var deltaExp = Math.Abs(mustBeExposure - exposure);
Assert.Less(deltaExp, 1, "CalculateAccountExposure() - неверный расчет экспозиции");
}
/// <summary>
/// возвращает позиции, которые надо закрыть
/// </summary>
public List <MarketOrder> CheckMarketOrders(int accountId)
{
var execOrders = new List <MarketOrder>();
List <MarketOrder> orders;
var status = proxyAccount.GetMarketOrders(accountId, out orders);
if (status != RequestStatus.OK)
{
return(execOrders);
}
foreach (var pos in orders)
{
var quote = quoteStorage.ReceiveValue(pos.Symbol);
if (quote == null)
{
continue;
}
CheckOrderTrailing(pos, quote);
if (pos.Side == 1)
{
if (pos.StopLoss != null && pos.StopLoss >= quote.bid)
{
execOrders.Add(pos);
pos.ExitReason = PositionExitReason.SL;
}
else
if (pos.TakeProfit != null && pos.TakeProfit <= quote.bid)
{
execOrders.Add(pos);
pos.ExitReason = PositionExitReason.TP;
}
}
else
{
// sell позиция
if (pos.StopLoss != null && pos.StopLoss <= quote.ask)
{
execOrders.Add(pos);
pos.ExitReason = PositionExitReason.SL;
}
else
if (pos.TakeProfit != null && pos.TakeProfit >= quote.ask)
{
execOrders.Add(pos);
pos.ExitReason = PositionExitReason.TP;
}
}
}
return(execOrders);
}
public decimal CalculateAccountEquity(int accountId, decimal balance, string depoCurx,
Dictionary<string, QuoteData> curPrices, ITradeSharpAccount proxyAccount)
{
var equity = balance;
List<MarketOrder> posList;
var result = proxyAccount.GetMarketOrders(accountId, out posList);
if (result != RequestStatus.OK)
{
Logger.ErrorFormat("Ошибка в CalculateAccountEquity({0}) - ошибка получения позиций", accountId);
return 0;
}
equity += posList.Sum(p =>
p.State != PositionState.Opened ? 0
: CalculatePositionProfit(p, depoCurx, curPrices));
return equity;
}
public decimal CalculateAccountEquity(int accountId, decimal balance, string depoCurx,
Dictionary <string, QuoteData> curPrices, ITradeSharpAccount proxyAccount)
{
var equity = balance;
List <MarketOrder> posList;
var result = proxyAccount.GetMarketOrders(accountId, out posList);
if (result != RequestStatus.OK)
{
Logger.ErrorFormat("Ошибка в CalculateAccountEquity({0}) - ошибка получения позиций", accountId);
return(0);
}
equity += posList.Sum(p =>
p.State != PositionState.Opened ? 0
: CalculatePositionProfit(p, depoCurx, curPrices));
return(equity);
}
private void MakeTradeSharpAccountProxy()
{
fakeAccountManager = ProxyBuilder.Instance.MakeImplementer<ITradeSharpAccount>(true);
// "замочить" нужные методы
// ReSharper disable SuspiciousTypeConversion.Global
Account account;
((IMockableProxy)fakeAccountManager).MockMethods.Add(
// ReSharper restore SuspiciousTypeConversion.Global
StronglyName.GetMethodName<ITradeSharpAccount>(
f => f.GetAccountInfo(0, false, out account)),
new GetAccountInfoDel((int accountId, bool needEquityInfo, out Account act) =>
{
act = testAccount;
act.ID = accountId;
if (needEquityInfo)
{
List<MarketOrder> ordList;
fakeAccountManager.GetMarketOrders(accountId, out ordList);
var profit = DalSpot.Instance.CalculateOpenedPositionsCurrentResult(ordList,
QuoteStorage.Instance.ReceiveAllData(), act.Currency);
act.Equity = act.Balance + (decimal)profit;
}
return RequestStatus.OK;
}));
List<MarketOrder> orders;
// ReSharper disable SuspiciousTypeConversion.Global
((IMockableProxy)fakeAccountManager).MockMethods.Add(
// ReSharper restore SuspiciousTypeConversion.Global
StronglyName.GetMethodName<ITradeSharpAccount>(
f => f.GetMarketOrders(0, out orders)),
new GetMarketOrdersDel((int accountId, out List<MarketOrder> ordList) =>
{
ordList = new List<MarketOrder>
{
new MarketOrder
{
AccountID = accountId,
Symbol = "EURUSD",
Side = (int)DealType.Buy,
Volume = 100000,
PriceEnter = 1.3140f,
State = PositionState.Opened
},
new MarketOrder
{
AccountID = accountId,
Symbol = "EURUSD",
Side = (int)DealType.Sell,
Volume = 20000,
PriceEnter = 1.3180f,
State = PositionState.Opened
},
new MarketOrder
{
AccountID = accountId,
Symbol = "USDCAD",
Side = (int)DealType.Sell,
Volume = 80000,
PriceEnter = 1.1130f,
State = PositionState.Opened
}
};
return RequestStatus.OK;
}));
}
private void MakeTradeSharpAccountProxy()
{
fakeAccountManager = ProxyBuilder.Instance.MakeImplementer <ITradeSharpAccount>(true);
// "замочить" нужные методы
// ReSharper disable SuspiciousTypeConversion.Global
Account account;
((IMockableProxy)fakeAccountManager).MockMethods.Add(
// ReSharper restore SuspiciousTypeConversion.Global
StronglyName.GetMethodName <ITradeSharpAccount>(
f => f.GetAccountInfo(0, false, out account)),
new GetAccountInfoDel((int accountId, bool needEquityInfo, out Account act) =>
{
act = testAccount;
act.ID = accountId;
if (needEquityInfo)
{
List <MarketOrder> ordList;
fakeAccountManager.GetMarketOrders(accountId, out ordList);
var profit = DalSpot.Instance.CalculateOpenedPositionsCurrentResult(ordList,
QuoteStorage.Instance.ReceiveAllData(), act.Currency);
act.Equity = act.Balance + (decimal)profit;
}
return(RequestStatus.OK);
}));
List <MarketOrder> orders;
// ReSharper disable SuspiciousTypeConversion.Global
((IMockableProxy)fakeAccountManager).MockMethods.Add(
// ReSharper restore SuspiciousTypeConversion.Global
StronglyName.GetMethodName <ITradeSharpAccount>(
f => f.GetMarketOrders(0, out orders)),
new GetMarketOrdersDel((int accountId, out List <MarketOrder> ordList) =>
{
ordList = new List <MarketOrder>
{
new MarketOrder
{
AccountID = accountId,
Symbol = "EURUSD",
Side = (int)DealType.Buy,
Volume = 100000,
PriceEnter = 1.3140f,
State = PositionState.Opened
},
new MarketOrder
{
AccountID = accountId,
Symbol = "EURUSD",
Side = (int)DealType.Sell,
Volume = 20000,
PriceEnter = 1.3180f,
State = PositionState.Opened
},
new MarketOrder
{
AccountID = accountId,
Symbol = "USDCAD",
Side = (int)DealType.Sell,
Volume = 80000,
PriceEnter = 1.1130f,
State = PositionState.Opened
}
};
return(RequestStatus.OK);
}));
}
public Dictionary <string, decimal> CalculateAccountExposure(int accountId,
out decimal equity,
out decimal reservedMargin,
out decimal exposure,
Dictionary <string, QuoteData> curPrices,
ITradeSharpAccount proxyAccount,
Func <int, AccountGroup> getAccountGroup)
{
if (curPrices == null)
{
Logger.Error("Ошибка в CalculateAccountExposure - curPrices == null");
throw new Exception("Ошибка в CalculateAccountExposure - curPrices == null");
}
equity = 0;
exposure = 0;
reservedMargin = 0;
var exps = new Dictionary <string, decimal>();
Account account;
proxyAccount.GetAccountInfo(accountId, true, out account);
if (account == null)
{
return(exps);
}
equity = account.Equity;
List <MarketOrder> marketOrders;
try
{
var result = proxyAccount.GetMarketOrders(accountId, out marketOrders);
if (result != RequestStatus.OK)
{
return(exps);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - GetMarketOrders", ex);
throw;
}
if (marketOrders == null)
{
Logger.Error("Ошибка в CalculateAccountExposure - posInf == null");
throw new Exception("Ошибка в CalculateAccountExposure - posInf == null");
}
foreach (var position in marketOrders)
{
var volume = position.Volume * position.Side;
if (exps.ContainsKey(position.Symbol))
{
exps[position.Symbol] += volume;
}
else
{
exps.Add(position.Symbol, volume);
}
}
// перевести экспозицию по каждой валюте в валюту депо
foreach (var pair in exps)
{
var deltaExp = pair.Value;
try
{
string errorStr;
var deltaExpDepo = DalSpot.Instance.ConvertToTargetCurrency(pair.Key, true, account.Currency,
(double)deltaExp, curPrices, out errorStr, true);
if (deltaExpDepo.HasValue)
{
exposure += Math.Abs(deltaExpDepo.Value);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - ConvertBase2Depo", ex);
throw;
}
}
// марж. требования
try
{
var accountGroup = getAccountGroup(accountId);
reservedMargin = exposure / (decimal)accountGroup.BrokerLeverage;
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - getAccountGroup", ex);
throw;
}
return(exps);
}
public Dictionary<string, decimal> CalculateAccountExposure(int accountId,
out decimal equity,
out decimal reservedMargin,
out decimal exposure,
Dictionary<string, QuoteData> curPrices,
ITradeSharpAccount proxyAccount,
Func<int, AccountGroup> getAccountGroup)
{
if (curPrices == null)
{
Logger.Error("Ошибка в CalculateAccountExposure - curPrices == null");
throw new Exception("Ошибка в CalculateAccountExposure - curPrices == null");
}
equity = 0;
exposure = 0;
reservedMargin = 0;
var exps = new Dictionary<string, decimal>();
Account account;
proxyAccount.GetAccountInfo(accountId, true, out account);
if (account == null) return exps;
equity = account.Equity;
List<MarketOrder> marketOrders;
try
{
var result = proxyAccount.GetMarketOrders(accountId, out marketOrders);
if (result != RequestStatus.OK) return exps;
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - GetMarketOrders", ex);
throw;
}
if (marketOrders == null)
{
Logger.Error("Ошибка в CalculateAccountExposure - posInf == null");
throw new Exception("Ошибка в CalculateAccountExposure - posInf == null");
}
foreach (var position in marketOrders)
{
var volume = position.Volume * position.Side;
if (exps.ContainsKey(position.Symbol)) exps[position.Symbol] += volume;
else
exps.Add(position.Symbol, volume);
}
// перевести экспозицию по каждой валюте в валюту депо
foreach (var pair in exps)
{
var deltaExp = pair.Value;
try
{
string errorStr;
var deltaExpDepo = DalSpot.Instance.ConvertToTargetCurrency(pair.Key, true, account.Currency,
(double)deltaExp, curPrices, out errorStr, true);
if (deltaExpDepo.HasValue)
exposure += Math.Abs(deltaExpDepo.Value);
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - ConvertBase2Depo", ex);
throw;
}
}
// марж. требования
try
{
var accountGroup = getAccountGroup(accountId);
reservedMargin = exposure / (decimal)accountGroup.BrokerLeverage;
}
catch (Exception ex)
{
Logger.Error("Ошибка в CalculateAccountExposure - getAccountGroup", ex);
throw;
}
return exps;
}