示例#1
0
        private IObservable <Message> MapToMessage(TdApi.Message msg)
        {
            return(_agent.Execute(new TdApi.GetChat
            {
                ChatId = msg.ChatId
            })
                   .Select(chat => new Message
            {
                MessageData = msg,
                Chat = chat
            })
                   .SelectMany(message =>
            {
                if (message.MessageData.SenderUserId != 0)
                {
                    return _agent.Execute(new TdApi.GetUser
                    {
                        UserId = message.MessageData.SenderUserId
                    })
                    .Select(user => new Message
                    {
                        MessageData = message.MessageData,
                        Chat = message.Chat,
                        User = user
                    });
                }

                return Observable.Return(message);
            }));
        }
示例#2
0
        private IObservable <TdApi.InputMessageContent> ReplyToDocumentMessage(
            TdApi.Message message,
            TdApi.MessageContent.MessageDocument messageContent)
        {
            var file = messageContent.Document.Document_;

            return(_fileLoader.LoadFile(file)
                   .FirstAsync(f => f.Local != null && f.Local.IsDownloadingCompleted)
                   .SelectMany(f =>
            {
                var localFile = f.Local?.Path;

                if (localFile != null && File.Exists(localFile))
                {
                    return File.ReadAllTextAsync(localFile)
                    .ToObservable()
                    .Select(content => new TdApi.InputMessageContent.InputMessageText
                    {
                        Text = new TdApi.FormattedText
                        {
                            Text = $"You said: {content}"
                        }
                    });
                }

                return Observable.Empty <TdApi.InputMessageContent>();
            }));
        }
示例#3
0
        private async Task <TelegramMessage> CreateMessage(TdApi.Message tdMessage)
        {
            if (tdMessage.Content is TdApi.MessageContent.MessageText text)
            {
                var sent = DateTimeOffset.FromUnixTimeSeconds((long)tdMessage.Date).UtcDateTime;
                var chat = await GetChat(tdMessage.ChatId);

                var msgSender = await GetTelegramContact(tdMessage.SenderUserId);

                if (_chats.ContainsKey(tdMessage.ChatId))
                {
                    var msg = new TelegramMessage
                    {
                        MessageId     = tdMessage.Id,
                        ChatId        = tdMessage.ChatId,
                        ChatName      = chat.Title,
                        Text          = text.Text.Text,
                        Sent          = sent,
                        SenderContact = msgSender
                    };
                    return(msg);
                }
            }

            return(null);
        }
示例#4
0
        public void PushMessageToStack(long chatId, TdApi.Message message)
        {
            if (!_stackedMessages.TryGetValue(chatId, out var stack))
            {
                stack = new Stack <TdApi.Message>();
                _stackedMessages.Add(chatId, stack);
            }

            stack.Push(message);
        }
        private IObservable <Message> MapToMessage(
            MessageLoaderScope scope,
            TdApi.Message msg,
            bool fetchReply = true)
        {
            return(Observable.Return(new Message
            {
                MessageData = msg
            })
                   .SelectSeq(message =>
            {
                // get chat data
                return scope.GetChat(msg.ChatId)
                .Select(chat =>
                {
                    message.ChatData = chat;
                    return message;
                });
            })
                   .SelectSeq(message =>
            {
                // get user data
                if (message.MessageData.SenderUserId != 0)
                {
                    return scope.GetUser(message.MessageData.SenderUserId)
                    .Select(user =>
                    {
                        message.UserData = user;
                        return message;
                    });
                }

                return Observable.Return(message);
            })
                   .SelectSeq(message =>
            {
                // get reply data
                if (fetchReply && message.MessageData.ReplyToMessageId != 0)
                {
                    return scope.GetMessage(message.MessageData.ChatId, message.MessageData.ReplyToMessageId)
                    .SelectSeq(m => MapToMessage(scope, m, false))
                    .Select(reply =>
                    {
                        message.ReplyMessage = reply;
                        return message;
                    });
                }

                return Observable.Return(message);
            }));
        }
示例#6
0
        private IObservable <TdApi.InputMessageContent> ReplyToTextMessage(
            TdApi.Message message,
            TdApi.MessageContent.MessageText messageContent)
        {
            var content = messageContent.Text.Text;

            var reply = new TdApi.InputMessageContent.InputMessageText
            {
                Text = new TdApi.FormattedText
                {
                    Text = $"You said: {content}"
                }
            };

            return(Observable.Return(reply));
        }
 private void CheckGoldChannelMessage(TdApi.Message message)
 {
     try
     {
         //DataReceiveHelper.Information.AppendLine("Gold Message Received");
         var messageText = "";
         if (message.Content is TdApi.MessageContent.MessageText text)
         {
             messageText = text.Text.Text;
         }
         var price = FindGoldPrice(messageText);
         if (price <= 0)
         {
             return;
         }
         var tomorrowMeltedGold = new TomorrowMeltedGold
         {
             MessageId   = message.Id,
             MessageText = messageText,
             Date        = UnixTimeStampToDateTime(message.Date),
             Price       = price
         };
         var goldOptionsBuilder = new DbContextOptionsBuilder <TomorrowMeltedGoldContext>();
         goldOptionsBuilder.UseSqlServer(_connectionString);
         using var goldContext =
                   new TomorrowMeltedGoldContext(goldOptionsBuilder.Options);
         if (goldContext.TomorrowMeltedGold.Any(item =>
                                                item.MessageId == tomorrowMeltedGold.MessageId))
         {
             return;
         }
         goldContext.Add(tomorrowMeltedGold);
         goldContext.SaveChanges();
         //DataReceiveHelper.Information.AppendLine("New Gold Message Added");
     }
     catch (TdException e)
     {
         var error = e.Error;
         DataReceiveHelper.Information.AppendLine("CheckGoldChannelMessage-1 " + error.Message);
     }
     catch (Exception ex)
     {
         DataReceiveHelper.Information.AppendLine("CheckGoldChannelMessage-2 " + ex.Message);
     }
 }