mapo-core/MP.Data/Services/MessageService.cs

using Blazored.LocalStorage;
using Blazored.SessionStorage;
using EgwCoreLib.Utils;
using Microsoft.Extensions.Configuration;
using MP.Data.DatabaseModels;
using MP.Data.DTO;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace MP.Data.Services
{
    public class MessageService
    {
        #region Public Fields

        public const string KeyCommDtRif = "DtRifComm";
        public const string KeyCommText = "ValComm";
        public int orarioDip = 0;

        #endregion Public Fields

        #region Public Constructors

        public MessageService(IConfiguration configuration, ILocalStorageService genLocalStorage, ISessionStorageService sessStore)
        {
            _configuration = configuration;

            // gestione sessioni in browser
            localStorage = genLocalStorage;
            sessionStore = sessStore;

            // setup compoenti REDIS
            redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            redisDb = redisConn.GetDatabase();
        }

        #endregion Public Constructors

        #region Public Events

        public event Action EA_OperUpdated = null!;

        public event Action EA_PageUpdated = null!;

        #endregion Public Events

        #region Public Properties

        public string CognomeNome
        {
            get
            {
                string answ = "";
                //int answ = -1;
                if (_rigaOper != null)
                {
                    answ = $"{_rigaOper.Cognome} {_rigaOper.Nome}";
                }
                return answ;
            }
        }

        /// <summary>
        /// Dizionario macchine
        /// </summary>
        public Dictionary<string, string> DictMacchine
        {
            get
            {
                Dictionary<string, string> answ = new Dictionary<string, string>();
                var pUpd = Task.Run(async () =>
                {
                    answ = await localStorage.GetItemAsync<Dictionary<string, string>>(KeyMacDict);
                });
                pUpd.Wait();
                return answ;
            }
            set
            {
                var pUpd = Task.Run(async () =>
                {
                    await localStorage.SetItemAsync(KeyMacDict, value);
                });
                pUpd.Wait();
            }
        }

        public int MatrOpr
        {
            get
            {
                int answ = -1;
                if (_rigaOper != null)
                {
                    answ = _rigaOper.MatrOpr;
                }
                return answ;
            }
        }

        public AnagOperatoriModel? RigaOper
        {
            get => _rigaOper;
            set
            {
                // salvo
                _rigaOper = value;
                if (EA_OperUpdated != null)
                {
                    EA_OperUpdated?.Invoke();
                }
            }
        }

        public string UserAuthKey
        {
            get
            {
                string answ = "";
                if (_rigaOper != null)
                {
                    answ = _rigaOper.authKey;
                }
                return answ;
            }
        }

        /// <summary>
        /// Dizionario totale preferenze utente
        /// </summary>
        public Dictionary<string, string> UsersPrefDict
        {
            get => redisHashDictGet((RedisKey)$"{redisBaseKey}:{MatrOpr}");
            set => redisHashDictSet((RedisKey)$"{redisBaseKey}:{MatrOpr}", value);
        }

        #endregion Public Properties

        #region Public Methods

        public async Task ClearLocalStor()
        {
            await localStorage.ClearAsync();
        }

        public async Task ClearSessionStor()
        {
            await sessionStore.ClearAsync();
        }

        /// <summary>
        /// DateTime riferimento evento x commento fermata
        /// </summary>
        /// <param name="remAfter"></param>
        /// <returns></returns>
        public async Task<DateTime> CommentoDtRifGet(bool remAfter)
        {
            DateTime answ = DateTime.Now;
            bool hasKey = await sessionStore.ContainKeyAsync(KeyCommDtRif);
            if (hasKey)
            {
                answ = await sessionStore.GetItemAsync<DateTime>(KeyCommDtRif);
                // svuoto data registrata se richiesto
                if (remAfter)
                {
                    await sessionStore.RemoveItemAsync(KeyCommDtRif);
                }
            }
            return answ;
        }

        /// <summary>
        /// Macchine attualmente selezionata
        /// </summary>
        public async Task CommentoDtRifSet(DateTime DtRif)
        {
            await sessionStore.SetItemAsync(KeyCommDtRif, DtRif);
        }

        /// <summary>
        /// Commento fermata x recupero in editing
        /// </summary>
        /// <param name="remAfter"></param>
        /// <returns></returns>
        public async Task<string> CommentoValGet(bool remAfter)
        {
            string answ = "";
            bool hasKey = await sessionStore.ContainKeyAsync(KeyCommText);
            if (hasKey)
            {
                // recupero
                answ = await sessionStore.GetItemAsync<string>(KeyCommText);
                // svuoto data registrata se richiesto
                if (remAfter)
                {
                    await sessionStore.RemoveItemAsync(KeyCommText);
                }
            }
            return answ;
        }

        /// <summary>
        /// Macchine attualmente selezionata
        /// </summary>
        public async Task CommentoValSet(string Valore)
        {
            await sessionStore.SetItemAsync(KeyCommText, Valore);
        }

        /// <summary>
        /// Restituisce il valore Ipv4 del Device da localstorage
        /// </summary>
        /// <returns></returns>
        public async Task<string> getDevIpAsync()
        {
            string answ = "";
            var result = await localStorage.GetItemAsync<string>(KeyDevIp4);
            if (result != null)
            {
                answ = result;
            }
            return answ;
        }

        /// <summary>
        /// Restituisce il valore di DeviceSecret da localstorage
        /// </summary>
        /// <returns></returns>
        public async Task<string> getDevSecretAsync()
        {
            string answ = "";
            var result = await localStorage.GetItemAsync<string>(KeyDevSec);
            if (result != null)
            {
                answ = result;
            }
            return answ;
        }

        /// <summary>
        /// Recupero dati MSE x macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<MappaStatoExpl?> GetMachineMse(string idxMacchina)
        {
            MappaStatoExpl answ = null;
            string rawData = await localStorage.GetItemAsync<string>(machineMse(idxMacchina));
            if (rawData != "")
            {
                answ = JsonConvert.DeserializeObject<MappaStatoExpl>(rawData);
            }
            return answ;
        }

        /// <summary>
        /// Macchine attualmente selezionata
        /// </summary>
        public async Task<string> IdxMaccGet()
        {
            return await sessionStore.GetItemAsync<string>("CurrMach");
        }

        /// <summary>
        /// Imposta Macchina
        /// </summary>
        public async Task IdxMaccSet(string machSel)
        {
            await sessionStore.SetItemAsync("CurrMach", machSel);
        }

        /// <summary>
        /// Effettua salvataggio in localstorage dei dati MSE correnti
        /// </summary>
        /// <param name="currListMSE"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task SaveMse(List<MappaStatoExpl> currListMSE)
        {
            foreach (var item in currListMSE)
            {
                string serVal = JsonConvert.SerializeObject(item);
                await localStorage.SetItemAsync(machineMse(item.IdxMacchina), serVal);
            }
        }

        /// <summary>
        /// Verifico esistenza chiave in session store
        /// </summary>
        /// <param name="keyName"></param>
        /// <returns></returns>
        public async Task<bool> SessHasVal(string keyName)
        {
            bool hasKey = await sessionStore.ContainKeyAsync(keyName);
            return hasKey;
        }

        /// <summary>
        /// Scrive il valore di IPV4 del device nel localstoragee
        /// </summary>
        /// <param name="newVal"></param>
        /// <returns></returns>
        public async Task<bool> setDevIpv4Async(string newVal)
        {
            bool answ = false;
            try
            {
                await localStorage.SetItemAsync(KeyDevIp4, newVal);
                answ = true;
            }
            catch (Exception ex)
            {
                Log.Error($"Eccezione in setDevIpv4Async{Environment.NewLine}{ex}");
            }
            return answ;
        }

        /// <summary>
        /// Scrive il valore di DeviceSecret nel localstoragee
        /// </summary>
        /// <param name="newVal"></param>
        /// <returns></returns>
        public async Task<bool> setDevSecretAsync(string newVal)
        {
            bool answ = false;
            try
            {
                await localStorage.SetItemAsync(KeyDevSec, newVal);
                answ = true;
            }
            catch (Exception ex)
            {
                Log.Error($"Eccezione in setDevSecretAsync{Environment.NewLine}{ex}");
            }
            return answ;
        }


        /// <summary>
        /// Recupero singola preferenza utente
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public string UserPrefGet(string chiave)
        {
            string answ = "";
            var currDict = UsersPrefDict;
            if (currDict.ContainsKey(chiave))
            {
                answ = currDict[chiave];
            }
            return answ;
        }

        /// <summary>
        /// Salvo singola rpeferenza utente
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <returns></returns>
        public bool UserPrefSave(string chiave, string valore)
        {
            bool done = false;
            var currDict = UsersPrefDict;
            if (currDict.ContainsKey(chiave))
            {
                currDict[chiave] = valore;
            }
            else
            {
                currDict.Add(chiave, valore);
            }
            UsersPrefDict = currDict;
            return done;
        }

        #endregion Public Methods

        #region Protected Fields

        protected const string KeyDevIp4 = "DevIpv4";
        protected const string KeyDevSec = "DevSec";
        protected const string KeyMacDict = "MachineDict";
        protected static IConfiguration _configuration = null!;

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        protected ConnectionMultiplexer redisConn = null!;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        protected IDatabase redisDb = null!;

        #endregion Protected Fields

        #region Protected Properties

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

        protected ISessionStorageService sessionStore { get; set; } = null!;

        #endregion Protected Properties

        #region Private Fields

        public string DecryptData(string encData)
        {
            return SteamCrypto.DecryptString(encData, Constants.passPhrase);
        }

        private AnagOperatoriModel? _rigaOper;
        //{
        //    get
        //    {
        //        AnagOperatoriModel answ = new AnagOperatoriModel();
        //        string rawData = "";
        //        var pUpd = Task.Run(async () =>
        //        {
        //            rawData = await getCurrOperDtoAsync();
        //        });
        //        pUpd.Wait();
        //        var decodedUrl = Uri.UnescapeDataString(rawData);
        //        var decrData = DecryptData(decodedUrl);
        //        answ = JsonConvert.DeserializeObject<AnagOperatoriModel>(decodedUrl);
        //        return answ;
        //    }
        //    set
        //    {
        //        var serVal = JsonConvert.SerializeObject(value);
        //        var encData = EncryptData(serVal);
        //        var escdata = Uri.EscapeDataString(encData);
        //        var pUpd = Task.Run(async () =>
        //        {
        //            await setCurrOperDtoAsync(escdata);
        //        });
        //        pUpd.Wait();
        //    }
        //}
        public string EncryptData(string rawData)
        {
            return SteamCrypto.EncryptString(rawData, Constants.passPhrase);
        }



        /// <summary>
        /// Durata cache lunga IN SECONDI
        /// </summary>
        private int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata cache breve IN SECONDI
        /// </summary>
        private int cacheTtlShort = 60 * 1;

        private Logger Log = LogManager.GetCurrentClassLogger();
        private string redisBaseKey = "MP:TAB:User";
        private Random rnd = new Random();

        #endregion Private Fields

        #region Private Methods

        private string machineMse(string idxMacc)
        {
            return $"MSE_{idxMacc}";
        }

        /// <summary>
        /// Recupero HashSet redis come Dictionary
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        private Dictionary<string, string> redisHashDictGet(RedisKey currKey)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            try
            {
                answ = redisDb
                            .HashGetAll(currKey)
                            .ToDictionary(x => $"{x.Name}", x => $"{x.Value}");
            }
            catch (Exception exc)
            {
                Log.Info($"Errore redisHashDictGet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio Dictionary come HashSet Redis
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        private bool redisHashDictSet(RedisKey currKey, Dictionary<string, string> dict)
        {
            bool fatto = false;
            try
            {
                HashEntry[] data2ins = new HashEntry[dict.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in dict)
                {
                    data2ins[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                // salvo!
                redisDb.HashSet(currKey, data2ins);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redisHashDictSet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }


        /// <summary>
        /// Restituisce il record OperatoreDTO da localstorage
        /// </summary>
        /// <returns></returns>
        public async Task<string> getCurrOperDtoAsync()
        {
            string answ = "";
            var result = await localStorage.GetItemAsync<string>("currTkn");
            if (result != null)
            {
                //var data = JsonConvert.DeserializeObject<userTknDTO>(result);
                answ = result;
            }
            return answ;
        }

        /// <summary>
        /// scrive il record OperatoreDTO nel localstorage
        /// </summary>
        /// <returns></returns>
        public async Task<bool> setCurrOperDtoAsync(string currTkn)
        {
            bool answ = false;
            await localStorage.SetItemAsync("currTkn", currTkn);
            answ = true;
            return answ;
        }

        #endregion Private Methods

#if false
        public event Action EA_DateChanged = null!;
        public event Action EA_CalModeChanged = null!;

        public event Action EA_TimbUpd = null!;
#endif

#if false
        public RegAttivitaModel? clonedRA { get; set; } = null;

        /// <summary>
        /// Calcola HASH del codice impiego = payload utente
        /// </summary>
        /// <returns></returns>
        public string HashDip
        {
            get
            {
                DataValidator cDV = new DataValidator(_rigaOper);
                string hash = cDV.HashDip;
                return hash;
            }
        }
#endif
#if false
        public bool IsActive
        {
            get
            {
                bool answ = false;
                if (_rigaOper != null && _rigaOper.Attivo != null)
                {
                    answ = (bool)_rigaOper.Attivo;
                }
                return answ;
            }
        }

        public bool isRicTimb { get; set; } = false;

        public CalendarModeEnum.modoControllo modoCal { get; set; } = CalendarModeEnum.modoControllo.showCalendar;
#endif

#if false
        /// <summary>
        /// Indica ultima azione compiuta
        /// </summary>
        public string LastAction
        {
            get => lastAction;
            set
            {
                if (lastAction != value)
                {
                    lastAction = value;
                }
            }
        }

        /// <summary>
        /// Indica se il prossimo stato timbratura sia entrata
        /// </summary>
        public bool NextIsEntrata
        {
            get => nextIsEntrata;
            set
            {
                if (nextIsEntrata != value)
                {
                    nextIsEntrata = value;
                }
            }
        }

        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 bool PayloadOk { get; set; } = false;
        public RegAttivitaModel? recordRA { get; set; } = null;
#endif
#if false
        public string SearchVal
        {
            get => _searchVal;
            set
            {
                if (_searchVal != value)
                {
                    _searchVal = value;

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

        public int selWeekNum { get; set; } = 0;
        public int selYear { get; set; } = DateTime.Today.Year;

        public bool ShowSearch
        {
            get => showSearch;
            set
            {
                if (showSearch != value)
                {
                    showSearch = value;
                }
            }
        }

        public DateTime targetDate { get; set; } = DateTime.Today;
        public DateTime targetDateMancTimb { get; set; }
#endif
#if false

        public void ReportDateChange()
        {
            if (EA_DateChanged != null)
            {
                EA_DateChanged?.Invoke();
            }
        }

        public void setModeCalendar()
        {
            modoCal = CalendarModeEnum.modoControllo.showCalendar;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }
        public void setModeGauge()
        {
            modoCal = CalendarModeEnum.modoControllo.showGauge;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }
        public void setModeProj()
        {
            modoCal = CalendarModeEnum.modoControllo.showProj;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }
        public void setModeTempRil()
        {
            modoCal = CalendarModeEnum.modoControllo.showTempRil;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }
        public void setModeRichTimb()
        {
            modoCal = CalendarModeEnum.modoControllo.showTimbr;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }
        public void setModeShowWeek()
        {
            modoCal = CalendarModeEnum.modoControllo.showWeek;
            if (EA_CalModeChanged != null)
            {
                EA_CalModeChanged?.Invoke();
            }
        }

        public void ReportTimbratura()
        {
            if (EA_TimbUpd != null)
            {
                EA_TimbUpd?.Invoke();
            }
        }
#endif
#if false
        private string _pageIcon = "";
        private string _pageName = "";
#endif
#if false
        private string _searchVal = "";
        private bool showSearch;
#endif

#if false
        private string lastAction { get; set; } = "";
        private bool nextIsEntrata { get; set; } = true;
#endif

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

        private void ReportSearch()
        {
            if (EA_DipUpdated != null)
            {
                EA_DipUpdated?.Invoke();
            }
        }
#endif
    }
}