public ChatServiceMultiplexer(ILogger <ChatServiceMultiplexer> logger, IList <IChatService> streamingServices)
{
_logger = logger;
_streamingServices = streamingServices;
_twitchService = (TwitchService)streamingServices.First(s => s is TwitchService);
_bilibiliService = (BiliBiliService)streamingServices.First(s => s is BiliBiliService);
var displayNameBuilder = new StringBuilder();
foreach (var service in _streamingServices)
{
service.OnTextMessageReceived += Service_OnTextMessageReceived;
service.OnJoinChannel += Service_OnJoinChannel;
service.OnRoomStateUpdated += Service_OnRoomStateUpdated;
service.OnLeaveChannel += Service_OnLeaveChannel;
service.OnLogin += Service_OnLogin;
service.OnChatCleared += Service_OnChatCleared;
service.OnMessageCleared += Service_OnMessageCleared;
service.OnChannelResourceDataCached += Service_OnChannelResourceDataCached;
if (displayNameBuilder.Length > 0)
{
displayNameBuilder.Append(", ");
}
displayNameBuilder.Append(service.DisplayName);
}
DisplayName = displayNameBuilder.Length > 0 ? displayNameBuilder.ToString() : "Generic";
}
public DiscordBot(Config config, ILogger <DiscordBot> logger, IServiceCollection serviceCollection, TwitchService twitch)
{
_config = config;
_logger = logger;
_serviceCollection = serviceCollection;
_twitch = twitch;
}
public static void Init(TwitchClient client, TwitchPubSub pubsubClient, ApplicationSettings appSettings, Account account,
CouchDbStore <Viewer> viewerCollection, List <Command> settings)
{
_client = client;
_account = account;
_viewerCollection = viewerCollection;
_commandSettings = settings;
_twitchService = new TwitchService(appSettings);
_client.OnJoinedChannel += OnJoinedChannel;
_client.OnMessageReceived += OnMessageReceived;
_client.OnWhisperReceived += OnWhisperReceived;
_client.OnNewSubscriber += OnNewSubscriber;
_client.OnLog += OnLog;
_client.OnConnectionError += OnConnectionError;
_client.OnChatCommandReceived += OnChatCommandReceived;
_client.OnUserTimedout += OnUserTimedOut;
_client.OnUserBanned += ClientOnUserBanned;
pubsubClient.OnPubSubServiceConnected += TwitchPubSubOnOnPubSubServiceConnected;
pubsubClient.OnPubSubServiceClosed += TwitchPubSubOnOnPubSubServiceClosed;
pubsubClient.OnChannelSubscription += TwitchPubSubOnOnChannelSubscription;
pubsubClient.OnFollow += TwitchPubSubOnOnFollow;
pubsubClient.OnEmoteOnly += TwitchPubSubOnOnEmoteOnly;
pubsubClient.OnEmoteOnlyOff += TwitchPubSubOnOnEmoteOnlyOff;
pubsubClient.ListenToFollows(appSettings?.Keys.Twitch.ChannelId);
pubsubClient.ListenToSubscriptions(appSettings?.Keys.Twitch.ChannelId);
pubsubClient.ListenToChatModeratorActions(_account?.TwitchBotSettings.Username, appSettings?.Keys.Twitch.ChannelId);
}
public TwitchController(TwitchService service, DiscordBot discord, DiscordContext ctx, ILogger <TwitchController> logger)
{
_service = service;
_discord = discord;
_db = ctx;
_logger = logger;
}
public TwitchController(
AccountService accountService,
TwitchService twitchService)
{
_twitchService = twitchService;
_accountService = accountService;
}
private async Task InvokeAddTwitchListener()
{
List <IMessage> messagesInInteraction = new List <IMessage>();
try
{
messagesInInteraction.Add(Context.Message);
twitchService = new TwitchService();
messagesInInteraction.Add(await ReplyAsync("Which twitch channel do you want to monitor for stream activity?"));
var channelToWatch = await NextMessageAsync(timeout : TimeSpan.FromSeconds(60));
string twitchUserId = await getTwitchUserIdFromChannelName(messagesInInteraction, channelToWatch);
if (twitchUserId == null)
{
return;
}
messagesInInteraction.Add(await ReplyAsync("What would you like to say when this channel goes online? You can use `[streamer]` and `[streamlink]` and I will replace it with the streamer's name or their stream link respectively!"));
var announcementText = await NextMessageAsync(timeout : TimeSpan.FromSeconds(120));
if (!await IsAnnouncementNotNull(messagesInInteraction, announcementText))
{
return;
}
await twitchService.SaveOrUpdateTwitchMonitorRecord(new TwitchMonitorRecord(Context, twitchUserId, announcementText.Content));
await SendConfirmationEmbed(messagesInInteraction, channelToWatch, announcementText);
}
finally
{
await CleanUpMessagesAfterFiveSeconds(messagesInInteraction);
}
}
public async Task Twitch(CommandContext ctx,
[Description("Channel to find on Twitch")][RemainingText] string query)
{
if (!BotServices.CheckUserInput(query))
{
return;
}
var results = await TwitchService.GetTwitchDataAsync(query).ConfigureAwait(false);
if (results.Stream.Count == 0)
{
await BotServices.SendEmbedAsync(ctx, Resources.NOT_FOUND_TWITCH, EmbedType.Missing).ConfigureAwait(false);
}
else
{
var stream = results.Stream[0];
var output = new DiscordEmbedBuilder()
.WithTitle(stream.UserName + " is live on Twitch!")
.WithDescription(stream.Title)
.AddField("Start Time:", stream.StartTime, true)
.AddField("View Count:", stream.ViewCount.ToString(), true)
.WithImageUrl(stream.ThumbnailUrl.Replace("{width}", "500").Replace("{height}", "300"))
.WithUrl("https://www.twitch.tv/" + stream.UserName)
.WithColor(new DiscordColor("#6441A5"));
await ctx.RespondAsync(embed : output.Build()).ConfigureAwait(false);
}
}
public LeagueOfLegendsChannel(IHttpClient httpClient, IJsonSerializer jsonSerializer, ILogManager logManager)
{
_logger = logManager.GetLogger(GetType().Name);
_lolVideoProvider = new LolVideoProvider(httpClient, jsonSerializer, _logger);
_twitchService = new TwitchService(httpClient, jsonSerializer);
_vimeoService = new VimeoService(httpClient, jsonSerializer);
}
public TwitchTeamService(
ILogger <TwitchTeamService> logger,
ITwitchTeamMemberRepository twitchTeamMemberRepository,
ITwitchTeamSettingsRepository twitchTeamSettingsRepository,
IEnumerable <BotDiscordSocketClient> botDiscordSocketClients,
TwitchService twitchService,
Random random
)
{
_logger = logger;
_twitchTeamMemberRepository = twitchTeamMemberRepository;
_twitchTeamSettingsRepository = twitchTeamSettingsRepository;
_botDiscordSocketClients = botDiscordSocketClients;
_twitchService = twitchService;
_random = random;
_timer = new System.Timers.Timer(2 * 60 * 1000);
_timer.Elapsed += timer_Elapsed;
_timer.AutoReset = true;
_timerTeam = new System.Timers.Timer(10 * 60 * 1000);
_timerTeam.Elapsed += timerTeam_Elapsed;
_timerTeam.AutoReset = true;
_existingMessages = new ConcurrentDictionary <ulong, List <Message> >();
_guildTeamMembers = new ConcurrentDictionary <ulong, List <string> >();
}
public Channel(string channelId, TwitchService twitchService, MacroService macroService, AuthenticationService authenticationService)
{
Id = channelId.ToLower();
_twitchService = twitchService;
_macroService = macroService;
_authenticationService = authenticationService;
}
public TwitchController(TwitchService twitchService, UserService userService, TwitchManager twitchManager, ConfigurationService configurationService)
{
this.twitchService = twitchService;
this.userService = userService;
this.twitchManager = twitchManager;
this.configurationService = configurationService;
}
public void SetupTests()
{
var settingsCollection = new CouchDbStore <ApplicationSettings>(ApplicationSettings.CouchDbUrl);
var settings = settingsCollection.FindAsync("9c3131ee7b9fb97491e8551211495381").GetAwaiter().GetResult();
_twitchService = new TwitchService(settings);
}
public TwitchModule(DiscordSocketClient client)
{
if (twitchService == null)
{
twitchService = new TwitchService(client);
}
this.client = client;
}
public IntegrationController(IntegrationService integrationService, YoutubeService youtubeService,
TwitchService twitchService, DiscordService discordService)
{
this.integrationService = integrationService;
this.youtubeService = youtubeService;
this.twitchService = twitchService;
this.discordService = discordService;
}
public TwitchMonitoringJob(long channelId, TwitchService twitchService, JakeBotContext botContext,
DiscordSocketClient client)
{
_channelId = channelId;
_twitchService = twitchService;
_botContext = botContext;
_client = client;
}
public MainWindow(MainWindowViewModel mainWindowViewModel,
TwitchService twitchService)
{
_twitchService = twitchService;
DataContext = mainWindowViewModel;
Closing += MainWindow_Closing;
InitializeComponent();
}
public async Task Twitch(CommandContext ctx,
[Description("Channel to find on Twitch.")][RemainingText]
string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return;
}
await ctx.TriggerTypingAsync();
var results = await TwitchService.GetTwitchDataAsync(Program.Settings.Tokens.TwitchToken, query)
.ConfigureAwait(false);
if (results.Total == 0)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_TWITCH, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
foreach (var streamer in results.Streams)
{
var output = new DiscordEmbedBuilder()
.WithTitle(streamer.Channel.DisplayName)
.WithDescription("[LIVE] Now Playing: " + streamer.Channel.Game)
.AddField("Broadcaster", streamer.Channel.BroadcasterType.ToUpperInvariant(), true)
.AddField("Viewers", streamer.Viewers.ToString(), true)
.AddField("Followers", streamer.Channel.Followers.ToString(), true)
.AddField("Status", streamer.Channel.Status)
.WithThumbnail(streamer.Channel.Logo)
.WithImageUrl(streamer.Preview.Large)
.WithUrl(streamer.Channel.Url)
.WithFooter(!streamer.Id.Equals(results.Streams.Last().Id)
? "Type 'next' within 10 seconds for the next streamer."
: "This is the last found streamer on the list.")
.WithColor(new DiscordColor("#6441A5"));
var message = await ctx.RespondAsync(output.Build()).ConfigureAwait(false);
if (results.Total == 1)
{
continue;
}
var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false);
if (interactivity.Result is null)
{
break;
}
await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false);
if (!streamer.Id.Equals(results.Streams.Last().Id))
{
await BotServices.RemoveMessage(message).ConfigureAwait(false);
}
}
}
public async Task StopSubscription()
{
Logger.LogInformation($"{DateTime.UtcNow}: Stopping Subscription");
var channels = Config.GetSection(Constants.CONFIG_TWITCH_CHANNELS).Get <List <string> >();
await TwitchService.UnsubscribeFromChannelEvents(channels);
Logger.LogInformation($"{DateTime.UtcNow}: Stopped Subscription");
}
public void Perform(TwitchClient client, TwitchService service, ChatCommand chatCommand, Command command)
{
if (!command.IsActive)
{
return;
}
client.SendMessage(chatCommand.ChatMessage.Channel, "Tier 1 emote: kungraHEY Tier 2 emote: kungraDERP Tier 3 emote: kungraTHRONE");
}
public MainWindowViewModel(TwitchService twitchService,
ChatViewModel chatViewModel,
CommandsViewModel commandsViewModel)
{
ChatViewModel = chatViewModel;
CommandsViewModel = commandsViewModel;
_twitchService = twitchService;
_twitchService.Start();
}
protected override async Task OnInitializedAsync()
{
var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
if (authState.User.Identity.IsAuthenticated)
{
await TwitchService.LoadChannelData();
}
}
private async Task StopSubscription(string channel = null)
{
Logger.LogFormattedMessage("Stopping Subscription");
var channels = string.IsNullOrEmpty(channel) ? TwitchService.TwitchUsers.Select(x => x.LoginName) : new[] { channel };
await TwitchService.UpdateFollowerSubscription(channels, SubscriptionStatus.Unsubscribed);
await TwitchService.UpdateStreamChangeSubscription(channels, SubscriptionStatus.Unsubscribed);
Logger.LogFormattedMessage("Stopped Subscription");
}
public SingleStreamerModule(
ISingleStreamerSettingsRepository singleStreamerSettingsRepository,
IGuildSettingsRepository guildSettingsRepoistory,
TwitchService twitchService
)
{
_singleStreamerSettingsRepository = singleStreamerSettingsRepository;
_guildSettingsRepoistory = guildSettingsRepoistory;
_twitchService = twitchService;
}
public async Task <IReadOnlyList <TwitchStream> > GetTwitchStreamsAsync(int take)
{
var random = new Random();
return(await Task.Run(() => TwitchService
.GetTwitchStreams()
.OrderBy(x => random.Next())
.Take(take)
.ToList()));
}
protected override async Task OnInitializedAsync()
{
var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
if (authState.User.Identity.IsAuthenticated)
{
await TwitchService.LoadChannelData(Config.GetSection(Constants.CONFIG_TWITCH_CHANNELS).Get <List <string> >());
await TwitchService.GetCurrentSubscriptions();
}
}
public void Awake()
{
ChatCoreInstance chatCore = ChatCoreInstance.Create();
twitchService = chatCore.RunTwitchServices();
twitchService.OnTextMessageReceived += OnMessage;
DontDestroyOnLoad(this);
enabled = false;
}
public TwitchTeamModule(
ITwitchTeamMemberRepository twitchTeamMemberRepository,
ITwitchTeamSettingsRepository twitchTeamSettingsRepository,
IGuildSettingsRepository guildSettingsRepoistory,
TwitchService twitchService
)
{
_twitchTeamMemberRepository = twitchTeamMemberRepository;
_twitchTeamSettingsRepository = twitchTeamSettingsRepository;
_guildSettingsRepoistory = guildSettingsRepoistory;
_twitchService = twitchService;
}
public CallbackController(
ILogger <CallbackController> logger,
TwitchService service,
StringCipher cypher,
IEnumerable <BotDiscordSocketClient> botDiscordSocketClients,
IOwnerTwitchCredentialRepository ownerTwitchCredentialRespository)
{
_logger = logger;
_service = service;
_cypher = cypher;
_botDiscordSocketClients = botDiscordSocketClients;
_ownerTwitchCredentialRespository = ownerTwitchCredentialRespository;
}
public Form1()
{
InitializeComponent();
var streamCore = ChatCoreInstance.Create();
streamingService = streamCore.RunAllServices();
twitchService = streamingService.GetTwitchService();
streamingService.OnLogin += StreamingService_OnLogin;
streamingService.OnTextMessageReceived += StreamServiceProvider_OnMessageReceived;
streamingService.OnJoinChannel += StreamServiceProvider_OnChannelJoined;
streamingService.OnLeaveChannel += StreamServiceProvider_OnLeaveChannel;
streamingService.OnRoomStateUpdated += StreamServiceProvider_OnChannelStateUpdated;
//Console.WriteLine($"StreamService is of type {streamServiceProvider.ServiceType.Name}");
}
public ChatViewModel(TwitchService twitchService,
TwitchSettings twitchSettings,
IPhoneticMatch phonetic,
ToolContext context,
OverrustlelogsService overrustlelogsService)
{
Messages = new ObservableCollection <TwitchMessage>();
_twitchService = twitchService;
TwitchSettings = twitchSettings;
_phonetic = phonetic;
_context = context;
_overrustlelogsService = overrustlelogsService;
_twitchService.Client.OnMessageReceived += Client_OnMessageReceived;
_whitelistedWords = _context.WhitelistWords.ToList();
_whitelistedUsers = _context.WhitelistUsers.ToList();
}
