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

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

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

        public string CheckSelect(string codArticolo)
        {
            return currRecord?.CodArticolo == codArticolo
                ? "table-info"
                : "";
        }

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

        #endregion Public Methods

        #region Protected Methods

        protected override async Task OnInitializedAsync()
        {
            numRecord = 10;
            await ReloadBaseData();
        }

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

        #endregion Protected Methods

        #region Private Fields

        private int _currPage = 1;
        private int _numRecord = 10;
        private string _selAzienda = "*";
        private int availRecord = 1000;
        private SelectArticoliParams currFilter = new SelectArticoliParams();
        private AnagArticoliModel? currRecord = null;
        private bool isLoading = false;
        private bool isNewArt = false;
        private List<AnagGruppiModel>? ListAziende;
        private List<AnagArticoliModel>? ListRecords;
        private List<ListValuesModel>? ListTipoArt;
        private int maxNumRecord = 1000;
        private List<AnagArticoliModel>? SearchRecords;
        private string selTipoArt = "*";
        private int totalCount = 0;

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Verifica cablata x add tutto tranne KIT
        /// </summary>
        private bool CanAdd => !selTipoArt.Equals("KIT");

        private int currPage
        {
            get => _currPage;
            set
            {
                if (_currPage != value)
                {
                    _currPage = value;
                    UpdateTable();
                }
            }
        }

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

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

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

        private int numRecord
        {
            get => _numRecord;
            set
            {
                if (_numRecord != value)
                {
                    _numRecord = value;
                    UpdateTable();
                }
            }
        }

        private string searchCss => string.IsNullOrEmpty(searchVal) ? "btn-secondary" : "btn-primary";

        private string searchVal { get; set; } = "";

        private string SearchVal
        {
            get => searchVal;
            set
            {
                // salvo solo se 3+ chars
                if (value.Length > 2 || string.IsNullOrEmpty(value))
                {
                    searchVal = value;
                }
            }
        }

        private string selAzienda
        {
            get => _selAzienda;
            set
            {
                if (value != _selAzienda)
                {
                    _selAzienda = value;
                }
            }
        }

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

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Crea nuovo record e va in editing...
        /// </summary>
        /// <returns></returns>
        private void AddNew()
        {
            isNewArt = true;
            currRecord = new AnagArticoliModel()
            {
                CodArticolo = $"_NEW_{DateTime.Now:yyyyMMdd.HHmmss}",
                DescArticolo = "Nuovo articolo",
                Azienda = !selAzienda.Equals("*") ? selAzienda : "MAPO",
                Disegno = "",
                Tipo = !selTipoArt.Equals("*") ? selTipoArt : "ART",
                CurrRev = "",
                ProdRev = ""
            };
        }

        /// <summary>
        /// Verifica cancellabilità record
        /// </summary>
        /// <param name="selRec"></param>
        /// <returns></returns>
        private bool ArticoloDelEnabled(AnagArticoliModel currRec)
        {
            if (currRec.Tipo.Equals("KIT"))
                return false;

            return MDService.ArticoloDelEnabled(currRec.CodArticolo);
        }

        /// <summary>
        /// Cloning record
        /// </summary>
        /// <param name="selRec"></param>
        private void cloneRecord(AnagArticoliModel selRec)
        {
            isNewArt = true;
            // creo record duplicato...
            AnagArticoliModel newRec = new AnagArticoliModel()
            {
                Azienda = selRec.Azienda,
                CodArticolo = $"clone-{selRec.CodArticolo}",
                DescArticolo = $"CLONE - {selRec.DescArticolo}",
                Disegno = selRec.Disegno,
                Tipo = selRec.Tipo,
                CurrRev = "",
                ProdRev = ""
            };
            currRecord = newRec;
        }

        /// <summary>
        /// Eliminazione record selezionato (previa conferma)
        /// </summary>
        /// <param name="selRec"></param>
        /// <returns></returns>
        private async Task deleteRecord(AnagArticoliModel 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 ReloadDataAsync();
            await Task.Delay(1);
        }

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

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

        private async Task ReloadAziendaAsync()
        {
            isLoading = true;
            // svuoto cache redis...
            ConfigModel updRec = new ConfigModel()
            {
                Chiave = "AZIENDA",
                Valore = selAzienda
            };
            await MDService.ConfigUpdateAsync(updRec);
            await MDService.ConfigResetCacheAsync();
            // ricarico
            await ResetDataAsync();
        }

        private async Task ReloadBaseData()
        {
            isLoading = true;
            await MDService.EnsureArtCacheLoadedAsync(true);
            selAzienda = await MDService.ConfigTryGetAsync("AZIENDA");
            if (string.IsNullOrEmpty(selAzienda))
            {
                selAzienda = "*";
            }
            ListAziende = await MDService.ElencoAziendeAsync();
            ListTipoArt = await MDService.AnagTipoArtLvAsync();
        }

        private async Task ReloadDataAsync()
        {
            isLoading = true;
            SearchRecords = await MDService.ArticoliGetSearchAsync(maxNumRecord, selTipoArt, selAzienda, SearchVal);
            availRecord = await MDService.ArticoliCountSearchAsync(selTipoArt, selAzienda, searchVal);
            totalCount = SearchRecords.Count;
            UpdateTable();
        }

        private void ResetData()
        {
            isNewArt = false;
            currRecord = null;
        }

        private async Task ResetDataAsync()
        {
            currPage = 1;
            currRecord = null;
            await MDService.FlushFusionCacheArticoli();
            await ReloadDataAsync();
        }

        private async Task ResetSearch()
        {
            SearchVal = "";
            await ResetDataAsync();
        }

        private async Task ResetSel()
        {
            isNewArt = false;
            currRecord = null;
            await ResetDataAsync();
        }

        private async Task selRecord(AnagArticoliModel selRec)
        {
            isNewArt = false;
            currRecord = selRec;
            await Task.Delay(1);
        }

        private async Task UpdateAsync(AnagArticoliModel selRec)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Confermi di voler salvare le modifiche?"))
                return;

            var done = await MDService.ArticoliUpsertRecord(selRec);
            await ResetDataAsync();
        }

        private void UpdateTable()
        {
            ListRecords = SearchRecords?
                            .Skip(numRecord * (currPage - 1))
                            .Take(numRecord)
                            .ToList() ?? new();
            isLoading = false;
        }

        #endregion Private Methods
    }
}