public async Task Run(ITeleCommands cmd, TelegramUser user, MessageEventArgs e)
{
if (cmd == null)
{
}
await cmd.Run(user, e.Message);
}
private async void ReceivedMessageReminderTime(TelegramUser user, Reminder reminder, string messageReceived)
{
try
{
TimeSpan sendTime = new TimeSpan();
if (TimeSpan.TryParse(messageReceived, out sendTime))
{
if (reminder == null)
{
await sendMessageAsync(user.TelegramChatId, $"Cadastro falhou. Inicie novamente.");
return;
}
reminder.SetTimeToRemind(sendTime);
await sendMessageAsync(user.TelegramChatId, $"Cadastro criado com sucesso!!!{Environment.NewLine}{Environment.NewLine}Você receberá a mensagem: {reminder.TextMessage}{Environment.NewLine}Todos os dias as {reminder.RemindTimeToSend.ToString()}");
_unitOfWork.Reminders.Update(reminder);
_unitOfWork.TelegramUsers.Update(user);
}
else
{
await sendMessageAsync(user.TelegramChatId, "Não reconheço este formato de horário. O horário precisa estar no formato HH:MM");
}
}
catch (Exception ex)
{
_logger.LogError($"{DateTime.Now} : {ex.ToString()}");
}
}
private async void ReceivedMessageReminder(TelegramUser user)
{
try
{
var keyboard = new ReplyKeyboardMarkup
{
Keyboard = new[]
{
new[]
{
new KeyboardButton("Iniciar")
},
new [] {
new KeyboardButton("Consultar")
}
}
};
string texto = $"Selecione uma das opções no teclado que apareceu para você ou digite:{Environment.NewLine}" +
$"*Iniciar* - para iniciar o cadastro de um lembrete{Environment.NewLine}" +
$"*Consultar* - para consultar os lembretes ativos{Environment.NewLine}";
await sendMessageAsync(user.TelegramChatId, texto, keyboard);
}
catch (Exception ex)
{
_logger.LogError($"{DateTime.Now} : {ex.ToString()}");
}
}
private async Task <TelegramUser> GetOrCreateTelegramUser(TelegramUserDto dto)
{
var user = await hookrRepository
.ReadAsync((context, token) => context.TelegramUsers
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == dto.Id, token),
Token);
if (user != null)
{
await UpdateTelegramUserAsync(hookrRepository.Context.Update(user).Entity, dto);
return(user);
}
var createdUser = new TelegramUser
{
Id = dto.Id,
State = TelegramUserStates.Default
};
await UpdateTelegramUserAsync(hookrRepository.Context.Add(createdUser).Entity,
dto);
return(createdUser);
}
public MainWindow()
{
InitializeComponent();
Users = new ObservableCollection <TelegramUser>();
usersList.ItemsSource = Users;
MsgsId = new List <int>();
string token = "1379182133:AAEK55Lcz8yTQZzkcQGvHBHIEL-Jyl5FN0k";
bot = new TelegramBotClient(token);
bot.OnMessage += delegate(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
string msg = $"{DateTime.Now}: {e.Message.From.FirstName} {e.Message.From.Id} {e.Message.Text}";
File.AppendAllText("data.log", $"{msg}\n");
Debug.WriteLine(msg);
this.Dispatcher.Invoke(() =>
{
bool isTimerOn = false;
var person = new TelegramUser(e.Message.From.FirstName, e.Message.From.Id);
if (!Users.Contains(person))
{
Users.Add(person);
}
string mes = (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Text) ? e.Message.Text : e.Message.Type.ToString();
Users[Users.IndexOf(person)].AddMessage($"{e.Message.Chat.Id} {person.Nick}: {e.Message.MessageId} {mes}");
if ((e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Text) && (e.Message.EntityValues == null))
{
if (!isTimerOn)
{
isTimerOn = true;
SendWarning(e.Message.Chat.Id);
TimerCallback tm = new TimerCallback(DeleteMsgs);
Timer timer = new Timer(tm, e.Message.Chat.Id, 0, 60000);
}
if (isTimerOn)
{
MsgsId.Add(e.Message.MessageId);
}
}
});
};
bot.StartReceiving();
btnSendMsg.Click += delegate { SendMsg(); };
txtBxSendMsg.KeyDown += (s, e) => { if (e.Key == Key.Return)
{
SendMsg();
}
};
txtBxSendMsg.MouseMove += delegate { ClearText(); };
txtBxSendMsg.MouseLeave += delegate { DisplayText(); };
}
public static TelegramUser SetGuns(this TelegramUser user)
{
IEnumerable <uint> readUints() => Console.ReadLine().Split(":").Select(new Func <string, uint>(Convert.ToUInt32));
Console.Write("Restrict power [days:hours:minutes]: ");
TimeSpan span;
try
{
var arr = readUints().ToList();
span = new TimeSpan((int)arr[0], (int)arr[1], (int)arr[2], 0);
}
catch
{
Console.WriteLine("Error: It was necessary to enter days:hours:mnutes, like 1:23:59");
return(user);
}
Console.Write("Number of bullets and guns [guns:bullets]: ");
uint guns, bullets;
try
{
var GunsAndBullets = readUints();
guns = GunsAndBullets.First();
bullets = GunsAndBullets.Last();
}
catch
{
Console.WriteLine("Error: It was necessary to enter guns:bullets, like 1:5");
return(user);
}
user.Property[span] = (guns, bullets);
return(user);
}
private TelegramUser CreateNewTelegramUser()
{
var user = new TelegramUser();
_telegramUserRepository.Add(user);
return(user);
}
public UserModel GetUser(long tuserId, string fromUsername, string fromFirstName, string fromLastName)
{
using (var dataModel = new Mibarim_plusEntities())
{
var res = new UserModel();
var user = dataModel.TelegramUsers.FirstOrDefault(x => x.TelegramUserId == tuserId);
if (user == null)
{
var tuser = new TelegramUser();
tuser.TmsgUserName = fromUsername;
tuser.TmsgName = fromFirstName;
tuser.TelegramUserId = tuserId;
tuser.TmsgFamily = fromLastName;
tuser.TcreateTime = DateTime.Now;
dataModel.TelegramUsers.Add(tuser);
dataModel.SaveChanges();
user = tuser;
}
res.TuserId = user.TuserId;
res.UserName = user.TmsgUserName;
res.Name = user.TmsgName;
res.TelegramUserId = tuserId;
res.Family = user.TmsgFamily;
res.CreateTime = user.TcreateTime;
res.UserId = user.UserId == null ? 0 : (long)user.UserId;
return(res);
}
}
private string RecivePassword(Update update)
{
try
{
using (botEntities3 bd = new botEntities3())
{
TelegramUser tg = bd.TelegramUser.Where(x => x.Username == update.callback_query.from.id.ToString()).FirstOrDefault();
if (tg == null)
{
return("Вы еще не зареистрированы");
}
Users users = bd.Users.Where(x => x.Id == tg.UserId).FirstOrDefault();
if (users != null)
{
return("Ваш пароль " + users.Passwords + " Ваш логин " + " " + users.Email);
}
else
{
return("Вы еще не зарегистрированы");
}
}
}
catch
{
return("Вы еще не зареистрированы");
}
}
/// <summary>
/// Запись в файл-конфигурацию нового пользователя
/// </summary>
/// <param name="user"></param>
public void SetNewUser(TelegramUser user)
{
var xFile = new XmlDocument();
xFile.Load("Config.config");
var xElement = xFile.DocumentElement;
var xRoot = xElement?.SelectSingleNode("UsersAccessList");
var userNode = xFile.CreateElement("User");
var userId = xFile.CreateElement("TelegramId");
var userAllowed = xFile.CreateElement("Allowed");
var userIdValue = xFile.CreateTextNode(user.TelegramId.ToString());
var userAllowedValue = xFile.CreateTextNode(user.Allowed.ToString());
userId.AppendChild(userIdValue);
userAllowed.AppendChild(userAllowedValue);
userNode.AppendChild(userId);
userNode.AppendChild(userAllowed);
xRoot?.AppendChild(userNode);
xFile.Save("Config.config");
}
protected override Task CustomOrderAsyncValidator(Order order, TelegramUser user)
{
if (order.State != AllowedState)
{
throw new InvalidOperationException("Order has insufficient state to perform this action.");
}
return(Task.CompletedTask);
}
private async Task UpdateTelegramUserAsync(TelegramUser user,
TelegramUserDto dto)
{
user.Username = dto.Username;
user.FirstName = dto.FirstName;
user.PhotoUrl = dto.PhotoUrl;
user.LastUpdatedAt = DateTime.UtcNow;
await hookrRepository.SaveChangesAsync();
}
protected override Task CustomOrderAsyncValidator(Order order, TelegramUser user)
{
if (order.State != OrderStates.Constructing)
{
throw new InvalidOperationException("Order is already confirmed.");
}
return(Task.CompletedTask);
}
public TelegramMember()
{
// PortAdmins=new HashSet<PortAdmin>();
// TelegramBotMessages=new List<TelegramBotMessage>();
TelegramMemberGuid = Guid.NewGuid();
// TelegramMemberBotSettings=new List<TelegramMemberBotSetting>();
TelegramUser = new TelegramUser();
Gender = true;
}
public void SetUp()
{
telegramUser = new TelegramUser(1337);
botLogic = new BotLogic(new MockDataBase());
telegramHandler = new TelegramHandler(null);
telegramHandler.OnMessage += botLogic.ExecuteUserRequest;
botLogic.OnReply += Nothing;
}
private static Session SessionFactory(TelegramUser user)
=> new Session
{
Key = Guid.NewGuid(),
Id = user.Id,
State = user.State,
Username = user.Username,
PhotoUrl = user.PhotoUrl,
FirstName = user.FirstName
};
public static bool FasAnswer(string msgText, ApplicationContext db, TelegramUser @from, TelegramBotClient client,
Update update)
{
var message = update.Message;
var textForSend = GetAnswer(db, msgText);
Thread.Sleep(3000);
client.SendTextMessageAsync(message.Chat.Id, textForSend);
return(true);
}
//First
public ITeleCommands ByInline(TelegramUser user, MessageEventArgs e, ITeleCommands cmd)
{
var inline = _inline.GetInline(e.Message.Text);
if (inline == null)
{
return(ByProject(user, e, cmd));
}
cmd = _commands.FirstOrDefault(m => m.Name.ToLower() == inline.CommandName);
return(cmd ?? ByProject(user, e, cmd));
}
public ITeleCommands ByProject(TelegramUser user, MessageEventArgs e, ITeleCommands cmd)
{
var project = _project.GetFirst(m => m.Name.ToLower() == e.Message.Text.ToLower());
if (project != null)
{
cmd = _commands.FirstOrDefault(m => m.Name == "/project");
cmd.SetData <Project>(project);
}
return(cmd ?? ByLastCommand(user, e, cmd));
}
public string RegisterTelegram(string telegramID)
{
var user = new TelegramUser {
TelegramID = telegramID
};
var result = context.TelegramUsers.Add(user);
context.SaveChanges();
return("true");
}
public void DeleteSubreddit(string subreddit, TelegramUser user)
{
var users = SettingsController.SettingsStore.TelegramUsers
.Where(u => u.Subreddits.Contains(subreddit)).ToList();
if (users.Count == 1 && users.Contains(user))
{
WatchedSubreddits.Remove(subreddit);
LastSubredditsNews.Remove(subreddit);
}
}
public void Parse(Message message, TelegramUser user)
{
User = user;
var command = message.Text;
if (CommandRegex.IsMatch(command))
{
Do(CommandArgs(command));
}
}
/// <summary>
/// Получить модель пользователя.
/// </summary>
/// <param name="chatId">Идентификтаор чата с пользователем.</param>
/// <param name="firstName">Имя пользователя</param>
/// <param name="nickName">Ник пользователя.</param>
public static TelegramUser GetUser(long chatId, string firstName, string nickName)
{
TelegramUser user;
if (UsersMapper.TryGetValue(chatId, out user))
{
return(user);
}
user = new TelegramUser(chatId, firstName, nickName);
UsersMapper.Add(chatId, user);
return(user);
}
public Response Execute(TelegramUser user, List <string> args, UpdateModel update)
{
var keyboard = new InlineKeyboardMarkup();
keyboard.AddButton("Test", "/heas");
return(new Response()
{
KeyboardMarkup = keyboard,
Text = "Hello world"
});
}
public async Task ProcessNewChatMember(Update update)
{
var message = update.Message;
var freshness = DateTime.UtcNow - message.Date.ToUniversalTime();
if (freshness > _settings.ProcessEventTimeout)
{
_logger.LogInformation($"Сообщение о {message.NewChatMembers.Length} получено {freshness} назад и проигнорировано");
return;
}
foreach (var unauthorizedUser in message.NewChatMembers)
{
await _telegramBot.RestrictChatMemberAsync(
message.Chat.Id,
unauthorizedUser.Id,
new ChatPermissions
{
CanAddWebPagePreviews = false,
CanChangeInfo = false,
CanInviteUsers = false,
CanPinMessages = false,
CanSendMediaMessages = false,
CanSendMessages = false,
CanSendOtherMessages = false,
CanSendPolls = false
},
DateTime.Now.AddDays(1));
var answer = new Random().Next(1, ButtonsCount + 1);
var prettyUserName = GetPrettyName(unauthorizedUser);
var sendTextMessage = await _telegramBot.SendTextMessageAsync(
message.Chat.Id,
$"Привет, {prettyUserName}, нажми кнопку {answer}, чтобы тебя не забанили!",
replyToMessageId : message.MessageId,
replyMarkup : new InlineKeyboardMarkup(GetKeyboardButtons()));
var telegramUser = new TelegramUser(
message.Chat.Id,
message.From.Id,
sendTextMessage.MessageId,
message.MessageId,
GetPrettyName(message.From),
answer);
_userService.Add(telegramUser);
_logger.LogInformation(
$"Новый пользователь {unauthorizedUser.Id} с именем {prettyUserName} Обнаружен и испытан. " +
$"У него есть {_settings.ProcessEventTimeout.ToString()}, чтобы ответить.");
}
}
public void Remember([Description("День")] int Day,
[Description("Номер пары")] int Num,
[Description("Название пары")] string LessonName,
[Description("Кабинет")] int Cabinet)
{
var user = Db.Users.FirstOrDefault(x => x.Id == Update.Message.FromUser.UserId);
if (user == null)
{
user = new TelegramUser()
{
Id = Update.Message.FromUser.UserId,
Name = Update.Message.FromUser.FirstName
};
Db.Users.Add(user);
}
var schedule = user.Schedule;
if (schedule == null)
{
schedule = new Schedule();
user.Schedule = schedule;
Db.Schedules.Add(schedule);
}
if (Day < 1 || Day > 7)
{
var msg = string.Format("В неделе 1 дней!!");
API.SendMessage(Update.Message.Chat, msg);
}
var day = schedule.Days[Day - 1];
var lesson = new Lesson()
{
Name = LessonName,
Cabinet = Cabinet
};
if (day.Lessons.ContainsKey(Num))
{
day.Lessons[Num] = lesson;
}
else
{
day.Lessons.Add(Num, lesson);
}
Db.Save();
API.SendMessage(Update.Message.Chat, "Запомнил");
}
public static AppUser ToEntity(this TelegramUser user, UserRole role)
{
return(new AppUser
{
FirstName = user.FirstName,
LastName = user.LastName,
IsBot = user.IsBot,
LanguageCode = user.LanguageCode,
TelegramId = user.Id,
UserRole = role,
UserName = user.Username
});
}
public static TelegramUser SetMoney(this TelegramUser user)
{
Console.Write("Money: ");
if (UInt32.TryParse(Console.ReadLine(), out var m))
{
user.Money = m;
}
else
{
Console.WriteLine("Error: It was necessary to enter number of money.");
}
return(user);
}
private void InitializeUser(TelegramUser user)
{
TelegramUser = new TelegramUserWrapper(user);
TelegramUser.PropertyChanged += (s, e) =>
{
if (!HasChanges)
{
HasChanges = _telegramUserRepository.HasChanges();
}
//TODO: add raiseCanExecuteChanged() if has errors
};
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
}
private TelegramUserModel ConvertEntityToTelegramUserModel(TelegramUser entity)
{
return(new TelegramUserModel
{
Id = entity.Id,
FirstName = entity.FirstName,
LastName = entity.LastName,
LanguageCode = entity.LanguageCode,
Username = entity.Username,
ChatId = entity.ChatId,
UserId = entity.UserId
});
}
