static void Main(string[] args)
{
Console.WriteLine("HELLO WORLD");
SlackBot.Configuration = new SlackBotConfiguration()
{
AuthToken = "xoxp-41105373671-41469381379-42639991936-7ad9c24d95"
};
SlackBot.Run();
Console.Read();
}
private static async Task Run(string token)
{
using (var bot = new SlackBot(token))
{
bot.AddHandler(new PingHandler());
await bot.Connect().ConfigureAwait(false);
Console.WriteLine("Connected");
await WaitForKeyPress().ConfigureAwait(false);
}
}
public void InstantiateInstanceWithPluginPath()
{
var slackBot = SlackBot.Create("xxx")
.WithoutCoreHandlers()
.WithPluginPath("../../../DummyTestPlugins/Dll/")
.Instantiate();
Assert.NotNull(slackBot);
Assert.True(slackBot.MessageHandlers.Count() == 2);
Assert.NotNull(slackBot.SlackService);
Assert.True(slackBot.MessageHandlers.Any(h => h.GetType() == typeof(TestPlugin1)));
Assert.True(slackBot.MessageHandlers.Any(h => h.GetType() == typeof(TestPlugin2)));
}
public void InstantiateInstanceWithAssemblyPlugin()
{
var slackBot = SlackBot.Create("xxx")
.WithoutCoreHandlers()
.WithPluginAssembly(typeof(TestPlugin1).Assembly)
.Instantiate();
Assert.NotNull(slackBot);
Assert.True(slackBot.MessageHandlers.Count() == 2);
Assert.NotNull(slackBot.SlackService);
Assert.True(slackBot.MessageHandlers.Any(h => h.GetType() == typeof(TestPlugin1)));
Assert.True(slackBot.MessageHandlers.Any(h => h.GetType() == typeof(TestPlugin2)));
}
public async Task HubRemovedFromState_WhenBotLeavesHub(Func <IHubLeft> generator)
{
var bot = await SlackBot.InitializeAsync(this.driver, this.bus);
var msg = generator();
msg.Channel = Guid.NewGuid().ToString();
this.state.AddHub(msg.Channel, msg.Channel, msg.HubType);
bot.WaitForMessageToBeReceived <IHubLeft>(
m => m.Channel == msg.Channel,
() => this.bus.Publish(msg));
Assert.Null(this.state.GetHubById(msg.Channel));
}
private void Connect()
{
if (!_connected)
{
lock (_connectLock)
{
if (!_connected)
{
_bot = SlackBot.Connect(_token).Result;
_bot.RegisterHandler(this);
_connected = true;
OnConnected();
}
}
}
}
public static void Main(string[] args)
{
CloudRail.AppKey = "[Your Cloudrail Key]";
String serviceName = SelectService();
FacebookMessenger facebookMessenger = new FacebookMessenger(null, "[Bot Token]");
Telegram telegram = new Telegram(null, "[Bot Token]", "[Webhook URL]");
Line line = new Line(null, "[Bot Token]");
Viber viber = new Viber(null, "[Bot Token]", "[Webhook URL]", "[Bot Name]");
SlackBot slackBot = new SlackBot(null, "[Bot Token]");
service = null;
switch (serviceName)
{
case "1":
Console.WriteLine("Selected Service: FacebookMessenger");
service = facebookMessenger;
break;
case "2":
Console.WriteLine("Selected Service: Telegram");
service = telegram;
break;
case "3":
Console.WriteLine("Selected Service: Line");
service = line;
break;
case "4":
Console.WriteLine("Selected Service: Viber");
service = viber;
break;
case "5":
Console.WriteLine("Selected Service: SlackBot");
service = slackBot;
break;
default:
Console.WriteLine("Selected Service: FacebookMessenger");
service = facebookMessenger;
break;
}
RunHttpServer();
}
public static void WaitForMessageToBeReceived <T>(this SlackBot bot, Predicate <T> matcher, Action action)
where T : IRtmMessage
{
var evt = new AutoResetEvent(false);
using (bot.On <T>(msg => { if (matcher(msg))
{
evt.Set();
}
}))
{
action();
if (!evt.WaitOne(100))
{
Assert.True(false, $"{typeof(T).Name} message was not received");
}
}
}
/// <summary>
/// Get the slack bot id
/// </summary>
/// <returns>the id for the slack bot</returns>
private string GetSlackBotID()
{
string slackData = GetData("users.list", "", false);
string id = "";
JObject users = JObject.Parse(slackData);
IList <JToken> cData = users["members"].Children().ToList();
foreach (JToken temp in cData)
{
SlackBot bTemp = temp.ToObject <SlackBot>();
if (Convert.ToBoolean(bTemp.is_bot))
{
id = bTemp.id;
Debug.WriteLine(id);
}
}
return(id);
}
private static async Task Run(string[] args)
{
string token = args[0];
string logfile = args[1];
string aikey = args[2];
string aiend = args[3];
using (var bot = new SlackBot(token)){
bot.AddHandler(new PingHandler());
//bot.AddHandler(new MessageHandler());
bot.AddHandler(new MessageHandler(logfile));
bot.AddHandler(new AnalyticsHandler(aikey, aiend));
await bot.Connect().ConfigureAwait(false);
Console.WriteLine("Connected");
await WaitForKeyPress().ConfigureAwait(false);
}
}
public static void Main(string[] args)
{
MessageHandler[] messageHandlers = new MessageHandler[]
{
new HealthCheckMessageHandler(),
new HelloMessageHandler(),
new PingMessageHandler()
};
using (SlackBot slackBot = new SlackBot(ApplicationConfiguration.SlackBotApiToken, messageHandlers))
{
slackBot.Start();
while (Console.ReadLine() != "Close")
{
}
}
Console.WriteLine("Boo!");
}
public void Set(Models.Plugins.SlackBotInfo info)
{
if (m_bot != null)
{
m_bot.Dispose();
m_bot.OnConnected -= OnBotConnectedToSlack;
OnBotConnectionChanged?.Invoke(false);
}
m_bot = new SlackBot(info.Token, info.Name);
m_bot.OnConnected += OnBotConnectedToSlack;
//Force the client to constantly check for the channel & force connect
//ToDo: Make this async and improve
if (m_channelThread != null)
{
m_channelThread.Abort();
}
m_channelThread = new Thread(() => FindChannel(info.Channel));
m_channelThread.Start();
}
private static void Run(string baseUrl, string dataView, string username, string password, string slackToken)
{
OrbitApiClient apiClient = new OrbitApiClient(dataView, new ApiConnectorFactory(baseUrl));
if (!apiClient.Login(username, password))
{
throw new Exception("Can't log in to the dataview " + dataView + " with username " + username + " using the API at " + baseUrl);
}
OrbitResponseHandler responseHandler = new OrbitResponseHandler(apiClient);
SlackBot bot = new SlackBot(new SlackClientFactory(), responseHandler, new ConsoleLogger(), slackToken);
bot.Start();
System.Console.WriteLine("Orbit Slackbot started. Press return to stop");
System.Console.WriteLine();
System.Console.ReadLine();
bot.Stop();
}
public async Task HubAddedToState_WhenBotJoinsHub(Func <IHubJoined> generator)
{
var bot = await SlackBot.InitializeAsync(this.driver, this.bus);
var msg = generator();
msg.Channel = new Channel
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
bot.WaitForMessageToBeReceived <IHubJoined>(
m => m.Channel.Id == msg.Channel.Id,
() => this.bus.Publish(msg));
var hub = this.state.GetHubById(msg.Channel.Id);
Assert.NotNull(hub);
Assert.Equal(hub.Id, msg.Channel.Id);
Assert.Contains(msg.Channel.Name, hub.Name);
Assert.Equal(hub.HubType, msg.HubType);
}
protected override void OnStart(string[] args)
{
base.OnStart(args);
EnsureOrbitConnectionParametersCorrect();
logger.Log("Starting Orbit Slackbot - connecting to Orbit API");
OrbitApiClient apiClient = new OrbitApiClient(dataView, new ApiConnectorFactory(baseUrl));
if (!apiClient.Login(username, password))
{
throw new Exception("Can't log in to the dataview " + dataView + " with username " + username + " using the API at " + baseUrl);
}
logger.Log("Starting Orbit Slackbot - successfully connected to Orbit API");
OrbitResponseHandler responseHandler = new OrbitResponseHandler(apiClient);
logger.Log("Starting Orbit Slackbot - connecting to Slack");
bot = new SlackBot(new SlackClientFactory(), responseHandler, logger, slackToken);
bot.Start();
logger.Log("Successfully started Orbit Slackbot");
}
public async Task MatchMode_AllMatches()
{
var bot = await SlackBot.InitializeAsync(this.driver, this.bus, cfg =>
{
cfg.WhenHandlerMatchMode = WhenHandlerMatchMode.AllMatches;
});
this.state.AddUser("1", "user");
this.state.AddHub("1", "test hub", HubType.DirectMessage);
var evt = new CountdownEvent(2);
bot.When(Matches.Text("test"), cv =>
{
evt.Signal();
return(Task.CompletedTask);
});
bot.When(Matches.Text("test"), cv =>
{
evt.Signal();
return(Task.CompletedTask);
});
this.bus.Publish(new Message
{
Channel = "1",
User = "******",
Text = "test"
});
if (!evt.Wait(100))
{
Assert.True(false, "Both handlers were not fired");
}
}
public async Task MatchMode_FirstMatch()
{
var bot = await SlackBot.InitializeAsync(this.driver, this.bus, cfg =>
{
cfg.WhenHandlerMatchMode = WhenHandlerMatchMode.FirstMatch;
});
this.state.AddUser("1", "user");
this.state.AddHub("1", "test hub", HubType.DirectMessage);
var evt = new AutoResetEvent(false);
bot.When(Matches.Text("test"), cv =>
{
evt.Set();
return(Task.CompletedTask);
});
bot.When(Matches.Text("test"), cv =>
{
Assert.True(false, "Second handler should not be fired");
return(Task.CompletedTask);
});
this.bus.Publish(new Message
{
Channel = "1",
User = "******",
Text = "test"
});
if (!evt.WaitOne(100))
{
Assert.True(false, "First handler never fired");
}
}
public async Task MatchMode_BestMatch()
{
var bot = await SlackBot.InitializeAsync(this.driver, this.bus, cfg =>
{
cfg.WhenHandlerMatchMode = WhenHandlerMatchMode.BestMatch;
});
this.state.AddUser("1", "user");
this.state.AddHub("1", "test hub", HubType.DirectMessage);
var evt = new AutoResetEvent(false);
bot.When(new FixedScoreMatcher(1), cv =>
{
Assert.True(false, "Low score handler should not have been fired");
return(Task.CompletedTask);
});
bot.When(new FixedScoreMatcher(2), cv =>
{
evt.Set();
return(Task.CompletedTask);
});
this.bus.Publish(new Message
{
Channel = "1",
User = "******",
Text = "test"
});
if (!evt.WaitOne(100))
{
Assert.True(false, "High score handler was not fired");
}
}
public async Task OutgoingMessages_LimitedToOnePerSecond()
{
var evt = new CountdownEvent(3);
var driver = new CountdownDriver(evt);
var bot = await SlackBot.InitializeAsync(driver, this.bus);
await bot.SendAsync("test", "test", false, null);
await bot.SendAsync("test", "test", false, null);
await bot.SendAsync("test", "test", false, null);
if (!evt.Wait(TimeSpan.FromSeconds(6)))
{
Assert.True(false, "3 messages were not recorded as being sent");
}
Assert.Equal(3, driver.RecordedTimings.Count);
TimeSpan TimeBetween(int p1, int p2)
=> driver
.RecordedTimings[Math.Max(p1, p2)]
.Subtract(
driver
.RecordedTimings[Math.Min(p1, p2)]);
var first = TimeBetween(0, 1);
var second = TimeBetween(1, 2);
// allow some wiggle room with timing
var measure = TimeSpan.FromSeconds(0.92);
Assert.True(TimeBetween(0, 1) >= measure, $"Expected {first} >= {measure}");
Assert.True(TimeBetween(1, 2) >= measure, $"Expected {second} >= {measure}");
}
private async Task StanLeeBotWork()
{
while (!_stopping)
{
_logger.LogInformation("StanLee getting connected!");
var bot = await SlackBot.InitializeAsync(_appSettings.Slack.ApiToken,
cfg =>
{
cfg.LoggerFactory = _loggerFactory;
cfg.WhenHandlerMatchMode = WhenHandlerMatchMode.FirstMatch;
cfg.OnSendMessageFailure = async(queue, msg, logger, e) =>
{
if (msg.SendAttempts <= 5)
{
logger?.LogWarning($"Failed to send message {msg.Text}. Tried {msg.SendAttempts} times");
await Task.Delay(1000 * msg.SendAttempts);
queue.Enqueue(msg);
return;
}
logger?.LogError($"Gave up trying to send message {msg.Text}");
};
_stopping = true;
});
bot.When(MatchFactory.Matches.Text("hello"), async conv =>
{
await conv.PostMessage("Hi!");
})
.OnException((msg, ex) =>
{
_logger.LogError(ex, $"Stan Lee had an error! It's {ex}");
});
bot.When(MatchFactory.Matches.Text("whois"), async conv =>
{
const string toBeSearched = "whois";
var marvelCharacterStr = conv.Text.StripAscii()
.Substring(conv.Text.IndexOf(toBeSearched, StringComparison.Ordinal) + toBeSearched.Length)
.TrimPunctuation()
.Trim();
_logger.LogInformation($"Request by {conv.From.Username}");
var marvelCharacter = await _marvelService.GetCharacter(marvelCharacterStr);
var response = string.Empty;
if (marvelCharacter != null)
{
_logger.LogInformation($"Found information for {marvelCharacterStr}. Marvel Character ID: {marvelCharacter.Id}");
response = $"Excelsior! I found {marvelCharacter.Name} :star-struck:! {marvelCharacter.Description}.{Environment.NewLine}{Environment.NewLine}";
response += $"{Environment.NewLine}{Environment.NewLine}";
response += $"{marvelCharacter.Name} has appeared in {marvelCharacter.Comics.Available} comics!";
response += $"{Environment.NewLine}{Environment.NewLine}";
response += $"Learn more here: {marvelCharacter.Urls.FirstOrDefault(x => x.Type == "detail")?.Value ?? "... or not."}";
}
else
{
_logger.LogInformation($"Character not found: {marvelCharacterStr}.");
response = $"I wasn't able to find anything about {marvelCharacterStr}...";
}
_logger.LogInformation($"Sending information to Slack for {marvelCharacterStr} to {conv.From.Username}.");
await conv.PostMessage(response);
})
.OnException((msg, ex) =>
{
_logger.LogError(ex, $"Stan Lee had an error! It's {ex}");
});
}
_logger.LogInformation("StanLeeBot is stopping");
}
public WebsocketResurrector(SlackBot bot, ILoggerFactory loggerFactory)
: this(bot, loggerFactory, _defaultInterval, _defaultSelector)
{
}
