StreamingRequestProcessor

Namespace: LinqToTwitter
We found 10 examples in language CSharp for this search. You will see 54 fragments of code.

        [Fact]
        public void TwitterContext_Single_Param_Constructor_Sets_Defaults()
        {
            const string BaseUrl = "https://api.twitter.com/1.1/";
            const string SearchUrl = "https://api.twitter.com/1.1/search/";
            ITwitterAuthorizer authorizedClient = new PinAuthorizer();
            var ctx = new TwitterContext(authorizedClient);

            Assert.Same(authorizedClient, ctx.AuthorizedClient);
            Assert.Equal(BaseUrl, ctx.BaseUrl);
            Assert.Equal(SearchUrl, ctx.SearchUrl);
        }

        [Fact]
        public void TwitterContext_Three_Param_Constructor_Sets_Defaults()
        {
            ITwitterExecute execute = new TwitterExecute(new PinAuthorizer());
            const string BaseUrl = "http://api.twitter.com/1/";
            const string SearchUrl = "http://search.twitter.com/";
            var ctx = new TwitterContext(execute, BaseUrl, SearchUrl);

            Assert.Equal(BaseUrl, ctx.BaseUrl);
            Assert.Equal(SearchUrl, ctx.SearchUrl);
        }

        [Fact]
        public void TwitterContext_No_Param_Works_With_Object_Initialization()
        {
            const string BaseUrl = "http://api.twitter.com/1/";
            const string SearchUrl = "http://search.twitter.com/";
            var ctx =
                new TwitterContext(auth)
                {
                    BaseUrl = BaseUrl,
                    SearchUrl = SearchUrl,
                };

            Assert.Equal(BaseUrl, ctx.BaseUrl);
            Assert.Equal(SearchUrl, ctx.SearchUrl);
        }

        [Fact]
        public void TwitterContext_1_Param_Requres_NonNull_Authorization()
        {
            var ex = Assert.Throws<ArgumentNullException>(() => new TwitterContext((PinAuthorizer)null));

            Assert.Equal("authorizedClient", ex.ParamName);
        }

        [Fact]
        public void TwitterContext_4_Params_Requres_NonNull_Authorization()
        {
            var execMock = new Mock<ITwitterExecute>();
            
            var ex = Assert.Throws<ArgumentNullException>(() => new TwitterContext(null, execMock.Object, "", ""));

            Assert.Equal("authorization", ex.ParamName);
        }

        [Fact]
        public void TwitterContext_Requres_NonNull_Executor()
        {
            var authMock = new Mock<ITwitterAuthorizer>();

            var ex = Assert.Throws<ArgumentNullException>(() => new TwitterContext(authMock.Object, null, "", ""));

            Assert.Equal("execute", ex.ParamName);
        }


		[TestMethod]
		public void GetParametersTest()
		{
			var target = new StreamingRequestProcessor<Streaming>();

			var endTime = new DateTime(2020, 8, 30);
			var startTime = new DateTime(2020, 8, 1);
			Expression<Func<Streaming, bool>> expression =
				tweet =>
					tweet.Type == StreamingType.Filter &&
					tweet.BackfillMinutes == 5 &&
					tweet.Ids == "2,3" &&
					tweet.Expansions == "attachments.poll_ids,author_id" &&
					tweet.MediaFields == "height,width" &&
					tweet.PlaceFields == "country" &&
					tweet.PollFields == "duration_minutes,end_datetime" &&
					tweet.TweetFields == "author_id,created_at" &&
					tweet.UserFields == "created_at,verified";

			var lambdaExpression = expression as LambdaExpression;

			Dictionary<string, string> queryParams = target.GetParameters(lambdaExpression);

			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.Type), ((int)StreamingType.Filter).ToString(CultureInfo.InvariantCulture))));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.BackfillMinutes), "5")));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.Ids), "2,3")));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.Expansions), "attachments.poll_ids,author_id")));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.MediaFields), "height,width")));
			Assert.IsTrue(
			   queryParams.Contains(
				   new KeyValuePair<string, string>(nameof(Streaming.PlaceFields), "country")));
			Assert.IsTrue(
			   queryParams.Contains(
				   new KeyValuePair<string, string>(nameof(Streaming.PollFields), "duration_minutes,end_datetime")));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.TweetFields), "author_id,created_at")));
			Assert.IsTrue(
				queryParams.Contains(
					new KeyValuePair<string, string>(nameof(Streaming.UserFields), "created_at,verified")));
		}

		[TestMethod]
		public void BuildUrl_ForFilterStream_IncludesParameters()
		{
			const string ExpectedUrl =
				BaseUrl2 + "tweets/search/stream?" +
				"backfill_minutes=5&" +
				"expansions=attachments.poll_ids%2Cauthor_id&" +
				"ids=2%2C3&" +
				"media.fields=height%2Cwidth&" +
				"place.fields=country&" +
				"poll.fields=duration_minutes%2Cend_datetime&" +
				"tweet.fields=author_id%2Ccreated_at&" +
				"user.fields=created_at%2Cverified";
			var reqProc = new StreamingRequestProcessor<Streaming> { BaseUrl = BaseUrl2 };
			var parameters =
				new Dictionary<string, string>
				{
					{ nameof(Streaming.Type), StreamingType.Filter.ToString() },
					{ nameof(Streaming.BackfillMinutes), "5" },
					{ nameof(Streaming.Expansions), "attachments.poll_ids,author_id" },
					{ nameof(Streaming.MediaFields), "height,width" },
					{ nameof(Streaming.PlaceFields), "country" },
					{ nameof(Streaming.PollFields), "duration_minutes,end_datetime" },
					{ nameof(Streaming.TweetFields), "author_id,created_at" },
					{ nameof(Streaming.UserFields), "created_at,verified" },
					{ nameof(Streaming.Ids), "2,3" },
			   };

			Request req = reqProc.BuildUrl(parameters);

			Assert.AreEqual(ExpectedUrl, req.FullUrl);
		}

		[TestMethod]
        public void ParseJson_WithTweetEntity_Succeeds()
        {
            var content = new StreamContent(execMock.Object, TweetContent);

            (StreamTweet entity, StreamEntityType entityType) = content.ParseJson(TweetContent);

            Assert.IsNotNull(entity);
            Assert.AreEqual("1439984798332866573", entity.Tweet.ID);
            Assert.IsTrue(entity.Tweet.Text.StartsWith("Very"));
            Assert.AreEqual("1324201416731160579", entity.MatchingRules[0].ID);
            Assert.AreEqual("funny things", entity.MatchingRules[0].Tag);
            Assert.AreEqual(StreamEntityType.Tweet, entityType);
        }


        void InitializeTwitterContextForExecuteTest(out TwitterContext ctx, out Expression expression)
        {
            var exec = new Mock<ITwitterExecute>();
            exec.Setup(exc => exc.QueryTwitter(It.IsAny<Request>(), It.IsAny<IRequestProcessor<Status>>()))
                .Returns(SingleStatusResponse);

            ctx = new TwitterContext(exec.Object);
            var publicQuery =
                from tweet in ctx.Status
                where tweet.Type == StatusType.Show
                select tweet;

            expression = publicQuery.Expression;
        }

        [Fact]
        public void TwitterContext_Single_Param_Constructor_Sets_Defaults()
        {
            const string BaseUrl = "https://api.twitter.com/1.1/";
            const string SearchUrl = "https://api.twitter.com/1.1/search/";
            ITwitterAuthorizer authorizedClient = new PinAuthorizer();
            var ctx = new TwitterContext(authorizedClient);

            Assert.Same(authorizedClient, ctx.AuthorizedClient);
            Assert.Equal(BaseUrl, ctx.BaseUrl);
            Assert.Equal(SearchUrl, ctx.SearchUrl);
        }

        [Fact]
        public void TwitterContext_1_Param_Requres_NonNull_Authorization()
        {
            var ex = Assert.Throws<ArgumentNullException>(() => new TwitterContext((PinAuthorizer)null));

            Assert.Equal("authorizedClient", ex.ParamName);
        }

        [Fact]
        public void TwitterContext_Requres_NonNull_Executor()
        {
            var authMock = new Mock<ITwitterAuthorizer>();

            var ex = Assert.Throws<ArgumentNullException>(() => new TwitterContext((ITwitterExecute)null));

            Assert.Equal("execute", ex.ParamName);
        }

        [Fact]
        public void CreateRequestProcessor_Returns_ProperRequestProcessor()
        {
            var ctx = new TwitterContext(auth);

            var showQuery =
                from tweet in ctx.Status
                where tweet.Type == StatusType.Show
                select tweet;

            var statusProc = ctx.CreateRequestProcessor<Status>(showQuery.Expression);
            Assert.IsType(typeof(StatusRequestProcessor<Status>), statusProc);
        }

        [Fact]
        public void CreateStatusRequestProcessorTest()
        {
            var ctx = new TwitterContext(auth);

            var queryResult = from tweet in ctx.Status select tweet;

            IRequestProcessor<Status> actual = ctx.CreateRequestProcessor<Status>(queryResult.Expression);
            Assert.IsType(typeof(StatusRequestProcessor<Status>), actual);
        }

        /// <summary>
        /// Add rules to the filter stream
        /// </summary>
        /// <param name="rules">List of tag/value rules to add</param>
        /// <param name="isValidateOnly">"true" says don't apply rule - just validate to see if it's formatted correctly (dry run)</param>
        /// <param name="cancelToken">Allows you to cancel async operation</param>
        /// <returns></returns>
        public virtual async Task<Streaming?> AddStreamingFilterRulesAsync(List<StreamingAddRule> rules, bool isValidateOnly = false, CancellationToken cancelToken = default)
        {
            _ = rules ?? throw new ArgumentNullException(nameof(rules), $"{nameof(rules)} is required!");

            var addRules = new AddStreamingFilterRules 
            { 
                Add = rules 
            };
            return await AddOrValidateStreamingFilterRulesAsync(addRules, isValidateOnly, cancelToken);
        }

        /// <summary>
        /// Delete rules from the filter stream
        /// </summary>
        /// <param name="ruleIds">List of ids of rules to delete</param>
        /// <param name="isValidateOnly">"true" says don't apply rule - just validate to see if it's formatted correctly (dry run)</param>
        /// <param name="cancelToken">Allows you to cancel async operation</param>
        /// <returns></returns>
        public virtual async Task<Streaming?> DeleteStreamingFilterRulesAsync(List<string> ruleIds, bool isValidateOnly = false, CancellationToken cancelToken = default)
        {
            _ = ruleIds ?? throw new ArgumentNullException(nameof(ruleIds), $"{nameof(ruleIds)} is required!");

            var deleteRules = new DeleteStreamingFilterRules 
            { 
                Delete = new DeleteIds
                {
                    Ids = ruleIds
                }
            };
            return await AddOrValidateStreamingFilterRulesAsync(deleteRules, isValidateOnly, cancelToken);
        }

        async Task<Streaming?> AddOrValidateStreamingFilterRulesAsync<T>(T rules, bool isValidateOnly, CancellationToken cancelToken)
        {
            string rulesUrl = BaseUrl2 + "tweets/search/stream/rules";

            var postData = new Dictionary<string, string>();

            if (isValidateOnly)
            {
                postData["dry_run"] = true.ToString();
                rulesUrl += "?dry_run=true";
            }

            var reqProc = new StreamingRequestProcessor<Streaming>();

            RawResult =
                await TwitterExecutor.SendJsonToTwitterAsync(
                    HttpMethod.Post.ToString(),
                    rulesUrl,
                    postData,
                    rules,
                    cancelToken)
                   .ConfigureAwait(false);

            return reqProc.ProcessActionResult(RawResult, StreamingType.Filter);
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> { 
                       "Type",
                       "Count",
                       "Delimited",
                       "Follow",
                       "Track",
                       "Locations"
                   }).Parameters;

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                Delimited = parameters["Delimited"];
            }

            if (parameters.ContainsKey("Follow"))
            {
                Follow = parameters["Follow"];
            }

            if (parameters.ContainsKey("Track"))
            {
                Track = parameters["Track"];
            }

            if (parameters.ContainsKey("Locations"))
            {
                Locations = parameters["Locations"];
            }

            return 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 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 an url for filtering stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildFilterUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow") &&
                !parameters.ContainsKey("Locations") &&
                !parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("You must specify at least one of the parameters Follow, Locations, or Track.", "FollowOrLocationsOrTrack");
            }

            string url = BaseUrl + "statuses/filter.json";

            var urlParams = new List<string>();

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add("count=" + parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add("delimited=" + parameters["Delimited"]);
            }

            if (parameters.ContainsKey("Follow"))
            {
                urlParams.Add("follow=" + parameters["Follow"]);
            }

            if (parameters.ContainsKey("Locations"))
            {
                urlParams.Add("locations=" + parameters["Locations"]);
            }

            if (parameters.ContainsKey("Track"))
            {
                urlParams.Add("track=" + Uri.EscapeUriString(parameters["Track"]));
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return url;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildFirehoseUrl(Dictionary<string, string> parameters)
        {
            string url = BaseUrl + "statuses/firehose.json";

            var urlParams = new List<string>();

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add("count=" + parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add("delimited=" + parameters["Delimited"]);
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return url;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildLinksUrl(Dictionary<string, string> parameters)
        {
            string url = BaseUrl + "statuses/links.json";

            var urlParams = new List<string>();

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add("count=" + parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add("delimited=" + parameters["Delimited"]);
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return url;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildRetweetUrl(Dictionary<string, string> parameters)
        {
            string url = BaseUrl + "statuses/retweet.json";

            var urlParams = new List<string>();

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add("delimited=" + parameters["Delimited"]);
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return url;
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> { 
                       "Type",
                       "Count",
                       "Delimited",
                       "Follow",
                       "Track",
                       "Locations"
                   }).Parameters;

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                Delimited = parameters["Delimited"];
            }

            if (parameters.ContainsKey("Follow"))
            {
                Follow = parameters["Follow"];
            }

            if (parameters.ContainsKey("Track"))
            {
                Track = parameters["Track"];
            }

            if (parameters.ContainsKey("Locations"))
            {
                Locations = parameters["Locations"];
            }

            return 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 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 an url for filtering stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFilterUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow") &&
                !parameters.ContainsKey("Locations") &&
                !parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("You must specify at least one of the parameters Follow, Locations, or Track.", "FollowOrLocationsOrTrack");
            }

            var req = new Request(BaseUrl + "statuses/filter.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Follow"))
            {
                urlParams.Add(new QueryParameter("follow", parameters["Follow"]));
            }

            if (parameters.ContainsKey("Locations"))
            {
                urlParams.Add(new QueryParameter("locations", parameters["Locations"]));
            }

            if (parameters.ContainsKey("Track"))
            {
                urlParams.Add(new QueryParameter("track", parameters["Track"]));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFirehoseUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/firehose.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildLinksUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/links.json");
            var urlParams = req.RequestParameters;
      
            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildRetweetUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/retweet.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> {
                       nameof(Type),
                       nameof(BackfillMinutes),
                       nameof(Expansions),
                       nameof(Ids),
                       nameof(MediaFields),
                       nameof(PlaceFields),
                       nameof(PollFields),
                       nameof(TweetFields),
                       nameof(UserFields)
                   }).Parameters;

            return 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 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>
        /// appends parameters for Tweet request
        /// </summary>
        /// <param name="parameters">list of parameters from expression tree</param>
        /// <param name="url">base url</param>
        /// <returns>base url + parameters</returns>
        void BuildUrlParameters(Dictionary<string, string> parameters, IList<QueryParameter> urlParams)
        {
            if (parameters.ContainsKey(nameof(BackfillMinutes)))
            {
                int.TryParse(parameters[nameof(BackfillMinutes)], out int minutes);
                BackfillMinutes = minutes;
                urlParams.Add(new QueryParameter("backfill_minutes", BackfillMinutes.ToString()));
            }

            if (parameters.ContainsKey(nameof(Expansions)))
            {
                Expansions = parameters[nameof(Expansions)];
                urlParams.Add(new QueryParameter("expansions", Expansions.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(Ids)))
            {
                Ids = parameters[nameof(Ids)];
                urlParams.Add(new QueryParameter("ids", Ids.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(MediaFields)))
            {
                MediaFields = parameters[nameof(MediaFields)];
                urlParams.Add(new QueryParameter("media.fields", MediaFields.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(PlaceFields)))
            {
                PlaceFields = parameters[nameof(PlaceFields)];
                urlParams.Add(new QueryParameter("place.fields", PlaceFields.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(PollFields)))
            {
                PollFields = parameters[nameof(PollFields)];
                urlParams.Add(new QueryParameter("poll.fields", PollFields.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(TweetFields)))
            {
                TweetFields = parameters[nameof(TweetFields)];
                urlParams.Add(new QueryParameter("tweet.fields", TweetFields.Replace(" ", "")));
            }

            if (parameters.ContainsKey(nameof(UserFields)))
            {
                UserFields = parameters[nameof(UserFields)];
                urlParams.Add(new QueryParameter("user.fields", UserFields.Replace(" ", "")));
            }
        }

        /// <summary>
        /// Returns an object for interacting with stream
        /// </summary>
        /// <param name="notUsed">Not used</param>
        /// <returns>List with a single Streaming</returns>
        public List<T> ProcessResults(string responseJson)
        {
            IEnumerable<Streaming> streamingList;

            if (string.IsNullOrWhiteSpace(responseJson))
            {
                streamingList = new List<Streaming> { new Streaming() };
            }
            else
            {
                var tweetResult = JsonDeserialize(responseJson);
                streamingList = new List<Streaming> { tweetResult };
            }

            return streamingList.OfType<T>().ToList();
        }

        Streaming JsonDeserialize(string responseJson)
        {
            Streaming? streaming = JsonSerializer.Deserialize<Streaming>(responseJson);

            if (streaming == null)
                return new Streaming
                {
                    Type = Type,
                    Expansions = Expansions,
                    MediaFields = MediaFields,
                    PlaceFields = PlaceFields,
                    PollFields = PollFields,
                    TweetFields = TweetFields,
                    UserFields = UserFields
                };
            else
                return streaming with
                {
                    Type = Type,
                    Expansions = Expansions,
                    MediaFields = MediaFields,
                    PlaceFields = PlaceFields,
                    PollFields = PollFields,
                    TweetFields = TweetFields,
                    UserFields = UserFields
                };
        }

        public Streaming? ProcessActionResult(string twitterResponse, Enum theAction)
        {
            return JsonDeserialize(twitterResponse);
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> { 
                       "Type",
                       "AllReplies",
                       "Count",
                       "Delimited",
                       "Follow",
                       "Language",
                       "Locations",
                       "StallWarnings",
                       "Track",
                       "With",
                   }).Parameters;

            if (parameters.ContainsKey("AllReplies")) 
                AllReplies = bool.Parse(parameters["AllReplies"]);

            if (parameters.ContainsKey("Count"))
                Count = int.Parse(parameters["Count"]);

            if (parameters.ContainsKey("Delimited"))
                Delimited = parameters["Delimited"];

            if (parameters.ContainsKey("Follow"))
                Follow = parameters["Follow"];

            if (parameters.ContainsKey("Language"))
                Language = parameters["Language"];

            if (parameters.ContainsKey("Locations"))
                Locations = parameters["Locations"];

            if (parameters.ContainsKey("StallWarnings"))
                StallWarnings = bool.Parse(parameters["StallWarnings"]);

            if (parameters.ContainsKey("Track"))
                Track = parameters["Track"];

            if (parameters.ContainsKey("With"))
                With = parameters["With"];

            return 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 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.Sample:
                    return BuildSampleUrl(parameters);
                case StreamingType.Site:
                    return BuildSiteUrl(parameters);
                case StreamingType.User:
                    return BuildUserUrl(parameters);
                default:
                    break;
            }

            return null;
        }

        /// <summary>
        /// Builds an url for filtering stream.
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        Request BuildFilterUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow") &&
                !parameters.ContainsKey("Locations") &&
                !parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("You must specify at least one of the parameters Follow, Locations, or Track.", "FollowOrLocationsOrTrack");
            }

            var req = new Request(BaseUrl + "statuses/filter.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Follow"))
            {
                urlParams.Add(new QueryParameter("follow", parameters["Follow"]));
            }

            if (parameters.ContainsKey("Locations"))
            {
                urlParams.Add(new QueryParameter("locations", parameters["Locations"]));
            }

            if (parameters.ContainsKey("Track"))
            {
                urlParams.Add(new QueryParameter("track", parameters["Track"]));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            return req;
        }

        /// <summary>
        /// Builds an url for getting all results from the Twitter stream.
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        Request BuildFirehoseUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/firehose.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            return req;
        }

        /// <summary>
        /// Builds an url for getting random sample tweets from the stream.
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        Request BuildSampleUrl(Dictionary<string, string> parameters)
        {
            if (parameters.ContainsKey("Count"))
                throw new ArgumentException("Count is forbidden in Sample streams.", "Count");

            var req = new Request(BaseUrl + "statuses/sample.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            return req;
        }
        
        /// <summary>
        /// Builds an url for getting info for multiple users from stream.
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        Request BuildSiteUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow"))
            {
                throw new ArgumentNullException("Follow", "Follow is required.");
            }

            var req = new Request(SiteStreamUrl + "site.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Delimited"))
            {
                Delimited = parameters["Delimited"];
                urlParams.Add(new QueryParameter("delimited", Delimited.ToLower()));
            }

            if (parameters.ContainsKey("Language"))
            {
                Language = parameters["Language"].Replace(" ", "");
                urlParams.Add(new QueryParameter("language", Language));
            }

            if (parameters.ContainsKey("Follow"))
            {
                Follow = parameters["Follow"].Replace(" ", "");
                urlParams.Add(new QueryParameter("follow", Follow.ToLower()));
            }

            if (parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("Track is not supported for Site Streams.", "Track");
            }

            if (parameters.ContainsKey("With"))
            {
                With = parameters["With"];
                urlParams.Add(new QueryParameter("with", With.ToLower()));
            }

            if (parameters.ContainsKey("AllReplies"))
            {
                AllReplies = bool.Parse(parameters["AllReplies"]);

                if (AllReplies)
                {
                    urlParams.Add(new QueryParameter("replies", "all"));
                }
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                StallWarnings = bool.Parse(parameters["StallWarnings"]);
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            return req;
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> { 
                       "Type",
                       "Count",
                       "Delimited",
                       "Language",
                       "Follow",
                       "Track",
                       "Locations",
                       "StallWarnings"
                   }).Parameters;

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                Delimited = parameters["Delimited"];
            }

            if (parameters.ContainsKey("Language"))
            {
                Language = parameters["Language"];
            }

            if (parameters.ContainsKey("Follow"))
            {
                Follow = parameters["Follow"];
            }

            if (parameters.ContainsKey("Track"))
            {
                Track = parameters["Track"];
            }

            if (parameters.ContainsKey("Locations"))
            {
                Locations = parameters["Locations"];
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                StallWarnings = bool.Parse(parameters["StallWarnings"]);
            }

            return 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 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 an url for filtering stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFilterUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow") &&
                !parameters.ContainsKey("Locations") &&
                !parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("You must specify at least one of the parameters Follow, Locations, or Track.", "FollowOrLocationsOrTrack");
            }

            var req = new Request(BaseUrl + "statuses/filter.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Follow"))
            {
                urlParams.Add(new QueryParameter("follow", parameters["Follow"]));
            }

            if (parameters.ContainsKey("Locations"))
            {
                urlParams.Add(new QueryParameter("locations", parameters["Locations"]));
            }

            if (parameters.ContainsKey("Track"))
            {
                urlParams.Add(new QueryParameter("track", parameters["Track"]));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFirehoseUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/firehose.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildLinksUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/links.json");
            var urlParams = req.RequestParameters;
      
            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildRetweetUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/retweet.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }


        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public Dictionary<string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
               new ParameterFinder<Streaming>(
                   lambdaExpression.Body,
                   new List<string> { 
                       "Type",
                       "Count",
                       "Delimited",
                       "Language",
                       "Follow",
                       "Track",
                       "Locations",
                       "StallWarnings"
                   }).Parameters;

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
            }

            if (parameters.ContainsKey("Delimited"))
            {
                Delimited = parameters["Delimited"];
            }

            if (parameters.ContainsKey("Language"))
            {
                Language = parameters["Language"];
            }

            if (parameters.ContainsKey("Follow"))
            {
                Follow = parameters["Follow"];
            }

            if (parameters.ContainsKey("Track"))
            {
                Track = parameters["Track"];
            }

            if (parameters.ContainsKey("Locations"))
            {
                Locations = parameters["Locations"];
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                StallWarnings = bool.Parse(parameters["StallWarnings"]);
            }

            return 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 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 an url for filtering stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFilterUrl(Dictionary<string, string> parameters)
        {
            if (!parameters.ContainsKey("Follow") &&
                !parameters.ContainsKey("Locations") &&
                !parameters.ContainsKey("Track"))
            {
                throw new ArgumentException("You must specify at least one of the parameters Follow, Locations, or Track.", "FollowOrLocationsOrTrack");
            }

            var req = new Request(BaseUrl + "statuses/filter.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Follow"))
            {
                urlParams.Add(new QueryParameter("follow", parameters["Follow"]));
            }

            if (parameters.ContainsKey("Locations"))
            {
                urlParams.Add(new QueryParameter("locations", parameters["Locations"]));
            }

            if (parameters.ContainsKey("Track"))
            {
                urlParams.Add(new QueryParameter("track", parameters["Track"]));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildFirehoseUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/firehose.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            if (parameters.ContainsKey("Language"))
            {
                urlParams.Add(new QueryParameter("language", parameters["Language"].Replace(" ", "")));
            }

            if (parameters.ContainsKey("StallWarnings"))
            {
                urlParams.Add(new QueryParameter("stall_warnings", parameters["StallWarnings"].ToLower()));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildLinksUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/links.json");
            var urlParams = req.RequestParameters;
      
            if (parameters.ContainsKey("Count"))
            {
                urlParams.Add(new QueryParameter("count", parameters["Count"]));
            }

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }

        /// <summary>
        /// builds an url for getting all results from the Twitter stream
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private Request BuildRetweetUrl(Dictionary<string, string> parameters)
        {
            var req = new Request(BaseUrl + "statuses/retweet.json");
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Delimited"))
            {
                urlParams.Add(new QueryParameter("delimited", parameters["Delimited"]));
            }

            return req;
        }

LinqToTwitter.StreamingRequestProcessor<T> : IRequestProcessor

Constructors :

public StreamingRequestProcessor()

Methods :

public String get_BaseUrl()
public Void set_BaseUrl(String value = )
public ITwitterExecute get_TwitterExecutor()
public Void set_TwitterExecutor(ITwitterExecute value = )
public StreamingType get_Type()
public Void set_Type(StreamingType value = )
public Int32 get_BackfillMinutes()
public Void set_BackfillMinutes(Int32 value = )
public String get_Expansions()
public Void set_Expansions(String value = )
public String get_Ids()
public Void set_Ids(String value = )
public String get_MediaFields()
public Void set_MediaFields(String value = )
public String get_PlaceFields()
public Void set_PlaceFields(String value = )
public String get_PollFields()
public Void set_PollFields(String value = )
public String get_TweetFields()
public Void set_TweetFields(String value = )
public String get_UserFields()
public Void set_UserFields(String value = )
public Dictionary<StringString> GetParameters(LambdaExpression lambdaExpression = )
public Request BuildUrl(Dictionary<StringString> parameters = )
public List<T> ProcessResults(String responseJson = )
public Streaming ProcessActionResult(String twitterResponse = , Enum theAction = )
public Type GetType()
public String ToString()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()