/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <LegalType>(parameters["Type"]);
switch (Type)
{
case LegalType.Privacy:
url = BuildPrivacyUrl(parameters);
break;
case LegalType.TOS:
url = BuildTosUrl(parameters);
break;
default:
break;
}
return(url);
}
/// <summary>
/// Builds url based on input parameters.
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <GeoType>(parameters["Type"]);
switch (Type)
{
case GeoType.ID:
return(BuildIDUrl(parameters));
case GeoType.Reverse:
return(BuildReverseUrl(parameters));
case GeoType.Search:
return(BuildSearchUrl(parameters));
case GeoType.SimilarPlaces:
return(BuildSimilarPlacesUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <AccountType>(parameters["Type"]);
switch (Type)
{
case AccountType.VerifyCredentials:
url = BaseUrl + "account/verify_credentials.xml";
break;
case AccountType.RateLimitStatus:
url = BaseUrl + "account/rate_limit_status.xml";
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey(nameof(Type)))
{
throw new ArgumentException($"You must set {nameof(Type)}.", nameof(Type));
}
Type = RequestProcessorHelper.ParseQueryEnumType <WelcomeMessageType>(parameters[nameof(Type)]);
switch (Type)
{
case WelcomeMessageType.ListMessages:
return(BuildListMessagesUrl(parameters));
case WelcomeMessageType.ListRules:
return(BuildListRulesUrl(parameters));
case WelcomeMessageType.ShowMessage:
return(BuildShowMessagesUrl(parameters));
case WelcomeMessageType.ShowRule:
return(BuildShowRuleUrl(parameters));
default:
throw new InvalidOperationException(
$"Didn't recognize '{Type}' for {nameof(Type)} parameter in WelcomeMessageRequestProcessor.BuildUrl.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <UserStreamType>(parameters["Type"]);
switch (Type)
{
case UserStreamType.User:
url = BuildUserUrl(parameters);
break;
case UserStreamType.Site:
url = BuildSiteUrl(parameters);
break;
default:
throw new ArgumentException("Invalid UserStreamType", "UserStreamType");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <SocialGraphType>(parameters["Type"]);
switch (Type)
{
case SocialGraphType.Followers:
url = BuildSocialGraphFollowersUrl(parameters);
break;
case SocialGraphType.Friends:
url = BuildSocialGraphFriendsUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <StreamingType>(parameters["Type"]);
switch (Type)
{
case StreamingType.Filter:
return(BuildFilterUrl(parameters));
case StreamingType.Firehose:
return(BuildFirehoseUrl(parameters));
case StreamingType.Links:
return(BuildLinksUrl(parameters));
case StreamingType.Retweet:
return(BuildRetweetUrl(parameters));
case StreamingType.Sample:
return(BuildSampleUrl(parameters));
default:
break;
}
return(null);
}
public Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <HelpType>(parameters["Type"]);
switch (Type)
{
case HelpType.Configuration:
return(new Request(BaseUrl + "help/configuration.json"));
case HelpType.Languages:
return(new Request(BaseUrl + "help/languages.json"));
case HelpType.Privacy:
return(new Request(BaseUrl + "help/privacy.json"));
case HelpType.RateLimits:
return(BuildRateLimitsUrl(parameters));
case HelpType.Tos:
return(new Request(BaseUrl + "help/tos.json"));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <DirectMessageType>(parameters["Type"]);
switch (Type)
{
case DirectMessageType.SentBy:
url = BuildSentByUrl(parameters);
break;
case DirectMessageType.SentTo:
url = BuildSentToUrl(parameters);
break;
case DirectMessageType.Show:
url = BuildShowUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <TrendType>(parameters["Type"]);
switch (Type)
{
case TrendType.Available:
return(BuildAvailableTrendsUrl());
case TrendType.Closest:
return(BuildClosestTrendsUrl(parameters));
case TrendType.Place:
return(BuildPlaceTrendsUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <GeoType>(parameters["Type"]);
switch (Type)
{
case GeoType.ID:
url = BuildIDUrl(parameters);
break;
case GeoType.Reverse:
url = BuildReverseUrl(parameters);
break;
case GeoType.Nearby:
url = BuildNearbyPlacesUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <BlockingType>(parameters["Type"]);
switch (Type)
{
case BlockingType.Blocking:
url = BuildBlockingUrl(parameters);
break;
case BlockingType.Exists:
url = BuildBlockingExistsUrl(parameters);
break;
case BlockingType.IDS:
url = BuildBlockingIDsUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <StatusType>(parameters["Type"]);
switch (Type)
{
case StatusType.Friends:
url = BuildFriendUrl(parameters);
break;
case StatusType.Home:
url = BuildHomeUrl(parameters);
break;
case StatusType.Mentions:
url = BuildMentionsUrl(parameters);
break;
case StatusType.Public:
url = BuildPublicUrl();
break;
case StatusType.Retweets:
url = BuildRetweetsUrl(parameters);
break;
case StatusType.RetweetedByMe:
url = BuildRetweetedByMeUrl(parameters);
break;
case StatusType.RetweetedToMe:
url = BuildRetweetedToMeUrl(parameters);
break;
case StatusType.RetweetsOfMe:
url = BuildRetweetsOfMeUrl(parameters);
break;
case StatusType.Show:
url = BuildShowUrl(parameters);
break;
case StatusType.User:
url = BuildUserUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public Request BuildUrl(Dictionary <string, string> parameters)
{
if (parameters.ContainsKey("Type"))
{
Type = RequestProcessorHelper.ParseQueryEnumType <SearchType>(parameters["Type"]);
}
else
{
throw new ArgumentException("Type is required", "Type");
}
return(BuildSearchUrlParameters(parameters, "search/tweets.json"));
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <UserType>(parameters["Type"]);
switch (Type)
{
case UserType.Followers:
url = BuildFollowersUrl(parameters);
break;
case UserType.Friends:
url = BuildFriendsUrl(parameters);
break;
case UserType.Show:
url = BuildShowUrl(parameters);
break;
case UserType.Categories:
url = BuildCategoriesUrl(parameters);
break;
case UserType.Category:
url = BuildUsersInCategoryUrl(parameters);
break;
case UserType.CategoryStatus:
url = BuildCategoryStatusUrl(parameters);
break;
case UserType.Lookup:
url = BuildLookupUrl(parameters);
break;
case UserType.Search:
url = BuildSearchUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <SearchType>(parameters["Type"]);
var url = BaseUrl + "search.atom";
url = BuildSearchUrlParameters(parameters, url);
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <FavoritesType>(parameters["Type"]);
var url = BaseUrl + "favorites.xml";
url = BuildFavoritesUrlParameters(parameters, url);
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <StatusType>(parameters["Type"]);
switch (Type)
{
case StatusType.Conversation:
return(BuildConversationUrl(parameters));
case StatusType.Home:
return(BuildHomeUrl(parameters));
case StatusType.Lookup:
return(BuildLookupUrl(parameters));
case StatusType.Mentions:
return(BuildMentionsUrl(parameters));
case StatusType.Oembed:
return(BuildOembedUrl(parameters));
case StatusType.RetweetsOfMe:
return(BuildRetweetsOfMeUrl(parameters));
case StatusType.Retweets:
return(BuildRetweets(parameters));
case StatusType.Show:
return(BuildShowUrl(parameters));
case StatusType.User:
return(BuildUserUrl(parameters));
case StatusType.Retweeters:
return(BuildRetweetersUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey(TypeParam))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <ListType>(parameters[TypeParam]);
switch (Type)
{
case ListType.Lists:
return(BuildListsUrl(parameters));
case ListType.Show:
return(BuildShowUrl(parameters));
case ListType.Statuses:
return(BuildStatusesUrl(parameters));
case ListType.Memberships:
return(BuildMembershipsUrl(parameters));
case ListType.Subscriptions:
return(BuildSubscriptionsUrl(parameters));
case ListType.Members:
return(BuildMembersUrl(parameters));
case ListType.IsMember:
return(BuildIsMemberUrl(parameters));
case ListType.Subscribers:
return(BuildSubscribersUrl(parameters));
case ListType.IsSubscribed:
return(BuildIsSubcribedUrl(parameters));
case ListType.Ownerships:
return(BuildOwnershipsUrl(parameters));
default:
throw new ArgumentException("Invalid ListType", TypeParam);
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <RelatedResultsType>(parameters["Type"]);
switch (Type)
{
case RelatedResultsType.Show:
return(BuildShowUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
// Joe: Why force a Type when there is only one Type?
//
// Answer: This is a LINQ to Twitter idiom and is necessary for extensibility.
// If we add another member to the enum in the future and this wasn't here,
// then adding this later would break a lot of code - Joe
Type = RequestProcessorHelper.ParseQueryEnumType <SearchType>(parameters["Type"]);
return(BuildSearchUrlParameters(parameters, "tweets.json"));
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <UserType>(parameters["Type"]);
switch (Type)
{
case UserType.Show:
return(BuildShowUrl(parameters));
case UserType.Categories:
return(BuildCategoriesUrl(parameters));
case UserType.Category:
return(BuildUsersInCategoryUrl(parameters));
case UserType.CategoryStatus:
return(BuildCategoryStatusUrl(parameters));
case UserType.Lookup:
return(BuildLookupUrl(parameters));
case UserType.Search:
return(BuildSearchUrl(parameters));
case UserType.Contributees:
return(BuildContributeesUrl(parameters));
case UserType.Contributors:
return(BuildContributorsUrl(parameters));
case UserType.BannerSizes:
return(BuildBannerSizesUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <FriendshipType>(parameters["Type"]);
switch (Type)
{
case FriendshipType.Incoming:
return(BuildFriendshipIncomingUrl(parameters));
case FriendshipType.Lookup:
return(BuildLookupUrl(parameters));
case FriendshipType.Outgoing:
return(BuildFriendshipOutgoingUrl(parameters));
case FriendshipType.Show:
return(BuildFriendshipShowUrl(parameters));
case FriendshipType.NoRetweetIDs:
return(BuildFriendshipNoRetweetIDsUrl());
case FriendshipType.FollowersList:
return(BuildFollowersListUrl(parameters));
case FriendshipType.FriendsList:
return(BuildFriendsListUrl(parameters));
case FriendshipType.FollowerIDs:
return(BuildFollowerIDsUrl(parameters));
case FriendshipType.FriendIDs:
return(BuildFriendIDsUrl(parameters));
default:
throw new ArgumentException("Invalid FriendshipType", "Type");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
const string ParamsParam = "parameters";
if (parameters == null)
{
throw new ArgumentException("You must pass a \"parameters\" Dictionary<string, string> parameter.", ParamsParam);
}
if (!parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <FavoritesType>(parameters["Type"]);
return(BuildFavoritesUrlParameters(parameters));
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <TrendType>(parameters["Type"]);
switch (Type)
{
case TrendType.Current:
url = BuildCurrentTrendsUrl(parameters);
break;
case TrendType.Daily:
url = BuildDailyTrendsUrl(parameters);
break;
case TrendType.Trend:
url = BuildTrendsUrl(parameters);
break;
case TrendType.Weekly:
url = BuildWeeklyTrendsUrl(parameters);
break;
case TrendType.Available:
url = BuildAvailableTrendsUrl(parameters);
break;
case TrendType.Location:
url = BuildLocationTrendsUrl(parameters);
break;
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
if (parameters == null || !parameters.ContainsKey(nameof(Type)))
{
throw new ArgumentException($"You must set {nameof(Type)}.", nameof(Type));
}
Type = RequestProcessorHelper.ParseQueryEnumType <AccountActivityType>(parameters[nameof(Type)]);
switch (Type)
{
case AccountActivityType.Subscriptions:
return(BuildSubscriptionsUrl(parameters));
case AccountActivityType.Webhooks:
return(BuildWebhooksUrl(parameters));
default:
throw new InvalidOperationException(
$"Didn't recognize '{Type}' for {nameof(Type)} parameter in AccountActivityRequestProcessor.BuildUrl.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public string BuildURL(Dictionary <string, string> parameters)
{
string url = null;
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", "Type");
}
Type = RequestProcessorHelper.ParseQueryEnumType <StreamingType>(parameters["Type"]);
switch (Type)
{
case StreamingType.Filter:
url = BuildFilterUrl(parameters);
break;
case StreamingType.Firehose:
url = BuildFirehoseUrl(parameters);
break;
case StreamingType.Links:
url = BuildLinksUrl(parameters);
break;
case StreamingType.Retweet:
url = BuildRetweetUrl(parameters);
break;
case StreamingType.Sample:
url = BuildSampleUrl(parameters);
break;
default:
break;
}
return(url);
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <ControlStreamType>(parameters["Type"]);
switch (Type)
{
case ControlStreamType.Followers:
return(BuildFollowersUrl(parameters));
case ControlStreamType.Info:
return(BuildInfoUrl(parameters));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public virtual Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <AccountType>(parameters[TypeParam]);
switch (Type)
{
case AccountType.VerifyCredentials:
return(BuildVerifyCredentialsUrl(parameters));
case AccountType.Settings:
return(new Request(BaseUrl + "account/settings.json"));
default:
throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified.");
}
}
/// <summary>
/// builds url based on input parameters
/// </summary>
/// <param name="parameters">criteria for url segments and parameters</param>
/// <returns>URL conforming to Twitter API</returns>
public Request BuildUrl(Dictionary <string, string> parameters)
{
const string TypeParam = "Type";
if (parameters == null || !parameters.ContainsKey("Type"))
{
throw new ArgumentException("You must set Type.", TypeParam);
}
Type = RequestProcessorHelper.ParseQueryEnumType <UserStreamType>(parameters["Type"]);
switch (Type)
{
case UserStreamType.User:
return(BuildUserUrl(parameters));
case UserStreamType.Site:
return(BuildSiteUrl(parameters));
default:
throw new ArgumentException("Invalid UserStreamType", "UserStreamType");
}
}