public GetHistoryRequest(InputPeer peer, int offset, int max_id, int limit) { _peer = peer; _offset = offset; _max_id = max_id; _limit = limit; }
static async Task <IReadOnlyList <Document.DefaultTag> > ScrapeHistoryDocuments( TelegramClient tg, InputPeer peer, int offset = 0 ) { const int batchLimit = 100; var resp = await tg.Call(new GetHistory( peer : peer, addOffset : offset, limit : batchLimit, minId : 0, maxId : 0, hash : 0, offsetDate : 0, offsetId : 0 )); var messages = resp.Slice !.Messages; var documents = messages .Reverse() .NChoose(x => x.Default) .NChoose(message => message.Media) .NChoose(x => x.Document) .NChoose(x => x.Document) .NChoose(x => x.Default); return(messages.Count == 0 ? documents.ToList() : (await ScrapeHistoryDocuments(tg, peer, offset + batchLimit)).Concat(documents).ToList()); }
public MarkHistoryAsReadRequest(InputPeer peer, int offset, int maxId, bool readContents) { this.peer = peer; this.offset = offset; this.maxId = maxId; this.readContents = readContents; }
public SendMessageRequest(InputPeer peer, string message) { this.peer = peer; this.message = message; randomId = Helpers.GenerateRandomLong(); }
public SendMediaRequest(InputPeer inputPeer, InputMedia inputMedia) { this.inputPeer = inputPeer; this.inputMedia = inputMedia; randomId = Helpers.GenerateRandomLong(); }
public static async Task Run(TelegramClient tg) { var chatsType = await tg.Messages.GetDialogs(); var chats = chatsType.Default !; var channels = chats.Chats.NChoose(x => x.Channel); var firstChannel = channels.FirstOrDefault() ?? throw new Exception("A channel is not found."); var photo = firstChannel.Photo .Default ?? throw new Exception("The first channel does not have a photo."); var photoLoc = new InputFileLocation.PeerPhotoTag( peer: new InputPeer.ChannelTag(firstChannel.Id, firstChannel.AccessHash !.Value), big: true, photoId: photo.PhotoId ); var fileType = await tg.Upload.GetFileType(photoLoc); var fileTypeExt = fileType.Match( pngTag: _ => ".png", jpegTag: _ => ".jpeg", _: () => throw new NotImplementedException() ); await using var fs = File.OpenWrite($"channel-photo{fileTypeExt}"); await tg.Upload.DownloadFile(fs, photoLoc); }
public GetHistoryRequest(InputPeer peer, int offset, int maxId, int limit) { this.peer = peer; this.offset = offset; this.maxId = maxId; this.limit = limit; }
public override async Task RemoveAndClearDialog() { try { await ClearDialogHistory(); if (dialog.peer.Constructor == Constructor.peerChat) { InputPeer peer = InputPeer; InputPeerChatConstructor peerChat = (InputPeerChatConstructor)peer; InputUser user = TL.inputUserSelf(); messages_StatedMessage message = await session.Api.messages_deleteChatUser(peerChat.chat_id, user); switch (message.Constructor) { case Constructor.messages_statedMessage: session.Updates.processUpdatePtsSeq(((Messages_statedMessageConstructor)message).pts, ((Messages_statedMessageConstructor)message).seq); break; case Constructor.messages_statedMessageLink: session.Updates.processUpdatePtsSeq(((Messages_statedMessageLinkConstructor)message).pts, ((Messages_statedMessageLinkConstructor)message).seq); break; } } session.Dialogs.Model.Dialogs.Remove(this); } catch (Exception ex) { logger.error("exception: {0}", ex); } }
// messages.sendMessage#4cde0aab peer:InputPeer message:string random_id:long = messages.SentMessage; public async Task <SentMessage> SendMessage(InputPeer inputPeer, string message) { var request = new SendMessageRequest(inputPeer, message); await SendRpcRequest(request); return(request.sentMessage); }
// messages.receivedMessages#28abcb68 max_id:int = Vector<int>; // messages.setTyping#a3825e50 peer:InputPeer action:SendMessageAction = Bool; public async Task <bool> SetTyping(InputPeer inputPeer, SendMessageAction action) { var request = new SetTypingRequest(inputPeer, action); await SendRpcRequest(request); return(request.state); }
// messages.sendMedia#a3c85d76 peer:InputPeer media:InputMedia random_id:long = messages.StatedMessage; public async Task <MessagesStatedMessage> SendMediaMessage(InputPeer inputPeer, InputMedia media) { var request = new SendMediaRequest(inputPeer, media); await SendRpcRequest(request); return(request.statedMessage); }
// messages.getHistory#92a1df2f peer:InputPeer offset:int max_id:int limit:int = messages.Messages; public async Task <MessagesMessages> GetHistory(InputPeer inputPeer, int offset, int limit, int maxId = -1) { var request = new GetHistoryRequest(inputPeer, offset, maxId, limit); await SendRpcRequest(request); return(request.messages); }
public async Task <messages_StatedMessage> SendMediaMessage(InputPeer inputPeer, InputMedia inputMedia) { var request = new Message_SendMediaRequest(inputPeer, inputMedia); await _sender.Send(request); await _sender.Recieve(request); return(request.StatedMessage); }
private async Task DoSendContact(UserModel user) { if (!(dialogToReturn is DialogModelPlain)) { return; } InputPeer ip = dialogToReturn.InputPeer; InputMedia media = TL.inputMediaContact(user.PhoneNumber, user.FirstName, user.LastName); DialogModelPlain dialog = (DialogModelPlain)dialogToReturn; await dialog.SendMedia(media); }
/// <summary> /// Gets message history for a chat. /// </summary> /// <param name="contact">User</param> /// <param name="offset">Number of list elements to be skipped. As of Layer 15 this value is added to the one that was calculated from max_id. Negative values are also accepted.</param> /// <param name="maxId">If a positive value was transferred, the method will return only messages with IDs less than max_id</param> /// <returns>Returns message history for a chat..</returns> public async Task <Models.History> GetHistoryAsync(Models.Contact contact) { await ConnectAsync(); int limit = 30; Models.History history = new Models.History { Messages = new List <Models.Message>(), }; InputPeer peer = null; if (contact.IsForeign) { peer = new InputPeerForeignConstructor(contact.Id, contact.AccessHash); } else { peer = new InputPeerContactConstructor(contact.Id); } MessagesMessages result = await _client.GetHistory(peer, 0, limit); if (result is MessagesMessagesConstructor messagesMessagesConstructor) { history.Messages.AddRange(messagesMessagesConstructor.messages.Select(m => (Models.Message)m).Where(m => m != null)); history.AddChats(messagesMessagesConstructor.chats.Select(c => (Models.Chat)c).Where(c => c != null)); history.AddContacts(messagesMessagesConstructor.users.Select(u => (Models.Contact)u).Where(u => u != null)); } else if (result is MessagesMessagesSliceConstructor messagesMessagesSliceConstructor) { int count = messagesMessagesSliceConstructor.count; int total = 0; do { total += limit; history.Messages.AddRange(messagesMessagesSliceConstructor.messages.Select(m => (Models.Message)m).Where(m => m != null)); history.AddChats(messagesMessagesSliceConstructor.chats.Select(c => (Models.Chat)c).Where(c => c != null)); history.AddContacts(messagesMessagesSliceConstructor.users.Select(u => (Models.Contact)u).Where(u => u != null)); if (total > count) { break; } result = await _client.GetHistory(peer, total, limit); messagesMessagesSliceConstructor = (MessagesMessagesSliceConstructor)result; } while (true); } return(history); }
private async Task DoForwardMessages(InputPeer peer) { if (messageId.Count == 1) { messages_StatedMessage msg = await TelegramSession.Instance.Api.messages_forwardMessage(peer, messageId.First(), Helpers.GenerateRandomLong()); TelegramSession.Instance.Updates.Process(msg); } else { messages_StatedMessages msgs = await TelegramSession.Instance.Api.messages_forwardMessages(peer, messageId); TelegramSession.Instance.Updates.Process(msgs); } }
public async Task <bool> SetCancelAllActionAsync(Models.Contact contact) { await ConnectAsync(); InputPeer peer = null; if (contact.IsForeign) { peer = new InputPeerForeignConstructor(contact.Id, contact.AccessHash); } else { peer = new InputPeerContactConstructor(contact.Id); } return(await _client.SetTyping(peer, SendMessageAction.CancelAction)); }
/// <summary> /// Marks message history as read. /// </summary> /// <param name="contact">Target user</param> /// <param name="offset">Value from (messages.affectedHistory) or 0</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>Object contains info on affected part of communication history with the user or in a chat.</returns> public async Task <MessagesAffectedHistory> MarkedMessagesAsReadAsync(Models.Contact contact, int offset, int maxId = -1) { InputPeer peer = null; if (contact.IsForeign) { peer = new InputPeerForeignConstructor(contact.Id, contact.AccessHash); } else { peer = new InputPeerContactConstructor(contact.Id); } await ConnectAsync(); return(await _client.ReadHistory(peer, offset, maxId)); }
static async Task <MessageMedia> UploadPhoto( TelegramClient tg, string photoName, byte[] bytes, InputPeer peer ) { var photo = await tg.Upload.UploadFile( name : photoName, fileLength : bytes.Length, stream : new MemoryStream(buffer: bytes) ); return(await tg.Messages.UploadMediaAsPhoto( peer : peer, file : photo )); }
static async Task <MessageMedia> UploadVideo( TelegramClient tg, string videoName, byte[] bytes, InputPeer peer, string mimeType ) { var video = await tg.Upload.UploadFile( name : videoName, fileLength : bytes.Length, stream : new MemoryStream(buffer: bytes) ); return(await tg.Messages.UploadMediaAsDocument( peer : peer, file : video, mimeType : mimeType )); }
public SendMessageRequest(InputPeer peer, string message) { _peer = peer; _message = message; }
public InputNotifyPeerConstructor(InputPeer peer) { this.peer = peer; }
public override void Read(BinaryReader reader) { this.peer = Tl.Parse <InputPeer>(reader); }
private void OnDialogSelected(object sender, DialogModel model) { InputPeer inputPeer = null; if (!(model is DialogModelPlain)) { return; } DialogModelPlain dmp = (DialogModelPlain)model; if (fromMedia == 1) { MessageMedia media = MediaTransitionHelper.Instance.Media; InputMedia im = null; if (media.Constructor == Constructor.messageMediaPhoto) { MessageMediaPhotoConstructor mmpc = (MessageMediaPhotoConstructor)media; InputPhoto ip = TL.inputPhoto(((PhotoConstructor)mmpc.photo).id, ((PhotoConstructor)mmpc.photo).access_hash); im = TL.inputMediaPhoto(ip); } else if (media.Constructor == Constructor.messageMediaVideo) { MessageMediaVideoConstructor mmvc = (MessageMediaVideoConstructor)media; InputVideo iv = TL.inputVideo(((VideoConstructor)mmvc.video).id, ((VideoConstructor)mmvc.video).access_hash); im = TL.inputMediaVideo(iv); } else if (media.Constructor == Constructor.messageMediaGeo) { MessageMediaGeoConstructor mmgc = (MessageMediaGeoConstructor)media; GeoPointConstructor gpc = (GeoPointConstructor)mmgc.geo; InputGeoPoint point = TL.inputGeoPoint(gpc.lat, gpc.lng); im = TL.inputMediaGeoPoint(point); } if (im != null) { dmp.SendMedia(im); NavigationService.GoBack(); } return; } if (messageId.Count == 0) { logger.error("error forwarding, no messageId"); } Peer peer = model.Peer; if (model.IsChat) { inputPeer = TL.inputPeerChat(((PeerChatConstructor)peer).chat_id); } else { inputPeer = TL.inputPeerContact(((PeerUserConstructor)peer).user_id); } DoForwardMessages(inputPeer); int modelId = TelegramSession.Instance.Dialogs.Model.Dialogs.IndexOf(model); NavigationService.Navigate(new Uri("/UI/Pages/DialogPage.xaml?modelId=" + modelId, UriKind.Relative)); }
public Message_SendMediaRequest(InputPeer inputPeer, InputMedia inputMedia) { this.inputPeer = inputPeer; this.inputMedia = inputMedia; }
public SetTypingRequest(InputPeer peer, SendMessageAction action) { this.peer = peer; this.action = action; }
public async Task<messages_StatedMessage> SendMediaMessage(InputPeer inputPeer, InputMedia inputMedia) { var request = new Message_SendMediaRequest(inputPeer, inputMedia); await _sender.Send(request); await _sender.Recieve(request); return request.StatedMessage; }