public static IReply <IEnumerable <T> > WithValues <T>(this IReply <IEnumerable <T> > reply, params T[] values) { using (var actual = reply.ParsedValue.GetEnumerator()) { var expected = values.GetEnumerator(); for (var i = 0; ; ++i) { var aMoved = actual.MoveNext(); var eMoved = expected.MoveNext(); if (aMoved != eMoved) { throw new AssertionException("parsed and expected value collections have different sizes"); } if (!aMoved) { break; } if (!Equals(expected.Current, actual.Current)) { throw new AssertionException($"parsed value [{i}]: {expected}", $"parsed value [{i}]: {reply.ParsedValue}"); } } } return(reply); }
/// <summary> /// Get request /// </summary> /// <typeparam name="TReply"></typeparam> /// <returns></returns> protected async virtual Task <bool> Execute <TReply>() where TReply : IReply { string json = null; try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url); request.AutomaticDecompression = DecompressionMethods.GZip; request.Headers.Add(Utils.AuthorisationKey, Utils.ApiKey); using (HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync()) //using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) using (Stream stream = response.GetResponseStream()) using (StreamReader reader = new StreamReader(stream)) { json = reader.ReadToEnd(); Reply = JsonConvert.DeserializeObject <TReply>(json); Reply.Json = json; return(Reply.Validate()); } } catch (Exception ex) { Reply = new BaseReply(false, ex.Message) { Json = json }; } return(Reply.Success); }
/// <summary> /// Получает и закрывается /// </summary> /// <param name="reply"></param> /// <returns></returns> public virtual bool Handle(IReply reply) { this.TotalHandledReplyCount++; this.CurrentReply = reply; return(true); }
public void SendReply(IReply reply) { StringBuilder sb = new StringBuilder(); // Server sb.Append(IRCServer.PREFIX); sb.Append(Server.ServerHost); sb.Append(' '); // Reply code sb.AppendFormat(@"{0:000}", reply.ReplyCode); sb.Append(' '); // Receiver if (Session == null) { sb.Append('-'); } else { sb.Append(Session.User.GetIRCName()); } sb.Append(' '); // Contents sb.Append(reply.GetLine()); sb.Append(IReply.CRLF); Send(sb); }
/// <summary> /// Sends <c>.webp</c> sticker. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="stickerId">A file id as string to resend a sticker that is already on the Telegram servers.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendStickerAsync([NotNull] string chatId, [NotNull] string stickerId, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(stickerId, nameof(stickerId)); var parameters = new NameValueCollection { { "sticker", stickerId } }; return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendSticker", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
public static void DeleteReply(int id) { ReplyInfo reply = GetReply(id); IReply dal = Factory <IReply> .Create("Reply"); dal.Delete(reply); Admin.UpdateForumCounts(); }
public static int AddReply(ReplyInfo reply) { IReply dal = Factory <IReply> .Create("Reply"); int replyid = dal.Add(reply); return(replyid); }
public async Task <bool> HandleAsync(IReply <TOriginal, TSubject> e) { if (e.Original.Equals(Original)) { return(await Handler(e.Subject)); } return(false); }
public static IReply <T> WithValue <T>(this IReply <T> reply, T expected) { if (!Equals(expected, reply.ParsedValue)) { throw new AssertionException($"parsed value: {expected}", $"parsed value: {reply.ParsedValue}"); } return(reply); }
public ReplyController(IReply replyContext, IMailService mailService, ILogger <ReplyController> logger, IUser user, IMapper mapper, IHubContext <CommentHub> hub, IComment commemtContext) { _commemtContext = commemtContext; _hub = hub; _replyContext = replyContext; _mailService = mailService; _logger = logger; _mapper = mapper; }
/// <summary> /// Sends a general file. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="documentId">A file id as string to resend a file that is already on the Telegram servers.</param> /// <param name="caption">The document caption, 0-200 characters.</param> /// <param name="disableNotification">if set to <c>true</c> [disable notification].</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> /// <remarks> /// Bots can currently send files of any type of up to 50 MB in size, this limit may be changed in the /// future. /// </remarks> public Task<Message> SendDocumentAsync([NotNull] string chatId, [NotNull] string documentId, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(documentId, nameof(documentId)); var parameters = new NameValueCollection { { "document", documentId } }; parameters.AddIf(!string.IsNullOrWhiteSpace(caption), "caption", caption); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendDocument", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
public static void MoveReplies(int newtopicid, List <int> replyIDs) { ITopic topicdal = Factory <ITopic> .Create("Topic"); TopicInfo topic = topicdal.GetById(newtopicid); IReply dal = Factory <IReply> .Create("Reply"); dal.MoveReplies(topic, replyIDs); Admin.UpdateForumCounts(); }
public static void Case <TToken, T>( this IReply <TToken, T> reply, Action <ITokenStream <TToken>, String> failure, Action <ITokenStream <TToken>, T> success) { reply.Case( failure: (stream, errorMessage) => { failure(stream, errorMessage); return(Unit.Instance); }, success: (stream, value) => { success(stream, value); return(Unit.Instance); }); }
/// <summary> /// Sends a point on the map. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="latitude">Latitude of location</param> /// <param name="longitude">Longitude of location</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendLocationAsync([NotNull] string chatId, double latitude, double longitude, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); var parameters = new NameValueCollection { { "latitude", latitude.ToString(CultureInfo.InvariantCulture) }, { "longitude", longitude.ToString(CultureInfo.InvariantCulture) } }; return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendLocation", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends an audio file to be displayed as a playable voice message on Telegram clients. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="voice">Id of an audio file that is already on the Telegram servers to resend it.</param> /// <param name="duration">Duration of sent audio in seconds.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> /// <remarks> /// For this to work, your audio must be in an .ogg file encoded with OPUS (other formats may be sent /// as <see cref="Audio" /> or <see cref="Document" />). Bots can currently send audio files of up to /// 50 MB in size, this limit may be changed in the future. /// </remarks> public Task<Message> SendVoiceAsync([NotNull] string chatId, [NotNull] string voice, int duration = 0, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(voice, nameof(voice)); var parameters = new NameValueCollection { { "voice", voice } }; if( duration > 0 ) parameters.Add("duration", duration); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendVoice", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="audioId">Id of an audio file that is already on the Telegram servers.</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendAudioAsync([NotNull] string chatId, [NotNull] string audioId, int duration = 0, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(chatId, nameof(audioId)); var parameters = new NameValueCollection { { "audio", audioId } }; parameters.AddIf(duration > 0, "duration", duration); parameters.AddIf(!string.IsNullOrWhiteSpace(performer), "performer", performer); parameters.AddIf(!string.IsNullOrWhiteSpace(title), "title", title); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendAudio", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
public override bool Handle(IReply reply) { this.TotalHandledReplyCount++; if (Owner.Instance.EvalBoolean(Expression)) { return(reply.Move(this, primTrue)); } else { return(reply.Move(this, primFalse)); } }
public override bool Handle(IReply reply) { CurrentReplyCount++; if (reply.PrevoisPrimitive is Blocker) { TotalNotHandledReplyCount++; } else { TotalHandledReplyCount++; } return(true); }
private IStatusCodeResult Map <T>(IReply <T> reply, HttpStatusCode defaultSuccess = HttpStatusCode.OK) { _logger.LogInformation(reply.ToStringLog()); if (reply.IsSuccess) { return(new StatusCodeResult <T>(defaultSuccess, reply.Value)); } return(reply.ErrorCode switch { NOT_FOUND => NotFound(reply.Value), INVALID_ID => BadRequest(reply.Value), _ => UnprocessableEntity(reply.Value) });
private IReplyMarkup GetKeyboard(IReply reply) { if (reply.GetType() == typeof(ReplyOnGetPlants)) { return(keyboardController.GetUserPlantsKeyboard(((ReplyOnGetPlants)reply).PlantsName.ToArray())); } if (reply.GetType() == typeof(ReplyOnGetPlantsToDelete)) { return(keyboardController.GetUserPlantsKeyboard(((ReplyOnGetPlantsToDelete)reply).PlantsName.ToArray())); } if (reply.GetType() == typeof(ReplyOnWantedAddPlant) || reply.GetType() == typeof(ReplyOnSetPlantName)) { return(keyboardController.GetCancelKeyboard()); } return(keyboardController.GetMainMenuKeyboard()); }
public static void UpdateReply(int replyid, string message, MemberInfo author, bool isAdministrator, bool showsig) { ReplyInfo reply = GetReply(replyid); reply.Message = message; if (!isAdministrator) { reply.LastEditDate = DateTime.UtcNow; reply.LastEditedById = author.Id; } reply.UseSignatures = showsig; IReply dal = Factory <IReply> .Create("Reply"); dal.Update(reply); }
/// <summary> /// Subscribes for an initial snapshot and then incremental update. /// </summary> /// <param name="fiber">the target executor to receive the message</param> /// <param name="receive"></param> public void PrimedSubscribe(IFiber fiber, Action <T> receive) { using (IReply <T> reply = this._requestChannel.SendRequest(new object())) { if (reply == null) { throw new ArgumentException(typeof(T).Name + " synchronous request has no reply subscriber."); } T result; if (!reply.Receive(this._timeoutInMs, out result)) { throw new ArgumentException(typeof(T).Name + " synchronous request timed out in " + this._timeoutInMs); } receive(result); this._updatesChannel.Subscribe(fiber, receive); } }
/// <summary>Send phone contacts.</summary> /// <param name="chatId"> /// Unique identifier for the target chat or username of the target channel (in the format /// @channelusername) /// </param> /// <param name="phoneNumber">Contact's phone number.</param> /// <param name="firstName">Contact's first name.</param> /// <param name="lastName">Contact's last name.</param> /// <param name="disableNotification"> /// If set to <c>true</c> sends the message silently. iOS users will not receive a notification, /// Android users will receive a notification with no sound. /// </param> /// <param name="replyToMessageId"> /// If the message is a reply, ID of the original message. /// </param> /// <param name="replyMarkup"> /// Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. /// </param> /// <param name="cancellationToken"> /// A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for the task to /// complete. /// </param> /// <returns> /// A task that represents the asynchronous operation. The task results contains sent /// <see cref="Message" /> on success. /// </returns> /// <exception cref="System.ArgumentNullException"> /// chatId cannot be null -or- phoneNumber cannot be null -or- firstName cannot be null. /// </exception> public Task<Message> SendContactAsync([NotNull] string chatId, [NotNull] string phoneNumber, [NotNull] string firstName, string lastName = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(phoneNumber, nameof(phoneNumber)); Contracts.EnsureNotNull(firstName, nameof(firstName)); var parameters = new NameValueCollection { { "chat_id", chatId }, { "phone_number", phoneNumber }, { "first_name", firstName } }; parameters.AddIf(!string.IsNullOrWhiteSpace(lastName), "last_name", lastName); parameters.AddIf(!disableNotification, "disable_notification", true); parameters.AddIf(replyToMessageId > 0, "reply_to_message_id", replyToMessageId); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendContact", parameters, replyMarkup: replyMarkup); }
/// <summary> /// Update the parent meme to reflect the new state of the supplied meme /// Recalculate and update the reply trend score of the supplied meme inside the reply list of the parent meme (identified by ResponseToId) /// </summary> /// <param name="replyMeme"></param> /// <returns></returns> public void UpdateReplyToMeme(IMeme replyMeme) { if (replyMeme != null && replyMeme.ResponseToId != null) { IMeme parentMeme = repository.GetMeme(replyMeme.ResponseToId); if (parentMeme.ReplyIds == null) { // This meme is not a reply within the parent meme return; } IReply reply = parentMeme.ReplyIds.FirstOrDefault(x => x.Id == replyMeme.Id); if (reply != null) { // Save the parent meme to which the reply meme is a response to (with the updated reply trend scrore) Save(parentMeme); } } }
public void BuildMessageToUser(IReply reply) { if (reply is ReplyOnGetPlantPhoto replyOnGetPlantPhoto) { if (replyOnGetPlantPhoto.IsExist) { SendAnswerWithPhoto(replyOnGetPlantPhoto); return; } var answerText = "У этого растения пока нет фотографий.\n\n" + "Чтобы добавить фотографию своего растения, просто отправь её мне. " + "Не забудь добавить в описании имя растения, иначе я тебя не пойму :("; var keyboard = keyboardController.GetMainMenuKeyboard(); SendAnswer(reply.UserId, answerText, keyboard); return; } SendAnswer(reply.UserId, GetTextAnswer(reply), GetKeyboard(reply)); }
/// <summary> /// Send information about a venue. /// </summary> /// <param name="chatId">Unique identifier for the target chat or username of the target channel (in the format /// @channelusername).</param> /// <param name="latitude">Latitude of the venue.</param> /// <param name="longitude">Longitude of the venue.</param> /// <param name="title">Name of the venue.</param> /// <param name="address">Address of the venue.</param> /// <param name="forsquareId">Foursquare identifier of the venue.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, /// Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for the task to /// complete.</param> /// <returns> /// A task that represents the asynchronous operation. The task results contains sent /// <see cref="Message" /> on success. /// </returns> /// <exception cref="System.ArgumentNullException">chatId cannot be null -or- title cannot be null -or- address cannot be null.</exception> public Task<Message> SendVenueAsync([NotNull] string chatId, float latitude, float longitude, [NotNull] string title, [NotNull] string address, string forsquareId = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(title, nameof(title)); Contracts.EnsureNotNull(address, nameof(address)); var parameters = new NameValueCollection { { "chat_id", chatId }, { "latitude", latitude.ToString(CultureInfo.InvariantCulture) }, { "longitude", longitude.ToString(CultureInfo.InvariantCulture) }, { "title", title }, { "address", address } }; parameters.AddIf(!string.IsNullOrWhiteSpace(forsquareId), "foursquare_id", forsquareId); parameters.AddIf(!disableNotification, "disable_notification", true); parameters.AddIf(replyToMessageId > 0, "reply_to_message_id", replyToMessageId); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendVenue", parameters, replyMarkup: replyMarkup); }
/// <summary> /// Post request /// </summary> /// <typeparam name="TReply"></typeparam> /// <typeparam name="TRequest"></typeparam> /// <param name="args"></param> /// <returns></returns> protected virtual bool Execute <TReply, TRequest>(TRequest args) where TReply : IReply where TRequest : IRequest { string json = null; try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url); request.ContentType = "application/json"; request.Method = "POST"; request.Headers.Add(Utils.AuthorisationKey, Utils.ApiKey); using (StreamWriter writer = new StreamWriter(request.GetRequestStream())) { json = JsonConvert.SerializeObject(args); writer.Write(json); writer.Flush(); writer.Close(); } using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) using (Stream stream = response.GetResponseStream()) using (StreamReader reader = new StreamReader(stream)) { json = reader.ReadToEnd(); Reply = JsonConvert.DeserializeObject <TReply>(json); Reply.Json = json; return(Reply.Validate()); } } catch (Exception ex) { Reply = new BaseReply(false, ex.Message) { Json = json }; } return(Reply.Success); }
/// <summary> /// Sends a photo. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="photoStream">A <see cref="Stream" /> to the photo to upload.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="photoStream" />.</param> /// <param name="caption">Photo caption (may also be used when resending photos by file id).</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendPhotoAsync([NotNull] string chatId, [NotNull] Stream photoStream, string fileName, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(photoStream, nameof(photoStream)); // ReSharper disable once UseObjectOrCollectionInitializer var content = new MultipartFormDataContent(); content.Add(new StreamContent(photoStream), "photo", fileName); if( !string.IsNullOrWhiteSpace(caption) ) content.Add("caption", caption); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendPhoto", content, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends a general file. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="documentStream">A <see cref="Stream" /> to the document file to send.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="documentStream" />.</param> /// <param name="caption">Document caption, 0-200 characters.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> /// <remarks> /// Bots can currently send files of any type of up to 50 MB in size, this limit may be changed in the /// future. /// </remarks> public Task<Message> SendDocumentAsync(long chatId, [NotNull] Stream documentStream, string fileName, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { return this.SendDocumentAsync(chatId.ToString(), documentStream, fileName, caption, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary>Send phone contacts.</summary> /// <param name="chatId"> /// Unique identifier for the target chat or username of the target channel (in the format /// @channelusername) /// </param> /// <param name="phoneNumber">Contact's phone number.</param> /// <param name="firstName">Contact's first name.</param> /// <param name="lastName">Contact's last name.</param> /// <param name="disableNotification"> /// If set to <c>true</c> sends the message silently. iOS users will not receive a notification, /// Android users will receive a notification with no sound. /// </param> /// <param name="replyToMessageId"> /// If the message is a reply, ID of the original message. /// </param> /// <param name="replyMarkup"> /// Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. /// </param> /// <param name="cancellationToken"> /// A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for the task to /// complete. /// </param> /// <returns> /// A task that represents the asynchronous operation. The task results contains sent /// <see cref="Message" /> on success. /// </returns> /// <exception cref="System.ArgumentNullException"> /// chatId cannot be null -or- phoneNumber cannot be null -or- firstName cannot be null. /// </exception> public Task<Message> SendContactAsync(long chatId, [NotNull] string phoneNumber, [NotNull] string firstName, string lastName = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendContactAsync(chatId.ToString(), phoneNumber, firstName, lastName, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary>Sends a text message.</summary> /// <param name="chatId"> /// Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername). /// </param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode"> /// Indicates the way that the Telegram should parse the sent message. /// </param> /// <param name="disableWebPagePreview"> /// if set to <c>true</c> disables link previews for links in this message. /// </param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId"> /// If the message is a reply, ID of the original message. /// </param> /// <param name="replyMarkup"> /// Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of /// cancellation. /// </param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendMessageAsync([NotNull] string chatId, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(text, nameof(text)); var parameters = new NameValueCollection { { "text", text } }; parameters.AddIf(disableWebPagePreview, "disable_web_page_preview", true); parameters.AddIf(parseMode != ParseMode.Normal, "parse_mode", parseMode.ToString()); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendMessage", parameters, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends a text message and requests to hide the current custom keyboard by default. Optionally if the /// message is a reply, ID of the original message will be sent. /// </summary> /// <param name="message">The original received message.</param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode">Indicates the way that the Telegram should parse the sent message.</param> /// <param name="disableWebPagePreview">if set to <c>true</c> disables link previews for links in this message.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. Defaults to hide the current /// custom keyboard.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendMessageAsync([NotNull] Message message, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(message, nameof(message)); return(this.SendMessageAsync(message.Chat.Id.ToString(), text, parseMode, disableWebPagePreview, disableNotification, message.ReplyToMessage?.Id ?? 0, replyMarkup, cancellationToken)); }
/// <summary> /// Sends a text message. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode">Indicates the way that the Telegram should parse the sent message.</param> /// <param name="disableWebPagePreview">if set to <c>true</c> disables link previews for links in this message.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendMessageAsync(long chatId, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return(this.SendMessageAsync(chatId.ToString(), text, parseMode, disableWebPagePreview, disableNotification, replyToMessageId, replyMarkup, cancellationToken)); }
/// <summary> /// Sends <c>.webp</c> sticker. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="stickerStream">A <see cref="Stream" /> to the sticker file to send.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="stickerStream" />.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendStickerAsync([NotNull] string chatId, [NotNull] Stream stickerStream, string fileName, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(stickerStream, nameof(stickerStream)); // ReSharper disable once UseObjectOrCollectionInitializer var content = new MultipartFormDataContent(); content.Add("sticker", stickerStream, fileName); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendSticker", content, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends <c>.webp</c> sticker. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="stickerId">A file id as string to resend a sticker that is already on the Telegram servers.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendStickerAsync(long chatId, [NotNull] string stickerId, long replyToMessageId = 0, bool disableNotification = false, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendStickerAsync(chatId.ToString(), stickerId, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a point on the map. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="latitude">Latitude of location</param> /// <param name="longitude">Longitude of location</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendLocationAsync(long chatId, double latitude, double longitude, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendLocationAsync(chatId.ToString(), latitude, longitude, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a text message. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode">Indicates the way that the Telegram should parse the sent message.</param> /// <param name="disableWebPagePreview">if set to <c>true</c> disables link previews for links in this message.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendMessageAsync(long chatId, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendMessageAsync(chatId.ToString(), text, parseMode, disableWebPagePreview, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a video file. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="filePath">Fully qualified path to the video file to send.</param> /// <param name="duration">Duration of sent video in seconds.</param> /// <param name="caption">Video caption.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> /// <remarks> /// Bots can currently send files of any type of up to 50 MB in size, this limit may be changed in the /// future. /// </remarks> public Task<Message> SendVideoFromFileAsync([NotNull] string chatId, [NotNull] string filePath, int duration = 0, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(filePath, nameof(filePath)); Contracts.EnsureFileExists(filePath); var fileName = Path.GetFileName(filePath); var fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read); return this.SendVideoAsync(chatId, fileStream, fileName, duration, caption, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a photo. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="photoStream">A <see cref="Stream" /> to the photo to upload.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="photoStream" />.</param> /// <param name="caption">Photo caption (may also be used when resending photos by file id).</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendPhotoAsync(long chatId, [NotNull] Stream photoStream, string fileName, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendPhotoAsync(chatId.ToString(), photoStream, fileName, caption, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends an audio file to be displayed as a playable voice message on Telegram clients. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="filePath">Fully qualified path to the audio file.</param> /// <param name="caption"></param> /// <param name="duration">Duration of sent audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendAudioFromFileAsync(long chatId, [NotNull] string filePath, string caption, int duration = 0, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { return(this.SendAudioFromFileAsync(chatId.ToString(), filePath, caption, duration, performer, title, disableNotification, replyToMessageId, replyMarkup, cancellationToken)); }
/// <summary> /// Instantiate this classed (and its variables) based on the values of another IReply /// </summary> /// <param name="reply"></param> public TableReply(IReply reply) : base(reply) { }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="audioId">Id of an audio file that is already on the Telegram servers.</param> /// <param name="caption">Audio caption, 0-200 characters</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendAudioAsync([NotNull] string chatId, [NotNull] string audioId, string caption = null, int duration = 0, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(chatId, nameof(audioId)); var parameters = new NameValueCollection { { "audio", audioId } }; parameters.AddIf(duration > 0, "duration", duration); parameters.AddIf(!string.IsNullOrWhiteSpace(performer), "performer", performer); parameters.AddIf(!string.IsNullOrWhiteSpace(title), "title", title); parameters.AddIf(!string.IsNullOrWhiteSpace(caption), "caption", caption.Length > 200 ? caption.Substring(0, 200) : caption); return(this.CallTelegramMethodAsync <Message>(cancellationToken, "sendAudio", parameters, chatId, replyToMessageId, replyMarkup, disableNotification)); }
/// <summary>Sends a text message.</summary> /// <param name="chatId"> /// Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername). /// </param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode"> /// Indicates the way that the Telegram should parse the sent message. /// </param> /// <param name="disableWebPagePreview"> /// if set to <c>true</c> disables link previews for links in this message. /// </param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId"> /// If the message is a reply, ID of the original message. /// </param> /// <param name="replyMarkup"> /// Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of /// cancellation. /// </param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendMessageAsync([NotNull] string chatId, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(text, nameof(text)); var parameters = new NameValueCollection { { "text", text } }; parameters.AddIf(disableWebPagePreview, "disable_web_page_preview", true); parameters.AddIf(parseMode != ParseMode.Normal, "parse_mode", parseMode.ToString()); return(this.CallTelegramMethodAsync <Message>(cancellationToken, "sendMessage", parameters, chatId, replyToMessageId, replyMarkup, disableNotification)); }
/// <summary> /// Sends a point on the map. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="latitude">Latitude of location</param> /// <param name="longitude">Longitude of location</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendLocationAsync(long chatId, double latitude, double longitude, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return(this.SendLocationAsync(chatId.ToString(), latitude, longitude, disableNotification, replyToMessageId, replyMarkup, cancellationToken)); }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="audioStream">A <see cref="Stream" /> to the audio file to send.</param> /// <param name="caption">Audio caption, 0-200 characters</param> /// <param name="fileName">A name for the file to be sent using <paramref name="audioStream" />.</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendAudioAsync([NotNull] string chatId, [NotNull] Stream audioStream, string caption, string fileName, int duration, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(audioStream, nameof(audioStream)); // ReSharper disable once UseObjectOrCollectionInitializer var content = new MultipartFormDataContent(); content.Add("audio", audioStream, fileName); content.AddIf(duration > 0, "duration", duration); content.AddIf(!string.IsNullOrWhiteSpace(performer), "performer", performer); content.AddIf(!string.IsNullOrWhiteSpace(title), "title", title); content.AddIf(!string.IsNullOrWhiteSpace(caption), "caption", caption.Length > 200 ? caption.Substring(0, 200) : caption); return(this.CallTelegramMethodAsync <Message>(cancellationToken, "sendAudio", content, chatId, replyToMessageId, replyMarkup, disableNotification)); }
/// <summary> /// Sends a text message and requests to hide the current custom keyboard by default. Optionally if the /// message is a reply, ID of the original message will be sent. /// </summary> /// <param name="message">The original received message.</param> /// <param name="text">Text of the message to be sent.</param> /// <param name="parseMode">Indicates the way that the Telegram should parse the sent message.</param> /// <param name="disableWebPagePreview">if set to <c>true</c> disables link previews for links in this message.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. Defaults to hide the current /// custom keyboard.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendMessageAsync([NotNull] Message message, [NotNull] string text, ParseMode parseMode = ParseMode.Normal, bool disableWebPagePreview = false, bool disableNotification = false, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(message, nameof(message)); return this.SendMessageAsync(message.Chat.Id.ToString(), text, parseMode, disableWebPagePreview, disableNotification, message.ReplyToMessage?.Id ?? 0, replyMarkup, cancellationToken); }
/// <summary> /// Sends an audio file to be displayed as a playable voice message on Telegram clients. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="filePath">Fully qualified path to the audio file.</param> /// <param name="caption"></param> /// <param name="duration">Duration of sent audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendAudioFromFileAsync([NotNull] string chatId, [NotNull] string filePath, string caption = null, int duration = 0, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(filePath, nameof(filePath)); Contracts.EnsureFileExists(filePath); var fileName = Path.GetFileName(filePath); var fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read); return(this.SendAudioAsync(chatId, fileStream, fileName, caption, duration, performer, title, disableNotification, replyToMessageId, replyMarkup, cancellationToken)); }
/// <summary>Send information about a venue.</summary> /// <param name="chatId">Unique identifier for the target chat.</param> /// <param name="latitude">Latitude of the venue.</param> /// <param name="longitude">Longitude of the venue.</param> /// <param name="title">Name of the venue.</param> /// <param name="address">Address of the venue.</param> /// <param name="forsquareId">Foursquare identifier of the venue.</param> /// <param name="disableNotification"> /// If set to <c>true</c> sends the message silently. iOS users will not receive a notification, /// Android users will receive a notification with no sound. /// </param> /// <param name="replyToMessageId"> /// If the message is a reply, ID of the original message. /// </param> /// <param name="replyMarkup"> /// Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user. /// </param> /// <param name="cancellationToken"> /// A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for the task to /// complete. /// </param> /// <returns> /// A task that represents the asynchronous operation. The task results contains sent /// <see cref="Message" /> on success. /// </returns> public Task<Message> SendVenueAsync(long chatId, float latitude, float longitude, [NotNull] string title, [NotNull] string address, string forsquareId = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendVenueAsync(chatId.ToString(), latitude, longitude, title, address, forsquareId, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="audioStream">A <see cref="Stream" /> to the audio file to send.</param> /// <param name="caption">Audio caption, 0-200 characters</param> /// <param name="fileName">A name for the file to be sent using <paramref name="audioStream" />.</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendAudioAsync(long chatId, [NotNull] Stream audioStream, string caption, string fileName, int duration, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return(this.SendAudioAsync(chatId.ToString(), audioStream, caption, fileName, duration, performer, title, disableNotification, replyToMessageId, replyMarkup, cancellationToken)); }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="audioStream">A <see cref="Stream" /> to the audio file to send.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="audioStream" />.</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendAudioAsync(long chatId, [NotNull] Stream audioStream, string fileName, int duration, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendAudioAsync(chatId.ToString(), audioStream, fileName, duration, performer, title, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a point on the map. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="latitude">Latitude of location</param> /// <param name="longitude">Longitude of location</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task <Message> SendLocationAsync([NotNull] string chatId, double latitude, double longitude, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); var parameters = new NameValueCollection { { "latitude", latitude.ToString(CultureInfo.InvariantCulture) }, { "longitude", longitude.ToString(CultureInfo.InvariantCulture) } }; return(this.CallTelegramMethodAsync <Message>(cancellationToken, "sendLocation", parameters, chatId, replyToMessageId, replyMarkup, disableNotification)); }
/// <summary> /// Sends an audio file to be displayed as a playable voice message on Telegram clients. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="filePath">Fully qualified path to the audio file.</param> /// <param name="duration">Duration of sent audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendAudioFromFileAsync(long chatId, [NotNull] string filePath, int duration = 0, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { return this.SendAudioFromFileAsync(chatId.ToString(), filePath, duration, performer, title, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Sends a video file. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="videoStream">A <see cref="Stream" /> to the video file to send.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="videoStream" />.</param> /// <param name="duration">Duration of sent video in seconds.</param> /// <param name="caption">Video caption.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> /// <remarks> /// Telegram clients support mp4 videos (other formats may be sent as <see cref="Document" />). Bots /// can currently send video files of up to 50 MB in size, this limit may be changed in the future. /// </remarks> public Task<Message> SendVideoAsync([NotNull] string chatId, [NotNull] Stream videoStream, string fileName, int duration = 0, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(videoStream, nameof(videoStream)); var content = new MultipartFormDataContent { { new StreamContent(videoStream), "video", fileName } }; if( duration > 0 ) content.Add("duration", duration); if( caption != null ) content.Add("caption", caption); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendVideo", content, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends an audio file. If you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. /// </summary> /// <param name="chatId">Unique identifier for the message recipient or username of the target channel (in the format /// @channelusername).</param> /// <param name="audioStream">A <see cref="Stream" /> to the audio file to send.</param> /// <param name="fileName">A name for the file to be sent using <paramref name="audioStream" />.</param> /// <param name="duration">Duration of the audio in seconds.</param> /// <param name="performer">The performer of the audio.</param> /// <param name="title">The track name.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Message" />. /// </returns> public Task<Message> SendAudioAsync([NotNull] string chatId, [NotNull] Stream audioStream, string fileName, int duration, string performer = null, string title = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotNull(chatId, nameof(chatId)); Contracts.EnsureNotNull(audioStream, nameof(audioStream)); // ReSharper disable once UseObjectOrCollectionInitializer var content = new MultipartFormDataContent(); content.Add("audio", audioStream, fileName); content.AddIf(duration > 0, "duration", duration); content.AddIf(!string.IsNullOrWhiteSpace(performer), "performer", performer); content.AddIf(!string.IsNullOrWhiteSpace(title), "title", title); return this.CallTelegramMethodAsync<Message>(cancellationToken, "sendAudio", content, chatId, replyToMessageId, replyMarkup, disableNotification); }
/// <summary> /// Sends a video file. /// </summary> /// <param name="chatId">Unique identifier for the message recipient.</param> /// <param name="videoId">A file id as string to resend a video that is already on the Telegram servers.</param> /// <param name="duration">Duration of sent video in seconds.</param> /// <param name="caption">Video caption.</param> /// <param name="disableNotification">If set to <c>true</c> sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.</param> /// <param name="replyToMessageId">If the message is a reply, ID of the original message.</param> /// <param name="replyMarkup">Additional interface options. An <see cref="Types.IReply" /> object for a custom reply keyboard, /// instructions to hide keyboard or to force a reply from the user.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of /// cancellation.</param> /// <returns> /// On success, returns the sent <see cref="Types.Message" />. /// </returns> /// <remarks> /// Telegram clients support mp4 videos (other formats may be sent as <see cref="Types.Document" />). Bots /// can currently send video files of up to 50 MB in size, this limit may be changed in the future. /// </remarks> public Task<Message> SendVideoAsync(long chatId, [NotNull] string videoId, int duration = 0, string caption = null, bool disableNotification = false, long replyToMessageId = 0, IReply replyMarkup = null, CancellationToken cancellationToken = default(CancellationToken)) { Contracts.EnsureNotZero(chatId, nameof(chatId)); return this.SendVideoAsync(chatId.ToString(), videoId, duration, caption, disableNotification, replyToMessageId, replyMarkup, cancellationToken); }
/// <summary> /// Instantiate this classed (and its variables) based on the values of another IReply /// </summary> /// <param name="reply"></param> public MessageReply(IReply reply) { StructuredResponse = reply.StructuredResponse; _Name = reply.Name; _Value = reply.Value; _Type = reply.ElementType; _ErrCode = reply.ErrCode; _ErrMsg = reply.ErrMsg; //_Contacts = reply.Contacts; }