mapo-core/MP.SPEC/Pages/Articoli.razor.cs

using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using MP.Data.DatabaseModels;
using MP.SPEC.Data;

namespace MP.SPEC.Pages
{
    public partial class Articoli : ComponentBase, IDisposable
    {
        #region Public Methods

        public string checkSelect(string CodArticolo)
        {
            string answ = "";
            if (currRecord != null)
            {
                try
                {
                    answ = (currRecord.CodArticolo == CodArticolo) ? "table-info" : "";
                }
                catch
                { }
            }
            return answ;
        }

        private SelectArticoliParams currFilter = new SelectArticoliParams();

        public void Dispose()
        {
            currRecord = null;
            ListTipoArt = null;
            ListAziende = null;
            SearchRecords = null;
            ListRecords = null;
            GC.Collect();
        }

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

        #endregion Public Methods

        #region Protected Properties

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        [Inject]
        protected MpDataService MDService { get; set; } = null!;

        [Inject]
        protected NavigationManager NavManager { get; set; } = null!;

        protected int totalCount
        {
            get
            {
                int answ = 0;
                if (SearchRecords != null)
                {
                    answ = SearchRecords.Count;
                }
                return answ;
            }
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Crea nuovo record e va in editing...
        /// </summary>
        /// <returns></returns>
        protected async Task addNew()
        {
            currRecord = new AnagArticoli()
            {
                CodArticolo = $"_NEW_{DateTime.Now:yyyyMMdd.HHmmss}",
                DescArticolo = "Nuovo articolo",
                Azienda = selAzienda != "*" ? selAzienda : "MAPO",
                Disegno = "",
                Tipo = "ART"
            };
            await Task.Delay(1);
        }

        protected async Task cancel()
        {
            currRecord = null;
            await reloadData();
            await Task.Delay(1);
        }

        /// <summary>
        /// Eliminazione record selezionato (previa conferma)
        /// </summary>
        /// <param name="selRec"></param>
        /// <returns></returns>
        protected async Task deleteRecord(AnagArticoli selRec)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Eliminazione Articolo: sei sicuro di voler procedere?"))
                return;
            await Task.Delay(1);
            var done = await MDService.ArticoliDeleteRecord(selRec);
            currRecord = null;
            await reloadData();
            await Task.Delay(1);
        }

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

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

        protected override async Task OnInitializedAsync()
        {
            numRecord = 10;
#if false
            configData = await MDService.ConfigGetAll();
            var currRec = configData.FirstOrDefault(x => x.Chiave == "AZIENDA");
            if (currRec != null)
            {
                selAzienda = currRec.Valore;
            } 
#endif
            selAzienda = await MDService.tryGetConfig("AZIENDA");
            ListAziende = await MDService.ElencoAziende();
            ListTipoArt = await MDService.AnagTipoArtLV();
        }

        protected override async Task OnParametersSetAsync()
        {
            await reloadData();
        }

        protected void ResetData()
        {
            currRecord = null;
        }

        protected async Task resetSel()
        {
            currRecord = null;
            await Task.Delay(1);
        }

        protected async Task selRecord(AnagArticoli selRec)
        {
            currRecord = selRec;
            await Task.Delay(1);
        }
        protected async Task cloneRecord(AnagArticoli selRec)
        {
            // creo record duplicato...
            AnagArticoli newRec = new AnagArticoli()
            {
                Azienda = selRec.Azienda,
                CodArticolo = selRec.CodArticolo,
                DescArticolo = $"CLONE - {selRec.DescArticolo}",
                Disegno = selRec.Disegno,
                Tipo = selRec.Tipo
            };
            currRecord = newRec;
            await Task.Delay(1);
        }


        protected async Task update(AnagArticoli selRec)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Confermi di voler salvare le modifiche?"))
                return;
            await Task.Delay(1);
            var done = await MDService.ArticoliUpdateRecord(selRec);
            currRecord = null;
            await reloadData();
            await Task.Delay(1);
        }

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

        #endregion Protected Methods

        #region Private Fields

        private string _selAzienda = "*";
        private AnagArticoli? currRecord = null;
        private List<AnagGruppi>? ListAziende;
        private List<AnagArticoli>? ListRecords;
        private List<ListValues>? ListTipoArt;
        private List<AnagArticoli>? SearchRecords;

        #endregion Private Fields

        #region Private Properties

        private int _currPage { get; set; } = 1;
        private int _numRecord { get; set; } = 10;

#if false
        private List<ConfigModel>? configData { get; set; } = null; 
#endif

        private int currPage
        {
            get => _currPage;
            set
            {
                if (_currPage != value)
                {
                    _currPage = value;
                    var pUpd = Task.Run(async () => await reloadData());
                    pUpd.Wait();
                }
            }
        }

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

        private int numRecord
        {
            get => _numRecord;
            set
            {
                if (_numRecord != value)
                {
                    _numRecord = value;
                    var pUpd = Task.Run(async () => await reloadData());
                    pUpd.Wait();
                }
            }
        }

        private string selAzienda
        {
            get => _selAzienda;
            set
            {
                if (value != _selAzienda)
                {
                    _selAzienda = value;
                    var pUpd = Task.Run(async () =>
                    {
                        // svuoto cache redis...
                        ConfigModel updRec = new ConfigModel()
                        {
                            Chiave = "AZIENDA",
                            Valore = value
                        };
                        await MDService.ConfigUpdate(updRec);
                        await MDService.ConfigResetCache();
                        // ricarico
                        await Task.Delay(1);
                        await reloadData();
                    });
                    pUpd.Wait();
                }
            }
        }

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

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Seleziona record x editing
        /// </summary>
        /// <param name="selRec"></param>
        /// <returns></returns>
        private bool ArticoloDelEnabled(string codArt)
        {
            bool answ = MDService.ArticoloDelEnabled(codArt);
            return answ;
        }

        private async Task reloadData()
        {
            isLoading = true;
            SearchRecords = await MDService.ArticoliGetSearch(100000, selAzienda, "");
            ListRecords = SearchRecords.Skip(numRecord * (currPage - 1)).Take(numRecord).ToList();
            isLoading = false;
        }

        #endregion Private Methods
    }
}