/// <summary>
        /// Adds a new webhook to account
        /// </summary>
        /// <param name="url">Url of webhook.</param>
        /// <returns>Account Activity data.</returns>
        public async Task <AccountActivity?> AddAccountActivityWebhookAsync(string url, CancellationToken cancelToken = default)
        {
            if (string.IsNullOrWhiteSpace(url))
            {
                throw new ArgumentException($"{nameof(url)} must be set.", nameof(url));
            }

            var newUrl = BaseUrl + $"account_activity/webhooks.json";

            RawResult =
                await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <AccountActivity>(
                    HttpMethod.Post.ToString(),
                    newUrl,
                    new Dictionary <string, string?>
            {
                { "url", url }
            },
                    cancelToken)
                .ConfigureAwait(false);

            var             reqProc = new AccountActivityRequestProcessor <AccountActivity>();
            AccountActivity?accAct  = reqProc.ProcessActionResult(RawResult, AccountActivityType.Webhooks);

            if (accAct != null)
            {
                accAct.Url = url;
            }

            return(accAct);
        }
        /// <summary>
        /// Sends a CRC check to a webhook for testing
        /// </summary>
        /// <param name="webhookID">ID of webhook to send CRC to.</param>
        /// <returns>Account Activity data.</returns>
        public async Task <AccountActivity?> SendAccountActivityCrcAsync(ulong webhookID, CancellationToken cancelToken = default)
        {
            if (webhookID == default)
            {
                throw new ArgumentException($"{nameof(webhookID)} must be set.", nameof(webhookID));
            }

            var newUrl = BaseUrl + $"account_activity/webhooks/{webhookID}.json";

            var accActValue = new AccountActivityValue();

            RawResult =
                await TwitterExecutor.SendJsonToTwitterAsync(
                    HttpMethod.Put.ToString(),
                    newUrl,
                    new Dictionary <string, string>(),
                    accActValue,
                    cancelToken)
                .ConfigureAwait(false);

            var             reqProc = new AccountActivityRequestProcessor <AccountActivity>();
            AccountActivity?accAct  = reqProc.ProcessActionResult(RawResult, AccountActivityType.Webhooks);

            if (accAct != null)
            {
                accAct.WebhookID = webhookID;
            }

            return(accAct);
        }
Ejemplo n.º 3
0
        protected internal IRequestProcessor <T> CreateRequestProcessor <T>(string requestType)
            where T : class
        {
            string baseUrl = BaseUrl;
            IRequestProcessor <T> req;

            switch (requestType)
            {
            case nameof(Account):
                req = new AccountRequestProcessor <T>();
                break;

            case nameof(AccountActivity):
                req = new AccountActivityRequestProcessor <T>();
                break;

            case nameof(Blocks):
                req = new BlocksRequestProcessor <T>();
                break;

            case nameof(ControlStream):
                req = new ControlStreamRequestProcessor <T>
                {
                    SiteStreamUrl = SiteStreamUrl
                };
                break;

            case nameof(DirectMessage):
                req = new DirectMessageRequestProcessor <T>();
                break;

            case nameof(DirectMessageEvents):
                req = new DirectMessageEventsRequestProcessor <T>();
                break;

            case nameof(Favorites):
                req = new FavoritesRequestProcessor <T>();
                break;

            case nameof(Friendship):
                req = new FriendshipRequestProcessor <T>();
                break;

            case nameof(Geo):
                req = new GeoRequestProcessor <T>();
                break;

            case nameof(Help):
                req = new HelpRequestProcessor <T>();
                break;

            case nameof(List):
                req = new ListRequestProcessor <T>();
                break;

            case nameof(Media):
                req = new MediaRequestProcessor <T>
                {
                    UploadUrl = UploadUrl
                };
                break;

            case nameof(Mute):
                req = new MuteRequestProcessor <T>();
                break;

            case nameof(Raw):
                req = new RawRequestProcessor <T>();
                break;

            case nameof(SavedSearch):
                req = new SavedSearchRequestProcessor <T>();
                break;

            case nameof(Search):
                req = new SearchRequestProcessor <T>();
                break;

            case nameof(Status):
                req = new StatusRequestProcessor <T>();
                break;

            case nameof(Streaming):
                baseUrl = StreamingUrl;
                req     = new StreamingRequestProcessor <T>
                {
                    UserStreamUrl   = UserStreamUrl,
                    SiteStreamUrl   = SiteStreamUrl,
                    TwitterExecutor = TwitterExecutor
                };
                break;

            case nameof(Trend):
                req = new TrendRequestProcessor <T>();
                break;

            case nameof(User):
                req = new UserRequestProcessor <T>();
                break;

            case nameof(Vine):
                req = new VineRequestProcessor <T>
                {
                    VineUrl = VineUrl
                };
                break;

            case nameof(WelcomeMessage):
                req = new WelcomeMessageRequestProcessor <T>();
                break;

            default:
                throw new ArgumentException($"Type, {requestType} isn't a supported LINQ to Twitter entity.", nameof(requestType));
            }

            if (baseUrl != null)
            {
                req.BaseUrl = baseUrl;
            }

            return(req);
        }