public async Task UnRead2()
{
var rnd = new Random();
while (true)
{
Task.Delay(rnd.Next(3000, 6000)).Wait();
var dialogs = telegramClient.GetUserDialogsAsync().Result as TLDialogs;
if (dialogs == null)
{
Task.Delay(rnd.Next(3000, 6000)).Wait();
continue;
}
foreach (TLDialog dialog in dialogs.Dialogs.Where(lambdaDialog => lambdaDialog.Peer is TLPeerChannel && lambdaDialog.UnreadCount > 0))
{
TLPeerChannel peer = (TLPeerChannel)dialog.Peer;
TLChannel channel = dialogs.Chats.OfType <TLChannel>().First(lambdaChannel => lambdaChannel.Id == peer.ChannelId);
TLInputPeerChannel target = new TLInputPeerChannel {
ChannelId = channel.Id, AccessHash = channel.AccessHash ?? 0
};
Task.Delay(rnd.Next(3000, 6000)).Wait();
TLChannelMessages hist = (TLChannelMessages)telegramClient.GetHistoryAsync(target, 0, -1, dialog.UnreadCount).Result;
if (hist == null)
{
continue;
}
var users = hist.Users.OfType <TLUser>().ToList();
var messages = hist.Messages.OfType <TLMessage>().ToList();
foreach (TLMessage message in messages)
{
TLUser sentUser = users.Single(lambdaUser => lambdaUser.Id == message.FromId);
Console.WriteLine($"{channel.Title} {sentUser.FirstName} {sentUser.LastName} {sentUser.Username}: {message.Message}");
}
TLInputChannel channelToMarkRead = new TLInputChannel {
ChannelId = target.ChannelId, AccessHash = target.AccessHash
};
var firstAbsMessage = hist.Messages[0];
int firstUnreadMessageId;
if (firstAbsMessage is TLMessage)
{
firstUnreadMessageId = ((TLMessage)firstAbsMessage).Id;
}
else if (firstAbsMessage is TLMessageService)
{
firstUnreadMessageId = ((TLMessageService)firstAbsMessage).Id;
}
else
{
continue;
}
var markHistoryAsReadRequest = new TLSchema.Channels.TLRequestReadHistory
{
Channel = channelToMarkRead,
MaxId = -1,
ConfirmReceived = true,
Dirty = true,
MessageId = firstUnreadMessageId,
Sequence = dialog.UnreadCount
};
Task.Delay(rnd.Next(3000, 6000)).Wait();
telegramClient.SendRequestAsync <bool>(markHistoryAsReadRequest).Wait();
Console.WriteLine("Mark messages as read");
}
}
}
public static async Task SendImageMessagetochannel(byte[] fileBytes, string filename, string captionText, TLInputPeerChannel channelPeer)
{
var streamReader = new StreamReader(new MemoryStream(fileBytes));
TLAbsInputFile file;
//Uploading photoFile to telegram server
try
{
file = (TLInputFile)await _client.UploadFile(filename, streamReader);
}
catch
{
throw new Exception("err uploading file");
}
//Sending file to channel
try
{
await _client.SendUploadedPhoto(channelPeer, file, captionText);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
//public virtual async Task AuthUser()
//{
// var client = NewClient();
// await client.ConnectAsync();
// var hash = await client.SendCodeRequestAsync(NumberToAuthenticate);
// var code = CodeToAuthenticate; // you can change code in debugger too
// if (String.IsNullOrWhiteSpace(code))
// {
// throw new Exception("CodeToAuthenticate is empty in the app.config file, fill it with the code you just got now by SMS/Telegram");
// }
// TLUser user = null;
// try
// {
// user = await client.MakeAuthAsync(NumberToAuthenticate, hash, code);
// }
// catch (CloudPasswordNeededException ex)
// {
// var passwordSetting = await client.GetPasswordSetting();
// var password = PasswordToAuthenticate;
// user = await client.MakeAuthWithPasswordAsync(passwordSetting, password);
// }
// catch (InvalidPhoneCodeException ex)
// {
// throw new Exception("CodeToAuthenticate is wrong in the app.config file, fill it with the code you just got now by SMS/Telegram",
// ex);
// }
// Assert.IsNotNull(user);
// Assert.IsTrue(client.IsUserAuthorized());
//}
public async Task <string> button3_ClickAsync()
{
try
{
bool stop = true;
int count = 2;
client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
//var hash = await client.SendCodeRequestAsync("+79179037140");
//var code = "72772";
//var user = await client.MakeAuthAsync("+79179037140", hash, code);
// DownloadFileFromWrongLocationTest();
sb.Append("#\tDate\tTime\tMID\tTUID\tText" + Environment.NewLine);
TLDialogsSlice dialogs = (TLDialogsSlice)await client.GetUserDialogsAsync(); //Получаем список чатов(диалогов)
// var tempDialogsChats = dialogs.Chats; // выгружаем полученные список чатов
foreach (var element in dialogs.Chats)
{
if (element is TLChat)
{
TLChat chats = element as TLChat;
listChats += $"Название {chats.Title} ID чата {chats.Id} " + Environment.NewLine;
}
if (element is TLChannel)
{
TLChannel chats = element as TLChannel;
listChats += $"Название {chats.Title} ID чата {chats.Id} " + Environment.NewLine;
}
if (element is TLChatForbidden)
{
TLChatForbidden chats = element as TLChatForbidden;
listChats += $"Название {chats.Title} ID чата {chats.Id} " + Environment.NewLine;
}
//if (chats is TLDialogS)
// continue;
}
SaveTextFile(listChats, "Список чатов.txt");
TLChannel chat = dialogs.Chats.Where(c => c.GetType() == typeof(TLChannel)).Cast <TLChannel>().FirstOrDefault(c => c.Id == VKFID); //Выбираем нужный нам чат
//if (chat == null)
// {
// }
TLInputPeerChannel inputPeer = new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = (long)chat.AccessHash
};
while (stop)
{
if (n > count)
{
stop = false;
}
try
{
TLChannelMessages res = await client.SendRequestAsync <TLChannelMessages> //получаем список все собщений из выбранного чата
(new TLRequestGetHistory()
{
Peer = inputPeer, Limit = 1000, AddOffset = offset, OffsetId = 0
});
var msgs = res.Messages; // выгружаем список сообщений
count = res.Count++;
if (res.Count > offset)
{
offset += msgs.Count;
foreach (TLAbsMessage msg in msgs)
{
if (msg is TLMessage)
{
TLMessage message = msg as TLMessage;
sb.Append(n.ToString() + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("dd'.'MM'.'yyyy") + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("HH':'mm':'ss") + "\t" +
message.Id + "\t" + message.FromId + "\t" + message.Message + Environment.NewLine);
}
if (msg is TLMessageService)
{
continue;
}
n++;
}
SaveTextFile(sb.ToString());
SaveTextFileBuilder(sb);
Thread.Sleep(22000);
//Thread.Sleep(22000); //to avoid TelegramFloodException 36,67 минут https://www.yandex.ru/search/?lr=43&offline_search=1&text=%D0%BA%D0%B0%D0%BB%D1%8C%D0%BA%D1%83%D0%BB%D1%8F%D1%82%D0%BE%D1%80%20%D1%81%D0%B5%D0%BA%D1%83%D0%BD%D0%B4%20%D0%B2%20%D0%BC%D0%B8%D0%BD%D1%83%D1%82%D1%8B
}
else
{
break;
}
}
catch (Exception ex)
{
SaveTextFile("Ошибка +" + ex, @"LogError.txt");
return(ex.Message);
// MessageBox.Show(ex.Message);
// break;
}
finally
{
await Task.Delay(22000); //чтобы обойти TelegramFloodException
SaveTextFile("Завершение работы", "Завершение работы.txt");
}
}
return(listChats);
//MessageBox.Show("Done");
}
catch (Exception ex)
{
SaveTextFile("Ошибка +" + ex, @"LogError.txt");
return(ex.ToString());
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
var data = Toast.GetData(taskInstance);
if (data != null)
{
if (data.ContainsKey("QuickMessage"))
{
var deviceInfoService = new DeviceInfoService();
var eventAggregator = new TelegramEventAggregator();
var cacheService = new InMemoryCacheService(eventAggregator);
var updatesService = new UpdatesService(cacheService, eventAggregator);
var transportService = new TransportService();
var connectionService = new ConnectionService(deviceInfoService);
var statsService = new StatsService();
var manualResetEvent = new ManualResetEvent(false);
var protoService = new MTProtoService(deviceInfoService, updatesService, cacheService, transportService, connectionService, statsService);
protoService.Initialized += (s, args) =>
{
var text = data["QuickMessage"];
var messageText = text.Replace("\r\n", "\n").Replace('\v', '\n').Replace('\r', '\n');
var entitiesBase = Utils.GetEntities(ref messageText);
var replyToMsgId = 0;
var inputPeer = default(TLInputPeerBase);
if (data.ContainsKey("from_id"))
{
inputPeer = new TLInputPeerUser {
UserId = int.Parse(data["from_id"]), AccessHash = long.Parse(data["access_hash"])
};
}
else if (data.ContainsKey("channel_id"))
{
inputPeer = new TLInputPeerChannel {
ChannelId = int.Parse(data["channel_id"]), AccessHash = long.Parse(data["access_hash"])
};
replyToMsgId = data.ContainsKey("msg_id") ? int.Parse(data["msg_id"]) : 0;
}
else if (data.ContainsKey("chat_id"))
{
inputPeer = new TLInputPeerChat {
ChatId = int.Parse(data["chat_id"])
};
replyToMsgId = data.ContainsKey("msg_id") ? int.Parse(data["msg_id"]) : 0;
}
TLVector <TLMessageEntityBase> entities = null;
if (entitiesBase != null)
{
entities = new TLVector <TLMessageEntityBase>(entitiesBase);
}
var obj = new TLMessagesSendMessage {
Peer = inputPeer, ReplyToMsgId = replyToMsgId, Message = messageText, Entities = entities, IsBackground = true, RandomId = TLLong.Random()
};
protoService.SendInformativeMessageInternal <TLUpdatesBase>("messages.sendMessage", obj, result =>
{
manualResetEvent.Set();
},
faultCallback: fault =>
{
// TODO: alert user?
manualResetEvent.Set();
},
fastCallback: () =>
{
manualResetEvent.Set();
});
//var date = TLUtils.DateToUniversalTimeTLInt(protoService.ClientTicksDelta, DateTime.Now);
//var message = TLUtils.GetMessage(SettingsHelper.UserId, inputPeer, TLMessageState.Sending, true, true, date, text, new TLMessageMediaEmpty(), TLLong.Random(), replyToMsgId);
//var history = cacheService.GetHistory(inputPeer, 1);
//cacheService.SyncSendingMessage(message, null, async (m) =>
//{
// await protoService.SendMessageAsync(message, () =>
// {
// // TODO: fast callback
// });
// manualResetEvent.Set();
//});
};
protoService.InitializationFailed += (s, args) =>
{
manualResetEvent.Set();
};
//cacheService.Init();
protoService.Initialize();
manualResetEvent.WaitOne(15000);
}
}
deferral.Complete();
}
public async void LoadFirstSlice()
{
var lastDate = 0;
var lastMsgId = 0;
var lastPeer = (TLInputPeerBase) new TLInputPeerEmpty();
var last = Items.LastOrDefault();
if (last != null && last.TopMessageItem != null)
{
lastDate = last.TopMessageItem.Date;
lastMsgId = last.TopMessage;
if (last.Peer is TLPeerUser)
{
lastPeer = new TLInputPeerUser {
UserId = last.Peer.Id
};
}
else if (last.Peer is TLPeerChat)
{
lastPeer = new TLInputPeerChat {
ChatId = last.Peer.Id
};
}
else if (last.Peer is TLPeerChannel)
{
lastPeer = new TLInputPeerChannel {
ChannelId = last.Peer.Id
};
}
}
//ProtoService.GetDialogsCallback(lastDate, lastMsgId, lastPeer, 200, (result) =>
//{
// var pinnedIndex = 0;
// Execute.BeginOnUIThread(() =>
// {
// foreach (var item in result.Dialogs)
// {
// if (item.IsPinned)
// {
// item.PinnedIndex = pinnedIndex++;
// }
// var chat = item.With as TLChat;
// if (chat != null && chat.HasMigratedTo)
// {
// continue;
// }
// else
// {
// Items.Add(item);
// }
// }
// IsFirstPinned = Items.Any(x => x.IsPinned);
// PinnedDialogsIndex = pinnedIndex;
// PinnedDialogsCountMax = config.PinnedDialogsCountMax;
// });
//});
var response = await ProtoService.GetDialogsAsync(lastDate, lastMsgId, lastPeer, 200);
if (response.IsSucceeded)
{
var config = CacheService.GetConfig();
var pinnedIndex = 0;
var items = new List <TLDialog>(response.Result.Dialogs.Count);
foreach (var item in response.Result.Dialogs)
{
if (item.IsPinned)
{
item.PinnedIndex = pinnedIndex++;
}
if (item.With is TLChat chat && chat.HasMigratedTo)
{
continue;
}
else
{
items.Add(item);
}
}
/// <summary>
/// Получаем все сообщения из текущих чатов
/// </summary>
/// <returns></returns>
public async Task <StringBuilder> GetChatTelegram()
{
//StartText();
try
{
TelegramClient client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
//var hash = await client.SendCodeRequestAsync("+79179037140");
//string stop = "";
//var code = "13643";
//var user = await client.MakeAuthAsync("+79179037140", hash, code);
// var temp = ConfigurationManager.AppSettings[nameof(ApiHash)];
sb.Append("#\tDate\tTime\tMID\tTUID\tText" + Environment.NewLine);
TLDialogsSlice dialogs = (TLDialogsSlice)await client.GetUserDialogsAsync(); // Получение списка чатов
//var chat123 = dialogs.Chats.Where(c => c.GetType() == typeof(TLChannel)).ToList();
//foreach (TeleSharp.TL.TLChannel myChat in chat123)
//{
// sb.Append("***************" + Environment.NewLine +
// "Id чата"+ myChat.Id + "\t" +
// "Название чата"+ myChat.Title + "\t" +
// "Хешш чата" +myChat.AccessHash + "\t" +
// "***************" + Environment.NewLine);
//}
//SaveTextFileBuilder(sb, "Messages.txt");
// Получаем ВЫБРАНЫЙ ЧАТ ПО ID
TLChannel chat = dialogs.Chats.Where(c => c.GetType() == typeof(TLChannel)).Cast <TLChannel>().FirstOrDefault(c => c.Id == VKFID);
// TLChannel channel = dialogs.Dialogs.
TLInputPeerChannel inputPeer = new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = (long)chat.AccessHash
};
while (countMessa != 100)
{
try
{
TLChannelMessages res = await client.SendRequestAsync <TLChannelMessages>
(new TLRequestGetHistory()
{
Peer = inputPeer, Limit = 1000, AddOffset = offset, OffsetId = 0
});
var msgs = res.Messages;
allCountMess = res.Count;
if (res.Count > offset)
{
offset += msgs.Count;
foreach (TLAbsMessage msg in msgs)
{
if (msg is TLMessage)
{
TLMessage message = msg as TLMessage;
sb.Append("***************" + Environment.NewLine +
n.ToString() + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("dd'.'MM'.'yyyy") + "\t" +
//ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("HH':'mm':'ss") + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("HH':'mm':'ss") + "\t" +
"ID message" + message.Id + "\t" + message.FromId + "\t" + message.Message + Environment.NewLine +
"***************" + Environment.NewLine);
}
if (msg is TLMessageService)
{
continue;
}
n++;
countMessa++;
}
Thread.Sleep(22000); //to avoid TelegramFloodException
SaveTextFileBuilder(sb, "Messages.txt");
Console.WriteLine($"Всего собщений в чате {allCountMess} + {Environment.NewLine} Получно {n}" + Environment.NewLine);
}
else
{
break;
}
}
catch (Exception ex)
{
string tempEx = $"Ошибка при получении списка сособщения из чата {VKFID}" + Environment.NewLine + ex;
SaveTextFile(tempEx);
break;
}
finally
{
// await Task.Delay(22000); //чтобы обойти TelegramFloodException
}
}
}
catch (Exception ex)
{
string tempEx = $"Ошибка при получении списка сособщения из чата {VKFID}" + Environment.NewLine + ex;
SaveTextFile(tempEx);
}
finally
{
// SaveTextFileBuilder(sb, "Messages.txt");
// return sb;
}
return(sb);
}
public Channel(TLInputPeerChannel c, int p, string s)
{
channel = c;
prevIds = p;
name = s;
}
public static async System.Threading.Tasks.Task Main(string[] args)
{
var client = new TelegramClient(2954623, hash);
await client.ConnectAsync();
var hashCode = await client.SendCodeRequestAsync(userNumber);
Console.WriteLine("Type telegram code");
var telegramCode = Console.ReadLine();
var user = await client.MakeAuthAsync(userNumber, hashCode, telegramCode);
if (client.IsUserAuthorized())
{
var dialogs = await client.GetUserDialogsAsync() as TLDialogs;
foreach (var dia in dialogs.Dialogs.Where(x => x.Peer is TLPeerChannel && x.UnreadCount > 0))
{
var peer = dia.Peer as TLPeerChannel;
var chat = dialogs.Chats.OfType <TLChannel>().FirstOrDefault(x => x.Id == peer.ChannelId &&
x.Title.Contains("ANGEL"));
var target = new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = (long)chat.AccessHash
};
var hist = await client.GetHistoryAsync(target, 0, -1, dia.UnreadCount);
Console.WriteLine("=====================================================================");
Console.WriteLine("THIS IS:" + chat.Title + " WITH " + dia.UnreadCount + " UNREAD MESSAGES");
foreach (var m in (hist as TLChannelMessages).Messages)
{
Console.WriteLine((m as TLMessage).Message);
}
}
Console.ReadLine();
//var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
//var chat = dialogs.Chats
// .OfType<TLChat>()
// .FirstOrDefault(c => c.Title.Contains("ANGEL"));
//var tlAbsMessages =
// await client.GetHistoryAsync(
// new TLInputPeerChat { ChatId = chat.Id }, 0,
// 0, -1, 1000);
//var tlChannelMessages = (TLMessages)tlAbsMessages;
//for (int i = 0; i < tlChannelMessages.Messages.Count - 1; i++)
//{
// var tlAbsMessage = tlChannelMessages.Messages[i];
// var message = (TLMessage)tlAbsMessage;
//}
//var result = await client.GetContactsAsync();
//var u = result.Users.OfType<TLUser>().ToList();
//var dialogs = await client.GetUserDialogsAsync() as TLDialogs;
//var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
//var chat = dialogs.Chats.OfType<TLChat>().ToList();
//foreach (var dia in dialogs.dialogs.lists.Where(x => x.peer is TLPeerChannel && x.unread_count > 0))
//{
// var peer = dia.peer as TLPeerChannel;
// var chat = dialogs.chats.lists.OfType<TLChannel>().First(x => x.id == peer.channel_id);
// var target = new TLInputPeerChannel() { channel_id = chat.id, access_hash = (long)chat.access_hash };
// var hist = await telegram.GetHistoryAsync(target, 0, -1, dia.unread_count);
// Console.WriteLine("=====================================================================");
// Console.WriteLine("THIS IS:" + chat.title + " WITH " + dia.unread_count + " UNREAD MESSAGES");
// foreach (var m in (hist as TLChannelMessages).messages.lists)
// Console.WriteLine((m as TLMessage).message);
//}
}
}
public async Task <StringBuilder> GetChatTelegram()
{
TelegramClient client = new TelegramClient(apiId, apiHash);
sb.Append("#\tDate\tTime\tMID\tTUID\tText" + Environment.NewLine);
TLDialogsSlice dialogs = (TLDialogsSlice)await client.GetUserDialogsAsync(); // Получение списка чатов
TLChannel chat = dialogs.Chats.Where(c => c.GetType() == typeof(TLChannel)).Cast <TLChannel>().FirstOrDefault(c => c.Id == VKFID);
TLInputPeerChannel inputPeer = new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = (long)chat.AccessHash
};
while (countMessa == 100)
{
try
{
TLChannelMessages res = await client.SendRequestAsync <TLChannelMessages>
(new TLRequestGetHistory()
{
Peer = inputPeer, Limit = 1000, AddOffset = offset, OffsetId = 0
});
var msgs = res.Messages;
if (res.Count > offset)
{
offset += msgs.Count;
foreach (TLAbsMessage msg in msgs)
{
if (msg is TLMessage)
{
TLMessage message = msg as TLMessage;
sb.Append(n.ToString() + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("dd'.'MM'.'yyyy") + "\t" +
ConvertFromUnixTimestamp(message.Date).ToLocalTime().ToString("HH':'mm':'ss") + "\t" +
message.Id + "\t" + message.FromId + "\t" + message.Message + Environment.NewLine);
}
if (msg is TLMessageService)
{
continue;
}
n++;
countMessa++;
}
Thread.Sleep(22000); //to avoid TelegramFloodException
}
else
{
break;
}
}
catch (Exception ex)
{
string tempEx = $"Ошибка при получении списка сособщения из чата {VKFID}" + Environment.NewLine;
//MessageBox.Show(ex.Message);
break;
}
finally
{
await Task.Delay(22000); //чтобы обойти TelegramFloodException
}
}
return(sb);
// textBox2.Text = sb.ToString();
// MessageBox.Show("Done");
}
private async Task ExportMessagesToWord()
{
using var telegram = new TLSharp.Core.TelegramClient(_authConfiguration.ApiId, _authConfiguration.ApiHash,
null,
_authConfiguration.SessionUserId);
await telegram.ConnectAsync();
await Task.Delay(10000);
var dialogs = (TLDialogs)await telegram.GetUserDialogsAsync();
var channel = dialogs.Chats
.OfType <TLChannel>()
.FirstOrDefault(c => c.Title == _myChannelConfiguration.ChannelHeapName);
var inputPeer = new TLInputPeerChannel()
{
ChannelId = channel.Id,
AccessHash = (long)channel.AccessHash
};
var offset = 0;
var sig = false;
await using var fs = new FileStream(
Path.Combine(
_reportConfiguration.FullPath,
$"{_reportConfiguration.Name}-{DateTime.Now:MM-dd-yyyy}.docx"
),
FileMode.Create,
FileAccess.Write
);
var doc = new XWPFDocument();
var paragraph = doc.CreateParagraph();
var run = paragraph.CreateRun();
while (true)
{
if (sig)
{
break;
}
await Task.Delay(10000);
var res = await telegram.SendRequestAsync <TLChannelMessages>(
new TLRequestGetHistory()
{
Peer = inputPeer,
Limit = 100,
AddOffset = offset,
OffsetId = 0
}
);
var msgs = res.Messages;
if (res.Count <= offset)
{
break;
}
offset += msgs.Count;
foreach (var msg in msgs)
{
if (!(msg is TLMessage message))
{
continue;
}
if (string.IsNullOrEmpty(message.Message))
{
continue;
}
if (message.Date > (int)DateTimeOffset.Parse(DateTime.UtcNow.ToString("MM/dd/yyyy"))
.ToUnixTimeSeconds())
{
continue;
}
if (message.Date < (int)DateTimeOffset.Parse(DateTime.UtcNow.AddDays(-1).ToString("MM/dd/yyyy"))
.ToUnixTimeSeconds())
{
sig = true;
break;
}
await Task.Delay(1000);
var ch = dialogs.Chats
.OfType <TLChannel>()
.FirstOrDefault(c => c.Id == message.FwdFrom.ChannelId);
if (ch == null)
{
continue;
}
run.AppendText(@$ "Канал: {ch.Title}");
run.AddCarriageReturn();
run.AppendText(
@$ "Дата: {new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(message.Date):d-M-yyyy HH:mm:ss}"
);
run.AddCarriageReturn();
run.AppendText(
@$ "Сообщение: {message.Message.Replace(" \ n ", string.Empty).Replace(" \ r ", string.Empty).Replace(" \ t ", string.Empty)}"
);
run.AddCarriageReturn();
run.AddCarriageReturn();
run.AddCarriageReturn();
}
}
doc.Write(fs);
}
private async WTask.Task GetMessages(int uID, long uAccess, string type = "chat")
{
Loading(null, true);
TLRequestMessagesGetHistory reqH = new TLRequestMessagesGetHistory();
reqH.setAddOffset(0);
reqH.setLimit(100);
reqH.setOffsetId(0);
reqH.setOffsetDate(0);
reqH.setMinId(0);
reqH.setMaxId(999999);
TLInputPeerUser upeer = new TLInputPeerUser();
TLInputPeerChat cpeer = new TLInputPeerChat();
TLInputPeerChannel chpeer = new TLInputPeerChannel();
switch (type.ToLower())
{
case "user":
upeer = new TLInputPeerUser();
upeer.setAccessHash(uAccess);
upeer.setUserId(uID);
reqH.setPeer(upeer);
break;
case "chat":
cpeer = new TLInputPeerChat();
cpeer.setChatId(uID);
reqH.setPeer(cpeer);
break;
case "channel":
chpeer = new TLInputPeerChannel();
chpeer.setAccessHash(uAccess);
chpeer.setChannelId(uID);
reqH.setPeer(chpeer);
break;
default:
break;
}
//var res = NewApi.Api().doRpcCall(reqH);
var res = await WTask.Task.Run(() => NewApi.Api().doRpcCall(reqH));
string notify = "";
if (res == null)
{
notify = "درخواست نتیجه ای نداشت!";
//NotifyBar.ForeColor = Color.Orange;
}
else
{
MessagesDGV.Rows.Clear();
if (res.GetType() == typeof(TLMessages))
{
try
{
TLMessages Messages = (TLMessages)res;
foreach (var msg in Messages.getMessages())
{
try
{
TLMessage message = (TLMessage)msg;
MessagesDGV.Rows.Add(message.getDate(), message.getId(), message.getMessage(), uID, uAccess);
}
catch { }
}
}
catch { }
}
else if (res.GetType() == typeof(TLMessagesSlice))
{
try
{
TLMessagesSlice Messages = (TLMessagesSlice)res;
foreach (var msg in Messages.getMessages())
{
try
{
TLMessage message = (TLMessage)msg;
MessagesDGV.Rows.Add(message.getDate(), message.getId(), message.getMessage(), uID, uAccess);
}
catch { }
}
}
catch { }
}
else if (res.GetType() == typeof(TLChannelMessages))
{
TLChannelMessages Messages = (TLChannelMessages)res;
foreach (var msg in Messages.getMessages())
{
try
{
TLMessage message = (TLMessage)msg;
MessagesDGV.Rows.Add(message.getDate(), message.getId(), message.getMessage(), uID, uAccess);
}
catch { }
}
}
}
Loading(null, false, notify);
}
