public void Return_False_When_No_User_Saved_This_Tweet()
        {
            //Arrange
            var fakeUnit         = new Mock <IUnitOfWork>();
            var dateTimeProvider = new TestDateTimeProvider();
            var fakeTweetService = new Mock <ITweetService>();
            var sut = new UserTweetService(fakeUnit.Object, fakeTweetService.Object, dateTimeProvider);

            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();

            var userTweet = new UserTweet {
                UserId = "123", TweetId = "456"
            };
            var userTweetCollection = new List <UserTweet> {
                userTweet
            };

            fakeUserTweetRepo.Setup(s => s.All).Returns(userTweetCollection.AsQueryable());
            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);

            //Act
            var expectedResult = sut.AnyUserSavedThisTweetById("7777");

            //Assert
            Assert.IsFalse(expectedResult);
        }
Exemple #2
0
        public void Return_Correct_Values_When_UserTweets_Exist()
        {
            //Arrange
            var timeProvider     = new TestDateTimeProvider();
            var fakeUnit         = new Mock <IUnitOfWork>();
            var fakeTweetService = Mock.Of <ITweetService>();
            var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, timeProvider);
            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();

            var testTweet1 = new Tweet {
                Text = "test1", TweetId = "10", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "666"
            };
            var testTweet2 = new Tweet {
                Text = "test2", TweetId = "11", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "666"
            };
            var testTweet3 = new Tweet {
                Text = "test3", TweetId = "12", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "789"
            };

            var testUserTweet1 = new UserTweet {
                UserId = "100", Tweet = testTweet1, TweetId = testTweet1.TweetId
            };
            var testUserTweet2 = new UserTweet {
                UserId = "100", Tweet = testTweet2, TweetId = testTweet2.TweetId
            };
            var testUserTweet3 = new UserTweet {
                UserId = "100", Tweet = testTweet3, TweetId = testTweet3.TweetId
            };

            var userTweetCollection = new List <UserTweet> {
                testUserTweet1, testUserTweet2, testUserTweet3
            };

            fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
            var expectedTweet1 = new FakeTweetDto
            {
                TweetId = testTweet1.TweetId,
                OriginalTweetCreatedOn = testTweet1.OriginalTweetCreatedOn,
                Text           = testTweet1.Text,
                UsersMentioned = testTweet1.UsersMentioned
            };

            var expectedTweet2 = new FakeTweetDto
            {
                TweetId = testTweet2.TweetId,
                OriginalTweetCreatedOn = testTweet2.OriginalTweetCreatedOn,
                Text           = testTweet2.Text,
                UsersMentioned = testTweet2.UsersMentioned
            };
            var expectedTweetDtos = new List <FakeTweetDto> {
                expectedTweet1, expectedTweet2
            };

            //Act
            var actualTweetDtos = sut.GetTweetsByUserIdAndFolloweeId("100", "666");

            //Assert
            CollectionAssert.AreEqual(expectedTweetDtos, actualTweetDtos.ToList());
        }
Exemple #3
0
        public void Invoke_SaveChanges_On_UnitOfWork_When_Found()
        {
            //Arrange
            var fakeUnit             = new Mock <IUnitOfWork>();
            var fakeDateTimeProvider = Mock.Of <IDateTimeProvider>();
            var fakeTweetService     = Mock.Of <ITweetService>();
            var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, fakeDateTimeProvider);

            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
            var userTweet         = new UserTweet {
                TweetId = "789", UserId = "123"
            };
            var userTweetCollection = new List <UserTweet> {
                userTweet
            };

            fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
            fakeUnit.Setup(s => s.SaveChanges()).Verifiable();

            //Act
            sut.DeleteUserTweet("123", "789");

            //Assert
            fakeUnit.Verify(v => v.SaveChanges(), Times.Once);
        }
Exemple #4
0
        public void Return_False_When_UserTweet_Does_Not_Exist()
        {
            //Arrange
            var fakeUnit             = new Mock <IUnitOfWork>();
            var fakeDateTimeProvider = Mock.Of <IDateTimeProvider>();
            var fakeTweetService     = Mock.Of <ITweetService>();
            var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, fakeDateTimeProvider);

            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();

            var userTweet = new UserTweet {
                UserId = "123", TweetId = "456"
            };

            var userTweetCollection = new List <UserTweet> {
                userTweet
            };

            fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);

            //Act
            var exists = sut.UserTweetExists(userTweet.UserId, "666");

            //Assert
            Assert.IsFalse(exists);
        }
        public void Invoke_DeleteUserTweetAndEntities_In_Same_Method_When_Provided_Correct_Parameters_And_User_Saved_Tweets()
        {
            //Arrange
            var fakeUserTweetSetvice    = Mock.Of <IUserTweetService>();
            var fakeUserFolloweeService = new Mock <IUserFolloweeService>();
            var fakeUnit             = new Mock <IUnitOfWork>();
            var fakeFolloweeService  = new Mock <IFolloweeService>();
            var fakeTweetService     = Mock.Of <ITweetService>();
            var fakeTweetTagService  = Mock.Of <ITweetTagService>();
            var fakeAdminUserService = Mock.Of <IAdminUserService>();
            var sut = new FakeCascadeDeleteService(fakeUserTweetSetvice, fakeUserFolloweeService.Object, fakeUnit.Object, fakeFolloweeService.Object, fakeTweetService, fakeTweetTagService, fakeAdminUserService);

            var fakeUserFolloweeRepo = new Mock <IGenericRepository <UserFollowee> >();
            var fakeUserTweetRepo    = new Mock <IGenericRepository <UserTweet> >();
            var userFollowees        = new List <UserFollowee>();
            var testTweet            = new Tweet {
                FolloweeId = "123", TweetId = "666"
            };
            var testUserTweet = new UserTweet {
                Tweet = testTweet, TweetId = testTweet.TweetId, UserId = "456"
            };
            var userTweets = new List <UserTweet> {
                testUserTweet
            };

            fakeUserFolloweeRepo.Setup(r => r.All).Returns(userFollowees.AsQueryable());
            fakeUserTweetRepo.Setup(r => r.All).Returns(userTweets.AsQueryable());
            fakeUnit.Setup(u => u.UserFollowees).Returns(fakeUserFolloweeRepo.Object);
            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
            fakeUserFolloweeService.Setup(s => s.AnyUserSavedThisFolloweeById(It.IsAny <string>())).Returns(false);

            //Act & Assert
            Assert.ThrowsException <FakeTestException>(() => sut.DeleteUserFolloweeAndEntries("123", "456"));
        }
        public async Task <bool> DownloadTweet(string userId, Tweet tweet)
        {
            var isDownloaded = false;

            var user = await this.DbContext.Users.FindAsync(userId);

            if (user != null)
            {
                var userTweetExists = await this.DbContext.UserTweets.FindAsync(userId, tweet.Id);

                if (userTweetExists == null)
                {
                    var userTweet = new UserTweet()
                    {
                        UserId  = userId,
                        User    = user,
                        TweetId = tweet.Id,
                        Tweet   = tweet
                    };

                    await this.DbContext.UserTweets.AddAsync(userTweet);

                    var tweetExists = await this.DbContext.Tweets.FindAsync(tweet.Id);

                    if (tweetExists != null)
                    {
                        if (tweetExists.IsDeleted)
                        {
                            tweetExists.IsDeleted = false;

                            var entry = this.DbContext.Entry(tweetExists);
                            entry.State = EntityState.Modified;
                        }
                    }
                    else
                    {
                        await this.DbContext.Tweets.AddAsync(tweet);
                    }

                    isDownloaded = true;
                }
                else
                {
                    if (userTweetExists.IsDeleted)
                    {
                        userTweetExists.IsDeleted = false;

                        var entry = this.DbContext.Entry(userTweetExists);
                        entry.State = EntityState.Modified;
                    }
                    isDownloaded = true;
                }
            }

            return(isDownloaded);
        }
Exemple #7
0
        public int AddTweetToFavourites(string tweetId, UserDTO userDto)
        {
            if (tweetId.IsNullOrWhitespace())
            {
                throw new InvalidTweetIdException(nameof(tweetId));
            }

            if (userDto.IsNull())
            {
                throw new NullUserException(nameof(userDto));
            }

            var tweet = GetSavedTweetById(tweetId);
            var user  = this.mappingProvider.MapTo <User>(userDto);

            UserTweet userTweet = null;

            if (this.IsActuallyFavourite(tweet.Id, user.Id))
            {
                if (!this.IsDeleted(tweet.Id, user.Id))
                {
                    throw new ArgumentException();
                }

                userTweet = this.userTweets
                            .AllAndDeleted
                            .SingleOrDefault(x =>
                                             x.TweetId.Equals(tweet.Id)
                                             &&
                                             x.UserId.Equals(user.Id)
                                             );

                userTweet.IsDeleted = false;

                this.userTweets.Update(userTweet);
            }
            else
            {
                userTweet = new UserTweet
                {
                    User    = user,
                    UserId  = user.Id,
                    Tweet   = tweet,
                    TweetId = tweet.TwitterId
                };

                userTweets.Add(userTweet);
            }

            return(this.saver.SaveChanges());
        }
Exemple #8
0
        public async Task <bool> TweetDownloaded(User user, Tweet tweet)
        {
            var checkIfTweetExists = await this.DbContext.UserTweets.FindAsync(user.Id, tweet.Id);

            if (checkIfTweetExists != null)
            {
                checkIfTweetExists.IsDeleted = false;
                return(true);
            }
            else
            {
                var userTweet = new UserTweet()
                {
                    UserId  = user.Id,
                    User    = user,
                    TweetId = tweet.Id,
                    Tweet   = tweet
                };
                this.DbContext.UserTweets.Add(userTweet);
                return(true);
            }
        }
        public void Invoke_SaveChanges_In_UnitOfWork_When_Tweet_Exist_TweetTag_Is_Deleted()
        {
            //Arrange
            var fakeUnit         = new Mock <IUnitOfWork>();
            var dateTimeProvider = new TestDateTimeProvider();
            var fakeTweetService = new Mock <ITweetService>();
            var sut = new UserTweetService(fakeUnit.Object, fakeTweetService.Object, dateTimeProvider);

            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
            var fakeTweetRepo     = new Mock <IGenericRepository <Tweet> >();

            var tweet = new Tweet {
                TweetId = "456"
            };
            var tweetCollection = new List <Tweet> {
                tweet
            };

            var userTweet = new UserTweet {
                TweetId = tweet.TweetId, UserId = "123", IsDeleted = true, DeletedOn = dateTimeProvider.DeletedOn
            };
            var userTweetCollection = new List <UserTweet> {
                userTweet
            };

            fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
            fakeTweetRepo.Setup(r => r.AllAndDeleted).Returns(tweetCollection.AsQueryable());
            fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(userTweetCollection.AsQueryable());
            fakeUnit.Setup(u => u.Tweets).Returns(fakeTweetRepo.Object);
            fakeUnit.Setup(u => u.SaveChanges()).Verifiable();

            //Act
            sut.SaveSingleTweetToUserByTweetId("123", "456");

            //Assert
            fakeUnit.Verify(v => v.SaveChanges(), Times.Once);
        }
        public void Return_Correct_Value_When_Provided_Valid_Id()
        {
            //Arrange
            var fakeUnitOfWork    = new Mock <IUnitOfWork>();
            var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
            var fakeTimeProvider  = new TestDateTimeProvider();

            var testUser1 = new User {
                UserName = "******", Id = "TestId1"
            };
            var testUser2 = new User {
                UserName = "******", Id = "TestId2"
            };

            var testFollowee1 = new Followee {
                ScreenName = "TestScreenName1"
            };
            var testFollowee2 = new Followee {
                ScreenName = "TestScreenName1"
            };

            var testTweet1 = new Tweet {
                Text = "testTweet1", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet1Id", Followee = testFollowee1
            };
            var testTweet2 = new Tweet {
                Text = "testTweet2", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet2Id", Followee = testFollowee2
            };
            var testTweet3 = new Tweet {
                Text = "testTweet3", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet3Id", Followee = testFollowee1
            };

            var testUserTweet1 = new UserTweet {
                Tweet = testTweet1, TweetId = testTweet1.TweetId, UserId = testUser1.Id, User = testUser1, IsDeleted = true, DeletedOn = fakeTimeProvider.DeletedOn
            };
            var testUserTweet2 = new UserTweet {
                Tweet = testTweet2, TweetId = testTweet2.TweetId, UserId = testUser1.Id, User = testUser1, IsDeleted = false
            };
            var testUserTweet3 = new UserTweet {
                Tweet = testTweet3, TweetId = testTweet3.TweetId, UserId = testUser2.Id, User = testUser2
            };

            var fakeUserTweetCollection = new List <UserTweet> {
                testUserTweet1, testUserTweet2, testUserTweet3
            };

            fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserTweetCollection.AsQueryable());
            fakeUnitOfWork.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);

            var deletedModel = new FakeDeletedTweetsModel
            {
                TweetDeletedOn         = testUserTweet1.DeletedOn.Value,
                Text                   = testUserTweet1.Tweet.Text,
                OriginalTweetCreatedOn = testUserTweet1.Tweet.OriginalTweetCreatedOn,
                AuthorScreenName       = testUserTweet1.Tweet.Followee.ScreenName
            };

            var expectedResult = new List <FakeDeletedTweetsModel> {
                deletedModel
            };
            var sut = new TweetStatisticsService(fakeUnitOfWork.Object);

            //Act
            var actualResult = sut.GetDeletedTweetsyUserId("TestId1").ToList();

            //Assert
            CollectionAssert.AreEqual(expectedResult, actualResult);
        }
Exemple #11
0
        public void SaveSingleTweetToUserByTweetId(string userId, string tweetId)
        {
            if (string.IsNullOrWhiteSpace(userId))
            {
                throw new ArgumentNullException(nameof(userId));
            }

            if (string.IsNullOrWhiteSpace(tweetId))
            {
                throw new ArgumentNullException(nameof(tweetId));
            }

            var tweetToSaveToUser = this.unitOfWork.Tweets.AllAndDeleted.FirstOrDefault(w => w.TweetId == tweetId);

            if (tweetToSaveToUser == null) // if it's a new Tweet, it's a new UserTweet
            {
                tweetToSaveToUser = this.tweetService.CreateFromApiById(tweetId);
                var userTweetToadd = new UserTweet {
                    UserId = userId, TweetId = tweetToSaveToUser.TweetId
                };

                this.unitOfWork.UserTweets.Add(userTweetToadd);
                this.unitOfWork.SaveChanges();
            }
            else
            {
                if (tweetToSaveToUser.IsDeleted)
                {
                    tweetToSaveToUser.IsDeleted  = false;
                    tweetToSaveToUser.DeletedOn  = null;
                    tweetToSaveToUser.ModifiedOn = this.dateTimeProvider.Now;

                    var tags = this.unitOfWork.TweetTags.AllAndDeleted.Where(w => w.TweetId == tweetId)
                               .Select(s => s.Tag).ToList();
                    foreach (var tag in tags)
                    {
                        var tweetTagToReAdd =
                            this.unitOfWork.TweetTags.AllAndDeleted.FirstOrDefault(
                                w => w.TagId == tag.Id && w.TweetId == tweetId);
                        if (tweetTagToReAdd != null && tweetTagToReAdd.IsDeleted)
                        {
                            tweetTagToReAdd.IsDeleted  = false;
                            tweetTagToReAdd.DeletedOn  = null;
                            tweetTagToReAdd.ModifiedOn = this.dateTimeProvider.Now;
                        }
                        if (tag.IsDeleted)
                        {
                            tag.IsDeleted  = false;
                            tag.DeletedOn  = null;
                            tag.ModifiedOn = this.dateTimeProvider.Now;
                        }
                    }
                    this.unitOfWork.SaveChanges();
                }

                if (!this.UserTweetExistsInDeleted(userId, tweetId))
                {
                    var userTweetToadd = new UserTweet {
                        UserId = userId, TweetId = tweetId
                    };

                    this.unitOfWork.UserTweets.Add(userTweetToadd);
                    this.unitOfWork.SaveChanges();
                }
                else
                {
                    var userTweetToBeReadded =
                        this.unitOfWork.UserTweets.AllAndDeleted.FirstOrDefault(a =>
                                                                                a.TweetId == tweetId && a.UserId == userId);

                    if (userTweetToBeReadded != null)
                    {
                        userTweetToBeReadded.IsDeleted  = false;
                        userTweetToBeReadded.DeletedOn  = null;
                        userTweetToBeReadded.ModifiedOn = this.dateTimeProvider.Now;
                        this.unitOfWork.SaveChanges();
                    }
                }
            }
        }
Exemple #12
0
        public void Return_Correct_Reports_When_Provided_Valid_Parameters()
        {
            //Arrange
            var fakeUnitOfWork       = new Mock <IUnitOfWork>();
            var fakeUserRepo         = new Mock <IGenericRepository <User> >();
            var fakeUserTweetRepo    = new Mock <IGenericRepository <UserTweet> >();
            var fakeUserFolloweeRepo = new Mock <IGenericRepository <UserFollowee> >();
            var fakeTimeProvider     = new TestDateTimeProvider();

            var testUser1 = new User {
                UserName = "******", Id = "TestId1", CreatedOn = fakeTimeProvider.CreatedOn, IsDeleted = true
            };
            var testUser2 = new User {
                UserName = "******", Id = "TestId2", CreatedOn = fakeTimeProvider.CreatedOn, IsDeleted = false
            };
            var fakeUserCollection = new List <User> {
                testUser1, testUser2
            };
            var testUserFollowee1 = new UserFollowee {
                User = testUser1, IsDeleted = true
            };
            var testUserFollowee2 = new UserFollowee {
                User = testUser2, IsDeleted = true
            };
            var testUserFollowee3 = new UserFollowee {
                User = testUser2, IsDeleted = false
            };
            var fakeUserFolloweeCollection = new List <UserFollowee> {
                testUserFollowee1, testUserFollowee2, testUserFollowee3
            };
            var testUserTweet1 = new UserTweet {
                User = testUser1, IsDeleted = true
            };
            var testUserTweet2 = new UserTweet {
                User = testUser2, IsDeleted = true
            };
            var testUserTweet3 = new UserTweet {
                User = testUser2, IsDeleted = false
            };
            var fakeUserTweetCollection = new List <UserTweet> {
                testUserTweet1, testUserTweet2, testUserTweet3
            };

            fakeUserRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserCollection.AsQueryable());
            fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserTweetCollection.AsQueryable());
            fakeUserFolloweeRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserFolloweeCollection.AsQueryable());
            fakeUnitOfWork.Setup(u => u.Users).Returns(fakeUserRepo.Object);
            fakeUnitOfWork.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
            fakeUnitOfWork.Setup(u => u.UserFollowees).Returns(fakeUserFolloweeRepo.Object);

            var sut = new StatisticsService(fakeUnitOfWork.Object);
            var statisticsModel1 = new FakeUserStatisticsModel
            {
                ActivelyFollowedAccountsCount = 0,
                DeletedAccountsCount          = 1,
                ActiveStatus       = "Deleted",
                UserId             = "TestId1",
                UserName           = "******",
                SavedTweetsCount   = 0,
                DeletedTweetsCount = 1,
                UserNameCreatedOn  = fakeTimeProvider.CreatedOn
            };
            var statisticsModel2 = new FakeUserStatisticsModel
            {
                ActivelyFollowedAccountsCount = 1,
                DeletedAccountsCount          = 1,
                ActiveStatus       = "Active",
                UserId             = "TestId2",
                UserName           = "******",
                SavedTweetsCount   = 1,
                DeletedTweetsCount = 1,
                UserNameCreatedOn  = fakeTimeProvider.CreatedOn
            };
            var totalStatisticsModel = new FakeTotalStatisticsModel
            {
                TotalDeletedAccountsCount = 2,
                TotalSavedTweetsCount     = 1,
                TotalDeletedTweetsCount   = 2,
                TotalUsers = 2,
                TotalActivelyFollowedAccountsCount = 1,
                TotalActiveUsers  = 1,
                TotalDeletedUsers = 1
            };
            var usesStatisticsModels = new Dictionary <string, UserStatisticsModel>
            {
                ["TestUser1"] = statisticsModel1,
                ["TestUser2"] = statisticsModel2
            };

            var expectedOutput = new FakeStatisticsScreenModel {
                TotalStatisticsModel = totalStatisticsModel, UserStatisticsModels = usesStatisticsModels.Values
            };

            //Act
            var actualOutput = sut.UsersStatistics();

            //Assert

            Assert.AreEqual(expectedOutput.TotalStatisticsModel, actualOutput.TotalStatisticsModel);
            CollectionAssert.AreEqual(expectedOutput.UserStatisticsModels.ToList(), actualOutput.UserStatisticsModels.ToList());
        }
Exemple #13
0
        public async Task <HttpResponseMessage> Post([FromBody] UserTweet tweet)
        {
            var userAuthInfo = Program.GetUserAuthInfo(tweet.screenName);

            if (userAuthInfo == null)
            {
                return(Request.CreateResponse(HttpStatusCode.OK));
            }


            var httpMethod         = "POST";
            var baseUrl            = "https://api.twitter.com/1.1/statuses/update.json";
            var twitterOauthParams = new Dictionary <string, string>()
            {
                { TwitterOauthUtils.OAuthConsumerKeyKey, TwitterSignInController.consumer_key },
                { TwitterOauthUtils.OAuthNonceKey, TwitterOauthUtils.GenerateNonce() },
                { TwitterOauthUtils.OAuthSignatureMethodKey, TwitterOauthUtils.OAuthSignatureMethod },
                { TwitterOauthUtils.OAuthTimestampKey, TwitterOauthUtils.UnixTimeStamp() },
                { TwitterOauthUtils.OAuthVersionKey, TwitterOauthUtils.OAuthVersion },
                { TwitterOauthUtils.OAuthTokenKey, userAuthInfo.OAuthToken }
            };
            var twitterQueryParams = new Dictionary <string, string>();

            twitterQueryParams.Add("status", tweet.message);
            var twitterPostParams = new Dictionary <string, string>();
            var oauthSignature    = TwitterOauthUtils.CreateSignature(httpMethod,
                                                                      baseUrl,
                                                                      twitterQueryParams,
                                                                      twitterPostParams,
                                                                      twitterOauthParams,
                                                                      TwitterSignInController.consumer_secret,
                                                                      userAuthInfo.OAuthTokenSecret);

            List <string> queryParamsList = new List <string>();

            foreach (var kvp in twitterQueryParams)
            {
                queryParamsList.Add(string.Format("{0}={1}", kvp.Key, kvp.Value));
            }

            var url = string.Format("{0}?{1}", baseUrl, string.Join("&", queryParamsList));


            HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, url);

            message.Headers.Add("Accept", "*/*");
            message.Headers.Add("User-Agent", "weatherama-client-1.0");
            message.Headers.Add("Host", "api.twitter.com");

            var oauthParamsList = new List <string>();

            foreach (var kvp in twitterOauthParams)
            {
                oauthParamsList.Add(string.Format("{0}=\"{1}\"", kvp.Key, TwitterOauthUtils.PercentEncode(kvp.Value)));
            }
            oauthParamsList.Add(string.Format("{0}=\"{1}\"", TwitterOauthUtils.OAuthSignatureKey, TwitterOauthUtils.PercentEncode(oauthSignature)));
            var oauthHeader = string.Format("OAuth {0}", string.Join(",", oauthParamsList));

            message.Headers.Add("Authorization", oauthHeader);



            HttpClient httpClient      = new HttpClient();
            var        responseMessage = await httpClient.SendAsync(message);

            string responseContent = string.Empty;

            if (responseMessage.Content != null)
            {
                responseContent = await responseMessage.Content.ReadAsStringAsync();
            }

            if (responseMessage.StatusCode == HttpStatusCode.OK)
            {
                System.Diagnostics.Debug.WriteLine(responseContent);
            }

            return(Request.CreateResponse(HttpStatusCode.OK));
        }