private static async void ShowAdminDelRegion(Telegram.Bot.Types.Message message)
{
string answer = "Удаление района следующим образом: \n" +
@"/region del [id]";
await Bot.SendTextMessageAsync(message.Chat.Id, answer);
}
private static async void ShowAdminDelProd(Telegram.Bot.Types.Message message)
{
string answer = "Удаление графити следующим образом: \n" +
@"/graphit del [id]";
await Bot.SendTextMessageAsync(message.Chat.Id, answer);
}
internal string ProcessMessage(Telegram.Bot.Types.Message m)
{
Console.WriteLine();
Console.WriteLine(nameof(ProcessMessage));
Console.WriteLine($"Time: {DateTime.UtcNow} From: {m.From.Id}\nMessage: '{m.Text}'");
var command = m.Text.Replace(Resources.MorningerBotName, string.Empty);
if (command == "/start")
{
return(CreateUser(m.From));
}
var user = UserSelect(m.From);
if (user == null)
{
return(Resources.YouAreNotRegisteredMessage);
}
switch (command)
{
case "/done": return(InsertEntry(user, "done"));
case "/dayoff": return(InsertEntry(user, "dayoff"));
case "/stat": return(GetStatistic(user));
default: return(ProcessDefaultMessage(user));
}
}
private static async void ShowAdminAddRegion(Telegram.Bot.Types.Message message)
{
string answer = "Добавление района следующим образом: \n" +
@"/region add [название] [краткое описание]";
await Bot.SendTextMessageAsync(message.Chat.Id, answer);
}
public UniversalMessage(IService fromTelegramSrv, Telegram.Bot.Types.Message telegramMessage)
: this(fromTelegramSrv,
((telegramMessage.From.FirstName + " " + telegramMessage.From.LastName).Trim()),
telegramMessage.Text,
telegramMessage.Date.AddHours(3))
{
}
public override void Execute(Message message, TelegramBotClient client)
{
var name = message.Text.Replace(Name, "").ToLower();
if (string.IsNullOrWhiteSpace(name))
{
client.SendTextMessageAsync(message.Chat.Id, $"Нельзя создать группу без имени");
return;
}
name = name.Trim();
if (_botContext.Groups.Any(item => item.Name == name))
{
client.SendTextMessageAsync(message.Chat.Id, $"{name} уже существует");
return;
}
_botContext.Groups.Add(new Group()
{
Name = name,
CreatorId = message.From.Id,
});
client.SendTextMessageAsync(message.Chat.Id, $"{name} успешно создана");
}
public Shitpost(Telegram.Bot.Types.Message msg)
{
this.senderId = msg.From.Id;
this.chatId = msg.Chat.Id;
this.messageId = msg.MessageId;
this.addedTime = DateTime.Now;
}
public override void Execute(Message message, TelegramBotClient client)
{
var name = message.Text.Replace(Name, "").ToLower();
if (string.IsNullOrWhiteSpace(name))
{
client.SendTextMessageAsync(message.Chat.Id, $"Нельзя удалить группу без имени");
return;
}
name = name.Trim();
var group = _botContext.Groups.FirstOrDefault(item => item.Name == name);
if (group == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"{name} не существует");
return;
}
if (group.CreatorId != message.From.Id)
{
client.SendTextMessageAsync(message.Chat.Id, $"Вы не создатель группы {name}");
return;
}
_botContext.Groups.Remove(group);
client.SendTextMessageAsync(message.Chat.Id, $"{name} успешно удалена");
}
///--------------------------------------------------------------------------------------------------------
///
public override async Task OnMessage(Telegram.Bot.Types.Message message)
{
if (commandState == eCommandState.WaitOpt)
{
long requesterId = message.Chat.Id;
if (requesterId == optWaitUserId)
{
commandState = eCommandState.Ready;
string otpStr = message.Text.Trim();
if (OtpChecker.CheckOtp(otpStr))
{
string response = await MakeResponse(requesterId, DateTimeHandler.ToLocalTime(message.Date));
await SendMessage(requesterId, response);
}
else
{
await SendMessage(requesterId, strings.GetString("Otp 인증에 실패 했습니다."));
}
Logger.Log("주소 생성 응답 완료.\n");
IsCompleted = true;
}
}
await Task.Run(() => { });
}
public override void Execute(Message message, TelegramBotClient client)
{
_logger.LogInformation($"{message.From.FirstName} set binance key");
var user = _botContext.Users.FirstOrDefault(item => item.Id == message.From.Id);
if (user == null)
{
_logger.LogWarning("user is null");
return;
}
var binance = message.Text.Split(':').ToList();
if (binance.Count != 2)
{
client.SendTextMessageAsync(user.ChatId, "введите в правильном формате api:key, либо вернитесь обратно в чат с помощью команды /returntochat");
return;
}
user.BinanceApi = binance[0];
user.SecretKey = binance[1];
user.UpdateBalance(_logger);
user.State = _botContext.OwnerUser == user ? (int)State.InChatOwner : (int)State.InChat;
var messageCount = _botContext.GetMessageByBalance(user.Balance) - _botContext.Messages.Count(item => item.UserId == user.Id && item.Time.Date == DateTime.Today);
client.SendTextMessageAsync(user.ChatId, $"успешно ввели ключь ваш баланс {user.Balance}, сегодня вы можете отправить {messageCount} сообщений");
}
/// <summary>
/// Sends a message to the registered telegram supergroup chat
/// </summary>
/// <param name="chatMsg"></param>
private static async Task <bool> SendTelegramChat(string chatMsg)
{
bool error = false;
bool isChatNotFoundError = false;
try
{
Telegram.Bot.Types.Message msg = await telegramClient.SendTextMessageAsync(APIKeysConstants.TELEGRAM_SUPERGROUP_CHATID, chatMsg);
return(true);
}
catch (Exception exp)
{
error = true;
if (exp is Telegram.Bot.Exceptions.ChatNotFoundException)
{
isChatNotFoundError = true;
}
Console.WriteLine(exp.ToString());
}
if (error && isChatNotFoundError) // ensure that its a connectivity issue, and not related to 'ChatNotFound'
{
lock (ChatBacklogs)
{
ChatBacklogs.Add(chatMsg);
}
}
return(false);
}
public async void testing()
{
var message = m.Message;
String text = "#Hello *World*";
Telegram.Bot.Types.Message mes = await bot.SendTextMessageAsync(message.Chat.Id, text, parseMode : Telegram.Bot.Types.Enums.ParseMode.Markdown);
}
public static async void CheckCountMessage(Telegram.Bot.Types.Message message)
{
//ICollection<int> keys = MainMenu.idMessageClientsWarnings.Keys;
//if (keys.Contains(Convert.ToInt32(message.Chat.Id)))
//{
// MainMenu.idMessageClientsWarnings[Convert.ToInt32(message.Chat.Id)]++;
// if (MainMenu.idMessageClientsWarnings[Convert.ToInt32(message.Chat.Id)] >= 50)
// {
// idMessageClientsBlackList.Add(Convert.ToInt32(message.Chat.Id));
// using (StreamWriter sw = new StreamWriter("BlackListIdMessageChatClients.xml"))
// {
// sw.WriteLine(string.Empty);
// }
// using (FileStream fs = new FileStream("BlackListIdMessageChatClients.xml", FileMode.OpenOrCreate))
// {
// MainMenu.serializerStatic.Serialize(fs, MainMenu.idMessageClientsBlackList);
// }
// try { await MainMenu.GetBot.SendTextMessageAsync(Convert.ToInt32(message.Chat.Id), "Вы занесены в черный список📛! Причина: Спам сообщений!"); } catch { }
// try { await MainMenu.GetBot.SendTextMessageAsync(Convert.ToInt32(415226650), "Попытка отправки более 70 сообщений📛! Пользователь добавлен в бан! ID: " + message.Chat.Id); } catch { }
// return false;
// }
//}
//else
//{
// MainMenu.idMessageClientsWarnings.Add(Convert.ToInt32(message.Chat.Id), 1);
//}
//return true;
}
/// <summary>
/// Initialize Message Data (Text, Photo, Audio, Document and ect.)
/// </summary>
/// <param name="mes"></param>
private object GetData(Telegram.Bot.Types.Message mes)
{
object data = null;
if (mes == null)
{
return(data);
}
switch (mes.Type)
{
case MessageType.Text:
data = mes.Text;
break;
case MessageType.Audio:
data = mes.Audio;
break;
case MessageType.Document:
//ToDo Init MessageDocument object
//this.Data =
break;
case MessageType.Photo:
data = GetMessagePhoto(PhotoQuality.High);
break;
}
return(data);
}
public static async Task StartDev(TelegramBotClient client, Telegram.Bot.Types.Message message, string baseAdress, string port)
{
using (var host = new HttpClient())
{
ClientExtension.PrepareHeaderForJenkins(host);
var lastBuild = await ParseJson.ResponseJson <JenkisBuildJson>(host, $"http://{baseAdress}:{port}/job/first/lastBuild/api/json");
var result = await host.GetAsync($"http://{baseAdress}:{port}/job/first/build?token=someAuthorizationFuckingTocketThatICantFindWhereToGenerate");
JenkisBuildJson resId;
do
{
Thread.Sleep(1000);
resId = await ParseJson.ResponseJson <JenkisBuildJson>(host, $"http://{baseAdress}:{port}/job/first/lastBuild/api/json");
} while (lastBuild.number == resId.number);
if (resId.result != null && resId.result.Equals("SUCCESS"))
{
await client.SendTextMessageAsync(message.Chat.Id, $"Готово, билд{resId.displayName}");
}
else
{
await client.SendTextMessageAsync(message.Chat.Id, $"Что то пошло не так:(, билд{resId.displayName}");
}
}
}
public static async void SendPhotoToChat(TelegramBotClient Bot, Telegram.Bot.Types.Message message)
{
NetworkCredential myCred = new NetworkCredential("admin", "");
CredentialCache credsCache = new CredentialCache();
credsCache.Add(new Uri("http://192.168.88.234/dms.jpg"), "Basic", myCred);
WebRequest wr = WebRequest.Create("http://192.168.88.234/dms.jpg");
wr.Credentials = credsCache;
var resp = wr.GetResponse();
var stream = resp.GetResponseStream();
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.UploadPhoto);
//WebClient webClient = new WebClient();
//webClient.DownloadFile("http://192.168.88.234/dms.jpg", @"123.png");
const string file = @"123.png";
var fileName = file.Split(Path.DirectorySeparatorChar).Last();
using (var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
await Bot.SendPhotoAsync(
message.Chat.Id,
stream,
"Прихожая");
}
}
public override void Execute(Message message, TelegramBotClient client)
{
var name = message.Text.Replace(Name, "").ToLower();
if (string.IsNullOrWhiteSpace(name))
{
client.SendTextMessageAsync(message.Chat.Id, $"Нельзя покинуть группу без имени");
return;
}
name = name.Trim();
var group = _botContext.Groups.FirstOrDefault(item => item.Name == name);
if (group == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"{name} не существует");
return;
}
var userId = message.From.Id;
var ug = _botContext.UserGroups.FirstOrDefault(item => item.Group == group.Name && item.UserId == userId);
if (ug == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"Вы не состоите в группе {name}");
return;
}
_botContext.UserGroups.Remove(ug);
client.SendTextMessageAsync(message.Chat.Id, $"Вы успешно вышли из группы {name}");
}
/// <summary>
/// Извлекает индексы из сообщения-команды
/// </summary>
/// <param name="message">Сообщение</param>
/// <returns>Список индексов</returns>
private List <int> DecomposeIndexes(Telegram.Bot.Types.Message message)
{
var indexes = new List <int>();
try
{
message.Text.Substring(message.Text.IndexOf(' ') + 1).Split(' ').ToList().ForEach(x => indexes.Add(int.Parse(x)));
}
catch (ArgumentException)
{
bot.SendTextMessageAsync(message.Chat.Id, "Ошибка: индексы введены неверно");
indexes.Clear();
}
catch (FormatException)
{
bot.SendTextMessageAsync(message.Chat.Id, "Неверное использование команды");
indexes.Clear();
}
catch (Exception ex)
{
bot.SendTextMessageAsync(message.Chat.Id, $"Ошибка: {ex.Message}");
indexes.Clear();
}
return(indexes);
}
private static async void ShowAdminAddProd(Telegram.Bot.Types.Message message)
{
string answer = "Добавление графити следующим образом: \n" +
@"/graphit add [название] [краткое описание] [размер] [широта] [долгота] [радиус] [район]";
await Bot.SendTextMessageAsync(message.Chat.Id, answer);
}
public BotRequest(string data, RequestType type, IUser user)
{
Type = type;
Data = data;
User = user;
Msg = null;
}
public void Execute(Message message)
{
var parameters = message.GetCommandParams();
if (parameters.Length == 0)
{
_bot.SendText(message.Chat.Id, Responses.AliasCommand_Usage);
return;
}
switch (parameters[0])
{
case "add":
if (!ValidateAdd(parameters.Skip(2).ToArray(), message.Chat.Id))
return;
var alias = new UserCommand
{
Type = UserCommandType.Alias,
Command = parameters[1],
AliasCommand = parameters.Skip(2).Join(" "),
ChatId = message.Chat.Id
};
_db.SaveUserCommand(alias);
_bot.SendText(message.Chat.Id, Responses.AliasCommand_AliasSaved);
break;
case "del": break;
case "list": break;
default:
_bot.SendText(message.Chat.Id, Responses.AliasCommand_Usage);
break;
}
}
private async static void Bot_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
//long idd = -364335647;
//long idd = -1414557052;
Telegram.Bot.Types.Message msg = e.Message;
if (msg == null || msg.Type != Telegram.Bot.Types.Enums.MessageType.Text)
{
return;
}
String answer = "";
switch (msg.Text)
{
case "/gen":
answer = msg.From.FirstName + " " + genWord();
break;
case "/gen@TryCreateMeBot":
answer = msg.From.FirstName + " " + genWord();
break;
default: return;
}
//answer = "сори, я потестить";
await Bot.SendTextMessageAsync(msg.Chat.Id, answer);
}
private static void BOT_OnMessage(object sender, MessageEventArgs e)
{
//Сообщения которые получает бот
Telegram.Bot.Types.Message message = e.Message;
string Answers = String.Empty;
switch (message.Text)
{
case "/start":
Answers = "Пора заняться спортом. Первым делом необходимо выбрать сотрудника, введите команду:/getEmp\nДалее для получение программы тренировок необходимо ввести команду: /getTrain\nУдачи";
BOT.SendTextMessageAsync(message.Chat.Id, Answers);
break;
case "/getEmp":
Answers = TPFE.Name;
BOT.SendTextMessageAsync(message.Chat.Id, Answers);
break;
case "/getTrain":
foreach (var item in TPFE.Trains)
{
BOT.SendTextMessageAsync(message.Chat.Id, item);
}
break;
default:
Answers = "Прости...Но я не знаю такой команды";
BOT.SendTextMessageAsync(message.Chat.Id, Answers);
break;
}
}
/// <summary>
/// Initialize InboxMessage
/// </summary>
/// <param name="mes"></param>
private void Init(Telegram.Bot.Types.Message mes)
{
this.Chat = new ChatWrapper(baseMessage.Chat);
this.ChatId = this.Chat.Id.Identifier;
this.MessageId = mes.MessageId;
this.Type = baseMessage.Type;
}
public static Room GetRoom(this Bot.Types.Message message)
{
return(new Room {
Id = message.Chat.Id.ToString(),
Name = message.Chat.Title
});
}
/// <summary>
/// Обработка контакта
/// </summary>
/// <param name="message"></param>
public void ContactProcessor(Telegram.Bot.Types.Message message)
{
User user = state[message.Chat.Id];
//Проверка состояния пользователя
if (user.State != UserState.Register)
{
client.SendTextMessageAsync(message.Chat.Id, $"Мне сейчас это не нужно");
return;//??
}
//Проверка на подмену контакта
if (message.Contact.UserId != message.Chat.Id)
{
client.SendTextMessageAsync(message.Chat.Id, $"Некорректный контакт");
return;//??
}
string phone = message.Contact.PhoneNumber;
log.Trace(phone);
//Регистрация пользователя
user.FirstName = message.Contact.FirstName;
user.LastName = message.Contact.LastName;
user.UserName = message.Chat.Username;
user.PhoneNumber = phone;
//Возврат к базовому состоянию пользователя
user.State = UserState.None;
state.Save(Properties.Settings.Default.FileName);
client.SendTextMessageAsync(message.Chat.Id, $"Твой телефон добавлен в базу: {phone}");
}
public override void Execute(Message message, TelegramBotClient client)
{
var name = message.Text.Replace(Name, "").ToLower();
if (string.IsNullOrWhiteSpace(name))
{
client.SendTextMessageAsync(message.Chat.Id, $"Нельзя посмотреть участников группы без имени");
return;
}
name = name.Trim();
var group = _botContext.Groups.FirstOrDefault(item => item.Name == name);
if (group == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"{name} не существует");
return;
}
var userGroups = _botContext.UserGroups.Where(item => item.Group == name).ToList();
var builder = new StringBuilder();
builder.AppendLine($"В группе {name} состоят {userGroups.Count} человек:");
foreach (var user in userGroups.Select(userGroup => _botContext.Users.FirstOrDefault(item => item.Id == userGroup.UserId)))
{
builder.AppendLine($"{user?.FirstName} @{user?.Name}");
}
client.SendTextMessageAsync(message.Chat.Id, builder.ToString());
}
public override void Execute(Message message, TelegramBotClient client)
{
_logger.LogInformation($"{message.From.FirstName} get users in chat ");
var user = _botContext.Users.FirstOrDefault(item => item.Id == message.From.Id);
if (user == null)
{
_logger.LogWarning("user is null");
return;
}
if (!user.InChat)
{
_logger.LogWarning("user not in chat");
return;
}
var builder = new StringBuilder();
foreach (var userInChat in _botContext.Users.Where(item => item.InChat))
{
builder.AppendLine($"**{userInChat.FirstName}** @{userInChat.Name}");
}
client.SendTextMessageAsync(user.ChatId, builder.ToString());
}
/// <summary>
/// Обработка команды
/// </summary>
/// <param name="message"></param>
private void CommandProcessor(Telegram.Bot.Types.Message message)
{
try
{
log.Trace("|<- CommandProcessor");
// Отрезаем первый символ (который должен быть '/')
string command = message.Text.Substring(1).ToLower();
// Построение имени метода для вызова
string method = command.Substring(0, 1).ToUpper() + command.Substring(1) + "Command";
// Ищем метод по имени
System.Reflection.MethodInfo info = GetType().GetMethod(method);
if (info == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"Я пока не понимаю команду {command}");
return;
}
// Вызов метода по имени
info.Invoke(this, new object[] { message });
}
finally
{
log.Trace("|-> CommandProcessor");
}
}
public override void Execute(Message message, TelegramBotClient client)
{
var name = message.Text.Replace(Name, "").ToLower();
if (string.IsNullOrWhiteSpace(name))
{
client.SendTextMessageAsync(message.Chat.Id, $"Нельзя выбрать из группы без имени");
return;
}
name = name.Trim();
var group = _botContext.Groups.FirstOrDefault(item => item.Name == name);
if (group == null)
{
client.SendTextMessageAsync(message.Chat.Id, $"{name} не существует");
return;
}
var users = _botContext.UserGroups.Where(item => item.Group == group.Name).Select(item => item.UserId).ToList();
var user = _botContext.Users.FirstOrDefault(item => item.Id == users[_botContext.Random.Next(users.Count)]);
client.SendTextMessageAsync(message.Chat.Id, $"Рандом выбрал {user.FirstName} @{user.Name}");
}
private static void Bot_OnUpdate(object sender, UpdateEventArgs e)
{
if (e.Update.Type == UpdateType.CallbackQuery && e.Update.CallbackQuery.Data == "update")
{
if (!e.Update.CallbackQuery.From.IsGlobalAdmin(db))
{
Bot.AnswerCallbackQueryAsync(e.Update.CallbackQuery.Id, "You are not authorized to do this!");
return;
}
nodes.ForEach(x => x.Stop());
Telegram.Bot.Types.Message cmsg = e.Update.CallbackQuery.Message;
string msgText = "Updating...\n";
Task.Run(() => StartNewNode(x =>
{
msgText += x + "\n";
if (msgText.Trim('\n', ' ') != cmsg.Text.Trim())
{
try { cmsg = Bot.EditMessageTextAsync(cmsg.Chat.Id, cmsg.MessageId, msgText).Result; } catch { }
}
}));
return;
}
if (e.Update.Type == UpdateType.CallbackQuery && e.Update.CallbackQuery.Data == "dontUpdate")
{
if (!e.Update.CallbackQuery.From.IsGlobalAdmin(db))
{
Bot.AnswerCallbackQueryAsync(e.Update.CallbackQuery.Id, "You are not authorized to do this!");
return;
}
Bot.DeleteMessageAsync(e.Update.CallbackQuery.Message.Chat.Id, e.Update.CallbackQuery.Message.MessageId);
}
if (e.Update.Type == UpdateType.Message && e.Update.Message.Text == "/update")
{
if (!e.Update.Message.From.IsGlobalAdmin(db))
{
Bot.SendTextMessageAsync(e.Update.Message.Chat.Id, "You are not authorized to do this!");
return;
}
nodes.ForEach(x => x.Stop());
string msgText = "Updating...\n";
Telegram.Bot.Types.Message cmsg = Bot.SendTextMessageAsync(e.Update.Message.Chat.Id, msgText).Result;
Task.Run(() => StartNewNode(x =>
{
msgText += x + "\n";
if (msgText.Trim('\n', ' ') != cmsg.Text.Trim())
{
try { cmsg = Bot.EditMessageTextAsync(cmsg.Chat.Id, cmsg.MessageId, msgText).Result; } catch { }
}
}));
return;
}
nodes.ForEach(x => x.SendMessage(new IpcMessage(e.Update)));
}
public Message SaveMessage(TelegramMessage telegramMessage, bool isReceived = true)
{
var messageRepository = _repositoryFactory.GetRepository<Message>();
var message = telegramMessage.Convert();
message.IsReceived = isReceived;
messageRepository.Add(message);
return message;
}
public void Execute(Message message)
{
var userCommand = _db.GetCommandByChat(message.Chat.Id, message.Text);
switch (userCommand.Type)
{
case UserCommandType.PostRequest:
case UserCommandType.GetRequest:
ExecuteRequestCommand(userCommand);
break;
case UserCommandType.Alias:
_bot.SendText(message.Chat.Id, "test");
return;
}
_bot.SendText(message.Chat.Id, Responses.UserCommandSuccessRun);
}
public void Execute(TelegramMessage message)
{
var text = message.Text.Split(' ');
switch (text.Count())
{
case 1:
_bot.SendText(message.Chat.Id, Responses.AllowUserCommandUsage);
break;
default:
var param = text[1];
int userId;
var user = int.TryParse(param, out userId) ? _db.Value.UserAllow(userId) : _db.Value.UserAllow(param);
if (user == null)
{
_bot.SendText(message.Chat.Id, Responses.UserNotFound);
break;
}
_bot.SendText(message.Chat.Id, string.Format(Responses.AllowUserCommandSuccessAllowUser, user.GetUsernameWithId()));
_bot.SendText(userId, Responses.AllowUserCommandCongratulation);
break;
}
}
public void Execute(Message message)
{
var text = message.Text.Split(' ');
switch (text.Count())
{
case 1:
case 2:
case 3:
_bot.SendText(message.Chat.Id, Responses.AddCommandUsageText);
break;
default:
var newCommand = new UserCommand
{
Command = text[1],
Type = text[2].ToLower() == "post" ? UserCommandType.PostRequest : UserCommandType.GetRequest,
ChatId = message.Chat.Id,
Url = text[3],
Data = GetData(text.Skip(4))
};
_db.SaveUserCommand(newCommand);
_bot.SendText(message.Chat.Id, string.Format(Responses.AddCommandSuccesfullyAddedCommand, text[1]));
break;
}
}
