/// <summary>SendWhisper wrapper method that will send a whisper back to the user who most recently sent a whisper to this bot.</summary>
public static void ReplyToLastWhisper(this ITwitchClient client, string message = "", bool dryRun = false)
{
if (client.PreviousWhisper != null)
{
client.SendWhisper(client.PreviousWhisper.Username, message, dryRun);
}
}
/// <summary>
/// Timesout a user using the first joined channel.
/// </summary>
/// <param name="viewer">Viewer name to timeout</param>
/// <param name="duration">Duration of the timeout via TimeSpan object</param>
/// <param name="message">Message to accompany the timeout and show the user.</param>
/// <param name="dryRun">Indicates a dryrun (will not sened if true)</param>
/// <param name="client">Client reference used to identify extension.</param>
public static void TimeoutUser(this ITwitchClient client, string viewer, TimeSpan duration, string message = "", bool dryRun = false)
{
if (client.JoinedChannels.Count > 0)
{
TimeoutUser(client, client.JoinedChannels[0], viewer, duration, message, dryRun);
}
}
public TwitchChannelLink(ITwitchEventProxy eventProxy, string userName, string accessToken, string channel)
{
_eventProxy = eventProxy;
Client = new TwitchClient();
Client.OnConnected += Client_OnConnected;
Client.OnBeingHosted += Client_OnBeingHosted;
Client.OnChannelStateChanged += Client_OnChannelStateChanged;
Client.OnChatCleared += Client_OnChatCleared;
Client.OnChatColorChanged += Client_OnChatColorChanged;
Client.OnChatCommandReceived += Client_OnChatCommandReceived;
Client.OnConnectionError += Client_OnConnectionError;
Client.OnDisconnected += Client_OnDisconnected;
Client.OnExistingUsersDetected += Client_OnExistingUsersDetected;
Client.OnGiftedSubscription += Client_OnGiftedSubscription;
Client.OnHostingStarted += Client_OnHostingStarted;
Client.OnHostingStopped += Client_OnHostingStopped;
Client.OnHostLeft += Client_OnHostLeft;
Client.OnIncorrectLogin += Client_OnIncorrectLogin;
Client.OnJoinedChannel += Client_OnJoinedChannel;
Client.OnLeftChannel += Client_OnLeftChannel;
Client.OnLog += Client_OnLog;
Client.OnMessageSent += Client_OnMessageSent;
Client.OnMessageThrottled += Client_OnMessageThrottled;
Client.OnMessageReceived += Client_OnMessageReceived;
Client.OnWhisperReceived += Client_OnWhisperReceived;
Client.OnNewSubscriber += Client_OnNewSubscriber;
Client.OnError += Client_OnError;
// Token by https://github.com/swiftyspiffy/twitch-token-generator
ConnectionCredentials credentials = new ConnectionCredentials(userName, accessToken);
Client.Initialize(credentials, channel);
}
public GamesService(IIgdbClient igdbClient, ITwitchClient twitchClient, ILogger <GamesService> logger, IMemoryCache cache)
{
_igdbClient = igdbClient;
_twitchClient = twitchClient;
_logger = logger;
_cache = cache;
}
public void Execute(ITwitchClient client, ChatMessage message, ReadOnlyMemory <char> parsedText)
{
if (allCommands.Count == 0)
{
PopulateAllCommandsDictionary(service);
}
if (parsedText.IsEmpty)
{
var keys = allCommands.Keys;
var output = string.Join(",", keys);
client.SendMessage(message.Channel, $"Available commands: {output}");
}
else
{
var parsedTextAsString = parsedText.ToString();
if (allCommands.ContainsKey(parsedTextAsString))
{
client.SendMessage(message.Channel, $"{parsedText}: {allCommands[parsedTextAsString]}");
}
else
{
client.SendMessage(message.Channel, $"{parsedText} command does not exist in bot");
}
}
}
public async Task ProcessMessage(ChatMessage chatMessage, ITwitchClient twitchClient)
{
var message = chatMessage.Message;
if (Regex.IsMatch(message, @"^[!#]\w+$", RegexOptions.Compiled) && Regex.IsMatch(message, @"^\P{IsCyrillic}+$", RegexOptions.Compiled))
{
if (ignoredCommands.Contains(message, StringComparer.OrdinalIgnoreCase))
{
return;
}
Random rand = new();
if (rand.Next(100) <= RandomizerChance)
{
var occurenceNumber = recentCommandsCache.GetAndUpdateCommandOccurences(message);
if (occurenceNumber >= NumberOfOccurencesToTrigger)
{
recentCommandsCache.DeleteCommand(message);
logger.LogWarning($"Participate in raffle on channel {chatMessage.Channel} with command {message}");
await Task.Run(async() =>
{
await Task.Delay(rand.Next(5000));
twitchClient.SendMessage(chatMessage.Channel, message);
});
}
}
}
}
public TwitchChatService(ITwitchClient client, IChannelDiscoverer discoverer, TimeSpan channelSniffInterval)
{
this._client = client;
this._discoverer = discoverer;
this.SniffInterval = channelSniffInterval;
client.OnMessageReceived += ClientOnMessageReceived;
}
/// <summary>
/// Unbans a user in chat using first joined channel.
/// </summary>
/// <param name="viewer">Viewer name to unban</param>
/// <param name="dryRun">Indicates a dryrun (will not send if true)</param>
/// <param name="client">Client reference used to identify extension.</param>
public static void UnbanUser(this ITwitchClient client, string viewer, bool dryRun = false)
{
if (client.JoinedChannels.Count > 0)
{
UnbanUser(client, client.JoinedChannels[0], viewer, dryRun);
}
}
public GiveGilCommand(GilBank gilBank, ITwitchClient twitchClient, ITwitchAPI api)
: base(x => x.GiveGilCommandWords, x => true)
{
_gilBank = gilBank;
_twitchClient = twitchClient;
_api = api;
}
public ClassChoiceNotifier(ITwitchClient client, IPlayerFactory pf,
int classChoiceLevel)
{
this.client = client;
this.playerFactory = pf;
this.classChoiceLevel = classChoiceLevel;
}
public StatusCommand(ITwitchClient twitchClient) : base(new List <string> {
"status", "st"
})
{
_twitchClient = twitchClient;
}
/// <summary>
/// Sends command to start a commercial of variable length.
/// </summary>
/// <param name="client">Client reference used to identify extension.</param>
/// <param name="channel">String representation of the channel to send the ad to.</param>
/// <param name="length">Enum representing the length of advertisement should be.</param>
/// <exception cref="ArgumentOutOfRangeException">length - null</exception>
public static void StartCommercial(this ITwitchClient client, string channel, Enums.CommercialLength length)
{
switch (length)
{
case Enums.CommercialLength.Seconds30:
client.SendMessage(channel, ".commercial 30");
break;
case Enums.CommercialLength.Seconds60:
client.SendMessage(channel, ".commercial 60");
break;
case Enums.CommercialLength.Seconds90:
client.SendMessage(channel, ".commercial 90");
break;
case Enums.CommercialLength.Seconds120:
client.SendMessage(channel, ".commercial 120");
break;
case Enums.CommercialLength.Seconds150:
client.SendMessage(channel, ".commercial 150");
break;
case Enums.CommercialLength.Seconds180:
client.SendMessage(channel, ".commercial 180");
break;
default:
throw new ArgumentOutOfRangeException(nameof(length), length, null);
}
}
public HelpCommand(ITwitchClient twitchClient) : base(new List <string> {
"help", "hp"
})
{
_twitchClient = twitchClient;
}
/// <summary>
/// Bans a user in chat using the first joined channel
/// </summary>
/// <param name="viewer">Viewer name to ban</param>
/// <param name="message">Message to accompany the ban and show the user.</param>
/// <param name="dryRun">Indicates a dryrun (will not send if true)</param>
/// <param name="client">Client reference used to identify extension.</param>
public static void BanUser(this ITwitchClient client, string viewer, string message = "", bool dryRun = false)
{
if (client.JoinedChannels.Count > 0)
{
BanUser(client, client.JoinedChannels[0], viewer, message, dryRun);
}
}
public ModManager(ITwitchClient twitchClient)
{
m_modLibrary = new Dictionary <string, TModType>();
m_modListener = (TModListener)Activator.CreateInstance(typeof(TModListener), twitchClient);
m_modListener.RegisterEvents();
m_modListener.OnInputReceived += HandleInput;
}
public NameBiddingViewModel(INameAccessor nameAccessor, ITwitchClient twitchClient,
IDataStore <CharacterNameBid> dataStore, IDialogService dialogService, ILogger <NameBiddingViewModel> logger,
ILogger <CharacterNameBidding> charNameBiddingLogger)
{
DomainEvents.Register <RemovingName>(HandleNameRemoval);
DomainEvents.Register <NameVoteReceived>(HandleNameVote);
DomainEvents.Register <TopNameChanged>(HandleTopNameChange);
DomainEvents.Register <RefreshEvent>(HandleNameRefresh);
_nameAccessor = nameAccessor;
_twitchClient = twitchClient;
_dataStore = dataStore;
_dialogService = dialogService;
_logger = logger;
_charNameBiddingLogger = charNameBiddingLogger;
ResetDataCommand = new SimpleCommand(x =>
{
if (_dialogService.ConfirmDialog("Are you sure you want to reset all name bids?"))
{
Reset();
}
});
foreach (CharNames charName in CharNames.Core)
{
CharacterNameBiddings.Add(new CharacterNameBidding(charName, _charNameBiddingLogger));
}
}
public void Handle(ITwitchClient client, IChatCommand command)
{
if (this.CanHandle(command))
{
this.HandleInternal(client, command);
}
}
public ChatBot(IOptions <TwitchSettings> twitchSettings,
ITwitchClient twitchClient, IColorEmitter colorEmitter)
{
_twitchClient = twitchClient;
_colorEmitter = colorEmitter;
_twitchSettings = twitchSettings.Value;
}
public QueueCommandHandler(ILogger <QueueCommandHandler> logger, ITwitchClient twitchClient, AppSettings settings, IRequestQueue requestQueue)
{
this.logger = logger;
this.twitchClient = twitchClient;
this.settings = settings;
this.requestQueue = requestQueue;
}
public void CreateEventAndRaise(ITwitchClient client, string raw)
{
Regex r = new Regex(AcceptingRegex);
MatchCollection mc = r.Matches(raw);
if (mc.Count == 1)
{
string tags = string.Empty;
string user = string.Empty;
string message = string.Empty;
GroupCollection gc = mc[0].Groups;
tags = gc[1].Value;
user = gc[2].Value;
message = gc[4].Value;
if (message.StartsWith("!"))
{
CreateRequestAndRaise(client, tags, user, message, raw);
}
else
{
CreateMessageAndRaise(client, tags, user, message, raw);
}
}
}
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 NonBattleCommand(T internalCommand,
ITwitchClient twitchClient, IMemoryAccessor memoryAccessor)
{
_internalCommand = internalCommand;
_twitchClient = twitchClient;
_memoryAccessor = memoryAccessor;
}
public BroadcastNotifications(ITwitchClient twitchClient, IOptions <TwitchOptions> twitchOptions, ITwitchBucketProvider bucketProvider)
{
_twitchClient = twitchClient;
_twitchOptions = twitchOptions;
_bucketProvider = bucketProvider;
_rand = new Random();
}
public TwitchBot(ITwitchClient twitchClient, ICommandManager commandManager,
SoundEffectManager.SoundEffectManager soundEffectManager)
{
_twitchClient = twitchClient;
_commandManager = commandManager;
_soundEffectManager = soundEffectManager;
}
private void CreateMessageAndRaise(ITwitchClient client, string tags, string user,
string message, string raw)
{
TwitchTags twitchTags = new TwitchTags(tags);
WhisperEventArgs e = new WhisperEventArgs(twitchTags, user, message, raw);
client.OnEvent(e);
}
private void CreateMessageAndRaise(ITwitchClient client, string tags, string user,
string channel, string message, string raw)
{
TwitchTags twitchTags = new TwitchTags(tags);
PrivEventArgs e = new PrivEventArgs(twitchTags, user, channel, message, raw);
client.OnEvent(e);
}
/// <summary>
/// TImesout a user in chat using a JoinedChannel object.
/// </summary>
/// <param name="channel">Channel object to send timeout to</param>
/// <param name="viewer">Viewer name to timeout</param>
/// <param name="duration">Duration of the timeout via TimeSpan object</param>
/// <param name="message">Message to accompany the timeout and show the user.</param>
/// <param name="dryRun">Indicates a dryrun (will not sened if true)</param>
/// <param name="client">Client reference used to identify extension.</param>
public static void TimeoutUser(this ITwitchClient client, JoinedChannel channel, string viewer, TimeSpan duration, string message = "", bool dryRun = false)
{
if (duration < TimeSpan.FromSeconds(1))
{
throw new Exceptions.InvalidParameterException("timeout duration must be longer than 1 second", client.TwitchUsername);
}
client.SendMessage(channel, $".timeout {viewer} {duration.Days}d{duration.Hours}h{duration.Minutes}m{duration.Seconds}s {message}", dryRun);
}
public CounterCommand(ITwitchClient twitchClient, ICounterService counterService) : base(new List <string>
{
"counter", "count"
})
{
_twitchClient = twitchClient;
_counterService = counterService;
}
public void Handle(ITwitchClient twitchClient, ChatMessage chatMessage)
{
twitchClient.SendMessage(chatMessage.Channel,
@"Come join us on 'The Hub' Discord server. The Hub is a group of Sci-Tech Twitch streamers
with a common goal of sharing knowledge and building each other up. Look for 'The Crew Lounge'
for our channels, but feel free to join other channels as well. You never know what you'll learn.
Check it out at https://discord.gg/jw4JRkvDks");
}
public UpdateStreamsService(IStreamsRepository repository, ITwitchClient twitch,
IOptions <AppSettings> settings, ILogger <UpdateStreamsService> logger)
{
_repository = repository;
_twitch = twitch;
_settings = settings;
_logger = logger;
}
public static TwitchService(ITwitchStaticClient staticClient, ITwitchClient twitchClient, ITwitchClientGeneric clientGeneric)
{
_staticClient = staticClient;
_twitchClient = twitchClient;
_clientGeneric = clientGeneric;
}
