public void it_should_get_correct_positions_result()
{
// setup
var givenUrl = "/serach?keyword=facebook";
var mockEndpoint = "http://localhost:5000";
var mockResult = "result";
var mockResponse = new PositionsResponse {
Positions = new List <int> {
1, 5
}
};
_mockConfigService.Setup(c => c.GetApiEndpoint()).Returns(mockEndpoint);
_mockApiClientHandler.Setup(a => a.ConfigureApiClient(mockEndpoint));
_mockApiClientHandler.Setup(a => a.Get(givenUrl)).Returns(mockResult);
_mockApiClientHandler.Setup(a => a.GetPositions(mockResult))
.Returns(mockResponse);
// act
var dto = _scrapperService.GetPositions(givenUrl).Positions.ToList();
// assert
Assert.Equal(dto[0], mockResponse.Positions.ToList()[0]);
Assert.Equal(dto[1], mockResponse.Positions.ToList()[1]);
}
private void OnPositionsResponse(PositionsResponse response)
{
foreach (var pos in response.MoneyPositions.GroupBy(p => p.Client))
{
SendOutMessage(
this.CreatePortfolioChangeMessage(pos.Key)
.Add(PositionChangeTypes.BeginValue, pos.Sum(p => p.SaldoIn))
.Add(PositionChangeTypes.CurrentValue, pos.Sum(p => p.Saldo))
.Add(PositionChangeTypes.Commission, pos.Sum(p => p.Commission)));
}
foreach (var pos in response.SecPositions)
{
SendOutMessage(
new PositionChangeMessage
{
PortfolioName = pos.Client,
SecurityId = new SecurityId {
Native = pos.SecId
},
DepoName = pos.Register,
ServerTime = CurrentTime.Convert(TimeHelper.Moscow),
}
.Add(PositionChangeTypes.BeginValue, pos.SaldoIn)
.Add(PositionChangeTypes.CurrentValue, pos.Saldo)
.Add(PositionChangeTypes.BlockedValue, pos.SaldoMin));
}
foreach (var fortsMoney in response.FortsMoneys)
{
SendOutMessage(
this
.CreatePortfolioChangeMessage(fortsMoney.Client)
.Add(PositionChangeTypes.BeginValue, fortsMoney.Free)
.Add(PositionChangeTypes.CurrentValue, fortsMoney.Current)
.Add(PositionChangeTypes.BlockedValue, fortsMoney.Blocked)
.Add(PositionChangeTypes.VariationMargin, fortsMoney.VarMargin));
}
foreach (var pos in response.FortsPositions)
{
SendOutMessage(this
.CreatePositionChangeMessage(pos.Client, new SecurityId {
Native = pos.SecId
})
.Add(PositionChangeTypes.BeginValue, (decimal)pos.StartNet)
.Add(PositionChangeTypes.CurrentValue, (decimal)pos.TotalNet)
.Add(PositionChangeTypes.VariationMargin, pos.VarMargin));
}
//foreach (var fortsCollaterals in response.FortsCollateralses)
//{
//}
//foreach (var spotLimit in response.SpotLimits)
//{
//}
}
public IActionResult GetAll()
{
Empty request = new();
try
{
PositionsResponse response = _positionsClient.GetAll(request);
LogData logData = new()
{
CallSide = nameof(PositionsController),
CallerMethodName = nameof(GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = response
};
_logger.AddLog(logData);
return(Ok(response));
}
catch (Exception ex)
{
LogData logData = new()
{
CallSide = nameof(PositionsController),
CallerMethodName = nameof(GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = ex
};
_logger.AddErrorLog(logData);
return(InternalServerError());
}
}
public void GetAll_should_handle_exception()
{
// Arrange
BaseMock.ShouldThrowException = true;
PositionsResponse expectedResponse = new()
{
Status = new BaseResponse {
Code = Code.UnknownError, ErrorMessage = "An error occured while loading positions data"
}
};
Empty request = new Empty();
LogData expectedLog = new()
{
CallSide = nameof(PositionsService),
CallerMethodName = nameof(_positionsService.GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = new Exception("Test exception")
};
// Act
PositionsResponse actual = _positionsService.GetAll(request, null).Result;
// Assert
Assert.AreEqual(expectedResponse, actual, "Data as expected");
_loggerMock.Verify(mocks => mocks.AddErrorLog(expectedLog), Times.Once);
}
[Test]
public static void CalculatePL(PositionsResponse positionsResponse)
{
Contract.Requires(positionsResponse != null);
positionsResponse.Positions.ForEach(openPosition =>
{
openPosition.Position.ProfitAndLoss = CalculatePL(openPosition).Value;
});
}
public void SellAllUSNGStocks(string curAccountNumber)
{
PositionsResponse positions = GetPositions(curAccountNumber);
var ngPositionUSD = positions.positions.FirstOrDefault(p => p.symbol == NG_SYMBOL_USD);
if (ngPositionUSD != null && ngPositionUSD.openQuantity > 0)
{
Console.WriteLine("\nSelling converted NG stocks...\n");
CreateMarketOrder(curAccountNumber, ngPositionUSD.symbol, ngPositionUSD.symbolId, false, (int)ngPositionUSD.openQuantity);
}
}
public List <PendingOrder> GetPendingOrdersForAccount(string accountNumber)
{
var pendingOrders = new List <PendingOrder>();
PositionsResponse positions = GetPositions(accountNumber);
BalancesResponse balances = GetBalances(accountNumber);
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == accountNumber);
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
var quote = GetQuote(symbol.symbolId);
var curPosition = positions.positions.FirstOrDefault(p => p.symbol == curStockTarget.Symbol);
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
double curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
double accountTargetPercent = ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100)) * 100;
double percentOfTarget = (curPercentOwned / accountTargetPercent) * 100;
if (percentOfTarget < 100)
{
var valueToBuy = ((accountTargetPercent - curPercentOwned) / 100) * totalEquity;
int numSharesToBuy = (int)Math.Floor(valueToBuy / quote.askPrice);
if (numSharesToBuy > 0)
{
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
IsBuyOrder = true,
TargetValue = valueToBuy,
Quantity = numSharesToBuy,
TargetPercent = accountTargetPercent,
OwnedPercent = curPercentOwned,
});
}
}
}
}
return(pendingOrders);
}
public void GetAll_should_return_all_positions_from_db()
{
// Arrange
PositionsResponse expectedResponse = new()
{
Status = new BaseResponse {
Code = Code.Success, ErrorMessage = string.Empty
}
};
expectedResponse.Data.Add(new PositionData
{
Id = _position1.Id,
CreatedOn = Timestamp.FromDateTime(_position1.CreatedOn),
HourRate = _position1.HourRate,
Name = _position1.Name,
TeamId = _position1.TeamId
});
expectedResponse.Data.Add(new PositionData
{
Id = _position2.Id,
CreatedOn = Timestamp.FromDateTime(_position2.CreatedOn),
HourRate = _position2.HourRate,
Name = _position2.Name,
TeamId = _position2.TeamId
});
Empty request = new Empty();
LogData expectedLog = new()
{
CallSide = nameof(PositionsService),
CallerMethodName = nameof(_positionsService.GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = expectedResponse
};
// Act
PositionsResponse actual = _positionsService.GetAll(request, null).Result;
// Assert
Assert.AreEqual(expectedResponse, actual, "Data as expected");
_loggerMock.Verify(mocks => mocks.AddLog(expectedLog), Times.Once);
}
[Test]
public void SellAllSecuritiesInAccount(string accountNumber)
{
if (IS_LIVE)
{
throw new Exception("Attempting to sell all securities on a LIVE account!");
}
else
{
PositionsResponse positions = GetPositions(accountNumber);
foreach (var curPosition in positions.positions)
{
if (curPosition.openQuantity > 0)
{
CreateMarketOrder(accountNumber, curPosition.symbol, curPosition.symbolId, false, (int)curPosition.openQuantity);
}
}
}
}
public void GetAll_should_return_Response_from_grpc_client()
{
// Arrange
PositionsResponse response = new()
{
Status = new BaseResponse {
Code = Code.Success, ErrorMessage = string.Empty
}
};
response.Data.Add(new PositionData
{
Name = "test",
CreatedOn = Timestamp.FromDateTime(_dateTimeUtil.GetCurrentDateTime()),
HourRate = 10,
TeamId = 1,
Id = 1
});
BaseMock.Response = response;
LogData expectedLog = new()
{
CallSide = nameof(PositionsController),
CallerMethodName = nameof(_positionsController.GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = new Empty(),
Response = response
};
// Act
ObjectResult actual = _positionsController.GetAll() as ObjectResult;
PositionsResponse actualData = actual.Value as PositionsResponse;
// Assert
Assert.AreEqual(200, actual.StatusCode, "Status code as expected");
Assert.AreEqual(response, actual.Value, "Response as expected");
_loggerMock.Verify(m => m.AddLog(expectedLog), Times.Once);
_positionsClientMock.Verify(m => m.GetAll(new Empty(), null, null, new CancellationToken()), Times.Once);
}
[Test]
public void GetAll_should_handle_exception()
{
// Arrange
BaseMock.ShouldThrowException = true;
LogData expectedLog = new()
{
CallSide = nameof(PositionsController),
CallerMethodName = nameof(_positionsController.GetAll),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = new Empty(),
Response = new Exception(BaseMock.ExceptionMessage)
};
// Act
ObjectResult actual = _positionsController.GetAll() as ObjectResult;
PositionsResponse actualData = actual.Value as PositionsResponse;
// Assert
Assert.AreEqual(500, actual.StatusCode, "Status code as expected");
Assert.AreEqual(BaseMock.ErrorResponseMessage, actual.Value, "Response as expected");
_loggerMock.Verify(m => m.AddErrorLog(expectedLog), Times.Once);
_positionsClientMock.Verify(m => m.GetAll(new Empty(), null, null, new CancellationToken()), Times.Once);
}
public List <PendingOrder> GetAccountBreakdown(string accountNumber)
{
var pendingOrders = new List <PendingOrder>();
PositionsResponse positions = GetPositions(accountNumber);
BalancesResponse balances = GetBalances(accountNumber);
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == accountNumber);
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
var quote = GetQuote(symbol.symbolId);
var curPosition = positions.positions.FirstOrDefault(p => p.symbol == curStockTarget.Symbol);
double curPercentOwned = 0;
double curValue = 0;
int curQuantity = 0;
if (curPosition != null)
{
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
curValue = curPosition.currentMarketValue;
curQuantity = (int)curPosition.openQuantity;
}
double accountTargetPercent = ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100)) * 100;
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
TargetValue = curValue,
Quantity = curQuantity,
TargetPercent = accountTargetPercent,
OwnedPercent = curPercentOwned,
});
}
}
// add owned stocks that are not on the target list
foreach (var curPosition in positions.positions)
{
if (pendingOrders.FirstOrDefault(p => p.Symbol.symbol == curPosition.symbol) == null)
{
var symbol = GetSymbol(curPosition.symbol);
var quote = GetQuote(symbol.symbolId);
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
double curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
TargetValue = curPosition.currentMarketValue,
Quantity = (int)curPosition.openQuantity,
TargetPercent = 0,
OwnedPercent = curPercentOwned,
});
}
}
return(pendingOrders);
}
public List <PendingOrder> GetNorbertsGambitRequirements(List <PendingOrder> pendingOrders)
{
var NGSymbolUSD = GetSymbol(NG_SYMBOL_USD);
var NGQuoteUSD = GetQuote(NGSymbolUSD.symbolId);
var pendingNGOrders = new List <PendingOrder>();
var pendingOrderGroups = pendingOrders.GroupBy(p => p.AccountNumber);
foreach (var curPendingOrderGroup in pendingOrderGroups)
{
var curAccountNumber = curPendingOrderGroup.Key;
// sell all NG stocks that are already converted to US
SellAllUSNGStocks(curAccountNumber);
// get total USD required
double requiredUSD = 0;
foreach (var curPendingOrder in curPendingOrderGroup)
{
if (curPendingOrder.Symbol.currency == CURRENCY_USD)
{
requiredUSD += curPendingOrder.TargetValue;
}
}
//get total USD that is waiting to be converted
BalancesResponse balances = GetBalances(curAccountNumber);
var curBalanceUSD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_USD);
// calculate value already being converted
PositionsResponse positions = GetPositions(curAccountNumber);
var ngPositionCAD = positions.positions.FirstOrDefault(p => p.symbol == NG_SYMBOL_CAD);
var pendingNGValueUSD = 0.0;
if (ngPositionCAD != null)
{
pendingNGValueUSD = ngPositionCAD.openQuantity * NGQuoteUSD.bidPrice;
}
var remainingUSDRequired = requiredUSD - (curBalanceUSD.cash + pendingNGValueUSD);
if (remainingUSDRequired > 0)
{
var numNGSharesNeeded = (int)Math.Ceiling(remainingUSDRequired / NGQuoteUSD.bidPrice);
var NGSymbolCAD = GetSymbol(NG_SYMBOL_CAD);
var NGQuoteCAD = GetQuote(NGSymbolCAD.symbolId);
pendingNGOrders.Add(new PendingOrder()
{
AccountNumber = curAccountNumber,
Symbol = NGSymbolCAD,
Quote = NGQuoteCAD,
Quantity = numNGSharesNeeded,
IsBuyOrder = true,
TargetValue = numNGSharesNeeded * NGQuoteCAD.askPrice
});
}
}
return(pendingNGOrders);
}
public List <PendingOrder> GetNorbertsGambitRequirements()
{
var NGSymbolUSD = GetSymbol(NG_SYMBOL_USD);
var NGQuoteUSD = GetQuote(NGSymbolUSD.symbolId);
var pendingNGOrders = new List <PendingOrder>();
foreach (var curAccount in curUser.accounts)
{
// sell all NG stocks that are already converted to US
SellAllUSNGStocks(curAccount.number);
BalancesResponse balances = GetBalances(curAccount.number);
// calculate total amount of USD that should be in the account
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == curAccount.number);
double requiredUSDValue = 0;
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
if (symbol.currency == CURRENCY_USD)
{
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
requiredUSDValue += totalEquity * ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100));
}
}
}
// reduce required amount by USD assets already owned
PositionsResponse positions = GetPositions(curAccount.number);
foreach (var curPosition in positions.positions)
{
var symbol = GetSymbol(curPosition.symbol);
if (symbol.currency == CURRENCY_USD)
{
requiredUSDValue -= curPosition.currentMarketValue;
}
}
// reduce required amount by the value that is already being processed
var ngPositionCAD = positions.positions.FirstOrDefault(p => p.symbol == NG_SYMBOL_CAD);
if (ngPositionCAD != null)
{
requiredUSDValue -= ngPositionCAD.openQuantity * NGQuoteUSD.bidPrice;
}
if (requiredUSDValue > 0)
{
var numNGSharesNeeded = (int)Math.Ceiling(requiredUSDValue / NGQuoteUSD.bidPrice);
var NGSymbolCAD = GetSymbol(NG_SYMBOL_CAD);
var NGQuoteCAD = GetQuote(NGSymbolCAD.symbolId);
var valueToBuyCAD = numNGSharesNeeded * NGQuoteCAD.askPrice;
// if required to buy is greater than cash on hand, truncate to cash level.
var curCashCAD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_CAD).cash;
if (valueToBuyCAD > curCashCAD)
{
numNGSharesNeeded = (int)Math.Floor(curCashCAD / NGQuoteCAD.askPrice);
valueToBuyCAD = numNGSharesNeeded * NGQuoteCAD.askPrice;
}
pendingNGOrders.Add(new PendingOrder()
{
AccountNumber = curAccount.number,
Symbol = NGSymbolCAD,
Quote = NGQuoteCAD,
Quantity = numNGSharesNeeded,
IsBuyOrder = true,
TargetValue = valueToBuyCAD
});
}
}
return(pendingNGOrders);
}
/// <summary>
/// Finds the expected response object derived from the URI of the call.
/// </summary>
/// <returns></returns>
private object ApiResponseDispatcher()
{
// Json is empty > Shit...
if (String.IsNullOrEmpty(Json))
{
//log.Error("Json == null or empty");
return(null);
}
// Uri is empty > Shit...
if (this.Uri == null || this.Uri.AbsolutePath == "")
{
//log.Error("Uri.AbsolutePath null or empty");
return(null);
}
object o;
// Return the correct type based on the Uri
switch (this.Uri.AbsolutePath.ToLower())
{
case "/api/v1/order":
if (this.Json.Substring(0, 1) == "[")
{
o = OrdersResponse.FromJson(this.Json);
}
else
{
o = OrderResponse.FromJson(this.Json);
}
break;
case "/api/v1/order/all":
case "/api/v1/order/bulk":
o = OrdersResponse.FromJson(this.Json);
break;
case "/api/v1/position/leverage":
o = PositionResponse.FromJson(this.Json);
break;
case "/api/v1/position":
o = PositionsResponse.FromJson(this.Json);
break;
case "/api/v1/order/closeposition":
o = OrderResponse.FromJson(this.Json);
break;
case "/api/v1/user/wallet":
o = WalletResponse.FromJson(this.Json);
break;
case "/api/v1/order/cancelallafter":
default:
o = null;
//log.Error("Uri unknown. Please add [" + this.Uri.AbsolutePath + "] to the evaluated Uri's.");
break;
}
return(o);
}
