public bool GetGracenoteMappingData()
        {
            try
            {
                var mapUrl = $"{ADIWF_Config.OnApi}ProgramMappings?" +
                             $"providerId={OnapiProviderid}&" +
                             $"api_key={ADIWF_Config.ApiKey}";

                GracenoteMappingData = null;

                Log.Info($"Calling On API Mappings url with Provider Value: {OnapiProviderid}");
                var webClient = new WebClientManager();
                GracenoteMappingData = webClient.HttpGetRequest(mapUrl);
                Log.Debug($"RECEIVED MAPPING DATA FROM GRACENOTE: \r\n{GracenoteMappingData}");
                if (GracenoteMappingData != null & webClient.SuccessfulWebRequest)
                {
                    return(true);
                }

                throw new Exception($"Gracenote Mapping Data: {GracenoteMappingData}, " +
                                    $"Failed Web request: {webClient.SuccessfulWebRequest}," +
                                    $"Web request response code: {webClient.RequestStatusCode}");
            }
            catch (Exception ggmdEx)
            {
                Log.Error($"[GetGracenoteMappingData] Error obtaining Gracenote mapping data: {ggmdEx.Message}");
                if (ggmdEx.InnerException != null)
                {
                    Log.Error($"[GetGracenoteMappingData] Inner exception: {ggmdEx.InnerException.Message}");
                }
            }

            return(false);
        }
        public bool GetGraceNoteSeriesSeasonSpecialsData()
        {
            try
            {
                var requestUrl = $"{ADIWF_Config.OnApi}Programs?" +
                                 $"tmsId={GraceNoteConnectorId}&" +
                                 $"api_key={ADIWF_Config.ApiKey}";

                Log.Info($"Retrieving MetaData from On API using Connector ID: {GraceNoteConnectorId}");

                GraceNoteSeriesSeasonSpecialsData = null;

                var webClient = new WebClientManager();
                GraceNoteSeriesSeasonSpecialsData = webClient.HttpGetRequest(requestUrl);

                if (GraceNoteSeriesSeasonSpecialsData != null & webClient.SuccessfulWebRequest)
                {
                    return(true);
                }

                throw new Exception("[GetGraceNoteSeriesSeasonSpecialsData] Error during receive of GN Api data, " +
                                    $"Web request data: {webClient.SuccessfulWebRequest}," +
                                    $"Web request response code: {webClient.RequestStatusCode}");
            }
            catch (Exception ggpdEx)
            {
                Log.Error("[GetGraceNoteSeriesSeasonSpecialsData] Error obtaining " +
                          $"Gracenote Api data: {ggpdEx.Message}");

                if (ggpdEx.InnerException != null)
                {
                    Log.Error("[GetGraceNoteSeriesSeasonSpecialsData] " +
                              $"Inner exception: {ggpdEx.InnerException.Message}");
                }

                return(false);
            }
        }
        public bool GetGracenoteProgramData()
        {
            try
            {
                Log.Info($"Retrieving MetaData from On API using TMSId: {GraceNoteTmsId}");
                var programUrl = $"{ADIWF_Config.OnApi}Programs?" +
                                 $"tmsId={GraceNoteTmsId}&" +
                                 $"api_key={ADIWF_Config.ApiKey}";

                GracenoteProgramData = null;

                Log.Info($"Calling On API Programs url with TmsId Value: {GraceNoteTmsId}");
                var webClient = new WebClientManager();
                GracenoteProgramData = webClient.HttpGetRequest(programUrl);

                if (GracenoteProgramData != null & webClient.SuccessfulWebRequest)
                {
                    return(true);
                }

                throw new Exception("Error during receive of GN Api Program data, " +
                                    $"Web request data: {webClient.SuccessfulWebRequest}," +
                                    $"Web request response code: {webClient.RequestStatusCode}");
            }
            catch (Exception ggpdEx)
            {
                Log.Error("[GetGracenoteProgramData] Error obtaining " +
                          $"Gracenote Program data: {ggpdEx.Message}");

                if (ggpdEx.InnerException != null)
                {
                    Log.Error("[GetGracenoteProgramData] " +
                              $"Inner exception: {ggpdEx.InnerException.Message}");
                }

                return(false);
            }
        }
        public bool GetGraceNoteUpdates(string updateId, string apiCall, string resultLimit)
        {
            try
            {
                //http://on-api.gracenote.com/v3/ProgramMappings?updateId=10938407543&limit=100&api_key=wgu7uhqcqyzspwxj28mxgy4b
                var updateUrl = $"{GN_UpdateTracker_Config.OnApi}{apiCall}" +
                                $"?updateId={updateId}" +
                                $"&limit={resultLimit}" +
                                $"&api_key={GN_UpdateTracker_Config.ApiKey}";

                GraceNoteUpdateData = null;

                Log.Info($"Calling On API url with Update Value: {updateId} and Limit: {resultLimit}");
                var webClient = new WebClientManager();
                GraceNoteUpdateData = webClient.HttpGetRequest(updateUrl);
                Log.Info("Successfully Called Gracenote OnApi");
                if (GraceNoteUpdateData != null & webClient.SuccessfulWebRequest)
                {
                    return(true);
                }

                throw new Exception($"Gracenote Update Data: {GraceNoteUpdateData}, " +
                                    $"Successful Web request: {webClient.SuccessfulWebRequest}," +
                                    $"Web request response code: {webClient.RequestStatusCode}");
            }
            catch (Exception ggnmuex)
            {
                Log.Error($"[GetGraceNoteUpdates] Error obtaining Gracenote Update data: {ggnmuex.Message}");
                if (ggnmuex.InnerException != null)
                {
                    Log.Error($"[GetGraceNoteUpdates] Inner exception: {ggnmuex.InnerException.Message}");
                }
            }

            return(false);
        }