public static async Task GetCustomWebhookInfoAsync() { ///TODO: GetWebhookInfo WebhookInfo webhookInfo = await Consts.botClient.GetWebhookInfoAsync(); string allUpd = "["; if (webhookInfo.AllowedUpdates != null) { foreach (var item in webhookInfo.AllowedUpdates) { allUpd += item.ToString() + "|"; } allUpd += "]"; } else { allUpd = "null"; } await Consts.botClient.SendTextMessageAsync(Consts.chatId, "CustomMiddleware GetWebhookInfoAsync:" + "\nUrl : " + webhookInfo.Url + "\nHas cust sert : " + webhookInfo.HasCustomCertificate.ToString() + "\nPending upd : " + webhookInfo.PendingUpdateCount.ToString() + "\nLastErrorDate : " + webhookInfo.LastErrorDate.ToString() + "\nLastErrorMsg : " + webhookInfo.LastErrorMessage + "\nMax conn : " + webhookInfo.MaxConnections.ToString() + "\nAllowedUpdates : " + allUpd); }
public async Task Should_Set_Webhook_With_SelfSigned_Cert() { await _fixture.SendTestCaseNotificationAsync(FactTitles.ShouldSetWebhookWithCertificate); const string url = "https://www.telegram.org/"; const int maxConnections = 5; using (var stream = File.OpenRead(Constants.FileNames.Certificate.PublicKey)) { await BotClient.SetWebhookAsync( url : url, certificate : stream, maxConnections : maxConnections, allowedUpdates : new UpdateType[0] ); } WebhookInfo info = await BotClient.GetWebhookInfoAsync(); Assert.Equal(url, info.Url); Assert.True(info.HasCustomCertificate); Assert.Equal(maxConnections, info.MaxConnections); Assert.Null(info.AllowedUpdates); await BotClient.DeleteWebhookAsync(); }
public async Task Should_Get_Deleted_Webhook_Info() { WebhookInfo info = await BotClient.GetWebhookInfoAsync(); Assert.Empty(info.Url); Assert.False(info.HasCustomCertificate); Assert.Equal(0, info.MaxConnections); Assert.Null(info.AllowedUpdates); }
public async Task Should_Get_Deleted_Webhook_Info() { await _fixture.SendTestCaseNotificationAsync(FactTitles.ShouldGetDeletedWebhookInfo); WebhookInfo info = await BotClient.GetWebhookInfoAsync(); Assert.Empty(info.Url); Assert.False(info.HasCustomCertificate); Assert.Equal(default, info.MaxConnections);
/// <summary> /// Creates a webhook. /// </summary> /// <param name="authorization"> /// An <a href=\"#\" onclick=\"this.href=oauthDoc()\" /// oncontextmenu=\"this.href=oauthDoc()\" target=\"oauthDoc\">OAuth Access Token /// </a> with scopes:<ul><li style='list-style-type: square'><a href=\"#\ /// " onclick=\"this.href=oauthDoc('webhook_write')\" oncontextmenu=\" /// this.href=oauthDoc('webhook_write')\" target=\"oauthDoc\">webhook_write</a /// ></li></ul>in the format <b>'Bearer {accessToken}'. /// </param> /// <param name="webhookInfo">Information about the webhook that you want to create</param> /// <param name="xApiUser"> /// The userId or email of API caller using the account or group token in the format <b> /// userid:{userId} OR email:{email}.</b> If it is not specified, then the caller is inferred from the token. /// </param> /// <param name="xOnBehalfOfUser"> /// The userId or email in the format <b>userid:{userId} OR email:{email}.</b> of /// the user that has shared his/her account /// </param> /// <returns>WebhookCreationResponse</returns> public WebhookCreationResponse CreateWebhook(string authorization, WebhookInfo webhookInfo, string xApiUser, string xOnBehalfOfUser) { // verify the required parameter 'authorization' is set if (authorization == null) { throw new ApiException(400, "Missing required parameter 'authorization' when calling CreateWebhook"); } // verify the required parameter 'webhookInfo' is set if (webhookInfo == null) { throw new ApiException(400, "Missing required parameter 'webhookInfo' when calling CreateWebhook"); } string path = "/webhooks"; path = path.Replace("{format}", "json"); Dictionary <string, string> queryParams = new Dictionary <string, string>(); Dictionary <string, string> headerParams = new Dictionary <string, string>(); Dictionary <string, string> formParams = new Dictionary <string, string>(); Dictionary <string, FileParameter> fileParams = new Dictionary <string, FileParameter>(); string postBody = null; if (authorization != null) { headerParams.Add("Authorization", ApiClient.ParameterToString(authorization)); // header parameter } if (xApiUser != null) { headerParams.Add("x-api-user", ApiClient.ParameterToString(xApiUser)); // header parameter } if (xOnBehalfOfUser != null) { headerParams.Add("x-on-behalf-of-user", ApiClient.ParameterToString(xOnBehalfOfUser)); // header parameter } postBody = ApiClient.Serialize(webhookInfo); // http body (model) parameter // authentication setting, if any string[] authSettings = { }; // make the HTTP request IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings); if ((int)response.StatusCode >= 400) { throw new ApiException((int)response.StatusCode, "Error calling CreateWebhook: " + response.Content, response.Content); } if ((int)response.StatusCode == 0) { throw new ApiException((int)response.StatusCode, "Error calling CreateWebhook: " + response.ErrorMessage, response.ErrorMessage); } return((WebhookCreationResponse)ApiClient.Deserialize(response.Content, typeof(WebhookCreationResponse), response.Headers)); }
/// <summary>Initializer method.</summary> public static void Initialize(Dictionary <ulong, string> initDict) { webhooks = new WebhookInfo[initDict.Count]; int i = 0; foreach (ulong id in initDict.Keys) { string token = initDict[id]; webhooks[i++] = new WebhookInfo(id, token); } }
public static HtmlMessage ParseWebHookInfo(this WebhookInfo webhookInfo) { var htmlMessage = HtmlMessage.Empty .Bold("EngineMode: ").TextBr("WebHook") .Bold("URL: ").TextBr(webhookInfo.Url) .Bold("Custom Cert: ").TextBr(webhookInfo.HasCustomCertificate.ToString()) .Bold("Allowed Updates: ").TextBr(webhookInfo.AllowedUpdates?.ToString()) .Bold("Pending Count: ").TextBr((webhookInfo.PendingUpdateCount - 1).ToString()) .Bold("Max Connection: ").TextBr(webhookInfo.MaxConnections.ToString()) .Bold("Last Error: ").TextBr(webhookInfo.LastErrorDate?.ToDetailDateTimeString()) .Bold("Error Message: ").TextBr(webhookInfo.LastErrorMessage); return(htmlMessage); }
static void Main(string[] args) { // Disable Cache bot.DeleteWebhookAsync(); // bot.SetWebhookAsync("https://tahaelectric.com"); WebhookInfo inf = bot.GetWebhookInfoAsync().Result; OnMessageRecived += Program_OnMessageRecived; Console.Title = "Server is Running . . ."; while (true) { OnMessageRecived("But is Runing ...", ConsoleColor.Green); GetUpdates(); string Input = Console.ReadLine(); } }
public BotService(IOptions <BotConfiguration> config) { _config = config.Value; Client = new TelegramBotClient(_config.BotToken); WebhookInfo webhoks = Client.GetWebhookInfoAsync().Result; if (webhoks != null) { Client.DeleteWebhookAsync().Wait(); } if (!string.IsNullOrEmpty(_config.CallbackUrl)) { var hook = _config.CallbackUrl; Client.SetWebhookAsync(hook).Wait(); } }
public async Task Should_Set_Webhook_With_SelfSigned_Cert() { await using (Stream stream = File.OpenRead(Constants.PathToFile.Certificate.PublicKey)) { await BotClient.SetWebhookAsync( url : "https://www.telegram.org/", certificate : stream, maxConnections : 3, allowedUpdates : Array.Empty <UpdateType>() // send all types of updates ); } WebhookInfo info = await BotClient.GetWebhookInfoAsync(); Assert.Equal("https://www.telegram.org/", info.Url); Assert.True(info.HasCustomCertificate); Assert.Equal(3, info.MaxConnections); Assert.Null(info.AllowedUpdates); }
public async Task Start(CancellationToken cancellationToken = default) { _client = await _clientFactory.Create(_options.Connection.ApiToken); // webhooks not supported WebhookInfo webhookInfo = await _client.GetWebhookInfoAsync(cancellationToken); if (!string.IsNullOrEmpty(webhookInfo.Url)) { _logger.LogWarning("A webhook is set up on the server. Deleting..."); await _client.DeleteWebhookAsync(cancellationToken); } _client.OnMessage += OnClientMessage; _client.OnCallbackQuery += OnCallbackQuery; _client.StartReceiving(AllowedUpdates, cancellationToken); _logger.LogInformation("Started receiving updates."); _cancellationToken = cancellationToken; }
private static async Task <WebhookCreationResponse> CreateWebhook() { HttpClient client = CreateClient(_apiAccessPoint); WebhookInfo model = new WebhookInfo { Name = "Webhook 1", Scope = StaticData.Scope.User, State = "ACTIVE", WebhookSubscriptionEvents = new[] { //StaticData.Event.AgreementCreated, StaticData.Event.AgreementActionCompleted, }, WebhookUrlInfo = new WebhookUrlInfo { Url = AzureFunctionUrl }, ApplicationName = "ApplicationName", ApplicationDisplayName = "ApplicationDisplayName", WebhookConditionalParams = new WebhookConditionalParams { WebhookAgreementEvents = new WebhookAgreementEvents { IncludeDetailedInfo = true, //IncludeDocumentsInfo = true, IncludeSignedDocuments = true, } } }; string json = JsonConvert.SerializeObject(model); HttpResponseMessage responseMesage = await client.PostAsync("webhooks", new StringContent(json, Encoding.UTF8, "application/json")); WebhookCreationResponse response = await HandleResponseMessageAsync <WebhookCreationResponse>(responseMesage); return(response); }
/// <summary> /// Updates a webhook. /// </summary> /// <param name="ifMatch">The server will only update the resource if it matches the listed ETag otherwise error RESOURCE_MODIFIED(412) is returned.</param> /// <param name="webhookId">The webhook identifier, as returned by the webhook creation API or retrieved from the API to fetch webhooks.</param> /// <param name="webhookInfo">Information necessary to update a webhook</param> /// <param name="xApiUser">The userId or email of API caller using the account or group token in the format <b>userid:{userId} OR email:{email}.</b> If it is not specified, then the caller is inferred from the token.</param> /// <param name="xOnBehalfOfUser">The userId or email in the format <b>userid:{userId} OR email:{email}.</b> of the user that has shared his/her account</param> /// <returns></returns> public void UpdateWebhook(string ifMatch, string webhookId, WebhookInfo webhookInfo, string xApiUser = null, string xOnBehalfOfUser = null) { // verify the required parameter 'authorization' is set // verify the required parameter 'ifMatch' is set if (ifMatch == null) { throw new ApiException(400, "Missing required parameter 'ifMatch' when calling UpdateWebhook"); } // verify the required parameter 'webhookId' is set if (webhookId == null) { throw new ApiException(400, "Missing required parameter 'webhookId' when calling UpdateWebhook"); } // verify the required parameter 'webhookInfo' is set if (webhookInfo == null) { throw new ApiException(400, "Missing required parameter 'webhookInfo' when calling UpdateWebhook"); } var path = "/webhooks/{webhookId}"; path = path.Replace("{format}", "json"); path = path.Replace("{" + "webhookId" + "}", ApiClient.ParameterToString(webhookId)); var queryParams = new Dictionary <String, String>(); var headerParams = new Dictionary <String, String>(); var formParams = new Dictionary <String, String>(); var fileParams = new Dictionary <String, FileParameter>(); String postBody = null; if (xApiUser != null) { headerParams.Add("x-api-user", ApiClient.ParameterToString(xApiUser)); // header parameter } if (xOnBehalfOfUser != null) { headerParams.Add("x-on-behalf-of-user", ApiClient.ParameterToString(xOnBehalfOfUser)); // header parameter } if (ifMatch != null) { headerParams.Add("If-Match", ApiClient.ParameterToString(ifMatch)); // header parameter } postBody = ApiClient.Serialize(webhookInfo); // http body (model) parameter // authentication setting, if any String[] authSettings = new String[] { }; // make the HTTP request IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.PUT, queryParams, postBody, headerParams, formParams, fileParams, authSettings); if (((int)response.StatusCode) >= 400) { throw new ApiException((int)response.StatusCode, "Error calling UpdateWebhook: " + response.Content, response.Content); } else if (((int)response.StatusCode) == 0) { throw new ApiException((int)response.StatusCode, "Error calling UpdateWebhook: " + response.ErrorMessage, response.ErrorMessage); } return; }
private bool ValidateWebhookUri(WebhookInfo webHookInfo) { return(string.Equals(webHookInfo.Url, _options.Webhook.Url)); }
public async Task <string> GetWebhookInfoJsonAsync() { WebhookInfo info = await Client.GetWebhookInfoAsync(); return(JsonConvert.SerializeObject(info)); }