private void button2_Click(object sender, EventArgs e)
{
bool success = NewApi.getKernelAuth().setAuthCode(VerfyCodeT.Text);
if (success)
{
BotStatus = LoginStatus.ALREADYLOGGED;
}
if (BotStatus == LoginStatus.ALREADYLOGGED)
{
IsConnected = true;
TLNearestDc dcInfo = (TLNearestDc)NewApi.Api().doRpcCallNonAuth(new TLRequestHelpGetNearestDc());
NewApi.Api().switchToDc(dcInfo.getNearestDc());
Api = NewApi.Api();
NotifyBar.Text = "فعال " + "(" + PhoneNumT.Text + ")";
NotifyBar.ForeColor = Color.Green;
ConnectB.BackColor = Color.Red;
ConnectB.Text = "قطع اتصال";
MessageTB.Enabled = true;
SendMessageB.Enabled = true;
VerfyCodeB.Enabled = false;
VerfyCodeT.Enabled = false;
}
else
{
NotifyBar.Text = "شکست در فعالسازی (" + BotStatus + ")";
NotifyBar.ForeColor = Color.Red;
IsConnected = false;
//throw new Exception("Failed to log in: " + BotStatus);
}
}
public SignalsService(TelegramApi telegram, ILogger <SignalsService> logger, IServiceProvider serviceProvider)
{
_telegram = telegram;
_logger = logger;
_serviceProvider = serviceProvider;
_signalWatches = new ConcurrentDictionary <string, SignalRunner>();
}
protected override void ProcessComplete(long chatId)
{
var path = Shell.GetPath(Path);
if (File.Exists(path))
{
Task.Run(() =>
{
try
{
using (var stream = File.OpenRead(path))
{
var filename = System.IO.Path.GetFileName(path);
var fileToSend = new FileToSend(filename, stream);
TelegramApi.SendDocumentAsync(chatId, fileToSend).Wait();
}
}
catch (Exception ex)
{
TelegramApi.SendTextMessageAsync(chatId, "File sending error: " + ex.Message);
}
finally
{
Session.Exit(this);
}
});
}
else
{
TelegramApi.SendTextMessageAsync(chatId, "File " + path + " not exists");
Session.Exit(this);
}
}
public override void OnStart(Message msg)
{
try
{
var sb = new StringBuilder();
sb.AppendLine("Processes:");
var needClean = false;
lock (Shell.ProcessTable.LockObject)
{
foreach (var proc in Shell.ProcessTable.Table)
{
var workingStr = proc.Value.Working ? "working" : "not working";
sb.AppendLine($"{proc.Key} - {proc.Value.Path} - {workingStr}");
if (!proc.Value.Working)
{
needClean = true;
}
}
}
var listTask = TelegramApi.SendTextMessageAsync(msg.Chat.Id, sb.ToString());
if (needClean)
{
listTask.ContinueWith(x => TelegramApi.SendTextMessageAsync(msg.Chat.Id, "/pclean - to clean not working processes"));
}
}
finally
{
Session.Exit(this);
}
}
private async void metroButton8_Click(object sender, EventArgs e)
{
if (String.IsNullOrWhiteSpace(metroTextBox10.Text))
{
return;
}
metroButton8.Enabled = false;
metroButton10.Enabled = false;
_chatId = 0;
label4.Text = null;
_chatId = await TelegramApi.GetChatIdViaUsername(metroTextBox10.Text);
if (_chatId != 0)
{
label4.Text = @"Deine Chat Id lautet " + _chatId + @".";
label4.ForeColor = Color.Green;
metroButton10.Enabled = true;
}
else
{
label4.Text = @"Deine Chat Id konnte nicht gefunden werden. Bitte wiederhole den vorgang oder Kontakte den Entwickler.";
label4.ForeColor = Color.Red;
}
metroButton8.Enabled = true;
}
public virtual void InitProcess(long chatId)
{
if (ExecProcess != null)
{
return;
}
try
{
ExecProcess = new Process();
ExecProcess.StartInfo = new ProcessStartInfo();
ExecProcess.StartInfo.WorkingDirectory = Shell.CurrentDirectory;
ExecProcess.StartInfo.UseShellExecute = false;
ExecProcess.StartInfo.RedirectStandardInput = true;
ExecProcess.StartInfo.RedirectStandardOutput = true;
ExecProcess.StartInfo.RedirectStandardError = true;
ExecProcess.StartInfo.FileName = Path;
ExecProcess.StartInfo.Arguments = Arguments;
ExecProcess.Start();
ExecProcess.StandardInput.AutoFlush = true;
Task.Run(() => BeginProxy(chatId, ExecProcess.StandardOutput, ExecProcess.StandardError));
}
catch (Exception ex)
{
Session.Exit(this);
TelegramApi.SendTextMessageAsync(chatId, "Exec error: " + ex.Message);
}
}
static void Main(string[] args)
{
Playlists = System.IO.File.ReadAllLines(@"D:\PROGRAMMING\C#\Univer_Project\Telegram-BOT-HELPER\playlists.txt");
var Quotes_data = System.IO.File.ReadAllText(@"D:\PROGRAMMING\C#\Univer_Project\Telegram-BOT-HELPER\quotes.json", System.Text.Encoding.UTF8);
Quotes = JsonConvert.DeserializeObject <List <Dictionary <string, string> > >(Quotes_data);
var API = new TelegramApi();
while (true)
{
var Updates = API.GetUpdates();
foreach (var update in Updates)
{
var Question = update.message.text;
var Answer = AnswerQuestion(Question);
API.sendMessage(Answer, update.message.chat.id);
}
}
Console.ReadKey();
}
public override void Process(Message msg)
{
if (WaitingSaveCheck)
{
if (msg.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
{
var text = msg.Text.ToLower();
if (text == "cancel")
{
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Canceled");
Session.Exit(this);
}
else if (text == "ok")
{
Task.Run(() => StreamUploader(msg.Chat.Id, FileId, Path));
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Uploading file...");
WaitingSaveCheck = false;
}
else
{
SendSaveQuestion(msg.Chat.Id);
}
return;
}
else
{
}
}
else
{
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Uploading file...");
}
}
public ActionResult Create(CreateVacancyView model)
{
if (model.Phone.Last() == '_')
{
ModelState.AddModelError("Phone", "Кажется, Вы неверно ввели телефон :(");
}
if (ModelState.IsValid)
{
//mapping
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CreateVacancyView, Vacancy>()
.ForMember(dest => dest.Id, opt => opt.UseValue(Guid.NewGuid()))
.ForMember(dest => dest.Premoderated, opt => opt.UseValue(false))
.ForMember(dest => dest.Created, opt => opt.UseValue(DateTime.Now));
});
IMapper mapper = config.CreateMapper();
Vacancy vacancy = mapper.Map <Vacancy>(model);
manager.AddVacancy(vacancy);
//send notification to telegram
var urlToCheck = Request.Url.Scheme + System.Uri.SchemeDelimiter + Request.Url.Host + (Request.Url.IsDefaultPort ? "" : ":" + Request.Url.Port) + Url.Action("Vacancies", "Check");
TelegramApi api = new TelegramApi();
api.SendNotification("*Новая вакансия*\r\n[Перейти](" + urlToCheck + ")");
return(RedirectToAction("Success", "Home"));
}
else
{
return(View(model));
}
}
public override void Execute()
{
using (AppDbContext db = new AppDbContext())
{
Program.Logger.Debug($"{GetType().Name}: Searching user with TelegramId: {Message.From.Id} in database");
var user = db.GetUserByTelegramId(Message.From.Id);
if (user == null)
{
user = new User
{
TelegramUserId = Message.From.Id,
FirstName = Message.From.FirstName,
LastName = Message.From.LastName,
Username = Message.From.Username
};
Program.Logger.Info($"{GetType().Name}: {user} is new User");
Program.Logger.Debug($"{GetType().Name}: Adding user {user} to database");
db.Users.Add(user);
}
else
{
Program.Logger.Debug($"{GetType().Name}: User {user} is already exist");
}
Program.Logger.Debug($"{GetType().Name}: Subscribing {user} to all shows");
var subscriptions = user.Subscriptions.ToList();
foreach (Show show in db.Shows)
{
Subscription subscription = new Subscription
{
User = user,
Show = show,
SubscriptionDate = DateTime.Now
};
if (subscriptions.Any(s => Equals(s.Show, show)))
{
continue;
}
db.Subscriptions.Add(subscription);
}
Program.Logger.Debug($"{GetType().Name}: Saving changes to database");
db.SaveChanges();
}
Program.Logger.Debug($"{GetType().Name}: Sending response to {Message.From}");
try
{
TelegramApi.SendMessage(Message.From, "Вы, братишка, подписаны на все сериалы");
}
catch (Exception e)
{
throw new Exception($"{GetType().Name}: An error occurred while sending response to {Message.From}", e);
}
Status = true;
}
public override void Process(Message msg)
{
if (string.IsNullOrWhiteSpace(msg.Text))
{
if (TempKey == null)
{
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Waiting..");
}
else
{
SendQuestion(msg.Chat.Id, TempKey.Value);
}
}
else
{
if (TempKey == null)
{
if (msg.Text == "/cancel")
{
Session.Exit(this);
}
else
{
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Waiting..");
}
}
else
{
ProcessAnswer(TempKey.Value, msg.Text);
TempKey = null;
ProcessNext(msg.Chat.Id);
}
}
}
private void SendSaveQuestion(long chatId)
{
WaitingSaveCheck = true;
var buttons = new string[] { "OK", "Cancel" }.Select(x => new KeyboardButton(x)).Select(x => new KeyboardButton[] { x }).ToArray();
var keyboard = new ReplyKeyboardMarkup(buttons, oneTimeKeyboard: true);
TelegramApi.SendTextMessageAsync(chatId, "File " + Path + " already exist", replyMarkup: keyboard);
}
protected virtual void SendQuestion(long chatId, KeyValuePair <string, string> key)
{
var variants = ListVariants(key);
var buttons = variants.Select(x => new KeyboardButton(x)).Select(x => new KeyboardButton[] { x }).ToArray();
var keyboard = new ReplyKeyboardMarkup(buttons, oneTimeKeyboard: true);
TelegramApi.SendTextMessageAsync(chatId, key.Value, replyMarkup: keyboard);
}
public override void Process(Message msg)
{
lock (AuthSet)
{
AuthSet.Add(msg.Chat.Id);
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Auth success").Wait();
}
}
//--Allgemeines ENDE
//--Feedback START
private async void metroTile2_Click(object sender, EventArgs e)
{
if (metroComboBox5.SelectedIndex == -1)
{
MetroMessageBox.Show(this,
"Feedback konnte nicht gesendet werden.\nAuswahl Fehlt", "Feedback Fehlgeschlagen", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (String.IsNullOrWhiteSpace(metroTextBox3.Text))
{
MetroMessageBox.Show(this,
"Feedback konnte nicht gesendet werden.\nBetreff Leer", "Feedback Fehlgeschlagen", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (String.IsNullOrWhiteSpace(metroTextBox2.Text))
{
MetroMessageBox.Show(this,
"Feedback konnte nicht gesendet werden.\nNachricht Leer", "Feedback Fehlgeschlagen", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
string subject = null;
switch (metroComboBox5.SelectedIndex)
{
case 0:
subject = "[PROBLEM] " + metroTextBox3.Text;
break;
case 1:
subject = "[VORSCHLAG] " + metroTextBox3.Text;
break;
case 2:
subject = "[SONSTIGES] " + metroTextBox3.Text;
break;
}
string body = metroTextBox2.Text + "\n";
if (!String.IsNullOrWhiteSpace(metroTextBox11.Text))
{
body += "\nEmail: " + metroTextBox11.Text;
}
if (!String.IsNullOrWhiteSpace(metroTextBox12.Text))
{
body += "\nTelegram: " + metroTextBox12.Text;
}
metroComboBox5.Enabled = metroTextBox3.Enabled =
metroTextBox2.Enabled = metroTextBox4.Enabled = metroButton6.Enabled = metroTextBox11.Enabled = metroTextBox12.Enabled = metroTile2.Enabled = false;
metroProgressSpinner1.Visible = true;
await TelegramApi.SendFeedbackMessage(subject, body, metroTextBox4.Text);
metroComboBox5.Enabled = metroTextBox3.Enabled =
metroTextBox2.Enabled = metroTextBox4.Enabled = metroButton6.Enabled = metroTextBox11.Enabled = metroTextBox12.Enabled = metroTile2.Enabled = true;
metroProgressSpinner1.Visible = false;
}
public SignalRunner(ILogger <SignalRunner> logger, BinanceApi binanceApi, StrategyFactory strategyFactory, TelegramApi telegram)
{
_logger = logger;
_binanceApi = binanceApi;
_strategyFactory = strategyFactory;
_telegram = telegram;
_candles = new Dictionary <long, Candle>();
_cancellationTokenSource = new CancellationTokenSource();
}
static void Notify(string message)
{
Console.WriteLine(message);
TelegramApi.SendMessage(
Environment.GetEnvironmentVariable("TELEGRAM_KEY"),
Environment.GetEnvironmentVariable("TELEGRAM_CHAT"),
message
);
}
public void AddingSomeoneElsesBirthdayWhileNotAnAdminDoesNotAddBirthday()
{
var api = new TelegramApi("", "");
var birthdays = new Birthdays(new List <Birthday>(), api, Mock.Of <IFileWriter>());
var sut = new TelegramMessageHandler(api, birthdays, new AdminManager());
var json = CreateTelegramUpdateDto("/birthadd tempo 01-01", "EriK", "AnyChat", 139);
sut.HandleMessage(json);
Assert.Empty(birthdays);
}
private async void metroButton10_Click(object sender, EventArgs e)
{
if (_chatId == 0)
{
return;
}
metroButton10.Enabled = false;
await TelegramApi.SendMessage(_chatId.ToString(), "Wenn du diese Nachricht erhälst hast du alles richtig Konfiguriert ;-)");
metroButton10.Enabled = true;
}
private async void metroButton10_Click(object sender, EventArgs e)
{
if (String.IsNullOrWhiteSpace(metroTextBox9.Text))
{
return;
}
metroButton10.Enabled = false;
await TelegramApi.SendMessage(metroTextBox9.Text,
"Wenn du diese Nachricht erhälst hast du alles richtig Konfiguriert ;-)");
metroButton10.Enabled = true;
}
public override void OnStart(Message msg)
{
try
{
Shell.ProcessTable.CleanUp(false);
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Clean up complete");
}
finally
{
Session.Exit(this);
}
}
private void SendResponse(string response)
{
Program.Logger.Debug($"{GetType().Name}: Sending response to {Message.From}");
try
{
TelegramApi.SendMessage(Message.From, response);
}
catch (Exception e)
{
throw new Exception($"{GetType().Name}: An error occurred while sending response to {Message.From}", e);
}
}
protected override void ProcessComplete(long chatId)
{
try
{
var path = Shell.GetPath(Path);
Shell.CurrentDirectory = path;
TelegramApi.SendTextMessageAsync(chatId, Shell.CurrentDirectory);
}
finally
{
Session.Exit(this);
}
}
public override void Execute()
{
Program.Logger.Debug($"{GetType().Name}: Sending help message to {Message.From}");
try
{
TelegramApi.SendMessage(Message.From, string.Format(HelpTemplate, Message.From.FirstName));
}
catch (Exception e)
{
throw new Exception($"{GetType().Name}: An error occurred while sending help message to {Message.From}", e);
}
Status = true;
}
public override void Execute()
{
Program.Logger.Debug($"{GetType().Name}: Sending message to {Message.From}");
try
{
TelegramApi.SendMessage(Message.From, "Пощади, братишка");
}
catch (Exception e)
{
throw new Exception($"{GetType().Name}: An error occurred while sending message to {Message.From}", e);
}
Status = true;
}
public void AddingYourOwnBirthdayDoesNotRequireBeingAnAdmin()
{
var api = new TelegramApi("", "");
var birthdays = new Birthdays(new List <Birthday>(), api, Mock.Of <IFileWriter>());
var sut = new TelegramMessageHandler(api, birthdays, new AdminManager());
var json = CreateTelegramUpdateDto("/birthadd erik 01-01", "EriK", "EriK", 139);
sut.HandleMessage(json);
Assert.Contains(birthdays, b =>
b.Human.Equals("erik", StringComparison.InvariantCultureIgnoreCase) &&
b.Date.Day == 1 &&
b.Date.Month == 1);
}
private static void StartPolling(TelegramApi api)
{
Logger.Debug("Starting polling");
Task pollingTask = api.StartPolling();
pollingTask.ContinueWith(
e =>
{
Logger.Error(e.Exception, "An error occurred while retrieving updates");
Thread.Sleep(retryPollingDelay);
StartPolling(api);
},
TaskContinuationOptions.OnlyOnFaulted);
}
private static void Load()
{
Console.WriteLine("Dates are specified in the format MM-DD");
LoadConfig();
_messagingApi = new TelegramApi(Config.Token, Config.ChatId);
Console.WriteLine($"Using {_messagingApi.GetType().Name}");
_birthdays = Birthdays.Load(_messagingApi);
var messageHandler = new TelegramMessageHandler(_messagingApi, _birthdays, _adminManager);
_messagingApi.AddHandler(messageHandler);
ExitHandlers.Add(_birthdays);
ExitHandlers.Add(messageHandler);
}
public override void OnStart(Message msg)
{
try
{
var args = Helpers.Ext.ParseArgs(msg.Text);
ProcessStartArgs(msg, args);
ProcessNext(msg.Chat.Id);
}
catch (Exception ex)
{
Session.Exit(this);
TelegramApi.SendTextMessageAsync(msg.Chat.Id, "Error: " + ex.Message);
}
finally
{
}
}
public void AddingSomeoneElsesBirthdayWhileAnAdminDoesAddBirthday()
{
var api = new TelegramApi("", "");
var birthdays = new Birthdays(new List <Birthday>(), api, Mock.Of <IFileWriter>());
var adminManager = new AdminManager(new List <string> {
"erik"
});
var sut = new TelegramMessageHandler(api, birthdays, adminManager);
var json = CreateTelegramUpdateDto("/birthadd tempo 12-15", "EriK", "AnyChat", 139);
sut.HandleMessage(json);
Assert.Contains(birthdays, b =>
b.Human.Equals("tempo", StringComparison.InvariantCultureIgnoreCase) &&
b.Date.Day == 15 &&
b.Date.Month == 12);
}
private static Command GetCommand(TelegramApi tg, Message message)
{
string commandTitle;
try
{
commandTitle = CommandRegex.Match(message.Text).Groups[1].Value;
}
catch (Exception e)
{
Logger.Error(e, "An error occurred while parsing command title");
return null;
}
Logger.Debug($"Creating command object for '{message.Text}'");
var command = Command.CreateCommand(commandTitle);
Logger.Info($"Received {command.GetType().Name} from " +
$"{message.From}");
command.TelegramApi = tg;
command.Message = message;
return command;
}
override public void onAuthCancelled(TelegramApi telegramApi) {
MessageBox.Show("onAuthCancelled");
}
protected Command(TelegramApi telegramApi, Message message)
{
Status = false;
TelegramApi = telegramApi;
Message = message;
}
public Notifier(TelegramApi telegramApi)
{
this.telegramApi = telegramApi;
}
public ShowsCommand(TelegramApi telegramApi, Message message)
: base(telegramApi, message)
{
}
static void Main()
{
Logger.Info($"HousewifeBot started: {Assembly.GetEntryAssembly().Location}");
if (!LoadSettings())
{
return;
}
TelegramApi tg = new TelegramApi(_token);
try
{
Logger.Debug("Executing GetMe");
var botUser = tg.GetMe();
Logger.Debug($"GetMe returned {botUser}");
}
catch (Exception e)
{
Logger.Error("GetMe failed");
Logger.Error(e);
return;
}
Database.SetInitializer(new MigrateDatabaseToLatestVersion<AppDbContext, DAL.Migrations.Configuration>());
Notifier notifier = new Notifier(tg);
var updateNotificationsTask = new Task(
() =>
{
while (true)
{
notifier.UpdateNotifications();
Thread.Sleep(_updateNotificationsInterval);
}
}
);
updateNotificationsTask.Start();
var sendEpisodesNotificationsTask = new Task(
() =>
{
while (true)
{
notifier.SendEpisodesNotifications();
Thread.Sleep(_sendNotificationsInterval);
}
}
);
var sendShowsNotificationsTask = new Task(
() =>
{
while (true)
{
notifier.SendShowsNotifications();
Thread.Sleep(_sendShowNotificationsInterval);
}
});
sendEpisodesNotificationsTask.Start();
sendShowsNotificationsTask.Start();
var processingCommandUsers = new ConcurrentDictionary<User, bool>();
Regex commandRegex = new Regex(@"(/\w+)\s*");
StartPolling(tg);
while (true)
{
foreach (var update in tg.Updates)
{
if (processingCommandUsers.ContainsKey(update.Key) &&
processingCommandUsers[update.Key])
{
continue;
}
if (update.Value.Count == 0)
{
continue;
}
Message message;
update.Value.TryDequeue(out message);
Logger.Debug($"Received message '{message.Text}' from " +
$"{message.From}");
string commandTitle;
try
{
commandTitle = commandRegex.Match(message.Text).Groups[1].Value;
}
catch (Exception e)
{
Logger.Error(e, "An error occurred while parsing command title");
continue;
}
Logger.Debug($"Creating command object for '{message.Text}'");
var command = Command.CreateCommand(commandTitle);
Logger.Info($"Received {command.GetType().Name} from " +
$"{message.From}");
command.TelegramApi = tg;
command.Message = message;
Logger.Debug($"Executing {command.GetType().Name}");
processingCommandUsers[update.Key] = true;
Task commandTask = Task.Run(() =>
{
try
{
command.Execute();
}
catch (Exception e)
{
Logger.Error($"An error occurred while executing {command.GetType().Name}.\n" +
$"Message: {command.Message.Text}\n" +
$"Arguments: {command.Arguments}\n" +
$"User: {command.Message.From}");
Logger.Error(e);
}
}
);
commandTask.ContinueWith(task =>
{
processingCommandUsers[update.Key] = false;
Logger.Debug($"{command.GetType().Name} from " +
$"{message.From} {(command.Status ? "succeeded" : "failed")}");
});
}
Thread.Sleep(200);
}
}
private static void StartPolling(TelegramApi tgApi)
{
Logger.Debug("Starting polling");
Task pollingTask = tgApi.StartPolling();
pollingTask.ContinueWith(e =>
{
Logger.Error(e.Exception, "An error occurred while retrieving updates");
Thread.Sleep(_retryPollingDelay);
StartPolling(tgApi);
},
TaskContinuationOptions.OnlyOnFaulted);
}
private static void StartPolling(TelegramApi tgApi)
{
//Logger.Debug("Starting polling");
Task pollingTask = tgApi.StartPolling();
pollingTask.ContinueWith(e =>
{
//Logger.Error(e.Exception, "An error occurred while retrieving updates");
new Timer(o =>
{
StartPolling(tgApi);
}, null, _retryPollingDelay, -1);
},
TaskContinuationOptions.OnlyOnFaulted);
}
static void Main(string[] args)
{
TelegramApi telegram = new TelegramApi(_token);
try
{
Console.WriteLine("Executing GetMe");
var botUser = telegram.GetMe();
Console.WriteLine("GetMe returned \n" + botUser.ToString());
}
catch (Exception e)
{
Console.WriteLine("GetMe failed");
Console.WriteLine(e.Message);
return;
}
using (var db = new AppDbContext())
{
db.SaveChanges();
var query = from b in db.Suggestions
orderby b.Id
select b;
Console.WriteLine("All suggestions:");
foreach (var item in query)
{
Console.WriteLine(item.Id + " " + item.Text);
}
//Console.ReadKey();
}
/*
ReplyKeyboardMarkup replyKB = new ReplyKeyboardMarkup();
replyKB.Keyboard = new string[][]
{
new string[] {"Yes","No"}
};
replyKB.OneTimeKeyboard = false;
replyKB.ResizeKeyboard = false;
replyKB.Selective = false;*/
//string json = JsonConvert.SerializeObject(replyKB);
StartPolling(telegram);
var processingCommandUsers = new ConcurrentDictionary<Telegram.User, bool>();
Regex commandRegex = new Regex(@"(/\w+)\s*");
while (true)
{
foreach (var update in telegram.Updates)
{
if (processingCommandUsers.ContainsKey(update.Key) &&
processingCommandUsers[update.Key])
{
continue;
}
if (update.Value.Count == 0)
{
continue;
}
Message message;
update.Value.TryDequeue(out message);
/*Logger.Debug($"Received message '{message.Text}' from " +
$"{message.From.FirstName} {message.From.LastName}");*/
string commandTitle = commandRegex.Match(message.Text).Groups[1].Value;
/*ReplyKeyboardMarkup replyKeyboard = new ReplyKeyboardMarkup() {Keyboard = new string[][] {
new string[] {"Yes","No"}
},
OneTimeKeyboard = true
};*/
string testText = message.Text;
Console.WriteLine("Received a message: " + testText);
//Logger.Debug($"Creating command object for '{commandTitle}'");
var command = Command.CreateCommand(commandTitle);
//Logger.Info($"Received {command.GetType().Name} from " +
// $"{message.From.FirstName} {message.From.LastName}");
command.TelegramApi = telegram;
command.Message = message;
//Logger.Debug($"Executing {command.GetType().Name}");
processingCommandUsers[update.Key] = true;
try
{
// telegram.SendMessage(message.From, testText, replyKeyboard);
// telegram.SendMessage(message.From, " ", replyKeyboard);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
Task commandTask = Task.Run(() =>
{
try
{
command.Execute();
}
catch (Exception e)
{
/*Logger.Error($"An error occurred while executing {command.GetType().Name}.\n" +
$"Message: {command.Message.Text}\n" +
$"Arguments: {command.Arguments}\n" +
$"User: {command.Message.From}");
Logger.Error(e);*/
Console.WriteLine(e.Message);
}
}
);
commandTask.ContinueWith(task =>
{
processingCommandUsers[update.Key] = false;
/*Logger.Debug($"{command.GetType().Name} from " +
$"{message.From.FirstName} {message.From.LastName} {(command.Status ? "succeeded" : "failed")}");*/
});
}
Thread.Sleep(200);
}
}
override public void onUpdatesInvalidated(TelegramApi api) {
MessageBox.Show("onUpdatesInvalidated");
}
public Notifier(TelegramApi telegramApi)
{
TelegramApi = telegramApi;
}
private static void Main()
{
Logger.Info($"HousewifeBot started: {Assembly.GetEntryAssembly().Location}");
if (!LoadSettings())
{
return;
}
TelegramApi tg = new TelegramApi(token);
try
{
Logger.Debug("Executing GetMe");
var botUser = tg.GetMe();
Logger.Debug($"GetMe returned {botUser}");
}
catch (Exception e)
{
Logger.Error("GetMe failed");
Logger.Error(e);
return;
}
Database.SetInitializer(new MigrateDatabaseToLatestVersion<AppDbContext, DAL.Migrations.Configuration>());
Notifier notifier = new Notifier(tg);
StartUpdateNotificationsTask(notifier);
StartSendEpisodesNotificationsTask(notifier);
StartSendShowsNotificationsTask(notifier);
var processingCommandUsers = new ConcurrentDictionary<User, bool>();
StartPolling(tg);
while (true)
{
foreach (var update in tg.Updates)
{
if (processingCommandUsers.ContainsKey(update.Key) &&
processingCommandUsers[update.Key])
{
continue;
}
if (update.Value.Count == 0)
{
continue;
}
Message message;
update.Value.TryDequeue(out message);
Logger.Debug($"Received message '{message.Text}' from {message.From}");
var command = GetCommand(tg, message);
if (command == null)
{
continue;
}
Logger.Debug($"Executing {command.GetType().Name}");
processingCommandUsers[update.Key] = true;
var commandTask = StartCommandTask(command);
commandTask.ContinueWith(task =>
{
processingCommandUsers[update.Key] = false;
Logger.Debug($"{command.GetType().Name} from {message.From} {(command.Status ? "succeeded" : "failed")}");
});
}
Thread.Sleep(200);
}
}
public BrowseCommand(TelegramApi telegramApi, Message message)
: base(telegramApi, message)
{
}
public abstract void onAuthCancelled(TelegramApi api);
public abstract void onUpdatesInvalidated(TelegramApi api);
