Store indexes in database instead of configurations.

Hi @Maksym, thanks for your suggestions. I solved it (but there are still workarounds in my solution).
I implemented my custom dataStorge and dataLoader. Here what I did:

CustomDataStorage:

public class FmReportManager : IDataStorage
{
    private readonly IDataLoader _dataLoader;

    public FmReportManager(IDataLoader dataLoader)
    {
        _dataLoader = dataLoader;
    }

    public async Task<IDataStructure> GetOrAddAsync(string cacheKey)
    {
        return _dataLoader.Load(cacheKey);
    }

    public void Remove(string key)
    {
        throw new System.NotImplementedException();
    }
}

CustomDataLoader: (not completed)

public class FmReportRepository : IDataLoader
{
    private readonly IDataSourcesRepository _dataSourcesRepository;
    private readonly IParser _parser;

    public FmReportRepository(IDataSourcesRepository dataSourcesRepository, IParser parser)
    {
        _dataSourcesRepository = dataSourcesRepository;
        _parser = parser;
    }

    public IDataStructure Load(string index)
    {
        var entity = _dataSourcesRepository.GetAsync(x => x.Index == index).Result;

        try
        {
            entity.LoadingStatus = DataSourceLoadingStatusTypes.Pending;
            // TODO: update entity in database

            // TODO: match entity to IndexOptions
            _parser.IndexOptions = new IndexOptions();

            var parsedData = _parser.Parse();
            var listDataStructure = new ColumnListDataStructure();
            var innerTypes = new Dictionary<int, ColumnType>();
            foreach (var rowsAndColumnsMatrix in parsedData)
            {
                if (listDataStructure.GetNameAndTypes().Count == 0)
                {
                    foreach (var keyValuePair in _parser.ColumnInfoByIndex)
                    {
                        var columnType = GetColumnType(keyValuePair.Value.Type);
                        innerTypes.Add(keyValuePair.Key, columnType);
                        listDataStructure.AddEmptyColumn(keyValuePair.Value.Name, columnType);
                    }
                }

                for (var columnIndex = 0; columnIndex < rowsAndColumnsMatrix.GetLength(1); ++columnIndex)
                {
                    if (innerTypes[columnIndex] == ColumnType.StringType)
                    {
                        var column = listDataStructure.GetColumn<string>(_parser.ColumnInfoByIndex[columnIndex].Name);
                        for (var rowIndex = 0; rowIndex < rowsAndColumnsMatrix.GetLength(0); ++rowIndex)
                        {
                            var columnValue = rowsAndColumnsMatrix[rowIndex, columnIndex];
                            column.Add(columnValue.ToString());
                        }
                    }
                    else
                    {
                        var column = listDataStructure.GetColumn<double?>(_parser.ColumnInfoByIndex[columnIndex].Name);
                        for (var rowIndex = 0; rowIndex < rowsAndColumnsMatrix.GetLength(0); ++rowIndex)
                        {
                            var columnValue = rowsAndColumnsMatrix[rowIndex, columnIndex];
                            column.Add(columnValue is DBNull ? new double?() : Convert.ToDouble(columnValue));
                        }
                    }
                }
            }

            entity.LoadingStatus = DataSourceLoadingStatusTypes.Loaded;
            // TODO: update entity in database

            return listDataStructure;
        }
        catch (Exception)
        {
            entity.LoadingStatus = DataSourceLoadingStatusTypes.Failed;
            // TODO: update entity in database

            throw;
        }
    }

    private static ColumnType GetColumnType(Type columnType)
    {
        switch (Type.GetTypeCode(columnType))
        {
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
                return ColumnType.DoubleType;
            case TypeCode.DateTime:
                return ColumnType.DateType;
            default:
                return ColumnType.StringType;
        }
    }
}

All necessary requests:

public class FmReportsController : AnalyticServiceController, IFmReportsAppService
{
    private readonly IFmReportsAppService _fmReportsAppService;
    private readonly IApiService _fmApiService;
    private readonly IOptionsMonitor<DatasourceOptions> _datasourceOptions;

    public FmReportsController(IFmReportsAppService fmReportsAppService, IApiService fmApiService, IOptionsMonitor<DatasourceOptions> datasourceOptions)
    {
        _fmReportsAppService = fmReportsAppService;
        _fmApiService = fmApiService;
        _datasourceOptions = datasourceOptions;
    }

    [HttpPost("handshake")]
    public Task<HandshakeResponse> HandshakeAsync()
    {
        return _fmReportsAppService.HandshakeAsync();
    }

    [HttpPost("fields")]
    public Task<Schema> PostFieldsAsync(FieldsRequest request)
    {
        // TODO: This is a workaround for the issue with the Flexmonster Data Server. The private method in fmApiService still uses optionsMonitor pattern.
        // TODO: To override that private method, we need to implement whole IFmReportsAppService interface.
        _datasourceOptions.CurrentValue.Indexes = new Dictionary<string, IndexOptions> {{request.Index, new IndexOptions {Type = "json"}}};

        return _fmApiService.GetFieldsAsync(request.Index);
    }

    [HttpPost("members")]
    public Task<MembersResponse> PostMembersAsync(MembersRequest request)
    {
        // TODO: This is a workaround for the issue with the Flexmonster Data Server. The private method in fmApiService still uses optionsMonitor pattern.
        // TODO: To override that private method, we need to implement whole IFmReportsAppService interface.
        _datasourceOptions.CurrentValue.Indexes = new Dictionary<string, IndexOptions> {{request.Index, new IndexOptions {Type = "json"}}};

        return _fmApiService.GetMembersAsync(request);
    }

    [HttpPost("select")]
    public Task<SelectResponse> PostSelectAsync(SelectRequest request)
    {
        // TODO: This is a workaround for the issue with the Flexmonster Data Server. The private method in fmApiService still uses optionsMonitor pattern.
        // TODO: To override that private method, we need to implement whole IFmReportsAppService interface.
        _datasourceOptions.CurrentValue.Indexes = new Dictionary<string, IndexOptions> {{request.Index, new IndexOptions {Type = "json"}}};

        return _fmApiService.GetAggregatedDataAsync(request);
    }
}

and service replacement:

...
context.Services.AddFlexmonsterApi();
context.Services.ConfigureFlexmonsterOptions(configuration);
context.Services.Replace(ServiceDescriptor.Singleton<IDataStorage, FmReportManager>());
context.Services.Replace(ServiceDescriptor.Transient<IDataLoader, FmReportRepository>());

So instead of implement whole FDS, I just override DataStorage and DataLoader . But still I need a workaround like following:

[HttpPost("fields")]
public Task<Schema> PostFieldsAsync(FieldsRequest request)
{
    // workaround:
    _datasourceOptions.CurrentValue.Indexes = new Dictionary<string, IndexOptions> {{request.Index, new IndexOptions {Type = "json"}}};

    return _fmApiService.GetFieldsAsync(request.Index);
}

because of following code in IApiService . it is using _dataSourceOptions.

private async Task<IDataStructure> LoadData(string index)
{
  if (!this._dataSourceOptions.CurrentValue.Indexes.ContainsKey(index))
    throw new FlexmonsterApiException("Index with name \"" + index + "\" was not found.");
  if (this._dataSourceOptions.CurrentValue.Indexes[index].LoadingStatus == LoadingStatus.pending)
    throw new FlexmonsterApiException("Index with name \"" + index + "\" is currently loading. Please try again later.");
  if (this._dataSourceOptions.CurrentValue.Indexes[index].LoadingStatus == LoadingStatus.failed)
    throw new FlexmonsterApiException("Index with name \"" + index + "\" is unavailable.");
  return await this._dataStorage.GetOrAddAsync(index);
}

BTW, you said: "Our team is ready to guide you through the implementation process. Please let us know which solution fits better for you."

If they can help or any suggestion on my solution, it would be great 🙂 It would be nice if i could get rid of that workaround.