Beispiel #1
0
        public async Task <IActionResult> Authentication(string code, string scope, string state)
        {
            var cleanedUrl  = Request.GetEncodedUrl().Replace(Request.QueryString.Value, "");
            var apiResponse = await TwitchValidationClient.GetAccessToken(code, cleanedUrl);

            if (apiResponse != null)
            {
                tokenDetails.Token        = apiResponse.Access_Token;
                tokenDetails.RefreshToken = apiResponse.Refresh_Token;

                tokenDetails.DateTimestamp = DateTime.UtcNow;

                JsonFileProcessor.SaveAccessTokenFile(tokenDetails);

                return(RedirectToAction("Index", "TwitchData"));
            }

            ViewData["AuthenticationUrl"] = TwitchValidationClient.GetAuthenticationUrl(Url.Action("Authentication", "TwitchData", null, Request.Scheme));
            return(View());
        }
        public async Task <IActionResult> Index()
        {
            if (string.IsNullOrWhiteSpace(TwitchApiClient.ClientId))
            {
                TwitchApiClient.ClientId = _clientSettings.Id;

                TwitchValidationClient.ClientId     = _clientSettings.Id;
                TwitchValidationClient.ClientSecret = _clientSettings.Secret;
            }

            if (!Directory.Exists(appDataFolder))
            {
                Directory.CreateDirectory(appDataFolder);
            }

            if (!System.IO.File.Exists($@"{appDataFolder}\UserSettings.json"))
            {
                JsonFileProcessor.GenerateConfigurationFile();
            }

            if (System.IO.File.Exists($@"{appDataFolder}\SavedToken.json"))
            {
                var tokenDetails = await JsonFileProcessor.LoadAccessTokenFile();

                var timeSinceValidation = DateTime.UtcNow.Subtract(tokenDetails.DateTimestamp);
                if (timeSinceValidation.TotalMinutes >= 30)
                {
                    if (await TwitchValidationClient.ValidateTokenAsync(tokenDetails.Token))
                    {
                        TwitchApiClient.SetAccessToken(tokenDetails.Token);
                        return(RedirectToAction("Index", "TwitchData"));
                    }

                    if (!String.IsNullOrWhiteSpace(tokenDetails.RefreshToken))
                    {
                        var apiResponse = await TwitchValidationClient.RefreshAccessToken(tokenDetails.RefreshToken);

                        if (apiResponse != null)
                        {
                            tokenDetails.Token        = apiResponse.Access_Token;
                            tokenDetails.RefreshToken = apiResponse.Refresh_Token;

                            tokenDetails.DateTimestamp = DateTime.UtcNow;

                            JsonFileProcessor.SaveAccessTokenFile(tokenDetails);

                            TwitchApiClient.SetAccessToken(tokenDetails.Token);
                            return(RedirectToAction("Index", "TwitchData"));
                        }
                    }
                }
                else
                {
                    if (await TwitchValidationClient.ValidateTokenAsync(tokenDetails.Token))
                    {
                        TwitchApiClient.SetAccessToken(tokenDetails.Token);
                        return(RedirectToAction("Index", "TwitchData"));
                    }
                }
            }

            ViewData["AuthenticationUrl"] = TwitchValidationClient.GetAuthenticationUrl(Url.Action("Authentication", "TwitchData", null, Request.Scheme));
            return(View());
        }
Beispiel #3
0
        public async Task <IActionResult> RefreshStreamData()
        {
            var loadedConfig = await JsonFileProcessor.LoadConfigurationFile();

            var userApiResponse = await TwitchApiClient.GetUserDataAsync(loadedConfig.Login);

            if (userApiResponse != null)
            {
                var selectedUser       = userApiResponse.Data.First();
                var channelApiResponse = await TwitchApiClient.GetChannelDataAsync(selectedUser.Login);

                if (channelApiResponse != null)
                {
                    var stats = new TwitchStatsModel()
                    {
                        ChannelViews     = selectedUser.View_Count,
                        ChannelFollowers = 0
                    };

                    var followerApiResponse = await TwitchApiClient.GetFollowerDataAsync(selectedUser.Id);

                    if (followerApiResponse != null)
                    {
                        stats.ChannelFollowers = followerApiResponse.Total;
                    }

                    var selectedChannel = channelApiResponse.Data.First(m => m.Id.Equals(selectedUser.Id));

                    if (selectedChannel.Is_Live)
                    {
                        var streamApiResponse = await TwitchApiClient.GetStreamDataAsync(selectedUser.Id);

                        if (streamApiResponse == null)
                        {
                            stats.Viewers             = 1;
                            stats.StreamStartDateTime = selectedChannel.Started_At;
                            stats.Clips = 0;

                            return(PartialView("_LiveInformationPartial", stats));
                        }
                        if (streamApiResponse.Data.Count < 1)
                        {
                            return(PartialView("_OfflineInformationPartial", stats));
                        }

                        var selectedStream = streamApiResponse.Data.First();

                        stats.Viewers             = selectedStream.Viewer_Count;
                        stats.StreamStartDateTime = selectedStream.Started_At;

                        var clipApiResponse = await TwitchApiClient.GetClipDataAsync(selectedUser.Id, selectedStream.Started_At);

                        stats.Clips = clipApiResponse != null ? clipApiResponse.Data.Count : 0;

                        if (System.IO.File.Exists(loadedConfig.NowPlayingFile))
                        {
                            stats.NowPlaying = await System.IO.File.ReadAllTextAsync(loadedConfig.NowPlayingFile);

                            stats.NowPlaying = stats.NowPlaying.Trim();
                        }

                        return(PartialView("_LiveInformationPartial", stats));
                    }

                    return(PartialView("_OfflineInformationPartial", stats));
                }
            }

            ViewData["AuthenticationUrl"] = TwitchValidationClient.GetAuthenticationUrl(Url.Action("Authentication", "TwitchData", null, Request.Scheme));
            return(PartialView("_ReauthenticationPartial"));
        }