public TLAbsInputPeer CreatePeerFromDialog(TLADialog dialog)
{
TLAbsInputPeer peer = null;
if (dialog.Type == TLADialogType.Channel)
{
peer = new TLInputPeerChannel()
{
channel_id = dialog.Id, access_hash = dialog.AccessHash
}
}
;
else if (dialog.Type == TLADialogType.Chat)
{
peer = new TLInputPeerChat()
{
chat_id = dialog.Id
}
}
;
else if (dialog.Type == TLADialogType.User)
{
peer = new TLInputPeerUser()
{
user_id = dialog.Id, access_hash = dialog.AccessHash
}
}
;
else
{
throw new TLCoreException("Type of TLDialog is unknown");
}
return(peer);
}
public async Task <string> GetUserMessagesAsync(User user)
{
if (!user.AccessHash.HasValue)
{
return(null);
}
var tlUser = new TLInputPeerUser {
user_id = user.Id, access_hash = user.AccessHash.Value
};
IList <TLMessage> messages;
try
{
messages = await _messagesTL.GetMessagesAsync(tlUser);
}
catch (Exception ex)
{
if (!ex.Message.Equals("PEER_ID_INVALID"))
{
throw;
}
await _userService.UpdateHashes();
messages = await _messagesTL.GetMessagesAsync(tlUser);
}
if (messages == null || !messages.Any())
{
return(null);
}
await _messagesTL.MarkUserMessagesAsReadAsync(tlUser);
return(messages[0].message);
}
public DialogHandler(TelegramClient client, int id, long hash)
{
_client = client;
Peer = new TLInputPeerUser {
UserId = id, AccessHash = hash
};
}
public void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
var data = Toast.GetData(taskInstance);
if (data != null)
{
if (data.ContainsKey("QuickMessage"))
{
var manualResetEvent = new ManualResetEvent(false);
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 = new int?();
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"]) : new int?();
}
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"]) : new int?();
}
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() };
ConnectionManager.Instance.UserId = SettingsHelper.UserId;
ConnectionManager.Instance.SendRequest(new TLInvokeWithoutUpdates { Query = obj }, (message, ex) =>
{
manualResetEvent.Set();
},
() =>
{
manualResetEvent.Set();
},
ConnectionManager.DefaultDatacenterId, ConnectionType.Generic, RequestFlag.CanCompress | RequestFlag.FailOnServerError | RequestFlag.RequiresQuickAck | RequestFlag.Immediate);
manualResetEvent.WaitOne(15000);
}
}
deferral.Complete();
}
public async Task MarkUserMessagesAsReadAsync(User user)
{
if (!user.AccessHash.HasValue)
{
return;
}
var tlUser = new TLInputPeerUser {
user_id = user.Id, access_hash = user.AccessHash.Value
};
await _messagesTL.MarkUserMessagesAsReadAsync(tlUser);
}
public async Task SendMessageAsync(User user, string message)
{
if (!user.AccessHash.HasValue)
{
return;
}
var tlUser = new TLInputPeerUser {
user_id = user.Id, access_hash = user.AccessHash.Value
};
await _messagesTL.SendMessageAsync(tlUser, message);
}
public void SendMessage(Message message)
{
var cont = GetTlContact(message.ContactIdentifier);
var accessHash = cont.access_hash.Value;
var id = message.ContactIdentifier;
var peer = new TLInputPeerUser {
access_hash = accessHash, user_id = id
};
_api.SendMessageAsync(
peer, message.Text);
}
private async void button3_Click_1(object sender, EventArgs e)
{
if (textBox1.Text != "")
{
Loading(SendMessageB, true);
string notify = "";
if (NewApi.isAuthenticated())
{
TLInputPeerUser iuser = null;
Random rand = new Random();
string search = textBox1.Text.Trim().Replace("@", "").Replace("+", "").Replace(" ", "").ToLower();
TLUser user = await FindPeer(search);
if (user != null)
{
TLInputPeerUser Puser = new TLInputPeerUser();
Puser.setAccessHash(user.getAccessHash());
Puser.setUserId(user.getId());
if (search == null || search == "")
{
search = user.getFirstName() + " " + user.getLastName();
}
TLRequestMessagesSendMessage req = new TLRequestMessagesSendMessage();
req.setRandomId(rand.Next());
req.setPeer(Puser);
req.setMessage(MessageTB.Text);
try
{
//TLUpdates res = (TLUpdates)Api.doRpcCall(req);
var res = await WTask.Task.Run(() => Api.doRpcCall(req));
//MessageBox.Show(string.Join(",", res));
notify = "پیام به " + search + " ارسال شد.";
//NotifyBar.ForeColor = Color.Green;
}
catch (Exception ex)
{
notify = "خطا: " + ex.Message;
//NotifyBar.ForeColor = Color.Red;
}
}
}
Loading(SendMessageB, false, notify);
}
}
public IAsyncOperation <LoadMoreItemsResult> LoadMoreItemsAsync(uint count)
{
return(AsyncInfo.Run(async(token) =>
{
var lastDate = 0;
var lastMsgId = 0;
var lastPeer = (TLInputPeerBase) new TLInputPeerEmpty();
var last = this.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
};
}
}
var response = await _protoService.GetDialogsAsync(lastDate, lastMsgId, lastPeer, 200);
if (response.IsSucceeded)
{
foreach (var item in response.Result.Dialogs)
{
Add(item);
}
return new LoadMoreItemsResult {
Count = (uint)response.Result.Dialogs.Count
};
}
return new LoadMoreItemsResult {
Count = 20
};
}));
}
private async Task UpdateUserChat()
{
rtbMain.SelectAll();
rtbMain.Selection.Text = "";
var selected = (UserView)lbUserChats.SelectedItem;
var peer = new TLInputPeerUser()
{
UserId = selected.id, AccessHash = selected.accessHash ?? 0
};
currentPeer = peer;
currentChatLastMessageId = 0;
await UpdateChat(peer, currentChatLastMessageId);
}
private TLAbsMessages GetHistory(TLClient client, TLInputPeerUser target, TLDialog dia)
{
try
{
var historyAsync = Task.Run(() => client.GetHistoryAsync(target, 0, -1, dia.UnreadCount));
historyAsync.Wait();
var hist = historyAsync.Result;
return(hist);
}
catch (Exception ex)
{
return(null);
}
}
private static async Task <int?> QueryBot2(bool execute_true_select_false, MessageEventArgs e,
TelegramBotAbstract sender)
{
if (e.Message.ReplyToMessage == null || string.IsNullOrEmpty(e.Message.ReplyToMessage.Text))
{
var text = new Language(new Dictionary <string, string>
{
{ "en", "You have to reply to a message containing the query" }
});
await sender.SendTextMessageAsync(e.Message.From.Id, text, ChatType.Private,
e.Message.From.LanguageCode, ParseMode.Html, null, e.Message.From.Username, e.Message.MessageId);
return(null);
}
var query = e.Message.ReplyToMessage.Text;
if (execute_true_select_false)
{
var i = SqLite.Execute(query);
var text = new Language(new Dictionary <string, string>
{
{ "en", "Query execution. Result: " + i }
});
await sender.SendTextMessageAsync(e.Message.From.Id, text, ChatType.Private,
e.Message.From.LanguageCode, ParseMode.Html, null, e.Message.From.Username, e.Message.MessageId);
return(i);
}
var x = SqLite.ExecuteSelect(query);
var x2 = StreamSerialization.SerializeToStream(x);
var documentInput =
new TelegramFile(x2, "table.bin", "Query result", "application/octet-stream");
TLAbsInputPeer peer2 = new TLInputPeerUser {
UserId = e.Message.From.Id
};
var peer = new Tuple <TLAbsInputPeer, long>(peer2, e.Message.From.Id);
var text2 = new Language(new Dictionary <string, string>
{
{ "en", "Query result" }
});
var v = await sender.SendFileAsync(documentInput, peer, text2, TextAsCaption.AS_CAPTION,
e.Message.From.Username, e.Message.From.LanguageCode, e.Message.MessageId, false);
return(v ? 1 : 0);
}
internal static async Task MarkMessagesAsRead()
{
try
{
Console.WriteLine("Marking messages as read....");
var client1 = Auth.Client1();
var client2 = Auth.Client2();
await client1.ConnectAsync();
var target2 = new TLInputPeerUser {
UserId = User2Id
};
var readed2 = new TLRequestReadHistory {
Peer = target2
};
await client1.SendRequestAsync <TLAffectedMessages>(readed2);
Console.WriteLine("Marked messages from " + ImporterApp.NameUser2 + " as read in " + Auth.phone1 + " account.");
await client2.ConnectAsync();
var target1 = new TLInputPeerUser {
UserId = User1Id
};
var readed1 = new TLRequestReadHistory {
Peer = target1
};
await client2.SendRequestAsync <TLAffectedMessages>(readed1);
Console.WriteLine("Marked messages from " + ImporterApp.NameUser1 + " as read in " + Auth.phone2 + " account.");
}
catch (FloodException ex)
{
string time;
time = ex.TimeToWait.ToString();
Console.WriteLine(floodlimit + time);
Thread.Sleep(ex.TimeToWait);
MarkMessagesAsRead().Wait();
}
catch (Exception ex)
{
Console.WriteLine("Unknown error while marking messages as read. Here is the full exception code:\n\n" + ex);
Console.WriteLine("\n\nPress ENTER to try it again. If you receive another error after trying again, please, post the full exception code in a new issue in GitHub, describing the issue as much as possible.");
Console.ReadLine();
MarkMessagesAsRead().Wait();
}
return;
}
public async Task SendLocalVideoAsync(YVideo video, VideoStreamInfo videoStream, string path)
{
if (video == null)
{
throw new ArgumentNullException("video");
}
if (videoStream == null)
{
throw new ArgumentNullException("videoStream");
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
FileInfo file = new FileInfo(path);
if (!file.Exists)
{
throw new Exception(string.Format("Файл по адресу {0} не найден",
path));
}
TLAbsInputFile fileResult = this.UploadLocalFileToTelegram(path, video.Title);
string mimeType = "video/mp4";
TLDocumentAttributeVideo attr1 = new TLDocumentAttributeVideo()
{
Duration = (int)video.Duration.TotalSeconds + 1,
H = videoStream.Resolution.Height,
W = videoStream.Resolution.Width,
};
TLVector <TLAbsDocumentAttribute> attrs = new TLVector <TLAbsDocumentAttribute>();
attrs.Add(attr1);
TLInputPeerUser peer = new TLInputPeerUser()
{
UserId = this.CurrentAuthUser.Id
};
var sendTask = this.TClient.SendUploadedDocument(
peer, fileResult, video.Title, mimeType, attrs);
sendTask.Wait();
}
private async Task InitBotContact()
{
TLDialogs dialogs = (TLDialogs)await client.GetUserDialogsAsync();
foreach (TLUser user in dialogs.Users)
{
if (user.FirstName.Contains("LTC"))
{
bot = user;
botPeer = new TLInputPeerUser()
{
AccessHash = (long)bot.AccessHash, UserId = bot.Id
};
break;
}
}
}
public virtual async Task DownloadFileFromContactTest()
{
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TeleSharp.TL.Contacts.TLContacts result = await client.GetContactsAsync();
TLUser user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == this.NumberToSendMessage);
TLInputPeerUser inputPeer = new TLInputPeerUser()
{
UserId = user.Id
};
TLMessagesSlice res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
Peer = inputPeer
});
TLDocument document = res.Messages
.OfType <TLMessage>()
.Where(m => m.Media != null)
.Select(m => m.Media)
.OfType <TLMessageMediaDocument>()
.Select(md => md.Document)
.OfType <TLDocument>()
.First();
TeleSharp.TL.Upload.TLFile resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
AccessHash = document.AccessHash,
Id = document.Id,
Version = document.Version
},
document.Size);
Assert.IsTrue(resFile.Bytes.Length > 0);
}
public virtual async Task DownloadFileFromContactTest()
{
var client = NewClient();
await client.ConnectAsync();
var result = await client.GetContactsAsync();
var user = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.phone == NumberToSendMessage);
var inputPeer = new TLInputPeerUser()
{
user_id = user.id
};
var res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
peer = inputPeer
});
var document = res.messages.lists
.Where(m => m.GetType() == typeof(TLMessage))
.Cast <TLMessage>()
.Where(m => m.media != null && m.media.GetType() == typeof(TLMessageMediaDocument))
.Select(m => m.media)
.Cast <TLMessageMediaDocument>()
.Where(md => md.document.GetType() == typeof(TLDocument))
.Select(md => md.document)
.Cast <TLDocument>()
.First();
var resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
access_hash = document.access_hash,
id = document.id,
version = document.version
},
document.size);
Assert.IsTrue(resFile.bytes.Length > 0);
}
private async Task InitializeParticipant(string participantName)
{
var searchResult = await _client.SearchUserAsync(participantName);
var participant = (TLUser)searchResult.Users.FirstOrDefault();
if (participant == null)
{
throw new Exception($"Didn't find participant: {participantName}");
}
var id = participant.Id;
var hash = participant.AccessHash.Value;
_participant = new TeleSharp.TL.TLInputPeerUser()
{
UserId = id, AccessHash = hash
};
}
public virtual async Task DownloadFileFromContactTest()
{
var client = NewClient();
await client.ConnectAsync();
var result = await client.GetContactsAsync();
var user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == NumberToSendMessage);
var inputPeer = new TLInputPeerUser()
{
UserId = user.Id
};
var res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
Peer = inputPeer
});
var document = res.Messages
.OfType <TLMessage>()
.Where(m => m.Media != null)
.Select(m => m.Media)
.OfType <TLMessageMediaDocument>()
.Select(md => md.Document)
.OfType <TLDocument>()
.First();
var resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
AccessHash = document.AccessHash,
Id = document.Id,
FileReference = document.FileReference,
ThumbSize = "250x250"
},
document.Size);
Assert.IsTrue(resFile.Bytes.Length > 0);
}
public async Task <TLAbsMessages> GetHistory(int id, long?hash, int limit, int offset, int maxId, HistoryPeer historyPeer)
{
await client.ConnectAsync();
TLAbsInputPeer peer = null;
switch (historyPeer)
{
case HistoryPeer.Channel:
if (hash == null)
{
throw new NullReferenceException("hash");
}
peer = new TLInputPeerChannel {
channel_id = id,
access_hash = hash.Value
};
break;
case HistoryPeer.Chat:
peer = new TLInputPeerChat {
chat_id = id
};
break;
case HistoryPeer.User:
if (hash == null)
{
throw new NullReferenceException("hash");
}
peer = new TLInputPeerUser {
user_id = id,
access_hash = hash.Value
};
break;
default:
throw new ArgumentOutOfRangeException(nameof(historyPeer), historyPeer, null);
}
return(await client.GetHistoryAsync(peer, offset, maxId, limit));
}
public virtual async Task DownloadFileFromContactTest()
{
NumberToSendMessage = tbNumber.Text;
var client = NewClient();
await client.ConnectAsync();
var result = await client.GetContactsAsync();
var user = result.users.lists.ToList()
.OfType <TLUser>()
.FirstOrDefault(x => x.phone == NumberToSendMessage);
var inputPeer = new TLInputPeerUser()
{
user_id = user.id
};
var res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
peer = inputPeer, limit = 1
});
var document = res.messages.lists.ToList()
.OfType <TLMessage>()
.Where(m => m.media != null)
.Select(m => m.media)
.OfType <TLMessageMediaDocument>()
.Select(md => md.document)
.OfType <TLDocument>()
.FirstOrDefault();
var resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
access_hash = document.access_hash,
id = document.id,
version = document.version
},
document.size);
bool sss = resFile.bytes.Length > 0;
}
public static async Task <bool> GetAllGroups(long chatId, string username, TelegramBotAbstract sender,
string lang)
{
var groups = Groups.GetAllGroups();
Stream stream = new MemoryStream();
FileSerialization.SerializeFile(groups, ref stream);
TLAbsInputPeer peer2 = new TLInputPeerUser {
UserId = (int)chatId
};
var peer = new Tuple <TLAbsInputPeer, long>(peer2, chatId);
var text2 = new Language(new Dictionary <string, string>
{
{ "en", "Here are all groups:" },
{ "it", "Ecco tutti i gruppi:" }
});
return(await SendMessage.SendFileAsync(new TelegramFile(stream, "groups.bin",
null, "application/octet-stream"), peer,
text2, TextAsCaption.BEFORE_FILE,
sender, username, lang, null, true));
}
public async Task ForwardMessgae(TLMessage message, TLChannel from, TLUser to)
{
Random rand = new Random();
TLInputPeerChannel cha = new TLInputPeerChannel
{
ChannelId = from.Id,
AccessHash = from.AccessHash.Value
};
TLInputPeerUser us = new TLInputPeerUser
{
AccessHash = to.AccessHash.Value,
UserId = to.Id
};
TLVector <long> a = new TLVector <long>();
a.Add(rand.Next());
TLVector <int> b = new TLVector <int>();
b.Add(message.Id);
TLRequestForwardMessages aa = new TLRequestForwardMessages();
aa.FromPeer = cha;
aa.ToPeer = us;
aa.RandomId = a;
aa.MessageId = message.Id;
aa.Id = b;
aa.Silent = true;
aa.WithMyScore = true;
TLUpdates rr = await telegramClient.SendRequestAsync <TLUpdates>(aa);
}
private async Task GetMessages()
{
try
{
TLAbsDialogs Dialogs = await Client.GetUserDialogsAsync();
TLDialogs Dlogs = Dialogs as TLDialogs;
int i = 0;
foreach (TLUser user in Dlogs.users.lists)
{
TLAbsMessages messages = null;
string type = (Dlogs.dialogs.lists[i].peer.GetType() + "").Replace("TeleSharp.TL.", "");
string peerID = "";
//MessageBox.Show(type);
switch (type)
{
case "TLPeerUser":
TLInputPeerUser ipeer = new TLInputPeerUser();
ipeer.access_hash = (long)user.access_hash;
ipeer.user_id = user.id;
peerID = user.id + "";
messages = await Client.GetHistoryAsync(ipeer, 0, 999999, 1);
break;
case "TLPeerChannel":
break;
case "TLPeerChat":
break;
case "TLPeerNotifyEventsAll":
break;
case "TLPeerNotifyEventsEmpty":
break;
case "TLPeerNotifySettings":
break;
case "TLPeerNotifySettingsEmpty":
break;
case "TLPeerSettings":
break;
default:
break;
}
if (messages != null)
{
try
{
TLMessages msgs = messages as TLMessages;
TLMessagesSlice msgs2 = messages as TLMessagesSlice;
if (msgs != null)
{
foreach (var msg in msgs.messages.lists)
{
string uniq = "";
TLMessage msgg = msg as TLMessage;
if (msgg != null)
{
uniq = peerID + "_" + msgg.id + "# " + msgg.message;
if (UpdatesList.Items.IndexOf(uniq) < 0)
{
UpdatesList.Items.Add(uniq);
}
}
}
}
else if (msgs2 != null)
{
foreach (var msg in msgs2.messages.lists)
{
string uniq = "";
TLMessage msgg = msg as TLMessage;
if (msgg != null)
{
uniq = peerID + "_" + msgg.id + "# " + msgg.message;
if (UpdatesList.Items.IndexOf(uniq) < 0)
{
UpdatesList.Items.Add(uniq);
}
}
}
}
}
catch (Exception ex)
{
ErrorsBox.Items.Add(ex.Message);
}
}
i++;
}
//await GetUpdates();
}
catch (Exception ex) {
ErrorsBox.Items.Add(ex.Message);
}
}
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();
}
static async Task runAsync(string[] args)
{
var config = System.IO.File.ReadAllLines("client.config");
var connectionInfo = new ConnectionInfo(config[2],
config[3],
new PasswordAuthenticationMethod(config[3], config[4]));
var sshClient = new SshClient(connectionInfo);
var sshCommand = config[5];
var client = new TelegramClient(int.Parse(config[0]), config[1]);
await client.ConnectAsync();
if (!client.IsUserAuthorized())
{
Console.WriteLine("Please enter your phone number");
var number = Console.ReadLine();
var hash = await client.SendCodeRequestAsync(number);
Console.WriteLine("Enter the code you recieved from Telegram");
var code = Console.ReadLine();
TLUser user = null;
try
{
user = await client.MakeAuthAsync(number, hash, code);
}
catch (CloudPasswordNeededException)
{
var password = await client.GetPasswordSetting();
Console.WriteLine("Enter your 2FA Password");
var password_str = Console.ReadLine();
user = await client.MakeAuthWithPasswordAsync(password, password_str);
}
}
var result = await client.GetContactsAsync();
var userToSendTo = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Username == "browny99");
var logPeer = new TLInputPeerUser()
{
UserId = userToSendTo.Id
};
await client.SendMessageAsync(logPeer, "Started monitoring");
string UserNameToSendMessage = "@corgigroupagreebot";
var unameResult = await client.SearchUserAsync(UserNameToSendMessage);
var userByName = unameResult.Users
.Where(x => x.GetType() == typeof(TLUser))
.OfType <TLUser>()
.FirstOrDefault(x => x.Username == UserNameToSendMessage.TrimStart('@'));
int retryCounter = 0;
while (!System.IO.File.Exists("cancel.wjdummy"))
{
try
{
TLInputPeerUser botToCheck = new TLInputPeerUser()
{
UserId = userByName.Id, AccessHash = (long)userByName.AccessHash
};
await client.SendMessageAsync(botToCheck, "/start");
await Task.Delay(TimeSpan.FromSeconds(30));
TLAbsMessages history = await client.GetHistoryAsync(botToCheck, limit : 1);
TLMessagesSlice slice = (TLMessagesSlice)history;
var message = ((TLMessage)slice.Messages.ElementAt(0));
if (message.Out == false && message.Message.StartsWith("Hey, good to see you again"))
{
var request = new TLRequestReadHistory();
request.Peer = botToCheck;
await client.SendRequestAsync <TLAffectedMessages>(request);
retryCounter = 0;
}
else
{
retryCounter++;
await client.SendMessageAsync(logPeer, "30 sec unresponsive");
}
if (retryCounter > 5)
{
sshClient.Connect();
var res = sshClient.CreateCommand(sshCommand).Execute();
sshClient.Disconnect();
await client.SendMessageAsync(logPeer, "Restarted server\n\n" + res);
await Task.Delay(TimeSpan.FromSeconds(90));
retryCounter = 0;
}
} catch (Exception e)
{
try
{
await client.SendMessageAsync(logPeer, "Error: \n" + e.ToString());
} catch (Exception ex)
{
Console.WriteLine($"ERROR\n\n{e}\n{ex}\n\nENDERROR");
return;
}
}
}
}
static async Task MainAsync()
{
int apiId = 0;
string apiHash = "",
readPathApi = @"api.txt",
readPathApiNash = @"apiHash.txt";
if (File.Exists("api.txt") && File.Exists("apiHash.txt") && File.Exists("session.dat"))
{
try
{
using (StreamReader sr = new StreamReader(readPathApi, Encoding.Default))
{
apiId = Int32.Parse(sr.ReadLine());
}
using (StreamReader sr = new StreamReader(readPathApiNash, Encoding.Default))
{
apiHash = sr.ReadLine();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
else
{
Console.WriteLine("Enter api:");
apiId = Int32.Parse(Console.ReadLine());
Console.WriteLine();
Console.WriteLine("Enter apiHash:");
apiHash = Console.ReadLine();
Console.WriteLine();
try
{
using (StreamWriter sw = new StreamWriter(readPathApi, false, Encoding.Default))
{
sw.WriteLine(apiId.ToString());
}
using (StreamWriter sw = new StreamWriter(readPathApiNash, false, Encoding.Default))
{
sw.WriteLine(apiHash);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
var store = new FileSessionStore();
var client = new TelegramClient(apiId, apiHash, store);
await client.ConnectAsync();
bool authorized = client.IsUserAuthorized();
if (authorized != true)
{
Console.WriteLine("Enter your phone number:");
string phoneNumber = Console.ReadLine();
Console.WriteLine();
var hash = await client.SendCodeRequestAsync(phoneNumber);
Console.WriteLine("Enter Login code:");
string codeLogin = Console.ReadLine();
Console.WriteLine();
var user = await client.MakeAuthAsync(phoneNumber, hash, codeLogin);
}
//var found = await client.SearchUserAsync("msg_below", 1);
//var u = found.Users.ToList().OfType<TLUser>().FirstOrDefault();
//var peer = new TLInputPeerUser() { UserId = u.Id, AccessHash = (long)u.AccessHash };
//Надсилаю повідомлення
//Console.WriteLine("Enter ur test message: ");
//string a = Console.ReadLine();
//await client.SendMessageAsync(peer, a);
var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
while (true)
{
foreach (var dia in dialogs.Dialogs.ToList())
{
if (dia.UnreadCount < 1)
{
continue;
}
if (dia.Peer is TLPeerUser)
{
var peer = dia.Peer as TLPeerUser;
var chat = dialogs.Users.ToList().OfType <TLUser>().First(x => x.Id == peer.UserId);
var target = new TLInputPeerUser {
UserId = chat.Id, AccessHash = chat.AccessHash ?? default(long)
};
var hist = await client.GetHistoryAsync(target, 0, -1, dia.UnreadCount);
int firstMessage = 0;
if (hist is TLMessagesSlice)
{
int index = 0;
foreach (var m in ((TLMessagesSlice)hist).Messages.ToList())
{
TLMessage msg = m as TLMessage;
if (index == 0)
{
firstMessage = msg.Id;
}
Console.WriteLine("{0} {1} {2}", msg.Id, msg.Message, msg.FromId);
}
}
else if (hist is TLMessages)
{
int index = 0;
foreach (var m in ((TLMessages)hist).Messages.ToList())
{
TLMessage msg = m as TLMessage;
if (index == 0)
{
firstMessage = msg.Id;
}
Console.WriteLine("{0} {1} {2}", msg.Id, msg.Message, msg.FromId);
}
}
Thread.Sleep(5000);
}
}
}
}
public int ReceiveMessages(TLClient client, MessageRepository messageRepository)
{
TLInputPeerUser target = null;
bool hayNuevos = false;
int messageCount = 0;
int firstMessage = 0;
try
{
var dialogs = GetUserDialogs(client);
IEnumerable <TLDialog> listDialogs = dialogs.Dialogs.ToList().Where(x => (x.UnreadCount > 0));
foreach (var dia in listDialogs)
{
hayNuevos = true;
if (dia.Peer is TLPeerUser)
{
var peer = dia.Peer as TLPeerUser;
var chat = dialogs.Users.ToList().OfType <TLUser>().First(x => x.Id == peer.UserId);
target = new TLInputPeerUser {
UserId = chat.Id, AccessHash = (long)chat.AccessHash
};
var hist = GetHistory(client, target, dia);
if (hist is TLMessagesSlice)
{
var h = hist as TLMessagesSlice;
var history = h.Messages.ToList();
for (var i = 0; i < history.Count; i++)
{
var mens = history[i] as TLMessage;
if (i == 0)
{
firstMessage = mens.Id;
}
if (!mens.Out)
{
Chat c = new Chat
{
Created = (new DateTime(1970, 1, 1)).AddSeconds((double)mens.Date).AddHours(1),
FromTo = chat.Phone,
Mensaje = mens.Message,
Send = false,
Seen = false
};
messageRepository.InsertChat(c);
messageCount++;
}
}
}
else if (hist is TLMessages)
{
var h = hist as TLMessages;
var history = h.Messages.ToList();
for (var i = 0; i < history.Count; i++)
{
var mens = history[i] as TLMessage;
if (i == 0)
{
firstMessage = mens.Id;
}
if (!mens.Out)
{
Chat c = new Chat
{
Created = (new DateTime(1970, 1, 1)).AddSeconds((double)mens.Date).AddHours(1),
FromTo = chat.Phone,
Mensaje = mens.Message,
Send = false,
Seen = false
};
messageRepository.InsertMessage(c);
messageCount++;
}
}
}
}
if (firstMessage > 0)
{
var readed = new TeleSharp.TL.Messages.TLRequestReadHistory
{
Peer = target
};
var affectedMessages = Task.Run(() => client.SendRequestAsync <TLAffectedMessages>(readed));
affectedMessages.Wait();
var resultado = affectedMessages.Result;
}
}
return(messageCount);
}
catch (Exception ex)
{
return(-1);
}
}
private async Task get_updates()
{
while (getupdates)
{
var state = await Client.SendRequestAsync <TLState>(new TLRequestGetState());
TLRequestGetDifference req = new TLRequestGetDifference();
req.date = state.date;
req.pts = state.pts - 1;
req.qts = state.qts - 1;
var adiff = await Client.SendRequestAsync <TLAbsDifference>(req);
if (!(adiff is TLDifferenceEmpty))
{
if (adiff is TLDifference)
{
var diff = adiff as TLDifference;
string uniq = "";
uniq += ("chats:" + diff.chats.lists.Count);
uniq += (" new:" + diff.new_messages.lists.Count);
uniq += (" user:"******" other:" + diff.other_updates.lists.Count);
if (diff.new_messages.lists.Count > 0)
{
foreach (var upd in diff.new_messages.lists)
{
TLMessage msg = (upd as TLMessage);
uniq = msg.from_id.Value + "_" + msg.id + ": " + (msg.message);
if (UpdatesList.Items.IndexOf(uniq) < 0 && msg.message != "")
{
UpdatesList.Items.Insert(0, uniq);
string replay = "";
TLInputPeerUser peer = new TLInputPeerUser();
foreach (string item in ReplisBox.Items)
{
string[] st = item.Split('#');
if (st[0] == msg.message.Trim())
{
if (MyDialogs.ContainsKey(msg.from_id.Value))
{
}
else
{
await GetDialogs();
}
replay = st[1];
peer.access_hash = MyDialogs[msg.from_id.Value];
peer.user_id = msg.from_id.Value;
}
}
if (replay != "")
{
await Client.SendMessageAsync(peer, replay);
}
}
}
}
}
else if (adiff is TLDifferenceTooLong)
{
ErrorsBox.Items.Add("too long");
//Console.WriteLine("too long");
}
else if (adiff is TLDifferenceSlice)
{
//Console.WriteLine("slice");
ErrorsBox.Items.Add("slice");
}
}
//await Task.Delay(500);
}
}
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);
}
}
