Beispiel #1
0
        /// <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 paramFinder =
                new ParameterFinder <TweetQuery>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(EndTime),
                nameof(Exclude),
                nameof(Expansions),
                nameof(Ids),
                nameof(ID),
                nameof(MaxResults),
                nameof(MediaFields),
                nameof(PaginationToken),
                nameof(PlaceFields),
                nameof(PollFields),
                nameof(SinceID),
                nameof(StartTime),
                nameof(TweetFields),
                nameof(UntilID),
                nameof(UserFields)
            });

            return(paramFinder.Parameters);
        }
Beispiel #2
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <User>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "Page",
                "Count",
                "Cursor",
                "Slug",
                "Query",
                "Lang",
                "IncludeEntities",
                "SkipStatus",
                "ImageSize"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #3
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Status>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "SinceID",
                "MaxID",
                "Count",
                "Page",
                "IncludeRetweets",
                "ExcludeReplies",
                "IncludeEntities",
                "TrimUser",
                "IncludeContributorDetails"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #4
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <User>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(UserID),
                nameof(UserIdList),
                nameof(ScreenName),
                nameof(ScreenNameList),
                nameof(Page),
                nameof(Count),
                nameof(Cursor),
                nameof(Slug),
                nameof(Query),
                nameof(Lang),
                nameof(IncludeEntities),
                nameof(SkipStatus),
                nameof(ImageSize),
                nameof(TweetMode)
            });

            return(paramFinder.Parameters);
        }
Beispiel #5
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Status>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "SinceID",
                "MaxID",
                "Count",
                "Cursor",
                "IncludeRetweets",
                "ExcludeReplies",
                "IncludeEntities",
                "IncludeUserEntities",
                "TrimUser",
                "IncludeContributorDetails",
                "IncludeMyRetweet",
                "OEmbedUrl",
                "OEmbedMaxWidth",
                "OEmbedHideMedia",
                "OEmbedHideThread",
                "OEmbedOmitScript",
                "OEmbedAlign",
                "OEmbedRelated",
                "OEmbedLanguage"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #6
0
        /// <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(System.Linq.Expressions.LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Search>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "Query",
                "SearchLanguage",
                "Locale",
                "PageSize",
                "Page",
                "Since",
                "Until",
                "SinceID",
                "MaxID",
                "GeoCode",
                "ShowUser",
                "ResultType",
                "WordPhrase",
                "WordAnd",
                "WordOr",
                "WordNot",
                "Hashtag",
                "PersonFrom",
                "PersonTo",
                "PersonReference",
                "Attitude",
                "WithLinks",
                "WithRetweets"
            });

            return(paramFinder.Parameters);
        }
Beispiel #7
0
        /// <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 <UserStream>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "Delimited",
                "Language",
                "Follow",
                "Track",
                "With",
                "AllReplies",
                "StallWarnings",
                "Locations"
            }).Parameters;

            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("With"))
            {
                With = parameters["With"];
            }

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

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

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

            return(parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var parameters =
                new ParameterFinder <List>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ScreenName",
                "Cursor",
                "ID",
                "ListID",
                "MaxID",
                "PerPage",
                "Page",
                "SinceID"
            })
                .Parameters;

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

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

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

            if (parameters.ContainsKey("MaxID"))
            {
                MaxID = ulong.Parse(parameters["MaxID"]);
            }

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

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

            if (parameters.ContainsKey("SinceID"))
            {
                SinceID = ulong.Parse(parameters["SinceID"]);
            }

            return(parameters);
        }
Beispiel #9
0
        /// <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 <Legal>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type"
            }).Parameters;

            return(parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Mute>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "Cursor",
                "IncludeEntities",
                "SkipStatus"
            });

            return(paramFinder.Parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <AccountActivity>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(WebhookID)
            });

            Dictionary <string, string> parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #12
0
        /// <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 paramFinder =
                new ParameterFinder <SavedSearch>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #13
0
        /// <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 paramFinder =
                new ParameterFinder <Friendship>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "SubjectUser",
                "FollowingUser"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #14
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Media>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(Command),
                nameof(MediaID)
            });

            Dictionary <string, string> parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #15
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <ControlStream>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "UserID",
                "StreamID"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #16
0
        /// <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 paramFinder =
                new ParameterFinder <ComplianceQuery>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(EndTime),
                nameof(ID),
                nameof(StartTime),
                nameof(Status)
            });

            return(paramFinder.Parameters);
        }
Beispiel #17
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Vine>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "Url",
                "MaxWidth",
                "MaxHeight",
                "OmitScript"
            });

            return(paramFinder.Parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <WelcomeMessage>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Count),
                nameof(Cursor),
                nameof(ID),
                nameof(Type)
            });

            Dictionary <string, string> parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #19
0
        /// <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 paramFinder =
                new ParameterFinder <TwitterUserQuery>(
                    lambdaExpression.Body,
                    new List <string> {
                nameof(Type),
                nameof(Ids),
                nameof(Usernames),
                nameof(Expansions),
                nameof(TweetFields),
                nameof(UserFields)
            });

            return(paramFinder.Parameters);
        }
Beispiel #20
0
        /// <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 paramFinder =
                new ParameterFinder <User>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "Page"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #21
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <DirectMessage>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "SinceID",
                "MaxID",
                "Page",
                "Count"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Blocks>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "Page"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #23
0
        /// <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 paramFinder =
                new ParameterFinder <SocialGraph>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "UserID",
                "ScreenName",
                "Cursor",
                "Count"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #24
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public override Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Status>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "Since",
                "SinceID",
                "Count",
                "Page"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
Beispiel #25
0
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Blocks>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "UserID",
                "ScreenName",
                "Page",
                "PerPage",
                "IncludeEntities",
                "SkipStatus",
                "Cursor"
            });

            return(paramFinder.Parameters);
        }
Beispiel #26
0
        /// <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(System.Linq.Expressions.LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Search>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "Query",
                "Language",
                "PageSize",
                "Page",
                "SinceID",
                "GeoCode",
                "ShowUser"
            });

            return(paramFinder.Parameters);
        }
        /// <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(Expansions),
                nameof(MediaFields),
                nameof(PlaceFields),
                nameof(PollFields),
                nameof(TweetFields),
                nameof(UserFields),
                nameof(Ids)
            }).Parameters;

            return(parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Status>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "ID",
                "UserID",
                "ScreenName",
                "SinceID",
                "MaxID",
                "Count",
                "Page"
            });

            var parameters = paramFinder.Parameters;

            return(parameters);
        }
        /// <summary>
        /// extracts parameters from lambda
        /// </summary>
        /// <param name="lambdaExpression">lambda expression with where clause</param>
        /// <returns>dictionary of parameter name/value pairs</returns>
        public virtual Dictionary <string, string> GetParameters(LambdaExpression lambdaExpression)
        {
            var paramFinder =
                new ParameterFinder <Friendship>(
                    lambdaExpression.Body,
                    new List <string> {
                "Type",
                "SubjectUser",
                "FollowingUser",
                "SourceUserID",
                "SourceScreenName",
                "TargetUserID",
                "TargetScreenName",
                "Cursor"
            });

            var parameters = paramFinder.Parameters;

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