private static async Task<TLAbsInputFile> UploadFile(string name, StreamReader reader,
TelegramClient client, bool isBigFileUpload)
{
var file = GetFile(reader);
var fileParts = GetFileParts(file);
int partNumber = 0;
int partsCount = fileParts.Count;
long file_id = BitConverter.ToInt64(Helpers.GenerateRandomBytes(8), 0);
while (fileParts.Count != 0)
{
var part = fileParts.Dequeue();
if (isBigFileUpload)
{
await client.SendRequestAsync<bool>(new TLRequestSaveBigFilePart
{
file_id = file_id,
file_part = partNumber,
bytes = part,
file_total_parts = partsCount
});
}
else
{
await client.SendRequestAsync<bool>(new TLRequestSaveFilePart
{
file_id = file_id,
file_part = partNumber,
bytes = part
});
}
partNumber++;
}
if (isBigFileUpload)
{
return new TLInputFileBig
{
id = file_id,
name = name,
parts = partsCount
};
}
else
{
return new TLInputFile
{
id = file_id,
name = name,
parts = partsCount,
md5_checksum = GetFileHash(file)
};
}
}
private async Task <int> GetTelegramCode()
{
try
{
var client = new TelegramClient(57982, "19706860344842eadeb0cc00f28d0902");
await client.ConnectAsync();
var hash = await client.SendCodeRequestAsync(this.txtBoxPhone.Text.Trim());
}
catch (Exception ex)
{
var st = new StackTrace(ex, true);
var frame = st.GetFrame(0);
var line = frame.GetFileLineNumber();
// --- Report on error and continue
emailHelper.SendExceptionEmail(ex.Message + " " + line);
}
return(1);
}
public bool Login(string login, string password = "")
{
this.login = login;
var store = new FileSessionStore();
string sessionKey = Name;
//153480, "b4fe99e13f7820911ad3cd6c12514e7f
//162156, "489ea0f0a6ec8dff21fd02dcbea6ee42
client = new TelegramClient(153480, "b4fe99e13f7820911ad3cd6c12514e7f", store, sessionKey);
var x = new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
/* run your code here */
ALogin();
Task.Delay(5000).Wait();
});
x.Start();
x.Join();
return(connected);
}
public async Task RunPeriodically(TelegramClient client, SendModel sendModel, UserSearchResult searchResult, CancellationToken token)
{
if (sendModel.Photos == null && sendModel.Documents == null && string.IsNullOrEmpty(sendModel.Message))
{
return;
}
while (sendModel.Interval != TimeSpan.Zero)
{
foreach (var user in searchResult.TlUsers)
{
await Task.Delay(sendModel.Interval.Value, token);
searchResult.TlUsers = new List <TLUser>()
{
user
};
await SendMessage(client, sendModel, searchResult);
}
}
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="botApiUrl">The Telegram bot API url</param>
/// <param name="token">The token.</param>
/// <param name="chatId">The chat identifier.</param>
/// <param name="message">The message.</param>
/// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
private async Task SendMessage(string? botApiUrl, string token, string chatId, string message)
{
this.TryWriteToSelflog($"Trying to send message to chatId '{chatId}': '{message}'.");
var client = new TelegramClient(token, 5, botApiUrl);
try
{
var result = await client.PostMessage(message, chatId);
if (result != null)
{
this.TryWriteToSelflog($"Message sent to chatId '{chatId}': '{result.StatusCode}'.");
}
}
catch (Exception ex)
{
SelfLog.WriteLine($"{ex.Message} {ex.StackTrace}");
this.options.FailureCallback?.Invoke(ex);
}
}
private async Task <int> SendTelegram(string message)
{
try
{
var client = new TelegramClient(57982, "19706860344842eadeb0cc00f28d0902");
await client.ConnectAsync();
var hash = await client.SendCodeRequestAsync(this.txtBoxPhone.Text.Trim());
var code = this.txtBoxTelegramCode.Text.Trim(); // you can change code in debugger
var user = await client.MakeAuthAsync(this.txtBoxPhone.Text.Trim(), hash, code);
//get available contacts
var result = await client.GetContactsAsync();
//find recipient in contacts
var recipient = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.phone == this.txtBoxPhone.Text.Trim());
//send message
await client.SendMessageAsync(new TLInputPeerUser()
{
user_id = recipient.id
}, message);
}
catch (Exception ex)
{
var st = new StackTrace(ex, true);
var frame = st.GetFrame(0);
var line = frame.GetFileLineNumber();
// --- Report on error and continue
emailHelper.SendExceptionEmail(ex.Message + " " + line);
}
return(1);
}
protected override async Task ProcessListenSessionCommandInternalAsync(MBUser user, Message message, ILogger logger, bool isAuthorizationCallback = false)
{
var splits = new List <string>(message.Text.Trim().Split(' '));
splits.RemoveAll(x => string.IsNullOrWhiteSpace(x.Trim()));
if (splits.Count == 1)
{
await TelegramClient.SendTextMessageAsync(
message.Chat.Id,
"You didn't provide a song, dummy.");
return;
}
var resource = splits[1];
// TODO: Allow Playlist, Album
// TODO: Artist??
// URL: https://open.spotify.com/track/2wJDK6Epha7t2rewssvELD?si=iYD2K3e-Sd-RGQEAaDHWfg
if (resource.StartsWith(UrlQualifier, StringComparison.OrdinalIgnoreCase))
{
await Queue(resource.Substring(UrlQualifier.Length, resource.IndexOf('?') - UrlQualifier.Length), '/', logger);
}
// URI: spotify:track:2wJDK6Epha7t2rewssvELD
else if (resource.StartsWith(UriQualifier, StringComparison.OrdinalIgnoreCase))
{
await Queue(resource.Substring(UriQualifier.Length), ':', logger);
}
else
{
// TODO: Search???
await TelegramClient.SendTextMessageAsync(
message.Chat.Id,
"I'm not sure how to handle that");
return;
}
}
public async Task <Result> SendMessageAsync(MessageModel message)
{
Result result = new Result();
try
{
using (var client = new TelegramClient(telegramSettings.ApiId, telegramSettings.ApiHash))
{
await client.ConnectAsync();
var dialogs = (TLDialogs)await client.GetUserDialogsAsync();
var chat = dialogs.Chats.Where(x => x.GetType() == typeof(TLChannel)).Cast <TLChannel>().FirstOrDefault(x => x.Title == telegramSettings.Channel);
await client.SendMessageAsync(new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = chat.AccessHash.Value
},
$"{message.Subject} {Environment.NewLine} {message.Body}");
}
result = new Result()
{
Success = true, Data = GetType().Name, ProjectId = message.ProjectId
};
}
catch (Exception ex)
{
result = new Result()
{
Success = false, Errors = new List <string>()
{
ex.Message
}, Data = GetType().Name, ProjectId = message.ProjectId
};
}
await Log(result);
return(result);
}
/// <summary>
/// Not Valid Yet.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private static async Task GetChannelsUsingOffset(TelegramClient client)
{
/// This is not working properly need fix.
Console.WriteLine("5. Trying to get Channels using offset...");
int offsetId = 0;
var peer = new TeleSharp.TL.TLInputPeerEmpty();
var iLoadCount = 4;
while (true)
{
// get available contacts
var result = await client.GetUserDialogsAsync(0, offsetId, peer, iLoadCount) as TeleSharp.TL.Messages.TLDialogsSlice;
//find recipient in contacts
var list = result.Chats
.Where(x => x.GetType() == typeof(TLChannel))
.Cast <TLChannel>();
foreach (var item in list)
{
Console.WriteLine($"Offset Id: {offsetId} {item.Title} ");
}
if (list.Count() == 0)
{
break;
}
offsetId += iLoadCount;
System.Threading.Thread.Sleep(1000);
}
Console.WriteLine("5. Trying to get Channels using offset [Done]!");
Console.WriteLine();
}
private async Task <IInputFile> UploadProfilePhoto(Telegram service, TelegramClient client,
byte[] resizedPhoto)
{
var fileId = service.GenerateRandomId();
const int chunkSize = 65536;
var chunk = new byte[chunkSize];
uint chunkNumber = 0;
var offset = 0;
using (var memoryStream = new MemoryStream(resizedPhoto))
{
int bytesRead;
while ((bytesRead = memoryStream.Read(chunk, 0, chunk.Length)) > 0)
{
//RPC call
var uploaded =
await client.Methods.UploadSaveFilePartAsync(new UploadSaveFilePartArgs
{
Bytes = chunk,
FileId = fileId,
FilePart = chunkNumber
});
if (!uploaded)
{
return(null);
}
chunkNumber++;
offset += bytesRead;
}
return(new InputFile
{
Id = fileId,
Md5Checksum = "",
Name = service.GenerateRandomId() + ".jpeg",
Parts = chunkNumber
});
}
}
public static CodeRegister VerifyCode(Service service, TelegramSettings settings, string code)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var iresult = TelegramUtils.RunSynchronously(client.Methods.AuthRecoverPasswordAsync(new AuthRecoverPasswordArgs
{
Code = code
}));
var result = (AuthAuthorization)iresult;
Thread.Sleep(100); //wait until the other response comes in.
return(new CodeRegister
{
AccountId = (result.User as User).Id,
Response = CodeRegister.Type.Success
});
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
var cr = new CodeRegister();
cr.Response = CodeRegister.Type.Failure;
return(cr);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(null);
}
}
public static async Task <TelegramClient> CreateTelegramClientAsync(string phoneNumber)
{
var client = TelegramClients.FirstOrDefault(x => x.Session.TLUser.Phone == phoneNumber);
if (client != null)
{
return(client);
}
int apiId = 907056;
string apiHash = "697525d840e31523f43a972dff47e16a";
client = new TelegramClient(apiId, apiHash, sessionUserId: phoneNumber);
await client.ConnectAsync();
if (!client.IsUserAuthorized())
{
throw new System.Exception("Session not found");
}
TelegramClients.Add(client);
return(client);
}
public async Task GetUpdates()
{
var store = new FileSessionStore();
var client = new TelegramClient(store, "session", apiId, apiHash);
await client.Connect();
Assert.IsTrue(client.IsUserAuthorized());
var updatesState = await client.GetUpdatesState();
var initialState = updatesState as Updates_stateConstructor;
Assert.IsNotNull(initialState);
var difference = await client.GetUpdatesDifference(initialState.pts, initialState.date, initialState.qts);
Assert.IsNotNull(difference);
Assert.AreEqual(difference.Constructor, Constructor.updates_differenceEmpty);
var userIdToSendMessage = await client.ImportContactByPhoneNumber(NumberToSendMessage);
await client.SendMessage(userIdToSendMessage.Value, "test");
var differenceAfterMessage = await client.GetUpdatesDifference(initialState.pts, initialState.date, initialState.qts);
Assert.IsNotNull(differenceAfterMessage);
Assert.AreEqual(differenceAfterMessage.Constructor, Constructor.updates_difference);
var differenceUpdate = differenceAfterMessage as Updates_differenceConstructor;
Assert.IsNotNull(differenceUpdate);
Assert.AreEqual(1, differenceUpdate.new_messages.Count);
var messageUpdate = differenceUpdate.new_messages[0] as MessageConstructor;
Assert.IsNotNull(messageUpdate);
Assert.AreEqual("test", messageUpdate.message);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
// Setup telegram client
TelegramClient telegramClient = new TelegramClient();
var authenticationToken = Configuration["Settings:authenticationToken"];
telegramClient.SetAuthenticationToken(authenticationToken);
// Set up webhook
string webhookUrl = Configuration["Settings:webhookUrl"];
int maxConnections = int.Parse(Configuration["Settings:maxConnections"]);
UpdateType[] allowedUpdates = { UpdateType.MessageUpdate };
telegramClient.SetWebhook(webhookUrl, maxConnections, allowedUpdates);
services.AddScoped <ITelegramClient>(client => telegramClient);
}
public static async Task Run(TelegramClient tg)
{
var dialogs = await tg.Messages.GetDialogs();
var firstChannel = dialogs
.Default !
.Chats
.NChoose(x => x.Channel)
.FirstOrDefault() ?? throw new Exception("A channel is not found.");
var channelPeer = new InputPeer.ChannelTag(
channelId: firstChannel.Id,
accessHash: firstChannel.AccessHash !.Value
);
var top100Messages = await tg.Messages.GetHistory(channelPeer, limit : 100);
Console.WriteLine("Here are top 100 messages from the first channel:");
top100Messages.Channel !.Messages.NForEach(msg => {
Console.WriteLine(msg);
Console.WriteLine();
});
}
public static async Task AuthClient(TelegramClient client)
{
Console.WriteLine("\nВведите номер\n");
var num = Console.ReadLine();
var hash = await client.SendCodeRequestAsync(num);
Console.WriteLine("\nВведите код из телеги\n");
var code = Console.ReadLine(); //вводишь код, который пришел в телегу
try
{
await client.MakeAuthAsync(num, hash, code);
}
catch (CloudPasswordNeededException)
{
Console.WriteLine("\nВведите облачный пароль\n");
var passwordStr = Console.ReadLine();
var password = await client.GetPasswordSetting();
await client.MakeAuthWithPasswordAsync(password, passwordStr);
}
}
public async Task <TLAbsUpdates> SendMedia(TLAbsInputPeer peer, TelegramClient telegramClient,
Language caption, string username, string lang)
{
TLAbsUpdates r2 = null;
try
{
r2 = await SendMedia2(peer, telegramClient, caption, lang);
}
catch (Exception e)
{
;
}
if (r2 != null)
{
return(r2);
}
if (string.IsNullOrEmpty(username))
{
return(null);
}
try
{
peer = await UserbotPeer.GetPeerUserWithAccessHash(username, telegramClient);
var r = await SendMedia2(peer, telegramClient, caption, lang);
return(r);
}
catch (Exception e2)
{
return(null);
}
return(null);
}
public FullClientDisposable(Telegram telegram)
{
if (telegram.IsFullClientConnected)
{
_client = telegram._fullClient;
_isFullClient = true;
}
else
{
var transportConfig =
new TcpClientTransportConfig(telegram._settings.NearestDcIp, telegram._settings.NearestDcPort);
var client = new TelegramClient(transportConfig,
new ConnectionConfig(telegram._settings.AuthKey, telegram._settings.Salt), AppInfo);
var result = TelegramUtils.RunSynchronously(client.Connect());
if (result != MTProtoConnectResult.Success)
{
throw new Exception("Failed to connect: " + result);
}
_client = client;
_isFullClient = false;
}
}
public async Task <UserSearchResult> GetByUserStatus(TelegramClient client, List <TLUser> users, TLAbsUserStatus searchedStatus)
{
var result = new UserSearchResult()
{
TlUsers = new List <TLUser>(), Users = new List <UserModel>()
};
foreach (TLUser user in users)
{
TLAbsUserStatus actualStatus = user.Status;
var searchedStatusName = searchedStatus.GetType().FullName;
if (actualStatus.ToString() == searchedStatusName)
{
var statusStr = searchedStatusName.Substring(14);
result.TlUsers.Add(user);
result.Users.Add(CreateCustomUser(user, userStatus: searchedStatusName.Substring(11))); //todo didn't check
}
}
return(result);
}
public async Task <UserSearchResult> Find(TelegramClient client, UserSearchModel searchModel)
{
UserSearchResult searchResult = new UserSearchResult()
{
TlUsers = new List <TLUser>(), Users = new List <UserModel>()
};
List <TLUser> users = await GetUsers(client);
if (searchModel.IsPhotoPresent != null)
{
var res = await GetUsersBasedOnPhotoPresense(client, users, searchModel.IsPhotoPresent);
searchResult.TlUsers.AddRange(res.TlUsers);
searchResult.Users.AddRange(res.Users);
}
if (searchModel.UserStatus != null)
{
var res = await GetByUserStatus(client, users, searchModel.UserStatus);
searchResult.TlUsers.AddRange(res.TlUsers);
searchResult.Users.AddRange(res.Users);
}
if (searchModel.LastSeen != null)
{
var res = await GetByLastSeen(client, users, searchModel.LastSeen);
searchResult.TlUsers.AddRange(res.TlUsers);
searchResult.Users.AddRange(res.Users);
}
if (searchModel.IsNicknamePresent != null)
{
var res = await GetByPresenetNickname(client, users, searchModel.IsNicknamePresent);
searchResult = res;
searchResult.TlUsers.AddRange(res.TlUsers);
searchResult.Users.AddRange(res.Users);
}
return(EnsureUniqueUsers(searchResult));
}
static void Main(string[] args)
{
TelegramNotApi.GetUpdates(TelegramData.Token);
TelegramClient bot = new TelegramClient(TelegramData.Token);
Console.WriteLine(bot.GetMe().result.username);
bot.OnMessage += (arg) =>
{
Console.WriteLine($"{arg.FirstName}: {arg.Text}");
bot.SendMessage(
chatId: arg.ChatId,
text: "Получено",
replyToMsgId: arg.MessageId
);
};
bot.Start();
}
public void CustomerDisconnected()
{
//TODO: Get first and if connect, then remove from queue
var customerChatId = WaitingQueueRepo.Dequeue();
if (customerChatId == default(long))
{
return;
}
var customer = SubscriberRepo.GetByChatId(customerChatId);
ConnectionManager.TryConnect(customer);
var waitersChatIds = WaitingQueueRepo.GetAll().ToList();
foreach (var waiterChatId in waitersChatIds)
{
TelegramClient.SendTextMessageAsync(waiterChatId, $"You're Number {waitersChatIds.IndexOf(waiterChatId) + 1} In Queue.",
replyMarkup: StateManager.GetCustomerReplyKeyboardMarkup(customer));
}
}
public virtual async Task SendMessageToChannelTest()
{
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TLDialogs dialogs = (TLDialogs)await client.GetUserDialogsAsync();
TLChannel chat = dialogs.Chats
.OfType <TLChannel>()
.FirstOrDefault(c => c.Title == "TestGroup");
await client.SendMessageAsync(new TLInputPeerChannel()
{
ChannelId = chat.Id, AccessHash = chat.AccessHash.Value
}, "TEST MSG");
}
protected async Task <IActionResult> SendTextMessageAndForceReply(string TextMesage, string ForceReplyMessage)
{
try
{
if (TextMesage != null && ForceReplyMessage != null && TextMesage != "" && ForceReplyMessage != "" && !BotInfo.Configuration.BotBlocked)
{
await TelegramClient.SendTextMessageAsync(this.ChatId, TextMesage, ParseMode.Html);
return(await SendForceReplyMessage(ForceReplyMessage));
}
else
{
return(OkResult);
}
}
catch
{
return(OkResult);
}
}
/// <summary>
/// Создать иОтправить ForceReply сообщение
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
protected virtual async Task <IActionResult> SendForceReplyMessage(string text)
{
if (BotInfo.Configuration.BotBlocked)
{
await TelegramClient.SendTextMessageAsync(this.ChatId, BotBlockedMsg, ParseMode.Html);
}
if (!BotInfo.Configuration.BotBlocked && this.Update.CallbackQuery != null)
{
await AnswerCallback();
}
if (!BotInfo.Configuration.BotBlocked && await SendForceReply(text) != null)
{
return(OkResult);
}
else
{
return(OkResult);
}
}
/// <summary>
/// Подписываемся на первый канал по списку поиска
/// </summary>
/// <param name="channelList">список найденных каналов</param>
/// <returns></returns>
private async static Task <bool> JoinChannel(this TelegramClient client, TLChannel channel)
{
var ChannelInfo = channel;
var RequestJoin = new TeleSharp.TL.Channels.TLRequestJoinChannel()
{
Channel = new TLInputChannel
{
ChannelId = ChannelInfo.Id,
AccessHash = (long)ChannelInfo.AccessHash
}
};
try
{
var JoinResponse = await client.SendRequestAsync <TLUpdates>(RequestJoin);
}
catch (Exception)
{
return(false);
}
return(true);
}
public async Task Auth(string phone, string code, TelegramClient client)
{
string hash = await _loginRepository.GetHash(phone);
try
{
if (!await client.IsPhoneRegisteredAsync(phone))
{
var usu = Task.Run(() => client.SignUpAsync(phone, hash, code, "", ""));
usu.Wait();
}
var u = Task.Run(() => client.MakeAuthAsync(phone, hash, code));
u.Wait();
}
catch (FloodException flood)
{
await _loginRepository.SetLimit(Convert.ToInt32(flood.TimeToWait));
Thread.Sleep(flood.TimeToWait);
await Auth(phone, code, client);
}
}
public async Task UploadAndSendMedia()
{
var store = new FileSessionStore();
var client = new TelegramClient(store, "session", apiId, apiHash);
await client.Connect();
Assert.IsTrue(client.IsUserAuthorized());
var res = await client.ImportContactByPhoneNumber(NumberToSendMessage);
Assert.IsNotNull(res);
var file = File.ReadAllBytes("../../data/cat.jpg");
var mediaFile = await client.UploadFile("test_file.jpg", file);
Assert.IsNotNull(mediaFile);
var state = await client.SendMediaMessage(res.Value, mediaFile);
Assert.IsTrue(state);
}
protected override void Do(List <string> args)
{
var messageBuilder = new StringBuilder();
var addedSubreddits = new List <string>();
var ignoredSubreddits = new List <string>();
foreach (var subreddit in args)
{
if (User.Subreddits.Contains(subreddit))
{
ignoredSubreddits.Add(subreddit);
}
else
{
SettingsController.SettingsStore.RedditSettings.AddSubreddit(subreddit);
User.Subreddits.Add(subreddit);
addedSubreddits.Add(subreddit);
}
}
SettingsController.GetInstance().SaveSettings();
if (addedSubreddits.Any())
{
messageBuilder.Append($"Subscribed to: {string.Join(", ", addedSubreddits)}\n");
}
if (ignoredSubreddits.Any())
{
messageBuilder.Append($"Already subscribed to: {string.Join(", ", ignoredSubreddits)}");
}
SettingsController.SettingsStore.RedditSettings.WatchedSubreddits =
SettingsController.SettingsStore.RedditSettings.WatchedSubreddits
.Union(addedSubreddits).ToList();
TelegramClient.SendMessage(User.ChatId, messageBuilder.ToString());
}
/// <summary>
/// Отправить сообщение
/// </summary>
/// <param name="botMessage"></param>
/// <param name="EditMessageId"></param>
/// <param name="ReplyToMessageId"></param>
/// <returns></returns>
protected async Task <Message> SendMessage(BotMessage botMessage, int EditMessageId = 0, int ReplyToMessageId = 0, bool DisableWeb = true)
{
try
{
if (BotInfo.Configuration.BotBlocked)
{
return(await TelegramClient.SendTextMessageAsync(this.ChatId, BotBlockedMsg, ParseMode.Html, DisableWeb, false));
}
if (botMessage != null && this.Update.CallbackQuery != null && this.CallBackQueryId != null)
{
await AnswerCallback(botMessage.CallBackTitleText);
}
if (botMessage != null && EditMessageId != 0 && !BotInfo.Configuration.BotBlocked)
{
return(await TelegramClient.EditMessageTextAsync(this.ChatId, EditMessageId, botMessage.TextMessage, ParseMode.Html, true, botMessage.MessageReplyMarkup));
}
if (botMessage != null && botMessage.TextMessage != null && !BotInfo.Configuration.BotBlocked)
{
return(await TelegramClient.SendTextMessageAsync(this.ChatId, botMessage.TextMessage, ParseMode.Html, DisableWeb, false, ReplyToMessageId, botMessage.MessageReplyMarkup));
}
else
{
return(null);
}
}
catch (Exception e)
{
// await TelegramClient.SendTextMessageAsync(this.ChatId, botMessage.TextMessage, ParseMode.Html, false, false, ReplyToMessageId, botMessage.MessageReplyMarkup);
return(null);
}
}
private void HandleTextMessage(Update update, SubscriberRecord subscriberRecord)
{
switch (update.Message.Text)
{
case Keyboards.BroadcastCommand:
if (IsAdmin(subscriberRecord))
{
TelegramClient.SendTextMessageAsync(subscriberRecord.ChatId,
"پیام مورد نظر را برای انتشار ارسال کنید.",
replyMarkup: Keyboards.FlushMarkup, disableNotification: true);
_broadcastingSubscriberChatId = subscriberRecord.ChatId;
}
break;
case Keyboards.StartCommand:
const string defaultWelcomeMessage = "1.عکس ها را بفرستید\n2.دکمه را بزنید";
TelegramClient.SendTextMessageAsync(subscriberRecord.ChatId, defaultWelcomeMessage,
replyMarkup: Keyboards.FlushMarkup);
break;
case Keyboards.FlushCommand:
try
{
Flush(update, subscriberRecord);
}
catch (Exception exception)
{
var baseException = exception.GetBaseException();
Logger.LogError(baseException, "Error in Flush: {Message} -> {StackTrace}", baseException.Message, baseException.StackTrace);
}
break;
default:
TelegramClient.SendTextMessageAsync(subscriberRecord.ChatId, $"متوجه پیام نشدم.",
replyMarkup: Keyboards.FlushMarkup);
break;
}
}
