<TelerikButton OnClick="@_gridStateManager.SaveState" Icon="download">Save State</TelerikButton>
<TelerikButton OnClick="@_gridStateManager.LoadState" Icon="upload">Load State</TelerikButton>
<TelerikButton OnClick="@_gridStateManager.ResetState" Icon="reset">Reset State</TelerikButton>

 protected override async Task OnInitializedAsync()
{
     _gridStateManager = new GridStateManager<PortfolioListItem>(LocalStorage, PortfolioListGrid, GetDefaultGridState);
}

OnStateInit="@((GridStateEventArgs<PortfolioListItem> args) => _gridStateManager.OnStateInitHandler(args))">

using System;
using System.Threading.Tasks;
using Blazored.LocalStorage;
using Telerik.Blazor.Components;

namespace Argus.Client;

public class GridStateManager<T> where T : class
{
    private readonly ILocalStorageService _localStorage;
    private readonly TelerikGrid<T> _grid;
    private readonly Func<GridState<T>> _getDefaultGridState;
    private readonly string _stateStorageKey;

    public GridStateManager(
        ILocalStorageService localStorage,
        TelerikGrid<T> grid,
        Func<GridState<T>> getDefaultGridState)
    {
        _localStorage = localStorage;
        _grid = grid;
        _getDefaultGridState = getDefaultGridState;
        _stateStorageKey = $"GridStateFor{nameof(T)}";
    }

    public async Task OnStateInitHandler(GridStateEventArgs<T> args)
    {
        try
        {
            var storageState = await _localStorage.GetItemAsync<GridState<T>>(_stateStorageKey);
            if (storageState != null)
                args.GridState = storageState;
            if (storageState == null && _getDefaultGridState != null)
                args.GridState = _getDefaultGridState();
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

    public async Task SaveState()
    {
        var gridState = _grid.GetState();
        await _localStorage.SetItemAsync(_stateStorageKey, gridState);
    }

    public async Task LoadState()
    {
        GridState<T> storedState = await _localStorage.GetItemAsync<GridState<T>>(_stateStorageKey);
        if (storedState != null)
        {
            await _grid.SetState(storedState);
        }
    }

    public async void ResetState()
    {
        if (_getDefaultGridState != null)
        {
            await _grid.SetState(_getDefaultGridState());
        }
        await _localStorage.RemoveItemAsync(_stateStorageKey);
    }
}

OnStateInit="@((GridStateEventArgs<PortfolioListItem> args) => _gridStateManager.OnStateInitHandler(args, @gridRef))">

OnStateInit="@((GridStateEventArgs<PortfolioListItem> args) => InitGridStateManager(args))">

private async Task InitGridStateManager(GridStateEventArgs<PortfolioListItem> args)
{
       _gridStateManager = new GridStateManager<PortfolioListItem>(LocalStorage, PortfolioListGrid, GetDefaultGridState);
       await _gridStateManager.OnStateInitHandler(args);
 }

        
private readonly string _conn;
        private readonly AuthenticationStateProvider _auth;

        public StudyFeeService(IConfiguration config, AuthenticationStateProvider auth)
        {
            _conn = config.GetConnectionString("PharmCTConn");
            _auth = auth;
        }

        public async Task<string> GetUser()
        {
            var authState = await _auth.GetAuthenticationStateAsync();
            var user = authState.User;
            return user.Identity.Name;
        }
        public async Task<bool> CreateStudyFee(StudyFeeViewModel studyFee)
        {
            var parameters = new DynamicParameters();
            studyFee.CreatedBy = await GetUser();

            parameters.AddDynamicParams(new
            {
                studyFee.HREC,
                studyFee.Fee,
                studyFee.CreatedBy
            });  

            using (var conn = new SqlConnection(_conn))
            {
                string query = @"insert into dbo.StudyFee (HREC, Fee, CreatedBy) 
                                 values (@HREC, @Fee, @CreatedBy)";

                await conn.ExecuteAsync(query, parameters, commandType: CommandType.Text);
            }
            return true;
        }

<TelerikRootComponent>
    <NavMenu/>
    <div class="page">
        <TelerikNotification @ref="@Notification.Instance"
                             HorizontalPosition="@NotificationHorizontalPosition.Right"
                             VerticalPosition="@NotificationVerticalPosition.Top"
                             Class="bi-notification">
        </TelerikNotification>
        <TelerikLoaderContainer Visible="@ProgressIndicator.Visible" Text="Working on it .." Size="@LoaderSize.Large"/>

        <CascadingValue IsFixed="true" Value="@Notification">
            <CascadingValue Value="@ProgressIndicator">
                @Body
            </CascadingValue>
        </CascadingValue>

    </div>
</TelerikRootComponent>

@code
{
    Notification Notification { get; } = new();
    ShowProgressIndicator ProgressIndicator { get; } = new();
}

public class ShowProgressIndicator
    {
        public TelerikLoaderContainer LoaderContainer { get; set; }

        public bool Visible { get; set; }
        public string Text { get; set; } = "Working on it ..";
        
        // public void Show()
        // {
        //     Text = "Working on it ..";
        //     Visible = true;
        // }
        //     
        // public void Hide()
        // {
        //     Visible = false;
        // }
    }