private static void ChangeStreamIdToVodId(long streamId)
{
long streamerId = 0;
Stream stream;
using (var context = new MainDataContext()) {
stream = context.Streams.FirstOrDefault(item => item.vodId == streamId);
}
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
if (stream != null)
{
var response =
twitchApiHelpers.TwitchRequest(
$"https://api.twitch.tv/helix/videos?user_id={stream.streamerId}&first=1", Method.GET);
var deserializedJson = JsonConvert.DeserializeObject <GetStreamsResult>(response.Content);
if (deserializedJson.data[0] != null)
{
var streamVod = deserializedJson.data[0];
if ((streamVod.created_at - stream.createdAt).TotalSeconds < 20)
{
// if stream was created within 20 seconds of going live. Not very reliable but is the only way I can see how to implement it.
using (var context = new MainDataContext()) {
stream = context.Streams.FirstOrDefault(item => item.vodId == streamId);
stream.streamId = Int64.Parse(streamVod.id);
context.SaveChanges();
}
}
}
}
}
public void Validate()
{
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
twitchApiHelpers.TwitchRequest("https://id.twitch.tv/oauth2/validate", Method.GET);
Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info("Validated authentication.");
}
public string SaveUserDataToDb()
{
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
var response = twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/users", Method.GET);
var deserializedResponse = JsonConvert.DeserializeObject <UserJsonClass.User>(response.Content);
string currentUserId = GlobalConfig.GetGlobalConfig("userId");
if (currentUserId == null)
{
GlobalConfig.SetGlobalConfig("userId", deserializedResponse.data[0].id.ToString());
}
string currentUserName = GlobalConfig.GetGlobalConfig("userName");
if (currentUserName == null)
{
GlobalConfig.SetGlobalConfig("userName", deserializedResponse.data[0].login);
}
return(currentUserName);
}
public void UpdateStreamerDetails(List <Streamer> listOfStreamers)
{
string listOfIds = "?id=";
for (int i = 0; i < listOfStreamers.Count; i++)
{
if (i != listOfStreamers.Count - 1)
{
listOfIds += listOfStreamers[i].streamerId + "&id=";
}
else
{
listOfIds += listOfStreamers[i].streamerId;
}
}
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
var response = twitchApiHelpers.TwitchRequest($"https://api.twitch.tv/helix/users{listOfIds}", Method.GET);
var deserializedResponse = JsonConvert.DeserializeObject <UserJsonClass.User>(response.Content);
for (int i = 0; i < deserializedResponse.data.Count; i++)
{
Streamer result = new Streamer {
streamerId = deserializedResponse.data[i].id,
displayName = deserializedResponse.data[i].display_name,
username = deserializedResponse.data[i].login,
thumbnailLocation = deserializedResponse.data[i].profile_image_url,
description = deserializedResponse.data[i].description,
viewCount = deserializedResponse.data[i].view_count,
};
StreamerLogic streamerLogic = new StreamerLogic();
streamerLogic.UpdateStreamer(result, null);
}
}
public StreamHelpers.GetStreamsResult FetchStreams(int id)
{
bool isLive = false;
using (var context = new MainDataContext()) {
Streamer data = context.Streamers.FirstOrDefault(item => item.streamerId == id);
if (data != null && data.isLive != null)
{
isLive = (bool)data.isLive;
}
}
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
var response = twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/videos" +
$"?user_id={id}" +
"&first=100", Method.GET);
var deserializeResponse =
JsonConvert.DeserializeObject <StreamHelpers.GetStreamsResult>(response.Content);
StreamHelpers.GetStreamsResult getStreamsResult =
new StreamHelpers.GetStreamsResult();
getStreamsResult.data = new List <StreamHelpers.Data>();
string cursor;
foreach (var stream in deserializeResponse.data)
{
if (isLive && stream.thumbnail_url.Length > 0)
{
getStreamsResult.data.Add(stream);
}
else if (!isLive)
{
getStreamsResult.data.Add(stream);
}
}
if (deserializeResponse.pagination.cursor != null && deserializeResponse.data.Count >= 100)
{
cursor = deserializeResponse.pagination.cursor;
}
else
{
cursor = null;
}
while (cursor != null)
{
var paginatedResponse = twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/videos" +
$"?user_id={id}" +
"&first=100" +
$"&after={deserializeResponse.pagination.cursor}",
Method.GET);
deserializeResponse =
JsonConvert.DeserializeObject <StreamHelpers.GetStreamsResult>(paginatedResponse
.Content);
foreach (var stream in deserializeResponse.data)
{
if (isLive && stream.thumbnail_url.Length > 0)
{
getStreamsResult.data.Add(stream);
}
else if (!isLive)
{
getStreamsResult.data.Add(stream);
}
}
if (deserializeResponse.data.Count >= 100)
{
cursor = deserializeResponse.pagination.cursor;
}
else
{
cursor = null;
}
}
for (int x = 0; x < getStreamsResult.data.Count; x++)
{
/*if (getStreamsResult.data[x].type != "archive") {
* // only retrieve vods
* getStreamsResult.data.Remove(getStreamsResult.data[x]);
* }*/
// manually add thumbnail dimensions because twitch is too lazy to do it
getStreamsResult.data[x].thumbnail_url = getStreamsResult.data[x].thumbnail_url
.Replace("%{width}", "320").Replace("%{height}", "180");
}
return(getStreamsResult);
}
public DeleteStreamReturn DeleteSingleStreamLogic(long streamId)
{
using (var context = new MainDataContext()) {
var stream = context.Streams.FirstOrDefault(item => item.streamId == streamId);
if (stream == null)
{
stream = context.Streams.FirstOrDefault(item => item.vodId == streamId); // add live stream delete capabilities
}
if (stream != null)
{
if (stream.downloadJobId != null)
{
var splitJobKey = stream.downloadJobId.Split(".");
try {
JobHelpers.CancelJob(splitJobKey[1], splitJobKey[0], QuartzSchedulers.PrimaryScheduler(), true);
} catch (MissingJobException e) {
_logger.Info(e.Message);
}
}
if (stream.vodId != 0)
{
try {
CleanUpStreamFiles(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.vodId, stream.streamerId);
} catch (DirectoryNotFoundException) {
CleanUpStreamFiles(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.streamId, stream.streamerId);
}
}
else
{
CleanUpStreamFiles(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.streamId, stream.streamerId);
}
context.Remove(stream);
if (stream.chatDownloadJobId != null)
{
var splitJobKey = stream.chatDownloadJobId.Split(".");
try {
JobHelpers.CancelJob(splitJobKey[1], splitJobKey[0], QuartzSchedulers.PrimaryScheduler(), true);
} catch (MissingJobException e) {
_logger.Info(e.Message);
}
}
using (var chatContext = new ChatDataContext()) {
chatContext.Chats.RemoveRange(chatContext.Chats.Where(item => item.streamId == streamId));
chatContext.SaveChanges();
}
}
context.SaveChanges();
}
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
var request =
twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/videos?id=" + streamId, Method.GET);
if (request.StatusCode == HttpStatusCode.OK)
{
return(new DeleteStreamReturn {
isStillAvailable = true
});
}
return(new DeleteStreamReturn {
isStillAvailable = false
});
}
public void UpdateLiveStatus(List <Streamer> listOfStreamers)
{
string listOfIds = "?user_id=";
for (int i = 0; i < listOfStreamers.Count; i++)
{
if (i != listOfStreamers.Count - 1)
{
listOfIds += listOfStreamers[i].streamerId + "&user_id=";
}
else
{
listOfIds += listOfStreamers[i].streamerId;
}
}
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
var response = twitchApiHelpers.TwitchRequest($"https://api.twitch.tv/helix/streams{listOfIds}&first=100",
Method.GET);
StreamHelpers.GetStreamsResult liveStream =
JsonConvert.DeserializeObject <StreamHelpers.GetStreamsResult>(response.Content);
for (int x = 0; x < listOfStreamers.Count; x++)
{
var stream = liveStream.data.FirstOrDefault(item => item.user_id == listOfStreamers[x].streamerId);
if (stream != null && stream.type == "live")
{
// if live and if not a re-run or something else
using (var context = new MainDataContext()) {
var alreadyExistingStream =
context.Streams.FirstOrDefault(item => item.vodId == Int64.Parse(stream.id));
var streamer =
context.Streamers.FirstOrDefault(item => item.streamerId == listOfStreamers[x].streamerId);
if (streamer.isLive == false)
{
streamer.isLive = true;
context.SaveChanges();
}
NotificationHub.Current.Clients.All.SendAsync($"{streamer.id}Live",
true);
if (streamer.getLive == false || alreadyExistingStream != null)
{
// already downloading/downloaded, or user does not want to download this streamers live stream
continue;
}
}
if (DateTime.UtcNow.Subtract(stream.started_at).TotalMinutes < 5)
{
// queue up the stream to be downloaded
StreamExtended convertedLiveStream = new StreamExtended {
streamId = StreamHelpers.GetStreamDetails(Int64.Parse(stream.id), true, stream.user_id).streamId,
vodId = Int64.Parse(stream.id),
streamerId = stream.user_id,
title = stream.title,
createdAt = stream.started_at
};
CreateLiveStream createLiveStream = new CreateLiveStream();
createLiveStream.PrepareLiveStreamDownload(convertedLiveStream, stream.user_login);
}
}
else
{
using (var context = new MainDataContext()) {
var streamer =
context.Streamers.FirstOrDefault(item => item.streamerId == listOfStreamers[x].streamerId);
if (streamer.isLive == true)
{
streamer.isLive = false;
context.SaveChanges();
}
NotificationHub.Current.Clients.All.SendAsync($"{streamer.id}Live",
false);
}
}
}
}
public static StreamExtended GetStreamDetails(long streamId, bool isLive = false, long userId = default)
{
Logger _logger = new LogFactory().GetCurrentClassLogger();
using (var context = new MainDataContext()) {
var existingStream = context.Streams.FirstOrDefault(item => item.streamId == streamId);
if (existingStream != null)
{
// stream already exists in database
throw new Exception("Stream already exists.");
}
}
StreamExtended stream;
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
IRestResponse response;
try {
if (isLive)
{
response = twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/videos" +
$"?user_id={userId}", Method.GET);
}
else
{
response = twitchApiHelpers.TwitchRequest("https://api.twitch.tv/helix/videos" +
$"?id={streamId}", Method.GET);
}
} catch (NetworkInformationException e) {
_logger.Error(e);
throw;
}
var deserializeResponse =
JsonConvert.DeserializeObject <GetStreamsResult>(response.Content);
StreamExtended retrievedStream;
if (isLive)
{
var tempStream = deserializeResponse.data.First(item => Int64.Parse(item.stream_id) == streamId);
return(new StreamExtended {
streamId = Int32.Parse(tempStream.id),
started_at = tempStream.started_at,
vodId = streamId,
streamerId = tempStream.user_id,
title = tempStream.title,
createdAt = tempStream.created_at
});
}
else
{
return(new StreamExtended {
streamerId = deserializeResponse.data[0].user_id,
streamId = streamId,
thumbnailLocation = deserializeResponse.data[0].thumbnail_url,
title = deserializeResponse.data[0].title,
createdAt = deserializeResponse.data[0].created_at
});
}
}
public Task DownloadChat(long streamId)
{
TwitchApiHelpers twitchApiHelpers = new TwitchApiHelpers();
IRestResponse response;
try {
response =
twitchApiHelpers.LegacyTwitchRequest($"https://api.twitch.tv/v5/videos/{streamId}/comments",
Method.GET);
} catch (NetworkInformationException e) {
_logger.Error(e);
_logger.Error("Cleaning database, removing failed chat download from database.");
RemoveStreamChatFromDb(streamId);
return(Task.FromException(e));
}
ChatMessageJsonClass.ChatMessage deserializeResponse;
try {
deserializeResponse = JsonConvert.DeserializeObject <ChatMessageJsonClass.ChatMessage>(response.Content);
} catch (JsonSerializationException e) {
_logger.Error(e);
_logger.Error("Cleaning database, removing failed chat download from database.");
RemoveStreamChatFromDb(streamId);
return(Task.FromException(e));
}
ChatMessageJsonClass.ChatMessage chatMessage = new ChatMessageJsonClass.ChatMessage();
chatMessage.comments = new List <ChatMessageJsonClass.Comment>();
var cursor = "";
int databaseCounter = 0;
// clear out existing vod messages, should only activate when redownloading
RemoveStreamChatFromDb(streamId);
foreach (var comment in deserializeResponse.comments)
{
if (comment.message.user_badges != null)
{
comment.message.userBadges = ReformatBadges(comment.message.user_badges);
}
if (comment.message.emoticons != null)
{
comment.message.formattedEmoticons = ReformatEmoticons(comment.message.emoticons);
}
chatMessage.comments.Add(comment);
}
if (deserializeResponse._next != null)
{
cursor = deserializeResponse._next;
}
else
{
AddChatMessageToDb(chatMessage.comments, streamId);
}
while (cursor != null)
{
_logger.Info($"Getting more chat for {streamId}..");
//if (token.IsCancellationRequested) {
//await _hubContext.Clients.All.SendAsync("ReceiveMessage", CheckForDownloadingStreams());
//return; // insta kill
//}
IRestResponse paginatedResponse;
try {
paginatedResponse = twitchApiHelpers.LegacyTwitchRequest(
$"https://api.twitch.tv/v5/videos/{streamId}/comments" +
$"?cursor={deserializeResponse._next}", Method.GET);
} catch (NetworkInformationException e) {
_logger.Error(e);
_logger.Error("Cleaning database, removing failed chat download from database.");
RemoveStreamChatFromDb(streamId);
return(Task.FromException(e));
}
try {
deserializeResponse = JsonConvert.DeserializeObject <ChatMessageJsonClass.ChatMessage>(paginatedResponse.Content);
} catch (JsonSerializationException e) {
_logger.Error(e);
_logger.Error("Cleaning database, removing failed chat download from database.");
RemoveStreamChatFromDb(streamId);
return(Task.FromException(e));
}
foreach (var comment in deserializeResponse.comments)
{
if (comment.message.user_badges != null)
{
comment.message.userBadges = ReformatBadges(comment.message.user_badges);
}
if (comment.message.emoticons != null)
{
comment.message.formattedEmoticons = ReformatEmoticons(comment.message.emoticons);
}
chatMessage.comments.Add(comment);
}
databaseCounter++;
if (databaseCounter == 50 || deserializeResponse._next == null)
{
// if we have collected 50 comments or there are no more chat messages
AddChatMessageToDb(chatMessage.comments, streamId);
databaseCounter = 0;
chatMessage.comments.Clear();
}
cursor = deserializeResponse._next;
}
StreamHelpers.SetChatDownloadToFinished(streamId, false);
//await _hubContext.Clients.All.SendAsync("ReceiveMessage", CheckForDownloadingStreams());
return(Task.CompletedTask);
}
