mapo-core/MP.Stats/Pages/TrendAnalysis.razor.cs

using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using MP.Data.DbModels;
using MP.Data.Services;
using MP.Stats.Data;
using NLog.Config;
using Org.BouncyCastle.Utilities;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace MP.Stats.Pages
{
    public partial class TrendAnalysis
    {
        #region Public Methods

        public void Dispose()
        {
            MServ.EA_SearchUpdated -= OnSeachUpdated;
            PlotRecords.Clear();
            SearchRecords.Clear();
        }

        public async void OnSeachUpdated()
        {
            await InvokeAsync(() =>
            {
                Task task = UpdateData();
                StateHasChanged();
            });
        }

        #endregion Public Methods

        #region Protected Fields

        protected string CodFluxSel = "*";
        protected string fileName = "TrendAnalysis.csv";

        protected int SelCount = 0;
        protected int TotalCount = 0;

        #endregion Protected Fields

        #region Protected Enums

        protected enum ResolutionLevel
        {
            Low,
            Med,
            High,
            Custom
        }

        #endregion Protected Enums

        #region Protected Properties

        protected List<string> CodFluxList { get; set; } = new List<string>() { "Energy", "Parameter" };

        [Inject]
        protected IJSRuntime JSRuntime { get; set; }

        /// <summary>
        /// Verifica validità selezione macchine
        /// </summary>
        protected bool MaccSelValid
        {
            get => currFilter.MaccSelValid;
        }

        /// <summary>
        /// Numero max di punti da mostrare
        /// </summary>
        protected int MaxPoints
        {
            get => _maxPoints;
            set
            {
                if ((_maxPoints != value))
                {
                    _maxPoints = value;
                    FiltData();
                }
            }
        }

        [Inject]
        protected Data.MessageService MServ { get; set; }

        [Inject]
        protected NavigationManager NavManager { get; set; }

        protected ResolutionLevel ReqRes
        {
            get => _reqRes;
            set
            {
                if (_reqRes != value)
                {
                    _reqRes = value;
                    if (value < ResolutionLevel.Custom)
                    {
                        int numSel = currFilter.ListIdxMaccSel.Count;
                        // verifico selcount valido... che sia almeno MaxDisp/
                        if (SelCount == 0)
                        {
                            SelCount = TotalCount * numSel / NumMacc;
                        }
                        int scale = 256;
                        switch (value)
                        {
                            case ResolutionLevel.Low:
                                MaxPoints = (int)Math.Round(SelCount / numSel / 32 / (double)scale) * scale;
                                break;

                            case ResolutionLevel.Med:
                                MaxPoints = (int)Math.Round(SelCount / numSel / 8 / (double)scale) * scale;
                                break;

                            case ResolutionLevel.High:
                                MaxPoints = (int)Math.Round(SelCount / numSel / (double)scale) * scale;
                                break;

                            default:
                                break;
                        }
                    }
                }
                // limite minimo 256...
                MaxPoints = MaxPoints < 256 ? 256 : MaxPoints;
            }
        }

        [Inject]
        protected MpStatsService StatService { get; set; }

        [Inject]
        protected TranslateSrv TradService { get; set; }

        #endregion Protected Properties

        #region Protected Methods

        protected async Task DoFilter(SelectData newFilter)
        {
            SearchRecords = null;
            currFilter = newFilter;
            await ReloadData();
        }

        protected override async Task OnInitializedAsync()
        {
            isLoading = true;
            MServ.ShowSearch = false;
            MServ.PageName = "Trend Analisys";
            MServ.PageIcon = "fa-solid fa-arrow-trend-up";
            CalcFilt();
            MServ.EA_SearchUpdated += OnSeachUpdated;
            await LoadConfData();
            await ReloadData();
            isLoading = false;
        }

        protected async Task ResetFilter(SelectData newFilter)
        {
            SearchRecords = null;
            CalcFilt();
            await ReloadData();
        }

        /// <summary>
        /// Salvataggio codflux
        /// </summary>
        /// <param name="newCodFlux"></param>
        /// <returns></returns>
        protected async Task SetCodFlux(string newCodFlux)
        {
            CodFluxSel = newCodFlux;
            await ReloadData();
        }

        /// <summary>
        /// Traduzione lemma richeisto (lingua default="IT")
        /// </summary>
        /// <param name="Lemma"></param>
        /// <returns></returns>
        protected string Traduci(string Lemma)
        {
            return TradService.Traduci(Lemma);
        }

        protected async Task UpdateData()
        {
            await ReloadData();
        }

        #endregion Protected Methods

        #region Private Fields

        private int _maxPoints = 256;
        private ResolutionLevel _reqRes = ResolutionLevel.Low;
        private List<ConfigModel> ConfigList;

        private int MaxDisplay = 10;
        private int NumMacc = 0;
        private List<FLModel> PlotRecords;

        /// <summary>
        /// Dizionario liste valori da mostrare
        /// </summary>
        private Dictionary<string, List<FLModel>> SearchRecords = new Dictionary<string, List<FLModel>>();

        #endregion Private Fields

        #region Private Properties

        private SelectData currFilter
        {
            get
            {
                return MServ.ODL_Filter;
            }
            set
            {
                MServ.ODL_Filter = value;
            }
        }

        private bool isLoading { get; set; } = false;

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Calcola il filtro alla data necessaria x arrivare al confronto x mese...
        /// </summary>
        private void CalcFilt()
        {
            DateTime oggi = DateTime.Now.Date;
            DateTime inizio = new DateTime(oggi.Year, oggi.Month, 1).AddMonths(-1);
            int numPrev = (int)oggi.Subtract(inizio).TotalDays;
            currFilter = SelectData.Init(5, numPrev);
        }

        /// <summary>
        /// Effettua filtro/downsample dei dati
        /// </summary>
        private void FiltData()
        {
            // in primis suddivido in un dizionario x ogni macchina...
            PlotRecords = new List<FLModel>();
            // per ogni valore recupero timeserie downsampled fino al num max di quelle ottenibili...
            int numAdd = 0;
            SelCount = 0;
            var listSel = currFilter.ListIdxMaccSel;
            foreach (var item in SearchRecords)
            {
                // verifico se sia tra le macchine selezionate...
                if (listSel.Contains(item.Key))
                {
                    numAdd++;
                    SelCount += item.Value.Count;
                    // ora effettuo deduplica valori per tenere un subset minore ed evitare problemi visualizzazione...
                    PlotRecords.AddRange(TimeSeriesUtils.DownsampleFluxModels(item.Value, MaxPoints));
                    // verifico comunque superamento limite amcchine
                    if (numAdd >= MaxDisplay)
                    {
                        return;
                    }
                }
            }
        }

        private async Task LoadConfData()
        {
            ConfigList = await StatService.ConfigGetAll();
            if (ConfigList.Count > 0)
            {
                var recConf = ConfigList.Where(x => x.Chiave == "STATS_TrendMaxSelect").FirstOrDefault();
                if (recConf != null)
                {
                    int.TryParse(recConf.Valore, out MaxDisplay);
                }
            }
            CodFluxList = await StatService.FluxTypeList();
        }

        private async Task ReloadData()
        {
            isLoading = true;
            var listMacchine = await StatService.MachineList(true);
            NumMacc = listMacchine.Count;
            // ciclo caricando info x ogni macchina selezionata...
            SearchRecords = new Dictionary<string, List<FLModel>>();
            if (currFilter.ListIdxMaccSel.Count > 0)
            {
                foreach (var idxMacc in currFilter.ListIdxMaccSel)
                {
                    currFilter.IdxMacchina = idxMacc;
                    var tempRec = await StatService.FluxLogRawData(currFilter, CodFluxSel, MServ.SearchVal);
                    SearchRecords.Add(idxMacc, tempRec);
                }
            }

#if false
            SearchRecords = await StatService.FluxLogRawData(currFilter, CodFluxSel, MServ.SearchVal);
#endif
            TotalCount = SearchRecords.Count;
            // se ho un elenco di macchine mostro grafici, altrimenti resoconto

            FiltData();
            isLoading = false;
        }

        /// <summary>
        /// Elimina da dict macchina indicata
        /// </summary>
        /// <param name="idxMacc"></param>
        private async Task RemoveMachine(string idxMacc)
        {
            // in primis se contiene spazio --> prendo prima aprte che è idxMacc...
            if (idxMacc.Contains(" "))
            {
                var sVals = idxMacc.Split(' ');
                idxMacc = sVals[0];
            }
            if (SearchRecords.ContainsKey(idxMacc))
            {
                currFilter.ListIdxMaccSel.Remove(idxMacc);
                SearchRecords.Remove(idxMacc);
                await ReloadData();
            }
        }

        #endregion Private Methods
    }
}