limanapp/LiMan.UI/Data/MessageService.cs

using Blazored.LocalStorage;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace LiMan.UI.Data
{
    public class MessageService
    {
        #region Public Constructors

        public MessageService(ILocalStorageService genLocalStorage)
        {
            // gestione sessioni in browser
            localStore = genLocalStorage;
        }

        #endregion Public Constructors

        #region Public Events

        public event Action EA_FilterUpdated;

        public event Action EA_HideSearch;

        public event Action EA_PageUpdated;

        public event Action EA_SearchUpdated;

        public event Action EA_ShowSearch;

        public event Action EA_UserNameUpd;

        #endregion Public Events

        #region Public Properties

        public SelectNext DetailDBFilter
        {
            get => _detailFilterNext;
            set
            {
                if (_detailFilterNext != value)
                {
                    _detailFilterNext = value;

                    if (EA_FilterUpdated != null)
                    {
                        EA_FilterUpdated?.Invoke();
                    }
                }
            }
        }

        public SelectData DetailFilter
        {
            get => _detailFilter;
            set
            {
                if (_detailFilter != value)
                {
                    _detailFilter = value;

                    if (EA_FilterUpdated != null)
                    {
                        EA_FilterUpdated?.Invoke();
                    }
                }
            }
        }

        public SelectGLS DetailGLSFilter
        {
            get => _detailFilterGLS;
            set
            {
                if (_detailFilterGLS != value)
                {
                    _detailFilterGLS = value;

                    if (EA_FilterUpdated != null)
                    {
                        EA_FilterUpdated?.Invoke();
                    }
                }
            }
        }

        public string PageIcon
        {
            get => _pageIcon;
            set
            {
                if (_pageIcon != value)
                {
                    _pageIcon = value;
                    ReportPageUpd();
                }
            }
        }

        public string PageName
        {
            get => _pageName;
            set
            {
                if (_pageName != value)
                {
                    _pageName = value;
                    //ReportPageUpd();
                }
            }
        }

        public int PageNum { get; set; } = 1;

        public int PageSize { get; set; } = 10;

        public string SearchVal
        {
            get => _searchVal;
            set
            {
                if (_searchVal != value)
                {
                    _searchVal = value;

                    if (EA_SearchUpdated != null)
                    {
                        EA_SearchUpdated?.Invoke();
                    }
                }
            }
        }

        public bool ShowSearch
        {
            get => showSearch;
            set
            {
                if (showSearch != value)
                {
                    showSearch = value;
                    if (showSearch)
                    {
                        if (EA_ShowSearch != null)
                        {
                            EA_ShowSearch?.Invoke();
                        }
                    }
                    else
                    {
                        if (EA_HideSearch != null)
                        {
                            EA_HideSearch?.Invoke();
                        }
                    }
                }
            }
        }

        public string UserName
        {
            get => _userName;
            set
            {
                if (_userName != value)
                {
                    _userName = value;
                    ReportUserUpd();
                }
            }
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Num record x la pagina corrente
        /// </summary>
        public async Task<int> NumRowGridGet(string gridName)
        {
            var answ = await localStore.GetItemAsync<int>($"{gridName}_nRow");
            answ = answ > 0 ? answ : 10;
            return answ;
        }

        /// <summary>
        /// Imposta num record x la pagina corrente
        /// </summary>
        public async Task NumRowGridSet(string gridName, int newVal)
        {
            await localStore.SetItemAsync($"{gridName}_nRow", newVal);
        }

        /// <summary>
        /// Preferenza utente salvata in local storage
        /// </summary>
        public async ValueTask<T?> UserPrefGet<T>(string userPref)
        {
            var sData = await localStore.GetItemAsync<string>(userPref);
            if (string.IsNullOrEmpty(sData))
            {
                return default(T);
            }
            else
            {
                return (T)Convert.ChangeType(sData, typeof(T));
            }
        }

        /// <summary>
        /// Imposta pref utente
        /// </summary>
        public async Task UserPrefSet(string userPref, string newVal)
        {
            await localStore.SetItemAsync(userPref, newVal);
        }

        /// <summary>
        /// Cerca un parametro utente salvato (se presente) e restituisce, se non trova restituisce ""
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string UsrParamGet(string key)
        {
            string answ = "";
            if (userCurrParams.ContainsKey(key))
            {
                answ = userCurrParams[key];
            }
            return answ;
        }

        /// <summary>
        /// Cerca un parametro utente salvato (se presente) e restituisce, se non trova restituisce 0
        /// </summary>
        /// <param name="key"></param>
        /// <param name="nullVal">Valore da restituire se NON trovato</param>
        /// <returns></returns>
        public int UsrParamGetUInt(string key, int nullVal)
        {
            int answ = nullVal;
            var sVal = UsrParamGet(key);
            if (!string.IsNullOrEmpty(sVal))
            {
                int.TryParse(sVal, out answ);
            }
            return answ;
        }

        /// <summary>
        /// Upsert di un parametro utente
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public string UsrParamSet(string key, string value)
        {
            string answ = "";
            if (userCurrParams.ContainsKey(key))
            {
                userCurrParams[key] = value;
            }
            else
            {
                userCurrParams.Add(key, value);
            }
            return answ;
        }

        #endregion Public Methods

        #region Protected Properties

        protected ILocalStorageService localStore { get; set; } = null!;

        #endregion Protected Properties

        #region Private Fields

        private SelectData _detailFilter = SelectData.Init(5, 15);

        private SelectGLS _detailFilterGLS = SelectGLS.Init(60, -30);

        private SelectNext _detailFilterNext = SelectNext.Init(60, -30);

        private string _pageIcon;

        private string _pageName;

        private string _searchVal;

        private string _userName;

        private bool showSearch;

        /// <summary>
        /// Dizionario parametri utente (in memoria x sessione utente)
        /// </summary>
        private Dictionary<string, string> userCurrParams = new Dictionary<string, string>();

        #endregion Private Fields

        #region Private Methods

        private void ReportPageUpd()
        {
            if (EA_PageUpdated != null)
            {
                EA_PageUpdated?.Invoke();
            }
        }

        private void ReportSearch()
        {
            if (EA_SearchUpdated != null)
            {
                EA_SearchUpdated?.Invoke();
            }
        }

        private void ReportUserUpd()
        {
            if (EA_UserNameUpd != null)
            {
                EA_UserNameUpd?.Invoke();
            }
        }

        #endregion Private Methods
    }
}