static void Main(string[] args)
{
TelegramRequest Tr = new TelegramRequest();
Tr.ResponseReceived += Tr_ResponseReceived;
Tr.GetUpdates();
}
public void Start()
{
logger.Info("Starting bot");
TelegramRequest Tr = new TelegramRequest(MainSettings.Default.Token, MainSettings.Default.API_URL);
Tr.MessageText += Tr_MessageText;
Tr.MessageSticker += Tr_MessageSticker;
Tr.MessagePhoto += Tr_MessagePhoto;
Tr.MessageVideo += Tr_MessageVideo;
Tr.MessageDocument += Tr_MessageDocument;
Tr.MessageLocation += Tr_MessageLocation;
Tr.MessageContact += Tr_MessageContact;
Tr.MessageVoice += Tr_MessageVoice;
DBAPI Db = new DBAPI(MainSettings.Default.DB_DataSource, MainSettings.Default.DB_UserID, MainSettings.Default.DB_Password, MainSettings.Default.DB_InitialCatalog);
Db.RegTransactionEvent += RegisterTransaction;
logger.Info("Connection to DB");
Db.Connect();
logger.Info("Start pooling telegram API");
Tr.GetUpdates();
//Console.ReadLine();
}
/// <summary>
/// Send UptimeRobot uptime notification to Telegram
/// </summary>
/// <param name="uptimeRobotAlert"></param>
/// <returns></returns>
public async Task <bool> TrySendUptimeRobotAlert(UptimeRobotAlert uptimeRobotAlert)
{
try
{
var message = "";
// Down
if (uptimeRobotAlert.AlertType == UptimeRobotAlert.AlertTypes.Down)
{
message = $"<b>{uptimeRobotAlert.FriendlyName}</b> has gone <strong>{uptimeRobotAlert.AlertTypeFriendlyName.ToUpper()}</strong>\n";
}
// Up
else if (uptimeRobotAlert.AlertType == UptimeRobotAlert.AlertTypes.Up)
{
message = $"<b>{uptimeRobotAlert.FriendlyName}</b> is now <strong>{uptimeRobotAlert.AlertTypeFriendlyName.ToUpper()}</strong>\nDown for: <b>{uptimeRobotAlert.AlertDuration} seconds</b>\n";
}
message += (!string.IsNullOrEmpty(uptimeRobotAlert.Url)) ? $"Target: {uptimeRobotAlert.Url}\n" : "";
message += (!string.IsNullOrEmpty(uptimeRobotAlert.AlertDetails)) ? $"Details: {uptimeRobotAlert.AlertDetails}\n" : "";
var telegramRequest = new TelegramRequest(_telegramSettings.TelegramChannel, "HTML", message);
var telegramResponse = await _httpClient.PostAsync(new Uri($"{_telegramSettings.TelegramUrl}/bot{_telegramSettings.Token}/sendMessage"), new StringContent(JsonConvert.SerializeObject(telegramRequest), Encoding.UTF8, "application/json"));
return(telegramResponse.IsSuccessStatusCode);
}
catch (Exception e)
{
_logger.Error(e, "Got an exception while sending UptimeRobot alert to Twitter");
return(false);
}
}
public Task Process(TelegramRequest request)
{
// Log
// Answer properly
return(Task.FromResult(0));
}
private async Task ValidateRequestAsync <TResult>(IRequest <TResult> request, Command command, CustomContext context)
{
IClientApi client = await _telegramService.BuildAsync(command.UserId);
var result = (await TelegramRequest.HandleAsync(() =>
{
return(client.CustomRequestsService.SendRequestAsync(request));
}, context));
}
public async Task <Result> HandleAsync(Query query)
{
IClientApi client = await _telegramService.BuildAsync(query.UserId);
TUserFull result = await TelegramRequest.HandleAsync(() =>
{
return(client.UsersService.GetCurrentUserFullAsync());
});
return(new Result(result.User.As <TUser>()));
}
public async Task <bool> HandleAsync(Query query)
{
IClientApi client = await _telegramService.BuildAsync(query.UserId);
await TelegramRequest.HandleAsync(() =>
{
return(client.AuthService.LogoutAsync());
});
return(true);
}
public async Task <string> HandleAsync(Query query)
{
string hashedPhoneId = HashHelper.GetHash(query.PhoneNumber);
IClientApi client = await _telegramService.BuildAsync(hashedPhoneId).ConfigureAwait(false);
ISentCode result = await TelegramRequest.HandleAsync(() =>
{
return(client.AuthService.SendCodeAsync(query.PhoneNumber));
}).ConfigureAwait(false);
return(result.PhoneCodeHash);
}
/// <summary>
/// Send pidns query statistics to Telegram
/// </summary>
/// <param name="totalDnsRequests"></param>
/// <param name="totalAdsBlocked"></param>
/// <param name="printableTimeSpan"></param>
/// <returns></returns>
public async Task <bool> TrySendPiDnsStatistics(long totalDnsRequests, long totalAdsBlocked, string printableTimeSpan)
{
try
{
var message = $"During the last {printableTimeSpan}, <a href=\"https://pi-dns.com\">pi-dns.com</a> have served <b>{totalDnsRequests.ToString("n0", new CultureInfo("en-US"))}</b> DNS requests and blocked <b>{totalAdsBlocked.ToString("n0", new CultureInfo("en-US"))}</b> ads!";
var telegramRequest = new TelegramRequest(_telegramSettings.TelegramChannel, "HTML", message);
var telegramResponse = await _httpClient.PostAsync($"{_telegramSettings.TelegramUrl}/bot{_telegramSettings.Token}/sendMessage", new StringContent(JsonConvert.SerializeObject(telegramRequest), Encoding.UTF8, "application/json"));
return(telegramResponse.IsSuccessStatusCode);
}
catch (Exception e)
{
_logger.Error(e, "Got an exception while sending pidns statistics alert to Telegram");
return(false);
}
}
public async Task <TUser> HandleAsync(Query query)
{
string hashedPhoneId = HashHelper.GetHash(query.PhoneNumber);
IClientApi client = await _telegramService.BuildAsync(hashedPhoneId).ConfigureAwait(false);
var sentCode = new TSentCode()
{
PhoneCodeHash = query.SentCode
};
TUser result = await TelegramRequest.HandleAsync(() =>
{
return(client.AuthService.SignInAsync(query.PhoneNumber, sentCode, query.Code));
}).ConfigureAwait(false);
return(result);
}
public async Task <bool> HandleAsync(Query query)
{
IClientApi client = await _telegramService.BuildAsync(query.UserId);
byte[] result = (await TelegramRequest.HandleAsync(() =>
{
return(client.FileService.DownloadFullFileAsync(query.Location));
}));
return(true);
//return new FileInfo()
//{
// Content = result,
// Name = _guidService.New().ToString("n")
//};
}
public async Task <List <Chat> > HandleAsync(Query query)
{
IClientApi client = await _telegramService.BuildAsync(query.UserId);
TDialogs result = (await TelegramRequest.HandleAsync(() =>
{
return(client.MessagesService.GetUserDialogsAsync());
})).As <TDialogs>();
var chats = new List <Chat>();
foreach (IChat chat in result.Chats)
{
chats.AddWhenNotNull(ChatParser.ParseChat(chat));
}
return(chats);
}
public async Task ForPeer(int id, PeerType peerType, string userId, int offset, int maxId)
{
IInputPeer peer = GetPeer(id, peerType);
IClientApi client = await _telegramService.BuildAsync(userId);
IMessages history = await TelegramRequest.HandleAsync(() =>
{
return(client.MessagesService.GetHistoryAsync(peer, offset, maxId, 100));
});
List <Message> messages = MessagesParser.Parse(history, id, peerType);
await _eventHub.SendAsync(messages);
if (messages.Count > 0)
{
BackgroundJob.Schedule <GetMessages>(
job => job.ForPeer(id, peerType, userId, offset + 100, 0),
TimeSpan.FromSeconds(_randomService.Random.Next(5, 20)));
}
}
/// <summary>
/// Send HetrixTools uptime notification to Telegram
/// </summary>
/// <param name="hetrixToolsAlert"></param>
/// <returns></returns>
public async Task <bool> TrySendHetrixToolsAlert(HetrixToolsAlert hetrixToolsAlert)
{
try
{
var message = "";
// Down
if (hetrixToolsAlert.Monitor_status == HetrixToolsAlert.MonitorStatus.Offline)
{
message = $"<b>{hetrixToolsAlert.Monitor_name}</b> has gone <strong>{hetrixToolsAlert.Monitor_status.ToUpper()}</strong>\nTarget: <b>{hetrixToolsAlert.Monitor_target}</b>\nMonitor Type: {hetrixToolsAlert.Monitor_type}\nMonitor Reports: \n";
foreach (var obj in hetrixToolsAlert.Monitor_errors.GetType()
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(p => !p.GetIndexParameters().Any())
.Where(p => p.CanRead && p.CanWrite))
{
var value = obj.GetValue(hetrixToolsAlert.Monitor_errors, null);
if (value != null)
{
message += $"\t-{obj.Name}: {value}\n";
}
}
}
// Up
else if (hetrixToolsAlert.Monitor_status == HetrixToolsAlert.MonitorStatus.Online)
{
message = $"<b>{hetrixToolsAlert.Monitor_name}</b> is now <strong>{hetrixToolsAlert.Monitor_status.ToUpper()}</strong>\nTarget: <b>{hetrixToolsAlert.Monitor_target}</b>\nType: {hetrixToolsAlert.Monitor_type}";
}
var telegramRequest = new TelegramRequest(_telegramSettings.TelegramChannel, "HTML", message);
var telegramResponse = await _httpClient.PostAsync(new Uri($"{_telegramSettings.TelegramUrl}/bot{_telegramSettings.Token}/sendMessage"), new StringContent(JsonConvert.SerializeObject(telegramRequest), Encoding.UTF8, "application/json"));
return(telegramResponse.IsSuccessStatusCode);
}
catch (Exception e)
{
_logger.Error(e, "Got an exception while sending hetrix tools alert to Telegram");
return(false);
}
}
public async Task <List <Contact> > HandleAsync(Query query)
{
IClientApi client = await _telegramService.BuildAsync(query.UserId);
TContacts result = (await TelegramRequest.HandleAsync(() =>
{
return(client.ContactsService.GetContactsAsync());
}));
List <Contact> contacts = result.Users.Select(c =>
{
var user = c.As <TUser>();
return(new Contact()
{
FirstName = user.FirstName,
Id = user.Id,
LastName = user.LastName,
UserName = user.Username
});
}).ToList();
return(contacts);
}
private void Tr_MessageText(object sendr, MessageText e)
{
logger.Debug($"New message: message_id:{e.message_id} user_id:{e.from.id} chat_id:{e.chat.id} username:{e.from.username} name: {e.from.first_name} {e.from.last_name} date: {e.date} message:'{e.text}'");
Method m = new Method(MainSettings.Default.Token, MainSettings.Default.API_URL);
DBAPI d = new DBAPI(MainSettings.Default.DB_DataSource, MainSettings.Default.DB_UserID, MainSettings.Default.DB_Password, MainSettings.Default.DB_InitialCatalog);
d.RegTransactionEvent += RegisterTransaction;
d.Connect();
string answer;
string message = e.text.Replace("@DeeBeeTeeBot", "");
message = message.Replace("@DeeBeeTeeTestBot", "");
string command_params = "";
int space = message.IndexOf(" ");
string command;
if (space == -1)
{
command = message;
}
else
{
command = message.Substring(0, space);
command_params = message.Substring(space, message.Length - space);
}
logger.Info("Получение команды " + command);
logger.Info("Проверка изоляции чата" + command);
bool _isolated = d.CheckIsolated(e.chat.id);
string _username = e.from.username;
if (_isolated)
{
logger.Debug("Чат изолирован!");
_username = e.chat.id.ToString() + "___" + e.from.username;
logger.Debug("New user name" + _username);
message = message.Replace("@", "@" + e.chat.id.ToString() + "___");
logger.Debug("New message" + message);
command_params = command_params.Replace("@", "@" + e.chat.id.ToString() + "___");
logger.Debug("New command_params" + command_params);
}
if (command.StartsWith("/isolate_"))
{
answer = d.Command_isolate(command, e.chat.id, command_params);
}
else
if (command.StartsWith("/tid_"))
{
answer = d.Command_tid(command, command_params);
}
else
{
switch (command)
{
case "/balance":
answer = d.Command_balance(_username, command_params);
break;
case "/b":
answer = d.Command_balance(_username, command_params);
break;
case "/details":
answer = d.Command_details(_username, command_params);
break;
case "/d":
answer = d.Command_details(_username, command_params);
break;
case "/hello":
answer = d.Command_hello();
break;
case "/help":
answer = d.Command_help(command_params);
break;
case "/start":
answer = d.Command_start(_username, e.from.id);
break;
case "/t":
answer = d.Command_transaction(_username, message);
break;
case "/transaction":
answer = d.Command_transaction(_username, message);
break;
case "/j":
answer = d.Command_journal(_username, command_params);
break;
case "/journal":
answer = d.Command_journal(_username, command_params);
break;
case "/isolate":
answer = d.Command_isolate_request(_username, e.chat.id, command_params);
break;
case "/private":
answer = d.Command_private(_username, command_params);
break;
//Admins command
case "/a_balance":
answer = d.Command_a_balance(message);
break;
case "/a_details":
answer = d.Command_a_details(message);
break;
case "/terminate9616":
answer = "Emergency shutdown";
TelegramRequest TelR = sendr as TelegramRequest;
TelR.ForceTerminate = true;
break;
default:
answer = $"Извините я команду '{command}' не поддерживаю. Поддерживаемые команды можно посмотреть /help";
break;
}
}
if (_isolated)
{
answer = answer.Replace("@" + e.chat.id.ToString() + "___", "@");
}
m.SendMessage(answer, e.chat.id);
d.UpdateChat(e.chat.id, e.chat.type, e.from.id, e.from.username, e.chat.title);
// Сообщение мне!
m.SendMessage("New " + e.chat.type + " message from @" + e.from.username + ": " + message, 2730927);
d.Disconnect();
}
