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 GetHistoryRequest(InputPeer peer, int offset, int max_id, int limit)
{
_peer = peer;
_offset = offset;
_max_id = max_id;
_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;
}
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 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 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;
}
