public override async Task Execute(ModelContainer db, TelegramBotService botService, Message message)
{
var chatId = message.Chat.Id;
var alertTypes = Enum.GetValues(typeof(AlertType)).Cast <AlertType>().ToList();
var alertTypesStrings = new List <string>();
foreach (var alertType in alertTypes)
{
alertTypesStrings.Add(Extensions.GetEnumDescription(alertType));
}
var keyboard = new List <List <KeyboardButton> >();
foreach (string str in alertTypesStrings)
{
keyboard.Add(new List <KeyboardButton>
{
new KeyboardButton()
{
Text = str
}
});
}
var markup = new ReplyKeyboardMarkup()
{
Keyboard = keyboard,
ResizeKeyboard = true,
OneTimeKeyboard = true
};
await botService.SendTextMessageAsync(chatId, "Выберите тип уведомлений который хотите настроить.", replyMarkup : markup);
}
public override async Task Execute(ModelContainer db, TelegramBotService client, Message message)
{
var chatId = message.Chat.Id;
var text = message.Text;
int interval = 0;
var chat = db.TelegramChats.FirstOrDefault(x => x.ChatId == chatId);
if (chat == null)
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
}
switch (text)
{
case "\xD83D\xDD50 5 минут": interval = 5 * 60; break;
case "\xD83D\xDD51 10 минут": interval = 10 * 60; break;
case "\xD83D\xDD52 15 минут": interval = 15 * 60; break;
case "\xD83D\xDD55 30 минут": interval = 30 * 60; break;
}
var telegramChatSetting = db.TelegramChatSettings.FirstOrDefault(x => x.TelegramChatId == chat.Id);
if (telegramChatSetting == null)
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
return;
}
await client.SetInterval(db, chat, telegramChatSetting.Type, interval);
var carTypes = Enum.GetValues(typeof(CarType)).Cast <CarType>().ToList();
List <string> stringList = new List <string>();
foreach (var carType in carTypes)
{
stringList.Add(Extensions.GetEnumDescription(carType));
}
var keyboard = new List <IEnumerable <KeyboardButton> >();
var keyboardButtonList = new List <KeyboardButton>();
foreach (string str in stringList)
{
keyboardButtonList.Add(new KeyboardButton {
Text = str
});
}
keyboard.Add(keyboardButtonList);
var markup = new ReplyKeyboardMarkup {
ResizeKeyboard = true, OneTimeKeyboard = true, Keyboard = keyboard
};
await client.SendTextMessageAsync(chatId, "Интервал уведомлении установлено! " + Environment.NewLine + Environment.NewLine +
"Выберите тип машин", replyMarkup : markup);
}
public override async Task Execute(ModelContainer db, TelegramBotService client, Message message)
{
var chatId = message.Chat.Id;
var text = message.Text;
var chat = db.TelegramChats.FirstOrDefault(x => x.ChatId == chatId);
if (chat == null)
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
}
var type = new AlertType();
switch (text)
{
case "Нарушение скоростного режима":
type = AlertType.SpeedViolation;
break;
case "Работа без плана":
type = AlertType.NoAssignment;
break;
case "Длинные остановки":
type = AlertType.Stop;
break;
case "Аудит GPS Провайдера":
type = AlertType.GpsProviderAudit;
break;
}
if (await client.CreateChatSettings(db, chat, type))
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
}
var keyboard = new List <List <KeyboardButton> >
{
new List <KeyboardButton> {
new KeyboardButton("\xD83D\xDD50 5 минут")
},
new List <KeyboardButton> {
new KeyboardButton("\xD83D\xDD51 10 минут")
},
new List <KeyboardButton> {
new KeyboardButton("\xD83D\xDD52 15 минут")
},
new List <KeyboardButton> {
new KeyboardButton("\xD83D\xDD55 30 минут")
},
};
var markup = new ReplyKeyboardMarkup {
ResizeKeyboard = true, OneTimeKeyboard = true, Keyboard = keyboard
};
await client.SendTextMessageAsync(chatId, "Тип уведомлении установлено! Выберите интервал.",
replyMarkup : markup);
}
public Task ProcessCommand(Message message, string arguments, TelegramBotService telegramBotService)
{
return(telegramBotService.SendTextMessageAsync(message.Chat.Id,
"Ощущение, по определению В. И. Ленина, «есть превращение энрегии внешнего раздражения в факт сознания». " +
"Таким образом, источник звука, звуковые волны и работа слухового аппарата существуют объективно.",
replyToMessageId: message.MessageId,
parseMode: ParseMode.Markdown));
}
public MessageController(ApplicationContext context, EventLoggerService eventLogger, TelegramBotService telegramBot,
TelegramMarkupsService markups)
{
_eventLogger = eventLogger;
_context = context;
_telegramBot = telegramBot;
_markups = markups;
_eventLogger.AddClass <MessageController>();
_eventLogger.LogDebug("Initialization MessageController");
}
public TelegramWorker(TelegramBotService bot,
IBackgroundQueue <TelegramMessage> incomingQueue,
IBackgroundQueue <TelegramReplyMessage> outgoingQueue,
ILogger <TelegramWorker> logger)
{
_bot = bot;
_bot.OnMessage += BotOnMessage;
_bot.OnMessageEdited += BotOnMessage;
_incomingQueue = incomingQueue;
_outgoingQueue = outgoingQueue;
_logger = logger;
}
public override async Task Execute(ModelContainer db, TelegramBotService botService, Message message)
{
var chatId = message.Chat.Id;
var phoneNumber = message.Contact.PhoneNumber;
var repMsg = "Вы уже подписаны";
if (await botService.RegisterChat(db, chatId, phoneNumber))
{
repMsg = "Поздравляем! Вы подписались";
}
await botService.SendTextMessageAsync(chatId, repMsg);
}
public override async Task Execute(ModelContainer db, TelegramBotService client, Message message)
{
var chatId = message.Chat.Id;
var text = message.Text;
var chat = db.TelegramChats.FirstOrDefault(x => x.ChatId == chatId);
if (chat == null)
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
return;
}
var carType = new CarType();
switch (text)
{
case "Грузовой автомобиль": carType = CarType.Truck; break;
case "Жатка самоходная": carType = CarType.ZhatkaSamokhodnaya; break;
case "Комбайн": carType = CarType.Combine; break;
case "Легковой автомобиль": carType = CarType.PassengerCar; break;
case "Опрыскиватель": carType = CarType.Sprayer; break;
case "Топливозаправщик": carType = CarType.Refueller; break;
case "Трактор": carType = CarType.Tractor; break;
}
var telegramChatSetting = db.TelegramChatSettings.FirstOrDefault(x => x.TelegramChatId == chat.Id);
if (telegramChatSetting == null)
{
await client.SendTextMessageAsync(chatId, "Вы не подписаны на уведомления!");
return;
}
await client.SetCarType(db, chat, telegramChatSetting.Type, carType);
var cars = db.Cars
.Where(x => x.CarType == carType)
.ToDictionary(x => x.Id, y => y.Name);
var keyboard = Extensions.GetInlineKeyboard(cars, 0, null);
var markup = new InlineKeyboardMarkup(keyboard);
await client.SendTextMessageAsync(chatId, "Тип машин выбрано! Выберите машины", replyMarkup : markup);
}
public CommandsCollection(IEventsApiClient apiClient, TelegramBotService telegramService)
{
commands = new Dictionary <string, ICommand>();
var types = typeof(Startup).Assembly.GetTypes()
.Where(type => typeof(ICommand).IsAssignableFrom(type) && !type.IsAbstract && type.IsClass);
foreach (var type in types)
{
var instance = (ICommand)Activator.CreateInstance(type, apiClient, telegramService);
var name = instance.GetType().GetProperty("CommandName").GetValue(instance).ToString();
commands.TryAdd(name, instance);
}
}
public void Constructor_should_create_client()
{
var fakeOptions = new Mock <IOptions <TelegramBotConfiguration> >();
var fakeConfig = new TelegramBotConfiguration
{
BotToken = "1234567:4TT8bAc8GHUspu3ERYn-KGcvsvGB9u_n4ddy"
};
fakeOptions.SetupGet(x => x.Value).Returns(fakeConfig);
var service = new TelegramBotService(fakeOptions.Object);
service.Client.Should().NotBeNull();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
//inicia o Bot do telegram:
TelegramBotService.Startup();
// configure strongly typed settings objects
var appSettingsSection = Configuration.GetSection("AppSettings");
services.Configure <AppSettings>(appSettingsSection);
// configure jwt authentication
var appSettings = appSettingsSection.Get <AppSettings>();
var key = Encoding.ASCII.GetBytes(appSettings.Secret);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
// configure DI for application services
services.AddScoped <IUsuarioService, UsuarioService>();
// Ativa o uso do token como forma de autorizar o acesso
// a recursos deste projeto
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddMvc();
}
public async Task <OkResult> Post([FromBody] Update update)
{
MessageController messageController = this;
ModelContainer db = new ModelContainer();
TelegramBotService client = await Bot.Get();
try
{
await client.ProcessCmd(db, update);
}
catch (Exception ex)
{
Trace.WriteLine(ex);
await client.SendTextMessageAsync(update.Message.Chat.Id, ex.Message);
}
return(messageController.Ok());
}
public Task ProcessCommand(Message message, string arguments, TelegramBotService telegramBotService)
{
if (string.IsNullOrWhiteSpace(arguments))
{
return(telegramBotService.SendTextMessageAsync(message.Chat.Id, Resources.ScaleCommand_Hints,
replyToMessageId: message.MessageId,
parseMode: ParseMode.Markdown));
}
var key = arguments.Replace(" ", string.Empty).Replace("w", "2").Replace("h", "1");
var scales = _scales.IanringScalesByStepsCyclic.Where(k => k.Key.Contains(key)).ToArray();
if (scales.Length == 0)
{
return(telegramBotService.SendTextMessageAsync(message.Chat.Id, Resources.NoScalesFound,
replyToMessageId: message.MessageId,
parseMode: ParseMode.Markdown));
}
var builder = new StringBuilder();
var topScales = scales.OrderByDescending(s => s.Value.Names.Sum(n => n.Length)).Take(5);
foreach (var scale in topScales)
{
var name = string.Join(", ", scale.Value.Names);
if (string.IsNullOrWhiteSpace(name))
{
name = Resources.UntitledScale;
}
builder.AppendLine($"{scale.Key} : *{name}*");
}
if (scales.Length > 5)
{
builder.AppendLine("...");
}
return(telegramBotService.SendTextMessageAsync(message.Chat.Id, builder.ToString(),
replyToMessageId: message.MessageId,
parseMode: ParseMode.Markdown));
}
public override async Task Execute(ModelContainer db, TelegramBotService botService, Message message)
{
var chatId = message.Chat.Id;
int messageId = message.MessageId;
if (message.Chat.Type != ChatType.Private)
{
await botService.SendTextMessageAsync(chatId, "Only private chat is supported.", messageId);
}
var keyboard = new List <List <KeyboardButton> >
{
new List <KeyboardButton> {
new KeyboardButton("✉ Подписаться на уведомления")
{
RequestContact = true
}
},
new List <KeyboardButton> {
new KeyboardButton("⚙️ Настроить уведомления")
},
new List <KeyboardButton> {
new KeyboardButton("\xD83D\xDEAB Отписаться от уведомлений")
}
};
var markup = new ReplyKeyboardMarkup {
ResizeKeyboard = true, OneTimeKeyboard = true, Keyboard = keyboard
};
await botService.SendTextMessageAsync(
chatId,
$"Отправьте ваш номер ,чтобы подписаться на уведомления{Environment.NewLine}{Environment.NewLine}" +
$"Алгоритм определения остановок следующий: Каждое утро в 9.00 Система Agrostream запрашивает информацию у провайдера, кто имел ПОСЛЕДНЮЮ остановку длительностью: свыше 10 минут, 30 минут, 1 час, 6 часов,12 часов, 24 часов. В последующем до 00.00, каждые 20 минут Система Agrostream уведомляет о длительности ПОСЛЕДНИХ остановок до 6 часов с момента получения последнего сигнала до момента запроса у провайдера. Если провайдер по каким либо причинам не передал данные по технике, в уведомление техника не попадет. Время обработки данных и отправки уведомления может достигать до 5 минут.",
replyToMessageId : messageId,
replyMarkup : markup
);
}
public EventChangesController(ILogger <EventChangesService> logger, TelegramBotService telegramBotService, IMapper mapper)
{
this.logger = logger;
this.telegramBotService = telegramBotService;
this.mapper = mapper;
}
public GetEventsCommand(IEventsApiClient apiClient, TelegramBotService telegramService)
{
this.apiClient = apiClient;
this.telegramService = telegramService;
}
private static async Task AttachTelegramServiceAsync(IBot bot)
{
var teleService = new TelegramBotService(ConfigManager <TelegramBotConfig> .Instance);
await bot.AttachAsync(teleService).ConfigureAwait(false);
}
public BotMessageHandler(TelegramBotService botService, YoutubeDlService youtubeDlService)
{
_botService = botService;
_youtubeDlService = youtubeDlService;
}
public abstract Task Execute(ModelContainer db, TelegramBotService botService, Message message);
