public GiveGilCommand(GilBank gilBank, ITwitchClient twitchClient, ITwitchAPI api)
: base(x => x.GiveGilCommandWords, x => true)
{
_gilBank = gilBank;
_twitchClient = twitchClient;
_api = api;
}
public Server(ITwitchNETDALService twitchNETService,
TwitchClient client,
IBot bot,
IServerDTO serverDTO,
ITwitchAPI twitchAPI,
int maxMessagesInQueue)
{
_twitchNetService = twitchNETService;
_serverDTO = serverDTO;
_bot = bot;
_twitchAPI = twitchAPI;
_maxMessagesInQueue = maxMessagesInQueue;
_client = client;
_client.OnUserJoined += OnUserJoined;
_client.OnUserLeft += OnUserLeft;
_client.OnJoinedChannel += OnJoinedChannel;
_client.OnMessageReceived += OnMessageReceived;
_client.OnNewSubscriber += OnNewSubscriber;
_client.OnLeftChannel += OnLeaveChannel;
_client.OnChatColorChanged += OnChatColorChanged;
if (_client.IsConnected &&
!_client.JoinedChannels.Any(s => s.Channel.Trim().ToLower() == serverDTO.Username.Trim().ToLower()))
{
_client.JoinChannel(_serverDTO.Username.Trim().ToLower());
}
}
/// <summary>
/// Async main method
/// </summary>
/// <param name="args">Arguments</param>
/// <returns>the Task</returns>
private async Task MainAsync(string[] args)
{
var channelId = Settings.GetSection("twitch").GetValue <string>("channelId");
//set up twitchlib api
API = new TwitchAPI();
API.Settings.ClientId = Settings.GetSection("twitch.api").GetValue <string>("client-id");
API.Settings.Secret = Settings.GetSection("twitch.api").GetValue <string>("secret");
//Set up twitchlib pubsub
PubSub = new TwitchPubSub();
PubSub.OnListenResponse += OnListenResponse;
PubSub.OnPubSubServiceConnected += OnPubSubServiceConnected;
PubSub.OnPubSubServiceClosed += OnPubSubServiceClosed;
PubSub.OnPubSubServiceError += OnPubSubServiceError;
//Set up listeners
ListenToBits(channelId);
ListenToChatModeratorActions(channelId, channelId);
ListenToFollows(channelId);
ListenToLeaderboards(channelId);
ListenToPredictions(channelId);
ListenToRaid(channelId);
ListenToRewards(channelId);
ListenToSubscriptions(channelId);
ListenToVideoPlayback(channelId);
ListenToWhispers(channelId);
//Connect to pubsub
PubSub.Connect();
//Keep the program going
await Task.Delay(Timeout.Infinite);
}
public AtAll(ITwitchClientManager client,
TextWriter writer,
ITwitchAPI api)
: base(client, writer)
{
Api = api;
}
public LiveStreamMonitorService(ITwitchAPI api, int secondsBetweenChecks)
{
this.api = api;
//Load the info for streams that have been reported on.
//string monitoredUsersResult = SaveLoadService.Load(monitoredUsersFilename);
Dictionary <string, Stream> monitoredChannels = SaveLoadService.Load <Dictionary <string, Stream> >(monitoredUsersFilename);
if (monitoredChannels == null)
{
monitoredChannels = new Dictionary <string, Stream>();
SaveLoadService.Save(monitoredUsersFilename, monitoredChannels);
}
LiveStreams.Clear();
foreach (var key in monitoredChannels.Keys)
{
LiveStreams.TryAdd(key, monitoredChannels[key]);
}
// Call the check with the given interval between the calls.
timer = new Timer(TimeSpan.FromSeconds(secondsBetweenChecks).TotalMilliseconds);
timer.AutoReset = true;
timer.Elapsed += new ElapsedEventHandler(Tick);
timer.Start();
}
public UnityFollowerService(ITwitchAPI api, int checkIntervalSeconds = 60, int queryCount = 25) : base(api, checkIntervalSeconds, queryCount)
{
ThreadDispatcher.EnsureCreated();
base.OnServiceStarted += ((object sender, OnServiceStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStarted?.Invoke(sender, e)); });
base.OnServiceStopped += ((object sender, OnServiceStoppedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStopped?.Invoke(sender, e)); });
base.OnNewFollowersDetected += ((object sender, OnNewFollowersDetectedArgs e) => { ThreadDispatcher.Enqueue(() => OnNewFollowersDetected?.Invoke(sender, e)); });
}
public TwitchRewardsManager(ILogger <TwitchRewardsManager> logger, ITwitchAPI twitchApi, ICustomRewardsHolder rewardsHolder, AppSettings settings)
{
this.logger = logger;
this.twitchApi = twitchApi;
this.rewardsHolder = rewardsHolder;
this.settings = settings;
options = new JsonSerializerOptions {
WriteIndented = true, Converters = { new JsonStringEnumConverter(allowIntegerValues: true) }
};
}
/// <summary>
/// The constructor from the LiveStreamMonitorService
/// </summary>
/// <exception cref="ArgumentNullException">When the <paramref name="api"/> is null.</exception>
/// <exception cref="ArgumentException">When the <paramref name="checkIntervalInSeconds"/> is lower than one second.</exception>
/// <exception cref="ArgumentException">When the <paramref name="maxStreamRequestCountPerRequest"/> is less than 1 or more than 100.</exception>
/// <param name="api">The api used to query information.</param>
/// <param name="checkIntervalInSeconds"></param>
/// <param name="maxStreamRequestCountPerRequest"></param>
public LiveStreamMonitorService(ITwitchAPI api, int checkIntervalInSeconds = 60, int maxStreamRequestCountPerRequest = 100) :
base(api, checkIntervalInSeconds)
{
if (maxStreamRequestCountPerRequest < 1 || maxStreamRequestCountPerRequest > 100)
{
throw new ArgumentException("Twitch doesn't support less than 1 or more than 100 streams per request.", nameof(maxStreamRequestCountPerRequest));
}
MaxStreamRequestCountPerRequest = maxStreamRequestCountPerRequest;
}
public TwitchBot(ConnectionCredentials credentials, string accessToken, string clientID, string channel)
{
_client = new TwitchClient();
_client.Initialize(credentials, channel, Prefix, Prefix);
_client.SetConnectionCredentials(credentials);
_api = new TwitchAPI();
_api.Settings.AccessToken = accessToken;
_api.Settings.ClientId = clientID;
}
public UnityFollowerService(ITwitchAPI api, int checkIntervalSeconds = 60, int queryCount = 25) : base(api, checkIntervalSeconds, queryCount)
{
_threadDispatcher = new GameObject("ThreadDispatcher");
_threadDispatcher.AddComponent <ThreadDispatcher>();
UnityEngine.Object.DontDestroyOnLoad(_threadDispatcher);
base.OnServiceStarted += ((object sender, OnServiceStartedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnServiceStarted?.Invoke(sender, e)); });
base.OnServiceStopped += ((object sender, OnServiceStoppedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnServiceStopped?.Invoke(sender, e)); });
base.OnNewFollowersDetected += ((object sender, OnNewFollowersDetectedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnNewFollowersDetected?.Invoke(sender, e)); });
}
/// <summary>Service constructor.</summary>
/// <exception cref="BadResourceException">If channel is invalid, an InvalidChannelException will be thrown.</exception>
/// <param name="checkIntervalSeconds">Param representing number of seconds between calls to Twitch Api.</param>
/// <param name="queryCount">Number of recent followers service should request from Twitch Api. Max: 100, Min: 1</param>
/// <param name="clientId">Optional param representing Twitch Api-required application client id, not required if already set.</param>
public FollowerService(ITwitchAPI api, int checkIntervalSeconds = 60, int queryCount = 25, string clientId = "")
{
_api = api;
CheckIntervalSeconds = checkIntervalSeconds;
QueryCount = queryCount;
_followerServiceTimer.Elapsed += _followerServiceTimerElapsed;
if (clientId != "")
{
ClientId = clientId;
}
}
public UnityLiveStreamMonitor(ITwitchAPI api, int checkIntervalSeconds = 60, int maxStreamRequestCountPerRequest = 100) : base(api, checkIntervalSeconds, maxStreamRequestCountPerRequest)
{
ThreadDispatcher.EnsureCreated();
base.OnStreamOnline += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
base.OnStreamOffline += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
base.OnStreamUpdate += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
base.OnServiceStarted += ((object sender, OnServiceStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStarted?.Invoke(sender, e)); });
base.OnServiceStopped += ((object sender, OnServiceStoppedArgs e) => { ThreadDispatcher.Enqueue(() => OnServiceStopped?.Invoke(sender, e)); });
base.OnChannelsSet += ((object sender, OnChannelsSetArgs e) => { ThreadDispatcher.Enqueue(() => OnChannelsSet?.Invoke(sender, e)); });
}
public UnityLiveStreamMonitor(ITwitchAPI api, int checkIntervalSeconds = 60, bool checkStatusOnStart = true, bool invokeEventsOnStart = false) : base(api, checkIntervalSeconds, checkStatusOnStart, invokeEventsOnStart)
{
ThreadDispatcher.EnsureCreated();
base.OnStreamOnline += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
base.OnStreamOffline += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
base.OnStreamUpdate += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
base.OnStreamMonitorStarted += ((object sender, OnStreamMonitorStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamMonitorStarted?.Invoke(sender, e)); });
base.OnStreamMonitorEnded += ((object sender, OnStreamMonitorEndedArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamMonitorEnded?.Invoke(sender, e)); });
base.OnStreamsSet += ((object sender, OnStreamsSetArgs e) => { ThreadDispatcher.Enqueue(() => OnStreamsSet?.Invoke(sender, e)); });
}
// private readonly IDatabaseService<TwitchUser> _database;
public TwitchBot(
ILoggerFactory loggerFactory
, ITwitchAPI twitchApi
, IOptionsMonitor <Credentials> options
// , IDatabaseService<TwitchUser> database
)
{
_logger = loggerFactory.CreateLogger("twitch");
_twitchAPI = twitchApi;
_options = options.CurrentValue;
// _database = database;
}
public ServerManager(ITwitchNETDALService twitchNETService,
TwitchClient client,
ITwitchAPI twitchAPI,
IBot bot,
int maxNumberMessagesInQueue)
{
_twitchNetService = twitchNETService;
_client = client;
_bot = bot;
_twitchAPI = twitchAPI;
_maxNumberMessagesInQueue = maxNumberMessagesInQueue;
}
public TwitchChatClient(TwitchClientSettings settings, ITwitchAPI twitchApi)
{
_settings = settings;
_twitchApi = twitchApi;
var credentials = new ConnectionCredentials(settings.TwitchUsername, settings.TwitchOAuth);
_twitchClient = new TwitchClient(credentials, settings.TwitchChannel);
_twitchClient.OnChatCommandReceived += ChatCommandReceived;
_twitchClient.OnNewSubscriber += NewSubscriber;
_twitchClient.OnUserJoined += TwitchClientOnOnUserJoined;
_twitchClient.OnUserLeft += TwitchClientOnOnUserLeft;
}
public async void SetFollowerService(ITwitchAPI api)
{
// FollowerService
_followerService = new FollowerService(api);
_followerService.SetChannelByChannelId(AivaClient.Instance.ChannelId);
_followerService.OnNewFollowersDetected
+= (sender, e)
=> OnNewFollower?.Invoke(this, e.NewFollowers);
await _followerService.StartService().ConfigureAwait(false);
}
public UnityFollowerService(ITwitchAPI api, int checkIntervalSeconds = 60, bool checkStatusOnStart = true, bool invokeEventsOnStart = false) : base(api, checkIntervalSeconds, checkStatusOnStart, invokeEventsOnStart)
{
_threadDispatcher = new GameObject("ThreadDispatcher");
_threadDispatcher.AddComponent <ThreadDispatcher>();
UnityEngine.Object.DontDestroyOnLoad(_threadDispatcher);
base.OnStreamOnline += ((object sender, OnStreamOnlineArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamOnline?.Invoke(sender, e)); });
base.OnStreamOffline += ((object sender, OnStreamOfflineArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamOffline?.Invoke(sender, e)); });
base.OnStreamUpdate += ((object sender, OnStreamUpdateArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamUpdate?.Invoke(sender, e)); });
base.OnStreamMonitorStarted += ((object sender, OnStreamMonitorStartedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamMonitorStarted?.Invoke(sender, e)); });
base.OnStreamMonitorEnded += ((object sender, OnStreamMonitorEndedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamMonitorEnded?.Invoke(sender, e)); });
base.OnStreamsSet += ((object sender, OnStreamsSetArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnStreamsSet?.Invoke(sender, e)); });
}
public TwitchChatClient(TwitchClientSettings settings, ITwitchAPI twitchApi, ILoggerAdapter <TwitchChatClient> logger)
{
_settings = settings;
_twitchApi = twitchApi;
_logger = logger;
var credentials = new ConnectionCredentials(settings.TwitchUsername, settings.TwitchBotOAuth);
_twitchClient = new TwitchClient();
_twitchClient.Initialize(credentials, channel: settings.TwitchChannel);
_twitchClient.OnChatCommandReceived += ChatCommandReceived;
_twitchClient.OnNewSubscriber += NewSubscriber;
_twitchClient.OnUserJoined += TwitchClientOnOnUserJoined;
_twitchClient.OnUserLeft += TwitchClientOnOnUserLeft;
}
public TwitchFollowerService(ITwitchAPI twitchApi, TwitchClientSettings settings)
{
_twitchApi = twitchApi;
_settings = settings;
_followerService = new FollowerService(twitchApi);
_followerService.SetChannelByChannelId(settings.TwitchChannelId);
_followerService.StartService().Wait();
_followerService.OnNewFollowersDetected += FollowerServiceOnOnNewFollowersDetected;
}
/// <summary>
/// Constructor from the ApiService.
/// </summary>
/// <exception cref="ArgumentNullException">When the <paramref name="api"/> is null.</exception>
/// <exception cref="ArgumentException">When the <paramref name="checkIntervalInSeconds"/> is lower than one second.</exception>
/// <param name="api">The api used to query information.</param>
/// <param name="checkIntervalInSeconds"></param>
protected ApiService(ITwitchAPI api, int checkIntervalInSeconds)
{
if (api == null)
{
throw new ArgumentNullException(nameof(api));
}
if (checkIntervalInSeconds < 1)
{
throw new ArgumentException("The interval must be 1 second or more.", nameof(checkIntervalInSeconds));
}
_api = api;
_serviceTimer = new ServiceTimer(OnServiceTimerTick, checkIntervalInSeconds);
}
/// <summary>
/// FollowerService constructor.
/// </summary>
/// <exception cref="ArgumentNullException">When the <paramref name="api"/> is null.</exception>
/// <exception cref="ArgumentException">When the <paramref name="checkIntervalInSeconds"/> is lower than one second.</exception>
/// <exception cref="ArgumentException">When the <paramref name="queryCountPerRequest" /> is less than 1 or more than 100 followers per request.</exception>
/// <exception cref="ArgumentException">When the <paramref name="cacheSize" /> is less than the queryCountPerRequest.</exception>
/// <param name="api">The api to use for querying followers.</param>
/// <param name="checkIntervalInSeconds">How often new followers should be queried.</param>
/// <param name="queryCountPerRequest">The amount of followers to query per request.</param>
/// <param name="cacheSize">The maximum amount of followers to cache per channel.</param>
public FollowerService(ITwitchAPI api, int checkIntervalInSeconds = 60, int queryCountPerRequest = 100, int cacheSize = 1000) :
base(api, checkIntervalInSeconds)
{
if (queryCountPerRequest < 1 || queryCountPerRequest > 100)
{
throw new ArgumentException("Twitch doesn't support less than 1 or more than 100 followers per request.", nameof(queryCountPerRequest));
}
if (cacheSize < queryCountPerRequest)
{
throw new ArgumentException($"The cache size must be at least the size of the {nameof(queryCountPerRequest)} parameter.", nameof(cacheSize));
}
QueryCountPerRequest = queryCountPerRequest;
CacheSize = cacheSize;
}
public ConsoleApplication(
ILogger <ConsoleApplication> logger,
IOptions <AppSettings> config,
ITwitchAPI twitchApi,
IApiSettings apiSettings,
IWebhookService webhookService
)
{
_logger = logger;
_config = config;
_twitchApi = twitchApi;
_apiSettings = apiSettings;
_webhookService = webhookService;
_twitchMonitor = new LiveStreamMonitorService(_twitchApi, config.Value.TwitchApiCheckIntervalSeconds);
_token = new CancellationToken();
}
public TwitchFollowerService(ITwitchAPI twitchApi, TwitchClientSettings settings)
{
_twitchApi = twitchApi;
_settings = settings;
_followerService = new FollowerService(twitchApi);
_followerService.SetChannelsById(new List <string> {
settings.TwitchChannelId
});
_followerService.Start();
_followerService.OnNewFollowersDetected += FollowerServiceOnOnNewFollowersDetected;
}
public TwitchBot(
ILogger <TwitchBot> logger,
AppSettings settings,
ConnectionCredentials credentials,
ITwitchAPI api,
ITwitchPubSub pubSub,
ITwitchClient client,
IOnRewardHandler onRewardHandler,
IOnMessageHandler onMessageHandler)
{
this.logger = logger;
this.settings = settings;
this.credentials = credentials;
this.api = api;
this.pubSub = pubSub;
this.client = client;
this.onRewardHandler = onRewardHandler;
this.onMessageHandler = onMessageHandler;
}
public AmongUsTwitchAPI(Settings settings)
{
var outputTemplate = "[{Timestamp:HH:mm:ss} {Level}] {Message}{NewLine}{Exception}";
_logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Console(outputTemplate: outputTemplate)
.WriteTo.File("log/api_log_.txt", outputTemplate: outputTemplate, rollingInterval: RollingInterval.Day)
.CreateLogger();
rewards = new Dictionary <int, CustomReward>();
API = new TwitchAPI();
this.channelId = settings.twitch.channelId;
this.clientId = settings.twitch.api.clientId;
this.secret = settings.twitch.api.secret;
this.accessToken = settings.twitch.token.userAccess;
this.refreshToken = settings.twitch.token.refresh;
}
public TwitchService
(
string clientId,
ConfigurationService configurationService,
ISpeechSynthesizerService speechSynthesizerService,
ITwitchAPI api = null,
ITwitchPubSub pubSub = null,
ITwitchClient client = null
)
{
if (string.IsNullOrWhiteSpace(clientId))
{
throw new ArgumentException(Resources.Argument_cannot_be_null_or_whitespace_, nameof(clientId));
}
_configurationService = configurationService;
_speechSynthesizerService = speechSynthesizerService;
_twitchApi = api ?? new TwitchAPI();
_twitchPubSub = pubSub ?? new TwitchPubSub();
_twitchClient = client ?? new TwitchClient();
ClientId = clientId;
}
public TopViewersDiscovery(ITwitchAPI api)
{
_api = api;
}
protected CoreMonitor(ITwitchAPI api)
{
_api = api;
}
public NameBasedMonitor(ITwitchAPI api) : base(api)
{
}
