public async Task <GenericResponse <AddRatingModel> > AddEndorsements(AddRatingModel addRatingModel)
{
GenericResponse <AddRatingModel> savedUserResponse = new GenericResponse <AddRatingModel>();
HttpResponseMessage response = null;
var uri = new Uri(string.Format(ApiPath.PostRating(), string.Empty));
try
{
var json = JsonConvert.SerializeObject(addRatingModel);
var content = new StringContent(json, Encoding.UTF8, "application/json");
HttpClient _client = new HttpClient();
response = await _client.PostAsync(uri, content);
if (response.IsSuccessStatusCode)
{
var respContent = await response.Content.ReadAsStringAsync();
savedUserResponse = JsonConvert.DeserializeObject <GenericResponse <AddRatingModel> >(respContent);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(savedUserResponse);
}
public async Task Should_RenamePortfolio()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Rename Portfolio
var newName = "newname!";
var renamePayload = new { name = newName }.ToJsonPayload();
var renameResponse = await _client.PatchAsync(ApiPath.Portfolio(portfolio.Id) + "/rename", renamePayload);
renameResponse.EnsureSuccessStatusCode();
// Grab Portfolio and verify renamed
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
getPortfolioResponse.EnsureSuccessStatusCode();
var fetchedPortfolio = await getPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.Equal(portfolio.Id, fetchedPortfolio.Id);
Assert.Equal(newName, fetchedPortfolio.Name);
}
async Task UpdateNames()
{
//await LogMessage("Starting name update...");
ApiPath path = ESI.Path("/corporations/{corporation_id}/members/");
ApiResponse respose = await path.Get(("corporation_id", 98270640));
List <string> corpUsers = respose.ToType <List <string> >().Response;
Dictionary <ulong, ulong> dbUser = await GetDbUsers();
foreach (IGuildUser user in await guild.GetUsersAsync())
{
bool userAuthed = dbUser.TryGetValue(user.Id, out ulong eveId);
if (userAuthed)
{
await VerifyName(user, eveId);
}
await VerifyRole(user, guild.GetRole(Config.AuthedRole), userAuthed);
// Check if user has correct corp roles.
bool corpStatus = corpUsers.Contains(eveId.ToString());
if (userAuthed)
{
await VerifyRole(user, guild.GetRole(Config.CorpRole), corpStatus);
}
}
//await LogMessage("Done.");
}
public async Task Should_DeletePortfolioWithSymbols()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Search for symbols by keyword
SymbolSearchResultDTO jpmSymbol = await FetchSymbol("JPM", ExchangeType.NYSE);
// Add symbols to Portfolio
var addJPMResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = jpmSymbol.SymbolId }.ToJsonPayload());
addJPMResponse.EnsureSuccessStatusCode();
// Verify Portfolio exists
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
getPortfolioResponse.EnsureSuccessStatusCode();
// Delete and check it no longer exists
var deletePortfolioResponse = await _client.DeleteAsync(ApiPath.Portfolio(portfolio.Id));
deletePortfolioResponse.EnsureSuccessStatusCode();
var getPortfolioAfterDeleteResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
Assert.Equal(HttpStatusCode.NotFound, getPortfolioAfterDeleteResponse.StatusCode);
}
private async Task AddSymbolToPortfolio(TestUser testUser, int symbolId)
{
var addResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(testUser.PortfolioId), new { SymbolId = symbolId }.ToJsonPayload());
addResponse.EnsureSuccessStatusCode();
await addResponse.Content.ReadAsAsync <PortfolioSymbol>();
}
private async Task <List <StockSingleQuoteDataDTO> > GetSingleQuoteData(int[] symbolIds)
{
string singleQuotePath = ApiPath.GetSingleQuoteData(symbolIds);
var response = await _client.GetAsync(singleQuotePath);
var data = await response.Content.ReadAsAsync <IEnumerable <StockSingleQuoteDataDTO> >();
return(data.ToList());
}
public override void SetAuthorization(string id, string key)
{
var headers = HttpRequestMessage.Headers.ToDictionary(httpRequestHeader => httpRequestHeader.Key,
httpRequestHeader => httpRequestHeader.Value.First());
var sign = QcloudClsSignature.BuildSignature(id, key, HttpRequestMessage.Method.Method,
ApiPath.EnsureStartsWith('/'), RequestParamsRecord, headers, 300000);
HttpRequestMessage.Headers.TryAddWithoutValidation("Authorization", sign);
}
public async Task Should_HandleEmptyData()
{
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(100));
LeaderBoardViewModel leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
Assert.Empty(leaderBoardViewModel.WorstPerformers.Values);
Assert.Empty(leaderBoardViewModel.BestPerformers.Values);
Assert.Empty(leaderBoardViewModel.MostBearish.Values);
Assert.Empty(leaderBoardViewModel.MostBullish.Values);
}
public async Task Should_SetTheCorrectColumnHeaders()
{
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(100));
var leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
Assert.Equal("Worst Performing User", leaderBoardViewModel.WorstPerformers.Header);
Assert.Equal("Best Performing User", leaderBoardViewModel.BestPerformers.Header);
Assert.Equal("Most Bearish Stock", leaderBoardViewModel.MostBearish.Header);
Assert.Equal("Most Bullish Stock", leaderBoardViewModel.MostBullish.Header);
}
private async Task <Dictionary <int, TotalVotes> > GetVoteData(string userId, int[] symbolIds)
{
var httpMessage = new HttpRequestMessage(HttpMethod.Get, ApiPath.GetVotes(symbolIds));
httpMessage.Headers.Add(TestAuthHandler.CustomUserIdHeader, userId);
var fetchResponse = await _client.SendAsync(httpMessage);
fetchResponse.EnsureSuccessStatusCode();
Dictionary <int, TotalVotes> voteData = await fetchResponse.Content.ReadAsAsync <Dictionary <int, TotalVotes> >();
return(voteData);
}
private async Task <SymbolSearchResultDTO> FetchSymbol(string ticker, ExchangeType exchange)
{
var response = await _client.GetAsync(ApiPath.SymbolSearch(ticker, 1));
response.EnsureSuccessStatusCode();
var searchResults = await response.Content.ReadAsAsync <IEnumerable <SymbolSearchResultDTO> >();
var result = searchResults.Single();
Assert.Equal(ticker, result.Ticker);
return(searchResults.Single());
}
public async Task Should_ReturnBadRequest_WhenAddNonExistingSymbolToPortfolio()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Add symbols to Portfolio
var addInvalidSymbolResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = -999 }.ToJsonPayload());
Assert.Equal(HttpStatusCode.BadRequest, addInvalidSymbolResponse.StatusCode);
}
private async Task AddSymbolToPortfolioWithAvgPrice(TestUser testUser, int symbolId, decimal averagePrice)
{
var addResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(testUser.PortfolioId), new { SymbolId = symbolId }.ToJsonPayload());
addResponse.EnsureSuccessStatusCode();
PortfolioSymbol portfolioSymbol = await addResponse.Content.ReadAsAsync <PortfolioSymbol>();
var httpMessage = new HttpRequestMessage(HttpMethod.Patch, ApiPath.PortfolioSymbolsAveragePrice(testUser.PortfolioId, portfolioSymbol.Id));
httpMessage.Headers.Add(TestAuthHandler.CustomUserIdHeader, testUser.UserId.ToString());
httpMessage.Content = (new { AveragePrice = averagePrice }).ToJsonPayload();
var saveResponse = await _client.SendAsync(httpMessage);
saveResponse.EnsureSuccessStatusCode();
}
public async Task Should_OnlyShowedTheTopMembers()
{
TestUser testUser1 = await CreateTestUserWithPortfolio();
TestUser testUser2 = await CreateTestUserWithPortfolio();
TestUser testUser3 = await CreateTestUserWithPortfolio();
SymbolSearchResultDTO jpmStock = await FetchSymbol("JPM", ExchangeType.NYSE);
// Add singlequote stocks
var jpmData = new SingleQuoteData(jpmStock.SymbolId, jpmStock.Ticker, 200, 200, 200, 200, 200, 200, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
await SetSingleQuoteData(new UpsertSingleQuoteData(jpmStock.SymbolId, jpmData));
// Add symbols User 1
await AddSymbolToPortfolioWithAvgPrice(testUser1, jpmStock.SymbolId, 100);
// Add symbols User 2
await AddSymbolToPortfolioWithAvgPrice(testUser2, jpmStock.SymbolId, 200);
// Add symbols User 3
await AddSymbolToPortfolioWithAvgPrice(testUser3, jpmStock.SymbolId, 300);
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(2));
LeaderBoardViewModel leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
// Verify calculations
BoardValue bestPerformerRank1 = leaderBoardViewModel.BestPerformers.Values.ElementAt(0);
BoardValue bestPerformerRank2 = leaderBoardViewModel.BestPerformers.Values.ElementAt(1);
BoardValue worstPerformerRank1 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(0);
BoardValue worstPerformerRank2 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(1);
Assert.Equal(2, leaderBoardViewModel.BestPerformers.Values.Count());
Assert.Equal(2, leaderBoardViewModel.WorstPerformers.Values.Count());
Assert.Equal(testUser1.UserId, Guid.Parse(bestPerformerRank1.Id));
Assert.Equal(testUser2.UserId, Guid.Parse(bestPerformerRank2.Id));
Assert.Equal(testUser3.UserId, Guid.Parse(worstPerformerRank1.Id));
Assert.Equal(testUser2.UserId, Guid.Parse(worstPerformerRank2.Id));
}
public async Task PathSuccsess()
{
ApiPath path = esi.Path("/alliances/");
ApiResponse response = await path.Get();
List <string> alliances = (await path.Get <List <string> >()).Response;
Assert.AreEqual("1354830081", alliances[0]);
ApiPath aPath = esi.Path("/alliances/{alliance_id}/");
await aPath.Get <dynamic>(("alliance_id", alliances[0]));
await aPath.GetBatch <dynamic>(("alliance_id", new List <object> {
alliances[0], alliances[1]
}));
Assert.Pass();
}
public async Task Should_IgnorePortfolioSymbolsWithNoAveragePrice()
{
TestUser testUser1 = await CreateTestUserWithPortfolio();
TestUser testUser2 = await CreateTestUserWithPortfolio();
SymbolSearchResultDTO jpmStock = await FetchSymbol("JPM", ExchangeType.NYSE);
SymbolSearchResultDTO fbStock = await FetchSymbol("FB", ExchangeType.NASDAQ);
// Add singlequote stocks
var jpmData = new SingleQuoteData(jpmStock.SymbolId, jpmStock.Ticker, 200, 200, 200, 200, 200, 200, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
var fbData = new SingleQuoteData(fbStock.SymbolId, fbStock.Ticker, 333.33m, 333.33m, 333.33m, 333.33m, 333.33m, 300, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
await SetSingleQuoteData(new UpsertSingleQuoteData(jpmStock.SymbolId, jpmData));
await SetSingleQuoteData(new UpsertSingleQuoteData(fbData.SymbolId, fbData));
// Add symbols User 1
await AddSymbolToPortfolioWithAvgPrice(testUser1, jpmStock.SymbolId, 100);
await AddSymbolToPortfolio(testUser1, fbStock.SymbolId);
// Add symbols User 2
await AddSymbolToPortfolio(testUser2, jpmStock.SymbolId);
await AddSymbolToPortfolio(testUser2, fbStock.SymbolId);
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(2));
LeaderBoardViewModel leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
// Verify calculations
BoardValue bestPerformerRank1 = leaderBoardViewModel.BestPerformers.Values.ElementAt(0);
BoardValue worstPerformerRank1 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(0);
Assert.Single(leaderBoardViewModel.BestPerformers.Values);
Assert.Single(leaderBoardViewModel.WorstPerformers.Values);
Assert.Equal(testUser1.UserId, Guid.Parse(bestPerformerRank1.Id));
Assert.Equal("100.00", bestPerformerRank1.Value);
Assert.Equal(testUser1.UserId, Guid.Parse(worstPerformerRank1.Id));
Assert.Equal("100.00", worstPerformerRank1.Value);
}
public async Task Should_ReturnMembersGroupedByTheirFirstLetterAlphabetically()
{
var a_users = new List <Guid>();
var d_users = new List <Guid>();
var z_users = new List <Guid>();
var other_users = new List <Guid>();
a_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Abe"));
d_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Dave"));
d_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Dan"));
z_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Zack"));
z_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Zane"));
z_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Zoro"));
z_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "Zax"));
other_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "!12AK47"));
other_users.Add(await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString, "__UK__"));
var httpMessage = new HttpRequestMessage(HttpMethod.Get, ApiPath.MembersData(100, 0));
httpMessage.Headers.Add(TestAuthHandler.CustomUserIdHeader, a_users.First().ToString());
var membersResponse = await _client.SendAsync(httpMessage);
var viewModel = await membersResponse.Content.ReadAsAsync <MembersViewModel>();
int total = a_users.Count + d_users.Count + z_users.Count + other_users.Count;
Assert.Equal(total, viewModel.Total);
Assert.Equal(a_users.Count, viewModel.MemberGroupings['A'].Count);
Assert.Equal(d_users.Count, viewModel.MemberGroupings['D'].Count);
Assert.Equal(z_users.Count, viewModel.MemberGroupings['Z'].Count);
Assert.Equal(other_users.Count, viewModel.UncategorizedMembers.Count());
Assert.True((new string[] { "Abe" }).SequenceEqual(viewModel.MemberGroupings['A'].Select(m => m.Name)));
Assert.True((new string[] { "Dan", "Dave" }).SequenceEqual(viewModel.MemberGroupings['D'].Select(m => m.Name)));
Assert.True((new string[] { "Zack", "Zane", "Zax", "Zoro" }).SequenceEqual(viewModel.MemberGroupings['Z'].Select(m => m.Name)));
Assert.True((new string[] { "!12AK47", "__UK__" }).SequenceEqual(viewModel.UncategorizedMembers.Select(m => m.Name)));
}
private async Task <SymbolSearchResultDTO> SearchSymbol(string ticker, ExchangeType exchange)
{
var response = await _client.GetAsync(ApiPath.SymbolSearch(ticker, 1));
response.EnsureSuccessStatusCode();
var searchResultsJson = await response.Content.ReadAsStringAsync();
var settings = new JsonSerializerSettings();
settings.MissingMemberHandling = MissingMemberHandling.Error;
settings.NullValueHandling = NullValueHandling.Include;
var searchResults = JsonConvert.DeserializeObject <IEnumerable <SymbolSearchResultDTO> >(searchResultsJson, settings);
var result = searchResults.Single();
Assert.Equal(ticker, result.Ticker);
return(searchResults.Single());
}
public async Task Should_DeleteSymbolFromPortfolio()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Search for symbols by keyword
SymbolSearchResultDTO tslaSymbol = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
SymbolSearchResultDTO jpmSymbol = await FetchSymbol("JPM", ExchangeType.NYSE);
// Add symbols to Portfolio
var addTSLAResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = tslaSymbol.SymbolId }.ToJsonPayload());
addTSLAResponse.EnsureSuccessStatusCode();
var addJPMResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = jpmSymbol.SymbolId }.ToJsonPayload());
addJPMResponse.EnsureSuccessStatusCode();
// Delete JPM
var jpmPortfolioSymbol = await addJPMResponse.Content.ReadAsAsync <PortfolioSymbol>();
var deleteJPMResponse = await _client.DeleteAsync(ApiPath.PortfolioSymbols(portfolio.Id, jpmPortfolioSymbol.Id));
deleteJPMResponse.EnsureSuccessStatusCode();
// Check only one symbol left on Portfolio
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
getPortfolioResponse.EnsureSuccessStatusCode();
var fetchedPortfolio = await getPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.Single(fetchedPortfolio.PortfolioSymbols);
Assert.Equal("TSLA", fetchedPortfolio.PortfolioSymbols.First().Ticker);
}
private async Task <TestUser> CreateTestUserWithPortfolio()
{
Guid userId = await TestUtil.CreateNewUser(AppTestSettings.Instance.TestDBConnectionString);
var httpMessage = new HttpRequestMessage(HttpMethod.Post, ApiPath.Portfolio());
httpMessage.Headers.Add(TestAuthHandler.CustomUserIdHeader, userId.ToString());
httpMessage.Content = (new { name = "test" }).ToJsonPayload();
var createPortfolioResponse = await _client.SendAsync(httpMessage);
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
return(new TestUser
{
UserId = userId,
PortfolioId = portfolio.Id,
Name = userId.ToString()
});
}
public async Task Should_UpdateAveragePricePortfolioSymbol()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Search for symbols by keyword
SymbolSearchResultDTO jpmSymbol = await FetchSymbol("JPM", ExchangeType.NYSE);
// Add symbols to Portfolio
var addJPMResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = jpmSymbol.SymbolId }.ToJsonPayload());
addJPMResponse.EnsureSuccessStatusCode();
var jpmPortfolioSymbol = await addJPMResponse.Content.ReadAsAsync <PortfolioSymbol>();
var newAvgPricePayload = new
{
AveragePrice = 1.24m
}.ToJsonPayload();
var updateAveragePriceResponse = await _client.PatchAsync(ApiPath.PortfolioSymbolsAveragePrice(portfolio.Id, jpmPortfolioSymbol.Id), newAvgPricePayload);
updateAveragePriceResponse.EnsureSuccessStatusCode();
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
var fetchedPortfolio = await getPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.Equal(portfolio.Id, fetchedPortfolio.Id);
var jpm = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "JPM");
Assert.Equal(1.24m, jpm.AveragePrice);
}
private void DataGrid1_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (DataGrid1.SelectedItem is ApiPath)
{
_apiDoc.BaseUri = TbBaseUri.Text;
ApiPath apiPath = DataGrid1.SelectedItem as ApiPath;
//string resMsg = WebApiHelper.GetString(path.GetUrl());
//TbResult.Text = string.Format("path:\n{0}\nResult:\n{1}\n", path, resMsg);
string url = apiPath.GetUrl();
if (string.IsNullOrEmpty(url))
{
TbResult.Text = string.Format("path:\n{0}\nStatus:{1}\nResult:\n{2}\n", apiPath, "NoUri", "");
apiPath.SetResultState("NoUri");
}
else
{
try
{
var client = new HttpClient();
HttpResponseMessage resMsg = client.GetAsync(url).Result;
var result = resMsg.Content.ReadAsStringAsync().Result;
//string resMsg=WebApiHelper.GetString(url);
TbResult.Text = string.Format("url:\n{0}\npath:\n{1}\nStatus:{2}\nResult:\n{3}\n", url, apiPath, resMsg.StatusCode, result);
apiPath.SetResultState(resMsg.StatusCode.ToString());
}
catch (Exception ex)
{
TbResult.Text = string.Format("url:\n{0}\npath:\n{1}\nStatus:{2}\nResult:\n{3}\n", url, apiPath, "Error", ex);
}
}
}
else
{
string url = DataGrid1.SelectedItem as string;
TbResult.Text = url;
}
}
public async Task Should_ReturnBadRequestWhenSymbolAlreadyExistsInPortfolio()
{
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), new { name = string.Empty }.ToJsonPayload());
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Search for symbols by keyword
SymbolSearchResultDTO tslaSymbol = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
// Add symbols to Portfolio
var addTSLAResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = tslaSymbol.SymbolId }.ToJsonPayload());
addTSLAResponse.EnsureSuccessStatusCode();
var addTSLAResponse2 = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = tslaSymbol.SymbolId }.ToJsonPayload());
Assert.Equal(HttpStatusCode.BadRequest, addTSLAResponse2.StatusCode);
}
public async Task Should_GetNewPortfolioWithCorrectSymbolsAddedInCorrectOrder()
{
var portfolioName = Guid.NewGuid().ToString();
var payload = new { name = portfolioName }.ToJsonPayload();
var currentDateTimeUtc = DateTime.UtcNow;
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), payload);
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
Assert.True(portfolio.DateCreated.ToUniversalTime() >= currentDateTimeUtc);
Assert.Equal(portfolio.Name, portfolioName);
// Search for symbols by keyword
var tslaSymbol = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
var jpmSymbol = await FetchSymbol("JPM", ExchangeType.NYSE);
// Add symbols to Portfolio
var addTSLAResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = tslaSymbol.SymbolId }.ToJsonPayload());
addTSLAResponse.EnsureSuccessStatusCode();
var addJPMResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = jpmSymbol.SymbolId }.ToJsonPayload());
addJPMResponse.EnsureSuccessStatusCode();
var tslaPortfolioSymbol = await addTSLAResponse.Content.ReadAsAsync <PortfolioSymbol>();
Assert.Equal("NASDAQ", tslaPortfolioSymbol.ExchangeName);
Assert.Equal("TSLA", tslaPortfolioSymbol.Ticker);
Assert.False(string.IsNullOrWhiteSpace(tslaPortfolioSymbol.FullName));
Assert.Equal(1, tslaPortfolioSymbol.SortOrder);
Assert.True(tslaPortfolioSymbol.SymbolId > 0);
var jpmPortfolioSymbol = await addJPMResponse.Content.ReadAsAsync <PortfolioSymbol>();
Assert.Equal("NYSE", jpmPortfolioSymbol.ExchangeName);
Assert.Equal("JPM", jpmPortfolioSymbol.Ticker);
Assert.False(string.IsNullOrWhiteSpace(jpmPortfolioSymbol.FullName));
Assert.Equal(2, jpmPortfolioSymbol.SortOrder);
Assert.True(jpmPortfolioSymbol.SymbolId > 0);
// Grab Portfolio and verify symbols returned
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
getPortfolioResponse.EnsureSuccessStatusCode();
var fetchedPortfolio = await getPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.Equal(portfolio.Id, fetchedPortfolio.Id);
Assert.Equal(2, fetchedPortfolio.PortfolioSymbols.Count());
var tsla = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "TSLA");
var jpm = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "JPM");
Assert.Equal("NASDAQ", tsla.ExchangeName);
Assert.False(string.IsNullOrWhiteSpace(tsla.FullName));
Assert.Equal(1, tsla.SortOrder);
Assert.Equal(tslaSymbol.SymbolId, tsla.SymbolId);
Assert.Equal("NYSE", jpm.ExchangeName);
Assert.False(string.IsNullOrWhiteSpace(jpm.FullName));
Assert.Equal(2, jpm.SortOrder);
Assert.Equal(jpmSymbol.SymbolId, jpm.SymbolId);
}
public async Task Should_ReorderPortfolioSymbols()
{
var payload = new { name = "" }.ToJsonPayload();
// Create Portfolio
var createPortfolioResponse = await _client.PostAsync(ApiPath.Portfolio(), payload);
createPortfolioResponse.EnsureSuccessStatusCode();
var portfolio = await createPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.True(portfolio.Id > 0);
// Search for symbols by keyword
SymbolSearchResultDTO tslaSymbol = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
SymbolSearchResultDTO jpmSymbol = await FetchSymbol("JPM", ExchangeType.NYSE);
SymbolSearchResultDTO fbSymbol = await FetchSymbol("FB", ExchangeType.NASDAQ);
SymbolSearchResultDTO msftSymbol = await FetchSymbol("MSFT", ExchangeType.NASDAQ);
// Add symbols to Portfolio
var addTSLAResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = tslaSymbol.SymbolId }.ToJsonPayload());
addTSLAResponse.EnsureSuccessStatusCode();
var tslaPortfolioSymbol = await addTSLAResponse.Content.ReadAsAsync <PortfolioSymbol>();
var addJPMResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = jpmSymbol.SymbolId }.ToJsonPayload());
addJPMResponse.EnsureSuccessStatusCode();
var jpmPortfolioSymbol = await addJPMResponse.Content.ReadAsAsync <PortfolioSymbol>();
var addFBResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = fbSymbol.SymbolId }.ToJsonPayload());
addFBResponse.EnsureSuccessStatusCode();
var fbPortfolioSymbol = await addFBResponse.Content.ReadAsAsync <PortfolioSymbol>();
var addMSFTResponse = await _client.PostAsync(ApiPath.PortfolioSymbols(portfolio.Id), new { SymbolId = msftSymbol.SymbolId }.ToJsonPayload());
addMSFTResponse.EnsureSuccessStatusCode();
var msftPortfolioSymbol = await addMSFTResponse.Content.ReadAsAsync <PortfolioSymbol>();
// Check starting order is as expected
Assert.Equal(1, tslaPortfolioSymbol.SortOrder);
Assert.Equal(2, jpmPortfolioSymbol.SortOrder);
Assert.Equal(3, fbPortfolioSymbol.SortOrder);
Assert.Equal(4, msftPortfolioSymbol.SortOrder);
var newOrder = new
{
PortfolioSymbolIdToSortOrder = new Dictionary <int, int>
{
{ fbPortfolioSymbol.Id, 1 },
{ tslaPortfolioSymbol.Id, 2 },
{ msftPortfolioSymbol.Id, 3 },
{ jpmPortfolioSymbol.Id, 4 },
}
}.ToJsonPayload();
var reorderTSLAResponse = await _client.PatchAsync(ApiPath.PortfolioSymbolsReorder(portfolio.Id), newOrder);
reorderTSLAResponse.EnsureSuccessStatusCode();
var getPortfolioResponse = await _client.GetAsync(ApiPath.Portfolio(portfolio.Id));
var fetchedPortfolio = await getPortfolioResponse.Content.ReadAsAsync <Portfolio>();
Assert.Equal(portfolio.Id, fetchedPortfolio.Id);
var tsla = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "TSLA");
var jpm = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "JPM");
var fb = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "FB");
var msft = fetchedPortfolio.PortfolioSymbols.Single(s => s.Ticker == "MSFT");
Assert.Equal(1, fb.SortOrder);
Assert.Equal(2, tsla.SortOrder);
Assert.Equal(3, msft.SortOrder);
Assert.Equal(4, jpm.SortOrder);
}
public async Task Should_ReturnBestAndWorstPerformers()
{
TestUser testUser1 = await CreateTestUserWithPortfolio();
TestUser testUser2 = await CreateTestUserWithPortfolio();
TestUser testUser3 = await CreateTestUserWithPortfolio();
SymbolSearchResultDTO jpmStock = await FetchSymbol("JPM", ExchangeType.NYSE);
SymbolSearchResultDTO fbStock = await FetchSymbol("FB", ExchangeType.NASDAQ);
SymbolSearchResultDTO tslaStock = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
SymbolSearchResultDTO msftStock = await FetchSymbol("MSFT", ExchangeType.NASDAQ);
// Add singlequote stocks
var jpmData = new SingleQuoteData(jpmStock.SymbolId, jpmStock.Ticker, 200, 200, 200, 200, 200, 200, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
var fbData = new SingleQuoteData(fbStock.SymbolId, fbStock.Ticker, 333.33m, 333.33m, 333.33m, 333.33m, 333.33m, 300, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
var tslaData = new SingleQuoteData(tslaStock.SymbolId, tslaStock.Ticker, 888.88m, 888.88m, 888.88m, 888.88m, 888.88m, 800, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
var msftData = new SingleQuoteData(msftStock.SymbolId, msftStock.Ticker, 225, 225, 225, 225, 225, 200, 0, 0, DateTime.UtcNow, DateTime.UtcNow);
await SetSingleQuoteData(new UpsertSingleQuoteData(jpmStock.SymbolId, jpmData));
await SetSingleQuoteData(new UpsertSingleQuoteData(fbData.SymbolId, fbData));
await SetSingleQuoteData(new UpsertSingleQuoteData(tslaData.SymbolId, tslaData));
await SetSingleQuoteData(new UpsertSingleQuoteData(msftData.SymbolId, msftData));
// Add symbols User 1
await AddSymbolToPortfolioWithAvgPrice(testUser1, jpmStock.SymbolId, 100.25m);
await AddSymbolToPortfolioWithAvgPrice(testUser1, fbStock.SymbolId, 260.35m);
await AddSymbolToPortfolioWithAvgPrice(testUser1, msftStock.SymbolId, 175.50m);
// Add symbols User 2
await AddSymbolToPortfolioWithAvgPrice(testUser2, jpmStock.SymbolId, 5.00m);
await AddSymbolToPortfolioWithAvgPrice(testUser2, fbStock.SymbolId, 10.00m);
// Add Symbols Users 3
await AddSymbolToPortfolioWithAvgPrice(testUser3, jpmStock.SymbolId, 180.88m);
await AddSymbolToPortfolioWithAvgPrice(testUser3, fbStock.SymbolId, 400.00m);
await AddSymbolToPortfolioWithAvgPrice(testUser3, tslaStock.SymbolId, 1000m);
await AddSymbolToPortfolioWithAvgPrice(testUser3, msftStock.SymbolId, 300.90m);
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(3));
LeaderBoardViewModel leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
// Verify calculations
BoardValue bestPerformerRank1 = leaderBoardViewModel.BestPerformers.Values.ElementAt(0);
BoardValue bestPerformerRank2 = leaderBoardViewModel.BestPerformers.Values.ElementAt(1);
BoardValue bestPerformerRank3 = leaderBoardViewModel.BestPerformers.Values.ElementAt(2);
Assert.Equal(3, leaderBoardViewModel.BestPerformers.Values.Count());
Assert.Equal(testUser2.UserId, Guid.Parse(bestPerformerRank1.Id));
Assert.Equal(testUser1.UserId, Guid.Parse(bestPerformerRank2.Id));
Assert.Equal(testUser3.UserId, Guid.Parse(bestPerformerRank3.Id));
Assert.Equal(testUser2.UserId, Guid.Parse(bestPerformerRank1.Name));
Assert.Equal(testUser1.UserId, Guid.Parse(bestPerformerRank2.Name));
Assert.Equal(testUser3.UserId, Guid.Parse(bestPerformerRank3.Name));
Assert.Equal("3,566.65", bestPerformerRank1.Value);
Assert.Equal("51.91", bestPerformerRank2.Value);
Assert.Equal("-10.61", bestPerformerRank3.Value);
BoardValue worstPerformerRank1 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(0);
BoardValue worstPerformerRank2 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(1);
BoardValue worstPerformerRank3 = leaderBoardViewModel.WorstPerformers.Values.ElementAt(2);
Assert.Equal(3, leaderBoardViewModel.WorstPerformers.Values.Count());
Assert.Equal(testUser3.UserId, Guid.Parse(worstPerformerRank1.Id));
Assert.Equal(testUser1.UserId, Guid.Parse(worstPerformerRank2.Id));
Assert.Equal(testUser2.UserId, Guid.Parse(worstPerformerRank3.Id));
Assert.Equal("-10.61", worstPerformerRank1.Value);
Assert.Equal("51.91", worstPerformerRank2.Value);
Assert.Equal("3,566.65", worstPerformerRank3.Value);
}
public async Task Should_ReturnMostBearishAndMostBullishStocksByVotes()
{
TestUser testUser1 = await CreateTestUserWithPortfolio();
TestUser testUser2 = await CreateTestUserWithPortfolio();
TestUser testUser3 = await CreateTestUserWithPortfolio();
SymbolSearchResultDTO jpmStock = await FetchSymbol("JPM", ExchangeType.NYSE);
SymbolSearchResultDTO fbStock = await FetchSymbol("FB", ExchangeType.NASDAQ);
SymbolSearchResultDTO tslaStock = await FetchSymbol("TSLA", ExchangeType.NASDAQ);
SymbolSearchResultDTO msftStock = await FetchSymbol("MSFT", ExchangeType.NASDAQ);
// User 1 votes
await SubmitVoteForUser(new VoteCommand { SymbolId = jpmStock.SymbolId, Direction = VoteDirection.UpVote }, testUser1.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = fbStock.SymbolId, Direction = VoteDirection.UpVote }, testUser1.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = tslaStock.SymbolId, Direction = VoteDirection.DownVote }, testUser1.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = msftStock.SymbolId, Direction = VoteDirection.DownVote }, testUser1.UserId);
// User 2 votes
await SubmitVoteForUser(new VoteCommand { SymbolId = jpmStock.SymbolId, Direction = VoteDirection.UpVote }, testUser2.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = fbStock.SymbolId, Direction = VoteDirection.DownVote }, testUser2.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = tslaStock.SymbolId, Direction = VoteDirection.DownVote }, testUser2.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = msftStock.SymbolId, Direction = VoteDirection.DownVote }, testUser2.UserId);
// User 2 votes
await SubmitVoteForUser(new VoteCommand { SymbolId = jpmStock.SymbolId, Direction = VoteDirection.UpVote }, testUser3.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = fbStock.SymbolId, Direction = VoteDirection.None }, testUser3.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = tslaStock.SymbolId, Direction = VoteDirection.DownVote }, testUser3.UserId);
await SubmitVoteForUser(new VoteCommand { SymbolId = msftStock.SymbolId, Direction = VoteDirection.UpVote }, testUser3.UserId);
var leaderBoardResponse = await _client.GetAsync(ApiPath.LeaderBoard(4));
LeaderBoardViewModel leaderBoardViewModel = await leaderBoardResponse.Content.ReadAsAsync <LeaderBoardViewModel>();
// Verify most bullish order
BoardValue mostBullishRank1 = leaderBoardViewModel.MostBullish.Values.ElementAt(0);
BoardValue mostBullishRank2 = leaderBoardViewModel.MostBullish.Values.ElementAt(1);
BoardValue mostBullishRank3 = leaderBoardViewModel.MostBullish.Values.ElementAt(2);
BoardValue mostBullishRank4 = leaderBoardViewModel.MostBullish.Values.ElementAt(3);
Assert.Equal(jpmStock.SymbolId.ToString(), mostBullishRank1.Id);
Assert.Equal("JPM", mostBullishRank1.Name);
Assert.Equal("3", mostBullishRank1.Value);
Assert.Equal(fbStock.SymbolId.ToString(), mostBullishRank2.Id);
Assert.Equal("FB", mostBullishRank2.Name);
Assert.Equal("0", mostBullishRank2.Value);
Assert.Equal(msftStock.SymbolId.ToString(), mostBullishRank3.Id);
Assert.Equal("MSFT", mostBullishRank3.Name);
Assert.Equal("-1", mostBullishRank3.Value);
Assert.Equal(tslaStock.SymbolId.ToString(), mostBullishRank4.Id);
Assert.Equal("TSLA", mostBullishRank4.Name);
Assert.Equal("-3", mostBullishRank4.Value);
// Verify most bearish order
BoardValue mostBearishRank1 = leaderBoardViewModel.MostBearish.Values.ElementAt(0);
BoardValue mostBearishRank2 = leaderBoardViewModel.MostBearish.Values.ElementAt(1);
BoardValue mostBearishRank3 = leaderBoardViewModel.MostBearish.Values.ElementAt(2);
BoardValue mostBearishRank4 = leaderBoardViewModel.MostBearish.Values.ElementAt(3);
Assert.Equal(tslaStock.SymbolId.ToString(), mostBearishRank1.Id);
Assert.Equal("TSLA", mostBearishRank1.Name);
Assert.Equal("-3", mostBearishRank1.Value);
Assert.Equal(msftStock.SymbolId.ToString(), mostBearishRank2.Id);
Assert.Equal("MSFT", mostBearishRank2.Name);
Assert.Equal("-1", mostBearishRank2.Value);
Assert.Equal(fbStock.SymbolId.ToString(), mostBearishRank3.Id);
Assert.Equal("FB", mostBearishRank3.Name);
Assert.Equal("0", mostBearishRank3.Value);
Assert.Equal(jpmStock.SymbolId.ToString(), mostBearishRank4.Id);
Assert.Equal("JPM", mostBearishRank4.Name);
Assert.Equal("3", mostBearishRank4.Value);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Task <string> Handle()
{
var rlt = Task.Run <string>(() => { return(""); });
Result = new ApiResult <IResponse> {
node = XCore.WebNode, code = "-1", success = false, message = "unkown error"
};
if (string.IsNullOrEmpty(ApiHost))
{
Result.code = "400";
Result.message = "request host not set";
}
else if (string.IsNullOrEmpty(ApiPath))
{
Result.code = "400";
Result.message = "request path not set";
}
else
{
System.Net.Http.HttpClient http = null;
Task <System.Net.Http.HttpResponseMessage> task = null;
if (Certificate == null)
{
http = new System.Net.Http.HttpClient();
}
else
{
var handler = new System.Net.Http.HttpClientHandler();
handler.ClientCertificateOptions = System.Net.Http.ClientCertificateOption.Manual;
handler.SslProtocols = System.Security.Authentication.SslProtocols.Tls12;
handler.ClientCertificates.Add(Certificate);
http = new System.Net.Http.HttpClient(handler);
}
http.BaseAddress = new System.Uri(ApiHost);
if (Method == "GET")
{
var query = RequestBody as string;
if (!string.IsNullOrEmpty(query))
{
var link = ApiPath.IndexOf('?') < 0 ? '?' : '&';
ApiPath += query[0] == '?' || query[0] == '&' ? query : link + query;
}
if (HttpRequestHeaders != null)
{
foreach (var kv in HttpRequestHeaders)
{
http.DefaultRequestHeaders.Add(kv.Key, kv.Value);
}
}
task = http.GetAsync(ApiPath);
}
else
{
System.Net.Http.HttpContent content = null;
var text = RequestBody as string;
var bytes = RequestBody as byte[];
if (bytes != null)
{
content = new System.Net.Http.ByteArrayContent(bytes);
}
else if (!string.IsNullOrEmpty(text))
{
content = new System.Net.Http.StringContent(text, Encoding, ContentType);
}
else if (RequestBody != null)
{
content = new System.Net.Http.StringContent(Json.ToString(RequestBody), Encoding, ContentType);
}
else
{
content = new System.Net.Http.ByteArrayContent(new byte[0]);
}
if (HttpRequestHeaders != null)
{
foreach (var kv in HttpRequestHeaders)
{
content.Headers.Add(kv.Key, kv.Value);
}
}
task = http.PostAsync(ApiPath, content);
}
task.Result.Content.ReadAsStringAsync().ContinueWith((res) =>
{
ResponseBody = res.Result;
HttpResponseHeaders = new Dictionary <string, string>();
foreach (var item in task.Result.Headers)
{
var em = item.Value.GetEnumerator();
if (em.MoveNext())
{
HttpResponseHeaders.Add(item.Key.ToLower(), em.Current);
}
}
rlt = Task.Run <string>(() => { return(res.Result); });
}).Wait();
}
return(rlt);
}
