public async Task <IUpdates> SendUploadedDocument( IInputPeer peer, IInputFile file, string caption, string mimeType, TVector <IDocumentAttribute> attributes, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); return(await SenderService.SendRequestAsync( new RequestSendMedia { RandomId = TlHelpers.GenerateRandomLong(), Background = false, ClearDraft = false, Media = new TInputMediaUploadedDocument { File = file, Caption = caption, MimeType = mimeType, Attributes = attributes }, Peer = peer }, cancellationToken).ConfigureAwait(false)); }
/// <summary>Returns full chat info according to its ID.</summary> /// <param name="chatId">Chat's identifier</param> /// <returns>Object contains extended info on chat with auxiliary data.</returns> public async Task <IChatFull> GetFullChatAsync(int chatId, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestGetFullChat { ChatId = chatId }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
public async Task <IContacts> GetContactsAsync(CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var req = new RequestGetContacts { Hash = 0 }; return(await SenderService.SendRequestAsync(req, cancellationToken).ConfigureAwait(false)); }
/// <summary>Returns chat basic info on their IDs.</summary> /// <param name="ids">Identifiers of chats</param> /// <returns>Object contains list of chats with auxiliary data.</returns> public async Task <IChats> GetChatsAsync(TVector <int> ids, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestGetChats { Id = ids }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
/// <summary>Confirms receipt of messages by a client, cancels PUSH-notification sending.</summary> /// <param name="maxId">Maximum message ID available in a client.</param> /// <returns>The method returns the list of message IDs, for which PUSH-notifications were cancelled.</returns> /// TODO: interface? public async Task <TVector <TReceivedNotifyMessage> > ReceivedMessagesAsync(int maxId, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var receivedMessages = new RequestReceivedMessages { MaxId = maxId }; return(await SenderService.SendRequestAsync(receivedMessages, cancellationToken).ConfigureAwait(false)); }
/// <summary>Notifies the sender about the recipient having listened a voice message or watched a video.</summary> /// <param name="ids">Identifiers of messages</param> /// <returns>Returns a <see cref="IAffectedMessages" /> object containing a affected messages</returns> public async Task <IAffectedMessages> ReadMessageContentsAsync(TVector <int> ids, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var readMessageContents = new RequestReadMessageContents { Id = ids }; return(await SenderService.SendRequestAsync(readMessageContents, cancellationToken).ConfigureAwait(false)); }
/// <summary>Marks message history as read.</summary> /// <param name="peer">User or group to receive the message</param> /// <param name="maxId"> /// If a positive value is passed, only messages with identifiers less or equal than the given one will /// be read /// </param> /// <returns>Returns a <see cref="IAffectedMessages" /> object containing a affected messages</returns> public async Task <IAffectedMessages> ReadHistoryAsync(IInputPeer peer, int maxId, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var readHistory = new RequestReadHistory { Peer = peer, MaxId = maxId }; return(await SenderService.SendRequestAsync(readHistory, cancellationToken).ConfigureAwait(false)); }
/// <summary>Deletes a user from a chat and sends a service message on it.</summary> /// <param name="chatId">Chat's identifier</param> /// <param name="user">User ID to be deleted</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during the action.</returns> public async Task <IUpdates> DeleteChatUser(int chatId, IInputUser user, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestDeleteChatUser { ChatId = chatId, UserId = user }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
/// <summary>Chanages chat name and sends a service message on it.</summary> /// <param name="chatId">Chat's identifier</param> /// <param name="title">New chat name, different from the old one</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns> public async Task <IUpdates> EditChatTitle(int chatId, string title, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestEditChatTitle { ChatId = chatId, Title = title }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
/// <summary>Changes chat photo and sends a service message on it.</summary> /// <param name="chatId">Chat's identifier</param> /// <param name="photo">Photo to be set</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns> public async Task <IUpdates> EditChatPhoto(int chatId, IInputChatPhoto photo, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestEditChatPhoto { ChatId = chatId, Photo = photo }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
/// <summary>Deletes messages by their IDs.</summary> /// <param name="ids">Identifiers of messages</param> /// <param name="revoke">Delete messages for everyone</param> /// <returns>Returns a <see cref="IAffectedMessages" /> object containing a affected messages</returns> public async Task <IAffectedMessages> DeleteMessagesAsync(TVector <int> ids, bool revoke, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var deleteMessages = new RequestDeleteMessages { Id = ids, Revoke = revoke }; return(await SenderService.SendRequestAsync(deleteMessages, cancellationToken).ConfigureAwait(false)); }
/// <summary>Serch user or chat.</summary> /// <param name="q">User or chat name</param> /// <param name="limit">Max result count</param> /// <param name="cancellationToken">A cancellation token</param> /// <returns></returns> public async Task <IFound> SearchUserAsync(string q, int limit = 10, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var r = new RequestSearch { Q = q, Limit = limit }; return(await SenderService.SendRequestAsync(r, cancellationToken).ConfigureAwait(false)); }
/// <summary>Creates a new chat.</summary> /// <param name="title">Chat name</param> /// <param name="users">List of user IDs to be invited</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns> public async Task <IUpdates> CreateChatAsync(string title, TVector <IInputUser> users, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var request = new RequestCreateChat { Title = title, Users = users }; return(await SenderService.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)); }
public async Task <IDialogs> GetUserDialogsAsync(int limit = 100, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var getDialogs = new RequestGetDialogs { OffsetDate = 0, OffsetPeer = new TInputPeerSelf(), Limit = limit }; return(await SenderService.SendRequestAsync(getDialogs, cancellationToken).ConfigureAwait(false)); }
public async Task <IDifference> GetUpdates(IState currentState, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var getDiffRequest = new RequestGetDifference { Pts = currentState.Pts, Qts = currentState.Qts, Date = currentState.Date }; return(await SenderService.SendRequestAsync(getDiffRequest, cancellationToken).ConfigureAwait(false)); }
/// <summary>Forwards single messages.</summary> /// <param name="peer">User or chat where a message will be forwarded</param> /// <param name="messageId">Forwarded message ID</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns> public async Task <IUpdates> ForwardMessageAsync(IInputPeer peer, int messageId, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var forwardMessage = new RequestForwardMessage { Peer = peer, Id = messageId, RandomId = TlHelpers.GenerateRandomLong() }; return(await SenderService.SendRequestAsync(forwardMessage, cancellationToken).ConfigureAwait(false)); }
/// <summary>Send text message to peer</summary> /// <returns>Object contains list of updates.</returns> public async Task <IUpdates> SendMessageAsync(IInputPeer peer, string message, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); return(await SenderService.SendRequestAsync( new RequestSendMessage { Peer = peer, Message = message, RandomId = TlHelpers.GenerateRandomLong() }, cancellationToken).ConfigureAwait(false)); }
/// <summary>Deletes communication history.</summary> /// <param name="peer">User or chat, communication history of which will be deleted</param> /// <param name="maxId"> /// If a positive value was transferred, the method will return only messages with IDs less than the /// set one /// </param> /// <param name="justClear">Delete as non-recoverable or just clear the history</param> /// <returns>Returns a <see cref="IAffectedHistory" /> object containing a affected history</returns> public async Task <IAffectedHistory> DeleteHistoryAsync(IInputPeer peer, int maxId, bool justClear, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var deleteHistory = new RequestDeleteHistory { Peer = peer, JustClear = justClear, MaxId = maxId }; return(await SenderService.SendRequestAsync(deleteHistory, cancellationToken).ConfigureAwait(false)); }
public async Task <IMessages> GetHistoryAsync(IInputPeer peer, int offset, int maxId, int limit, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var req = new RequestGetHistory { Peer = peer, AddOffset = offset, MaxId = maxId, Limit = limit }; return(await SenderService.SendRequestAsync(req, cancellationToken).ConfigureAwait(false)); }
/// <summary>Sends a non-text message.</summary> /// <param name="peer">User or group to receive the message</param> /// <param name="media">Message contents</param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during the action.</returns> public async Task <IUpdates> SendMediaAsync(IInputPeer peer, IInputMedia media, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var sendMedia = new RequestSendMedia { RandomId = TlHelpers.GenerateRandomLong(), Peer = peer, Media = media, Background = false, ClearDraft = false }; return(await SenderService.SendRequestAsync(sendMedia, cancellationToken).ConfigureAwait(false)); }
/// <summary>Forwards messages by their IDs.</summary> /// <param name="fromPeer">User or chat from where a message will be forwarded</param> /// <param name="toPeer">User or chat where a message will be forwarded</param> /// <param name="ids">Forwarded message IDs</param> /// <param name="silent"></param> /// <param name="withMyScore"></param> /// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns> public async Task <IUpdates> ForwardMessagesAsync(IInputPeer fromPeer, IInputPeer toPeer, TVector <int> ids, bool silent, bool withMyScore, CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); var forwardMessages = new RequestForwardMessages { FromPeer = fromPeer, ToPeer = toPeer, Id = ids, Background = false, Silent = silent, WithMyScore = withMyScore, RandomId = TlHelpers.GenerateRandomTVectorLong(ids.Items.Count) }; return(await SenderService.SendRequestAsync(forwardMessages, cancellationToken)); }
public async Task <IState> GetCurrentState(CancellationToken cancellationToken = default(CancellationToken)) { AuthApiService.EnsureUserAuthorized(); return(await SenderService.SendRequestAsync(new RequestGetState(), cancellationToken).ConfigureAwait(false)); }