Mapo-IOB/SMGen/Pages/SMEvent2State.razor.cs

using EgwCoreLib.Razor;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;
using NLog;
using SMGen.Core;
using SMGen.Data;
using SMGen.Data.Data;
using SMGen.Data.DbModels;
using SMGen.Data.Services;

namespace SMGen.Pages
{
    public partial class SMEvent2State
    {
        #region Protected Fields

        protected static Logger Log = LogManager.GetCurrentClassLogger();
        protected SelectSMIn2EvParams currFilter = new SelectSMIn2EvParams();

        protected DataPager? pagerSMIn2Ev = null!;

        #endregion Protected Fields

        #region Protected Properties

        [Inject]
        protected IConfiguration conf { get; set; } = null!;

        [Inject]
        protected IWebHostEnvironment env { get; set; } = null!;

        protected string pathDir { get; set; } = "";

        protected string pathFile { get; set; } = "";
        protected Dictionary<string, FilesClass> Files { get; set; } = new Dictionary<string, FilesClass>();

        [Inject]
        protected SMGDataService SMGDService { get; set; } = null!;

        protected string statiCsvPath
        {
            get => conf.GetValue<string>("ServerConf:StatiCsvPath");
        }


        #endregion Protected Properties

        #region Protected Methods

        protected override async Task OnInitializedAsync()
        {
            await Task.Delay(1);
            await SMGDService.ExecFlushRedisPattern(Constants.FILES_TO_PROC);
        }

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

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

        protected async Task pgResetReq(bool doReset)
        {
            if (doReset)
            {
                await Task.Delay(1);
                if (pagerSMIn2Ev != null)
                {
                    pagerSMIn2Ev.resetCurrPage();
                }
            }
        }


        protected async Task updateFilter(SelectSMIn2EvParams newParams)
        {
            await Task.Delay(1);
            currPage = 1;
            // salvo comunque filtro reparto x utente
            await Task.Delay(1);
            await InvokeAsync(() => StateHasChanged());
            currFilter = newParams;
        }

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

        #endregion Protected Methods

        #region Private Properties

        private int currPage
        {
            get => currFilter.CurrPage;
            set => currFilter.CurrPage = value;
        }

        private int numRecord
        {
            get => currFilter.NumRec;
            set => currFilter.NumRec = value;
        }

        private int totalCount
        {
            get => currFilter.TotCount;
            set => currFilter.TotCount = value;
        }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Procedee a bonificare la cartella di upload dei files + vecchi di 3 mesi
        /// </summary>
        private void deleteOldFiles(string dirPath)
        {
            // elenco files nella directory
            string[] files = Directory.GetFiles(dirPath);
            // li guardo tutti e se vecchi li elimino...
            foreach (string file in files)
            {
                FileInfo fi = new FileInfo(file);
                if (fi.LastAccessTime < DateTime.Now.AddMinutes(-20))
                {
                    fi.Delete();
                }
            }
        }

        //// va dopo
        //private StreamWriter objWriter { get; set; };
        private async Task LoadFiles(InputFileChangeEventArgs e)
        {
            List<IBrowserFile> loadedFiles = new();
            long maxFileSize = 1024 * 50;
            int maxAllowedFiles = 150;
            loadedFiles.Clear();

            foreach (var file in e.GetMultipleFiles(maxAllowedFiles))
            {
                try
                {
                    loadedFiles.Add(file);

                    //assegno un nome file randomico x sicurezza
                    var trustedFileNameForFileStorage = Path.GetRandomFileName();

                    //path del file da scrivere
                    pathFile = Path.Combine(env.ContentRootPath,
                            env.EnvironmentName, "unsafe_uploads",
                            trustedFileNameForFileStorage);

                    //path cartella root (development)
                    pathDir = Path.Combine(env.ContentRootPath,
                            env.EnvironmentName, "unsafe_uploads");

                    //se la cartella non esiste, creo
                    if (!Directory.Exists(pathDir))
                    {
                        Directory.CreateDirectory(pathDir);
                        Log.Info($"Creato directory {pathDir}");
                    }

                    //creo file
                    using (FileStream fs = new(pathFile, FileMode.Create))
                    {
                        //copio il contenuto del file
                        await file.OpenReadStream(maxFileSize).CopyToAsync(fs);
                    }
                    if (file.Name.Contains(".rul"))
                    {

                        var newFIle = new FilesClass()
                        {
                            tempFileName = pathFile,
                            isOk = false
                        };

                        Files.Add(file.Name, newFIle);
                        //files2Read.Add(file.Name, pathFile);
                        //filesStatus.Add(file.Name, false);
                    }
                }
                catch (Exception ex)
                {
                    Log.Error($"Generato errore durante caricamento file: {Environment.NewLine}{ex}");
                }

                if(Files != null && Files.Count > 0)
                {
                    await SMGDService.FilesLoadRedis(Files);
                }
            }
            await InvokeAsync(() => StateHasChanged());
        }

        #endregion Private Methods
    }
}