public async Task Handle(TelegramChatJoinEvent @event)
        {
            try
            {
                var chatResponse = await _telegramHttpClient.GetChatByNameOrLink(@event.ChatUserName);

                var message = new TGSendMessageDTO
                {
                    ChatId = @event.TgChatId
                };
                if (chatResponse.IsOK)
                {
                    var type = chatResponse.Result.GetChatType();
                    if (type == ChatType.Private || type == ChatType.None)
                    {
                        message.Text = "用户名仅支持群组或频道";
                    }
                    else
                    {
                        var chat = await _chatService.GetByTGChatId(chatResponse.Result.Id);

                        if (chat == null)
                        {
                            chat = await _chatService.GetOrCreateChat(chatResponse.Result, @event.TgUserId);

                            message.Text = $"【{chatResponse.Result.Title}】 收录成功! 你可以继续输入其他群组用户名";
                            _eventBus.Publish(new TelegramChatRefreshEvent(chat.Id));
                        }
                        else
                        {
                            message.Text = "此群组已经收录过了,请勿重复操作!";
                        }
                    }
                }
                else
                {
                    message.Text = "未能找到群组或者频道";
                }
                await _telegramHttpClient.SendMessage(message);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "添加群组失败");
            }
        }
Пример #2
0
        public async Task HandleMessage(TGMessageDTO dto, User user, Message message)
        {
            var chatType = dto.Chat.GetChatType();

            if (chatType != ChatType.Private)
            {
                if (dto.Text.ToUpper().Contains(ApplicationDefaults.CNBotUserName))
                {
                    // Only use command in private chat
                    await _telegramHttpClient.SendMessage(TGSendMessageDTO.BuildOnlyUseInPrivateMessage(dto.Chat.Id, dto.MessageId));
                }
                //If not my command. Nothing to do
                return;
            }
            var             utcNow      = DateTime.UtcNow;
            UserCommandType commandType = dto.GetCommandType();

            if (commandType == UserCommandType.None)
            {
                var lastCommand = await _userService.FindLastCommand(user.Id);

                if (lastCommand == null || lastCommand.Completed)
                {
                    // No command found. So we just show the default message
                    await _telegramHttpClient.SendMessage(TGSendMessageDTO.BuildUnrecognizedMessage(dto.Chat.Id, dto.MessageId));

                    return;
                }
                else
                {
                    commandType = lastCommand.Type;
                }
            }
            var command = new UserCommand
            {
                Created   = utcNow,
                Completed = false,
                Type      = commandType,
                UserId    = user.Id,
                Text      = dto.Text
            };
            await _userService.AddCommand(command);

            await this.HandleCommand(dto, command, message);

            if (command.Type != UserCommandType.Remove && dto.Entities != null && dto.Entities.Any())
            {
                _eventBus.Publish(new TelegramMessageEntityExtractEvent(dto.Entities));
            }
        }