private static void SendSlackNotification(string post)
{
post = post.Replace("&", "&").Replace("<", "<").Replace(">", ">");
var slack = new Slack();
slack.PostSlackMessage(post);
}
static void Main(string[] args)
{
Setting setting = YamlObject.GetFromFile <Setting>(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "setting.yml"));
var slack = new Slack(setting.Token);
Dictionary <string, List <string> > message = setting.GetMessages();
var directroy = new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "images"));
Parallel.ForEach(directroy.EnumerateFiles("*", SearchOption.TopDirectoryOnly), new ParallelOptions()
{
MaxDegreeOfParallelism = 5
}, file =>
{
var user = file.Name.Replace(file.Extension, "");
if (!message.ContainsKey(user))
{
Console.WriteLine($"message is not found user: {file.Name}");
return;
}
var binary = ReadImageFile(file);
var channel = slack.FileUpload(user, binary).Result;
message[user].ForEach(x => slack.MessageSend(user, x, channel).Wait());
});
}
public AppRepository(LiteDatabase db, Slack slack)
{
this.Database = db;
this.Slack = slack;
var settings = Database.GetCollection <AppSettings>("settings");
var results = settings.FindOne(x => x.Id == 1);
if (results != null)
{
Settings.Id = results.Id;
Settings.LastDocumentId = results.LastDocumentId;
Settings.LastDocumentModified = results.LastDocumentModified;
Settings.Region = results.Region;
Settings.AWSSecret = results.AWSSecret;
Settings.AWSKeyID = results.AWSKeyID;
Settings.BucketName = results.BucketName;
Settings.MyobServerName = results.MyobServerName;
Settings.MyobDatabaseName = results.MyobDatabaseName;
Settings.Mode = results.Mode;
Settings.Folder = results.Folder;
Settings.FolderLists = results.FolderLists;
Settings.IncludeFolderName = results.IncludeFolderName;
Settings.Restart = results.Restart;
Settings.UseProxy = results.UseProxy;
Settings.Password = results.Password;
Settings.Host = results.Host;
Settings.Port = results.Port;
Settings.Username = results.Username;
}
}
public static Host GetLastHost(this Slack instance)
{
Host value;
LastHosts.TryGetValue(instance, out value);
return(value);
}
/// <summary>
/// Handles interactive messages. Used for button presses on previews.
/// </summary>
/// <param name="interactiveMessage"></param>
/// <returns></returns>
public async Task HandleInteractive(InteractiveMessage interactiveMessage)
{
if (Slack.ValidInteractiveMessage(interactiveMessage))
{
var action = interactiveMessage.Actions[0];
var slackUser = await Slack.GetUser(interactiveMessage.User.Id);
if (action.Name == "post")
{
await Slack.PostMessage(new ChatMessage
{
Channel = interactiveMessage.Channel.Id,
Username = slackUser.Profile.DisplayName,
Text = action.Value,
IconUrl = slackUser.Profile.ImageOriginal,
User = interactiveMessage.User.Id,
});
}
else if (action.Name == "random")
{
var url = await ImageSearch(action.Value, true);
await SendGif(interactiveMessage.Channel.Id,
slackUser.Profile.DisplayName,
slackUser.Profile.ImageOriginal,
slackUser.Id,
action.Value,
url);
}
await Slack.DeleteResponse(interactiveMessage.ResponseUrl.ToString());
}
}
private async Task LookupAddressAsync(IncomingMessage incomingMessage, string location)
{
if (incomingMessage == null)
{
throw new ArgumentNullException("incomingMessage");
}
if (location == null)
{
throw new ArgumentNullException("location");
}
const string googleMapUrl = "http://maps.googleapis.com/maps/api/geocode/json";
using (var client = new HttpClient())
{
var uri = string.Format("{0}?address={1}&sensor={2}", googleMapUrl, HttpUtility.UrlEncode(location), true);
var response = await client.GetAsync(uri);
var body = JsonConvert.DeserializeObject <dynamic>(await response.Content.ReadAsStringAsync());
var coords = body.results[0].geometry.location;
var text = await LookupWeatherAsync((decimal)coords.lat, (decimal)coords.lng);
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("@{0} {1}", incomingMessage.UserName, text));
}
}
public static void LogToSlack(string url,
string channel,
string username,
string ip,
string controller,
string action,
object message)
{
SlackLogObject seo = new SlackLogObject()
{
LogId = Guid.NewGuid(),
ServerIP = ip,
Controller = controller,
Action = action,
Message = message
};
string body = JsonConvert.SerializeObject(seo, Formatting.Indented);
Slack slack = new Slack()
{
text = $"Log Entry: {body}",
username = username,
icon_emoji = ":grimacing:",
channel = $"#{channel}"
};
string res = url.postJSON(slack);
}
public void TestConnect()
{
var slack = new Slack();
Assert.IsTrue(slack.Init(Token), "Invalid Token");
Assert.IsTrue(slack.Connect(), "Failed to Connect");
}
private async Task CaptureAsync(IncomingMessage incomingMessage, string resource)
{
if (string.IsNullOrEmpty(resource))
{
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("@{0} what are you trying to capture?", incomingMessage.UserName));
return;
}
string text;
object value;
if (Brain.TryGetValue(resource, out value) == false)
{
Brain[resource] = incomingMessage.UserName;
text = string.Format("{0} captured by @{1}", resource, incomingMessage.UserName);
}
else
{
text = string.Format("@{0} {1} is being held captive by @{2}", incomingMessage.UserName, resource, value);
}
await Slack.SendAsync(incomingMessage.ReplyTo(), text);
}
private static string SubstituteMarkup(string p, Slack instance)
{
return(Regex.Replace(p, @"<([@#])(.*?)>", (match) =>
{
switch (match.Groups[1].Value)
{
case "#":
var chan = instance.GetChannel(match.Groups[2].Value);
if (chan == null)
{
break;
}
return "#" + chan.Name;
case "@":
var user = instance.GetUser(match.Groups[2].Value);
if (user == null)
{
break;
}
return "@" + user.Name;
}
return match.Groups[0].Value;
}));
}
internal void Check(Slack slack)
{
try
{
var whosin = Singleton <NetworkData> .Instance.CertainHosts().Select(h => h.Owner).Distinct();
foreach (var item in Notes.ToArray())
{
var who = slack.GetUser(item.Who);
var name = "@" + who.Name;
if (whosin.Contains(name, System.StringComparer.CurrentCultureIgnoreCase))
{
var im = slack.Ims.FirstOrDefault(i => i.Name == who.Id);
if (im == null)
{
im = who.OpenIm();
}
slack.SendMessage(im.Id, "Reminder: " + item.Text);
Notes.Remove(item);
}
}
PersistentSingleton <Reminders> .Dirty();
}
catch (Exception c)
{
Console.WriteLine(c);
}
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var Instance = new Slack();
string token = "";
bool success;
Instance.OnEvent += Instance_OnEvent;
do
{
if (File.Exists("token.txt"))
{
token = File.ReadAllText("token.txt");
}
if (String.IsNullOrWhiteSpace(token))
{
Console.WriteLine("Please obtain a Token, and paste it below:");
token = Console.ReadLine();
File.WriteAllText("token.txt", token);
}
success = Instance.Init(token);
if (!success)
{
File.WriteAllText("token.txt", "");
}
} while (!success);
Instance.Connect();
while (Instance.Connecting || Instance.Connected)
{
Thread.Sleep(0);
}
Console.WriteLine("===Disconnected===");
Console.ReadKey();
}
public static void SendMessage(MessagePayload message)
{
if (Properties.Settings.Default.Plugin.ToUpper() == "SLACK")
{
Slack.SendToRoom(message, Properties.Settings.Default.RecruitmentRoomName, Properties.Settings.Default.SlackWebhook);
}
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
// If the process has started, all three disposable objects will be valid
// I would just call OnStop, but the code analysis tool doesn't look inside
// it and thinks the members aren't being Disposed.
if (Processors.Count > 0)
{
// Clean up the directory watcher and crash processor threads
foreach (var Processor in Processors)
{
Processor.Dispose();
}
Processors.Clear();
Watcher.Dispose();
Watcher = null;
StatusReporter.Dispose();
StatusReporter = null;
Slack.Dispose();
Slack = null;
// Flush the log to disk
Log.Dispose();
Log = null;
}
}
base.Dispose(disposing);
}
public Task <SlackMessage> SendActionMessage(string channel, string message, SlackInteractiveMessage messageData)
{
var ts = new TaskCompletionSource <SlackMessage>();
var actions = new List <AttachmentAction>();
foreach (var button in messageData.Buttons)
{
actions.Add(new AttachmentAction(button.Name, button.Text));
}
Slack.PostMessage(
_ => { ProcessCompletion(ts, channel, _); },
channel,
message,
as_user: true,
attachments: new Attachment[]
{
new Attachment()
{
title = messageData.Text,
text = messageData.Description,
callback_id = messageData.CallbackId,
actions = actions.ToArray()
}
});
return(ts.Task);
}
private async Task VersionAsync(IncomingMessage incomingMessage)
{
var environmentName = ConfigurationManager.AppSettings["EnvironmentName"];
var version = typeof(IoC).Assembly.GetName().Version.ToString(3);
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("{0} - {1}", environmentName, version));
}
private async Task GiphyAsync(IncomingMessage incomingMessage, string input)
{
Exception exception = null;
try
{
if (string.IsNullOrEmpty(input) || input.ToLower().StartsWith("random"))
{
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("@{0} {1}", incomingMessage.UserName, await Random()));
return;
}
var random = new Random();
var results = await Search(input);
var max = results.Count();
var image = max <= 0
? await Random()
: results[random.Next(max)];
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("@{0} {1}", incomingMessage.UserName, image));
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
var response = string.Format("@{0} Umm... something went wrong \"{1}\" {2}", incomingMessage.UserName, incomingMessage.Text, exception.Message);
await Slack.SendAsync(incomingMessage.ReplyTo(), response);
}
}
public static void Reply(this Message message, Slack Instance, string Text, bool targeted = false)
{
if (targeted)
{
Text = string.Format("{1}: {0}", Text, Instance.GetUser(message.User).Name);
}
Instance.SendMessage(message.Channel, Text);
}
public void PostToSlack(List <RestaurantMenu> menus, Slack settings)
{
dynamic postRequestObject = GetRequestObjectFromSlackConfiguration(settings);
postRequestObject.text = FormatMenuForSlack(menus);
PostToSlack(postRequestObject, PostMessageUri);
}
public override IDocEntity SaveChanges(bool ignoreCache, DocConstantPermission permission)
{
Description = Description?.TrimAndPruneSpaces();
Email = Email?.TrimAndPruneSpaces();
Name = Name?.TrimAndPruneSpaces();
Slack = Slack?.TrimAndPruneSpaces();
return(base.SaveChanges(ignoreCache, permission));
}
private async Task SendAsync(IncomingMessage incomingMessage, string replyTo, string input)
{
var response = incomingMessage.Text.StartsWith(incomingMessage.BotName)
? string.Format("@{0} I speak for myself thank you very much!", incomingMessage.UserName)
: input;
await Slack.SendAsync(replyTo, response);
}
public void TestSlack()
{
Slack s = new Slack();
var t = s.PublishMessage("This is a test message", "https://example.org");
Assert.IsTrue(t.Result.StatusCode == System.Net.HttpStatusCode.OK);
}
private async Task RespondAsync(IncomingMessage incomingMessage)
{
var random = new Random();
var responses = GetResponses();
var response = responses[random.Next(responses.Length)];
await Slack.SendAsync(incomingMessage.ReplyTo(), string.Format("@{0} {1}", incomingMessage.UserName, response));
}
public void UpdateToSlack(List <RestaurantMenu> menus, string timestamp, Slack settings)
{
dynamic postRequestObject = GetRequestObjectFromSlackConfiguration(settings);
postRequestObject.text = FormatMenuForSlack(menus);
postRequestObject.ts = timestamp;
PostToSlack(postRequestObject, UpdateMessageUri);
}
public override async Task Handle(IncomingMessage incomingMessage)
{
var match = Regex.Match(incomingMessage.Text, "foo (.*)", RegexOptions.IgnoreCase);
if (match.Length > 0)
{
await Slack.SendAsync(incomingMessage.ReplyTo(), match.Groups[1].Value);
}
}
public async void when_http_client_throws()
{
var mockHttp = new Mock <IHttp>();
mockHttp
.Setup(http => http.Get(It.IsAny <string>()))
.Throws(new Exception());
var sut = new Slack(mockHttp.Object);
}
private ExpandoObject GetRequestObjectFromSlackConfiguration(Slack slackSetting)
{
dynamic result = new ExpandoObject();
result.token = slackSetting.BotToken;
result.channel = slackSetting.ChannelName;
result.bot_id = slackSetting.BotId;
return(result);
}
public SlackMessage SignalPublisherSlack(ChannelRequest request, ILambdaContext ctx)
{
processor.Logger = new LambdaLogger(ctx.Logger);
processor.Logger.Info($"Version : {Version}");
processor.Logger.Info(JsonTools.Serialize(request));
SlackMessage reply = Slack.Publish(request);
processor.Logger.Info(JsonTools.Serialize(reply));
return(reply);
}
private async Task LoadAsync(IncomingMessage incomingMessage, string input)
{
var users = new List <string>();
var names = input.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
users.AddRange(names.Where(name => name.ToLower() != incomingMessage.BotName));
Brain[UsersKey] = string.Join(",", users);
var response = string.Format("@{0} users loaded. [{1}]", incomingMessage.UserName, string.Join(", ", users));
await Slack.SendAsync(incomingMessage.ReplyTo(), response);
}
public void TestStartValid()
{
if (String.IsNullOrWhiteSpace(Token))
{
Assert.Inconclusive("No valid token specified");
return;
}
var slack = new Slack(Token);
Assert.IsTrue(slack.Init());
}
public void Test1()
{
Hale.Alert.Slack slack = new Slack();
slack.SendMessage();
}
