private void AddKnownUser(StreamUserModel newUser)
{
if (!_knownUsers.Any(a => a.Id.Equals(newUser.Id, StringComparison.InvariantCultureIgnoreCase)))
{
_knownUsers.Add(newUser);
}
}
public async Task <IActionResult> NewFollower()
{
StreamUserModel newFollower = new StreamUserModel("123", "WilliamGates", "https://specials-images.forbesimg.com/imageserve/5c76b4b84bbe6f24ad99c370/416x416.jpg?background=000000&cropX1=0&cropX2=4000&cropY1=0&cropY2=4000");
await _hubContext.Clients.All.SendAsync("ReceiveNewFollower", newFollower);
return(RedirectToAction("test"));
}
private async Task DoWorkAsync(object state, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
_timer?.Change(Timeout.Infinite, Timeout.Infinite);
return;
}
// Check follower count & publish to SignalR hub
long followerCount = await _streamAnalytics.GetFollowerCountAsync();
if (followerCount != _followerCount)
{
_followerCount = followerCount;
await _overlayHubContext.Clients.All.SendAsync("ReceiveFollowerCount", _followerCount);
}
// Check viewer count & publish to SignalR hub
int viewerCount = await _streamAnalytics.GetViewerCountAsync();
if (viewerCount != _viewerCount)
{
_viewerCount = viewerCount;
await _overlayHubContext.Clients.All.SendAsync("ReceiveViewerCount", _viewerCount);
}
StreamUserModel lastFollower = await _streamAnalytics.GetLastFollowerAsync();
if (lastFollower != _lastFollower)
{
_lastFollower = lastFollower;
await _overlayHubContext.Clients.All.SendAsync("ReceiveNewFollower", _lastFollower);
}
}
private async Task Client_OnUserJoined(object sender, OnUserJoinedArgs e)
{
if (!_knownUsers.Any(c => c.DisplayName.Equals(e.Username, StringComparison.InvariantCultureIgnoreCase)))
{
StreamUserModel newChatter = await _streamAnalytics.GetUserByUsernameAsync(e.Username);
AddKnownUser(newChatter);
}
}
private async Task OnFollow(object sender, OnFollowArgs e)
{
StreamUserModel newFollower = _knownUsers.FirstOrDefault(f => f.Id.Equals(e.UserId, StringComparison.InvariantCultureIgnoreCase));
if (newFollower == null)
{
newFollower = await _streamAnalytics.GetUserAsync(e.UserId);
AddKnownUser(newFollower);
}
await BroadcastNewFollower(newFollower);
}
private async Task Client_OnMessageReceivedAsync(object sender, OnMessageReceivedArgs e)
{
IEnumerable <IChatService> chatServices = _serviceProvider.GetServices <IChatService>();
string botResponse = string.Empty;
foreach (IChatService chatService in chatServices)
{
botResponse = await chatService.ProcessMessageAsync(e.ChatMessage);
if (!string.IsNullOrEmpty(botResponse))
{
break;
}
}
StreamUserModel chatUser = _knownUsers.FirstOrDefault(f => f.Id.Equals(e.ChatMessage.UserId, StringComparison.CurrentCultureIgnoreCase));
if (chatUser == null)
{
chatUser = await _streamAnalytics.GetUserAsync(e.ChatMessage.UserId);
AddKnownUser(chatUser);
}
ChatHubMessage chatHubMessage = ChatHubMessage.FromChatMessage(e.ChatMessage, chatUser);
if (!string.IsNullOrEmpty(chatHubMessage.HubMessage.Trim()))
{
await BroadcastChatMessage(chatHubMessage);
if (!string.IsNullOrEmpty(botResponse))
{
ChatHubMessage botChatHubMessage = ChatHubMessage.FromBot(botResponse);
await BroadcastChatMessage(botChatHubMessage);
}
EmoteSet emoteSet = e.ChatMessage.EmoteSet;
if (emoteSet != null && emoteSet.Emotes.Count > 0)
{
List <EmoteSet.Emote> emotes = emoteSet.Emotes;
foreach (EmoteSet.Emote emote in emotes)
{
await BroadcastEmote(emote.ImageUrl);
await Task.Delay(new Random().Next(500, 1200));
}
}
}
}
private async void Client_OnNewSubscriber(object sender, OnNewSubscriberArgs e)
{
if (e.Subscriber.SubscriptionPlan == SubscriptionPlan.Prime)
{
twitchClient.SendMessage(e.Channel, $"{e.Subscriber.DisplayName}, thanks for your Prime subscription!");
}
else
{
twitchClient.SendMessage(e.Channel, $"{e.Subscriber.DisplayName}, thanks so much for the sub!");
}
StreamUserModel lastSubscriber = await _streamAnalytics.GetLastSubscriberAsync();
await _overlayHubContext.Clients.All.SendAsync("ReceiveNewSubscription", lastSubscriber);
}
private async Task PollAsync(object state, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
_timer?.Change(Timeout.Infinite, Timeout.Infinite);
return;
}
try
{
// Check follower count & publish to SignalR hub
long followerCount = await _streamAnalytics.GetFollowerCountAsync();
await BroadcastNewFollowerCount(followerCount);
// Check viewer count & publish to SignalR hub
int viewerCount = await _streamAnalytics.GetViewerCountAsync();
await BroadcastNewViewerCount(viewerCount);
// Check for last follower and publish to SignalR hub
string lastFollowerId = await _streamAnalytics.GetLastFollowerAsync();
StreamUserModel _lastFollower = _knownUsers.FirstOrDefault(f => f.Id.Equals(lastFollowerId, StringComparison.InvariantCultureIgnoreCase));
if (_lastFollower == null)
{
_lastFollower = await _streamAnalytics.GetUserAsync(lastFollowerId);
AddKnownUser(_lastFollower);
}
await BroadcastLastFollower(_lastFollower);
// Check for last subscriber and publish to SignalR hub
StreamUserModel lastSubscriber = await _streamAnalytics.GetLastSubscriberAsync();
if (!_knownUsers.Any(f => f.Id.Equals(lastSubscriber.Id, StringComparison.InvariantCultureIgnoreCase)))
{
AddKnownUser(lastSubscriber);
}
await BroadcastLastSubscriber(lastSubscriber);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task <StreamUserModel> GetLastFollowerAsync()
{
var followers = await _twitchAPI.Helix.Users.GetUsersFollowsAsync(toId : Constants.TwitchChannelId, first : 1);
if (followers != null &&
followers.Follows.Count() > 0)
{
var lastFollower = followers.Follows.First();
if (_lastFollowerId != lastFollower.FromUserId)
{
_lastFollowerId = lastFollower.FromUserId;
User userObj = await GetUserAsync(_lastFollowerId);
_lastFollower = new StreamUserModel(userObj.DisplayName, userObj.ProfileImageUrl);
}
return(_lastFollower);
}
return(null);
}
public async Task BroadcastNewFollower(StreamUserModel newFollower)
{
await _alertHubConnection.InvokeAsync("BroadcastNewFollower", newFollower);
}
/// <summary>
/// Broadcasts the last subscriber to listening clients
/// </summary>
/// <param name="lastSubscriber">Last subscriber to the stream</param>
private async Task BroadcastLastSubscriber(StreamUserModel lastSubscriber)
{
await _overlayHubConnection.InvokeAsync("BroadcastLastSubscriber", lastSubscriber);
}
public async Task BroadcastNewFollower(StreamUserModel newFollower)
{
await Clients.All.ReceiveNewFollower(newFollower);
}
private async Task UpdateLastSubscriberAsync()
{
_lastSubscriber = await _streamAnalytics.GetLastSubscriberAsync();
}
private async Task UpdateLastFollowerAsync()
{
_lastFollower = await _streamAnalytics.GetLastFollowerAsync();
}
/// <summary>
/// Broadcasts the last subscriber to listening clients
/// </summary>
/// <param name="lastSubscriber">Last subscriber to the stream</param>
public async Task BroadcastLastSubscriber(StreamUserModel lastSubscriber)
{
await Clients.All.ReceiveLastSubscriber(lastSubscriber);
}
