private async Task ProcessMessage(TelegramMessage msg)
{
TelegramReplyMessage reply;
using (var scope = _serviceProvider.CreateScope())
{
var transactionService = scope.ServiceProvider.GetRequiredService <TransactionService>();
switch (msg.Text.ToLower())
{
case "dashboard":
reply = await transactionService.GetDashboardAsync(msg);
break;
case "reload":
reply = await transactionService.ReloadCacheAsync(msg);
break;
default:
reply = await transactionService.ProcessTransactionStepAsync(msg);
break;
}
}
await _outgoingQueue.Write(reply);
}
public List <TelegramMessage> ParseLastMessages(string stringResponse)
{
JObject lastMessages = new JObject();
try
{
lastMessages = JObject.Parse(stringResponse);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
List <TelegramMessage> answer = new List <TelegramMessage>();
foreach (JToken message in lastMessages["result"])
{
TelegramMessage currentMessage = new TelegramMessage()
{
UpdateId = message["update_id"].Value <int>(),
Chat = message["message"]["chat"]["id"].Value <int>(),
SenderName = message["message"]["from"]["first_name"].Value <string>(),
Text = message["message"]["text"].Value <string>(),
};
answer.Add(currentMessage);
}
return(answer);
}
protected void PostNonPriorityMessage(TelegramMessage message)
{
GenerateMessage(new TelegramMessageEventArgs()
{
TelegramMessage = message, Immediately = false
}, true);
}
protected void PostMessage(TelegramMessage message, bool immediately = false)
{
GenerateMessage(new TelegramMessageEventArgs()
{
TelegramMessage = message, Immediately = immediately
});
}
private async Task <TelegramMessage> CreateMessage(TdApi.Message tdMessage)
{
if (tdMessage.Content is TdApi.MessageContent.MessageText text)
{
var sent = DateTimeOffset.FromUnixTimeSeconds((long)tdMessage.Date).UtcDateTime;
var chat = await GetChat(tdMessage.ChatId);
var msgSender = await GetTelegramContact(tdMessage.SenderUserId);
if (_chats.ContainsKey(tdMessage.ChatId))
{
var msg = new TelegramMessage
{
MessageId = tdMessage.Id,
ChatId = tdMessage.ChatId,
ChatName = chat.Title,
Text = text.Text.Text,
Sent = sent,
SenderContact = msgSender
};
return(msg);
}
}
return(null);
}
public void NewMessage(TelegramMessage message)
{
_logger.LogInformation(
"{ChatName} {Sender} {SentDateTime} {Message}",
message.ChatName,
message.SenderContact.PhoneNumber,
message.Sent,
message.Text);
_messageAuditService.LogMessage(new List <TelegramMessage>()
{
message
});
var chatId = message.ChatId;
foreach (var sub in _chatSubscriptions)
{
var conn = _hub.Clients.Client(sub.Key);
if (conn != null && sub.Value.Contains(chatId))
{
conn.OnNewMessage(message);
}
}
}
async Task <int> AddUpdateMsgToDb(Update update)
{
Follower follower = new Follower();
string MessageId = "";
int BotId = 0;
try
{
using (MarketBotDbContext db = new MarketBotDbContext())
{
var builder = new ConfigurationBuilder()
.SetBasePath(System.IO.Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
string name = builder.Build().GetSection("BotName").Value;
if (update.CallbackQuery != null && update.InlineQuery == null)
{
follower = await db.Follower.Where(f => f.ChatId == update.CallbackQuery.From.Id).FirstOrDefaultAsync();
MessageId = update.CallbackQuery.Message.MessageId.ToString();
}
if (update.Message != null && update.InlineQuery == null)
{
follower = await db.Follower.Where(f => f.ChatId == update.Message.From.Id).FirstOrDefaultAsync();
MessageId = update.Message.MessageId.ToString();
}
BotId = db.BotInfo.Where(b => b.Name == name).FirstOrDefault().Id;
if (follower != null && db.TelegramMessage.Where(t => t.UpdateId == update.Id).FirstOrDefault() == null && BotId > 0 && update.InlineQuery == null)
{
TelegramMessage telegramMessage = new TelegramMessage
{
FollowerId = follower.Id,
MessageId = MessageId,
UpdateId = update.Id,
UpdateJson = JsonConvert.SerializeObject(update),
DateAdd = DateTime.Now,
BotInfoId = BotId
};
db.TelegramMessage.Add(telegramMessage);
return(await db.SaveChangesAsync());
}
else
{
return(-1);
}
}
}
catch (Exception exp)
{
return(-1);
}
}
async Task <int> AddUpdateMsgToDb(Update _update)
{
Follower follower = new Follower();
string MessageId = "";
int BotId = 0;
try
{
using (MarketBotDbContext db = new MarketBotDbContext())
{
string name = GeneralFunction.GetBotName();
if (_update.CallbackQuery != null && _update.InlineQuery == null)
{
follower = await db.Follower.Where(f => f.ChatId == _update.CallbackQuery.From.Id).FirstOrDefaultAsync();
if (_update.CallbackQuery.Message != null)
{
MessageId = _update.CallbackQuery.Message.MessageId.ToString();
}
}
if (_update.Message != null && _update.InlineQuery == null)
{
follower = await db.Follower.Where(f => f.ChatId == _update.Message.From.Id).FirstOrDefaultAsync();
MessageId = _update.Message.MessageId.ToString();
}
BotId = db.BotInfo.Where(b => b.Name == name).FirstOrDefault().Id;
if (follower != null && db.TelegramMessage.Where(t => t.UpdateId == _update.Id).FirstOrDefault() == null && BotId > 0 && _update.InlineQuery == null)
{
TelegramMessage telegramMessage = new TelegramMessage
{
FollowerId = follower.Id,
MessageId = MessageId,
UpdateId = _update.Id,
UpdateJson = JsonConvert.SerializeObject(_update),
DateAdd = DateTime.Now,
BotInfoId = BotId
};
db.TelegramMessage.Add(telegramMessage);
return(await db.SaveChangesAsync());
}
else
{
return(-1);
}
}
}
catch (Exception exp)
{
return(-1);
}
}
public async void Send(string MessageContent, int TelegramChatId)
{
var botClient = new TelegramBotClient(_telegramConfiguration.AccessToken);
TelegramMessage telegramMessage = new TelegramMessage();
telegramMessage.Content = MessageContent;
Message message = await botClient.SendTextMessageAsync(new ChatId(TelegramChatId), telegramMessage.Content);
}
public Task <bool> AskLocationAsync(int chatId)
{
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = BotDialog.ASK_LOCATION
};
return(_telegramService.SendMessage(message));
}
private IDarioBotReply ReplyWithForwarded(TelegramMessage telegramMsg)
{
var fromReplyMessage = "Tiocanta!!! Non ti conosco zio! Aspetta che ti faccio l'audio. Sta calmo che arriva";
var @from = telegramMsg.From;
var fromId = telegramMsg.From.Id;
var name = telegramMsg.Text;
string toReplyMessage = $"Dario, {@from.FirstName} {from.LastName} ha chiesto un audio per {name}. Grazie \U0001f618";
return(new ForwardDarioBotReply(_telegramApi, _repository, fromReplyMessage, toReplyMessage, fromId, _forwardId, name));
}
private IDarioBotReply ReplyFor(TelegramMessage telegramMsg)
{
if (IsACommand(telegramMsg.Text))
{
return(HandleCommand(telegramMsg.Text, telegramMsg.From));
}
return(_repository.HasAnAudio(telegramMsg.Text,
audioBytes => ReplyWithAudio(telegramMsg, audioBytes),
() => ReplyWithForwarded(telegramMsg)));
}
public static TelegramTextMessage CreateTelegramTextMessage(string messageText)
{
return(TelegramTextMessage.Create(
TelegramMessage.Create(
new TelegramUpdate
{
Message = new Message
{
Text = messageText
}
})));
}
public async Task <bool> QuerySheetAsync(int linkedMessageId, string callbackQueryId, int chatId, int scale)
{
var coordinates = await _amazonDynamoDbService.QueryAsync(chatId);
var sheets = _sheetService.GetSheetsByCoordinate(coordinates.lat, coordinates.lon, scale).ToList();
if (!sheets.Any())
{
return(false);
}
var deleteMessage = new TelegramDeleteMessage
{
ChatId = chatId,
MessageId = linkedMessageId
};
await _telegramService.DeleteMessage(deleteMessage);
var answerCallbackQuery = new AnswerCallbackQuery
{
CallbackQueryId = callbackQueryId,
Text = "Sorgu tamamlandı."
};
await _telegramService.AnswerCallbackQuery(answerCallbackQuery);
string messageText;
if (sheets.Count() > 1)
{
messageText = "Birden fazla pafta ile kesişiyor:";
foreach (var sheetDto in sheets)
{
messageText += "\n" + sheetDto.Name;
}
}
else
{
messageText = sheets.FirstOrDefault().Name;
}
messageText += $"\nÖlçek: 1:{scale}.000";
messageText += $"\nKoordinatlar: {coordinates.lat:F6}, {coordinates.lon:F6}";
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = messageText
};
return(await _telegramService.SendMessage(message));
}
private async Task SendMessage(string messageText, bool notify)
{
var telegramApi = RestService.For <ITelegramApi>(_channelConfiguration.BaseAddress);
var message = new TelegramMessage()
{
Text = messageText,
ChatId = _channelConfiguration.ChatId,
DisableNotification = !notify
};
await telegramApi.SendMessage(_channelConfiguration.BotToken, message);
_logger.LogInformation("Sent message to chat {TelegramChatId}", _channelConfiguration.ChatId);
}
private async Task HandleUpdateAsync(TelegramUpdate update)
{
if (update == null)
{
return;
}
_logger.LogDebug("Update Received");
switch (update.Type)
{
case UpdateType.Message:
await _messageHandler.HandleAsync(TelegramMessage.Create(update));
break;
case UpdateType.Unknown:
break;
case UpdateType.InlineQuery:
break;
case UpdateType.ChosenInlineResult:
break;
case UpdateType.CallbackQuery:
break;
case UpdateType.EditedMessage:
break;
case UpdateType.ChannelPost:
break;
case UpdateType.EditedChannelPost:
break;
case UpdateType.ShippingQuery:
break;
case UpdateType.PreCheckoutQuery:
break;
case UpdateType.Poll:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task SendTextAsync_SuccessfullySend_SuccessfullyResult()
{
var messageSender = GetService <IMessageSender <TelegramMessage> >();
var message = new TelegramMessage
{
Receiver = "123",
Text = "test"
};
var result = await messageSender.SendTextAsync(message);
Assert.True(result.Success);
Assert.AreEqual(string.Empty, result.Error);
}
public async Task <bool> SendMessage(TelegramMessage message)
{
var url = $"{TelegramApiUrl}/bot{_apiToken}/sendMessage";
var content = new StringContent(JsonConvert.SerializeObject(message, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}), Encoding.UTF8, "application/json");
using var client = new HttpClient();
using var response = await client.PostAsync(url, content);
if (!response.IsSuccessStatusCode)
{
throw new TelegramApiException(await response.Content.ReadAsStringAsync());
}
return(true);
}
public static TelegramCommand CreateTelegramCommand(string messageText, long chatId = 42)
{
return(new TelegramCommand(
TelegramTextMessage.Create(
TelegramMessage.Create(
new TelegramUpdate
{
Message = new Message
{
Chat = new Chat
{
Id = chatId
},
Text = messageText
}
}))));
}
private async void BotOnMessage(object sender, MessageEventArgs e)
{
if (e.Message.Type != MessageType.Text)
{
return;
}
var model = new TelegramMessage
{
ChatId = e.Message.Chat.Id,
Text = e.Message.Text
};
await _incomingQueue.Write(model);
_logger.LogInformation(model.Text);
}
public void CanExecute_returns_false_if_command_is_not_a_command()
{
var executor = new EchoCommandExecutor(null, null);
var command = new TelegramCommand(
TelegramTextMessage.Create(
TelegramMessage.Create(
new TelegramUpdate
{
Message = new Message {
Text = ""
}
})));
command.IsCommand.Should().BeFalse();
var result = executor.CanExecute(command);
result.Should().BeFalse();
}
public async Task SendTextAsync_UnsuccessfullySend_UnsuccessfullyResult()
{
var messageSender = GetService <IMessageSender <TelegramMessage> >();
var message = new TelegramMessage
{
Receiver = "-1",
Text = "test",
Keyboard = null,
DisableNotification = false,
ParseMode = ParseMode.Default,
DisableWebPagePreview = false,
ReplyToMessageId = 1
};
var result = await messageSender.SendTextAsync(message);
Assert.False(result.Success);
Assert.AreEqual(Constants.Error, result.Error);
}
public Task <int> SendMessage(BotClientWrapper botClient, long chatId, TelegramMessage message, bool notify)
{
switch (message.Type)
{
case TelegramMessageType.Text:
return(SendMessage(botClient, chatId, (TextTelegramMessage)message, notify));
case TelegramMessageType.Photo:
return(SendMessage(botClient, chatId, (PhotoTelegramMessage)message, notify));
case TelegramMessageType.RequestLocation:
return(SendMessage(botClient, chatId, (RequestLocationTelegramMessage)message, notify));
case TelegramMessageType.SelectOption:
return(SendMessage(botClient, chatId, (SelectOptionTelegramMessage)message, notify));
default:
throw new NotSupportedException($"{nameof(TelegramMessageType)}.{message.Type} is not supported");
}
}
public async Task <bool> RemoveLocationAsync(int chatId)
{
var updateRequest = _updateRequestBuilder
.CreateRequest(chatId)
.RemoveLocation()
.Build();
var updateResult = await _subscribtionStore.UpdateAsync(updateRequest);
if (!updateResult)
{
return(false);
}
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = BotDialog.REMOVED_LOCATION
};
return(await _telegramService.SendMessage(message));
}
public async Task <bool> StartSubscriptionAsync(int chatId)
{
var updateRequest = _updateRequestBuilder
.CreateRequest(chatId)
.SetMagnitude(0)
.Build();
var updateResult = await _subscribtionStore.UpdateAsync(updateRequest);
if (!updateResult)
{
return(false);
}
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = BotDialog.START_SUBSCRIPTION
};
return(await _telegramService.SendMessage(message));
}
public async Task <string> Send(TelegramMessage msg)
{
FileStream fileStream = new FileStream(_filePath, FileMode.Open);
if (fileStream.CanRead)
{
if (FileSizeInBytes <= 52_428_800) // но это не точно
{
_documentToSend = new FileToSend(FileName, fileStream);
}
else
{
throw new Exception("Файл не повинен перевищувати 50 мб!");
}
}
else
{
throw new FileNotFoundException($"Не знайдено файл!\n{_filePath}");
}
await msg.Bot.SendDocumentAsync(msg.CanalName, _documentToSend, msg.Text, msg.DisableNotification, replyMarkup : msg.InlineMarkup);
fileStream.Dispose();
return($@"Файл {FileName} успішно відправлений!");
}
public async Task <bool> SetMagnitudeAsync(int linkedMessageId, string callbackQueryId, int chatId, double magnitude)
{
var updateRequest = _updateRequestBuilder
.CreateRequest(chatId)
.SetMagnitude(magnitude)
.Build();
var updateResult = await _subscribtionStore.UpdateAsync(updateRequest);
if (!updateResult)
{
return(false);
}
var deleteMessage = new TelegramDeleteMessage
{
ChatId = chatId,
MessageId = linkedMessageId
};
await _telegramService.DeleteMessage(deleteMessage);
var answerCallbackQuery = new AnswerCallbackQuery
{
CallbackQueryId = callbackQueryId,
Text = string.Format(BotDialog.REPLY_MAGNITUDE, magnitude)
};
await _telegramService.AnswerCallbackQuery(answerCallbackQuery);
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = string.Format(BotDialog.REPLY_MAGNITUDE, magnitude)
};
return(await _telegramService.SendMessage(message));
}
public IDarioBotReply ReplyBack(TelegramUpdate telegramMsg)
{
TelegramMessage message = telegramMsg.Message;
TelegramCallbackQuery callbackQuery = telegramMsg.CallbackQuery;
if (callbackQuery != null)
{
return(ReplyFor(callbackQuery));
}
else
{
if (message.Voice != null)
{
return(ReplyFor(message.From, message.Voice));
}
if (message.Text == null)
{
return(new UnhandledInput(_telegramApi, _repository, message.From));
}
return(ReplyFor(message));
}
}
public Task <bool> AskMagnitudeAsync(int chatId)
{
var replyMarkup = new TelegramInlineKeyboardMarkup
{
InlineKeyboard = new List <IEnumerable <TelegramInlineKeyboardButton> > {
new List <TelegramInlineKeyboardButton>
{
new TelegramInlineKeyboardButton {
Text = "Hepsi", CallBackData = "0"
},
new TelegramInlineKeyboardButton {
Text = "3.0+", CallBackData = "3"
},
new TelegramInlineKeyboardButton {
Text = "4.0+", CallBackData = "4"
},
new TelegramInlineKeyboardButton {
Text = "5.0+", CallBackData = "5"
},
new TelegramInlineKeyboardButton {
Text = "6.0+", CallBackData = "6"
}
}
}
};
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = BotDialog.ASK_MAGNITUDE,
ReplyMarkup = JsonConvert.SerializeObject(replyMarkup)
};
return(_telegramService.SendMessage(message));
}
public async Task <bool> AskScaleAsync(int chatId, Location location)
{
if (location.Longitude > 45 || location.Longitude < 25.5 ||
location.Latitude > 42.5 || location.Latitude < 36)
{
return(await _telegramService.SendMessage(new TelegramMessage
{
ChatId = chatId.ToString(),
Text = "Koordinatlar sınır dışında kalıyor."
}));
}
var response = await _amazonDynamoDbService.UpdateAsync(chatId, location.Latitude, location.Longitude);
if (!response)
{
return(await _telegramService.SendMessage(new TelegramMessage
{
ChatId = chatId.ToString(),
Text = "Bir hata oluştu."
}));
}
var replyMarkup = new TelegramInlineKeyboardMarkup
{
InlineKeyboard = new List <IEnumerable <TelegramInlineKeyboardButton> > {
new List <TelegramInlineKeyboardButton>
{
new TelegramInlineKeyboardButton {
Text = "250", CallBackData = "250"
},
new TelegramInlineKeyboardButton {
Text = "100", CallBackData = "100"
},
new TelegramInlineKeyboardButton {
Text = "50", CallBackData = "50"
},
new TelegramInlineKeyboardButton {
Text = "25", CallBackData = "25"
},
new TelegramInlineKeyboardButton {
Text = "10", CallBackData = "10"
},
new TelegramInlineKeyboardButton {
Text = "5", CallBackData = "5"
},
new TelegramInlineKeyboardButton {
Text = "2", CallBackData = "2"
},
new TelegramInlineKeyboardButton {
Text = "1", CallBackData = "1"
}
}
}
};
var message = new TelegramMessage
{
ChatId = chatId.ToString(),
Text = "Pafta ölçeğini seçiniz (1:___.000):",
ReplyMarkup = JsonConvert.SerializeObject(replyMarkup)
};
return(await _telegramService.SendMessage(message));
}
