public override async Task Enable()
{
if (this.LeaderboardType == OverlayLeaderboardListItemTypeEnum.Subscribers)
{
this.userSubDates.Clear();
IEnumerable <UserSubscriptionModel> subscribers = await ChannelSession.TwitchUserConnection.GetSubscribersV5(ChannelSession.TwitchChannelV5, int.MaxValue);
foreach (UserSubscriptionModel subscriber in subscribers)
{
UserViewModel user = await UserViewModel.Create(subscriber.user);
DateTimeOffset?subDate = TwitchPlatformService.GetTwitchDateTime(subscriber.created_at);
if (subDate.HasValue && this.ShouldIncludeUser(user))
{
this.userSubDates[user.ID] = subDate.GetValueOrDefault();
}
}
await this.UpdateSubscribers();
GlobalEvents.OnSubscribeOccurred += GlobalEvents_OnSubscribeOccurred;
GlobalEvents.OnResubscribeOccurred += GlobalEvents_OnResubscribeOccurred;
GlobalEvents.OnSubscriptionGiftedOccurred += GlobalEvents_OnSubscriptionGiftedOccurred;
}
else if (this.LeaderboardType == OverlayLeaderboardListItemTypeEnum.Donations)
{
GlobalEvents.OnDonationOccurred += GlobalEvents_OnDonationOccurred;
}
await base.Enable();
}
private async Task RefreshTwitchUserAccountDate()
{
TwitchV5API.Users.UserModel twitchV5User = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(this.TwitchUsername);
if (twitchV5User != null && !string.IsNullOrEmpty(twitchV5User.created_at))
{
this.AccountDate = TwitchPlatformService.GetTwitchDateTime(twitchV5User.created_at);
}
}
public static Task <DateTimeOffset> GetStartTime()
{
DateTimeOffset startTime = DateTimeOffset.MinValue;
if (ChannelSession.TwitchStreamNewAPI != null)
{
startTime = TwitchPlatformService.GetTwitchDateTime(ChannelSession.TwitchStreamNewAPI.started_at).GetValueOrDefault();
}
return(Task.FromResult(startTime));
}
private async Task RefreshTwitchUserFollowDate()
{
UserFollowModel follow = await ChannelSession.TwitchUserConnection.CheckIfFollowsNewAPI(ChannelSession.TwitchUserNewAPI, this.GetTwitchNewAPIUserModel());
if (follow != null && !string.IsNullOrEmpty(follow.followed_at))
{
this.FollowDate = TwitchPlatformService.GetTwitchDateTime(follow.followed_at);
}
else
{
this.FollowDate = null;
}
}
private async Task RefreshTwitchUserSubscribeDate()
{
if (ChannelSession.TwitchUserNewAPI.IsAffiliate() || ChannelSession.TwitchUserNewAPI.IsPartner())
{
TwitchV5API.Users.UserSubscriptionModel subscription = await ChannelSession.TwitchUserConnection.CheckIfSubscribedV5(ChannelSession.TwitchChannelV5, this.GetTwitchV5APIUserModel());
if (subscription != null && !string.IsNullOrEmpty(subscription.created_at))
{
this.SubscribeDate = TwitchPlatformService.GetTwitchDateTime(subscription.created_at);
this.Data.TwitchSubscriberTier = TwitchEventService.GetSubTierNumberFromText(subscription.sub_plan);
}
else
{
this.SubscribeDate = null;
this.Data.TwitchSubscriberTier = 0;
}
}
}
public static async Task <Result> ConnectTwitchBot()
{
Result <TwitchPlatformService> result = await TwitchPlatformService.ConnectBot();
if (result.Success)
{
ChannelSession.TwitchBotConnection = result.Value;
ChannelSession.TwitchBotNewAPI = await ChannelSession.TwitchBotConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchBotNewAPI == null)
{
return(new Result(Resources.TwitchFailedBotData));
}
if (ChannelSession.Services.Chat.TwitchChatService != null && ChannelSession.Services.Chat.TwitchChatService.IsUserConnected)
{
return(await ChannelSession.Services.Chat.TwitchChatService.ConnectBot());
}
}
return(result);
}
public static async Task <Result> ConnectTwitchUser()
{
Result <TwitchPlatformService> result = await TwitchPlatformService.ConnectUser();
if (result.Success)
{
ChannelSession.TwitchUserConnection = result.Value;
ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchUserNewAPI == null)
{
return(new Result(Resources.TwitchFailedNewAPIUserData));
}
ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (ChannelSession.TwitchUserV5 == null)
{
return(new Result(Resources.TwitchFailedV5APIUserData));
}
}
return(result);
}
public static async Task <Result> ConnectTwitchUser(bool isStreamer)
{
Result <TwitchPlatformService> result = await TwitchPlatformService.ConnectUser(isStreamer);
if (result.Success)
{
ChannelSession.TwitchUserConnection = result.Value;
ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchUserNewAPI == null)
{
return(new Result("Failed to get New API Twitch user data"));
}
ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (ChannelSession.TwitchUserV5 == null)
{
return(new Result("Failed to get V5 API Twitch user data"));
}
}
return(result);
}
public static async Task <Result> ConnectUser(SettingsV3Model settings)
{
Result userResult = new Result(success: false);
try
{
ChannelSession.Settings = settings;
// Twitch connection
if (!ChannelSession.Settings.StreamingPlatformAuthentications.ContainsKey(StreamingPlatformTypeEnum.Twitch))
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch] = new StreamingPlatformAuthenticationSettingsModel(StreamingPlatformTypeEnum.Twitch);
}
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, "Assigning of initial Settings failed");
throw ex;
}
Result <TwitchPlatformService> twitchResult = new Result <TwitchPlatformService>(success: false, (TwitchPlatformService)null);
try
{
twitchResult = twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].UserOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchUserConnection = twitchResult.Value;
userResult = twitchResult;
}
else
{
userResult = await ChannelSession.ConnectTwitchUser();
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
try
{
if (userResult != null && userResult.Success)
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].IsEnabled = true;
ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchUserNewAPI == null)
{
return(new Result(Resources.TwitchFailedNewAPIUserData));
}
ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (ChannelSession.TwitchUserV5 == null)
{
return(new Result(Resources.TwitchFailedV5APIUserData));
}
try
{
if (ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken != null)
{
twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchBotConnection = twitchResult.Value;
ChannelSession.TwitchBotNewAPI = await ChannelSession.TwitchBotConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchBotNewAPI == null)
{
return(new Result(Resources.TwitchFailedBotData));
}
}
else
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken = null;
return(new Result(success: true, message: "Failed to connect Twitch bot account, please manually reconnect"));
}
}
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, "Getting bot details failed");
throw ex;
}
}
else
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].UserOAuthToken = null;
return(userResult);
}
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, "Getting user details failed");
throw ex;
}
return(userResult);
}
public static async Task <Result> ConnectUser(SettingsV3Model settings)
{
Result userResult = null;
ChannelSession.Settings = settings;
// Twitch connection
if (!ChannelSession.Settings.StreamingPlatformAuthentications.ContainsKey(StreamingPlatformTypeEnum.Twitch))
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch] = new StreamingPlatformAuthenticationSettingsModel(StreamingPlatformTypeEnum.Twitch);
}
Result <TwitchPlatformService> twitchResult = twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].UserOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchUserConnection = twitchResult.Value;
userResult = twitchResult;
}
else
{
userResult = await ChannelSession.ConnectTwitchUser();
}
if (userResult.Success)
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].IsEnabled = true;
ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchUserNewAPI == null)
{
return(new Result("Failed to get Twitch user data"));
}
ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (ChannelSession.TwitchUserV5 == null)
{
return(new Result("Failed to get V5 API Twitch user data"));
}
if (ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken != null)
{
twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchBotConnection = twitchResult.Value;
ChannelSession.TwitchBotNewAPI = await ChannelSession.TwitchBotConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchBotNewAPI == null)
{
return(new Result("Failed to get Twitch bot data"));
}
}
else
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken = null;
return(new Result(success: true, message: "Failed to connect Twitch bot account, please manually reconnect"));
}
}
}
else
{
ChannelSession.Settings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch] = null;
return(userResult);
}
return(userResult);
}
public static async Task <Result> ConnectUser(SettingsV2Model settings)
{
Result userResult = null;
ChannelSession.Settings = settings;
// Twitch connection
Result <TwitchPlatformService> twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.TwitchUserOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchUserConnection = twitchResult.Value;
userResult = twitchResult;
}
else
{
userResult = await ChannelSession.ConnectTwitchUser(ChannelSession.Settings.IsStreamer);
}
if (userResult.Success)
{
ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchUserNewAPI == null)
{
return(new Result("Failed to get Twitch user data"));
}
ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (ChannelSession.TwitchUserV5 == null)
{
return(new Result("Failed to get V5 API Twitch user data"));
}
if (settings.TwitchBotOAuthToken != null)
{
twitchResult = await TwitchPlatformService.Connect(settings.TwitchBotOAuthToken);
if (twitchResult.Success)
{
ChannelSession.TwitchBotConnection = twitchResult.Value;
ChannelSession.TwitchBotNewAPI = await ChannelSession.TwitchBotConnection.GetNewAPICurrentUser();
if (ChannelSession.TwitchBotNewAPI == null)
{
return(new Result("Failed to get Twitch bot data"));
}
}
else
{
settings.TwitchBotOAuthToken = null;
return(new Result(success: true, message: "Failed to connect Twitch bot account, please manually reconnect"));
}
}
}
else
{
ChannelSession.Settings.TwitchUserOAuthToken = null;
return(userResult);
}
return(userResult);
}
