private static async Task <Tuple <bool?, DateTime?> > FixTheFactThatSomeGroupsDoesNotHaveOurModerationBot6Async(
TLChat x5, TLAbsInputPeer u, TelegramBotAbstract telegramBotAbstract)
{
;
var isOurBotPresent2 = await CheckIfOurBotIsPresent3Async(x5, telegramBotAbstract);
if (isOurBotPresent2 == null)
{
return(new Tuple <bool?, DateTime?>(false, null));
}
;
if (isOurBotPresent2.Item2 != null)
{
return(new Tuple <bool?, DateTime?>(null, isOurBotPresent2.Item2));
}
if (isOurBotPresent2.Item1 != null && isOurBotPresent2.Item1.Value)
{
return(new Tuple <bool?, DateTime?>(true, null));
}
var r4 = await InsertOurBotAsyncChat(x5, u, null, telegramBotAbstract);
return(new Tuple <bool?, DateTime?>(r4, null));
}
private static async Task <bool?> InsertOurBotAsyncChat(TLChat x5,
TLAbsInputPeer u, long?accessHash, TelegramBotAbstract telegramBotAbstract)
{
;
;
const long userIdOfOurBot = 768169879;
TLInputChannel channel = null;
if (accessHash != null)
{
channel = new TLInputChannel {
AccessHash = accessHash.Value, ChannelId = x5.Id
}
}
;
else
{
channel = new TLInputChannel {
ChannelId = x5.Id
}
};
var r4 = await F1Async(telegramBotAbstract, userIdOfOurBot, u, x5.Title, x5.Id, channel);
if (r4.returnobject != null)
{
return(r4.returnobject.Value);
}
if (r4.r2.Item1 == null)
{
var m = "\n";
m += "We can't make our bot admin in this group:\n";
m += "[Title] " + x5.Title + "\n";
m += "[ID] " + x5.Id;
m += "\n --- end --- ";
m += "\n";
var e2 = new Exception(m, r4.r2.Item2);
await NotifyUtil.NotifyOwners(e2, telegramBotAbstract);
await DeleteMessageAddedAsync(r4.idMessageAdded, x5, accessHash, telegramBotAbstract);
return(false);
}
Thread.Sleep(2000);
;
await DeleteMessageAddedAsync(r4.idMessageAdded, x5, accessHash, telegramBotAbstract);
id_of_chats_we_know_are_ok[x5.Id] = true;
return(r4.r != null && r4.r2.Item1 != null);
return(null);
}
private TelegramContactResponse BuildTelegramResponse(TLChat chat)
{
return(new TelegramContactResponse.Builder()
.WithId(chat.Id)
.WithName(chat.Title)
.WithType(ContactType.Channel)
.Build());
}
public async Task <UserSearchResult> GetUsersOld(TelegramClient client)
{
UserSearchResult searchResult = new UserSearchResult()
{
TlUsers = new List <TLUser>(), Users = new List <UserModel>()
};
try
{
dynamic dialogs;
try
{
dialogs = (TLDialogs)await client.GetUserDialogsAsync();
}
catch (Exception ex)
{
dialogs = (TLDialogsSlice)await client.GetUserDialogsAsync();
Logger.Error(ex);
}
foreach (TLAbsChat element in dialogs.Chats)
{
if (element is TLChat)
{
TLChat chat = element as TLChat;
var request = new TLRequestGetFullChat()
{
ChatId = chat.Id
};
TeleSharp.TL.Messages.TLChatFull chatFull = await client.SendRequestAsync <TeleSharp.TL.Messages.TLChatFull>(request);
foreach (var absUser in chatFull.Users)
{
TLUser user = absUser as TLUser;
if (!user.Bot && !user.Deleted && !user.Self)
{
searchResult.TlUsers.Add(user);
var customeUser = _userService.CreateCustomUserModel(user);
searchResult.Users.Add(customeUser);
}
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(searchResult);
}
private async void GetGroupsBT_Click(object sender, EventArgs e)
{
Loading(GetGroupsBT, true);
TLRequestMessagesGetDialogs req = new TLRequestMessagesGetDialogs();
req.setOffsetPeer(new TLInputPeerSelf());
req.setOffsetDate(0);
req.setLimit(1000);
//var res = NewApi.Api().doRpcCall(req);
var res = await WTask.Task.Run(() => NewApi.Api().doRpcCall(req));
string notify = "";
if (res == null)
{
notify = "درخواست نتیجه ای نداشت!";
//NotifyBar.ForeColor = Color.Orange;
}
else
{
GroupsDGV.Rows.Clear();
ChannelsDGV.Rows.Clear();
TLDialogs Dailogs = (TLDialogs)res;
/*
* var ChanGP = Dailogs.getChats().toArray()
* .Where(x => x.GetType() == typeof(TLChannel))
* .Cast<TLChannel>();
*/
foreach (var dial in Dailogs.getChats())
{
if (dial.GetType() == typeof(TLChat))
{
TLChat chat = (TLChat)dial;
GroupsDGV.Rows.Add(chat.getTitle(), "-", chat.getId(), 0);
}
else if (dial.GetType() == typeof(TLChannel))
{
TLChannel chat = (TLChannel)dial;
if ((chat.getId() + "").Substring(0, 3) != "100")
{
GroupsDGV.Rows.Add(chat.getTitle(), chat.getUsername(), chat.getId(), chat.getAccessHash());
}
else
{
ChannelsDGV.Rows.Add(chat.getTitle(), chat.getUsername(), chat.getId(), chat.getAccessHash());
}
}
}
}
Loading(GetGroupsBT, false, notify);
}
public async Task <List <TLUser> > GetUsers(TelegramClient client)
{
var usersList = new List <TLUser>();
try
{
var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
//var dialogs2 = (TLDialogsSlice)await client.GetUserDialogsAsync();
foreach (TLAbsChat element in dialogs.Chats)
{
if (element is TLChat) //chats with permissions
{
TLChat chat = element as TLChat;
var request = new TLRequestGetFullChat()
{
ChatId = chat.Id
};
TeleSharp.TL.Messages.TLChatFull chatFull = await client.SendRequestAsync <TeleSharp.TL.Messages.TLChatFull>(request);
foreach (var absUser in chatFull.Users)
{
TLUser user = absUser as TLUser;
if (!user.Bot)
{
usersList.Add(user);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(usersList);
}
public BitmapImage this[TLChat chat]
{
get
{
if (chat == null)
{
return(null);
}
if (_context.TryGetValue(chat.Photo, out Tuple <TLBitmapSource, WeakReference <BitmapImage> > reference) &&
reference.Item2.TryGetTarget(out BitmapImage target))
{
return(target);
}
var bitmap = new TLBitmapSource(chat);
_context[chat.Photo] = new Tuple <TLBitmapSource, WeakReference <BitmapImage> >(bitmap, new WeakReference <BitmapImage>(bitmap.Image));
return(bitmap.Image);
}
}
// verify if currect API ID & HASH are linked to a Agent, that has Admin or Creator access to Chat; also
// verify if chat specified is Super Group or not, to check if Message History is available from such a chat
private static bool CheckGroupPermissions(TLChat chat, bool accessWrite = false, bool checkHistory = false)
{
if (null != chat && null == chat.MigratedTo)
{
Logger.Warn("Trivial Group:\"{0}\" chats history not available", new string[] { chat.Title });
if (checkHistory)
{
return(false);
}
}
if (null != chat && !chat.Admin && !chat.Creator)
{
Logger.Warn("TL Agent is not Creator or Admin of Group:\"{0}\"", new string[] { chat.Title });
if (accessWrite)
{
return(false);
}
}
return(true);
}
public static async Task Do()
{
var client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
var hash = await client.SendCodeRequestAsync("79165223104");
var code = Console.ReadLine();
var user = await client.MakeAuthAsync("79165223104", hash, code);
var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
foreach (var element in dialogs.Chats)
{
TLChat chat = element as TLChat;
if (chat != null && chat.Title == ChatName)
{
await client.SendMessageAsync(new TLInputPeerChat()
{
ChatId = chat.Id
}, "Some restart message");
}
}
}
public override TLChatBase this[long index]
{
get
{
if (TryGetValue(index, out TLChatBase value))
{
return(value);
}
Statement statement;
Sqlite3.sqlite3_prepare_v2(_database, $"SELECT {_fields} FROM `Chats` WHERE `index` = {index}", out statement);
TLChatBase result = null;
if (Sqlite3.sqlite3_step(statement) == SQLiteResult.Row)
{
var id = Sqlite3.sqlite3_column_int64(statement, 0);
var title = Sqlite3.sqlite3_column_text(statement, 4);
var version = Sqlite3.sqlite3_column_int(statement, 6);
var date = Sqlite3.sqlite3_column_int(statement, 8);
TLChatPhotoBase photo = null;
var photoType = Sqlite3.sqlite3_column_type(statement, 10);
if (photoType == 1) // SQLITE_INTEGER
{
var photo_small_local_id = Sqlite3.sqlite3_column_int(statement, 10);
var photo_small_secret = Sqlite3.sqlite3_column_int64(statement, 11);
var photo_small_volume_id = Sqlite3.sqlite3_column_int64(statement, 12);
var photo_small_dc_id = Sqlite3.sqlite3_column_int(statement, 13);
var photo_big_local_id = Sqlite3.sqlite3_column_int(statement, 14);
var photo_big_secret = Sqlite3.sqlite3_column_int64(statement, 15);
var photo_big_volume_id = Sqlite3.sqlite3_column_int64(statement, 16);
var photo_big_dc_id = Sqlite3.sqlite3_column_int(statement, 17);
photo = new TLChatPhoto
{
PhotoSmall = new TLFileLocation
{
LocalId = photo_small_local_id,
Secret = photo_small_secret,
VolumeId = photo_small_volume_id,
DCId = photo_small_dc_id
},
PhotoBig = new TLFileLocation
{
LocalId = photo_big_local_id,
Secret = photo_big_secret,
VolumeId = photo_big_volume_id,
DCId = photo_big_dc_id
}
};
}
else
{
photo = new TLChatPhotoEmpty();
}
if (((ulong)id & PeerIdTypeMask) == PeerIdChatShift) // CHAT
{
var flags = (TLChat.Flag)Sqlite3.sqlite3_column_int(statement, 3);
var participants_count = Sqlite3.sqlite3_column_int(statement, 7);
TLInputChannelBase migratedTo = null;
if (flags.HasFlag(TLChat.Flag.MigratedTo))
{
var channel_id = Sqlite3.sqlite3_column_int(statement, 18);
var access_hash = Sqlite3.sqlite3_column_int64(statement, 19);
migratedTo = new TLInputChannel {
ChannelId = channel_id, AccessHash = access_hash
};
}
result = new TLChat
{
Id = (int)(uint)((ulong)id & PeerIdMask),
Flags = flags,
Title = title,
Version = version,
ParticipantsCount = participants_count,
Date = date,
Photo = photo,
MigratedTo = migratedTo
};
}
else if (((ulong)id & PeerIdTypeMask) == PeerIdChannelShift) // CHANNEL
{
var flags = (TLChannel.Flag)Sqlite3.sqlite3_column_int(statement, 3);
var access_hash = Sqlite3.sqlite3_column_int64(statement, 2);
var username = Sqlite3.sqlite3_column_text(statement, 5);
var restriction_reason = Sqlite3.sqlite3_column_text(statement, 9);
TLChannelAdminRights adminRights = null;
if (flags.HasFlag(TLChannel.Flag.AdminRights))
{
adminRights = new TLChannelAdminRights {
Flags = (TLChannelAdminRights.Flag)Sqlite3.sqlite3_column_int(statement, 20)
};
}
TLChannelBannedRights bannedRights = null;
if (flags.HasFlag(TLChannel.Flag.AdminRights))
{
bannedRights = new TLChannelBannedRights {
Flags = (TLChannelBannedRights.Flag)Sqlite3.sqlite3_column_int(statement, 21)
};
}
result = new TLChannel
{
Id = (int)(uint)((ulong)id & PeerIdMask),
AccessHash = access_hash,
Flags = flags,
Title = title,
Username = username,
Version = version,
Date = date,
RestrictionReason = restriction_reason,
Photo = photo,
AdminRights = adminRights,
BannedRights = bannedRights
};
}
base[index] = result;
}
Sqlite3.sqlite3_finalize(statement);
return(result);
}
set
{
base[index] = value;
Statement statement;
Sqlite3.sqlite3_prepare_v2(_database, $"INSERT OR REPLACE INTO `Chats` ({_fields}) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", out statement);
if (value is TLChat chat)
{
Sqlite3.sqlite3_bind_int64(statement, 1, (long)(PeerIdChatShift | (ulong)(uint)chat.Id));
Sqlite3.sqlite3_bind_int(statement, 2, chat.Id);
Sqlite3.sqlite3_bind_null(statement, 3);
Sqlite3.sqlite3_bind_int(statement, 4, (int)chat.Flags);
Sqlite3.sqlite3_bind_text(statement, 5, chat.Title, -1);
Sqlite3.sqlite3_bind_null(statement, 6);
Sqlite3.sqlite3_bind_int(statement, 7, chat.Version);
Sqlite3.sqlite3_bind_int(statement, 8, chat.ParticipantsCount);
Sqlite3.sqlite3_bind_int(statement, 9, chat.Date);
Sqlite3.sqlite3_bind_null(statement, 10);
if (chat.Photo is TLChatPhoto photo && photo.PhotoSmall is TLFileLocation small && photo.PhotoBig is TLFileLocation big)
{
Sqlite3.sqlite3_bind_int(statement, 11, small.LocalId);
Sqlite3.sqlite3_bind_int64(statement, 12, small.Secret);
Sqlite3.sqlite3_bind_int64(statement, 13, small.VolumeId);
Sqlite3.sqlite3_bind_int(statement, 14, small.DCId);
Sqlite3.sqlite3_bind_int(statement, 15, big.LocalId);
Sqlite3.sqlite3_bind_int64(statement, 16, big.Secret);
Sqlite3.sqlite3_bind_int64(statement, 17, big.VolumeId);
Sqlite3.sqlite3_bind_int(statement, 18, big.DCId);
}
else
{
Sqlite3.sqlite3_bind_null(statement, 11);
Sqlite3.sqlite3_bind_null(statement, 12);
Sqlite3.sqlite3_bind_null(statement, 13);
Sqlite3.sqlite3_bind_null(statement, 14);
Sqlite3.sqlite3_bind_null(statement, 15);
Sqlite3.sqlite3_bind_null(statement, 16);
Sqlite3.sqlite3_bind_null(statement, 17);
Sqlite3.sqlite3_bind_null(statement, 18);
}
if (chat.HasMigratedTo && chat.MigratedTo is TLInputChannel inputChannel)
{
Sqlite3.sqlite3_bind_int(statement, 19, inputChannel.ChannelId);
Sqlite3.sqlite3_bind_int64(statement, 20, inputChannel.AccessHash);
}
else
{
Sqlite3.sqlite3_bind_null(statement, 19);
Sqlite3.sqlite3_bind_null(statement, 20);
}
Sqlite3.sqlite3_bind_null(statement, 21);
Sqlite3.sqlite3_bind_null(statement, 22);
}
else if (value is TLChannel channel)
private static async Task <Tuple <bool?, DateTime?> > FixTheFactThatSomeGroupsDoesNotHaveOurModerationBot4(
TLChat x5, TLAbsInputPeer u, TelegramBotAbstract telegramBotAbstract)
{
if (x5 == null)
{
return(null);
}
;
;
if (x5.MigratedTo == null)
{
var r4 = await FixTheFactThatSomeGroupsDoesNotHaveOurModerationBot6Async(x5, u, telegramBotAbstract);
return(r4);
}
var x6 = x5.MigratedTo;
TLInputChannel x8 = null;
if (x6 is TLInputChannel x7)
{
x8 = x7;
}
else
{
;
return(null);
}
if (x5.MigratedTo == null)
{
return(null);
}
TLAbsInputChannel channel = x8;
TLChatFull x = null;
var channel2 = GetChannel(channel);
if (channel2 == null)
{
return(new Tuple <bool?, DateTime?>(false, null));
}
var isOurBotPresent2 = await CheckIfOurBotIsPresent2Async(channel2, telegramBotAbstract);
if (isOurBotPresent2 == null)
{
return(new Tuple <bool?, DateTime?>(false, null));
}
if (isOurBotPresent2.Item2 != null)
{
return(new Tuple <bool?, DateTime?>(null, isOurBotPresent2.Item2));
}
if (isOurBotPresent2.Item1 != null && isOurBotPresent2.Item1.Value)
{
return(new Tuple <bool?, DateTime?>(true, null));
}
var r3 = await InsertOurBotAsyncChat(x5, u, x8.AccessHash, telegramBotAbstract);
return(new Tuple <bool?, DateTime?>(r3, null));
}
public void Copy(TLChat chat)
{
Id = chat.id;
Title = chat.title;
IsChannel = false;
}
public Chat(TLChat tlChat)
{
Copy(tlChat);
}
//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 static bool IsLike(this TLChat chat, string[] query, StringComparison comp)
{
return(IsLike(chat.Title, null, query, comp));
}
public GroupView(TLChat chat)
{
id = chat.Id;
text = chat.Title;
}
private static async Task DeleteMessageAddedAsync(int?idMessageAdded, TLChat x5, long?accessHash,
TelegramBotAbstract telegramBotAbstract)
{
await DeleteMessageAddedAsync2(idMessageAdded, x5.Id, accessHash, telegramBotAbstract);
}
private static async Task <Tuple <bool?, DateTime?> > CheckIfOurBotIsPresent3Async(TLChat x5,
TelegramBotAbstract telegramBotAbstract)
{
if (id_of_chats_we_know_are_ok.ContainsKey(x5.Id))
{
return(new Tuple <bool?, DateTime?>(id_of_chats_we_know_are_ok[x5.Id], null));
}
TLChatFull x = null;
try
{
x = await telegramBotAbstract._userbotClient.Messages_getFullChat(x5.Id);
}
catch (Exception e)
{
if (e is FloodException floodException)
{
var untilWhen = GetUntilWhenWeCanMakeRequests(floodException);
return(new Tuple <bool?, DateTime?>(null, untilWhen));
}
}
if (x == null)
{
return(new Tuple <bool?, DateTime?>(false, null));
}
;
var r = CheckIfOurBotIsPresent(x);
if (r)
{
id_of_chats_we_know_are_ok[x5.Id] = r;
}
return(new Tuple <bool?, DateTime?>(r, null));
}
private async Task MainAsync(string[] args)
{
TelegramClient client = null;
try
{
// -- if necessary, IP can be changed so the client can connect to the test network.
Session session = null;
// new Session(new FileSessionStore(), "session")
//{
// ServerAddress = "149.154.175.10",
// Port = 443
//};
//Console.WriteLine($"{session.ServerAddress}:{session.Port} {phone}");
client = new TelegramClient(APIId, APIHash);
// subscribe an event to receive live messages
//client.Updates += Client_Updates;
await client.ConnectAsync();
Console.WriteLine($"Authorised: {client.IsUserAuthorized()}");
TLUser user = null;
// -- If the user has already authenticated, this step will prevent account from being blocked as it
// -- reuses the data from last authorisation.
if (client.IsUserAuthorized())
{
//user = client.Session.TLUser;
}
else
{
var registered = await client.IsPhoneRegisteredAsync(phone);
var hash = await client.SendCodeRequestAsync(phone);
Console.Write("Code: ");
var code = Console.ReadLine();
if (!registered)
{
Console.WriteLine($"Sign up {phone}");
user = await client.SignUpAsync(phone, hash, code, "First", "Last");
}
Console.WriteLine($"Sign in {phone}");
user = await client.MakeAuthAsync(phone, hash, code);
}
var contacts = await client.GetContactsAsync();
Console.WriteLine("Contacts:");
foreach (var contact in contacts.Users.OfType <TLUser>())
{
var contactUser = contact as TLUser;
Console.WriteLine($"\t{contact.Id} {contact.Phone} {contact.FirstName} {contact.LastName}");
}
var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
Console.WriteLine("Channels: ");
foreach (var channelObj in dialogs.Chats.OfType <TLChannel>())
{
var channel = channelObj as TLChannel;
Console.WriteLine($"\tChat: {channel.Title}");
}
Console.WriteLine("Groups:");
TLChat chat = null;
foreach (var chatObj in dialogs.Chats.OfType <TLChat>())
{
chat = chatObj as TLChat;
Console.WriteLine($"Chat name: {chat.Title}");
var request = new TLRequestGetFullChat()
{
ChatId = chat.Id
};
var fullChat = await client.SendRequestAsync <TeleSharp.TL.Messages.TLChatFull>(request);
var participants = (fullChat.FullChat as TeleSharp.TL.TLChatFull).Participants as TLChatParticipants;
foreach (var p in participants.Participants)
{
if (p is TLChatParticipant)
{
var participant = p as TLChatParticipant;
Console.WriteLine($"\t{participant.UserId}");
}
else if (p is TLChatParticipantAdmin)
{
var participant = p as TLChatParticipantAdmin;
Console.WriteLine($"\t{participant.UserId}**");
}
else if (p is TLChatParticipantCreator)
{
var participant = p as TLChatParticipantCreator;
Console.WriteLine($"\t{participant.UserId}**");
}
}
var peer = new TLInputPeerChat()
{
ChatId = chat.Id
};
var m = await client.GetHistoryAsync(peer, 0, 0, 0);
Console.WriteLine(m);
if (m is TLMessages)
{
var messages = m as TLMessages;
foreach (var message in messages.Messages)
{
if (message is TLMessage)
{
var m1 = message as TLMessage;
Console.WriteLine($"\t\t{m1.Id} {m1.Message}");
}
else if (message is TLMessageService)
{
var m1 = message as TLMessageService;
Console.WriteLine($"\t\t{m1.Id} {m1.Action}");
}
}
}
else if (m is TLMessagesSlice)
{
bool done = false;
int total = 0;
while (!done)
{
var messages = m as TLMessagesSlice;
foreach (var m1 in messages.Messages)
{
if (m1 is TLMessage)
{
var message = m1 as TLMessage;
Console.WriteLine($"\t\t{message.Id} {message.Message}");
++total;
}
else if (m1 is TLMessageService)
{
var message = m1 as TLMessageService;
Console.WriteLine($"\t\t{message.Id} {message.Action}");
++total;
done = message.Action is TLMessageActionChatCreate;
}
}
m = await client.GetHistoryAsync(peer, total, 0, 0);
}
}
}
//// -- Wait in a loop to handle incoming updates. No need to poll.
//for (; ; )
//{
// await client.WaitEventAsync();
//}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
