public async ValueTask <ThumbnailCache?> FindOneAsync(NestedPath filePath, int width, int height, ThumbnailResizeType resizeType, ThumbnailFormatType formatType)
        {
            await Task.Delay(1).ConfigureAwait(false);

            using (await _asyncLock.LockAsync())
            {
                var id = new ThumbnailCacheIdEntity()
                {
                    FilePath            = NestedPathEntity.Import(filePath),
                    ThumbnailWidth      = width,
                    ThumbnailHeight     = height,
                    ThumbnailResizeType = resizeType,
                    ThumbnailFormatType = formatType,
                };
                var storage = this.GetStorage();

                var liteFileInfo = storage.FindById(id);
                if (liteFileInfo is null)
                {
                    return(null);
                }

                using (var inStream = liteFileInfo.OpenRead())
                {
                    return(RocketMessage.FromStream <ThumbnailCache>(inStream));
                }
            }
        }
Ejemplo n.º 2
0
        public void When_bot_is_mentioned_set_flag()
        {
            var rocketMessage = AutoFixture.Build <RocketMessage>()
                                .Create();
            var payload = new
            {
                id         = AutoFixture.Create <string>(),
                msg        = "added",
                collection = "stream-messages",
                fields     = new
                {
                    args = new object[]
                    {
                        AutoFixture.Create <string>(),
                        rocketMessage
                    }
                }
            };

            RocketMessage result = null;

            _driver.MessageReceived += message => result = message;

            // Act
            _mockClient.DataReceivedRaw += Raise.Event <DataReceived>(payload.msg, JObject.FromObject(payload));

            // Assert
            result.Should().NotBeNull();
            result.Message.Should().Be(rocketMessage.Message);
        }
Ejemplo n.º 3
0
        public async Task When_sending_messages_bot_flag_should_be_set()
        {
            var text            = AutoFixture.Create <string>();
            var messageReceived = new AutoResetEvent(false);

            RocketMessage message = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                message = rocketMessage;
                messageReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            // Act
            await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            messageReceived.WaitOne(_timeout);

            // Assert
            message.Should().NotBeNull();
            message.IsBot.Should().BeTrue();
        }
Ejemplo n.º 4
0
        public async Task Can_send_messages()
        {
            var text            = AutoFixture.Create <string>();
            var messageReceived = new AutoResetEvent(false);

            RocketMessage message = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                message = rocketMessage;
                messageReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            // Act
            var result = await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            messageReceived.WaitOne(_timeout);

            // Assert
            result.HasError.Should().BeFalse();
            message.Should().NotBeNull();
            result.Result.ToString().Should().Be(message.ToString());
        }
Ejemplo n.º 5
0
        public async Task Can_set_reaction()
        {
            const string reactionName    = ":grinning:";
            var          text            = AutoFixture.Create <string>();
            var          messageReceived = new AutoResetEvent(false);

            RocketMessage message = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                message = rocketMessage;
                messageReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            var messageResult = await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            messageReceived.WaitOne(_timeout);
            messageReceived.Reset();

            // Act
            var result = await _fixture.Master.Driver.SetReactionAsync(reactionName, messageResult.Result.Id);

            messageReceived.WaitOne(_timeout);

            // Assert
            result.HasError.Should().BeFalse();
            message.Reactions.Should().HaveCount(1);
            message.Reactions[0].Name.Should().Be(reactionName);
        }
Ejemplo n.º 6
0
        public async Task Messages_received_should_populate_created_by()
        {
            var text            = AutoFixture.Create <string>();
            var messageReceived = new AutoResetEvent(false);

            RocketMessage message = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                message = rocketMessage;
                messageReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            var userId = ((RocketChatDriver)_fixture.Master.Driver).UserId;

            // Act
            await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            messageReceived.WaitOne(_timeout);

            // Assert
            message.Should().NotBeNull();
            message.CreatedBy.Id.Should().Be(userId);
            message.CreatedBy.Username.Should().Be(Constants.OneUsername);
        }
Ejemplo n.º 7
0
        public async Task Can_update_messages()
        {
            var originalText    = AutoFixture.Create <string>();
            var text            = AutoFixture.Create <string>();
            var messageReceived = new AutoResetEvent(false);

            RocketMessage resultMessage = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.Message == text)
                {
                    messageReceived.Set();
                    resultMessage = rocketMessage;
                }
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            var message = await _fixture.Master.Driver.SendMessageAsync(originalText, _fixture.RoomId);

            // Act
            var result = await _fixture.Master.Driver.UpdateMessageAsync(message.Result.Id, message.Result.RoomId,
                                                                         text);

            messageReceived.WaitOne(_timeout);

            // Assert
            result.HasError.Should().BeFalse();
            resultMessage.Message.Should().Be(text);
            resultMessage.WasEdited.Should().BeTrue();
        }
Ejemplo n.º 8
0
        public async Task <MethodResult> UnpinMessageAsync(RocketMessage message)
        {
            var results =
                await _client.CallAsync("unpinMessage", TimeoutToken, message).ConfigureAwait(false);

            return(results.ToObject <MethodResult>(JsonSerializer));
        }
Ejemplo n.º 9
0
 public IEnumerable <BasicResponse> Response(RocketMessage message)
 {
     if (message.Message.StartsWith(GiphyCommand) && !message.Message.Equals(GiphyCommand))
     {
         var search = message.Message.Replace(GiphyCommand, "").Trim();
         var url    = GetGiphy(search);
         yield return(message.CreateBasicReply(url));
     }
 }
Ejemplo n.º 10
0
        public async Task When_message_is_sent_set_room_property()
        {
            var text = AutoFixture.Create <string>();

            var           masterReceived = new AutoResetEvent(false);
            RocketMessage masterMessage  = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                masterMessage = rocketMessage;
                masterReceived.Set();
            };

            var           slaveReceived = new AutoResetEvent(false);
            RocketMessage slaveMessage  = null;

            _fixture.Slave.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                slaveMessage = rocketMessage;
                slaveReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            await _fixture.Slave.InitAsync(Constants.TwoUsername, Constants.TwoPassword);

            await _fixture.Master.Driver.SubscribeToRoomListAsync();

            await _fixture.Slave.Driver.SubscribeToRoomListAsync();

            // Act
            await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            masterReceived.WaitOne(_timeout);
            slaveReceived.WaitOne(_timeout);

            // Assert
            masterMessage.Should().NotBeNull();
            masterMessage.Room.Should().NotBeNull();

            slaveMessage.Should().NotBeNull();
            slaveMessage.Room.Should().BeNull(); // User is not apart of this room, should be null
        }
Ejemplo n.º 11
0
        private void ClientOnDataReceivedRaw(string type, dynamic data)
        {
            var isMessage = type == "added" && data.collection == MessageTopic && data.fields.args != null;

            if (isMessage)
            {
                var           messageRaw = data.fields.args[1];
                RocketMessage message    = DriverHelper.ParseMessage(messageRaw);

                var edit = message.WasEdited ? "(EDIT)" : "";
                _logger.Info($"Message from {message.CreatedBy.Username}@{message.RoomId}{edit}: {message.Message}");

                OnMessageReceived(message);
            }
        }
Ejemplo n.º 12
0
        public static RocketMessage ParseMessage(dynamic data)
        {
            var message = new RocketMessage
            {
                Id        = data["_id"],
                RoomId    = data.rid,
                Message   = data.msg.ToString().Trim(),
                IsBot     = data.bot != null && data.bot == true,
                CreatedOn = DriverHelper.ParseDateTime(data.ts),
                CreatedBy = DriverHelper.ParseUser(data.u),
                EditedOn  = DriverHelper.ParseDateTime(data.editedAt),
                EditedBy  = DriverHelper.ParseUser(data.editedBy)
            };

            return(message);
        }
Ejemplo n.º 13
0
        public async Task When_bot_sends_message_on_receive_set_myself_flag()
        {
            var text = AutoFixture.Create <string>() + " @" + Constants.OneUsername;

            var           masterReceived = new AutoResetEvent(false);
            RocketMessage masterMessage  = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                masterMessage = rocketMessage;
                masterReceived.Set();
            };

            var           slaveReceived = new AutoResetEvent(false);
            RocketMessage slaveMessage  = null;

            _fixture.Slave.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                slaveMessage = rocketMessage;
                slaveReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            await _fixture.Slave.InitAsync(Constants.TwoUsername, Constants.TwoPassword);

            // Act
            await _fixture.Master.Driver.SendMessageAsync(text, _fixture.RoomId);

            masterReceived.WaitOne(_timeout);
            slaveReceived.WaitOne(_timeout);

            // Assert
            masterMessage.Should().NotBeNull();
            masterMessage.IsFromMyself.Should().BeTrue();

            slaveMessage.Should().NotBeNull();
            slaveMessage.IsFromMyself.Should().BeFalse();
        }
        public async ValueTask InsertAsync(ThumbnailCache entity)
        {
            await Task.Delay(1).ConfigureAwait(false);

            using (await _asyncLock.LockAsync())
            {
                var id = new ThumbnailCacheIdEntity()
                {
                    FilePath            = NestedPathEntity.Import(entity.FileMeta.Path),
                    ThumbnailWidth      = (int)entity.ThumbnailMeta.Width,
                    ThumbnailHeight     = (int)entity.ThumbnailMeta.Height,
                    ThumbnailResizeType = entity.ThumbnailMeta.ResizeType,
                    ThumbnailFormatType = entity.ThumbnailMeta.FormatType,
                };
                var storage = this.GetStorage();

                if (!_database.BeginTrans())
                {
                    _logger.Error("current thread already in a transaction");
                    throw new Exception();
                }

                try
                {
                    using (var outStream = storage.OpenWrite(id, "-"))
                    {
                        RocketMessage.ToStream(entity, outStream);
                    }

                    if (!_database.Commit())
                    {
                        _logger.Error("failed to commit");
                        throw new Exception();
                    }
                }
                catch (Exception e)
                {
                    _logger.Debug(e);
                    _database.Rollback();
                }
            }
        }
Ejemplo n.º 15
0
        private void DriverOnMessageReceived(RocketMessage rocketMessage)
        {
            Task.Run(async() =>  // async this to prevent holding up the message loop
            {
                foreach (var botResponse in _botResponses)
                {
                    var hasResponse = false;
                    foreach (var response in botResponse.Response(rocketMessage))
                    {
                        hasResponse = true;
                        await _driver.SendMessageAsync(response.Message, response.RoomId);
                    }

                    if (hasResponse)
                    {
                        break;
                    }
                }
            });
        }
Ejemplo n.º 16
0
        private async Task SendMessageAsync(RocketMessage message)
        {
            var content = JsonConvert.SerializeObject(message);

            try
            {
                using (var client = new HttpClient())
                {
                    var response = await client.PostAsync(_appSettings.WebHookUrl,
                                                          new StringContent(content, Encoding.UTF8, "application/json"));

                    if (!response.IsSuccessStatusCode)
                    {
                        throw new HttpRequestException($"The WebHook {_appSettings.WebHookUrl} call failed. Status code {response.StatusCode}.");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError("Cannot call the web hook", ex);
            }
        }
Ejemplo n.º 17
0
        public async Task Can_send_attachment()
        {
            var attachment = AutoFixture.Build <Attachment>()
                             .Without(x => x.Timestamp)
                             .Create();

            var messageReceived = new AutoResetEvent(false);

            RocketMessage message = null;

            _fixture.Master.Driver.MessageReceived += rocketMessage =>
            {
                if (rocketMessage.RoomId != _fixture.RoomId)
                {
                    return;
                }
                message = rocketMessage;
                messageReceived.Set();
            };

            await _fixture.Master.InitAsync(Constants.OneUsername, Constants.OnePassword);

            // Act
            var result = await _fixture.Master.Driver.SendCustomMessageAsync(attachment, _fixture.RoomId);

            messageReceived.WaitOne(_timeout);

            // Assert
            result.HasError.Should().BeFalse();
            message.Should().NotBeNull();
            message.Message.Should().BeEmpty();
            message.Attachments.Should().HaveCount(1);

            var resultAttachment = message.Attachments.First();

            resultAttachment.Should().Be(attachment);
        }
Ejemplo n.º 18
0
        private void DriverOnMessageReceived(RocketMessage rocketMessage)
        {
            var context = new ResponseContext
            {
                Message         = rocketMessage,
                BotHasResponded = false,
                BotUserId       = Driver.UserId,
                BotUserName     = Driver.Username
            };

            Task.Run(async() =>  // async this to prevent holding up the message loop, I will handle exceptions.
            {
                foreach (var botResponse in GetValidResponses(context, _botResponses))
                {
                    try
                    {
                        _logger.Debug($"Trying response {botResponse.GetType()}.");
                        var hasResponse = false;
                        foreach (var response in botResponse.GetResponse(context, this))
                        {
                            hasResponse = true;
                            await SendMessageAsync(response).ConfigureAwait(false);
                        }

                        if (hasResponse)
                        {
                            _logger.Debug("Response succeeded.");
                        }
                    }
                    catch (Exception e)
                    {
                        _logger.Info($"ERROR: {e}");
                    }
                }
            });
        }
Ejemplo n.º 19
0
 private void OnMessageReceived(RocketMessage rocketmessage)
 {
     MessageReceived?.Invoke(rocketmessage);
 }
Ejemplo n.º 20
0
 protected void OnMessageReceived(RocketMessage rocketmessage)
 {
     MessageReceived?.Invoke(rocketmessage);
 }
Ejemplo n.º 21
0
        private async Task <RocketMessage> GetMessageAsync(DateTime eventDate)
        {
            var calendars = await FetchCalendarsAsync();

            IDateTime date = new CalDateTime(eventDate);

            var events = calendars.SelectMany(x => x.Events)
                         .Where(c => c.DtStart.Equals(date))
                         .ToList();

            if (!events.Any())
            {
                return(null);
            }

            var message = new RocketMessage
            {
                UserName = _appSettings.UserName,
                IconUrl  = _appSettings.IconUrl,
                Text     = _appSettings.Text
                           .Replace(MacroVariables.Date, eventDate.Date.ToString("D"))
            };

            foreach (var item in events)
            {
                var url      = item.Url.ToString();
                var imageUrl = await GetImageUrlAsync(url);

                if (string.IsNullOrWhiteSpace(imageUrl))
                {
                    imageUrl = _appSettings.DefaultImage;
                }

                var attachment = new RocketAttachment
                {
                    Title       = item.Summary,
                    TitleLink   = url,
                    MessageLink = url,
                    ImageUrl    = imageUrl,
                    Text        = Regex.Replace(item.Description, "\n{2,}", "\n")
                                  .Replace(_appSettings.SignatureForRemoval, string.Empty)
                                  .Trim(),
                    Fields = new List <RocketField>
                    {
                        new RocketField
                        {
                            Title = item.Summary,
                            Value = $"[Read]({url}) more about the holiday."
                        },
                        new RocketField
                        {
                            Title = item.Calendar.Properties["X-WR-CALNAME"].Value.ToString(),
                            Value = $"[Download]({item.Calendar.Properties["Url"].Value}) the calendar."
                        }
                    }
                };

                message.Attachments.Add(attachment);
            }

            return(message);
        }
Ejemplo n.º 22
0
        public async Task<MethodResult> UnpinMessageAsync(RocketMessage message)
        {
            var results =
                await _client.CallAsync("unpinMessage", TimeoutToken, message).ConfigureAwait(false);

            return results.ToObject<MethodResult>(JsonSerializer);
        }
Ejemplo n.º 23
0
 public static BasicResponse CreateBasicReply(this RocketMessage message, string reply)
 {
     return(new BasicResponse(reply, message.RoomId));
 }
Ejemplo n.º 24
0
 public static AttachmentResponse CreateAttachmentReply(this RocketMessage message, Attachment reply)
 {
     return(new AttachmentResponse(reply, message.RoomId));
 }
Ejemplo n.º 25
0
 private void OnMessageReceived(RocketMessage rocketmessage)
 {
     MessageReceived?.Invoke(rocketmessage);
 }