public override async Task ExecuteAsync(Message message, TelegramBotClient botClient)
{
var chatId = (int)message.Chat.Id;
using (TelegramContext db = new TelegramContext())
{
var User = db.Users.Where(p => p.Id == message.From.Id).SingleOrDefault();
if (User == null)
{
User user = new User {
Id = chatId, Name = message.From.Username
};
UserState us = new UserState {
User = user, State = (int)UserStatesEnum.Empty, LastMessageId = message.MessageId
};
db.Users.Add(user);
db.UserStates.Add(us);
db.SaveChanges();
UserLocker.AddUser(chatId);
UserLocker.LockUser(chatId);
}
VacanciesManager.MainMenu(message, botClient);
}
}
public override async Task ExecuteAsync(Message message, TelegramBotClient botClient)
{
var chatId = message.Chat.Id;
using (TelegramContext db = new TelegramContext())
{
var User = db.Users.Where(p => p.UserId == message.From.Id).SingleOrDefault();
if (User == null)
{
ObjectsModels.User user = new ObjectsModels.User {
UserId = message.From.Id, Name = message.From.Username
};
ObjectsModels.UserState US = new ObjectsModels.UserState {
UserId = message.From.Id, State = (int)UserStatesEnum.Empty
};
db.Users.Add(user);
db.UserStates.Add(US);
db.SaveChanges();
BuildingsManager.MainMenu(user, db, message, botClient);
}
else
{
BuildingsManager.MainMenu(User, db, message, botClient);
}
}
}
public static void ActionStateSelected(UserState userState,
TelegramContext db,
Telegram.Bot.TelegramBotClient botClient,
Update update)
{
switch (userState.State)
{
case (int)UserStatesEnum.Empty: //Empty
break;
case (int)UserStatesEnum.AddBuildingName: //AddCourse
BuildingsManager.AddBuildingName(botClient, db, update.Message);
break;
case (int)UserStatesEnum.AddBuildingAddress: //CoursesList
BuildingsManager.AddBuildingAddress(botClient, db, update.Message, userState);
break;
case (int)UserStatesEnum.AddBuildingComment: //AddCourseName
BuildingsManager.AddBuildingComment(botClient, db, update.Message, userState);
break;
case (int)UserStatesEnum.AddBuildingPhoto: //AddCourseName
FilesManager.SaveFile(botClient, update.Message, userState.BuildingId);
break;
}
}
private static async Task AddOrUpdateLocation(int id, GoogleAddress address)
{
using (var telegramContext = new TelegramContext())
{
await telegramContext.Database.EnsureCreatedAsync();
var locationProfile = await telegramContext.UserLocations.FindAsync(id);
if (locationProfile != null)
{
locationProfile.Latitude = address.Coordinates.Latitude;
locationProfile.Longitude = address.Coordinates.Longitude;
locationProfile.FormattedAddress = address.FormattedAddress;
locationProfile.IsAmerica = address.IsAmerica();
}
else
{
await telegramContext.UserLocations.AddAsync(
new UserLocation
{
Id = id,
Latitude = address.Coordinates.Latitude,
Longitude = address.Coordinates.Longitude,
FormattedAddress = address.FormattedAddress,
IsAmerica = address.IsAmerica()
}
);
}
await telegramContext.SaveChangesAsync();
}
}
public static async void SaveFile(TelegramBotClient botClient, Message message, int buildingId)
{
if (message.Document != null)
{
using (TelegramContext db = new TelegramContext())
{
DataFile LessonsData = new DataFile {
FileId = message.Document.FileId, Name = message.Document.FileId + "Build", BuildingId = buildingId
};
await db.DataFiles.AddAsync(LessonsData);
await db.SaveChangesAsync();
}
}
else if (message.Photo != null && message.Photo.Count() > 0)
{
using (TelegramContext db = new TelegramContext())
{
DataFile LessonsData = new DataFile {
FileId = message.Photo[1].FileId, Name = "Photo" + message.Photo[1].FileId, BuildingId = buildingId
};
await db.DataFiles.AddAsync(LessonsData);
await db.SaveChangesAsync();
}
}
else
{
//await botClient.SendTextMessageAsync(message.Chat.Id, "Отправте следующий файл, или введите одну из команд!", Telegram.Bot.Types.Enums.ParseMode.Default);
}
}
public async Task SendNewsletter()
{
if (MessageCommand.Parameters.Count != 1)
{
await ReplyTextMessageAsync("Usage:\n/send_newsletter <newsletter>");
return;
}
var newsletterKey = MessageCommand.Parameters[0];
var newsletter = await _newsletterService.GetNewsletterByKeyAsync(newsletterKey);
if (newsletter != null)
{
TelegramChat !.State = SendingNewsletterState;
TelegramChat["newsletter"] = newsletterKey;
await ReplyTextMessageAsync("Ok, now send me the text formatted as HTML");
await TelegramContext.SaveChangesAsync();
}
else
{
await ReplyTextMessageAsync(
$"The newsletter {newsletterKey} doesn't exist.\n" +
$"Use /create_newsletter {newsletterKey} - to create it");
}
}
public static void StateControl(Telegram.Bot.TelegramBotClient botClient, Update update)
{
using (TelegramContext db = new TelegramContext())
{
var userState = db.UserStates.Where(x => x.User.Id == update.Message.From.Id).SingleOrDefault();
ActionStateSelected(userState, db, botClient, update);
}
}
public async Task Setup()
{
TelegramChat.Role = ChatRole.Administrator;
await _newsletterService.CreateNewsletterAsync(new Newsletter("default", "The default newsletter."));
await TelegramContext.SaveChangesAsync();
await ReplyTextMessageAsync("Done");
}
public TelegramServer(IConfiguration configuration, TelegramContext telegramContext, Dispatcher dispatcher, MqContext mqContext)
{
this.configuration = configuration;
this.telegramContext = telegramContext;
this.dispatcher = dispatcher;
this.mqContext = mqContext;
mqConsumer = CreateEventConsumer();
mqConsumer.Received += OnMqMessageReceived;
}
public void Start()
{
Context = new TelegramContext();
if (First)
{
//Context.Database.EnsureDeleted();
First = false;
}
Context.Database.EnsureCreated();
}
public static void StateUpdate(long userId, int state)
{
using (TelegramContext db = new TelegramContext())
{
var userState = db.UserStates.Where(x => x.User.Id == userId).SingleOrDefault();
userState.State = state;
db.UserStates.Update(userState);
db.SaveChanges();
}
}
public bool Add(TelegramContext context)
{
var user = context.Users.FirstOrDefault(u => u.Id == Id);
if (user != null)
{
return(false);
}
context.Add(this);
return(true);
}
public TelegramIntegrationEventService(
ILogger <TelegramIntegrationEventService> logger,
IEventBus eventBus,
TelegramContext telegramContext,
Func <DbConnection, IIntegrationEventLogService> integrationEventLogServiceFactory)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_telegramContext = telegramContext ?? throw new ArgumentNullException(nameof(telegramContext));
_integrationEventLogServiceFactory = integrationEventLogServiceFactory ?? throw new ArgumentNullException(nameof(integrationEventLogServiceFactory));
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
_eventLogService = _integrationEventLogServiceFactory(_telegramContext.Database.GetDbConnection());
}
public static async void AddBuilding(TelegramBotClient botClient, TelegramContext db, Message message)
{
try
{
StateManager.StateUpdate(message.Chat.Id, (int)UserStatesEnum.AddBuildingName);
await botClient.SendTextMessageAsync(message.Chat.Id, "Введи назву будівлі", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0);
}
catch (Exception ex)
{
await botClient.SendTextMessageAsync(message.Chat.Id, "Ошибка: " + ex.Message, Telegram.Bot.Types.Enums.ParseMode.Default);
}
}
public async Task <bool> AddAsync(TelegramContext context)
{
var user = await context.Users.FirstOrDefaultAsync(u => u.Id == Id);
if (user != null)
{
return(false);
}
await context.AddAsync(this);
return(true);
}
private static async Task <string> GetUsername(int id)
{
using (var context = new TelegramContext())
{
await context.Database.EnsureCreatedAsync();
var profile = await context.UserProfiles.FindAsync(id);
return(profile?.LastFm);
}
}
public static async void SetLastMessage(Telegram.Bot.TelegramBotClient botClient, int chatId, int newMessageId)
{
using (TelegramContext db = new TelegramContext())
{
var userState = db.UserStates.Where(x => x.User.Id == chatId).SingleOrDefault();
if (userState != null)
{
userState.LastMessageId = newMessageId;
db.UserStates.Update(userState);
await db.SaveChangesAsync();
}
}
}
public static void StateUpdate(long userId, int state, int?buildingId = null)
{
using (TelegramContext db = new TelegramContext())
{
var userState = db.UserStates.Where(x => x.UserId == userId).SingleOrDefault();
userState.State = state;
if (buildingId != null)
{
userState.BuildingId = (int)buildingId;
}
db.UserStates.Update(userState);
db.SaveChanges();
}
}
public async Task SendGlobalNewsletter()
{
if (MessageCommand.Parameters.Count != 0)
{
await ReplyTextMessageAsync("Usage:\n/send_global_newsletter");
return;
}
TelegramChat !.State = SendingNewsletterState;
TelegramChat["newsletter"] = null;
await ReplyTextMessageAsync("Ok, now send me the text formatted as HTML");
await TelegramContext.SaveChangesAsync();
}
public static async void MainMenu(Models.ObjectsModels.User user, TelegramContext db, Message message, Telegram.Bot.TelegramBotClient botClient)
{
var keyboard = new InlineKeyboardMarkup(
new InlineKeyboardButton[]
{
new InlineKeyboardButton {
Text = "Нова будівля", CallbackData = "AddBuilding"
}
}
);
var mess = await botClient.SendTextMessageAsync(message.Chat.Id, "Привіт, " + message.Chat.FirstName +
"! \n\nЦей бот створений для для того, щоб ми якомога швидше могли шукати будівлі. яким потрібна наша допомога. " +
"\n\nШвидше тисни кнопку, та рятуй прекрасне місто!🦄", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, keyboard);
}
public static async void AddBuildingAddress(TelegramBotClient botClient, TelegramContext db, Message message, UserState userState)
{
try
{
var building = db.Buildings.Where(x => x.Id == userState.BuildingId).SingleOrDefault();
building.Address = message.Text;
db.Buildings.Update(building);
db.SaveChanges();
StateManager.StateUpdate(message.Chat.Id, (int)UserStatesEnum.AddBuildingComment);
await botClient.SendTextMessageAsync(message.Chat.Id, "Введи коментар до будівлі", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0);
}
catch (Exception ex)
{
await botClient.SendTextMessageAsync(message.Chat.Id, "Ошибка: " + ex.Message, Telegram.Bot.Types.Enums.ParseMode.Default);
}
}
public static async void AddBuildingComment(TelegramBotClient botClient, TelegramContext db, Message message, UserState userState)
{
try
{
var building = db.Buildings.Where(x => x.Id == userState.BuildingId).SingleOrDefault();
building.Comment = message.Text;
db.Buildings.Update(building);
db.SaveChanges();
StateManager.StateUpdate(message.Chat.Id, (int)UserStatesEnum.AddBuildingPhoto);
await botClient.SendTextMessageAsync(message.Chat.Id, "Надсилай фото будівлі, а коли закінчиш напиши команду /save щоб зберегти пост!", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0);
}
catch (Exception ex)
{
await botClient.SendTextMessageAsync(message.Chat.Id, "Ошибка: " + ex.Message, Telegram.Bot.Types.Enums.ParseMode.Default);
}
}
public static void ActionStateSelected(UserState userState,
TelegramContext db,
Telegram.Bot.TelegramBotClient botClient,
Update update)
{
switch (userState.State)
{
case (int)UserStatesEnum.Empty: //Empty
break;
case (int)UserStatesEnum.AddVacancies:
VacanciesManager.ConfirmVacancу(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddHeader:
VacanciesManager.AddHeader(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddDescription:
VacanciesManager.AddDescription(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddResponsibilities:
VacanciesManager.AddResponsibilities(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddRequirements:
VacanciesManager.AddRequirements(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddOffered:
VacanciesManager.AddOffered(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddPaymentOffers:
VacanciesManager.AddPaymentOffers(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddAdditionalComment:
VacanciesManager.AddAdditionalComment(botClient, update.Message, db);
break;
case (int)UserStatesEnum.AddContacts:
VacanciesManager.AddContacts(botClient, update.Message, db);
break;
}
}
private static async Task <string> GetUserWeather(int id)
{
using (var context = new TelegramContext())
{
await context.Database.EnsureCreatedAsync();
var location = await context.UserLocations.FindAsync(id);
if (location != null)
{
var weatherInfo = await Weather.GetForecast(location.Latitude, location.Longitude);
return(FormatWeather(weatherInfo, location));
}
return(Strings.WeatherDefault);
}
}
public static async void AddBuildingName(TelegramBotClient botClient, TelegramContext db, Message message)
{
try
{
var building = new Building()
{
Name = message.Text, ParrentUserId = db.Users.Where(x => x.UserId == message.Chat.Id).Select(x => x.Id).SingleOrDefault()
};
db.Buildings.Add(building);
db.SaveChanges();
StateManager.StateUpdate(message.Chat.Id, (int)UserStatesEnum.AddBuildingAddress, building.Id);
await botClient.SendTextMessageAsync(message.Chat.Id, "Введи адресу будівлі", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0);
}
catch (Exception ex)
{
await botClient.SendTextMessageAsync(message.Chat.Id, "Ошибка: " + ex.Message, Telegram.Bot.Types.Enums.ParseMode.Default);
}
}
public static async void RemoveLastMessage(Telegram.Bot.TelegramBotClient botClient, int chatId)
{
using (TelegramContext db = new TelegramContext())
{
try
{
var userState = db.UserStates.Where(x => x.User.Id == chatId).SingleOrDefault();
if (userState != null && userState.LastMessageId != null)
{
await botClient.DeleteMessageAsync(chatId, (int)userState.LastMessageId);
userState.LastMessageId = null;
db.UserStates.Update(userState);
db.SaveChanges();
}
}
catch { }
}
}
public static async void ChoseCallBackQuery(Telegram.Bot.TelegramBotClient botClient, Update Update)
{
try
{
using (TelegramContext db = new TelegramContext())
{
var update = Update;
var user = db.Users.Where(x => x.UserId == update.CallbackQuery.From.Id).Single();
var callBack = update.CallbackQuery;
await botClient.AnswerCallbackQueryAsync(update.CallbackQuery.Id);
if (callBack.Data == "AddBuilding")
{
BuildingsManager.AddBuilding(botClient, db, update.CallbackQuery.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public override async Task ExecuteAsync(Message message, TelegramBotClient botClient)
{
var chatId = message.Chat.Id;
using (TelegramContext db = new TelegramContext())
{
var uState = db.UserStates.Where(x => x.UserId == chatId).SingleOrDefault();
var build = db.Buildings.Where(x => x.Id == uState.BuildingId).SingleOrDefault();
if (String.IsNullOrEmpty(build.Link))
{
string[] buildarr = new string[4];
buildarr[0] = build.Name;
buildarr[1] = build.Address;
buildarr[2] = build.Comment;
var photos = FilesManager.GetFileByBuilding(build.Id, botClient, db);
GoogleAPIauth.UploadNewBuilding(buildarr, photos, botClient);
}
}
}
public async void OnSendCodeCommandExecute(object obj)
{
await Task.Run(async() =>
{
TeleStatus = "Ожидание подтверждения";
IsSetCode = false;
TelegramContext.Code = AuthCode;
try
{
await TelegramContext.AuthUserAsync();
TeleStatus = "Вы вошли успешно!!!";
IsProgramStarted = true;
IsStartEnabled = true;
IsCanChangeNumber = false;
TLChannelFulls = await TelegramContext.GetFullInfoCannelsAsync();
foreach (var channel in TLChannelFulls)
{
ChannelsNames.Add(channel.About);
}
TelegramContext.LogOut();
MySelectedItem = ChannelsNames?[0];
}
catch (Exception ex)
{
TeleStatus = ex.Message;
if (File.Exists(PhotoPath + "dat"))
{
File.Delete(PhotoPath + "dat");
}
}
});
}
private static async Task AddOrUpdateUsername(int id, string newUsername)
{
using (var context = new TelegramContext())
{
await context.Database.EnsureCreatedAsync();
var profile = await context.UserProfiles.FindAsync(id);
if (profile == null)
{
var newProfile = new UserProfile {
Id = id, LastFm = newUsername
};
await context.UserProfiles.AddAsync(newProfile);
await context.SaveChangesAsync();
}
else
{
profile.LastFm = newUsername;
await context.SaveChangesAsync();
}
}
}
