private async Task <bool> SetStreamsOnline(List <string> OnlineStreamIDs, GetStreamsResponse StreamsData)
{
using (var scope = _scopeFactory.CreateScope())
{
var _context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
var Streams = _context.StreamModels.Where(s => OnlineStreamIDs.Contains(s.UserID) && s.Type == StreamProviderTypes.Twitch).Include(x => x.StreamSubscriptions).ThenInclude(y => y.User);
Boolean write = false;
foreach (Data.DBModels.StreamModels.Stream stream in Streams)
{
TwitchLib.Api.Helix.Models.Streams.Stream streamdata = StreamsData.Streams.Single(sd => sd.UserId == stream.UserID);
if (stream.StreamState == StreamState.NotRunning)
{
stream.StreamState = StreamState.Running;
stream.Started = streamdata.StartedAt.ToLocalTime();
write = true;
if (stream.DiscordRelayChannel == "An")
{
stream.DiscordRelayChannel = getRandomRelayChannel();
}
NotifyUsers(stream, streamdata);
}
}
if (write)
{
_context.SaveChanges();
}
}
return(true);
}
public static async Task <Stream> TryGetStreamAsync(this ArisaTwitchClient arisaTwitchClient)
{
GetStreamsResponse streamsResponse =
await arisaTwitchClient.StreamsApi.GetStreamsAsync(first : 1, userIds : arisaTwitchClient.ChannelUser.Id.AsList());
if (streamsResponse.Streams.Length == 1)
{
return(streamsResponse.Streams[0]);
}
#if DEBUG
return(JsonConvert.DeserializeObject <Stream>(@"
{
""id"": ""321321321"",
""user_id"": ""123123123"",
""user_name"": ""MOCKUSER"",
""game_id"": ""12345"",
""type"": ""live"",
""title"": ""MOCK TITLE"",
""viewer_count"": 9001,
""started_at"": ""2019-03-22T16:00:00Z"",
""language"": ""en""
}
"));
#else
return(null);
#endif
}
public async Task CheckOnlineStreams()
{
try
{
if (!_inProgress)
{
_inProgress = true;
await FillClientIDs();
GetStreamsResponse StreamsData = await GetStreamData();
List <string> OnlineStreamIDs = StreamsData.Streams.Select(x => x.UserId).ToList();
await SetStreamsOffline(OnlineStreamIDs);
if (StreamsData.Streams.Count() > 0)
{
await SetStreamsOnline(OnlineStreamIDs, StreamsData);
}
_inProgress = false;
}
}
catch (Exception ex)
{
_inProgress = false;
}
return;
}
//public async Task ConfigLiveMonitorAsync(string [] channelsToMonitor)
//{
// Monitor.OnChannelsSet += (sender, e) => TwitchHelper.Monitor_OnChannelsSet(sender, e);
// //EITHER
// //var users = await API.V5.Users.GetUserByNameAsync("stanleyhun15");
// //var userId = users.Matches[0].Id;
// //List<string> lst = new List<string> { userId };
// //OR
// List<string> TwitchChannelIDs = new List<string>();
// var channelsToMonitorList = channelsToMonitor.ToList();
// if (channelsToMonitor != null && channelsToMonitorList.Count >= 1)
// {
// var tasks = new List<Task<string>>();
// //This is some next level async shit
// channelsToMonitorList.ForEach((x) => tasks.Add(GetTwitchIDAsync(API, x)));
// var results = await Task.WhenAll(tasks);
// foreach (string userId in results)
// {
// if (userId != null && !string.IsNullOrEmpty(userId))
// {
// TwitchChannelIDs.Add(userId);
// }
// }
// }
// //úgyse lesz benne semmi ha valami nem jó
// if (TwitchChannelIDs.Count >= 1)
// {
// Monitor.SetChannelsById(TwitchChannelIDs);
// }
// //Monitor.OnStreamOnline += async (sender, e) => await DiscordEventHandler.Monitor_OnStreamOnline(sender, e, client, API);
// //Monitor.OnStreamOffline += Monitor_OnStreamOffline;
// //Monitor.OnStreamUpdate += Monitor_OnStreamUpdate;
// Monitor.Start(); //Keep at the end!
//}
public async Task <GetStreamOnlineResponse> GetStreamOnline(string channel)
{
GetStreamsResponse getStreamResponse = new GetStreamsResponse();
try
{
getStreamResponse = await RetrieveTwitchChannelInfoAsync(channel);
}
catch (Exception) { return(new GetStreamOnlineResponse()
{
Online = false, ViewerCount = 0, TimeLapsedString = string.Empty
}); }
if (getStreamResponse.Streams != null && getStreamResponse.Streams.Count() > 0)
{
return(new GetStreamOnlineResponse()
{
Online = true,
TimeLapsedString = TwitchHelper.GetTimeLapsedFormattedString(getStreamResponse.Streams[0].StartedAt),
ViewerCount = getStreamResponse.Streams[0].ViewerCount
});
}
else
{
return new GetStreamOnlineResponse()
{
Online = false, ViewerCount = 0, TimeLapsedString = string.Empty
}
};
}
public async Task <int> GetViewerCountAsync()
{
var userIds = new List <string> {
_twitchClientSettings.TwitchChannelId
};
GetStreamsResponse streamInfo = await _twitchApi.Helix.Streams.GetStreamsAsync(userIds : userIds);
return(streamInfo.Streams.SingleOrDefault()?.ViewerCount ?? 0);
}
public async Task <TimeSpan?> GetUptimeAsync()
{
if (_streamStartedAt == null || _streamStartedAt < DateTime.UtcNow.AddHours(-1))
{
var userIds = new List <string> {
_twitchClientSettings.TwitchChannelId
};
GetStreamsResponse streamInfo = await _twitchApi.Helix.Streams.GetStreamsAsync(userIds : userIds);
_streamStartedAt = streamInfo.Streams.SingleOrDefault()?.StartedAt;
}
return(DateTime.UtcNow - _streamStartedAt);
}
protected override async Task Execute <T>(ChatMessage <T> message, CommandContext context, Bot bot)
{
GetStreamsResponse response = await TwitchBot.TwitchApi.Helix.Streams.GetStreamsAsync(userIds : new List <string> {
TwitchBot.CurrentChannel.Id
});
if (response.Streams.Length > 0)
{
TimeSpan uptime = DateTime.UtcNow - response.Streams[0].StartedAt;
bot.SendMessage($"@{message.Sender.UserName} Stream has been live for {Helpers.FormatTimeSpan(uptime)}.", context);
}
else
{
bot.SendMessage($"@{message.Sender.UserName} Stream is offline.", context);
}
}
private static List <TwitchLib.Api.Models.Helix.Streams.GetStreams.Stream> getTopChannels()
{
List <TwitchLib.Api.Models.Helix.Streams.GetStreams.Stream> list = new List <TwitchLib.Api.Models.Helix.Streams.GetStreams.Stream>();
bool done = false;
string next = "";
while (!done)
{
GetStreamsResponse resp = FetchChannels(next);
List <TwitchLib.Api.Models.Helix.Streams.GetStreams.Stream> toAdd = resp.Streams.ToList();
list = list.Concat(toAdd).ToList();
done = toAdd.Last().ViewerCount < min_viewers;
next = resp.Pagination.Cursor;
Thread.Sleep(limit);
}
return(list);
}
/// <summary>
/// Gets all the currently live streams of the users we're tracking.
/// </summary>
/// <returns>A list of all the live streams.</returns>
public async Task <Stream[]> GetStreams()
{
if (usersBeingTracked == null || usersBeingTracked.Count() == 0)
{
return(null);
}
try
{
GetStreamsResponse liveStreams = await api.Helix.Streams.GetStreamsAsync(null, null, 100, null, null,
"live", null, usersBeingTracked.ToList());
return(liveStreams.Streams);
}catch (Exception e)
{
Console.WriteLine($"Exception thrown while fetching streams. {e.Message}");
return(null);
}
}
void ITimerService.Process(double time)
{
if (!isconnected)
{
return;
}
followercheck -= time;
if (followercheck <= 0.0)
{
try {
CheckFollowers();
}
catch (Exception e) {
Logger.Error(this, "Unable to check for followers", e);
}
followercheck = 300.0;
}
viewercheck -= time;
if (viewercheck <= 0.0)
{
if (userdata != null)
{
GetStreamsResponse response = twitchapi.GetStreams(userdata.ID);
TwitchStream stream = response.Data.FirstOrDefault();
if (stream == null)
{
Logger.Warning(this, "There was no active stream found.");
viewercheck = 180.0;
return;
}
Viewers = stream.ViewerCount;
viewercheck = 180.0;
}
}
}
public TwitchTracker()
{
Tracking = new List <long>();
Online = new List <long>();
Offline = new List <long>();
try
{
if (File.Exists("Data/TwitchTracking.json"))
{
TwitchLocal obj = SaveManager.LoadSettings <TwitchLocal>("TwitchTracking");
Online.AddRange(obj.Online);
Offline.AddRange(obj.Offline);
}
}
catch { /* Probably some errors with the json file, manual impact or sth ~ better be sure ~ */ }
StreamDatabase = new Dictionary <long, StreamResponse>();
UserDatabase = new Dictionary <long, UserResponse>();
Update = new Timer(Global.Settings.TwitchStreamUpdate);
UserDatabaseUpdater = new Timer(Global.Settings.TwitchUserUpdate);
api = new TwitchAPI();
api.Settings.ClientId = Global.Settings.Credentials.Twitch.ClientId;
api.Settings.Secret = Global.Settings.Credentials.Twitch.ClientSecret;
string token = api.Helix.Streams.GetAccessToken();
api.Settings.AccessToken = token;
Restore();
Update.Elapsed += async(s, a) =>
{
List <StreamResponse> Streams = new List <StreamResponse>();
await ValidateAsync();
for (int i = 0; i < Tracking.Count; i += 100)
{
GetStreamsResponse resp = api.Helix.Streams.GetStreamsAsync(userIds: Tracking.Skip(i).Take(100).Select(t => t.ToString()).ToList()).Result;
Streams.AddRange(resp.Streams.Select(t => new StreamResponse(t)));
}
long[] Ids = Streams.Select(t => t.UserId).ToArray();
for (int i = 0; i < Ids.Length; i++)
{
long UserId = Ids[i];
if (!Online.Contains(UserId))
{
Online.Add(UserId);
Offline.Remove(UserId);
StreamDatabase.Add(UserId, Streams[i]);
OnStreamUp?.Invoke(Streams[i], UserDatabase[UserId]);
}
}
for (int i = 0; i < Online.Count; i++)
{
long UserId = Online[i];
if (!Ids.Contains(UserId))
{
Offline.Add(UserId);
Online.Remove(UserId);
if (StreamDatabase.ContainsKey(UserId))
{
OnStreamDown?.Invoke(StreamDatabase[UserId], UserDatabase[UserId]);
StreamDatabase.Remove(UserId);
}
}
}
SaveManager.SaveData("TwitchTracking", new TwitchLocal()
{
Online = Online,
Offline = Offline
});
};
UserDatabaseUpdater.Elapsed += async(s, a) =>
{
var Keys = UserDatabase.Keys;
await ValidateAsync();
List <UserResponse> Users = new List <UserResponse>();
for (int i = 0; i < Keys.Count; i += 100)
{
GetUsersResponse resp = api.Helix.Users.GetUsersAsync(Keys.Skip(i).Take(100).Select(t => t.ToString()).ToList()).Result;
Users.AddRange(resp.Users.Select(t => new UserResponse(t)));
}
UserDatabase.Clear();
for (int i = 0; i < Users.Count; i++)
{
UserResponse User = Users[i];
UserDatabase.Add(User.Id, User);
}
};
UserDatabaseUpdater.Start();
}
