public static SlackMessageBuilder MentionBlock(this SlackMessageBuilder builder, SlackLogMention mention)
{
var mentions = new List <string>();
if (mention.Channel.HasValue)
{
mentions.Add(SlackMessageTextHelper.ChannelMention(mention.Channel.Value));
}
if (mention.Users?.Any() == true)
{
mentions.AddRange(mention.Users.Select(SlackMessageTextHelper.UserMention));
}
if (mention.UserGroups?.Any() == true)
{
mentions.AddRange(mention.UserGroups.Select(SlackMessageTextHelper.UserGroupMention));
}
if (mentions.Any())
{
builder.MessageBlock(string.Join(", ", mentions));
}
return(builder);
}
public Task Invoke(string channel, string[] args)
{
var id = args[0];
var application = _applicationService.GetApplication(id);
var result = _applicationImageInstanceService.GetAllCurrentTagsForPrimary(application)
.ToDictionary(
x => x.Key.TagProperty.Path,
x => x.Key.TagProperty.ValueFormat == TagPropertyValueFormat.TagOnly ? $"{x.Key.Repository}:{x.Value}" : $"{x.Value}"
);
var builder = new SlackMessageBuilder($"The services for application '{id}' have the following tags:")
.AddDivider();
var allFields = result.Select(x => $"*{x.Key}*\n {x.Value}").ToList();
var startIndex = 0;
do
{
var fields = allFields.Skip(startIndex).Take(10).ToList();
builder.AddSection(fields: fields);
startIndex += fields.Count;
} while (startIndex < allFields.Count);
var message = builder.Build();
return(_slackClient.PostMessageAsync(channel, message));
}
public static SlackMessageBuilder AttachmentProperties(this SlackMessageBuilder builder, LogEvent logEvent, Dictionary <string, string> properties, string message = null)
{
var attachmentBlocks = new List <BlockBase>();
if (message != null)
{
var messageBlock = CreateMessageBlock(SlackMessageTextHelper.Italic(logEvent.Level.ToString("G")), message);
attachmentBlocks.Add(messageBlock);
}
if (properties != null && properties.Any())
{
var propertyBlocks = properties.Select(property => CreateMessageBlock(SlackMessageTextHelper.Bold(property.Key), property.Value));
attachmentBlocks.AddRange(propertyBlocks);
}
if (attachmentBlocks.Any())
{
var attachment = new Attachment
{
Color = GetAttachmentColor(logEvent.Level),
Blocks = attachmentBlocks,
};
builder.Attachments(attachment);
}
return(builder);
}
public void ComposeMessageBuildsExceptionMessage()
{
var message = new SlackMessageBuilder(_slackConfiguration, _exception, _notifierOptions, null).ComposeMessage();
Assert.IsType <SlackMessage>(message);
Assert.Equal("the chicken channel", message.Channel);
Assert.Equal("achicken", message.Username);
Assert.Contains("[Fried Chicken - Development] EXCEPTION!", message.Text);
Assert.Contains("This is an exception!", message.Text);
}
public static SlackMessageBuilder CreateMessageBuilder(string channel, LogEvent logEvent, string message, string replayTimespan = null)
=> SlackMessageBuilder.CreateBuilder(channel)
.Text(message)
.LineBreak()
.Reply(replayTimespan)
.Blocks(
new SectionBlock
{
Text = (MarkdownTextObject)SlackMessageTextHelper.Date(logEvent.Timestamp.ToUnixTimeSeconds(), "{date_num} {time_secs}", "LogDate"),
});
public static SlackMessageBuilder MessageBlock(this SlackMessageBuilder builder, params string[] messages)
{
var notEmptyMessages = messages.Where(message => !string.IsNullOrWhiteSpace(message)).ToArray();
if (notEmptyMessages.Any())
{
builder.Blocks(CreateMessageBlock(notEmptyMessages));
}
return(builder);
}
private async Task AttachExceptionAsync(SlackClient slackClient, SlackMessageBuilder threadMessageBuilder, Exception exception)
{
if (_logOptions.SendExceptionAsFile)
{
var exceptionType = exception.GetType().Name;
var fileObjectResponse = await slackClient.Files.UploadContentAsync(
exception.ToString(),
title : exceptionType,
filename : $"{exceptionType}.cs");
threadMessageBuilder.Text(fileObjectResponse.File.Permalink.ToString());
}
else
{
threadMessageBuilder
.MessageBlock(SlackMessageTextHelper.CodeBlock(exception.ToString()));
}
}
public IMessage BuildNotification(Deployment deployment)
{
var builder = new SlackMessageBuilder($"A new image of *{deployment.ImageRepository}* was detected (tag *{deployment.TargetTag}*).");
var messageConfiguration = builder
.AddDivider()
.AddSection(fields: new []
{
$"*From*\n{deployment.CurrentTag}",
$"*To*\n{deployment.TargetTag}",
$"*Application*\n{deployment.ApplicationId}",
$"*Status*\n{deployment.Status}"
}
);
if (deployment.Status == DeploymentStatus.Pending)
{
messageConfiguration.AddActions(
blockBuilder => blockBuilder
.AddButton("deploy", "Deploy", $"{deployment.Id:D}", style: "primary")
);
}
return(messageConfiguration.Build());
}
public SlackMessageBuilderTests()
{
_messageBuilder = new SlackMessageBuilder();
}
SendMessageResponse MessageWithBlocksResponse)> SendMessagesWithBuilderAsync(SlackClient slackClient, string channelName, string userId)
{
const string SampleUrl = "https://api.slack.com/";
var now = DateTime.Now;
var nowTimestamp = UnixTimeHelper.ToUnixTime(now);
var channelId = await ConversationsClientMethods.GetChannelIdAsync(slackClient, channelName);
var messageWithTextHelper = new SlackMessageBuilder(channelName)
.Text($"Channel mention by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.ChannelMention(SlackMention.Channel)}")
.LineBreak()
.Text($"Users mention by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.UserMentions(new[] { userId, userId })}")
.LineBreak()
.Text($"Public channel mention by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.PublicChannelMention(channelId)}")
.LineBreak()
.Text($"{SlackMessageTextHelper.Bold("bold text")} by {nameof(SlackMessageTextHelper)}")
.LineBreak()
.Text($"{SlackMessageTextHelper.InlineCode("inline code")} by {nameof(SlackMessageTextHelper)}")
.LineBreak()
.Text($"{SlackMessageTextHelper.Strike("strike text")} by {nameof(SlackMessageTextHelper)}")
.LineBreak()
.Text($"{SlackMessageTextHelper.Italic("italic text")} by {nameof(SlackMessageTextHelper)}")
.LineBreak()
.Text($"Link by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.Link(SampleUrl)}")
.LineBreak()
.Text($"Link by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.Link(new Uri(SampleUrl))}")
.LineBreak()
.Text($"Link by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.EmailLink("*****@*****.**")}")
.LineBreak()
.LineBreak()
.Text($"Code block by {nameof(SlackMessageTextHelper)}:{SlackMessageTextHelper.CodeBlock("code line #1\ncode line #2")}")
.LineBreak()
.LineBreak()
.Text($"Unquoted text by {nameof(SlackMessageTextHelper)}:{SlackMessageTextHelper.Quoted("quoted text #1\nquoted text #2")}Unquoted text again")
.LineBreak()
.LineBreak()
.Text($"List by {nameof(SlackMessageTextHelper)}:{SlackMessageTextHelper.List("list item #1", "list item #2")}")
.LineBreak()
.LineBreak()
.Text($"User mention by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.UserMention(userId)}")
.LineBreak()
.Text(SlackMessageTextHelper.Date(nowTimestamp, $"Date by {nameof(SlackMessageTextHelper)}: {{date_num}} {{time}}", now.ToString("yyyy-MM-dd hh:mm")));
var messageWithTextBuilder = new SlackMessageBuilder(channelId)
.ChannelMention(SlackMention.Here)
.UserMentions(new[] { userId, userId }, "\n")
.PublicChannelMention(channelId, "\n")
.BoldText("bold text", "\n")
.InlineCodeText("inline code", "\n")
.StrikeText("strike text", SlackMessageTextHelper.LineBreak)
.ItalicText("italic text", SlackMessageTextHelper.LineBreak)
.CodeBlock("code block", SlackMessageTextHelper.LineBreak)
.LinkText(SampleUrl, "Slack api url", SlackMessageTextHelper.LineBreak)
.LinkText(new Uri(SampleUrl), "Slack api url", SlackMessageTextHelper.LineBreak)
.EmailLinkText("*****@*****.**", "Test email", SlackMessageTextHelper.LineBreak)
.QuotedText("quoted text #1")
.QuotedText("quoted text #2")
.ListText(new[] { "list item #1", "list item #2" })
.UserMention(userId)
.Date(nowTimestamp, "{date_num} {time}", now.ToString("yyyy-MM-dd hh:mm"), new Uri(SampleUrl), SlackMessageTextHelper.LineBreak);
var userGroupListResponse = await slackClient.UserGroups.ListAsync();
var userGroup = userGroupListResponse.UserGroups.FirstOrDefault();
if (userGroup != null)
{
var userGroupId = userGroup.Id;
messageWithTextHelper = messageWithTextHelper
.LineBreak()
.Text($"User group mention by {nameof(SlackMessageTextHelper)}: {SlackMessageTextHelper.UserGroupMention(userGroupId)}");
messageWithTextBuilder = messageWithTextBuilder.UserGroupMention(userGroupId, SlackMessageTextHelper.LineBreak);
}
var messageWithTextHelperResponse = await slackClient.Chat.PostMessageAsync(messageWithTextHelper);
var messageWithTextBuilderResponse = await slackClient.Chat.PostMessageAsync(messageWithTextBuilder);
var messageWithBlocks = SlackMessageBuilder.CreateBuilder(channelName)
.Reply(messageWithTextBuilderResponse.Timestamp, true)
.Blocks(CreateHeaderBlock())
.Blocks(CreateActionBlock(), CreateContextBlock())
.Attachments(new Attachment("#000099", "Attachment1"))
.Attachments(new Attachment("#009900", "Attachment2"), new Attachment("#990000", "Attachment3"))
.CreateMessage();
var messageWithBlocksResponse = await slackClient.Chat.PostMessageAsync(messageWithBlocks);
return(messageWithTextHelperResponse, messageWithTextBuilderResponse, messageWithBlocksResponse);
}
