mapo-mono/MP.MONO.UI/Pages/AlarmsAnalysis.razor.cs

using MP.MONO.Data.DTO;
using MP.MONO.UI.Data;

namespace MP.MONO.UI.Pages
{
    public partial class AlarmsAnalysis
    {
        #region Public Properties

        public bool setFreqDur
        {
            get => currFilter.setFreqDur;
            set
            {
                if (currFilter.setFreqDur != value)
                {
                    currFilter.setFreqDur = value;
                    var pUpd = Task.Run(async () => await ReloadData());
                    pUpd.Wait();
                }
            }
        }

        #endregion Public Properties

        #region Protected Fields

        protected string percEvents = "";
        protected double totalVar = 0;

        #endregion Protected Fields

        #region Protected Properties

        protected DateTime dtEnd
        {
            get => currFilter.dtMax;
        }

        protected DateTime dtStart
        {
            get => currFilter.dtMin;
        }

        protected int totalCount { get; set; } = 0;

        #endregion Protected Properties

        #region Protected Methods

        protected void ForceReload(int newNum)
        {
            numRecord = newNum;
        }

        protected void ForceReloadPage(int newNum)
        {
            currPage = newNum;
        }

        protected override async Task OnInitializedAsync()
        {
            numRecord = 10;
            await Task.Delay(1);
        }

        protected override async Task OnParametersSetAsync()
        {
            isLoading = true;
            await ReloadData();
            await Task.Delay(1);
        }

        protected void ResetData()
        {
            currRecord = null;
        }

        protected void Select(AlarmFreqDTO selRecord)
        {
            // applico filtro da selezione
            currRecord = selRecord;
        }

        protected async Task toggleRec()
        {
            setFreqDur = !setFreqDur;
            await Task.Delay(1);
            await ReloadData();
        }

        protected async Task UpdateData()
        {
            currRecord = null;
            await ReloadData();
        }

        protected void updateTotal(int newTotCount)
        {
            totalCount = newTotCount;
        }

        #endregion Protected Methods

        #region Private Fields

        private AlarmFreqDTO? currRecord = null;

        #endregion Private Fields

        #region Private Properties

        private int _numRecord { get; set; } = 10;
        private selectChartParams currFilter { get; set; } = new selectChartParams();

        private int currPage
        {
            get => currFilter.CurrPage;
            set
            {
                if (currFilter.CurrPage != value)
                {
                    currFilter.CurrPage = value;
                }
            }
        }

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

        private int numRecord
        {
            get => currFilter.NumRecord;
            set
            {
                if (currFilter.NumRecord != value)
                {
                    currFilter.NumRecord = value;
                }
            }
        }

        #endregion Private Properties

        #region Private Methods

        private async Task ReloadData()
        {
            isLoading = true;

            await Task.Delay(1);
            isLoading = false;
        }

        private async Task updateFilter(selectChartParams newParams)
        {
            isLoading = true;
            await Task.Delay(1);
            currPage = 1;
            if (newParams.CurrPage == 0)
            {
                newParams.CurrPage = 1;
            }
            await Task.Delay(1);

            newParams.dtMax = dtEnd;
            newParams.dtMin = dtStart;
            await InvokeAsync(() => StateHasChanged());
            currFilter = newParams;
            isLoading = false;
        }

        #endregion Private Methods
    }
}