public static async Task <RegStage> GetStageAsync(Message message)
{
var chatId = message.Chat.Id;
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
return(secretEvent.RegistrationStage);
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(Registration)}.{nameof(GetStageAsync)}:{e.Message}");
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException);
}
}
}
return(RegStage.NotStarted);
}
public static async Task SetStageAsync(Message message, TelegramBotClient client, RegStage stage)
{
var chatId = message.Chat.Id;
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
secretEvent.RegistrationStage = stage;
await db.SaveChangesAsync();
await ShowStageMessageAsync(message, client, stage);
}
else
{
await client.SendTextMessageAsync(chatId, @"You have to start registration using command /register");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(Registration)}.{nameof(SetStageAsync)}:{e.Message}");
}
}
}
public static async Task <bool> SetFieldAsync(Message message, RegStage stage)
{
var chatId = message.Chat.Id;
bool result = false;
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
switch (stage)
{
case RegStage.SetName:
secretEvent.Name = message.Text;
result = true;
break;
case RegStage.SetDate:
secretEvent.Date = message.Text;
result = true;
break;
case RegStage.SetPlace:
secretEvent.Place = message.Text;
result = true;
break;
case RegStage.SetCount:
int count;
if (int.TryParse(message.Text, out count))
{
secretEvent.ParticipantsCount = count;
result = true;
}
break;
case RegStage.SetInfo:
secretEvent.Info = message.Text;
result = true;
break;
}
await db.SaveChangesAsync();
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(Registration)}.{nameof(SetFieldAsync)}:{e.Message}");
}
}
return(result);
}
public override async Task ExecuteAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
await client.SendChatActionAsync(chatId, ChatAction.Typing);
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
var telegramChatsIds = secretEvent.Participants.Select(x => x.Id).ToArray();
if (telegramChatsIds.Length >= minimumParticipantsCount)
{
telegramChatsIds.Shuffle();
for (int i = 0; i < telegramChatsIds.Count(); i++)
{
var chat = secretEvent.Participants.ElementAt(i);
chat.GiftUser = secretEvent.Participants.First(x => x.Id == telegramChatsIds[i]);
}
await client.SendTextMessageAsync(chatId, "The Magic Hat completed its work successfully! Each participant will" +
" automatically receive a message with the name of the person to whom he is giving the gift.");
await MessageDistributor.SendParticipantsMessageAsync(message, client);
}
else
{
await client.SendTextMessageAsync(chatId, $"Sorry, to use this command, there must be at least {minimumParticipantsCount} participants.");
}
}
else
{
await client.SendTextMessageAsync(chatId, @"You have to start registration using command /register.");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(ShuffleCommand)}:{e.Message}");
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException);
}
}
}
}
public static async Task SendParticipantsMessageAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
foreach (var participant in secretEvent.Participants)
{
var giftUser = participant.GiftUser;
var sb = new StringBuilder($"Person to whom you give a gift: {giftUser.FirstName} ");
if (!string.IsNullOrEmpty(giftUser.LastName))
{
sb.Append(giftUser.LastName);
}
if (!string.IsNullOrEmpty(giftUser.UserName))
{
sb.Append($"(@{giftUser.UserName})");
}
await client.SendTextMessageAsync(participant.ChatId, sb.ToString());
}
}
else
{
await client.SendTextMessageAsync(chatId, @"You have to start registration using command /register");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(MessageDistributor)}:{e.Message}");
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException);
}
}
}
}
public override async Task ExecuteAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
await client.SendChatActionAsync(chatId, ChatAction.Typing);
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var events = db.Events;
var _event = await events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (_event == null)
{
SecretSantaEvent secretSantaEvent = new SecretSantaEvent(chatId);
if (events.Where(x => x.InviteKey.Equals(secretSantaEvent.InviteKey)).Any())
{
secretSantaEvent.GenerateInviteKey();
}
db.Events.Add(secretSantaEvent);
await db.SaveChangesAsync();
await client.SendTextMessageAsync(chatId, "You can fill optional fields or/and generate invitation using command /generate.");
}
else
{
await client.SendTextMessageAsync(chatId, "You are already registered. You can fill optional fields or/and generate invitation.");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(RegisterCommand)}:{e.Message}");
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException.Message);
}
}
}
await Registration.SetStageAsync(message, client, RegStage.SelectOption);
await RegistrationStatus.Execute(message, client);
}
public async override Task ExecuteAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
await client.SendChatActionAsync(chatId, ChatAction.Typing);
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var events = db.Events;
var _event = await events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (_event != null)
{
var userList = _event.Participants;
if (userList.Count > 0)
{
db.Users.RemoveRange(userList);
}
db.Events.Remove(_event);
await db.SaveChangesAsync();
await client.SendTextMessageAsync(chatId, "Event and participants was successfully removed.");
}
else
{
await client.SendTextMessageAsync(chatId, "There is nothing to remove.");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(RemoveEventCommand)}:{e.Message}");
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException);
}
}
}
}
public override async Task ExecuteAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
bool userExists = false;
TelegramChat user = new TelegramChat
{
ChatId = chatId,
FirstName = message.Chat.FirstName,
LastName = message.Chat.LastName,
UserName = message.Chat.Username
};
using (TelegramChatContext db = new TelegramChatContext())
{
await client.SendTextMessageAsync(chatId, "Created DB context");
try
{
/*db.Database.Connection.Open();
* await client.SendTextMessageAsync(chatId, "Opened DB connection");*/
var users = db.Users;
await client.SendTextMessageAsync(chatId, "Get users");
foreach (var dbUser in users)
{
await client.SendTextMessageAsync(chatId, $"Check for user:{dbUser}");
if (user.ChatId == dbUser.ChatId)
{
await client.SendTextMessageAsync(chatId, "Your data already saved in db.");
userExists = true;
break;
}
}
if (!userExists)
{
await client.SendTextMessageAsync(chatId, "Try to add user to DB");
db.Users.Add(user);
await client.SendTextMessageAsync(chatId, "User has been added, trying to save changes");
await db.SaveChangesAsync();
await client.SendTextMessageAsync(chatId, $"ChatId={user.ChatId} and userName={user.FirstName} added to db.");
}
else
{
await client.SendTextMessageAsync(chatId, "User already exists in DB");
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
}
await client.SendTextMessageAsync(chatId, "Disposed");
}
public static async Task Execute(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
bool userExists = false;
Regex regex = new Regex(@"^\/start\s(.*)");
Match match = regex.Match(message.Text);
if (match.Success)
{
string eventKey = match.Groups[1].Value;
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var events = db.Events;
var _event = await events.FirstOrDefaultAsync(x => x.InviteKey == eventKey);
TelegramChat user = new TelegramChat
{
ChatId = chatId,
FirstName = message.Chat.FirstName,
LastName = message.Chat.LastName,
UserName = message.Chat.Username,
};
foreach (var eventUser in _event.Participants)
{
if (eventUser.ChatId == user.ChatId)
{
userExists = true;
break;
}
}
if (!userExists)
{
_event.Participants.Add(user);
await db.SaveChangesAsync();
await client.SendTextMessageAsync(chatId, $"Congratulations! You are registered to event!");
//await client.SendTextMessageAsync(chatId, $"Now you can add wishlist using next syntax: /addWish Type your wish here");
//await client.SendTextMessageAsync(chatId, $"To clear wish list use command /clearWishList");
//await client.SendTextMessageAsync(chatId, $"To show wish list use command /showWishList");
await client.SendTextMessageAsync(chatId, $"When the event organizer closes the registration, " +
$"I will send you a message with a random participant to whom you will give a gift.");
}
else
{
await client.SendTextMessageAsync(chatId, "You don't need to register to this event again.");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(UserStart)}:{e.Message}");
}
}
}
else
{
await client.SendTextMessageAsync(chatId, "Ooops, something wrong with your link or such event is not exists.");
}
}
public override async Task ExecuteAsync(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
string status = @"Hello\!👋" + Environment.NewLine;
await client.SendChatActionAsync(chatId, ChatAction.Typing);
using (TelegramChatContext db = new TelegramChatContext())
{
try
{
var secretEvent = await db.Events.FirstOrDefaultAsync(x => x.HostChatId == chatId);
if (secretEvent != null)
{
if (!string.IsNullOrWhiteSpace(secretEvent.Name))
{
status += string.Format(statusName, secretEvent.Name);
}
else
{
status += string.Format(statusName, "Secret Santa");
}
if (!string.IsNullOrWhiteSpace(secretEvent.Date))
{
status += string.Format(statusDate, secretEvent.Date);
}
if (!string.IsNullOrWhiteSpace(secretEvent.Place))
{
status += string.Format(statusPlace, secretEvent.Place);
}
if (!string.IsNullOrWhiteSpace(secretEvent.ParticipantsCount.ToString()))
{
if (secretEvent.ParticipantsCount > 0)
{
status += string.Format(statusCount, secretEvent.ParticipantsCount);
}
}
if (!string.IsNullOrWhiteSpace(secretEvent.Info))
{
status += string.Format(statusInfo, secretEvent.Info);
}
status += string.Format(statusLink, secretEvent.InviteKey);
await client.SendTextMessageAsync(chatId, "Forward the next message to participants");
await client.SendTextMessageAsync(chatId, status, ParseMode.MarkdownV2);
await client.SendTextMessageAsync(chatId, "When all participants are accepted their invitations (you can check it by command /status), use command /shuffle to shuffle participants list.");
}
else
{
await client.SendTextMessageAsync(chatId, "You have to start registration using command /register");
}
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(GenerateCommand)}:{e.Message}");
}
}
}
