Exemple #1
0
        public async Task <IUpdates> SendUploadedDocument(

            IInputPeer peer,
            IInputFile file,
            string caption,
            string mimeType,
            TVector <IDocumentAttribute> attributes)
        {
            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
            }).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IUpdates> SendUploadedDocumentAsync(IInputPeer peer,
                                                               IInputFile document,
                                                               string mimeType,
                                                               IReadOnlyList <IDocumentAttribute> attributes,
                                                               string message,
                                                               [AllowNull] IInputFile thumb        = null,
                                                               CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var request = new RequestSendMedia
            {
                RandomId   = Random.NextLong(),
                Background = false,
                ClearDraft = false,
                Message    = message,
                Media      = new TInputMediaUploadedDocument
                {
                    File       = document,
                    MimeType   = mimeType,
                    Thumb      = thumb,
                    Attributes = new TVector <IDocumentAttribute>(attributes.ToArray())
                },
                Peer = peer
            };

            return(await RequestSender.SendRequestAsync(request, cancellationToken).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <bool> SendTypingAsync(IInputPeer peer, CancellationToken cancellationToken = default(CancellationToken))
        {
            var req = new RequestSetTyping
            {
                Action = new TSendMessageTypingAction(),
                Peer   = peer
            };

            return(await RequestSender.SendRequestAsync(req, cancellationToken).ConfigureAwait(false));
        }
Exemple #4
0
        public async Task <bool> SendTypingAsync(IInputPeer peer)
        {
            var req = new RequestSetTyping
            {
                Action = new TSendMessageTypingAction(),
                Peer   = peer
            };

            return(await SenderService.SendRequestAsync(req).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IAffectedMessages> ReadHistoryAsync(IInputPeer peer, int maxId, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var readHistory = new RequestReadHistory
            {
                Peer  = peer,
                MaxId = maxId
            };

            return(await RequestSender.SendRequestAsync(readHistory, cancellationToken).ConfigureAwait(false));
        }
Exemple #6
0
        /// <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)
        {
            EnsureUserAuthorized();

            var readHistory = new RequestReadHistory
            {
                Peer  = peer,
                MaxId = maxId
            };

            return(await SenderService.SendRequestAsync(readHistory).ConfigureAwait(false));
        }
Exemple #7
0
        /// <summary>
        /// Send text message to peer
        /// </summary>
        /// <returns>
        /// Object contains list of updates.
        /// </returns>
        public async Task <IUpdates> SendMessageAsync(IInputPeer peer, string message)
        {
            EnsureUserAuthorized();

            return(await SenderService.SendRequestAsync(
                       new RequestSendMessage
            {
                Peer = peer,
                Message = message,
                RandomId = TlHelpers.GenerateRandomLong()
            }).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IAffectedHistory> DeleteHistoryAsync(IInputPeer peer, int maxId, bool justClear, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var deleteHistory = new RequestDeleteHistory
            {
                Peer      = peer,
                JustClear = justClear,
                MaxId     = maxId
            };

            return(await RequestSender.SendRequestAsync(deleteHistory, cancellationToken).ConfigureAwait(false));
        }
Exemple #9
0
        /// <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));
        }
Exemple #10
0
        /// <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)
        {
            EnsureUserAuthorized();

            var forwardMessage = new RequestForwardMessage
            {
                Peer     = peer,
                Id       = messageId,
                RandomId = TlHelpers.GenerateRandomLong()
            };

            return(await SenderService.SendRequestAsync(forwardMessage).ConfigureAwait(false));
        }
Exemple #11
0
        /// <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));
        }
Exemple #12
0
        /// <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)
        {
            EnsureUserAuthorized();

            var deleteHistory = new RequestDeleteHistory
            {
                Peer      = peer,
                JustClear = justClear,
                MaxId     = maxId
            };

            return(await SenderService.SendRequestAsync(deleteHistory).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IUpdates> SendMessageAsync(IInputPeer peer, string message, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            return(await RequestSender.SendRequestAsync(
                       new RequestSendMessage
            {
                Peer = peer,
                Message = message,
                RandomId = Random.NextLong()
            },
                       cancellationToken).ConfigureAwait(false));
        }
Exemple #14
0
        public async Task <IMessages> GetHistoryAsync(IInputPeer peer, int offset, int maxId, int limit)
        {
            EnsureUserAuthorized();

            var req = new RequestGetHistory
            {
                Peer      = peer,
                AddOffset = offset,
                MaxId     = maxId,
                Limit     = limit
            };

            return(await SenderService.SendRequestAsync(req).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IMessages> GetHistoryAsync(IInputPeer peer, int offset, int maxId, int limit, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var req = new RequestGetHistory
            {
                Peer      = peer,
                AddOffset = offset,
                MaxId     = maxId,
                Limit     = limit
            };

            return(await RequestSender.SendRequestAsync(req, cancellationToken).ConfigureAwait(false));
        }
Exemple #16
0
        /// <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)
        {
            EnsureUserAuthorized();

            var sendMedia = new RequestSendMedia
            {
                RandomId   = TlHelpers.GenerateRandomLong(),
                Peer       = peer,
                Media      = media,
                Background = false,
                ClearDraft = false
            };

            return(await SenderService.SendRequestAsync(sendMedia).ConfigureAwait(false));
        }
Exemple #17
0
        public async Task <IUpdates> SendUploadedPhoto(IInputPeer peer, IInputFile file, string caption)
        {
            EnsureUserAuthorized();

            return(await SenderService.SendRequestAsync(new RequestSendMedia
            {
                RandomId = TlHelpers.GenerateRandomLong(),
                Background = false,
                ClearDraft = false,
                Media = new TInputMediaUploadedPhoto {
                    File = file, Caption = caption
                },
                Peer = peer
            }).ConfigureAwait(false));
        }
        /// <inheritdoc />
        public async Task <IUpdates> SendMediaAsync(IInputPeer peer, IInputMedia media, string message, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var sendMedia = new RequestSendMedia
            {
                RandomId   = Random.NextLong(),
                Peer       = peer,
                Media      = media,
                Message    = message,
                Background = false,
                ClearDraft = false
            };

            return(await RequestSender.SendRequestAsync(sendMedia, cancellationToken).ConfigureAwait(false));
        }
Exemple #19
0
        /// <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)
        {
            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));
        }
        /// <inheritdoc />
        public async Task <IUpdates> SendUploadedPhotoAsync(IInputPeer peer, IInputFile photo, string message, CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var request = new RequestSendMedia
            {
                RandomId   = Random.NextLong(),
                Background = false,
                ClearDraft = false,
                Message    = message,
                Media      = new TInputMediaUploadedPhoto
                {
                    File = photo,
                },
                Peer = peer
            };

            return(await RequestSender.SendRequestAsync(request, cancellationToken).ConfigureAwait(false));
        }
Exemple #21
0
        public async Task ForPeer(int id, PeerType peerType, string userId, int offset, int maxId)
        {
            IInputPeer peer   = GetPeer(id, peerType);
            IClientApi client = await _telegramService.BuildAsync(userId);

            IMessages history = await TelegramRequest.HandleAsync(() =>
            {
                return(client.MessagesService.GetHistoryAsync(peer, offset, maxId, 100));
            });

            List <Message> messages = MessagesParser.Parse(history, id, peerType);
            await _eventHub.SendAsync(messages);

            if (messages.Count > 0)
            {
                BackgroundJob.Schedule <GetMessages>(
                    job => job.ForPeer(id, peerType, userId, offset + 100, 0),
                    TimeSpan.FromSeconds(_randomService.Random.Next(5, 20)));
            }
        }
        /// <inheritdoc />
        public async Task <IUpdates> ForwardMessagesAsync(IInputPeer fromPeer,
                                                          IInputPeer toPeer,
                                                          IReadOnlyList <int> ids,
                                                          bool silent,
                                                          bool withMyScore,
                                                          CancellationToken cancellationToken = default(CancellationToken))
        {
            ClientSettings.EnsureUserAuthorized();

            var forwardMessages = new RequestForwardMessages
            {
                FromPeer    = fromPeer,
                ToPeer      = toPeer,
                Id          = new TVector <int>(ids.ToArray()),
                Background  = false,
                Silent      = silent,
                WithMyScore = withMyScore,
                RandomId    = new TVector <long>(Random.NextLong())
            };

            return(await RequestSender.SendRequestAsync(forwardMessages, cancellationToken));
        }