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