// Destroy Friendship public string GetDestroyFriendshipWithQuery(IUserIdentifier userIdentifier) { _userQueryValidator.ThrowIfUserCannotBeIdentified(userIdentifier); var userIdentifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(userIdentifier); return string.Format(Resources.Friendship_Destroy, userIdentifierParameter); }
public UserTimelineQueryParameters( IUserIdentifier userIdentifier, IUserTimelineParameters queryParameters) { UserIdentifier = userIdentifier; QueryParameters = queryParameters; }
// User Timeline public string GetUserTimeline(IUserIdentifier userIdentifier, int maximumNumberOfTweets = 40) { var requestParameters = _timelineQueryParameterGenerator.CreateUserTimelineParameters(); requestParameters.MaximumNumberOfTweetsToRetrieve = maximumNumberOfTweets; return GetUserTimeline(userIdentifier, requestParameters); }
public static string GenerateParameterExpectedResult(IUserIdentifier userDTO, string idParameterName = "user_id", string screenNameParameterName = "screen_name") { if (userDTO.Id != TweetinviSettings.DEFAULT_ID) { return String.Format("{0}={1}", idParameterName, userDTO.GetHashCode()); } return String.Format("{0}={1}", screenNameParameterName, userDTO.GetHashCode()); }
public IEnumerable<ITweet> GetUserTimeline(IUserIdentifier userIdentifier, IUserTimelineParameters parameters) { if (parameters == null) { parameters = _timelineQueryParameterGenerator.CreateUserTimelineParameters(); } var queryParameters = _timelineQueryParameterGenerator.CreateUserTimelineQueryParameters(userIdentifier, parameters); return GetUserTimline(queryParameters); }
// User Lists public string GetUserSubscribedListsQuery(IUserIdentifier userIdentifier, bool getOwnedListsFirst) { if (!_userQueryValidator.CanUserBeIdentified(userIdentifier)) { return null; } var userIdParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(userIdentifier); return GenerateUserListsQuery(userIdParameter, getOwnedListsFirst); }
// Followers public string GetFollowerIdsQuery(IUserIdentifier userDTO, int maxFollowersToRetrieve) { if (!_userQueryValidator.CanUserBeIdentified(userDTO)) { return null; } string userIdentifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(userDTO); return GenerateGetFollowerIdsQuery(userIdentifierParameter, maxFollowersToRetrieve); }
// Get Existing Relationship public string GetRelationshipDetailsQuery(IUserIdentifier sourceUserIdentifier, IUserIdentifier targetUserIdentifier) { if (!_userQueryValidator.CanUserBeIdentified(sourceUserIdentifier) || !_userQueryValidator.CanUserBeIdentified(targetUserIdentifier)) { return null; } string sourceParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(sourceUserIdentifier, "source_id", "source_screen_name"); string targetParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(targetUserIdentifier, "target_id", "target_screen_name"); return string.Format(Resources.Friendship_GetRelationship, sourceParameter, targetParameter); }
private void Initialize(string text, IUserIdentifier recipient) { if (string.IsNullOrEmpty(text)) { throw new ArgumentNullException("Message Text cannot be null or empty."); } if (recipient == null) { throw new ArgumentNullException("Message recipient cannot be null."); } Text = text; Recipient = recipient; }
private void Init() { _maximumNumberOfTweetsParameterValue = TestHelper.GenerateRandomInt(); _fakeUserIdentifier = A.Fake<IUserIdentifier>(); _fakeHomeTimelineParameters = A.Fake<IHomeTimelineParameters>(); _fakeHomeTimelineParameters.CallsTo(x => x.MaximumNumberOfTweetsToRetrieve).Returns(_maximumNumberOfTweetsParameterValue); _fakeUserTimelineParameters = A.Fake<IUserTimelineParameters>(); _fakeUserTimelineParameters.CallsTo(x => x.MaximumNumberOfTweetsToRetrieve).Returns(_maximumNumberOfTweetsParameterValue); _fakeUserTimelineQueryParameters = A.Fake<IUserTimelineQueryParameters>(); _fakeUserTimelineQueryParameters.CallsTo(x => x.Parameters).Returns(_fakeUserTimelineParameters); _fakeUserTimelineQueryParameters.CallsTo(x => x.UserIdentifier).Returns(_fakeUserIdentifier); _fakeMentionsTimelineParameters = A.Fake<IMentionsTimelineParameters>(); _fakeMentionsTimelineParameters.CallsTo(x => x.MaximumNumberOfTweetsToRetrieve).Returns(_maximumNumberOfTweetsParameterValue); _userIdentifierParameter = TestHelper.GenerateString(); _includeRTSParameter = TestHelper.GenerateString(); _excludeRepliesParameter = TestHelper.GenerateString(); _includeContributorDetailsParameter = TestHelper.GenerateString(); _maximumNumberOfTweetsParameter = TestHelper.GenerateString(); _trimUserParameter = TestHelper.GenerateString(); _sinceIdParameter = TestHelper.GenerateString(); _maxIdParameter = TestHelper.GenerateString(); _includeDetailsParameter = TestHelper.GenerateString(); var queryParameterBuilder = new StringBuilder(); queryParameterBuilder.Append(_includeContributorDetailsParameter); queryParameterBuilder.Append(_maximumNumberOfTweetsParameter); queryParameterBuilder.Append(_trimUserParameter); queryParameterBuilder.Append(_sinceIdParameter); queryParameterBuilder.Append(_maxIdParameter); queryParameterBuilder.Append(_includeDetailsParameter); var homeQueryParameter = _excludeRepliesParameter + queryParameterBuilder; var userQueryParameter = _userIdentifierParameter + _includeRTSParameter + _excludeRepliesParameter + queryParameterBuilder; _expectedTimelineQuery = String.Format(Resources.Timeline_GetHomeTimeline, homeQueryParameter); _expectedUserTimelineQuery = String.Format(Resources.Timeline_GetUserTimeline, userQueryParameter); _expectedMentionsTimelineQuery = String.Format(Resources.Timeline_GetMentionsTimeline, queryParameterBuilder); }
private void InitData() { _fakeHomeTimelineParameters = A.Fake<IHomeTimelineParameters>(); _fakeUserTimelineParameters = A.Fake<IUserTimelineParameters>(); _fakeMentionsTimelineParameters = A.Fake<IMentionsTimelineParameters>(); _fakeUserTimelineQueryParameters = A.Fake<IUserTimelineQueryParameters>(); _maximuNumberOfTweets = TestHelper.GenerateRandomInt(); _resultDTO = new List<ITweetDTO>(); _result = new List<ITweet>(); _userName = TestHelper.GenerateString(); _userId = TestHelper.GenerateRandomLong(); _fakeUser = A.Fake<IUser>(); _fakeUserDTO = A.Fake<IUserDTO>(); _fakeUserIdentifier = _fakeUserDTO; }
public ITwitterListIdentifier Create(string slug, IUserIdentifier userIdentifier) { if (userIdentifier == null) { return null; } if (userIdentifier.Id != TweetinviSettings.DEFAULT_ID) { return Create(slug, userIdentifier.Id); } if (!string.IsNullOrEmpty(userIdentifier.ScreenName)) { return Create(slug, userIdentifier.ScreenName); } return null; }
public string GenerateIdOrScreenNameParameter( IUserIdentifier userIdentifier, string idParameterName = "user_id", string screenNameParameterName = "screen_name") { if (userIdentifier == null) { throw new ArgumentException("Cannot extract id or name parameter from a null userIdentifier."); } if (!_userQueryValidator.CanUserBeIdentified(userIdentifier)) { throw new ArgumentException("Cannot extract either id or name parameter from the given userIdentifier."); } if (_userQueryValidator.IsUserIdValid(userIdentifier.Id)) { return GenerateUserIdParameter(userIdentifier.Id, idParameterName); } return GenerateScreenNameParameter(userIdentifier.ScreenName, screenNameParameterName); }
public static void ArrangeCanUserBeIdentified(this Fake <IUserQueryValidator> userQueryValidator, IUserIdentifier userIdentifier, bool result) { userQueryValidator .CallsTo(x => x.CanUserBeIdentified(userIdentifier)) .Returns(result); }
public IEnumerable <ITweet> GetTweetsFromList(string slug, IUserIdentifier owner) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(GetTweetsFromList(identifier)); }
public Task <IUser> FollowUserAsync(IUserIdentifier user) { return(FollowUserAsync(new FollowUserParameters(user))); }
public bool AddMemberToList(string slug, string ownerScreenName, IUserIdentifier newUser) { var identifier = _twitterListIdentifierFactory.Create(slug, ownerScreenName); return(AddMemberToList(identifier, newUser)); }
public bool UnBlockUser(IUserIdentifier userDTO) { return _userQueryExecutor.UnBlockUser(userDTO); }
public MultiRequestsResult RemoveMultipleMembersFromList(string slug, IUserIdentifier owner, IEnumerable <IUserIdentifier> userIdentifiers) { throw new NotImplementedException(); }
public bool RemoveMemberFromList(ITwitterListIdentifier list, IUserIdentifier newUser) { return(_twitterListQueryExecutor.RemoveMemberFromList(list, newUser)); }
public bool RemoveMemberFromList(string slug, IUserIdentifier owner, IUserIdentifier newUser) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(RemoveMemberFromList(identifier, newUser)); }
public bool RemoveMemberFromList(long listId, IUserIdentifier newUser) { var identifier = _twitterListIdentifierFactory.Create(listId); return(RemoveMemberFromList(identifier, newUser)); }
public MultiRequestsResult AddMultipleMembersToList(string slug, IUserIdentifier owner, IEnumerable <IUserIdentifier> userIdentifiers) { var listIdentifier = _twitterListIdentifierFactory.Create(slug, owner); return(AddMultipleMembersToList(listIdentifier, userIdentifiers)); }
// Get User Lists public IEnumerable <ITwitterList> GetUserSubscribedLists(IUserIdentifier user, bool getOwnedListsFirst) { var listDTOs = _twitterListQueryExecutor.GetUserSubscribedLists(user, getOwnedListsFirst); return(_twitterListsFactory.CreateListsFromDTOs(listDTOs)); }
public bool AddMemberToList(ITwitterListIdentifier list, IUserIdentifier newUser) { return(_twitterListQueryExecutor.AddMemberToList(list, newUser)); }
public bool CheckIfUserIsAListMember(string slug, long ownerId, IUserIdentifier userIdentifier) { var listIdentifier = _twitterListIdentifierFactory.Create(slug, ownerId); return(CheckIfUserIsAListMember(listIdentifier, userIdentifier)); }
public IEnumerable<ITweet> GetFavouriteTweets(IUserIdentifier userDTO, int maxFavouritesToRetrieve = 40) { var favoriteTweetsDTO = _userQueryExecutor.GetFavouriteTweets(userDTO, maxFavouritesToRetrieve); return _tweetFactory.GenerateTweetsFromDTO(favoriteTweetsDTO); }
public bool CheckIfUserIsAListMember(string slug, IUserIdentifier owner, string userScreenName) { var listIdentifier = _twitterListIdentifierFactory.Create(slug, owner); return(CheckIfUserIsAListMember(listIdentifier, userScreenName)); }
public IEnumerable<IUser> GetFriends(IUserIdentifier userDTO, int maxFriendsToRetrieve = 250) { var friendIds = GetFriendIds(userDTO, maxFriendsToRetrieve); return _userFactory.GetUsersFromIds(friendIds); }
public IEnumerable <ITwitterList> GetUserOwnedLists(IUserIdentifier userIdentifier, int maximumNumberOfListsToRetrieve) { var listDTOs = _twitterListQueryExecutor.GetUserOwnedLists(userIdentifier, maximumNumberOfListsToRetrieve); return(_twitterListsFactory.CreateListsFromDTOs(listDTOs)); }
public Task <IUser> ReportUserForSpamAsync(IUserIdentifier user) { return(ReportUserForSpamAsync(new ReportUserForSpamParameters(user))); }
public IEnumerable <IUser> GetListSubscribers(string slug, IUserIdentifier owner, int maximumNumberOfUsersToRetrieve = 100) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(GetListSubscribers(identifier, maximumNumberOfUsersToRetrieve)); }
public bool AddMember(IUserIdentifier user) { return _twitterListController.AddMemberToList(this, user); }
public bool CheckUserMembership(IUserIdentifier user) { return _twitterListController.CheckIfUserIsAListMember(this, user); }
public bool AddMemberToList(long listId, IUserIdentifier newUser) { var identifier = _twitterListIdentifierFactory.Create(listId); return(AddMemberToList(identifier, newUser)); }
public async Task<bool> RemoveMemberAsync(IUserIdentifier user) { return await _taskFactory.ExecuteTaskAsync(() => RemoveMember(user)); }
public bool DestroyList(string slug, IUserIdentifier owner) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(DestroyList(identifier)); }
public async Task<bool> CheckUserSubscriptionAsync(IUserIdentifier user) { return await _taskFactory.ExecuteTaskAsync(() => CheckUserSubscription(user)); }
// Followers public static async Task <IEnumerable <IUser> > GetFollowers(IUserIdentifier user, int maxFollowersToRetrieve = 250) { return(await Sync.ExecuteTaskAsync(() => User.GetFollowers(user, maxFollowersToRetrieve))); }
/// <summary> /// Unmute a specific user. /// </summary> public static bool UnMuteUser(IUserIdentifier userIdentifier) { return AccountController.UnMuteUser(userIdentifier); }
public bool UnSubscribeLoggedUserFromList(string slug, IUserIdentifier owner) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(UnSubscribeLoggedUserFromList(identifier)); }
public bool AddMemberToList(string slug, IUserIdentifier owner, string newUserName) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(AddMemberToList(identifier, newUserName)); }
public bool RemoveMember(IUserIdentifier user) { return _twitterListController.RemoveMemberFromList(this, user); }
public bool CheckIfUserIsAListSubscriber(long listId, IUserIdentifier userIdentifier) { var listIdentifier = _twitterListIdentifierFactory.Create(listId); return(CheckIfUserIsAListSubscriber(listIdentifier, userIdentifier)); }
public bool CheckUserSubscription(IUserIdentifier user) { return _twitterListController.CheckIfUserIsAListSubscriber(this, user); }
public ITwitterList UpdateList(string slug, IUserIdentifier owner, ITwitterListUpdateParameters parameters) { var identifier = _twitterListIdentifierFactory.Create(slug, owner); return(UpdateList(identifier, parameters)); }
public async Task<bool> CheckUserMembershipAsync(IUserIdentifier user) { return await _taskFactory.ExecuteTaskAsync(() => CheckUserMembership(user)); }
public bool CheckIfUserIsAListSubscriber(string slug, IUserIdentifier owner, IUserIdentifier userIdentifier) { var listIdentifier = _twitterListIdentifierFactory.Create(slug, owner); return(CheckIfUserIsAListSubscriber(listIdentifier, userIdentifier)); }
// Query Parameters public IUserTimelineQueryParameters CreateUserTimelineQueryParameters(IUserIdentifier userIdentifier, IUserTimelineParameters userTimelineParameters) { var userIdentifierParameter = TweetinviFactory.CreateConstructorParameter("userIdentifier", userIdentifier); var queryParameters = TweetinviFactory.CreateConstructorParameter("parameters", userTimelineParameters); return _userTimelineRequestQueryParameterFactory.Create(userIdentifierParameter, queryParameters); }
public bool CheckIfUserIsAListSubscriber(ITwitterListIdentifier listIdentifier, IUserIdentifier userIdentifier) { return(_twitterListQueryExecutor.CheckIfUserIsAListSubscriber(listIdentifier, userIdentifier)); }
// Update Relationship Authorization With /// <summary> /// Changes the authorizations you give to a specific user. /// </summary> public static bool UpdateRelationshipAuthorizationsWith(IUserIdentifier userIdentifier, bool retweetsEnabled, bool deviceNotifictionEnabled) { return FriendshipController.UpdateRelationshipAuthorizationsWith(userIdentifier, retweetsEnabled, deviceNotifictionEnabled); }
public Task <IRelationshipDetails> GetRelationshipBetweenAsync(IUserIdentifier sourceUser, IUserIdentifier targetUser) { return(GetRelationshipBetweenAsync(new GetRelationshipBetweenParameters(sourceUser, targetUser))); }
public static string GetUserTimeline(IUserIdentifier userDTO, int maximumTweets = 40) { return TimelineJsonController.GetUserTimeline(userDTO, maximumTweets); }
public Task <long[]> GetFriendIdsAsync(IUserIdentifier user) { return(GetFriendIdsAsync(new GetFriendIdsParameters(user))); }
public bool BlockUser(IUserIdentifier userIdentifier) { return _userQueryExecutor.BlockUser(userIdentifier); }
public ITwitterIterator <long> GetFollowerIdsIterator(IUserIdentifier userIdentifier) { var parameters = new GetFollowerIdsParameters(userIdentifier); return(GetFollowerIdsIterator(parameters)); }
public bool ReportUserForSpam(IUserIdentifier userDTO) { return _userQueryExecutor.ReportUserForSpam(userDTO); }
public Task <IUser[]> GetFollowersAsync(IUserIdentifier user) { return(GetFollowersAsync(new GetFollowersParameters(user))); }
public IEnumerable<long> GetFollowerIds(IUserIdentifier userDTO, int maxFollowersToRetrieve = 5000) { return _userQueryExecutor.GetFollowerIds(userDTO, maxFollowersToRetrieve); }
public Task <IUser> UnblockUserAsync(IUserIdentifier user) { return(UnblockUserAsync(new UnblockUserParameters(user))); }