Make-HTTPS-requests-in-a-custom-indicator

This is the relevant code in our CNN Fear/Greed indicator, we use an in-house class called WLWebClient.

WLWebClient client = new WLWebClient(WLWebClientOptions.Compression);
client.AddAcceptHeaders("text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7");
client.AddLanguageHeaders("en-US,en;q=0.9");
client.AddHeader("Upgrade-Insecure-Requests", "1");
string s = client.Get("https://production.dataviz.cnn.io/index/fearandgreed/graphdata");

No, a custom indicator is the right way. The source is returning data for a single TimeSeries, not OHLC/V data. We express these kinds of things as custom indicators in the WL7/8 paradigm.

Thanks it works now.
@Glitch: You could add this indicator now as community indicator if you like.
I implemented even a cache functionality inside, that not too many HTTPS requests are made.

CODE:

/*
 * CustomCryptoFearGreedIndex
 * Author: Stephan Ferraro
 * Email: stephan.ferraro@aionda.com
 *
 * Description:
 * This code defines a custom indicator for WealthLab called "Custom Crypto Fear & Greed Index".
 * It fetches external data from an API to calculate the Fear & Greed Index for cryptocurrency markets.
 * The indicator caches the data to avoid unnecessary HTTP requests if the latest date in the time series has not changed.
 * If a new data point (candle) is added to the time series, the cache is refreshed to ensure updated values are fetched.
 * 
 * Key Features:
 * - Static caching mechanism to optimize performance and reduce HTTP calls.
 * - Dynamically maps Fear & Greed values to corresponding dates in the time series.
 * - Supports visualization in WealthLab with overbought and oversold levels.
 */

using WealthLab.Core;
using System;
using System.Collections.Generic;
using System.Globalization;
using WealthLab.Indicators;
using Newtonsoft.Json.Linq;
using System.Diagnostics;

namespace WealthLab.MyIndicators
{
   public class CustomCryptoFearGreedIndex : IndicatorBase
   {
      // Static cache to store Fear & Greed data to minimize redundant API calls.
      private static Dictionary<DateTime, int> _cachedData = new Dictionary<DateTime, int>();

      // Tracks the last date when the cache was updated.
      private static DateTime _lastCacheDate = DateTime.MinValue;

      // Default constructor initializing overbought and oversold levels.
      public CustomCryptoFearGreedIndex() : base()
      {
         OverboughtLevel = 70; // Overbought threshold for the index.
         OversoldLevel = 30;   // Oversold threshold for the index.
      }

      // Constructor for initializing with source data
      public CustomCryptoFearGreedIndex(TimeSeries source) : base()
      {
         Parameters[0].Value = source; // Assign the input time series.
         OverboughtLevel = 70;
         OversoldLevel = 30;
         Populate(); // Calculate the indicator values.
      }

      // Factory method for creating an instance of the indicator.
      public static CustomCryptoFearGreedIndex Series(TimeSeries source)
      {
         return new CustomCryptoFearGreedIndex(source);
      }

      // Name displayed in the WealthLab indicator list.
      public override string Name => "Custom Crypto Fear & Greed Index";

      // Abbreviation of the indicator name.
      public override string Abbreviation => "CustomCryptoFearGreedIndex";

      // Description displayed in the indicator manager in WealthLab.
      public override string HelpDescription =>
         "Custom Crypto Fear & Greed Index based on external data source.";

      // Ensures the indicator is plotted in a separate pane.
      public override string PaneTag => "CustomCryptoFearGreedIndex";

      // Default color for the indicator plot.
      public override WLColor DefaultColor => WLColor.Navy;

      // Main calculation method for populating the indicator values.
      public override void Populate()
      {
         TimeSeries source = Parameters[0].AsTimeSeries; // Get the input time series.

         DateTimes = source.DateTimes; // Set DateTimes from the source data.

         // Exit if source data is invalid or insufficient.
         if (source == null || source.Count == 0)
            return;

         // Initialize Values to hold calculated indicator values.
         if (Values == null || Values.Count != source.Count)
            Values = new List<double>(new double[source.Count]);

         DateTime latestDate = source.DateTimes[^1]; // Get the last date in the time series.

         // Refresh cache if a new data point is detected.
         if (_cachedData.Count == 0 || _lastCacheDate < latestDate)
         {
            _cachedData = GetFearGreedData(); // Fetch new data from the API.
            _lastCacheDate = latestDate; // Update the last cache date.
         }

         // Exit if no data is available in the cache.
         if (_cachedData == null || _cachedData.Count == 0)
            return;

         // Map Fear & Greed values to the corresponding dates in the time series.
         for (int i = 0; i < source.Count; i++)
         {
            DateTime date = source.DateTimes[i];
            if (_cachedData.TryGetValue(date, out int value))
            {
               Values[i] = value; // Assign the cached value for the date.
            }
            else
            {
               // If no data for the date, use the previous value or 0 if it's the first value.
               Values[i] = i > 0 ? Values[i - 1] : 0;
            }
         }
      }

      // Method to fetch Fear & Greed data from an external API.
      private Dictionary<DateTime, int> GetFearGreedData()
      {
         var data = new Dictionary<DateTime, int>();

         try
         {
            // Set up HTTP client with necessary headers.
            WLWebClient client = new WLWebClient(WLWebClientOptions.Compression);
            client.AddAcceptHeaders("application/json");
            client.AddLanguageHeaders("en-US,en;q=0.9");
            client.AddHeader("Upgrade-Insecure-Requests", "1");
            string response = client.Get("<a href="https://api.alternative.me/fng/?limit=999999&format=json&date_format=world" target="_blank">https://api.alternative.me/fng/?limit=999999&format=json&date_format=world</a>");

            // Parse the JSON response.
            var jsonResponse = JObject.Parse(response);
            var dataArray = jsonResponse["data"];

            // Extract date and value pairs from the JSON array.
            foreach (var item in dataArray)
            {
               if (DateTime.TryParseExact(item["timestamp"].ToString(), "dd-MM-yyyy",
                  CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date) &&
                  int.TryParse(item["value"].ToString(), out int value))
               {
                  data[date] = value; // Store the date-value pair in the dictionary.
               }
            }
         }
         catch (Exception ex)
         {
            // Log any errors during data retrieval.
            Debug.WriteLine($"Error fetching Fear & Greed data: {ex.Message}");
         }

         return data; // Return the populated dictionary.
      }

      // Method to define input parameters for the indicator.
      protected override void GenerateParameters()
      {
         // Add source time series and lookback period as parameters.
         AddParameter("Source", ParameterType.TimeSeries, PriceComponent.Close); // Input time series (e.g., closing price).
      }
   }
}