public static async Task Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e, DiscordClient client, TwitchAPI API)
{
try
{
var gameResp = await API.Helix.Games.GetGamesAsync(new List <string> {
e.Stream.GameId
});
var userResp = await API.V5.Users.GetUserByIDAsync(e.Stream.UserId);
var gameName = gameResp.Games[0].Name;
var userName = userResp.Name;
DiscordEmbedBuilder builder = new DiscordEmbedBuilder()
{
Title = userName + " élőben közvetíti: " + gameName + "!",
Color = DiscordColor.Azure,
Description = e.Stream.Title,
ImageUrl = userResp.Logo,
Url = new Uri(@"https://www.twitch.tv/" + userName).ToString()
};
await client.SendMessageAsync(client.Guilds.FirstOrDefault().Value.Channels.Where(x => x.Name == "general").FirstOrDefault(), null, false,
builder.Build());
}
catch (Exception ex) { logger.Error("Kivétel! --> " + ex.Message); }
}
private async Task LiveStreamMonitor_OnStreamOnline(OnStreamOnlineArgs e)
{
if (e.Stream.StartedAt.ToUniversalTime() < Program.Started)
{
return;
}
string msg = $"{e.Channel} just went live!\n=================================\n{e.Stream.Title}\nhttps://twitch.tv/{e.Channel}";
var guild = DiscordClient.GetGuild(Configuration.StreamNotifierSettings.NotificationGuild);
if (guild == null)
{
Log.Info($"Can't find guild {Configuration.StreamNotifierSettings.NotificationGuild}");
return;
}
var channel = guild.GetTextChannel(Configuration.StreamNotifierSettings.NotificationChannel);
if (channel == null)
{
Log.Info($"Can't find channel {Configuration.StreamNotifierSettings.NotificationChannel}");
return;
}
await channel.SendMessageAsync(msg);
}
private string ParseMessage(string Message, OnStreamOnlineArgs args)
{
var replacements = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase)
{
{ "{userName}", args.Stream.UserName },
{ "{channel}", args.Channel },
{ "{url}", $"https://twitch.tv/{args.Channel}" },
{ "{game}", GetGame(args.Stream.GameId).Name },
{ "{gameBoxArtUrl}", GetGame(args.Stream.GameId).BoxArtUrl },
{ "{streamLanguage}", args.Stream.Language },
{ "{streamType}", args.Stream.Type },
{ "{title}", args.Stream.Title },
{ "{viewerCount}", args.Stream.ViewerCount.ToString() },
{ "{startTime}", args.Stream.StartedAt.ToString() }
};
return(Regex.Replace(
Message,
String.Join(
"|",
replacements
.Keys
.Select(k => k.ToString())
.ToArray()),
m => replacements[m.Value],
RegexOptions.IgnoreCase));
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
using (var scope = _serviceProvider.CreateScope())
{
var botService = scope.ServiceProvider.GetRequiredService <IBotService>();
botService.SendTwitchNotification(e.Channel, TwitchNotificationType.StreamUp);
Console.WriteLine($"[{e.Stream.StartedAt}] Channel {e.Channel} is now live");
}
}
private async void OnStreamOnlineEventAsync(object sender, OnStreamOnlineArgs e)
{
if (StreamsOnline.Contains(e.Stream.UserId))
{
return;
}
var gameTemp = new List <string>
{
e.Stream.GameId
};
GetGamesResponse getGamesResponse = new GetGamesResponse();
try
{
getGamesResponse = await TwApi.Helix.Games.GetGamesAsync(gameTemp);
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync($"{ex.GetType().Name}: Error at GetGamesResponse. Aborting process. - {ex.Message}");
return;
}
try
{
UpdateLiveStreamModelsAsync(e.Stream, getGamesResponse);
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync($"{ex.GetType().Name}: Error at UpdateLiveStreamModelsAsync. Aborting process. - {ex.Message}");
return;
}
EmbedBuilder eb = CreateStreamerEmbed(StreamModels[e.Stream.UserId]);
foreach (var x in StreamNotifChannels)
{
await x.SendMessageAsync(null, false, eb.Build());
}
StreamsOnline.Add(e.Stream.UserId);
if (StreamsOnline.Contains(e.Stream.UserId))
{
await Console.Out.WriteLineAsync($"Successfully add {e.Stream.UserName} to the StreamsOnline list.");
}
else
{
await Console.Out.WriteLineAsync($"Failed to add {e.Stream.UserName} to the StreamsOnline list.");
}
}
//Monitor Events
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
SetUpNewDataCollection();
followersFirstTime = true;
streamTrackingStopwatch.Reset();
streamTrackingStopwatch.Start();
ViewCountTimer(true);
StreamDataIntervalTimer(true);
totalViewers = e.Stream.ViewerCount;
oldViewCount = totalViewers;
Console.WriteLine("Stream is online with " + e.Stream.ViewerCount + " viewers");
}
public async void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
var streamLink = $"https://www.twitch.tv/{e.Stream.UserName}";
var twitchUserInfo = await GetTwitchUserInfoFromUsername(e.Stream.UserName);
var records = await GetTwitchMonitorRecord(twitchUserInfo.data[0].id);
var profileImageLink = twitchUserInfo.data[0].profile_image_url;
EmbedAuthorBuilder twitchStreamer = new EmbedAuthorBuilder
{
Name = $"{e.Stream.UserName}",
IconUrl = profileImageLink
};
EmbedFieldBuilder gameField = new EmbedFieldBuilder
{
Name = "Game",
Value = await GetGameFromApi(e.Stream.GameId),
IsInline = true
};
EmbedFieldBuilder viewerCountField = new EmbedFieldBuilder
{
Name = "Viewers",
Value = e.Stream.ViewerCount,
IsInline = true
};
EmbedBuilder twitchAnnouncement = new EmbedBuilder
{
Title = e.Stream.Title,
ImageUrl = $"https://static-cdn.jtvnw.net/previews-ttv/live_user_{e.Stream.UserName.ToLower()}-1920x1080.jpg",
ThumbnailUrl = profileImageLink,
Author = twitchStreamer,
Fields = new List <EmbedFieldBuilder>()
{
gameField, viewerCountField
},
Url = streamLink
};
foreach (var record in records)
{
var channelToAnnounce = client.GetChannel(ulong.Parse(record.channelId)) as SocketTextChannel;
var announcementMessage = record.streamAnnouncementMessage.Replace("[streamer]", e.Stream.UserName).Replace("[streamlink]", $"https://www.twitch.tv/{e.Stream.UserName}");
await channelToAnnounce.SendMessageAsync(announcementMessage, false, twitchAnnouncement.Build());
}
}
public async void OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
var subs = WebCalls.GetRootObject();
List <string> gameIds = new List <string> {
e.Stream.GameId
};
var games = await TwitchApi.Helix.Games.GetGamesAsync(gameIds);
var channel = await TwitchApi.V5.Channels.GetChannelByIDAsync("109598326");
Console.WriteLine(e.Stream.ThumbnailUrl);
var embed = new DiscordEmbedBuilder
{
Author = new DiscordEmbedBuilder.EmbedAuthor
{
Name = channel.DisplayName,
IconUrl = channel.Logo
},
Color = DiscordColor.Purple,
Title = e.Channel + " is now live! :D",
Url = "https://www.twitch.tv/phenomalytv",
ImageUrl = "https://static-cdn.jtvnw.net/previews-ttv/live_user_phenomalytv-320x180.jpg",
ThumbnailUrl = channel.Logo,
};
embed.AddField("Stream Title: ", e.Stream.Title);
embed.AddField("Viewers: ", e.Stream.ViewerCount.ToString(), true);
embed.AddField("Subscriptions: ", (subs.data.Count - 1).ToString(), true);
embed.AddField("Game: ", games.Games[0].Name, true);
embed.AddField("Time started [GMT]: ", e.Stream.StartedAt.ToShortTimeString(), true);
embed.AddField("Followers: ", channel.Followers.ToString(), true);
embed.AddField("Rated Mature?: ", channel.Mature.ToString(), true);
embed.AddField("Language: ", e.Stream.Language, true);
var chan = await TwitchBotMain.discord.GetChannelAsync(552255972060692504);
await chan.SendMessageAsync("Supppp " + "@everyone" + ", " + channel.DisplayName + " is now live! Come and watch here: <https://www.twitch.tv/phenomalytv> :)!!");
await chan.SendMessageAsync("\n", embed : embed);
}
private void OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
try
{
_logger.LogInformation("Streamer is online");
if (_client.IsConnected && _client.JoinedChannels.Any())
{
_client.SendMessage(e.Channel,
$"Looks like @{e.Channel} has come online, better get to work!");
}
else
{
if (!_client.IsConnected)
{
_client.Connect();
}
if (!_client.JoinedChannels.Any())
{
_client.JoinChannel(e.Channel);
}
_client.SendMessage(e.Channel,
$"What?? @{e.Channel} is live?!? POWERING UP!");
}
_streamStatusApiClient.SaveStreamStatus(new PutStreamStatusRequest
{
BroadcasterUsername = e.Channel.ToLower(),
IsOnline = true
}).Wait();
ScheduleStreamTasks(e.Stream.Title);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error OnStreamOnline");
}
}
private Task LiveStreamMonitorServiceOnOnStreamOnline(object?sender, OnStreamOnlineArgs e)
{
Console.WriteLine($"Stream Online: {e.Channel}");
// Call process channel runningdirectory
var processStartInfo = new ProcessStartInfo
{
FileName = _processFileName,
Arguments = $"{e.Channel} {_config["Values:BotAssembly:Directory"]}"
};
var process = new Process {
StartInfo = processStartInfo
};
if (!process.Start())
{
throw new ApplicationException($"Process {process.ProcessName} unable to start");
}
_botProcessDictionary.Add(e.Channel, process.Id);
return(Task.CompletedTask);
}
private static async void OnStreamOnline(object sender, OnStreamOnlineArgs streamOnline)
{
HostingMonitor.StopMonitor();
if (DatabaseManager.ActiveStreams.Insert(SettingsManager.Configuration.TwitchStream.Username))
{
await Task.Delay(8000);
IsLive = true;
_ = Discord.DiscordClient.SetStatus($"Watching {SettingsManager.Configuration.TwitchStream.DisplayName}!", SettingsManager.Configuration.TwitchStream.Url);
_ = Discord.DiscordClient.TwitchChannelChange(SettingsManager.Configuration.TwitchStream.DiscordChannel, SettingsManager.Configuration.TwitchStream.Url, streamOnline.Stream.ThumbnailUrl, $"{SettingsManager.Configuration.TwitchStream.DisplayName} is live!", streamOnline.Stream.Title, true, true);
LoggingManager.Log.Info($"{SettingsManager.Configuration.TwitchStream.DisplayName} just went live");
}
else
{
_ = Discord.DiscordClient.SetStatus($"Watching {SettingsManager.Configuration.TwitchStream.DisplayName}!", SettingsManager.Configuration.TwitchStream.Url);
LoggingManager.Log.Info($"{SettingsManager.Configuration.TwitchStream.DisplayName} is still live");
}
}
private async void Monitor_OnStreamOnlineAsync(object sender, OnStreamOnlineArgs e)
{
try
{
var ee = await API.V5.Streams.GetStreamByUserAsync(e.Channel);
if (!_liveEmbeds.ContainsKey(ee.Stream.Channel.Id) && _client.ConnectionState == ConnectionState.Connected)
{
string url = @"https://www.twitch.tv/" + ee.Stream.Channel.Name;
EmbedBuilder eb = SetupLiveEmbed($":link: {ee.Stream.Channel.DisplayName}", ee.Stream.Channel.Status, ee.Stream.Channel.Game,
ee.Stream.Preview.Medium + Guid.NewGuid(), ee.Stream.Channel.Logo, url, ee.Stream.Viewers);
Console.WriteLine($"{Globals.CurrentTime} Monitor {ee.Stream.Channel.DisplayName} is live playing {ee.Stream.Game}");
await Task.Delay(1000);
await SetupEmbedMessageAsync(eb, ee, null);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
Log.Write($"{e.Channel} is now live with the title {e.Stream.Title}");
}
private static void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs args)
{
Task.Run(async() =>
{
// TODO: Use the 'Date' field in the link database to determine whether we should post it.
var links = Links.Values.Where(e => string.Equals(e.Value.Split("|", StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(), args.Channel, StringComparison.CurrentCultureIgnoreCase));
foreach (var link in links)
{
try
{
var linkValues = link.Value.Split("|", StringSplitOptions.RemoveEmptyEntries);
var streamName = linkValues.FirstOrDefault();
long linkStreamId = -1;
var linkDateCreated = DateTime.MinValue;
var linkDateUpdated = DateTime.MinValue;
ulong discordMessageId = 0;
if (linkValues.Length > 1)
{
long.TryParse(linkValues[1], out linkStreamId);
}
if (linkValues.Length > 2)
{
if (long.TryParse(linkValues[2], out long ticks))
{
linkDateCreated = new DateTime(ticks, DateTimeKind.Utc);
}
}
if (linkValues.Length > 3)
{
if (long.TryParse(linkValues[3], out long ticks))
{
linkDateUpdated = new DateTime(ticks, DateTimeKind.Utc);
}
}
if (linkValues.Length > 4)
{
ulong.TryParse(linkValues[4], out discordMessageId);
}
// Attempt to retrieve the V5 stream data for more detailed info.
TwitchLib.Api.V5.Models.Streams.Stream stream = null;
try
{
stream = (await Ditto.Twitch.V5.Streams.GetStreamByUserAsync(args.Stream.UserId, args.Stream.Type).ConfigureAwait(false))?.Stream;
}
catch { }
if (stream != null)
{
if (discordMessageId == 0 || (stream.Id != linkStreamId && stream.CreatedAt > linkDateCreated))
{
linkStreamId = stream.Id;
linkDateCreated = stream.CreatedAt;
linkDateUpdated = DateTime.UtcNow;
Log.Debug($"Twitch | {stream?.Channel?.Name} went live (Id: {stream?.Id} at {stream?.CreatedAt.ToLongTimeString()}).");
var embedBuilder = GetTwitchEmbedMessage(args.Stream, stream, link);
if (link.Channel != null)
{
var message = await link.Channel.EmbedAsync(embedBuilder,
options: new RequestOptions()
{
RetryMode = RetryMode.RetryRatelimit | RetryMode.RetryTimeouts
}
).ConfigureAwait(false);
discordMessageId = message?.Id ?? 0;
}
else
{
Log.Debug($"Twitch | Link #{link.Id} doesn't have a channel, clean-up database?");
}
}
else
{
var discordMessage = (await link.Channel.GetMessageAsync(discordMessageId,
CacheMode.AllowDownload,
new RequestOptions()
{
RetryMode = RetryMode.AlwaysRetry
}
).ConfigureAwait(false)) as IUserMessage;
if (discordMessage?.Author?.IsBot == true)
{
var embedBuilder = GetTwitchEmbedMessage(args.Stream, stream, link);
await discordMessage.ModifyAsync(x => x.Embed = embedBuilder.Build(), new RequestOptions()
{
RetryMode = RetryMode.AlwaysRetry
}).ConfigureAwait(false);
discordMessageId = discordMessage.Id;
linkDateCreated = stream.CreatedAt;
linkDateUpdated = DateTime.UtcNow;
}
else
{
discordMessageId = 0;
linkDateCreated = DateTime.MinValue;
linkDateUpdated = DateTime.MinValue;
}
}
// Update link
link.Value = $"{streamName}|{stream.Id}|{linkDateCreated.ToUniversalTime().Ticks}|{linkDateUpdated.Ticks}|{discordMessageId}";
await Ditto.Database.DoAsync((uow) =>
{
uow.Links.Update(link);
}).ConfigureAwait(false);
}
}
catch { }
}
});
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
Console.WriteLine($">> Stream {e.Stream.Id} has gone online");
}
// TODO: Use TweetHelper to tweet about the stream
public static void OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
Console.WriteLine("Got online notification!");
Console.WriteLine("Channel: " + e.Channel);
}
private void OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
IsLive = true;
ConsoleHelper.WriteLine($"ONLINE: {e.Channel} has gone live!");
}
// When stream is online, pass the appropriate parameters to TweetHelper
public async void OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
await _tweetHelper.HandleCooldown(e.Stream.UserName, e.Stream.Title);
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
throw new NotImplementedException();
}
private void onStreamStarts(object sender, OnStreamOnlineArgs e)
{
listaUsuariosxStream = new List <TUserJoined>();
}
private void OnStreamOnline(object sender, OnStreamOnlineArgs args)
{
this.OnStreamOnlineOrUpdate(args.Channel, args.Stream);
}
private void onStreamOnline(object sender, OnStreamOnlineArgs e)
{
MessageBox.Show($"Stream up! Stream: {e.Channel}");
}
//private void Follower_OnNewFollow(object sender, OnNewFollowersDetectedArgs e)
//{
// e.NewFollowers.ForEach(async(follower) => {
// Console.WriteLine($"New follower: {follower.FromUserName}");
// await _connection.InvokeAsync("PlaySoundMessage", follower.FromUserName, "follow");
// });
//}
//private void Follower_OnServiceStarted(object sender, OnServiceStartedArgs e)
//{
// Console.WriteLine("OnFollowerService Started");
//}
//private void Follower_OnChannelsSet(object sender, OnChannelsSetArgs e)
//{
// Console.WriteLine("Follower OnChannelSet from Api");
//}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
Console.WriteLine("Stream online from Api");
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs e)
{
}
private void Monitor_OnStreamOnline(object sender, OnStreamOnlineArgs args)
{
if (_config.Value.SkipActiveStreamsOnStartup && DateTime.Now < _startNotificationTime)
{
_logger.LogInformation($"Skipping Active Stream {args.Channel}");
return;
}
_logger.LogInformation($"channel: {args.Channel}");
var message = _config.Value.TwitchChannels
.Where(
a => a.Channel.Equals(args.Channel, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault()
.Message;
var user = _twitchApi.Helix.Users
.GetUsersAsync(logins: new List <string>()
{
args.Channel
})
.GetAwaiter()
.GetResult()
.Users
.FirstOrDefault();
var webhookMessage = new WebhookMessage();
try
{
webhookMessage.Content = ParseMessage(message, args);
_logger.LogInformation($"Message: {webhookMessage.Content}");
}
catch (System.Exception e)
{
_logger.LogCritical(e, $"Unable to parse message: {e.Message}");
return;
}
string tags = string.Empty;
List <string> tagsList = new List <string>();
try
{
var tagsResult = _twitchApi.Helix.Streams
.GetStreamTagsAsync(args.Stream.UserId)
.GetAwaiter()
.GetResult()
.Data;
foreach (var tag in tagsResult)
{
string localizedTag;
if (tag.LocalizationNames.TryGetValue("en-us", out localizedTag))
{
tagsList.Add(localizedTag);
}
}
tags = string.Join(", ", tagsList);
}
catch (System.Exception e)
{
_logger.LogCritical(e, $"Unable to retrieve tags: {e.Message}");
}
webhookMessage.Embeds = new List <IMessageEmbed>()
{
new MessageEmbed()
{
Author = new MessageEmbedAuthor()
{
Name = args.Stream.UserName,
IconUrl = user.ProfileImageUrl,
Url = $"https://twitch.tv/{args.Channel}"
},
// Hex 9B59B6 "Dark Purple"
Color = 10181046,
Title = args.Stream.Title,
Url = $"https://twitch.tv/{args.Channel}",
Type = MessageEmbedType.rich,
Thumbnail = new MessageEmbedImage()
{
Url = user.ProfileImageUrl,
Height = 300,
Width = 300
},
Image = new MessageEmbedImage()
{
Url = args.Stream.ThumbnailUrl.Replace("{width}", "320").Replace("{height}", "180") + "?" + DateTime.UtcNow.ToFileTimeUtc().ToString(),
Height = 180,
Width = 320
},
Fields = new List <IMessageEmbedField>()
{
new MessageEmbedField()
{
IsInline = true,
Name = "Game",
Value = GetGame(args.Stream.GameId).Name
},
new MessageEmbedField()
{
IsInline = true,
Name = "Viewers",
Value = args.Stream.ViewerCount.ToString()
},
new MessageEmbedField()
{
IsInline = true,
Name = "Tags",
Value = tags
}
},
Timestamp = DateTime.UtcNow
}
};
_webhookService.SendMessageAsync(webhookMessage).GetAwaiter().GetResult();
}
