/// <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 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); }
Request BuildRetweetersUrl(Dictionary <string, string> parameters) { if (!parameters.ContainsKey("ID")) { throw new ArgumentException("ID is required.", "ID"); } var url = BaseUrl + "statuses/retweeters/ids.json"; var req = new Request(url); var urlParams = req.RequestParameters; ID = ulong.Parse(parameters["ID"]); urlParams.Add(new QueryParameter("id", parameters["ID"])); if (parameters.ContainsKey("Cursor")) { Cursor = long.Parse(parameters["Cursor"]); urlParams.Add(new QueryParameter("cursor", parameters["Cursor"])); } if (parameters.ContainsKey(nameof(TweetMode))) { TweetMode = RequestProcessorHelper.ParseEnum <TweetMode>(parameters[nameof(TweetMode)]); urlParams.Add(new QueryParameter("tweet_mode", TweetMode.ToString().ToLower())); } return(req); }
/// <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.ParseEnum <DirectMessageType>(parameters["Type"]); switch (Type) { case DirectMessageType.SentBy: return(BuildSentByUrl(parameters)); case DirectMessageType.SentTo: return(BuildSentToUrl(parameters)); case DirectMessageType.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) { if (parameters.ContainsKey(nameof(Type))) { Type = RequestProcessorHelper.ParseEnum <TweetType>(parameters[nameof(Type)]); } else { throw new ArgumentException($"{nameof(Type)} is required", nameof(Type)); } Type = RequestProcessorHelper.ParseEnum <TweetType>(parameters[nameof(Type)]); switch (Type) { case TweetType.Lookup: return(BuildLookupUrl(parameters)); case TweetType.MentionsTimeline: return(BuildMentionsTimelineUrl(parameters)); case TweetType.TweetsTimeline: return(BuildUserTimelineUrl(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 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 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.ParseEnum <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 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); }
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.ParseEnum <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 <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); }
Request BuildVerifyCredentialsUrl(Dictionary <string, string> parameters) { var req = new Request(BaseUrl + "account/verify_credentials.json"); var urlParams = req.RequestParameters; if (parameters.ContainsKey("SkipStatus") && RequestProcessorHelper.FlagTrue(parameters, "SkipStatus")) { SkipStatus = true; urlParams.Add(new QueryParameter("skip_status", "true")); } if (parameters.ContainsKey("IncludeEntities")) { IncludeEntities = bool.Parse(parameters["IncludeEntities"]); urlParams.Add(new QueryParameter("include_entities", parameters["IncludeEntities"].ToLower())); } if (parameters.ContainsKey("IncludeEmail")) { IncludeEmail = bool.Parse(parameters["IncludeEmail"]); urlParams.Add(new QueryParameter("include_email", parameters["IncludeEmail"].ToLower())); } return(req); }
/// <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 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 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); }
/// <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 Request BuildUrl(Dictionary <string, string> parameters) { if (parameters.ContainsKey(nameof(Type))) { Type = RequestProcessorHelper.ParseEnum <StreamingType>(parameters["Type"]); } else { throw new ArgumentException($"{nameof(Type)} is required", nameof(Type)); } string segment = Type == StreamingType.Filter ? "tweets/search/stream" : "tweets/sample/stream"; bool isStreaming = true; if (Type == StreamingType.Rules) { segment = "tweets/search/stream/rules"; isStreaming = false; } var req = new Request(BaseUrl + segment) { IsStreaming = isStreaming }; var urlParams = req.RequestParameters; BuildUrlParameters(parameters, urlParams); return(req); }
/// <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.ParseEnum <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 Request BuildUrl(Dictionary <string, string> parameters) { if (parameters.ContainsKey(nameof(Type))) { Type = RequestProcessorHelper.ParseEnum <TweetType>(parameters[nameof(Type)]); } else { throw new ArgumentException($"{nameof(Type)} is required", nameof(Type)); } return(BuildUrlParameters(parameters, "tweets")); }
/// <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> /// appends parameters for Favorites request /// </summary> /// <param name="parameters">list of parameters from expression tree</param> /// <param name="url">base url</param> /// <returns>base url + parameters</returns> Request BuildFavoritesUrlParameters(Dictionary <string, string> parameters) { var req = new Request(BaseUrl + "favorites/list.json"); var urlParams = req.RequestParameters; if (parameters.ContainsKey("UserID")) { UserID = ulong.Parse(parameters["UserID"]); urlParams.Add(new QueryParameter("user_id", parameters["UserID"])); } if (parameters.ContainsKey("ScreenName")) { ScreenName = parameters["ScreenName"]; urlParams.Add(new QueryParameter("screen_name", parameters["ScreenName"])); } if (parameters.ContainsKey("Count")) { Count = int.Parse(parameters["Count"]); urlParams.Add(new QueryParameter("count", parameters["Count"])); } if (parameters.ContainsKey("SinceID")) { SinceID = ulong.Parse(parameters["SinceID"]); urlParams.Add(new QueryParameter("since_id", parameters["SinceID"])); } if (parameters.ContainsKey("MaxID")) { MaxID = ulong.Parse(parameters["MaxID"]); urlParams.Add(new QueryParameter("max_id", parameters["MaxID"])); } if (parameters.ContainsKey("IncludeEntities")) { IncludeEntities = bool.Parse(parameters["IncludeEntities"]); urlParams.Add(new QueryParameter("include_entities", parameters["IncludeEntities"].ToLower())); } if (parameters.ContainsKey(nameof(TweetMode))) { TweetMode = RequestProcessorHelper.ParseEnum <TweetMode>(parameters[nameof(TweetMode)]); urlParams.Add(new QueryParameter("tweet_mode", TweetMode.ToString().ToLower())); } return(req); }
/// <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.ParseEnum<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) { 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 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 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 a url to show user info /// </summary> /// <param name="parameters">url parameters</param> /// <returns>new url for request</returns> Request BuildShowUrl(Dictionary <string, string> parameters) { if (!parameters.ContainsKey("UserID") && !parameters.ContainsKey("ScreenName")) { throw new ArgumentException("Parameters must include either UserID or ScreenName.", ScreenNameOrUserID); } if (parameters.ContainsKey("UserID") && string.IsNullOrWhiteSpace(parameters["UserID"])) { throw new ArgumentNullException("UserID", "If specified, UserID can't be null or an empty string."); } if (parameters.ContainsKey("ScreenName") && string.IsNullOrWhiteSpace(parameters["ScreenName"])) { throw new ArgumentNullException("ScreenName", "If specified, ScreenName can't be null or an empty string."); } var req = new Request(BaseUrl + "users/show.json"); var urlParams = req.RequestParameters; if (parameters.ContainsKey("UserID")) { UserID = ulong.Parse(parameters["UserID"]); urlParams.Add(new QueryParameter("user_id", parameters["UserID"])); } if (parameters.ContainsKey("ScreenName")) { ScreenName = parameters["ScreenName"]; urlParams.Add(new QueryParameter("screen_name", parameters["ScreenName"])); } if (parameters.ContainsKey("IncludeEntities")) { IncludeEntities = bool.Parse(parameters["IncludeEntities"]); urlParams.Add(new QueryParameter("include_entities", parameters["IncludeEntities"].ToLower())); } if (parameters.ContainsKey(nameof(TweetMode))) { TweetMode = RequestProcessorHelper.ParseEnum <TweetMode>(parameters[nameof(TweetMode)]); urlParams.Add(new QueryParameter("tweet_mode", TweetMode.ToString().ToLower())); } return(req); }
/// <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.ParseEnum <AccountType>(parameters[TypeParam]); return(Type switch { AccountType.VerifyCredentials => BuildVerifyCredentialsUrl(parameters), AccountType.Settings => new Request(BaseUrl + "account/settings.json"), _ => 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(nameof(Type))) { throw new ArgumentException($"You must set {nameof(Type)}.", nameof(Type)); } Type = RequestProcessorHelper.ParseEnum <DirectMessageEventsType>(parameters[nameof(Type)]); return(Type switch { DirectMessageEventsType.List => BuildListUrl(parameters), DirectMessageEventsType.Show => BuildShowUrl(parameters), _ => throw new InvalidOperationException( $"Didn't recognize '{Type}' for {nameof(Type)} parameter in " + $"DirectMessageEventsRequestProcessor.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 Request BuildUrl(Dictionary <string, string> parameters) { if (parameters.ContainsKey(nameof(Type))) { Type = RequestProcessorHelper.ParseEnum <UserType>(parameters["Type"]); } else { throw new ArgumentException($"{nameof(Type)} is required", nameof(Type)); } return(Type switch { UserType.IdLookup => BuildIdLookupUrl(parameters), UserType.UsernameLookup => BuildUsernameLookupUrl(parameters), _ => throw new InvalidOperationException("The default case of BuildUrl should never execute because a Type must be specified."), });