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); }