public async Task InitializeAsync()
{
if (settings.Twitch.EnableChatBot)
{
client.Initialize(credentials, settings.Twitch.Channel);
client.OnLog += Client_OnLog;
client.OnMessageReceived += Client_OnMessageReceived;
client.OnConnected += Client_OnConnected;
client.OnDisconnected += Client_OnDisconnected;
client.OnConnectionError += Client_OnConnectionError;
client.Connect();
}
if (settings.Twitch.EnablePubSub)
{
string channelId = await GetChannelId();
pubSub.ListenToRewards(channelId);
pubSub.OnRewardRedeemed += PubSub_OnRewardRedeemed;
pubSub.OnLog += PubSub_OnLog;
pubSub.OnPubSubServiceConnected += PubSub_OnPubSubServiceConnected;
pubSub.OnPubSubServiceError += PubSub_OnPubSubServiceError;
pubSub.OnPubSubServiceClosed += PubSub_OnPubSubServiceClosed;
pubSub.Connect();
}
}
public async Task Connect()
{
_twitchClient.OnConnected += TwitchClientConnected;
_twitchClient.Connect();
await _connectionCompletionTask.Task;
}
public Bot(TwitchSettings twitchSettings, IServiceProvider serviceProvider, ILoggingService loggingService)
{
this.serviceProvider = serviceProvider;
this.loggingService = loggingService;
LoadCommands();
ConnectionCredentials credentials = new ConnectionCredentials("developersgarage_bot", twitchSettings.OauthToken);
var clientOptions = new ClientOptions
{
MessagesAllowedInPeriod = 750,
ThrottlingPeriod = TimeSpan.FromSeconds(30)
};
WebSocketClient customClient = new WebSocketClient(clientOptions);
client = new TwitchClient(customClient);
client.Initialize(credentials, "developersgarage");
client.OnLog += Client_OnLog;
client.OnJoinedChannel += Client_OnJoinedChannel;
client.OnMessageReceived += Client_OnMessageReceived;
//client.OnWhisperReceived += Client_OnWhisperReceived;
//client.OnNewSubscriber += Client_OnNewSubscriber;
client.OnConnected += Client_OnConnected;
client.OnUserJoined += Client_OnUserJoined;
client.Connect();
}
public void Initialize(IServiceProvider serviceProvider)
{
mServiceProvider = serviceProvider;
Commands = Command.GetCommands(mServiceProvider);
_client.OnConnected += (s, e) =>
{
Console.WriteLine($"Connected to {e.AutoJoinChannel}");
};
_client.OnJoinedChannel += (s, e) =>
{
Console.WriteLine("Joined server.");
};
_client.OnNewSubscriber += (s, e) =>
{
};
_client.OnReSubscriber += (s, e) =>
{
};
_client.OnMessageReceived += async(s, e) => await ProcessCommand(e.ChatMessage);
_client.Connect();
}
public async Task Connect()
{
_twitchClient.OnConnected += TwitchClient_OnConnected;
_twitchClient.Connect();
await _connectionCompletionTask.Task.ConfigureAwait(false);
}
public Task StartAsync(CancellationToken cancellationToken)
{
_twitchClient.OnMessageReceived += Client_OnMessageReceived;
_twitchClient.Connect();
return(Task.CompletedTask);
}
public Task StartAsync(CancellationToken cancellationToken)
{
_twitchClient.OnMessageReceived += Client_OnMessageReceived;
_twitchClient.Connect();
_timer = new Timer(TimedWork, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
return(Task.CompletedTask);
}
public void Start()
{
_client.Initialize(new ConnectionCredentials("StreamerCompanion", _config["Secure:TwitchToken"]));
_twitchApi.Settings.ClientId = "yjg7ikvnh54s37xgxao69ufub0nv4b";
_twitchApi.Settings.AccessToken = _config["Secure:TwitchApiToken"];
_client.AutoReListenOnException = true;
_client.OnDisconnected += OnDisconnected;
_client.Connect();
}
public void Start()
{
var credentials = new ConnectionCredentials(_twitchSettings.Username, _twitchSettings.AccessToken);
_twitchClient.Initialize(credentials, _twitchSettings.Channel);
_twitchClient.Connect();
_twitchClient.OnConnected += TwitchClient_OnConnected;
_twitchClient.OnDisconnected += TwitchClient_OnDisconnected;
_twitchClient.OnMessageReceived += TwitchClient_OnMessageReceived;
_twitchClient.OnJoinedChannel += TwitchClient_OnJoinedChannel;
}
public void Connect()
{
/*ConsoleWriterMain.Program consoleWriter = new ConsoleWriterMain.Program();
* Process.Start(consoleWriter.ReturnPath() + "\\ConsoleWriterMain.exe");
* Console.ReadLine();*/
client = new TwitchClient();
client.Initialize(credentials, Channel);
client.OnJoinedChannel += Client_OnJoinedChannel;
client.OnMessageReceived += Client_OnMessageReceived;
client.OnMessageSent += Client_OnMessageSent;
client.OnWhisperSent += Client_OnWhisperSent;
client.Connect();
}
public void connect()
{
ConnectionCredentials credentials = new ConnectionCredentials(this.ChatBotTwitchUsername, this.ChatBotTwitchOauthToken);
twitchClient = new TwitchClient(credentials, this.channelDetails.channelName, '!', '!', false, null, true);
twitchClient.Logging = false;
twitchClient.ChatThrottler = new TwitchLib.Services.MessageThrottler(twitchClient, numberOfMessagesAllowed, TimeSpan.FromSeconds(secondsThrottled));
twitchClient.OnMessageReceived += new EventHandler <OnMessageReceivedArgs>(globalChatMessageReceived);
//cl.OnWhisperReceived += new EventHandler<OnWhisperReceivedArgs>(komarusSecretCommand);
twitchClient.OnConnected += new EventHandler <OnConnectedArgs>(onConnected);
twitchClient.OnConnectionError += Cl_OnConnectionError;
twitchClient.OnIncorrectLogin += Cl_OnIncorrectLogin;
twitchClient.OnDisconnected += Cl_OnDisconnected;
this.logger.LogInformation($"Connecting to {this.channelDetails.channelName}...");
twitchClient.Connect();
twitchClient.ChatThrottler.StartQueue();
}
public Task Connect(string twitchUsername, string accessToken, string channel)
{
_twitchClient.Initialize(new ConnectionCredentials(twitchUsername, accessToken), channel);
_twitchClient.OnLog += OnLog;
_twitchClient.OnMessageReceived += async(sender, message) =>
{
// Don't run a command if it is from a known bot
if (Constants.KnownBots.Any(bot =>
bot.Equals(message.ChatMessage.Username, StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
await _commandManager.MessageReceived(sender, message);
await _soundEffectManager.MessageReceived(sender, message);
};
_twitchClient.Connect();
return(Task.CompletedTask);
}
private static async Task SetupAndConnectABot()
{
_api = new TwitchAPI();
_api.Settings.Validators.SkipAccessTokenValidation = true;
_api.Settings.Validators.SkipDynamicScopeValidation = true;
_api.Settings.ClientId = _clientId;
_api.Settings.AccessToken = _secret;
await Task.Run(() =>
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(theme: AnsiConsoleTheme.Grayscale)
.CreateLogger();
var credentials = new ConnectionCredentials(_username, _oauth);
var logFactory = new TwitchLib.Logging.Providers.SeriLog.SerilogFactory();
_client = new TwitchClient(credentials, channel: _channel, logging: true, logger: new TwitchLib.Logging.Providers.SeriLog.SerilogLogger(Log.Logger, logFactory));
_client.OnMessageReceived += Client_OnMessageReceived;
_client.OnConnectionError += _client_OnConnectionError;
_client.ChatThrottler = new TwitchLib.Services.MessageThrottler(_client, 60, TimeSpan.FromSeconds(60));
_client.WhisperThrottler = new TwitchLib.Services.MessageThrottler(_client, 30, TimeSpan.FromSeconds(30));
_client.OnConnected += (s, e) => {
_client.ChatThrottler.StartQueue();
_client.WhisperThrottler.StartQueue();
};
_client.OnDisconnected += (s, e) => {
_client.ChatThrottler.StopQueue();
_client.WhisperThrottler.StopQueue();
};
_client.Connect();
bool running = true;
while (running)
{
var line = Console.ReadLine();
switch (line)
{
case "!exit":
running = false;
break;
case "!me":
JoinMyChannel();
break;
case "!testmessages":
TestSending();
break;
default:
if (line.StartsWith("!join"))
{
JoinChannel(line.Split(' ')[1]);
break;
}
else
{
_client.SendMessage(line);
}
break;
}
}
});
}
public void Connect()
{
twitchClient.Connect();
Thread.Sleep(3000);
}
